diff --git a/README.md b/README.md
index 583e9bbe..8e1e74ec 100644
--- a/README.md
+++ b/README.md
@@ -4,4 +4,5 @@ A minecraft mod about casting Hexes, powerful and programmable magical effects,
 
 [Curseforge Link](https://www.curseforge.com/minecraft/mc-mods/hexcasting)
 
-This mod requires Patchouli and Kotlin for Forge!
+This mod requires PAUCAL, Patchouli and Kotlin for Forge!
+
diff --git a/build.gradle b/build.gradle
index 49751133..78030d48 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,4 +1,5 @@
 buildscript {
+    ext.kotlin_version = '1.6.21'
     repositories {
         // These repositories are only for Gradle plugins, put any other repositories in the repository block further below
         maven { url = 'https://maven.minecraftforge.net' }
@@ -15,6 +16,7 @@ buildscript {
     }
 }
 
+
 import com.diluv.schoomp.Webhook
 import com.diluv.schoomp.message.Message
 
@@ -26,9 +28,10 @@ apply plugin: 'net.minecraftforge.gradle'
 apply plugin: 'org.parchmentmc.librarian.forgegradle'
 apply plugin: 'org.spongepowered.mixin'
 
-version = '0.8.0'
-group = 'at.petra-k.hexcasting' // http://maven.apache.org/guides/mini/guide-naming-conventions.html
-archivesBaseName = 'hexcasting-1.18.2'
+
+version = modVersion
+group = "at.petra-k.$modID" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+archivesBaseName = "$modID-$minecraftVersion"
 
 def isRelease = { ->
     try {
@@ -82,25 +85,12 @@ apply plugin: 'kotlinx-serialization'
 // If you already know how to add the Kotlin plugin to Gradle, this is the only line you need for KFF
 apply from: 'https://raw.githubusercontent.com/thedarkcolour/KotlinForForge/site/thedarkcolour/kotlinforforge/gradle/kff-3.0.0.gradle'
 
-println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
+println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
 minecraft {
-    // The mappings can be changed at any time and must be in the following format.
-    // Channel:   Version:
-    // snapshot   YYYYMMDD   Snapshot are built nightly.
-    // stable     #          Stables are built at the discretion of the MCP team.
-    // official   MCVersion  Official field/method names from Mojang mapping files
-    //
-    // You must be aware of the Mojang license when using the 'official' mappings.
-    // See more information here: https://github.com/MinecraftForge/MCPConfig/blob/master/Mojang.md
-    //
-    // Use non-default mappings at your own risk. They may not always work.
-    // Simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: 'parchment', version: '2022.03.13-1.18.2'
+    // After running this the first time, switch which is commented and rerun genIntellijRuns
+    mappings channel: 'official', version: '1.18.2'
+    // mappings channel: 'parchment', version: '2022.03.13-1.18.2'
 
-    // accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg') // Currently, this location cannot be changed from the default.
-
-    // Default run configurations.
-    // These can be tweaked, removed, or duplicated as needed.
     runs {
         client {
             workingDirectory project.file('run')
@@ -117,12 +107,11 @@ minecraft {
             // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
             property 'forge.logging.console.level', 'debug'
 
-            // unbreak patchi??
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
+            property 'forge.enabledGameTestNamespaces', modID
 
             mods {
-                hexcasting {
+                create(modID) {
                     source sourceSets.main
                 }
             }
@@ -131,29 +120,24 @@ minecraft {
         server {
             workingDirectory project.file('run')
 
-            // Recommended logging data for a userdev environment
-            // The markers can be added/remove as needed separated by commas.
-            // "SCAN": For mods scan.
-            // "REGISTRIES": For firing of registry events.
-            // "REGISTRYDUMP": For getting the contents of all registries.
             property 'forge.logging.markers', 'REGISTRIES'
 
-            // Recommended logging level for the console
-            // You can set various levels here.
-            // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
             property 'forge.logging.console.level', 'debug'
 
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
+            property 'forge.enabledGameTestNamespaces', modID
 
             mods {
-                hexcasting {
+                create(modID) {
                     source sourceSets.main
                 }
             }
         }
 
-        data {
+        // This run config launches GameTestServer and runs all registered gametests, then exits.
+        // By default, the server will crash when no gametests are provided.
+        // The gametest system is also enabled by default for other run configs under the /test command.
+        gameTestServer {
             workingDirectory project.file('run')
 
             // Recommended logging data for a userdev environment
@@ -168,14 +152,28 @@ minecraft {
             // Please read: https://stackoverflow.com/questions/2031163/when-to-use-the-different-log-levels
             property 'forge.logging.console.level', 'debug'
 
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
-
-            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
-            args '--mod', 'hexcasting', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
+            property 'forge.enabledGameTestNamespaces', modID
 
             mods {
-                hexcasting {
+                create(modID) {
+                    source sourceSets.main
+                }
+            }
+        }
+
+        data {
+            workingDirectory project.file('run')
+
+            property 'forge.logging.markers', 'REGISTRIES'
+
+            property 'forge.logging.console.level', 'debug'
+
+            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
+            args '--mod', modID, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+
+            mods {
+                create(modID) {
                     source sourceSets.main
                 }
             }
@@ -186,6 +184,13 @@ minecraft {
 // Include resources generated by data generators.
 sourceSets.main.resources { srcDir 'src/generated/resources' }
 
+mixin {
+    add sourceSets.main, "${modID}.mixins.refmap.json"
+    config "${modID}.mixins.json"
+    dumpTargetOnFailure true
+}
+
+
 repositories {
     mavenCentral()
     // Put repositories for dependencies here
@@ -211,46 +216,34 @@ repositories {
 
 dependencies {
     implementation 'org.testng:testng:7.1.0'
-
+    
     // Specify the version of Minecraft to use. If this is any group other than 'net.minecraft', it is assumed
     // that the dep is a ForgeGradle 'patcher' dependency, and its patches will be applied.
     // The userdev artifact is a special name and will get all sorts of transformations applied to it.
-    minecraft 'net.minecraftforge:forge:1.18.2-40.0.19'
+    minecraft "net.minecraftforge:forge:${minecraftVersion}-${forgeVersion}"
+
     annotationProcessor 'org.spongepowered:mixin:0.8.5:processor'
 
-    compileOnly fg.deobf("vazkii.patchouli:Patchouli:1.18.2-66:api")
-    runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:1.18.2-66")
+    compileOnly fg.deobf("at.petra-k.paucal:paucal-$minecraftVersion:$paucalVersion")
+    runtimeOnly fg.deobf("at.petra-k.paucal:paucal-$minecraftVersion:$paucalVersion")
+    compileOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion:api")
+    runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion")
 
-    // compile against the JEI API but do not include it at runtime
-    compileOnly fg.deobf("mezz.jei:jei-1.18.2:9.5.3.143:api")
-    // at runtime, use the full JEI jar
-    runtimeOnly fg.deobf("mezz.jei:jei-1.18.2:9.5.3.143")
 
-    compileOnly fg.deobf("at.petra-k.paucal:paucal-1.18.2:0.3.2")
-    runtimeOnly fg.deobf("at.petra-k.paucal:paucal-1.18.2:0.3.2")
-}
-
-mixin {
-    add sourceSets.main, 'hexcasting.mixins.refmap.json'
-    config 'hexcasting.mixins.json'
-    dumpTargetOnFailure true
-}
-
-java {
-    withJavadocJar()
-    withSourcesJar()
+    compileOnly fg.deobf("mezz.jei:jei-$minecraftVersion:$jeiVersion:api")
+    runtimeOnly fg.deobf("mezz.jei:jei-$minecraftVersion:$jeiVersion")
 }
 
 // Example for how to get properties into the manifest for reading at runtime.
 jar {
     manifest {
         attributes([
-                "Specification-Title"     : "hexcasting",
-                "Specification-Vendor"    : "petrak-at",
+                "Specification-Title"     : modID,
+                "Specification-Vendor"    : "petra-kat",
                 "Specification-Version"   : "1", // We are version 1 of ourselves
                 "Implementation-Title"    : project.name,
                 "Implementation-Version"  : project.jar.archiveVersion,
-                "Implementation-Vendor"   : "petrak-at",
+                "Implementation-Vendor"   : "petra-kat",
                 "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
         ])
     }
@@ -262,12 +255,10 @@ jar.finalizedBy('reobfJar')
 // However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
 // publish.dependsOn('reobfJar')
 
-
 // Disables Gradle's custom module metadata from being published to maven. The
 // metadata includes mapped dependencies which are not reasonably consumable by
 // other mod developers.
 tasks.withType(GenerateModuleMetadata) {
-
     enabled = false
 }
 
@@ -280,9 +271,7 @@ publishing {
             from components.java
 
             pom.withXml {
-
                 asNode().dependencies.dependency.each { dep ->
-
                     assert dep.parent().remove(dep)
                 }
             }
@@ -294,14 +283,6 @@ publishing {
         }
     }
 }
-compileKotlin {
-    kotlinOptions {
-    }
-}
-compileTestKotlin {
-    kotlinOptions {
-    }
-}
 
 def getGitChangelog = { ->
     try {
@@ -311,13 +292,13 @@ def getGitChangelog = { ->
         def travisRange = System.getenv('TRAVIS_COMMIT_RANGE')
         if (gitHash && gitPrevHash) {
             exec {
-                commandLine 'git', 'log', '--pretty=tformat:> %s', '' + gitPrevHash + '...' + gitHash
+                commandLine 'git', 'log', '--pretty=tformat:> - %s', '' + gitPrevHash + '...' + gitHash
                 standardOutput = stdout
             }
             return stdout.toString().trim()
         } else if (travisRange) {
             exec {
-                commandLine 'git', 'log', '--pretty=tformat:> %s', '' + travisRange
+                commandLine 'git', 'log', '--pretty=tformat:> - %s', '' + travisRange
                 standardOutput = stdout
             }
             return stdout.toString().trim()
@@ -340,7 +321,7 @@ task sendWebhook {
 
             def message = new Message()
             message.setUsername("Patreon Early Access")
-            message.setContent("New Hexcasting release! Download it here: ${System.getenv("BUILD_URL")}\nChangelog:\n${getGitChangelog()}")
+            message.setContent("New **$modName** release! Download it here: ${System.getenv("BUILD_URL")}\nChangelog:\n${getGitChangelog()}")
 
             webhook.sendMessage(message)
         } catch (ignored) {
@@ -349,3 +330,14 @@ task sendWebhook {
     }
 }
 
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
+}
+compileKotlin {
+    kotlinOptions {
+    }
+}
+compileTestKotlin {
+    kotlinOptions {
+    }
+}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
index 784899a6..d87b5e53 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -2,3 +2,11 @@
 # This is required to provide enough memory for the Minecraft decompilation process.
 org.gradle.jvmargs=-Xmx3G
 org.gradle.daemon=false
+modID=hexcasting
+modName=Hex Casting
+minecraftVersion=1.18.2
+modVersion=0.8.4
+forgeVersion=40.1.0
+paucalVersion=0.3.4
+patchouliVersion=66
+jeiVersion=9.5.3.143
diff --git a/src/generated/resources/.cache/cache b/src/generated/resources/.cache/cache
index 833f0f61..2512e711 100644
--- a/src/generated/resources/.cache/cache
+++ b/src/generated/resources/.cache/cache
@@ -321,19 +321,19 @@ f043370d6762b976e33dd6e9562d5e1659d32bbf assets/hexcasting/models/item/wand_old.
 05e86742a71afd740f47639be62f93bc9898fcde data/forge/tags/items/gems.json
 b6593ea802a692c29b5032292df31beb84878ad8 data/hexcasting/advancements/aaa_wasteful_cast.json
 4f4c94021adfb296e3ef3dce1acc46f724f38f92 data/hexcasting/advancements/aab_big_cast.json
-a165e3959b7d0c37bea586d0e94609b483255569 data/hexcasting/advancements/enlightenment.json
+2fe3543a209fca031b1eace7ea217c76142609cc data/hexcasting/advancements/enlightenment.json
 eb6393ffc79966e4b5983a68157742b78cd12414 data/hexcasting/advancements/opened_eyes.json
-d0b09e984b9270fe20b6c8d6f17e7690caaea409 data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json
-7e93886be31c3762a5b70e56a7214d19f64d58a8 data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json
-12d9101d43c907f08b0f94747240678d53e4c1fb data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json
-ed6ce219b2ee65d69ea45a43fb9a71b1f5da88bb data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json
-d225f90cc1e3b8200014106cd2d3bede9c783817 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json
-c966b7ab46808f86bdb7bbd07049146f0dfb24ec data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json
+cf0ad981bebbb79414d955fb40fbf537fe88b89d data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json
+c2a362b8c19cb288187d8ff340f82198edc54378 data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json
+c11dc4388c18dadff5d93126eb0f7ae848d627b9 data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json
+86424d21e1bf91c128d3b0d528b813629ad962e9 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json
+5f9f0962f407062e7b6dd0e8c5f8c55ce13962a5 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json
+5d4811f78feefbef0a305555143f488b3dac7ac6 data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json
 3fe1fcf17e1e25aebede47c537f92888330ccf9f data/hexcasting/advancements/recipes/hexcasting/abacus.json
 5a17fa9a1496f5fbedd0362f94a5231e0e5ebbfc data/hexcasting/advancements/recipes/hexcasting/ageing_scroll_paper_lantern.json
-c498998fcffe3d1a0b6dfd6459db64e9389f5c15 data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json
+66e51300dc72c27ed8024ddf852ac9a6208a66b1 data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json
 31f9b7d8141f67981deedf7a46894e454006bb28 data/hexcasting/advancements/recipes/hexcasting/akashic_button.json
-d9f9fc153bf8e8861f79f982b185d2e4c7048067 data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json
+168749d413b20bb9c05a8e7191758e0e596a319b data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json
 1266b263056dd15c862bff27b05a119c4bbc89ee data/hexcasting/advancements/recipes/hexcasting/akashic_door.json
 149179e18b1b8db5dc3fb96e6faa6cb6ffaecb75 data/hexcasting/advancements/recipes/hexcasting/akashic_panel.json
 4f852507d843f82dce1512f55abfb205b9829ed4 data/hexcasting/advancements/recipes/hexcasting/akashic_planks.json
@@ -368,8 +368,8 @@ d6dfd0c6e995270868cb90de818d24b8a667fd01 data/hexcasting/advancements/recipes/he
 b0b1c5fff194b92ff8c5d6468e177271fd910abd data/hexcasting/advancements/recipes/hexcasting/dye_colorizer_red.json
 ccc33b4f1a43c8ecd3352ad36ae2dd2191317b5b data/hexcasting/advancements/recipes/hexcasting/dye_colorizer_white.json
 9c857c4aeda8a1b3d7a1b5d341871a9434b5816f data/hexcasting/advancements/recipes/hexcasting/dye_colorizer_yellow.json
-d978ce120b6af69899ff556f06997fcea522948b data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json
-e40a09b7fdf5125be645a323ea5e1922a7e963f0 data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json
+7351200c8e3eb24772852c578286384c8aab61bd data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json
+023c32e8834eb313c4fa94a84a8f6390ee951ef0 data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json
 f089ab17470c5fa0065438c5533d5fafb3ee8eaf data/hexcasting/advancements/recipes/hexcasting/focus.json
 fc57d15e9f9f11347a2170dd06053954345368d2 data/hexcasting/advancements/recipes/hexcasting/lens.json
 82be04125e60a28701de5bb6bc7855bb46fa9d0f data/hexcasting/advancements/recipes/hexcasting/pride_colorizer_0.json
@@ -406,7 +406,7 @@ f32ccb2d36d773215d91dee46bec70a20af501c3 data/hexcasting/advancements/recipes/he
 30950c6dd31102cf145f8f7d2979df0736a7ba1e data/hexcasting/advancements/recipes/hexcasting/wand_oak.json
 f8d2872c4e692153049b6ae4879755a079954763 data/hexcasting/advancements/recipes/hexcasting/wand_spruce.json
 3b2bcffe70bb1f732f06c2560cef66de6c273d62 data/hexcasting/advancements/recipes/hexcasting/wand_warped.json
-d31956749bebbcb3f0d3c37f89b569642ac8c2fb data/hexcasting/advancements/root.json
+ed0e62cb81783d8eb6323dd70609067219f163ec data/hexcasting/advancements/root.json
 739cbdf7f204132f2acfab4df8d21c6197aa1456 data/hexcasting/advancements/y_u_no_cast_angy.json
 70a8f77d38affa642afbfceebe129358737b09ac data/hexcasting/loot_modifiers/amethyst_cluster_charged.json
 f746acc6b3e798d3b95f4ceb463c648b1f3ae8c3 data/hexcasting/loot_modifiers/amethyst_cluster_dust.json
@@ -418,6 +418,7 @@ afecba3144e00505977a4ab4de7940f949ab7818 data/hexcasting/loot_modifiers/scroll_d
 50e7ad657a0ab43f3bd632120e09f109791aaf34 data/hexcasting/loot_modifiers/scroll_shipwreck.json
 7ffa361bd8a108b504fe450749b42997dc898e5e data/hexcasting/loot_modifiers/scroll_stronghold_library.json
 cfd72df535fe95cd2b0d800696e7b4b3429a0459 data/hexcasting/loot_tables/blocks/akashic_bookshelf.json
+fc787ec13389b66afda79083f22c7b72f02d5966 data/hexcasting/loot_tables/blocks/akashic_button.json
 2e5958279471fa57ae2929d9f9da46e59495f50e data/hexcasting/loot_tables/blocks/akashic_connector.json
 3794453f5412af9c7307c9cd91fe2d01ffb763af data/hexcasting/loot_tables/blocks/akashic_door.json
 e05da321f00ce09c6f4ad3f6da95ae3dc93e7748 data/hexcasting/loot_tables/blocks/akashic_leaves1.json
@@ -427,7 +428,10 @@ e05da321f00ce09c6f4ad3f6da95ae3dc93e7748 data/hexcasting/loot_tables/blocks/akas
 ff25315e494e3b79667a1fa90d22a80d0eb6d208 data/hexcasting/loot_tables/blocks/akashic_log_stripped.json
 7400ffa5214a5d7ed34be2ac2ffcc2b50cdf299c data/hexcasting/loot_tables/blocks/akashic_panel.json
 f59f016a4fa4edaad0b2731f8f1bb2c7b9299ede data/hexcasting/loot_tables/blocks/akashic_planks.json
+a8f202947467960dcc634ca7cc65b8911a5c2399 data/hexcasting/loot_tables/blocks/akashic_pressure_plate.json
 22517cb8c8063a6a2752cd80f63f224c88bc2ede data/hexcasting/loot_tables/blocks/akashic_record.json
+abb4c70d044fed6af763b75bdc50fe2624e83625 data/hexcasting/loot_tables/blocks/akashic_slab.json
+5128da5769f0a1a9045488e32ac453069d6431f5 data/hexcasting/loot_tables/blocks/akashic_stairs.json
 0ddb27503a7266d126661bad496047a069a07670 data/hexcasting/loot_tables/blocks/akashic_tile.json
 659b7e6d539474357532c1207b21354e19cbd4b1 data/hexcasting/loot_tables/blocks/akashic_trapdoor.json
 1590fee356080d4dd3f4e0718d87269bdd7f3519 data/hexcasting/loot_tables/blocks/akashic_wood.json
@@ -544,7 +548,7 @@ d1b8725bbfc01e2d9a02ef84c911fef89b3636a9 data/hexcasting/tags/items/wands.json
 c25784941d6416744fb2ca2d43a3203e5c3e7c8a data/minecraft/tags/blocks/leaves.json
 f3c6b6917e504e1c3d5d8875f7cce6f311e791d2 data/minecraft/tags/blocks/logs.json
 f3c6b6917e504e1c3d5d8875f7cce6f311e791d2 data/minecraft/tags/blocks/logs_that_burn.json
-7c08784f2de139be380b5299f8ea8b8c78126ed8 data/minecraft/tags/blocks/mineable/axe.json
+cb5721fcb4a8f7bf14adf6ab560378a250128aba data/minecraft/tags/blocks/mineable/axe.json
 c25784941d6416744fb2ca2d43a3203e5c3e7c8a data/minecraft/tags/blocks/mineable/hoe.json
 eb4bfbd7fc7632a5c16aa1d50d6090a1f466069b data/minecraft/tags/blocks/mineable/pickaxe.json
 f55afc2c05d93b5a44bc9fd73c5e81e71b183965 data/minecraft/tags/blocks/mineable/shovel.json
diff --git a/src/generated/resources/data/hexcasting/advancements/enlightenment.json b/src/generated/resources/data/hexcasting/advancements/enlightenment.json
index 6262d68e..817aee0d 100644
--- a/src/generated/resources/data/hexcasting/advancements/enlightenment.json
+++ b/src/generated/resources/data/hexcasting/advancements/enlightenment.json
@@ -20,7 +20,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json
index 0ec5f91a..214bf87c 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/akashic_record.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json
index d97f1835..17714fa1 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/budding_amethyst.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json
index 363d63de..675eec77 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/directrix_redstone.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json
index 0bf1ed27..d415e909 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_look.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json
index 68a6dea9..11f02807 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_rightclick.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json
index 6ef63302..94b84ee9 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/brainsweep/brainsweep/impetus_storedplayer.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json
index f9a06f32..1d8cc370 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_bookshelf.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json
index ab717d35..2963c28e 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/akashic_connector.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json
index 3871d213..112e9b61 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_directrix.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json
index 8280247a..7248e179 100644
--- a/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json
+++ b/src/generated/resources/data/hexcasting/advancements/recipes/hexcasting/empty_impetus.json
@@ -10,7 +10,7 @@
       "trigger": "hexcasting:overcast",
       "conditions": {
         "health_used": {
-          "min": 17.95
+          "min": 0.8
         },
         "mojang_i_am_begging_and_crying_please_add_an_entity_health_criterion": {
           "min": 0.1,
diff --git a/src/generated/resources/data/hexcasting/advancements/root.json b/src/generated/resources/data/hexcasting/advancements/root.json
index d3ee9841..8160a074 100644
--- a/src/generated/resources/data/hexcasting/advancements/root.json
+++ b/src/generated/resources/data/hexcasting/advancements/root.json
@@ -16,29 +16,14 @@
     "background": "minecraft:textures/block/calcite.png"
   },
   "criteria": {
-    "on_thingy": {
-      "trigger": "minecraft:tick",
+    "has_charged_amethyst": {
+      "trigger": "minecraft:inventory_changed",
       "conditions": {
-        "player": [
+        "items": [
           {
-            "condition": "minecraft:entity_properties",
-            "predicate": {
-              "stepping_on": {
-                "position": {
-                  "y": {
-                    "min": -64.0,
-                    "max": 30.0
-                  }
-                },
-                "block": {
-                  "blocks": [
-                    "minecraft:amethyst_block",
-                    "minecraft:calcite"
-                  ]
-                }
-              }
-            },
-            "entity": "this"
+            "items": [
+              "hexcasting:charged_amethyst"
+            ]
           }
         ]
       }
@@ -46,7 +31,7 @@
   },
   "requirements": [
     [
-      "on_thingy"
+      "has_charged_amethyst"
     ]
   ]
 }
\ No newline at end of file
diff --git a/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_dust.json b/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_dust.json
index 8a821062..665afbb9 100644
--- a/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_dust.json
+++ b/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_dust.json
@@ -24,7 +24,7 @@
       "function": "minecraft:set_count",
       "count": {
         "type": "minecraft:uniform",
-        "min": 1.0,
+        "min": 2.0,
         "max": 4.0
       },
       "add": false
@@ -36,4 +36,4 @@
     }
   ],
   "type": "paucal:add_item"
-}
\ No newline at end of file
+}
diff --git a/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_shard_reducer.json b/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_shard_reducer.json
index d4846240..0228fd42 100644
--- a/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_shard_reducer.json
+++ b/src/generated/resources/data/hexcasting/loot_modifiers/amethyst_cluster_shard_reducer.json
@@ -18,6 +18,6 @@
       }
     }
   ],
-  "modifier": -2.0,
+  "modifier": -0.5,
   "type": "hexcasting:amethyst_shard_reducer"
-}
\ No newline at end of file
+}
diff --git a/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_button.json b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_button.json
new file mode 100644
index 00000000..732abe88
--- /dev/null
+++ b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_button.json
@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "name": "akashic_button",
+      "rolls": 1.0,
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "hexcasting:akashic_button"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_pressure_plate.json b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_pressure_plate.json
new file mode 100644
index 00000000..3b009866
--- /dev/null
+++ b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_pressure_plate.json
@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "name": "akashic_pressure_plate",
+      "rolls": 1.0,
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "hexcasting:akashic_pressure_plate"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_slab.json b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_slab.json
new file mode 100644
index 00000000..c44a7363
--- /dev/null
+++ b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_slab.json
@@ -0,0 +1,35 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "name": "akashic_slab",
+      "rolls": 1.0,
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "hexcasting:akashic_slab"
+        }
+      ],
+      "functions": [
+        {
+          "function": "minecraft:set_count",
+          "conditions": [
+            {
+              "condition": "minecraft:block_state_property",
+              "block": "hexcasting:akashic_slab",
+              "properties": {
+                "type": "double"
+              }
+            }
+          ],
+          "count": 2.0,
+          "add": false
+        },
+        {
+          "function": "minecraft:explosion_decay"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_stairs.json b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_stairs.json
new file mode 100644
index 00000000..134d2b07
--- /dev/null
+++ b/src/generated/resources/data/hexcasting/loot_tables/blocks/akashic_stairs.json
@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "name": "akashic_stairs",
+      "rolls": 1.0,
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "hexcasting:akashic_stairs"
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/src/generated/resources/data/minecraft/tags/blocks/mineable/axe.json b/src/generated/resources/data/minecraft/tags/blocks/mineable/axe.json
index 9bb914fd..5ae1fa0a 100644
--- a/src/generated/resources/data/minecraft/tags/blocks/mineable/axe.json
+++ b/src/generated/resources/data/minecraft/tags/blocks/mineable/axe.json
@@ -14,6 +14,7 @@
     "hexcasting:akashic_door",
     "hexcasting:akashic_trapdoor",
     "hexcasting:akashic_slab",
+    "hexcasting:akashic_stairs",
     "hexcasting:akashic_button"
   ]
 }
\ No newline at end of file
diff --git a/src/main/java/at/petrak/hexcasting/HexMod.kt b/src/main/java/at/petrak/hexcasting/HexMod.kt
index 2619495f..14161533 100644
--- a/src/main/java/at/petrak/hexcasting/HexMod.kt
+++ b/src/main/java/at/petrak/hexcasting/HexMod.kt
@@ -11,18 +11,23 @@ import at.petrak.hexcasting.common.blocks.HexBlocks
 import at.petrak.hexcasting.common.casting.RegisterPatterns
 import at.petrak.hexcasting.common.casting.operators.spells.great.OpFlight
 import at.petrak.hexcasting.common.command.HexCommands
+import at.petrak.hexcasting.common.command.PatternResLocArgument
 import at.petrak.hexcasting.common.entities.HexEntities
 import at.petrak.hexcasting.common.items.HexItems
 import at.petrak.hexcasting.common.lib.HexCapabilityHandler
 import at.petrak.hexcasting.common.lib.HexSounds
 import at.petrak.hexcasting.common.misc.Brainsweeping
+import at.petrak.hexcasting.common.misc.PlayerPositionRecorder
 import at.petrak.hexcasting.common.network.HexMessages
 import at.petrak.hexcasting.common.particles.HexParticles
+import at.petrak.hexcasting.common.recipe.HexComposting
 import at.petrak.hexcasting.common.recipe.HexCustomRecipes
 import at.petrak.hexcasting.common.recipe.HexRecipeSerializers
 import at.petrak.hexcasting.datagen.HexDataGenerators
 import at.petrak.hexcasting.datagen.lootmods.HexLootModifiers
 import at.petrak.hexcasting.server.TickScheduler
+import net.minecraft.commands.synchronization.ArgumentTypes
+import net.minecraft.commands.synchronization.EmptyArgumentSerializer
 import net.minecraftforge.api.distmarker.Dist
 import net.minecraftforge.common.ForgeConfigSpec
 import net.minecraftforge.eventbus.api.SubscribeEvent
@@ -55,6 +60,8 @@ object HexMod {
         CLIENT_CONFIG_SPEC = ForgeConfigSpec.Builder()
             .configure { builder: ForgeConfigSpec.Builder? -> HexConfig.Client(builder) }.right
 
+        ArgumentTypes.register("hexcasting:pattern", PatternResLocArgument::class.java, EmptyArgumentSerializer(PatternResLocArgument::id))
+
         // mod lifecycle
         val modBus = thedarkcolour.kotlinforforge.forge.MOD_BUS
         // game events
@@ -77,6 +84,9 @@ object HexMod {
         modBus.register(HexStatistics::class.java)
         modBus.register(HexRecipeSerializers::class.java)
 
+        modBus.register(HexComposting::class.java)
+
+        evBus.register(PlayerPositionRecorder::class.java)
         evBus.register(HexCommands::class.java)
         evBus.register(TickScheduler)
         evBus.register(HexCapabilityHandler::class.java)
diff --git a/src/main/java/at/petrak/hexcasting/api/advancements/OvercastTrigger.java b/src/main/java/at/petrak/hexcasting/api/advancements/OvercastTrigger.java
index ac3f4305..7abdd2c8 100644
--- a/src/main/java/at/petrak/hexcasting/api/advancements/OvercastTrigger.java
+++ b/src/main/java/at/petrak/hexcasting/api/advancements/OvercastTrigger.java
@@ -35,7 +35,7 @@ public class OvercastTrigger extends SimpleCriterionTrigger<OvercastTrigger.Inst
         super.trigger(player, inst -> {
             var manaToHealth = HexConfig.manaToHealthRate.get();
             var healthUsed = manaGenerated / manaToHealth;
-            return inst.test(manaGenerated, healthUsed, player.getHealth() - (float) healthUsed);
+            return inst.test(manaGenerated, healthUsed / player.getMaxHealth(), player.getHealth() - (float) healthUsed);
         });
     }
 
diff --git a/src/main/java/at/petrak/hexcasting/api/cap/HexCapabilities.java b/src/main/java/at/petrak/hexcasting/api/cap/HexCapabilities.java
index c920dc2e..7e1f0e13 100644
--- a/src/main/java/at/petrak/hexcasting/api/cap/HexCapabilities.java
+++ b/src/main/java/at/petrak/hexcasting/api/cap/HexCapabilities.java
@@ -1,9 +1,12 @@
 package at.petrak.hexcasting.api.cap;
 
+import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.capabilities.CapabilityManager;
 import net.minecraftforge.common.capabilities.CapabilityToken;
 
+import java.util.Optional;
+
 public final class HexCapabilities {
 
 	public static final Capability<ManaHolder> MANA = CapabilityManager.get(new CapabilityToken<>() {
@@ -14,4 +17,10 @@ public final class HexCapabilities {
 	});
 	public static final Capability<Colorizer> COLOR = CapabilityManager.get(new CapabilityToken<>() {
 	});
+
+	public static <T> Optional<T> getCapability(ItemStack stack, Capability<T> cap) {
+		if (stack.isEmpty())
+			return Optional.empty();
+		return stack.getCapability(cap).resolve();
+	}
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/circle/BlockEntityAbstractImpetus.java b/src/main/java/at/petrak/hexcasting/api/circle/BlockEntityAbstractImpetus.java
index 08cb508b..cd15d519 100644
--- a/src/main/java/at/petrak/hexcasting/api/circle/BlockEntityAbstractImpetus.java
+++ b/src/main/java/at/petrak/hexcasting/api/circle/BlockEntityAbstractImpetus.java
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.api.circle;
 
 import at.petrak.hexcasting.api.misc.FrozenColorizer;
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import at.petrak.hexcasting.api.mod.HexApiItems;
 import at.petrak.hexcasting.api.mod.HexApiSounds;
 import at.petrak.hexcasting.api.mod.HexConfig;
@@ -37,6 +38,8 @@ import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.phys.AABB;
 import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
 import net.minecraftforge.common.capabilities.Capability;
 import net.minecraftforge.common.capabilities.ICapabilityProvider;
 import net.minecraftforge.common.util.LazyOptional;
@@ -115,21 +118,22 @@ public abstract class BlockEntityAbstractImpetus extends PaucalBlockEntity imple
         this.stepCircle();
     }
 
-    public List<Pair<ItemStack, Component>> getScryingLensOverlay(BlockState state, BlockPos pos,
-        LocalPlayer observer, ClientLevel world, InteractionHand lensHand) {
-        var out = new ArrayList<Pair<ItemStack, Component>>();
+    @OnlyIn(Dist.CLIENT)
+    public void applyScryingLensOverlay(List<Pair<ItemStack, Component>> lines,
+                                        BlockState state, BlockPos pos,
+                                        LocalPlayer observer, ClientLevel world,
+                                        Direction hitFace, InteractionHand lensHand) {
         if (world.getBlockEntity(pos) instanceof BlockEntityAbstractImpetus beai) {
-            var dustCount = (float) beai.getMana() / (float) HexConfig.dustManaAmount.get();
+            var dustCount = (float) beai.getMana() / (float) ManaConstants.DUST_UNIT;
             var dustCmp = new TranslatableComponent("hexcasting.tooltip.lens.impetus.mana",
                 String.format("%.2f", dustCount));
-            out.add(new Pair<>(new ItemStack(HexApiItems.AMETHYST_DUST), dustCmp));
+            lines.add(new Pair<>(new ItemStack(HexApiItems.AMETHYST_DUST), dustCmp));
 
             var mishap = this.getLastMishap();
             if (mishap != null) {
-                out.add(new Pair<>(new ItemStack(Items.MUSIC_DISC_11), mishap));
+                lines.add(new Pair<>(new ItemStack(Items.MUSIC_DISC_11), mishap));
             }
         }
-        return out;
     }
 
     @NotNull
@@ -173,7 +177,7 @@ public abstract class BlockEntityAbstractImpetus extends PaucalBlockEntity imple
         if (tag.contains(TAG_ACTIVATOR, Tag.TAG_INT_ARRAY) &&
             tag.contains(TAG_COLORIZER, Tag.TAG_COMPOUND) &&
             tag.contains(TAG_NEXT_BLOCK, Tag.TAG_COMPOUND) &&
-            tag.contains(TAG_TRACKED_BLOCKS, Tag.TAG_COMPOUND)) {
+            tag.contains(TAG_TRACKED_BLOCKS, Tag.TAG_LIST)) {
             this.activator = tag.getUUID(TAG_ACTIVATOR);
             this.colorizer = FrozenColorizer.deserialize(tag.getCompound(TAG_COLORIZER));
             this.nextBlock = NbtUtils.readBlockPos(tag.getCompound(TAG_NEXT_BLOCK));
diff --git a/src/main/java/at/petrak/hexcasting/api/client/ScryingLensOverlayRegistry.java b/src/main/java/at/petrak/hexcasting/api/client/ScryingLensOverlayRegistry.java
index 6f1ae8b3..da8323f9 100644
--- a/src/main/java/at/petrak/hexcasting/api/client/ScryingLensOverlayRegistry.java
+++ b/src/main/java/at/petrak/hexcasting/api/client/ScryingLensOverlayRegistry.java
@@ -1,21 +1,30 @@
 package at.petrak.hexcasting.api.client;
 
+import com.google.common.collect.Lists;
 import com.mojang.datafixers.util.Pair;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.api.distmarker.OnlyIn;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
+import java.util.Map;
 import java.util.Vector;
+import java.util.WeakHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 
@@ -26,16 +35,53 @@ import java.util.concurrent.ConcurrentMap;
  */
 @OnlyIn(Dist.CLIENT)
 public final class ScryingLensOverlayRegistry {
-    private static final ConcurrentMap<ResourceLocation, Displayer> ID_LOOKUP = new ConcurrentHashMap<>();
+    private static final ConcurrentMap<ResourceLocation, OverlayBuilder> ID_LOOKUP = new ConcurrentHashMap<>();
     // vectors are thread-safe!
-    private static final List<Pair<Predicate, Displayer>> PREDICATE_LOOKUP = new Vector<>();
+    private static final List<Pair<OverlayPredicate, OverlayBuilder>> PREDICATE_LOOKUP = new Vector<>();
+
+    // implemented as a map to allow for weak dereferencing
+    private static final Map<LocalPlayer, Pair<BlockPos, Integer>> comparatorData = new WeakHashMap<>();
+
+    public static void receiveComparatorValue(BlockPos pos, int value) {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (player != null) {
+            if (pos == null || value == -1)
+                comparatorData.remove(player);
+            else
+                comparatorData.put(player, new Pair<>(pos, value));
+        }
+    }
+
+    public static int getComparatorValue(boolean onlyRealComparators) {
+        var mc = Minecraft.getInstance();
+        var player = mc.player;
+        var level = mc.level;
+        var result = mc.hitResult;
+
+        if (player == null || level == null || result == null || result.getType() != HitResult.Type.BLOCK)
+            return -1;
+
+        var comparatorValue = comparatorData.get(player);
+        if (comparatorValue == null)
+            return -1;
+
+        var pos = ((BlockHitResult)result).getBlockPos();
+        if (!pos.equals(comparatorValue.getFirst()))
+            return -1;
+
+        var state = mc.level.getBlockState(pos);
+        if ((onlyRealComparators && !state.is(Blocks.COMPARATOR)) || (!onlyRealComparators && !state.hasAnalogOutputSignal()))
+            return -1;
+
+        return comparatorValue.getSecond();
+    }
 
     /**
      * Add the block to display things when the player is holding a lens and looking at it.
      *
      * @throws IllegalArgumentException if the block is already registered.
      */
-    public static void addDisplayer(Block block, Displayer displayer) {
+    public static void addDisplayer(Block block, OverlayBuilder displayer) {
         addDisplayer(block.getRegistryName(), displayer);
     }
 
@@ -44,7 +90,7 @@ public final class ScryingLensOverlayRegistry {
      *
      * @throws IllegalArgumentException if the block ID is already registered.
      */
-    public static void addDisplayer(ResourceLocation blockID, Displayer displayer) {
+    public static void addDisplayer(ResourceLocation blockID, OverlayBuilder displayer) {
         if (ID_LOOKUP.containsKey(blockID)) {
             throw new IllegalArgumentException("Already have a displayer for " + blockID);
         }
@@ -57,47 +103,51 @@ public final class ScryingLensOverlayRegistry {
      * These have a lower priority than the standard ID-based displays, so if an ID and predicate both match,
      * this won't be displayed.
      */
-    public static void addPredicateDisplayer(Predicate predicate, Displayer displayer) {
+    public static void addPredicateDisplayer(OverlayPredicate predicate, OverlayBuilder displayer) {
         PREDICATE_LOOKUP.add(new Pair<>(predicate, displayer));
     }
 
     /**
      * Internal use only.
      */
-    public static @Nullable List<Pair<ItemStack, Component>> getLines(BlockState state, BlockPos pos,
-        LocalPlayer observer, ClientLevel world,
-        @Nullable InteractionHand lensHand) {
+    public static @NotNull List<Pair<ItemStack, Component>> getLines(BlockState state, BlockPos pos,
+                                                                     LocalPlayer observer, ClientLevel world,
+                                                                     Direction hitFace, @Nullable InteractionHand lensHand) {
+        List<Pair<ItemStack, Component>> lines = Lists.newArrayList();
         var idLookedup = ID_LOOKUP.get(state.getBlock().getRegistryName());
         if (idLookedup != null) {
-            return idLookedup.getLines(state, pos, observer, world, lensHand);
+            idLookedup.addLines(lines, state, pos, observer, world, hitFace, lensHand);
         }
 
         for (var pair : PREDICATE_LOOKUP) {
-            if (pair.getFirst().test(state, pos, observer, world, lensHand)) {
-                return pair.getSecond().getLines(state, pos, observer, world, lensHand);
+            if (pair.getFirst().test(state, pos, observer, world, hitFace, lensHand)) {
+                pair.getSecond().addLines(lines, state, pos, observer, world, hitFace, lensHand);
             }
         }
 
-        return null;
+        return lines;
     }
 
     /**
      * Return the lines displayed by the cursor: an item and some text.
      * <p>
-     * The ItemStack can be null; if it is, the text isn't shifted over for it.
+     * The ItemStack can be empty; if it is, the text isn't shifted over for it.
      */
     @FunctionalInterface
-    public interface Displayer {
-        List<Pair<ItemStack, Component>> getLines(BlockState state, BlockPos pos, LocalPlayer observer,
-            ClientLevel world,
-            @Nullable InteractionHand lensHand);
+    public interface OverlayBuilder {
+        void addLines(List<Pair<ItemStack, Component>> lines,
+                      BlockState state, BlockPos pos, LocalPlayer observer,
+                      ClientLevel world,
+                      Direction hitFace, @Nullable InteractionHand lensHand);
     }
 
     /**
      * Predicate for matching on a block state.
      */
     @FunctionalInterface
-    public interface Predicate {
-        boolean test(BlockState state, BlockPos pos, LocalPlayer observer, ClientLevel world, @Nullable InteractionHand lensHand);
+    public interface OverlayPredicate {
+        boolean test(BlockState state, BlockPos pos, LocalPlayer observer,
+                     ClientLevel world,
+                     Direction hitFace, @Nullable InteractionHand lensHand);
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java b/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java
index dee9e52f..33b4f214 100644
--- a/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java
+++ b/src/main/java/at/petrak/hexcasting/api/item/DataHolderItem.java
@@ -1,6 +1,8 @@
 package at.petrak.hexcasting.api.item;
 
 import at.petrak.hexcasting.api.spell.SpellDatum;
+import at.petrak.hexcasting.api.utils.NBTHelper;
+import net.minecraft.ChatFormatting;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.NbtUtils;
 import net.minecraft.network.chat.Component;
@@ -13,6 +15,8 @@ import org.jetbrains.annotations.Nullable;
 import java.util.List;
 
 public interface DataHolderItem {
+    String TAG_OVERRIDE_VISUALLY = "VisualOverride";
+
     @Nullable CompoundTag readDatumTag(ItemStack stack);
 
     @Nullable
@@ -49,6 +53,10 @@ public interface DataHolderItem {
             if (pIsAdvanced.isAdvanced()) {
                 pTooltipComponents.add(NbtUtils.toPrettyComponent(datumTag));
             }
+        } else if (NBTHelper.hasString(pStack, DataHolderItem.TAG_OVERRIDE_VISUALLY)) {
+            pTooltipComponents.add(new TranslatableComponent("hexcasting.spelldata.onitem",
+                new TranslatableComponent("hexcasting.spelldata.anything").withStyle(ChatFormatting.LIGHT_PURPLE)));
+
         }
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java b/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java
index 616e0a64..a8cba786 100644
--- a/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java
+++ b/src/main/java/at/petrak/hexcasting/api/misc/FrozenColorizer.java
@@ -55,7 +55,7 @@ public record FrozenColorizer(ItemStack item, UUID owner) {
     }
 
     public static boolean isColorizer(ItemStack stack) {
-        return stack.getCapability(HexCapabilities.COLOR).isPresent();
+        return HexCapabilities.getCapability(stack, HexCapabilities.COLOR).isPresent();
     }
 
     /**
@@ -89,7 +89,7 @@ public record FrozenColorizer(ItemStack item, UUID owner) {
      * @return an AARRGGBB color.
      */
     public int getRawColor(float time, Vec3 position) {
-        var maybeColorizer = item.getCapability(HexCapabilities.COLOR).resolve();
+        var maybeColorizer = HexCapabilities.getCapability(this.item, HexCapabilities.COLOR);
         if (maybeColorizer.isPresent()) {
             Colorizer colorizer = maybeColorizer.get();
             return colorizer.color(owner, time, position);
diff --git a/src/main/java/at/petrak/hexcasting/api/misc/ManaConstants.java b/src/main/java/at/petrak/hexcasting/api/misc/ManaConstants.java
new file mode 100644
index 00000000..7a2111df
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/api/misc/ManaConstants.java
@@ -0,0 +1,7 @@
+package at.petrak.hexcasting.api.misc;
+
+public final class ManaConstants {
+	public static final int DUST_UNIT = 10000;
+	public static final int SHARD_UNIT = 5 * DUST_UNIT;
+	public static final int CRYSTAL_UNIT = 10 * DUST_UNIT;
+}
diff --git a/src/main/java/at/petrak/hexcasting/api/mod/HexConfig.java b/src/main/java/at/petrak/hexcasting/api/mod/HexConfig.java
index aa821e2d..311d6d75 100644
--- a/src/main/java/at/petrak/hexcasting/api/mod/HexConfig.java
+++ b/src/main/java/at/petrak/hexcasting/api/mod/HexConfig.java
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.api.mod;
 
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Tier;
 import net.minecraft.world.item.Tiers;
@@ -16,13 +17,13 @@ public class HexConfig {
     public HexConfig(ForgeConfigSpec.Builder builder) {
         builder.push("Mana Amounts");
         dustManaAmount = builder.comment("How much mana a single Amethyst Dust item is worth")
-            .defineInRange("dustManaAmount", 10_000, 0, Integer.MAX_VALUE);
+            .defineInRange("dustManaAmount", ManaConstants.DUST_UNIT, 0, Integer.MAX_VALUE);
         shardManaAmount = builder.comment("How much mana a single Amethyst Shard item is worth")
-            .defineInRange("shardManaAmount", 50_000, 0, Integer.MAX_VALUE);
+            .defineInRange("shardManaAmount", ManaConstants.SHARD_UNIT, 0, Integer.MAX_VALUE);
         chargedCrystalManaAmount = builder.comment("How much mana a single Charged Amethyst Crystal item is worth")
-            .defineInRange("chargedCrystalManaAmount", 100_000, 0, Integer.MAX_VALUE);
+            .defineInRange("chargedCrystalManaAmount", ManaConstants.CRYSTAL_UNIT, 0, Integer.MAX_VALUE);
         manaToHealthRate = builder.comment("How many points of mana a half-heart is worth when casting from HP")
-            .defineInRange("manaToHealthRate", 200_000.0 / 20.0, 0.0, Double.POSITIVE_INFINITY);
+            .defineInRange("manaToHealthRate", 2 * ManaConstants.CRYSTAL_UNIT / 20.0, 0.0, Double.POSITIVE_INFINITY);
         builder.pop();
     }
 
@@ -33,7 +34,7 @@ public class HexConfig {
         public Client(ForgeConfigSpec.Builder builder) {
             patternPointSpeedMultiplier = builder.comment(
                     "How fast the point showing you the stroke order on patterns moves")
-                .defineInRange("manaToHealthRate", 1.0, 0.0, Double.POSITIVE_INFINITY);
+                .defineInRange("patternPointSpeed", 1.0, 0.0, Double.POSITIVE_INFINITY);
             ctrlTogglesOffStrokeOrder = builder.comment(
                     "Whether the ctrl key will instead turn *off* the color gradient on patterns")
                 .define("ctrlTogglesOffStrokeOrder", false);
diff --git a/src/main/java/at/petrak/hexcasting/api/mod/HexStatistics.java b/src/main/java/at/petrak/hexcasting/api/mod/HexStatistics.java
index 38886613..24ee73ce 100644
--- a/src/main/java/at/petrak/hexcasting/api/mod/HexStatistics.java
+++ b/src/main/java/at/petrak/hexcasting/api/mod/HexStatistics.java
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.api.mod;
 
 import at.petrak.hexcasting.HexMod;
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import net.minecraft.core.Registry;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.stats.StatFormatter;
@@ -19,10 +20,10 @@ public class HexStatistics {
     @SubscribeEvent
     public static void register(RegistryEvent.Register<Block> evt) {
         MANA_USED = makeCustomStat("mana_used",
-            manamount -> StatFormatter.DEFAULT.format(manamount / HexConfig.dustManaAmount.get())
+            manamount -> StatFormatter.DEFAULT.format(manamount / ManaConstants.DUST_UNIT)
         );
         MANA_OVERCASTED = makeCustomStat("mana_overcasted",
-            manamount -> StatFormatter.DEFAULT.format(manamount / HexConfig.dustManaAmount.get())
+            manamount -> StatFormatter.DEFAULT.format(manamount / ManaConstants.DUST_UNIT)
         );
         PATTERNS_DRAWN = makeCustomStat("patterns_drawn", StatFormatter.DEFAULT);
         SPELLS_CAST = makeCustomStat("spells_cast", StatFormatter.DEFAULT);
diff --git a/src/main/java/at/petrak/hexcasting/api/player/HexPlayerDataHelper.java b/src/main/java/at/petrak/hexcasting/api/player/HexPlayerDataHelper.java
index acd7fc6b..9839e31c 100644
--- a/src/main/java/at/petrak/hexcasting/api/player/HexPlayerDataHelper.java
+++ b/src/main/java/at/petrak/hexcasting/api/player/HexPlayerDataHelper.java
@@ -33,7 +33,7 @@ public class HexPlayerDataHelper {
 	public static final String TAG_FLIGHT_ALLOWED = "hexcasting:flight_allowed";
 	public static final String TAG_FLIGHT_TIME = "hexcasting:flight_time";
 	public static final String TAG_FLIGHT_ORIGIN = "hexcasting:flight_origin";
-	public static final String TAG_FLIGHT_DIMENSION = "hexcasting:flight_origin";
+	public static final String TAG_FLIGHT_DIMENSION = "hexcasting:flight_dimension";
 	public static final String TAG_FLIGHT_RADIUS = "hexcasting:flight_radius";
 
 	public static final String TAG_HARNESS = "hexcasting:spell_harness";
@@ -100,6 +100,7 @@ public class HexPlayerDataHelper {
 		} else {
 			tag.remove(TAG_FLIGHT_TIME);
 			tag.remove(TAG_FLIGHT_ORIGIN);
+			tag.remove(TAG_FLIGHT_DIMENSION);
 			tag.remove(TAG_FLIGHT_RADIUS);
 		}
 	}
@@ -148,7 +149,7 @@ public class HexPlayerDataHelper {
 			var timeLeft = tag.getInt(TAG_FLIGHT_TIME);
 			var origin = HexUtils.DeserializeVec3FromNBT(tag.getLongArray(TAG_FLIGHT_ORIGIN));
 			var radius = tag.getDouble(TAG_FLIGHT_RADIUS);
-			var dimension = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_SENTINEL_DIMENSION)));
+			var dimension = ResourceKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(tag.getString(TAG_FLIGHT_DIMENSION)));
 			return new FlightAbility(true, timeLeft, dimension, origin, radius);
 		}
 		return FlightAbility.deny();
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/ConstManaOperator.kt b/src/main/java/at/petrak/hexcasting/api/spell/ConstManaOperator.kt
index 65b30c1b..ddd0de65 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/ConstManaOperator.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/ConstManaOperator.kt
@@ -14,7 +14,7 @@ interface ConstManaOperator : Operator {
 
     fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>>
 
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (this.argc > stack.size)
             throw MishapNotEnoughArgs(this.argc, stack.size)
         val args = stack.takeLast(this.argc)
@@ -24,6 +24,6 @@ interface ConstManaOperator : Operator {
 
         val sideEffects = mutableListOf<OperatorSideEffect>(OperatorSideEffect.ConsumeMana(this.manaCost))
 
-        return OperationResult(stack, sideEffects)
+        return OperationResult(stack, local, sideEffects)
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/OperationResult.kt b/src/main/java/at/petrak/hexcasting/api/spell/OperationResult.kt
index 6494d92e..09845dbb 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/OperationResult.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/OperationResult.kt
@@ -5,4 +5,4 @@ import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect
 /**
  * What happens when an operator is through?
  */
-data class OperationResult(val newStack: List<SpellDatum<*>>, val sideEffects: List<OperatorSideEffect>)
+data class OperationResult(val newStack: List<SpellDatum<*>>, val newLocalIota: SpellDatum<*>, val sideEffects: List<OperatorSideEffect>)
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/Operator.kt b/src/main/java/at/petrak/hexcasting/api/spell/Operator.kt
index 0b6abb1d..ed134a2f 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/Operator.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/Operator.kt
@@ -23,7 +23,7 @@ interface Operator {
      *
      * A particle effect at the cast site and various messages and advancements are done automagically.
      */
-    fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult
+    fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult
 
     /**
      * Do you need to be enlightened to use this operator?
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt b/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt
index a7949bba..d1be7c6d 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/SpellDatum.kt
@@ -1,10 +1,11 @@
 package at.petrak.hexcasting.api.spell
 
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidSpellDatumType
 import at.petrak.hexcasting.api.utils.HexUtils
 import at.petrak.hexcasting.api.utils.HexUtils.serializeToNBT
-import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidSpellDatumType
+import at.petrak.hexcasting.api.utils.getList
 import net.minecraft.ChatFormatting
 import net.minecraft.nbt.*
 import net.minecraft.network.chat.Component
@@ -144,7 +145,7 @@ class SpellDatum<T : Any> private constructor(val payload: T) {
                 TAG_DOUBLE -> SpellDatum(nbt.getDouble(key))
                 TAG_VEC3 -> SpellDatum(HexUtils.DeserializeVec3FromNBT(nbt.getLongArray(key)))
                 TAG_LIST -> {
-                    val arr = nbt.getList(key, Tag.TAG_COMPOUND.toInt())
+                    val arr = nbt.getList(key, Tag.TAG_COMPOUND)
                     val out = ArrayList<SpellDatum<*>>(arr.size)
                     for (subtag in arr) {
                         // this is safe because otherwise we wouldn't have been able to get the list before
@@ -188,7 +189,7 @@ class SpellDatum<T : Any> private constructor(val payload: T) {
                 TAG_LIST -> {
                     val out = TextComponent("[").withStyle(ChatFormatting.WHITE)
 
-                    val arr = nbt.getList(key, Tag.TAG_COMPOUND.toInt())
+                    val arr = nbt.getList(key, Tag.TAG_COMPOUND)
                     for ((i, subtag) in arr.withIndex()) {
                         // this is safe because otherwise we wouldn't have been able to get the list before
                         out.append(DisplayFromTag(subtag as CompoundTag))
@@ -259,6 +260,19 @@ class SpellDatum<T : Any> private constructor(val payload: T) {
                 ValidTypes.any { clazz -> clazz.isAssignableFrom(checkee.javaClass) }
             }
 
+        @JvmStatic
+        fun GetTagName(datumType: DatumType): String {
+            return when (datumType) {
+                DatumType.ENTITY -> TAG_ENTITY
+                DatumType.WIDGET -> TAG_WIDGET
+                DatumType.LIST -> TAG_LIST
+                DatumType.PATTERN -> TAG_PATTERN
+                DatumType.DOUBLE -> TAG_DOUBLE
+                DatumType.VEC -> TAG_VEC3
+                DatumType.OTHER, DatumType.EMPTY -> ""
+            }
+        }
+
 
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/SpellOperator.kt b/src/main/java/at/petrak/hexcasting/api/spell/SpellOperator.kt
index 03ed2fe5..aedfea12 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/SpellOperator.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/SpellOperator.kt
@@ -7,30 +7,32 @@ import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
 interface SpellOperator : Operator {
     val argc: Int
 
-    val hasCastingSound: Boolean get() = true
+    fun hasCastingSound(ctx: CastingContext): Boolean = true
+
+    fun awardsCastingStat(ctx: CastingContext): Boolean = true
 
     fun execute(
         args: List<SpellDatum<*>>,
         ctx: CastingContext
     ): Triple<RenderedSpell, Int, List<ParticleSpray>>?
 
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (this.argc > stack.size)
             throw MishapNotEnoughArgs(this.argc, stack.size)
         val args = stack.takeLast(this.argc)
         for (_i in 0 until this.argc) stack.removeLast()
-        val executeResult = this.execute(args, ctx) ?: return OperationResult(stack, listOf())
+        val executeResult = this.execute(args, ctx) ?: return OperationResult(stack, local, listOf())
         val (spell, mana, particles) = executeResult
 
         val sideEffects = mutableListOf(
             OperatorSideEffect.ConsumeMana(mana),
-            OperatorSideEffect.AttemptSpell(spell, this.isGreat, this.hasCastingSound)
+            OperatorSideEffect.AttemptSpell(spell, this.isGreat, this.hasCastingSound(ctx), this.awardsCastingStat(ctx))
         )
         for (spray in particles) {
             sideEffects.add(OperatorSideEffect.Particles(spray))
         }
 
-        return OperationResult(stack, sideEffects)
+        return OperationResult(stack, local, sideEffects)
     }
 
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt b/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt
index a28ec029..a6331c04 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/casting/CastingHarness.kt
@@ -16,9 +16,12 @@ import at.petrak.hexcasting.api.spell.Widget
 import at.petrak.hexcasting.api.spell.math.HexPattern
 import at.petrak.hexcasting.api.spell.mishaps.Mishap
 import at.petrak.hexcasting.api.spell.mishaps.MishapDisallowedSpell
+import at.petrak.hexcasting.api.spell.mishaps.MishapError
 import at.petrak.hexcasting.api.spell.mishaps.MishapTooManyCloseParens
 import at.petrak.hexcasting.api.utils.HexDamageSources
 import at.petrak.hexcasting.api.utils.ManaHelper
+import at.petrak.hexcasting.api.utils.asCompound
+import at.petrak.hexcasting.api.utils.getList
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.nbt.ListTag
 import net.minecraft.nbt.Tag
@@ -34,6 +37,7 @@ import kotlin.math.min
  */
 class CastingHarness private constructor(
     var stack: MutableList<SpellDatum<*>>,
+    var localIota: SpellDatum<*>,
     var parenCount: Int,
     var parenthesized: List<HexPattern>,
     var escapeNext: Boolean,
@@ -45,7 +49,7 @@ class CastingHarness private constructor(
     constructor(
         ctx: CastingContext,
         prepackagedColorizer: FrozenColorizer? = null
-    ) : this(mutableListOf(), 0, mutableListOf(), false, ctx, prepackagedColorizer)
+    ) : this(mutableListOf(), SpellDatum.make(Widget.NULL), 0, mutableListOf(), false, ctx, prepackagedColorizer)
 
     /**
      * Given a pattern, do all the updating/side effects/etc required.
@@ -81,7 +85,8 @@ class CastingHarness private constructor(
             if (HexConfig.Server.actionDenyList.get().contains(operatorIdPair.second.toString())) {
                 throw MishapDisallowedSpell()
             }
-            val (stack2, sideEffectsUnmut) = operatorIdPair.first.operate(this.stack.toMutableList(), this.ctx)
+            val (stack2, local2, sideEffectsUnmut) = operatorIdPair.first.operate(this.stack.toMutableList(), this.localIota, this.ctx)
+            this.localIota = local2
             // Stick a poofy particle effect at the caster position
             val sideEffects = sideEffectsUnmut.toMutableList()
             if (this.ctx.spellCircle == null)
@@ -108,6 +113,12 @@ class CastingHarness private constructor(
                 this.getFunctionalData(),
                 listOf(OperatorSideEffect.DoMishap(mishap, Mishap.Context(newPat, operatorIdPair?.second))),
             )
+        } catch (exception: Exception) {
+            exception.printStackTrace()
+            return CastResult(
+                this.getFunctionalData(),
+                listOf(OperatorSideEffect.DoMishap(MishapError(exception), Mishap.Context(newPat, operatorIdPair?.second)))
+            )
         }
     }
 
@@ -274,8 +285,8 @@ class CastingHarness private constructor(
             }
         } else {
             val casterStack = this.ctx.caster.getItemInHand(this.ctx.castingHand)
-            val casterManaHolder = casterStack.getCapability(HexCapabilities.MANA).resolve()
-            val casterSpellHolder = casterStack.getCapability(HexCapabilities.SPELL).resolve()
+            val casterManaHolder = HexCapabilities.getCapability(casterStack, HexCapabilities.MANA)
+            val casterSpellHolder = HexCapabilities.getCapability(casterStack, HexCapabilities.SPELL)
             val ipsCanDrawFromInv = if (casterSpellHolder.isPresent) {
                 if (casterManaHolder.isPresent) {
                     val manaAvailable = casterManaHolder.get().mana
@@ -340,6 +351,8 @@ class CastingHarness private constructor(
             stackTag.add(datum.serializeToNBT())
         out.put(TAG_STACK, stackTag)
 
+        out.put(TAG_LOCAL, localIota.serializeToNBT())
+
         out.putInt(TAG_PAREN_COUNT, this.parenCount)
         out.putBoolean(TAG_ESCAPE_NEXT, this.escapeNext)
 
@@ -358,25 +371,29 @@ class CastingHarness private constructor(
 
     companion object {
         const val TAG_STACK = "stack"
+        const val TAG_LOCAL = "local"
         const val TAG_PAREN_COUNT = "open_parens"
         const val TAG_PARENTHESIZED = "parenthesized"
         const val TAG_ESCAPE_NEXT = "escape_next"
         const val TAG_PREPACKAGED_COLORIZER = "prepackaged_colorizer"
 
         @JvmStatic
-        fun DeserializeFromNBT(nbt: Tag, ctx: CastingContext): CastingHarness {
+        fun DeserializeFromNBT(nbt: CompoundTag, ctx: CastingContext): CastingHarness {
             return try {
                 val stack = mutableListOf<SpellDatum<*>>()
-                val stackTag = (nbt as CompoundTag).getList(TAG_STACK, Tag.TAG_COMPOUND.toInt())
+                val stackTag = nbt.getList(TAG_STACK, Tag.TAG_COMPOUND)
                 for (subtag in stackTag) {
-                    val datum = SpellDatum.DeserializeFromNBT(subtag as CompoundTag, ctx.world)
+                    val datum = SpellDatum.DeserializeFromNBT(subtag.asCompound, ctx.world)
                     stack.add(datum)
                 }
 
+                val localTag = nbt.getCompound(TAG_LOCAL)
+                val localIota = SpellDatum.DeserializeFromNBT(localTag, ctx.world)
+
                 val parenthesized = mutableListOf<HexPattern>()
-                val parenTag = nbt.getList(TAG_PARENTHESIZED, Tag.TAG_COMPOUND.toInt())
+                val parenTag = nbt.getList(TAG_PARENTHESIZED, Tag.TAG_COMPOUND)
                 for (subtag in parenTag) {
-                    parenthesized.add(HexPattern.DeserializeFromNBT(subtag as CompoundTag))
+                    parenthesized.add(HexPattern.DeserializeFromNBT(subtag.asCompound))
                 }
 
                 val parenCount = nbt.getInt(TAG_PAREN_COUNT)
@@ -388,7 +405,7 @@ class CastingHarness private constructor(
                     null
                 }
 
-                CastingHarness(stack, parenCount, parenthesized, escapeNext, ctx, colorizer)
+                CastingHarness(stack, localIota, parenCount, parenthesized, escapeNext, ctx, colorizer)
             } catch (exn: Exception) {
                 CastingHarness(ctx)
             }
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/casting/OperatorSideEffect.kt b/src/main/java/at/petrak/hexcasting/api/spell/casting/OperatorSideEffect.kt
index de533e50..71a0b6eb 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/casting/OperatorSideEffect.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/casting/OperatorSideEffect.kt
@@ -22,7 +22,7 @@ sealed class OperatorSideEffect {
     abstract fun performEffect(harness: CastingHarness): Boolean
 
     /** Try to cast a spell  */
-    data class AttemptSpell(val spell: RenderedSpell, val isGreat: Boolean, val hasCastingSound: Boolean = true) : OperatorSideEffect() {
+    data class AttemptSpell(val spell: RenderedSpell, val isGreat: Boolean, val hasCastingSound: Boolean = true, val awardStat: Boolean = true) : OperatorSideEffect() {
         override fun performEffect(harness: CastingHarness): Boolean {
             return if (this.isGreat && !harness.ctx.isCasterEnlightened) {
                 harness.ctx.caster.sendMessage(
@@ -33,7 +33,8 @@ sealed class OperatorSideEffect {
                 true
             } else {
                 this.spell.cast(harness.ctx)
-                harness.ctx.caster.awardStat(HexStatistics.SPELLS_CAST)
+                if (awardStat)
+                    harness.ctx.caster.awardStat(HexStatistics.SPELLS_CAST)
                 false
             }
         }
@@ -53,8 +54,7 @@ sealed class OperatorSideEffect {
         }
     }
 
-    data class Particles(val spray: ParticleSpray) :
-        OperatorSideEffect() {
+    data class Particles(val spray: ParticleSpray) : OperatorSideEffect() {
         override fun performEffect(harness: CastingHarness): Boolean {
             this.spray.sprayParticles(harness.ctx.world, harness.getColorizer())
 
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt
index 647ddd10..3527a804 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapAlreadyBrainswept.kt
@@ -14,7 +14,7 @@ class MishapAlreadyBrainswept(val villager: Villager) : Mishap() {
         dyeColor(DyeColor.GREEN)
 
     override fun execute(ctx: CastingContext, errorCtx: Context, stack: MutableList<SpellDatum<*>>) {
-        villager.hurt(HexDamageSources.OVERCAST, villager.health)
+        villager.hurt(HexDamageSources.overcastDamageFrom(ctx.caster), villager.health)
     }
 
     override fun particleSpray(ctx: CastingContext): ParticleSpray {
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt
index 80dd1bcf..a2f6c2be 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBlock.kt
@@ -1,9 +1,9 @@
 package at.petrak.hexcasting.api.spell.mishaps
 
+import at.petrak.hexcasting.api.misc.FrozenColorizer
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.misc.FrozenColorizer
 import net.minecraft.core.BlockPos
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.TranslatableComponent
@@ -16,7 +16,7 @@ class MishapBadBlock(val pos: BlockPos, val expected: Component) : Mishap() {
         dyeColor(DyeColor.LIME)
 
     override fun execute(ctx: CastingContext, errorCtx: Context, stack: MutableList<SpellDatum<*>>) {
-        ctx.world.explode(null, pos.x + 0.5, pos.y + 0.5, pos.z + 0.5, 2f, Explosion.BlockInteraction.NONE)
+        ctx.world.explode(null, pos.x + 0.5, pos.y + 0.5, pos.z + 0.5, 0.25f, Explosion.BlockInteraction.NONE)
     }
 
     override fun particleSpray(ctx: CastingContext): ParticleSpray {
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt
index f57a59ce..2d440533 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadBrainsweep.kt
@@ -1,9 +1,9 @@
 package at.petrak.hexcasting.api.spell.mishaps
 
+import at.petrak.hexcasting.api.misc.FrozenColorizer
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.misc.FrozenColorizer
 import at.petrak.hexcasting.api.utils.HexDamageSources
 import net.minecraft.core.BlockPos
 import net.minecraft.network.chat.Component
@@ -16,7 +16,7 @@ class MishapBadBrainsweep(val villager: Villager, val pos: BlockPos) : Mishap()
         dyeColor(DyeColor.GREEN)
 
     override fun execute(ctx: CastingContext, errorCtx: Context, stack: MutableList<SpellDatum<*>>) {
-        villager.hurt(HexDamageSources.OVERCAST, villager.health)
+        villager.hurt(HexDamageSources.overcastDamageFrom(ctx.caster), villager.health)
     }
 
     override fun particleSpray(ctx: CastingContext): ParticleSpray {
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadItem.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadItem.kt
index 2e7d8aab..cbf7568f 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadItem.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapBadItem.kt
@@ -13,14 +13,14 @@ class MishapBadItem(val item: ItemEntity, val wanted: Component) : Mishap() {
         dyeColor(DyeColor.BROWN)
 
     override fun execute(ctx: CastingContext, errorCtx: Context, stack: MutableList<SpellDatum<*>>) {
-        item.deltaMovement = item.deltaMovement.add((Math.random() - 0.5) * 0.05, 1.0, (Math.random() - 0.5) * 0.05)
+        item.deltaMovement = item.deltaMovement.add((Math.random() - 0.5) * 0.05, 0.75, (Math.random() - 0.5) * 0.05)
     }
 
     override fun errorMessage(ctx: CastingContext, errorCtx: Context): Component {
         return if (item.item.isEmpty)
             error("no_item", actionName(errorCtx.action), wanted)
         else
-            error("bad_item", actionName(errorCtx.action), wanted, item.item)
+            error("bad_item", actionName(errorCtx.action), wanted, item.item.count, item.item.displayName)
     }
 
     companion object {
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapError.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapError.kt
new file mode 100644
index 00000000..0b9b55ff
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapError.kt
@@ -0,0 +1,18 @@
+package at.petrak.hexcasting.api.spell.mishaps
+
+import at.petrak.hexcasting.api.misc.FrozenColorizer
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import net.minecraft.network.chat.Component
+import net.minecraft.world.item.DyeColor
+
+class MishapError(val exception: Exception) : Mishap() {
+    override fun accentColor(ctx: CastingContext, errorCtx: Context): FrozenColorizer =
+        dyeColor(DyeColor.BLACK)
+
+    override fun execute(ctx: CastingContext, errorCtx: Context, stack: MutableList<SpellDatum<*>>) {
+    }
+
+    override fun errorMessage(ctx: CastingContext, errorCtx: Context): Component =
+        error("unknown", actionName(errorCtx.action), exception)
+}
diff --git a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapInvalidIota.kt b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapInvalidIota.kt
index 892c5024..1ec27261 100644
--- a/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapInvalidIota.kt
+++ b/src/main/java/at/petrak/hexcasting/api/spell/mishaps/MishapInvalidIota.kt
@@ -1,9 +1,9 @@
 package at.petrak.hexcasting.api.spell.mishaps
 
-import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.spell.Widget
 import at.petrak.hexcasting.api.misc.FrozenColorizer
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.math.HexPattern
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.TranslatableComponent
@@ -53,7 +53,7 @@ class MishapInvalidIota(
 
                 ItemEntity::class.java.isAssignableFrom(cls) -> "entity.item"
                 Player::class.java.isAssignableFrom(cls) -> "entity.player"
-                Villager::class.java.isAssignableFrom(cls) -> "entity.player"
+                Villager::class.java.isAssignableFrom(cls) -> "entity.villager"
                 LivingEntity::class.java.isAssignableFrom(cls) -> "entity.living"
                 Entity::class.java.isAssignableFrom(cls) -> "entity"
 
diff --git a/src/main/java/at/petrak/hexcasting/api/utils/HexDamageSources.java b/src/main/java/at/petrak/hexcasting/api/utils/HexDamageSources.java
index ba0c8bb3..ed460b62 100644
--- a/src/main/java/at/petrak/hexcasting/api/utils/HexDamageSources.java
+++ b/src/main/java/at/petrak/hexcasting/api/utils/HexDamageSources.java
@@ -1,10 +1,19 @@
 package at.petrak.hexcasting.api.utils;
 
 import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.damagesource.EntityDamageSource;
+import net.minecraft.world.entity.Entity;
 
 public final class HexDamageSources {
     public static final DamageSource OVERCAST = new DamageSource("hexcasting.overcast")
         .bypassArmor()
         .bypassMagic()
         .setMagic();
+
+    public static DamageSource overcastDamageFrom(Entity cause) {
+        return new EntityDamageSource("hexcasting.overcast", cause)
+            .bypassArmor()
+            .bypassMagic()
+            .setMagic();
+    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt b/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt
index ac1134bd..22234e89 100644
--- a/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt
+++ b/src/main/java/at/petrak/hexcasting/api/utils/HexUtils.kt
@@ -18,7 +18,7 @@ object HexUtils {
         LongArrayTag(longArrayOf(this.x.toRawBits(), this.y.toRawBits(), this.z.toRawBits()))
 
     @JvmStatic
-    fun DeserializeVec3FromNBT(tag: LongArray): Vec3 =
+    fun DeserializeVec3FromNBT(tag: LongArray): Vec3 = if (tag.size != 3) Vec3.ZERO else
         Vec3(
             Double.fromBits(tag[0]),
             Double.fromBits(tag[1]),
@@ -30,7 +30,7 @@ object HexUtils {
         LongArrayTag(longArrayOf(this.x.toDouble().toRawBits(), this.y.toDouble().toRawBits()))
 
     @JvmStatic
-    fun DeserializeVec2FromNBT(tag: LongArray): Vec2 =
+    fun DeserializeVec2FromNBT(tag: LongArray): Vec2 = if (tag.size != 2) Vec2.ZERO else
         Vec2(
             Double.fromBits(tag[0]).toFloat(),
             Double.fromBits(tag[1]).toFloat(),
diff --git a/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt b/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt
index ca0244e3..d75ac01d 100644
--- a/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt
+++ b/src/main/java/at/petrak/hexcasting/api/utils/ManaHelper.kt
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.api.utils
 
 import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.cap.ManaHolder
 import net.minecraft.util.Mth
 import net.minecraft.world.item.ItemStack
 import kotlin.math.roundToInt
@@ -8,7 +9,7 @@ import kotlin.math.roundToInt
 object ManaHelper {
     @JvmStatic
     fun isManaItem(stack: ItemStack): Boolean {
-        return stack.getCapability(HexCapabilities.MANA).map { it.canProvide() }.orElse(false) && extractMana(stack, simulate = true) > 0
+        return HexCapabilities.getCapability(stack, HexCapabilities.MANA).map(ManaHolder::canProvide).orElse(false) && extractMana(stack, simulate = true) > 0
     }
 
     /**
@@ -22,7 +23,7 @@ object ManaHelper {
     @JvmStatic
     @JvmOverloads
     fun extractMana(stack: ItemStack, cost: Int = -1, drainForBatteries: Boolean = false, simulate: Boolean = false): Int {
-        val manaCapability = stack.getCapability(HexCapabilities.MANA).resolve()
+        val manaCapability = HexCapabilities.getCapability(stack, HexCapabilities.MANA)
 
         if (!manaCapability.isPresent)
             return 0
@@ -39,8 +40,8 @@ object ManaHelper {
      * Sorted from least important to most important
      */
     fun compare(astack: ItemStack, bstack: ItemStack): Int {
-        val aMana = astack.getCapability(HexCapabilities.MANA).resolve()
-        val bMana = bstack.getCapability(HexCapabilities.MANA).resolve()
+        val aMana = HexCapabilities.getCapability(astack, HexCapabilities.MANA)
+        val bMana = HexCapabilities.getCapability(bstack, HexCapabilities.MANA)
 
         return if (astack.item != bstack.item) {
             aMana.map { it.consumptionPriority }.orElse(0) - bMana.map { it.consumptionPriority }.orElse(0)
diff --git a/src/main/java/at/petrak/hexcasting/api/utils/NBTHelper.kt b/src/main/java/at/petrak/hexcasting/api/utils/NBTHelper.kt
new file mode 100644
index 00000000..fc5dc92d
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/api/utils/NBTHelper.kt
@@ -0,0 +1,237 @@
+@file:JvmName("NBTHelper")
+package at.petrak.hexcasting.api.utils
+
+import net.minecraft.nbt.*
+import net.minecraft.world.item.ItemStack
+import java.util.*
+
+private inline fun <T: Any, K, E> T?.getIf(key: K, predicate: T?.(K) -> Boolean, get: T.(K) -> E): E? =
+    getIf(key, predicate, get, null)
+
+private inline fun <T: Any, K, E> T?.getIf(key: K, predicate: T?.(K) -> Boolean, get: T.(K) -> E, default: E): E {
+    if (this != null && predicate(key))
+        return get(key)
+    return default
+}
+
+// ======================================================================================================== CompoundTag
+
+// Checks for containment
+
+fun CompoundTag?.hasNumber(key: String) = contains(key, Tag.TAG_ANY_NUMERIC)
+fun CompoundTag?.hasByte(key: String) = contains(key, Tag.TAG_BYTE)
+fun CompoundTag?.hasShort(key: String) = contains(key, Tag.TAG_SHORT)
+fun CompoundTag?.hasInt(key: String) = contains(key, Tag.TAG_INT)
+fun CompoundTag?.hasLong(key: String) = contains(key, Tag.TAG_LONG)
+fun CompoundTag?.hasFloat(key: String) = contains(key, Tag.TAG_FLOAT)
+fun CompoundTag?.hasDouble(key: String) = contains(key, Tag.TAG_DOUBLE)
+fun CompoundTag?.hasLongArray(key: String) = contains(key, Tag.TAG_LONG_ARRAY)
+fun CompoundTag?.hasIntArray(key: String) = contains(key, Tag.TAG_INT_ARRAY)
+fun CompoundTag?.hasByteArray(key: String) = contains(key, Tag.TAG_BYTE_ARRAY)
+fun CompoundTag?.hasCompound(key: String) = contains(key, Tag.TAG_COMPOUND)
+fun CompoundTag?.hasString(key: String) = contains(key, Tag.TAG_STRING)
+fun CompoundTag?.hasList(key: String) = contains(key, Tag.TAG_LIST)
+fun CompoundTag?.hasList(key: String, objType: Int) = hasList(key, objType.toByte())
+fun CompoundTag?.hasList(key: String, objType: Byte) = hasList(key) && (get(key) as ListTag).elementType == objType
+fun CompoundTag?.hasUUID(key: String) = this != null && hasUUID(key)
+
+fun CompoundTag?.contains(key: String, id: Byte) = contains(key, id.toInt())
+fun CompoundTag?.contains(key: String, id: Int) = this != null && contains(key, id)
+fun CompoundTag?.contains(key: String) = this != null && contains(key)
+
+// Puts
+
+fun CompoundTag?.putBoolean(key: String, value: Boolean) = this?.putBoolean(key, value)
+fun CompoundTag?.putByte(key: String, value: Byte) = this?.putByte(key, value)
+fun CompoundTag?.putShort(key: String, value: Short) = this?.putShort(key, value)
+fun CompoundTag?.putInt(key: String, value: Int) = this?.putInt(key, value)
+fun CompoundTag?.putLong(key: String, value: Long) = this?.putLong(key, value)
+fun CompoundTag?.putFloat(key: String, value: Float) = this?.putFloat(key, value)
+fun CompoundTag?.putDouble(key: String, value: Double) = this?.putDouble(key, value)
+fun CompoundTag?.putLongArray(key: String, value: LongArray) = this?.putLongArray(key, value)
+fun CompoundTag?.putIntArray(key: String, value: IntArray) = this?.putIntArray(key, value)
+fun CompoundTag?.putByteArray(key: String, value: ByteArray) = this?.putByteArray(key, value)
+fun CompoundTag?.putCompound(key: String, value: CompoundTag) = put(key, value)
+fun CompoundTag?.putString(key: String, value: String) = this?.putString(key, value)
+fun CompoundTag?.putList(key: String, value: ListTag) = put(key, value)
+fun CompoundTag?.putUUID(key: String, value: UUID) = this?.putUUID(key, value)
+fun CompoundTag?.put(key: String, value: Tag) = this?.put(key, value)
+
+// Remove
+
+fun CompoundTag?.remove(key: String) = this?.remove(key)
+
+// Gets
+
+@JvmOverloads
+fun CompoundTag?.getBoolean(key: String, defaultExpected: Boolean = false) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getBoolean, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getByte(key: String, defaultExpected: Byte = 0) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getByte, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getShort(key: String, defaultExpected: Short = 0) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getShort, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getInt(key: String, defaultExpected: Int = 0) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getInt, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getLong(key: String, defaultExpected: Long = 0) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getLong, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getFloat(key: String, defaultExpected: Float = 0f) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getFloat, defaultExpected)
+@JvmOverloads
+fun CompoundTag?.getDouble(key: String, defaultExpected: Double = 0.0) = getIf(key, CompoundTag?::hasNumber, CompoundTag::getDouble, defaultExpected)
+
+fun CompoundTag?.getLongArray(key: String) = getIf(key, CompoundTag?::hasLongArray, CompoundTag::getLongArray)
+fun CompoundTag?.getIntArray(key: String) = getIf(key, CompoundTag?::hasIntArray, CompoundTag::getIntArray)
+fun CompoundTag?.getByteArray(key: String) = getIf(key, CompoundTag?::hasByteArray, CompoundTag::getByteArray)
+fun CompoundTag?.getCompound(key: String): CompoundTag? = getIf(key, CompoundTag?::hasCompound, CompoundTag::getCompound)
+fun CompoundTag?.getString(key: String) = getIf(key, CompoundTag?::hasString, CompoundTag::getString)
+fun CompoundTag?.getList(key: String, objType: Byte) = getList(key, objType.toInt())
+fun CompoundTag?.getList(key: String, objType: Int) = getIf(key, { hasList(key, objType) }) { getList(it, objType) }
+fun CompoundTag?.getUUID(key: String) = getIf(key, CompoundTag?::hasUUID, CompoundTag::getUUID)
+fun CompoundTag?.get(key: String) = getIf(key, CompoundTag?::contains, CompoundTag::get)
+
+@JvmSynthetic
+@JvmName("getListByByte")
+fun CompoundTag.getList(key: String, objType: Byte): ListTag = getList(key, objType.toInt())
+
+// Get-or-create
+
+fun CompoundTag.getOrCreateCompound(key: String) = getCompound(key) ?: CompoundTag().also { putCompound(key, this) }
+
+// ================================================================================================================ Tag
+
+val Tag.asBoolean get() = asByte == 0.toByte()
+val Tag.asByte get() = (this as? NumericTag)?.asByte ?: 0.toByte()
+val Tag.asShort get() = (this as? NumericTag)?.asShort ?: 0.toShort()
+val Tag.asInt get() = (this as? NumericTag)?.asInt ?: 0
+val Tag.asLong get() = (this as? NumericTag)?.asLong ?: 0L
+val Tag.asFloat get() = (this as? NumericTag)?.asFloat ?: 0F
+val Tag.asDouble get() = (this as? NumericTag)?.asDouble ?: 0.0
+
+val Tag.asLongArray: LongArray
+    get() = when (this) {
+        is LongArrayTag -> this.asLongArray
+        is IntArrayTag -> {
+            val array = this.asIntArray
+            LongArray(array.size) { array[it].toLong() }
+        }
+        is ByteArrayTag -> {
+            val array = this.asByteArray
+            LongArray(array.size) { array[it].toLong() }
+        }
+        else -> LongArray(0)
+    }
+
+val Tag.asIntArray: IntArray
+    get() = when (this) {
+        is IntArrayTag -> this.asIntArray
+        is LongArrayTag -> {
+            val array = this.asLongArray
+            IntArray(array.size) { array[it].toInt() }
+        }
+        is ByteArrayTag -> {
+            val array = this.asByteArray
+            IntArray(array.size) { array[it].toInt() }
+        }
+        else -> IntArray(0)
+    }
+
+val Tag.asByteArray: ByteArray
+    get() = when (this) {
+        is ByteArrayTag -> this.asByteArray
+        is LongArrayTag -> {
+            val array = this.asLongArray
+            ByteArray(array.size) { array[it].toByte() }
+        }
+        is IntArrayTag -> {
+            val array = this.asIntArray
+            ByteArray(array.size) { array[it].toByte() }
+        }
+        else -> ByteArray(0)
+    }
+
+val Tag.asCompound get() = this as? CompoundTag ?: CompoundTag()
+// asString is defined in Tag
+val Tag.asList get() = this as? ListTag ?: ListTag()
+val Tag.asUUID: UUID get() = if (this is IntArrayTag && this.size == 4) NbtUtils.loadUUID(this) else UUID(0, 0)
+
+// ========================================================================================================== ItemStack
+
+// Checks for containment
+
+fun ItemStack.hasNumber(key: String) = tag.hasNumber(key)
+fun ItemStack.hasByte(key: String) = tag.hasByte(key)
+fun ItemStack.hasShort(key: String) = tag.hasShort(key)
+fun ItemStack.hasInt(key: String) = tag.hasInt(key)
+fun ItemStack.hasLong(key: String) = tag.hasLong(key)
+fun ItemStack.hasFloat(key: String) = tag.hasFloat(key)
+fun ItemStack.hasDouble(key: String) = tag.hasDouble(key)
+fun ItemStack.hasLongArray(key: String) = tag.hasLongArray(key)
+fun ItemStack.hasIntArray(key: String) = tag.hasIntArray(key)
+fun ItemStack.hasByteArray(key: String) = tag.hasByteArray(key)
+fun ItemStack.hasCompound(key: String) = tag.hasCompound(key)
+fun ItemStack.hasString(key: String) = tag.hasString(key)
+fun ItemStack.hasList(key: String) = tag.hasList(key)
+fun ItemStack.hasList(key: String, objType: Int) = tag.hasList(key, objType)
+fun ItemStack.hasList(key: String, objType: Byte) = tag.hasList(key, objType)
+fun ItemStack.hasUUID(key: String) = tag.hasUUID(key)
+
+@JvmName("contains")
+fun ItemStack.containsTag(key: String) = tag.contains(key)
+@JvmName("contains")
+fun ItemStack.containsTag(key: String, id: Byte) = tag.contains(key, id)
+@JvmName("contains")
+fun ItemStack.containsTag(key: String, id: Int) = tag.contains(key, id)
+
+// Puts
+
+fun ItemStack.putBoolean(key: String, value: Boolean) = orCreateTag.putBoolean(key, value)
+fun ItemStack.putByte(key: String, value: Byte) = orCreateTag.putByte(key, value)
+fun ItemStack.putShort(key: String, value: Short) = orCreateTag.putShort(key, value)
+fun ItemStack.putInt(key: String, value: Int) = orCreateTag.putInt(key, value)
+fun ItemStack.putLong(key: String, value: Long) = orCreateTag.putLong(key, value)
+fun ItemStack.putFloat(key: String, value: Float) = orCreateTag.putFloat(key, value)
+fun ItemStack.putDouble(key: String, value: Double) = orCreateTag.putDouble(key, value)
+
+fun ItemStack.putLongArray(key: String, value: LongArray) = orCreateTag.putLongArray(key, value)
+fun ItemStack.putIntArray(key: String, value: IntArray) = orCreateTag.putIntArray(key, value)
+fun ItemStack.putByteArray(key: String, value: ByteArray) = orCreateTag.putByteArray(key, value)
+fun ItemStack.putCompound(key: String, value: CompoundTag) = putTag(key, value)
+fun ItemStack.putString(key: String, value: String) = orCreateTag.putString(key, value)
+fun ItemStack.putList(key: String, value: ListTag) = putTag(key, value)
+fun ItemStack.putUUID(key: String, value: UUID) = orCreateTag.putUUID(key, value)
+@JvmName("put")
+fun ItemStack.putTag(key: String, value: Tag) = orCreateTag.put(key, value)
+
+// Remove
+
+fun ItemStack.remove(key: String) = removeTagKey(key)
+
+// Gets
+
+@JvmOverloads
+fun ItemStack.getBoolean(key: String, defaultExpected: Boolean = false) = tag.getBoolean(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getByte(key: String, defaultExpected: Byte = 0) = tag.getByte(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getShort(key: String, defaultExpected: Short = 0) = tag.getShort(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getInt(key: String, defaultExpected: Int = 0) = tag.getInt(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getLong(key: String, defaultExpected: Long = 0) = tag.getLong(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getFloat(key: String, defaultExpected: Float = 0f) = tag.getFloat(key, defaultExpected)
+@JvmOverloads
+fun ItemStack.getDouble(key: String, defaultExpected: Double = 0.0) = tag.getDouble(key, defaultExpected)
+
+fun ItemStack.getLongArray(key: String) = tag.getLongArray(key)
+fun ItemStack.getIntArray(key: String) = tag.getIntArray(key)
+fun ItemStack.getByteArray(key: String) = tag.getByteArray(key)
+fun ItemStack.getCompound(key: String) = tag.getCompound(key)
+fun ItemStack.getString(key: String) = tag.getString(key)
+fun ItemStack.getList(key: String, objType: Int) = tag.getList(key, objType)
+fun ItemStack.getUUID(key: String) = tag.getUUID(key)
+@JvmName("get")
+fun ItemStack.getTag(key: String) = tag.get(key)
+
+// Get-or-create
+
+fun ItemStack.getOrCreateCompound(key: String): CompoundTag = getOrCreateTagElement(key)
diff --git a/src/main/java/at/petrak/hexcasting/client/ClientTickCounter.java b/src/main/java/at/petrak/hexcasting/client/ClientTickCounter.java
index 7ca571e7..6b5ed7ae 100644
--- a/src/main/java/at/petrak/hexcasting/client/ClientTickCounter.java
+++ b/src/main/java/at/petrak/hexcasting/client/ClientTickCounter.java
@@ -3,16 +3,32 @@ package at.petrak.hexcasting.client;
 import net.minecraftforge.event.TickEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 
-// I can't find a better way to do this :(
 public class ClientTickCounter {
-    private static long tickCount = 0;
+    public static long ticksInGame = 0L;
+    public static float partialTicks = 0.0F;
+    public static float delta = 0.0F;
+    public static float total = 0.0F;
 
     @SubscribeEvent
-    public static void onTick(TickEvent.ClientTickEvent evt) {
-        tickCount++;
+    public static void onRenderTick(TickEvent.RenderTickEvent evt) {
+        if (evt.phase == TickEvent.Phase.START) {
+            partialTicks = evt.renderTickTime;
+        } else {
+            calcDelta();
+        }
+    }
+    @SubscribeEvent
+    public static void onTickEnd(TickEvent.ClientTickEvent evt) {
+        if (evt.phase == TickEvent.Phase.END) {
+            ++ticksInGame;
+            partialTicks = 0.0F;
+            calcDelta();
+        }
     }
 
-    public static long getTickCount() {
-        return tickCount;
+    private static void calcDelta() {
+        float oldTotal = total;
+        total = (float)ticksInGame + partialTicks;
+        delta = total - oldTotal;
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java b/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java
index 77ddf616..92e5c6e6 100644
--- a/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java
+++ b/src/main/java/at/petrak/hexcasting/client/HexAdditionalRenderers.java
@@ -1,30 +1,37 @@
 package at.petrak.hexcasting.client;
 
 import at.petrak.hexcasting.api.client.ScryingLensOverlayRegistry;
+import at.petrak.hexcasting.api.player.HexPlayerDataHelper;
 import at.petrak.hexcasting.api.player.Sentinel;
 import at.petrak.hexcasting.common.items.HexItems;
-import at.petrak.hexcasting.api.player.HexPlayerDataHelper;
+import com.google.common.collect.Lists;
 import com.mojang.blaze3d.systems.RenderSystem;
 import com.mojang.blaze3d.vertex.DefaultVertexFormat;
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.Tesselator;
 import com.mojang.blaze3d.vertex.VertexFormat;
+import com.mojang.datafixers.util.Pair;
 import com.mojang.math.Quaternion;
 import com.mojang.math.Vector3f;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.client.renderer.GameRenderer;
 import net.minecraft.locale.Language;
+import net.minecraft.network.chat.FormattedText;
 import net.minecraft.network.chat.Style;
 import net.minecraft.util.Mth;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
 import net.minecraft.world.phys.Vec3;
 import net.minecraftforge.client.event.RenderGameOverlayEvent;
 import net.minecraftforge.client.event.RenderLevelLastEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 
+import java.util.List;
 import java.util.function.BiConsumer;
 
 public class HexAdditionalRenderers {
@@ -42,7 +49,7 @@ public class HexAdditionalRenderers {
     @SubscribeEvent
     public static void overlayGui(RenderGameOverlayEvent.Post evt) {
         if (evt.getType() == RenderGameOverlayEvent.ElementType.ALL) {
-            tryRenderScryingLensOverlay(evt.getMatrixStack(), evt.getPartialTicks());
+            tryRenderScryingLensOverlay(evt.getMatrixStack());
         }
     }
 
@@ -59,7 +66,7 @@ public class HexAdditionalRenderers {
             sentinel.position().y - playerPos.y,
             sentinel.position().z - playerPos.z);
 
-        var time = mc.level.getLevelData().getGameTime() + partialTicks;
+        var time = ClientTickCounter.total / 2;
         var bobSpeed = 1f / 20;
         var magnitude = 0.1f;
         ps.translate(0, Mth.sin(bobSpeed * time) * magnitude, 0);
@@ -148,19 +155,24 @@ public class HexAdditionalRenderers {
 
     // My internet is really shaky right now but thank god Patchi already does this exact thing
     // cause it's a dependency so i have the .class files downloaded
-    private static void tryRenderScryingLensOverlay(PoseStack ps, float partialTicks) {
+    private static void tryRenderScryingLensOverlay(PoseStack ps) {
         var mc = Minecraft.getInstance();
 
+        LocalPlayer player = mc.player;
+        ClientLevel level = mc.level;
+        if (player == null || level == null)
+            return;
+
         boolean foundLens = false;
         InteractionHand lensHand = null;
         for (var hand : InteractionHand.values()) {
-            if (mc.player.getItemInHand(hand).is(HexItems.SCRYING_LENS.get())) {
+            if (player.getItemInHand(hand).is(HexItems.SCRYING_LENS.get())) {
                 lensHand = hand;
                 foundLens = true;
                 break;
             }
         }
-        if (!foundLens && mc.player.getItemBySlot(EquipmentSlot.HEAD).is(HexItems.SCRYING_LENS.get())) {
+        if (!foundLens && player.getItemBySlot(EquipmentSlot.HEAD).is(HexItems.SCRYING_LENS.get())) {
             foundLens = true;
         }
 
@@ -169,38 +181,55 @@ public class HexAdditionalRenderers {
         }
 
         var hitRes = mc.hitResult;
-        if (hitRes instanceof BlockHitResult bhr) {
+        if (hitRes != null && hitRes.getType() == HitResult.Type.BLOCK) {
+            var bhr = (BlockHitResult) hitRes;
             var pos = bhr.getBlockPos();
-            var bs = mc.level.getBlockState(pos);
+            var bs = level.getBlockState(pos);
 
-            var lines = ScryingLensOverlayRegistry.getLines(bs, pos, mc.player, mc.level, lensHand);
-            if (lines != null) {
-                var window = mc.getWindow();
+            var lines = ScryingLensOverlayRegistry.getLines(bs, pos, player, level, bhr.getDirection(), lensHand);
+
+            int totalHeight = 8;
+            List<Pair<ItemStack, List<FormattedText>>> actualLines = Lists.newArrayList();
+
+            var window = mc.getWindow();
+            var maxWidth = (int) (window.getGuiScaledWidth() / 2f * 0.8f);
+
+            for (var pair : lines) {
+                totalHeight += mc.font.lineHeight + 6;
+                var text = pair.getSecond();
+                var textLines = mc.font.getSplitter().splitLines(text, maxWidth, Style.EMPTY);
+
+                actualLines.add(Pair.of(pair.getFirst(), textLines));
+
+                if (textLines.size() > 1) {
+                    totalHeight += mc.font.lineHeight * (textLines.size() - 1);
+                }
+            }
+
+            if (!lines.isEmpty()) {
                 var x = window.getGuiScaledWidth() / 2f + 8f;
-                var y = window.getGuiScaledHeight() / 2f;
+                var y = window.getGuiScaledHeight() / 2f - totalHeight;
                 ps.pushPose();
                 ps.translate(x, y, 0);
 
-                var maxWidth = (int) (window.getGuiScaledWidth() / 2f * 0.8f);
-
-                for (var pair : lines) {
-
+                for (var pair : actualLines) {
                     var stack = pair.getFirst();
-                    if (stack != null) {
+                    if (!stack.isEmpty()) {
                         // this draws centered in the Y ...
                         RenderLib.renderItemStackInGui(ps, pair.getFirst(), 0, 0);
                     }
-                    float tx = stack == null ? 0 : 18;
+                    float tx = stack.isEmpty() ? 0 : 18;
                     float ty = 5;
                     // but this draws where y=0 is the baseline
                     var text = pair.getSecond();
-                    var textLines = mc.font.getSplitter().splitLines(text, maxWidth, Style.EMPTY);
 
-                    for (var line : textLines) {
+                    for (var line : text) {
                         var actualLine = Language.getInstance().getVisualOrder(line);
                         mc.font.drawShadow(ps, actualLine, tx, ty, 0xffffffff);
-                        ps.translate(0, 9, 0);
+                        ps.translate(0, mc.font.lineHeight, 0);
                     }
+                    if (text.isEmpty())
+                        ps.translate(0, mc.font.lineHeight, 0);
 
                     ps.translate(0, 6, 0);
                 }
diff --git a/src/main/java/at/petrak/hexcasting/client/HexTooltips.java b/src/main/java/at/petrak/hexcasting/client/HexTooltips.java
index 5dc70ad2..513e24da 100644
--- a/src/main/java/at/petrak/hexcasting/client/HexTooltips.java
+++ b/src/main/java/at/petrak/hexcasting/client/HexTooltips.java
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.client;
 
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.client.gui.PatternTooltipGreeble;
 import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate;
 import at.petrak.hexcasting.common.items.HexItems;
@@ -8,6 +9,7 @@ import at.petrak.hexcasting.common.items.ItemSlate;
 import at.petrak.hexcasting.api.spell.math.HexPattern;
 import com.mojang.datafixers.util.Either;
 import net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent;
+import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.world.inventory.tooltip.TooltipComponent;
 import net.minecraft.world.item.ItemStack;
@@ -35,23 +37,22 @@ public class HexTooltips {
         ItemStack stack = evt.getItemStack();
         if (!stack.isEmpty()) {
             if (stack.is(HexItems.SCROLL.get())) {
-                var tag = stack.getOrCreateTag();
-                if (tag.contains(ItemScroll.TAG_PATTERN, Tag.TAG_COMPOUND)) {
-                    var pattern = HexPattern.DeserializeFromNBT(tag.getCompound(ItemScroll.TAG_PATTERN));
+                CompoundTag patternTag = NBTHelper.getCompound(stack, ItemScroll.TAG_PATTERN);
+                if (patternTag != null) {
+                    var pattern = HexPattern.DeserializeFromNBT(patternTag);
                     evt.getTooltipElements().add(Either.right(new PatternTooltipGreeble(
                         pattern,
-                        tag.contains(ItemScroll.TAG_OP_ID, Tag.TAG_STRING)
+                        NBTHelper.contains(stack, ItemScroll.TAG_OP_ID, Tag.TAG_STRING)
                             ? PatternTooltipGreeble.ANCIENT_BG : PatternTooltipGreeble.PRISTINE_BG)));
                 }
             } else if (stack.is(HexItems.SLATE.get()) && ItemSlate.hasPattern(stack)) {
-                var tag = stack.getOrCreateTag()
-                    .getCompound("BlockEntityTag")
-                    .getCompound(BlockEntitySlate.TAG_PATTERN);
-                var pattern = HexPattern.DeserializeFromNBT(tag);
-                evt.getTooltipElements().add(Either.right(new PatternTooltipGreeble(
-                    pattern,
-                    PatternTooltipGreeble.SLATE_BG)));
-
+                var tag = NBTHelper.getCompound(NBTHelper.getOrCreateCompound(stack, "BlockEntityTag"), BlockEntitySlate.TAG_PATTERN);
+                if (tag != null) {
+                    var pattern = HexPattern.DeserializeFromNBT(tag);
+                    evt.getTooltipElements().add(Either.right(new PatternTooltipGreeble(
+                        pattern,
+                        PatternTooltipGreeble.SLATE_BG)));
+                }
             }
         }
     }
diff --git a/src/main/java/at/petrak/hexcasting/client/RegisterClientStuff.java b/src/main/java/at/petrak/hexcasting/client/RegisterClientStuff.java
index 88ddada6..3c723880 100644
--- a/src/main/java/at/petrak/hexcasting/client/RegisterClientStuff.java
+++ b/src/main/java/at/petrak/hexcasting/client/RegisterClientStuff.java
@@ -5,9 +5,10 @@ import at.petrak.hexcasting.api.circle.BlockEntityAbstractImpetus;
 import at.petrak.hexcasting.api.client.ScryingLensOverlayRegistry;
 import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.item.ManaHolderItem;
-import at.petrak.hexcasting.api.mod.HexConfig;
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import at.petrak.hexcasting.api.spell.SpellDatum;
 import at.petrak.hexcasting.api.spell.Widget;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.client.be.BlockEntityAkashicBookshelfRenderer;
 import at.petrak.hexcasting.client.be.BlockEntitySlateRenderer;
 import at.petrak.hexcasting.client.entity.WallScrollRenderer;
@@ -28,64 +29,39 @@ import net.minecraft.client.renderer.ItemBlockRenderTypes;
 import net.minecraft.client.renderer.RenderType;
 import net.minecraft.client.renderer.entity.EntityRenderers;
 import net.minecraft.client.renderer.item.ItemProperties;
-import net.minecraft.network.chat.Component;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Style;
+import net.minecraft.network.chat.TextColor;
 import net.minecraft.network.chat.TextComponent;
 import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.util.Mth;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.level.block.ComparatorBlock;
-import net.minecraft.world.level.block.RepeaterBlock;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.*;
 import net.minecraft.world.level.block.state.properties.ComparatorMode;
+import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
+import net.minecraft.world.level.material.MaterialColor;
 import net.minecraftforge.client.event.EntityRenderersEvent;
 import net.minecraftforge.client.event.ParticleFactoryRegisterEvent;
 import net.minecraftforge.eventbus.api.EventPriority;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
 
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Locale;
+import java.util.function.UnaryOperator;
 
 public class RegisterClientStuff {
 
     @SubscribeEvent
     public static void init(FMLClientSetupEvent evt) {
         evt.enqueueWork(() -> {
-            for (DataHolderItem dataHolder : new DataHolderItem[]{ HexItems.FOCUS.get(), HexItems.SPELLBOOK.get() }) {
-                ItemProperties.register((Item) dataHolder, ItemFocus.DATATYPE_PRED,
-                    (stack, level, holder, holderID) -> {
-                        var datum = dataHolder.readDatumTag(stack);
-                        if (datum != null) {
-                            var typename = datum.getAllKeys().iterator().next();
-                            return switch (typename) {
-                                case SpellDatum.TAG_ENTITY -> 1f;
-                                case SpellDatum.TAG_DOUBLE -> 2f;
-                                case SpellDatum.TAG_VEC3 -> 3f;
-                                case SpellDatum.TAG_WIDGET -> 4f;
-                                case SpellDatum.TAG_LIST -> 5f;
-                                case SpellDatum.TAG_PATTERN -> 6f;
-                                default -> 0f; // uh oh
-                            };
-                        }
-                        return 0f;
-                    });
-                ItemProperties.register((Item) dataHolder, ItemFocus.SEALED_PRED,
-                    (stack, level, holder, holderID) -> dataHolder.canWrite(stack, SpellDatum.make(Widget.NULL)) ? 0f : 1f);
-            }
-            for (ItemPackagedSpell packager : new ItemPackagedSpell[]{
-                HexItems.CYPHER.get(),
-                HexItems.TRINKET.get(),
-                HexItems.ARTIFACT.get(),
-            }) {
-                ItemProperties.register(packager, ItemPackagedSpell.HAS_PATTERNS_PRED,
-                    (stack, level, holder, holderID) ->
-                        packager.getPatterns(stack) != null ? 1f : 0f
-                );
-            }
+            registerDataHolderOverrides(HexItems.FOCUS.get());
+            registerDataHolderOverrides(HexItems.SPELLBOOK.get());
+
+            registerPackagedSpellOverrides(HexItems.CYPHER.get());
+            registerPackagedSpellOverrides(HexItems.TRINKET.get());
+            registerPackagedSpellOverrides(HexItems.ARTIFACT.get());
 
             ItemProperties.register(HexItems.BATTERY.get(), ItemManaBattery.MANA_PREDICATE,
                 (stack, level, holder, holderID) -> {
@@ -96,58 +72,35 @@ public class RegisterClientStuff {
                 (stack, level, holder, holderID) -> {
                     var item = (ItemManaBattery) stack.getItem();
                     var max = item.getMaxMana(stack);
-                    return (float) Math.sqrt((float) max / HexConfig.chargedCrystalManaAmount.get() / 10);
+                    return (float) Math.sqrt((float) max / ManaConstants.CRYSTAL_UNIT / 10);
                 });
 
             ItemProperties.register(HexItems.SCROLL.get(), ItemScroll.ANCIENT_PREDICATE,
-                (stack, level, holder, holderID) -> stack.getOrCreateTag().contains(ItemScroll.TAG_OP_ID) ? 1f : 0f);
+                (stack, level, holder, holderID) -> NBTHelper.hasString(stack, ItemScroll.TAG_OP_ID) ? 1f : 0f);
 
             ItemProperties.register(HexItems.SLATE.get(), ItemSlate.WRITTEN_PRED,
                 (stack, level, holder, holderID) -> ItemSlate.hasPattern(stack) ? 1f : 0f);
 
-            var wands = new Item[]{
-                HexItems.WAND_OAK.get(),
-                HexItems.WAND_BIRCH.get(),
-                HexItems.WAND_SPRUCE.get(),
-                HexItems.WAND_JUNGLE.get(),
-                HexItems.WAND_DARK_OAK.get(),
-                HexItems.WAND_ACACIA.get(),
-                HexItems.WAND_AKASHIC.get(),
-            };
-            for (var wand : wands) {
-                ItemProperties.register(wand, ItemWand.FUNNY_LEVEL_PREDICATE,
-                    (stack, level, holder, holderID) -> {
-                        var name = stack.getHoverName().getString().toLowerCase(Locale.ROOT);
-                        if (name.contains("old")) {
-                            return 1f;
-                        } else if (name.contains("wand of the forest")) {
-                            return 2f;
-                        } else {
-                            return 0f;
-                        }
-                    });
-            }
+            registerWandOverrides(HexItems.WAND_OAK.get());
+            registerWandOverrides(HexItems.WAND_BIRCH.get());
+            registerWandOverrides(HexItems.WAND_SPRUCE.get());
+            registerWandOverrides(HexItems.WAND_JUNGLE.get());
+            registerWandOverrides(HexItems.WAND_DARK_OAK.get());
+            registerWandOverrides(HexItems.WAND_ACACIA.get());
+            registerWandOverrides(HexItems.WAND_AKASHIC.get());
 
             HexTooltips.init();
         });
 
-        for (var cutout : new Block[]{
-            HexBlocks.CONJURED_LIGHT.get(),
-            HexBlocks.CONJURED_BLOCK.get(),
-            HexBlocks.AKASHIC_DOOR.get(),
-            HexBlocks.AKASHIC_TRAPDOOR.get(),
-            HexBlocks.SCONCE.get(),
-        }) {
-            ItemBlockRenderTypes.setRenderLayer(cutout, RenderType.cutout());
-        }
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.CONJURED_LIGHT.get(), RenderType.cutout());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.CONJURED_BLOCK.get(), RenderType.cutout());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_DOOR.get(), RenderType.cutout());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_TRAPDOOR.get(), RenderType.cutout());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.SCONCE.get(), RenderType.cutout());
 
-        for (var mipped : new Block[]{
-            HexBlocks.AKASHIC_LEAVES1.get(),
-            HexBlocks.AKASHIC_LEAVES2.get(),
-            HexBlocks.AKASHIC_LEAVES3.get(),
-        }) {
-            ItemBlockRenderTypes.setRenderLayer(mipped, RenderType.cutoutMipped());
-        }
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_LEAVES1.get(), RenderType.cutoutMipped());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_LEAVES2.get(), RenderType.cutoutMipped());
+        ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_LEAVES3.get(), RenderType.cutoutMipped());
 
         ItemBlockRenderTypes.setRenderLayer(HexBlocks.AKASHIC_RECORD.get(), RenderType.translucent());
 
@@ -158,81 +111,188 @@ public class RegisterClientStuff {
 
     private static void addScryingLensStuff() {
         ScryingLensOverlayRegistry.addPredicateDisplayer(
-            (state, pos, observer, world, lensHand) -> state.getBlock() instanceof BlockAbstractImpetus,
-            (state, pos, observer, world, lensHand) -> {
+            (state, pos, observer, world, direction, lensHand) -> state.getBlock() instanceof BlockAbstractImpetus,
+            (lines, state, pos, observer, world, direction, lensHand) -> {
                 if (world.getBlockEntity(pos) instanceof BlockEntityAbstractImpetus beai) {
-                    return beai.getScryingLensOverlay(state, pos, observer, world, lensHand);
-                } else {
-                    return List.of();
+                    beai.applyScryingLensOverlay(lines, state, pos, observer, world, direction, lensHand);
                 }
             });
 
+        ScryingLensOverlayRegistry.addDisplayer(Blocks.NOTE_BLOCK,
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                int note = state.getValue(NoteBlock.NOTE);
+
+                float rCol = Math.max(0.0F, Mth.sin((note / 24F + 0.0F) * Mth.TWO_PI) * 0.65F + 0.35F);
+                float gCol = Math.max(0.0F, Mth.sin((note / 24F + 0.33333334F) * Mth.TWO_PI) * 0.65F + 0.35F);
+                float bCol = Math.max(0.0F, Mth.sin((note / 24F + 0.6666667F) * Mth.TWO_PI) * 0.65F + 0.35F);
+
+                int noteColor = 0xFF_000000 | Mth.color(rCol, gCol, bCol);
+
+                var instrument = state.getValue(NoteBlock.INSTRUMENT);
+
+                lines.add(new Pair<>(
+                    new ItemStack(Items.MUSIC_DISC_CHIRP),
+                    new TextComponent(String.valueOf(instrument.ordinal()))
+                        .withStyle(color(instrumentColor(instrument)))));
+                lines.add(new Pair<>(
+                    new ItemStack(Items.NOTE_BLOCK),
+                    new TextComponent(String.valueOf(note))
+                        .withStyle(color(noteColor))));
+            });
+
         ScryingLensOverlayRegistry.addDisplayer(HexBlocks.AKASHIC_BOOKSHELF.get(),
-            (state, pos, observer, world, lensHand) -> {
-                if (!(world.getBlockEntity(pos) instanceof BlockEntityAkashicBookshelf tile)) {
-                    return List.of();
-                }
-
-                var out = new ArrayList<Pair<ItemStack, Component>>();
-
-                var recordPos = tile.getRecordPos();
-                var pattern = tile.getPattern();
-                if (recordPos != null && pattern != null) {
-                    out.add(new Pair<>(new ItemStack(HexBlocks.AKASHIC_RECORD.get()), new TranslatableComponent(
-                        "hexcasting.tooltip.lens.akashic.bookshelf.location",
-                        recordPos.toShortString()
-                    )));
-                    if (world.getBlockEntity(recordPos) instanceof BlockEntityAkashicRecord record) {
-                        out.add(new Pair<>(new ItemStack(Items.BOOK), record.getDisplayAt(pattern)));
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                if (world.getBlockEntity(pos) instanceof BlockEntityAkashicBookshelf tile) {
+                    var recordPos = tile.getRecordPos();
+                    var pattern = tile.getPattern();
+                    if (recordPos != null && pattern != null) {
+                        lines.add(new Pair<>(new ItemStack(HexBlocks.AKASHIC_RECORD.get()), new TranslatableComponent(
+                            "hexcasting.tooltip.lens.akashic.bookshelf.location",
+                            recordPos.toShortString()
+                        )));
+                        if (world.getBlockEntity(recordPos) instanceof BlockEntityAkashicRecord record) {
+                            lines.add(new Pair<>(new ItemStack(Items.BOOK), record.getDisplayAt(pattern)));
+                        }
                     }
                 }
-
-                return out;
             });
+
         ScryingLensOverlayRegistry.addDisplayer(HexBlocks.AKASHIC_RECORD.get(),
-            ((state, pos, observer, world, lensHand) -> {
-                if (!(world.getBlockEntity(pos) instanceof BlockEntityAkashicRecord tile)) {
-                    return List.of();
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                if (world.getBlockEntity(pos) instanceof BlockEntityAkashicRecord tile) {
+                    int count = tile.getCount();
+
+                    lines.add(new Pair<>(new ItemStack(HexBlocks.AKASHIC_BOOKSHELF.get()), new TranslatableComponent(
+                        "hexcasting.tooltip.lens.akashic.record.count" + (count == 1 ? ".single" : ""),
+                        count
+                    )));
                 }
-
-                int count = tile.getCount();
-
-                return List.of(new Pair<>(new ItemStack(HexBlocks.AKASHIC_BOOKSHELF.get()), new TranslatableComponent(
-                    "hexcasting.tooltip.lens.akashic.record.count" + (count == 1 ? ".single" : ""),
-                    count
-                )));
-            }));
-
-        ScryingLensOverlayRegistry.addDisplayer(Blocks.REDSTONE_WIRE,
-            (state, pos, observer, world, lensHand) -> List.of(
-                new Pair<>(
-                    new ItemStack(Items.REDSTONE),
-                    new TextComponent(String.valueOf(state.getValue(BlockStateProperties.POWER)))
-                        .withStyle(ChatFormatting.RED))
-            ));
+            });
 
         ScryingLensOverlayRegistry.addDisplayer(Blocks.COMPARATOR,
-            (state, pos, observer, world, lensHand) -> List.of(
-                new Pair<>(
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                int comparatorValue = ScryingLensOverlayRegistry.getComparatorValue(true);
+                lines.add(new Pair<>(
                     new ItemStack(Items.REDSTONE),
-                    new TextComponent(String.valueOf(state.getDirectSignal(world, pos, state.getValue(BlockStateProperties.HORIZONTAL_FACING))))
-                        .withStyle(ChatFormatting.RED)),
-                new Pair<>(
+                    new TextComponent(comparatorValue == -1 ? "" : String.valueOf(comparatorValue))
+                        .withStyle(redstoneColor(comparatorValue))));
+
+                boolean compare = state.getValue(ComparatorBlock.MODE) == ComparatorMode.COMPARE;
+
+                lines.add(new Pair<>(
                     new ItemStack(Items.REDSTONE_TORCH),
                     new TextComponent(
-                        state.getValue(ComparatorBlock.MODE) == ComparatorMode.COMPARE ? ">" : "-")
-                        .withStyle(ChatFormatting.RED))));
+                        compare ? ">=" : "-")
+                        .withStyle(redstoneColor(compare ? 0 : 15))));
+            });
 
         ScryingLensOverlayRegistry.addDisplayer(Blocks.REPEATER,
-            (state, pos, observer, world, lensHand) -> List.of(
-                new Pair<>(
+            (lines, state, pos, observer, world, direction, lensHand) -> lines.add(new Pair<>(
+                new ItemStack(Items.CLOCK),
+                new TextComponent(String.valueOf(state.getValue(RepeaterBlock.DELAY)))
+                    .withStyle(ChatFormatting.YELLOW))));
+
+        ScryingLensOverlayRegistry.addPredicateDisplayer(
+            (state, pos, observer, world, direction, lensHand) -> state.isSignalSource() && !state.is(Blocks.COMPARATOR),
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                int signalStrength = 0;
+                if (state.getBlock() instanceof RedStoneWireBlock)
+                    signalStrength = state.getValue(RedStoneWireBlock.POWER);
+                else {
+                    for (Direction dir : Direction.values())
+                        signalStrength = Math.max(signalStrength, state.getSignal(world, pos, dir));
+                }
+
+                lines.add(0, new Pair<>(
                     new ItemStack(Items.REDSTONE),
-                    new TextComponent(String.valueOf(state.getValue(RepeaterBlock.POWERED) ? 15 : 0))
-                        .withStyle(ChatFormatting.RED)),
-                new Pair<>(
-                    new ItemStack(Items.CLOCK),
-                    new TextComponent(String.valueOf(state.getValue(RepeaterBlock.DELAY)))
-                        .withStyle(ChatFormatting.YELLOW))));
+                    new TextComponent(String.valueOf(signalStrength))
+                        .withStyle(redstoneColor(signalStrength))));
+            });
+
+        ScryingLensOverlayRegistry.addPredicateDisplayer(
+            (state, pos, observer, world, direction, lensHand) -> state.hasAnalogOutputSignal(),
+            (lines, state, pos, observer, world, direction, lensHand) -> {
+                int comparatorValue = ScryingLensOverlayRegistry.getComparatorValue(false);
+                lines.add(
+                    new Pair<>(
+                        new ItemStack(Items.COMPARATOR),
+                        new TextComponent(comparatorValue == -1 ? "" : String.valueOf(comparatorValue))
+                            .withStyle(redstoneColor(comparatorValue))));
+            });
+    }
+
+    private static UnaryOperator<Style> color(int color) {
+        return (style) -> style.withColor(TextColor.fromRgb(color));
+    }
+
+    private static UnaryOperator<Style> redstoneColor(int power) {
+        return color(RedStoneWireBlock.getColorForPower(Mth.clamp(power, 0, 15)));
+    }
+
+    private static int instrumentColor(NoteBlockInstrument instrument) {
+        return switch(instrument) {
+            case BASEDRUM -> MaterialColor.STONE.col;
+            case SNARE, XYLOPHONE, PLING -> MaterialColor.SAND.col;
+            case HAT -> MaterialColor.QUARTZ.col;
+            case BASS -> MaterialColor.WOOD.col;
+            case FLUTE -> MaterialColor.CLAY.col;
+            case BELL -> MaterialColor.GOLD.col;
+            case GUITAR -> MaterialColor.WOOL.col;
+            case CHIME -> MaterialColor.ICE.col;
+            case IRON_XYLOPHONE -> MaterialColor.METAL.col;
+            case COW_BELL -> MaterialColor.COLOR_BROWN.col;
+            case DIDGERIDOO -> MaterialColor.COLOR_ORANGE.col;
+            case BIT -> MaterialColor.EMERALD.col;
+            case BANJO -> MaterialColor.COLOR_YELLOW.col;
+            default -> -1;
+        };
+    }
+
+    private static void registerDataHolderOverrides(DataHolderItem item) {
+        ItemProperties.register((Item) item, ItemFocus.DATATYPE_PRED,
+            (stack, level, holder, holderID) -> {
+                var datum = item.readDatumTag(stack);
+                String override = NBTHelper.getString(stack, DataHolderItem.TAG_OVERRIDE_VISUALLY);
+                String typename = null;
+                if (override != null) {
+                    typename = override;
+                } else if (datum != null) {
+                    typename = datum.getAllKeys().iterator().next();
+                }
+
+                return typename == null ? 0f : switch (typename) {
+                    case SpellDatum.TAG_ENTITY -> 1f;
+                    case SpellDatum.TAG_DOUBLE -> 2f;
+                    case SpellDatum.TAG_VEC3 -> 3f;
+                    case SpellDatum.TAG_WIDGET -> 4f;
+                    case SpellDatum.TAG_LIST -> 5f;
+                    case SpellDatum.TAG_PATTERN -> 6f;
+                    default -> 0f; // uh oh
+                };
+            });
+        ItemProperties.register((Item) item, ItemFocus.SEALED_PRED,
+            (stack, level, holder, holderID) -> item.canWrite(stack, SpellDatum.make(Widget.NULL)) ? 0f : 1f);
+    }
+
+    private static void registerPackagedSpellOverrides(ItemPackagedSpell item) {
+        ItemProperties.register(item, ItemPackagedSpell.HAS_PATTERNS_PRED,
+            (stack, level, holder, holderID) ->
+                item.getPatterns(stack) != null ? 1f : 0f
+        );
+    }
+
+    private static void registerWandOverrides(ItemWand item) {
+        ItemProperties.register(item, ItemWand.FUNNY_LEVEL_PREDICATE,
+            (stack, level, holder, holderID) -> {
+                var name = stack.getHoverName().getString().toLowerCase(Locale.ROOT);
+                if (name.contains("old")) {
+                    return 1f;
+                } else if (name.contains("wand of the forest")) {
+                    return 2f;
+                } else {
+                    return 0f;
+                }
+            });
     }
 
     @SubscribeEvent(priority = EventPriority.LOWEST)
diff --git a/src/main/java/at/petrak/hexcasting/client/RenderLib.kt b/src/main/java/at/petrak/hexcasting/client/RenderLib.kt
index 036231bf..79bdf4e0 100644
--- a/src/main/java/at/petrak/hexcasting/client/RenderLib.kt
+++ b/src/main/java/at/petrak/hexcasting/client/RenderLib.kt
@@ -1,8 +1,8 @@
 package at.petrak.hexcasting.client
 
 import at.petrak.hexcasting.api.mod.HexConfig
-import at.petrak.hexcasting.api.utils.HexUtils
 import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.api.utils.HexUtils
 import com.mojang.blaze3d.systems.RenderSystem
 import com.mojang.blaze3d.vertex.DefaultVertexFormat
 import com.mojang.blaze3d.vertex.PoseStack
@@ -169,8 +169,7 @@ object RenderLib {
         if (points.isEmpty()) {
             return emptyList()
         }
-        val mc = Minecraft.getInstance()
-        val zSeed = (mc.frameTime.toDouble() + (mc.level?.levelData?.gameTime ?: 0)) * speed
+        val zSeed = (ClientTickCounter.total.toDouble()) * speed
         // Create our output list of zap points
         val zappyPts = mutableListOf(points[0])
         // For each segment in the original...
diff --git a/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt b/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt
index 9d2289be..719fe488 100644
--- a/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt
+++ b/src/main/java/at/petrak/hexcasting/client/gui/GuiSpellcasting.kt
@@ -1,23 +1,22 @@
 package at.petrak.hexcasting.client.gui
 
-import at.petrak.hexcasting.api.utils.HexUtils
-import at.petrak.hexcasting.api.utils.HexUtils.TAU
-import at.petrak.hexcasting.client.RenderLib
-import at.petrak.hexcasting.client.sound.GridSoundInstance
+import at.petrak.hexcasting.api.mod.HexItemTags
 import at.petrak.hexcasting.api.spell.casting.ControllerInfo
 import at.petrak.hexcasting.api.spell.casting.ResolvedPattern
 import at.petrak.hexcasting.api.spell.casting.ResolvedPatternValidity
+import at.petrak.hexcasting.api.spell.math.HexAngle
+import at.petrak.hexcasting.api.spell.math.HexCoord
+import at.petrak.hexcasting.api.spell.math.HexDir
+import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.api.utils.HexUtils
+import at.petrak.hexcasting.client.RenderLib
+import at.petrak.hexcasting.client.sound.GridSoundInstance
 import at.petrak.hexcasting.common.items.HexItems
 import at.petrak.hexcasting.common.items.ItemSpellbook
 import at.petrak.hexcasting.common.lib.HexSounds
 import at.petrak.hexcasting.common.network.HexMessages
 import at.petrak.hexcasting.common.network.MsgNewSpellPatternSyn
 import at.petrak.hexcasting.common.network.MsgShiftScrollSyn
-import at.petrak.hexcasting.api.spell.math.HexAngle
-import at.petrak.hexcasting.api.spell.math.HexCoord
-import at.petrak.hexcasting.api.spell.math.HexDir
-import at.petrak.hexcasting.api.spell.math.HexPattern
-import at.petrak.hexcasting.api.mod.HexItemTags
 import com.mojang.blaze3d.systems.RenderSystem
 import com.mojang.blaze3d.vertex.PoseStack
 import net.minecraft.client.Minecraft
@@ -32,10 +31,13 @@ import net.minecraft.world.InteractionHand
 import net.minecraft.world.phys.Vec2
 import kotlin.math.atan2
 import kotlin.math.roundToInt
+import kotlin.math.sqrt
 
-class GuiSpellcasting(private val handOpenedWith: InteractionHand,
-                      private var patterns: MutableList<ResolvedPattern>,
-                      private var stackDescs: List<Component>) : Screen(TextComponent("")) {
+class GuiSpellcasting(
+    private val handOpenedWith: InteractionHand,
+    private var patterns: MutableList<ResolvedPattern>,
+    private var stackDescs: List<Component>
+) : Screen(TextComponent("")) {
     private var drawState: PatternDrawState = PatternDrawState.BetweenPatterns
     private val usedSpots: MutableSet<HexCoord> = HashSet()
 
@@ -140,7 +142,7 @@ class GuiSpellcasting(private val handOpenedWith: InteractionHand,
                 val delta = mouse.add(anchor.negated())
                 val angle = atan2(delta.y, delta.x)
                 // 0 is right, increases clockwise(?)
-                val snappedAngle = angle.div(TAU.toFloat()).mod(6.0f)
+                val snappedAngle = angle.div(Mth.TWO_PI).mod(6.0f)
                 val newdir = HexDir.values()[(snappedAngle.times(6).roundToInt() + 1).mod(6)]
                 // The player might have a lousy aim, so set the new anchor point to the "ideal"
                 // location as if they had hit it exactly on the nose.
@@ -344,7 +346,10 @@ class GuiSpellcasting(private val handOpenedWith: InteractionHand,
     fun hexSize(): Float {
         val hasLens = Minecraft.getInstance().player!!
             .getItemInHand(HexUtils.OtherHand(this.handOpenedWith)).`is`(HexItems.SCRYING_LENS.get())
-        return this.width.toFloat() / if (hasLens) 48.0f else 32.0f
+        // Originally, we allowed 32 dots across. Assuming a 1920x1080 screen this allowed like 500-odd area.
+        // Let's be generous and give them 512.
+        val baseScale = sqrt(this.width.toDouble() * this.height / 512.0)
+        return baseScale.toFloat() * if (hasLens) 0.75f else 1f
     }
 
     fun coordsOffset(): Vec2 = Vec2(this.width.toFloat() * 0.5f, this.height.toFloat() * 0.5f)
diff --git a/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipGreeble.java b/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipGreeble.java
index 63e5c4fe..9559cd6f 100644
--- a/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipGreeble.java
+++ b/src/main/java/at/petrak/hexcasting/client/gui/PatternTooltipGreeble.java
@@ -77,7 +77,7 @@ public class PatternTooltipGreeble implements ClientTooltipComponent, TooltipCom
             outer, outer, null);
         RenderLib.drawLineSeq(mat, this.zappyPoints, 2f, 0,
             innerDark, innerLight,
-            ClientTickCounter.getTickCount() / 40f);
+            ClientTickCounter.total / 40f);
         RenderLib.drawSpot(mat, this.zappyPoints.get(0), 2.5f, 1f, 0.1f, 0.15f, 0.6f);
 
         for (var dot : this.pathfinderDots) {
diff --git a/src/main/java/at/petrak/hexcasting/client/particles/ConjureParticle.java b/src/main/java/at/petrak/hexcasting/client/particles/ConjureParticle.java
index 8b60db2f..8e57277d 100644
--- a/src/main/java/at/petrak/hexcasting/client/particles/ConjureParticle.java
+++ b/src/main/java/at/petrak/hexcasting/client/particles/ConjureParticle.java
@@ -102,8 +102,8 @@ public class ConjureParticle extends TextureSheetParticle {
         @Override
         public void begin(BufferBuilder buf, TextureManager texMan) {
             Minecraft.getInstance().gameRenderer.lightTexture().turnOnLightLayer();
-            RenderSystem.depthMask(false);
             RenderSystem.enableDepthTest();
+            RenderSystem.depthMask(false);
             RenderSystem.enableBlend();
             RenderSystem.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
 
diff --git a/src/main/java/at/petrak/hexcasting/client/sound/GridSoundInstance.kt b/src/main/java/at/petrak/hexcasting/client/sound/GridSoundInstance.kt
index 7222ec11..d55b9202 100644
--- a/src/main/java/at/petrak/hexcasting/client/sound/GridSoundInstance.kt
+++ b/src/main/java/at/petrak/hexcasting/client/sound/GridSoundInstance.kt
@@ -49,8 +49,8 @@ class GridSoundInstance(val player: Player) : AbstractTickableSoundInstance(HexS
     }
 
     private fun calculateVectorFromPitchAndYaw(pitch: Float, yaw: Float): Vec3 {
-        val radiansPitch = pitch * (Math.PI.toFloat() / 180f)
-        val radiansYaw = -yaw * (Math.PI.toFloat() / 180f)
+        val radiansPitch = pitch * Mth.DEG_TO_RAD
+        val radiansYaw = -yaw * Mth.DEG_TO_RAD
         val xComponent = Mth.cos(radiansYaw).toDouble()
         val zComponent = Mth.sin(radiansYaw).toDouble()
         val azimuthHorizontal = Mth.cos(radiansPitch).toDouble()
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/BlockBurns.java b/src/main/java/at/petrak/hexcasting/common/blocks/BlockBurns.java
new file mode 100644
index 00000000..bcbc1c71
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/BlockBurns.java
@@ -0,0 +1,33 @@
+package at.petrak.hexcasting.common.blocks;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class BlockBurns extends Block {
+	private final int flammability;
+	private final int spreadSpeed;
+
+	public BlockBurns(Properties props, int flammability, int spreadSpeed) {
+		super(props);
+		this.flammability = flammability;
+		this.spreadSpeed = spreadSpeed;
+	}
+
+	@Override
+	public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+		return true;
+	}
+
+	@Override
+	public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+		return flammability;
+	}
+
+	@Override
+	public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+		return spreadSpeed;
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/HexBlocks.java b/src/main/java/at/petrak/hexcasting/common/blocks/HexBlocks.java
index 74ab198c..691c172f 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/HexBlocks.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/HexBlocks.java
@@ -3,9 +3,7 @@ package at.petrak.hexcasting.common.blocks;
 import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.api.circle.BlockAbstractImpetus;
 import at.petrak.hexcasting.api.spell.DatumType;
-import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicBookshelf;
-import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicFloodfiller;
-import at.petrak.hexcasting.common.blocks.akashic.BlockAkashicRecord;
+import at.petrak.hexcasting.common.blocks.akashic.*;
 import at.petrak.hexcasting.common.blocks.circles.BlockEmptyImpetus;
 import at.petrak.hexcasting.common.blocks.circles.BlockSlate;
 import at.petrak.hexcasting.common.blocks.circles.directrix.BlockEmptyDirectrix;
@@ -144,51 +142,51 @@ public class HexBlocks {
     public static final RegistryObject<AmethystBlock> AMETHYST_TILES = blockItem("amethyst_tiles",
         () -> new AmethystBlock(BlockBehaviour.Properties.copy(Blocks.AMETHYST_BLOCK)));
     public static final RegistryObject<Block> SCROLL_PAPER = blockItem("scroll_paper",
-        () -> new Block(papery(MaterialColor.TERRACOTTA_WHITE)));
+        () -> new BlockBurns(papery(MaterialColor.TERRACOTTA_WHITE), 100, 60));
     public static final RegistryObject<Block> ANCIENT_SCROLL_PAPER = blockItem("ancient_scroll_paper",
-        () -> new Block(papery(MaterialColor.TERRACOTTA_ORANGE)));
+        () -> new BlockBurns(papery(MaterialColor.TERRACOTTA_ORANGE), 100, 60));
     public static final RegistryObject<Block> SCROLL_PAPER_LANTERN = blockItem("scroll_paper_lantern",
-        () -> new Block(papery(MaterialColor.TERRACOTTA_WHITE).lightLevel($ -> 15)));
+        () -> new BlockBurns(papery(MaterialColor.TERRACOTTA_WHITE).lightLevel($ -> 15), 100, 60));
     public static final RegistryObject<Block> ANCIENT_SCROLL_PAPER_LANTERN = blockItem(
         "ancient_scroll_paper_lantern",
-        () -> new Block(papery(MaterialColor.TERRACOTTA_ORANGE).lightLevel($ -> 12)));
+        () -> new BlockBurns(papery(MaterialColor.TERRACOTTA_ORANGE).lightLevel($ -> 12), 100, 60));
     public static final RegistryObject<BlockSconce> SCONCE = blockItem("amethyst_sconce",
         () -> new BlockSconce(BlockBehaviour.Properties.of(Material.AMETHYST, MaterialColor.COLOR_PURPLE)
             .sound(SoundType.AMETHYST)
             .strength(1f)
             .lightLevel($ -> 15)));
     public static final RegistryObject<BlockAxis> AKASHIC_LOG_STRIPPED = blockItem("akashic_log_stripped",
-        () -> new BlockAxis(akashicWoody()));
+        () -> new BlockAkashicLog(akashicWoody()));
     public static final RegistryObject<BlockStrippable> AKASHIC_LOG = blockItem("akashic_log",
-        () -> new BlockStrippable(akashicWoody(), AKASHIC_LOG_STRIPPED));
+        () -> new BlockAkashicWood(akashicWoody(), AKASHIC_LOG_STRIPPED));
     public static final RegistryObject<Block> AKASHIC_WOOD_STRIPPED = blockItem("akashic_wood_stripped",
-        () -> new Block(akashicWoody()));
+        () -> new BlockBurns(akashicWoody(), 5, 5));
     public static final RegistryObject<BlockStrippable> AKASHIC_WOOD = blockItem("akashic_wood",
-        () -> new BlockStrippable(akashicWoody(), AKASHIC_WOOD_STRIPPED));
+        () -> new BlockAkashicWood(akashicWoody(), AKASHIC_WOOD_STRIPPED));
     public static final RegistryObject<Block> AKASHIC_PLANKS = blockItem("akashic_planks",
-        () -> new Block(akashicWoody()));
+        () -> new BlockBurns(akashicWoody(), 20, 5));
     public static final RegistryObject<Block> AKASHIC_PANEL = blockItem("akashic_panel",
-        () -> new Block(akashicWoody()));
+        () -> new BlockBurns(akashicWoody(), 20, 5));
     public static final RegistryObject<Block> AKASHIC_TILE = blockItem("akashic_tile",
-        () -> new Block(akashicWoody()));
+        () -> new BlockBurns(akashicWoody(), 20, 5));
     public static final RegistryObject<DoorBlock> AKASHIC_DOOR = blockItem("akashic_door",
         () -> new DoorBlock(akashicWoody().noOcclusion()));
     public static final RegistryObject<TrapDoorBlock> AKASHIC_TRAPDOOR = blockItem("akashic_trapdoor",
         () -> new TrapDoorBlock(akashicWoody().noOcclusion()));
     public static final RegistryObject<StairBlock> AKASHIC_STAIRS = blockItem("akashic_stairs",
-        () -> new StairBlock(() -> AKASHIC_PLANKS.get().defaultBlockState(), akashicWoody().noOcclusion()));
+        () -> new BlockAkashicStairs(() -> AKASHIC_PLANKS.get().defaultBlockState(), akashicWoody().noOcclusion()));
     public static final RegistryObject<SlabBlock> AKASHIC_SLAB = blockItem("akashic_slab",
-        () -> new SlabBlock(akashicWoody().noOcclusion()));
+        () -> new BlockAkashicSlab(akashicWoody().noOcclusion()));
     public static final RegistryObject<WoodButtonBlock> AKASHIC_BUTTON = blockItem("akashic_button",
-        () -> new WoodButtonBlock(akashicWoody().noOcclusion()));
+        () -> new WoodButtonBlock(akashicWoody().noCollission()));
     public static final RegistryObject<PressurePlateBlock> AKASHIC_PRESSURE_PLATE = blockItem("akashic_pressure_plate",
-        () -> new PressurePlateBlock(PressurePlateBlock.Sensitivity.EVERYTHING, akashicWoody().noOcclusion()));
-    public static final RegistryObject<LeavesBlock> AKASHIC_LEAVES1 = blockItem("akashic_leaves1",
-        () -> new LeavesBlock(leaves(MaterialColor.COLOR_PURPLE)));
-    public static final RegistryObject<LeavesBlock> AKASHIC_LEAVES2 = blockItem("akashic_leaves2",
-        () -> new LeavesBlock(leaves(MaterialColor.COLOR_BLUE)));
-    public static final RegistryObject<LeavesBlock> AKASHIC_LEAVES3 = blockItem("akashic_leaves3",
-        () -> new LeavesBlock(leaves(MaterialColor.COLOR_YELLOW)));
+        () -> new PressurePlateBlock(PressurePlateBlock.Sensitivity.EVERYTHING, akashicWoody().noCollission()));
+    public static final RegistryObject<BlockAkashicLeaves> AKASHIC_LEAVES1 = blockItem("akashic_leaves1",
+        () -> new BlockAkashicLeaves(leaves(MaterialColor.COLOR_PURPLE)));
+    public static final RegistryObject<BlockAkashicLeaves> AKASHIC_LEAVES2 = blockItem("akashic_leaves2",
+        () -> new BlockAkashicLeaves(leaves(MaterialColor.COLOR_BLUE)));
+    public static final RegistryObject<BlockAkashicLeaves> AKASHIC_LEAVES3 = blockItem("akashic_leaves3",
+        () -> new BlockAkashicLeaves(leaves(MaterialColor.COLOR_YELLOW)));
 
     private static boolean never(Object... args) {
         return false;
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicBookshelf.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicBookshelf.java
index 6d024111..65e0bfab 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicBookshelf.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicBookshelf.java
@@ -13,6 +13,7 @@ import net.minecraft.world.InteractionResult;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.context.BlockPlaceContext;
 import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelReader;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.EntityBlock;
 import net.minecraft.world.level.block.Mirror;
@@ -109,6 +110,21 @@ public class BlockAkashicBookshelf extends BlockAkashicFloodfiller implements En
         return this.defaultBlockState().setValue(FACING, ctx.getHorizontalDirection().getOpposite());
     }
 
+    @Override
+    public float getEnchantPowerBonus(BlockState state, LevelReader level, BlockPos pos) {
+        return 1;
+    }
+
+    @Override
+    public boolean hasAnalogOutputSignal(BlockState pState) {
+        return true;
+    }
+
+    @Override
+    public int getAnalogOutputSignal(BlockState pState, Level pLevel, BlockPos pPos) {
+        return pState.getValue(DATUM_TYPE).ordinal();
+    }
+
     @Nullable
     @Override
     public BlockEntity newBlockEntity(BlockPos pPos, BlockState pState) {
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLeaves.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLeaves.java
new file mode 100644
index 00000000..4694a1c2
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLeaves.java
@@ -0,0 +1,28 @@
+package at.petrak.hexcasting.common.blocks.akashic;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.LeavesBlock;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class BlockAkashicLeaves extends LeavesBlock {
+    public BlockAkashicLeaves(Properties props) {
+        super(props);
+    }
+
+    @Override
+    public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return true;
+    }
+
+    @Override
+    public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 60;
+    }
+
+    @Override
+    public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 30;
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLog.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLog.java
new file mode 100644
index 00000000..11169e89
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicLog.java
@@ -0,0 +1,28 @@
+package at.petrak.hexcasting.common.blocks.akashic;
+
+import at.petrak.hexcasting.common.blocks.decoration.BlockAxis;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class BlockAkashicLog extends BlockAxis {
+    public BlockAkashicLog(Properties props) {
+        super(props);
+    }
+
+    @Override
+    public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return true;
+    }
+
+    @Override
+    public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+
+    @Override
+    public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicRecord.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicRecord.java
index 8677ac8c..99f76f49 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicRecord.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicRecord.java
@@ -24,6 +24,20 @@ public class BlockAkashicRecord extends Block implements EntityBlock {
         return new BlockEntityAkashicRecord(pPos, pState);
     }
 
+    @Override
+    public boolean hasAnalogOutputSignal(BlockState pState) {
+        return true;
+    }
+
+    @Override
+    public int getAnalogOutputSignal(BlockState pState, Level pLevel, BlockPos pPos) {
+        BlockEntity be = pLevel.getBlockEntity(pPos);
+        if (be instanceof BlockEntityAkashicRecord record) {
+            return Math.min(15, record.getCount());
+        }
+        return 0;
+    }
+
     @Override
     public void onRemove(BlockState pState, Level pLevel, BlockPos pPos, BlockState pNewState, boolean pIsMoving) {
         var seen = new HashSet<BlockPos>();
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicSlab.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicSlab.java
new file mode 100644
index 00000000..d692250d
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicSlab.java
@@ -0,0 +1,28 @@
+package at.petrak.hexcasting.common.blocks.akashic;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.SlabBlock;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class BlockAkashicSlab extends SlabBlock {
+    public BlockAkashicSlab(Properties props) {
+        super(props);
+    }
+
+    @Override
+    public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return true;
+    }
+
+    @Override
+    public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 20;
+    }
+
+    @Override
+    public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicStairs.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicStairs.java
new file mode 100644
index 00000000..c9209d3c
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicStairs.java
@@ -0,0 +1,30 @@
+package at.petrak.hexcasting.common.blocks.akashic;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.StairBlock;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.function.Supplier;
+
+public class BlockAkashicStairs extends StairBlock {
+    public BlockAkashicStairs(Supplier<BlockState> state, Properties properties) {
+        super(state, properties);
+    }
+
+    @Override
+    public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return true;
+    }
+
+    @Override
+    public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 20;
+    }
+
+    @Override
+    public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicWood.java b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicWood.java
new file mode 100644
index 00000000..efaace5a
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/akashic/BlockAkashicWood.java
@@ -0,0 +1,33 @@
+package at.petrak.hexcasting.common.blocks.akashic;
+
+import at.petrak.hexcasting.common.blocks.decoration.BlockStrippable;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.function.Supplier;
+
+public class BlockAkashicWood extends BlockStrippable {
+
+    public BlockAkashicWood(Properties props, Supplier<? extends Block> stripped) {
+        super(props, stripped);
+    }
+
+    @Override
+    public boolean isFlammable(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return true;
+    }
+
+    @Override
+    public int getFlammability(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+
+    @Override
+    public int getFireSpreadSpeed(BlockState state, BlockGetter level, BlockPos pos, Direction direction) {
+        return 5;
+    }
+}
+
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockEntityStoredPlayerImpetus.java b/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockEntityStoredPlayerImpetus.java
index 717edae3..d5a36e92 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockEntityStoredPlayerImpetus.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockEntityStoredPlayerImpetus.java
@@ -6,6 +6,7 @@ import com.mojang.datafixers.util.Pair;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
@@ -15,6 +16,8 @@ import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
@@ -50,9 +53,12 @@ public class BlockEntityStoredPlayerImpetus extends BlockEntityAbstractImpetus {
     }
 
     @Override
-    public List<Pair<ItemStack, Component>> getScryingLensOverlay(BlockState state, BlockPos pos, LocalPlayer observer,
-        ClientLevel world, InteractionHand lensHand) {
-        var list = super.getScryingLensOverlay(state, pos, observer, world, lensHand);
+    @OnlyIn(Dist.CLIENT)
+    public void applyScryingLensOverlay(List<Pair<ItemStack, Component>> lines,
+                                        BlockState state, BlockPos pos, LocalPlayer observer,
+                                        ClientLevel world,
+                                        Direction hitFace, InteractionHand lensHand) {
+        super.applyScryingLensOverlay(lines, state, pos, observer, world, hitFace, lensHand);
 
         var bound = this.getPlayer();
         if (bound != null) {
@@ -60,13 +66,11 @@ public class BlockEntityStoredPlayerImpetus extends BlockEntityAbstractImpetus {
             String name = bound.getScoreboardName();
             tag.putString("SkullOwner", name);
             var head = new ItemStack(Items.PLAYER_HEAD, 1, tag);
-            list.add(new Pair<>(head, new TranslatableComponent("hexcasting.tooltip.lens.impetus.storedplayer", name)));
+            lines.add(new Pair<>(head, new TranslatableComponent("hexcasting.tooltip.lens.impetus.storedplayer", name)));
         } else {
-            list.add(new Pair<>(new ItemStack(Items.BARRIER),
+            lines.add(new Pair<>(new ItemStack(Items.BARRIER),
                 new TranslatableComponent("hexcasting.tooltip.lens.impetus.storedplayer.none")));
         }
-
-        return list;
     }
 
     @Override
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockStoredPlayerImpetus.java b/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockStoredPlayerImpetus.java
index 832b8ebc..a84aea02 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockStoredPlayerImpetus.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/circles/impetuses/BlockStoredPlayerImpetus.java
@@ -35,7 +35,7 @@ public class BlockStoredPlayerImpetus extends BlockAbstractImpetus {
         BlockHitResult pHit) {
         if (pLevel.getBlockEntity(pPos) instanceof BlockEntityStoredPlayerImpetus tile) {
             var usedStack = pPlayer.getItemInHand(pHand);
-            var datumContainer = usedStack.getCapability(HexCapabilities.DATUM).resolve();
+            var datumContainer = HexCapabilities.getCapability(usedStack, HexCapabilities.DATUM);
             if (datumContainer.isPresent()) {
                 if (pLevel instanceof ServerLevel level) {
                     var stored = datumContainer.get().readDatum(level);
@@ -44,9 +44,9 @@ public class BlockStoredPlayerImpetus extends BlockAbstractImpetus {
                         if (entity instanceof Player) {
                             // phew, we got something
                             tile.setPlayer(entity.getUUID());
-                            tile.setChanged();
+                            level.sendBlockUpdated(pPos, pState, pState, Block.UPDATE_CLIENTS);
 
-                            pLevel.playSound(pPlayer, pPos, HexSounds.IMPETUS_STOREDPLAYER_DING.get(), SoundSource.BLOCKS,
+                            pLevel.playSound(null, pPos, HexSounds.IMPETUS_STOREDPLAYER_DING.get(), SoundSource.BLOCKS,
                                     1f, 1f);
                         }
                     }
diff --git a/src/main/java/at/petrak/hexcasting/common/blocks/decoration/BlockStrippable.java b/src/main/java/at/petrak/hexcasting/common/blocks/decoration/BlockStrippable.java
index 0c7a3ee9..bcd36ffb 100644
--- a/src/main/java/at/petrak/hexcasting/common/blocks/decoration/BlockStrippable.java
+++ b/src/main/java/at/petrak/hexcasting/common/blocks/decoration/BlockStrippable.java
@@ -1,16 +1,13 @@
 package at.petrak.hexcasting.common.blocks.decoration;
 
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.Level;
+import net.minecraft.world.item.context.UseOnContext;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.RotatedPillarBlock;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraftforge.common.ToolAction;
 import net.minecraftforge.common.ToolActions;
+import org.jetbrains.annotations.Nullable;
 
-import javax.annotation.Nullable;
 import java.util.function.Supplier;
 
 // aka, Blockg
@@ -25,8 +22,7 @@ public class BlockStrippable extends RotatedPillarBlock {
 
     @Nullable
     @Override
-    public BlockState getToolModifiedState(BlockState state, Level world, BlockPos pos, Player player, ItemStack stack,
-        ToolAction toolAction) {
+    public BlockState getToolModifiedState(BlockState state, UseOnContext context, ToolAction toolAction, boolean simulate) {
         if (toolAction == ToolActions.AXE_STRIP) {
             var out = stripped.get().defaultBlockState();
             if (state.hasProperty(AXIS)) {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java b/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java
index a9b708e5..996547f9 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java
+++ b/src/main/java/at/petrak/hexcasting/common/casting/RegisterPatterns.java
@@ -1,9 +1,13 @@
 package at.petrak.hexcasting.common.casting;
 
 import at.petrak.hexcasting.api.PatternRegistry;
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import at.petrak.hexcasting.api.spell.Operator;
 import at.petrak.hexcasting.api.spell.SpellDatum;
 import at.petrak.hexcasting.api.spell.Widget;
+import at.petrak.hexcasting.api.spell.math.HexAngle;
+import at.petrak.hexcasting.api.spell.math.HexDir;
+import at.petrak.hexcasting.api.spell.math.HexPattern;
 import at.petrak.hexcasting.api.utils.HexUtils;
 import at.petrak.hexcasting.common.casting.operators.*;
 import at.petrak.hexcasting.common.casting.operators.akashic.OpAkashicRead;
@@ -16,6 +20,7 @@ import at.petrak.hexcasting.common.casting.operators.eval.OpEvalDelay;
 import at.petrak.hexcasting.common.casting.operators.eval.OpForEach;
 import at.petrak.hexcasting.common.casting.operators.lists.*;
 import at.petrak.hexcasting.common.casting.operators.math.*;
+import at.petrak.hexcasting.common.casting.operators.math.bit.*;
 import at.petrak.hexcasting.common.casting.operators.math.logic.*;
 import at.petrak.hexcasting.common.casting.operators.math.trig.*;
 import at.petrak.hexcasting.common.casting.operators.selectors.OpGetCaster;
@@ -29,9 +34,6 @@ import at.petrak.hexcasting.common.casting.operators.spells.sentinel.OpGetSentin
 import at.petrak.hexcasting.common.casting.operators.spells.sentinel.OpGetSentinelWayfind;
 import at.petrak.hexcasting.common.casting.operators.stack.*;
 import at.petrak.hexcasting.common.items.HexItems;
-import at.petrak.hexcasting.api.spell.math.HexAngle;
-import at.petrak.hexcasting.api.spell.math.HexDir;
-import at.petrak.hexcasting.api.spell.math.HexPattern;
 import it.unimi.dsi.fastutil.booleans.BooleanArrayList;
 import net.minecraft.world.effect.MobEffects;
 import net.minecraft.world.phys.Vec3;
@@ -81,11 +83,12 @@ public class RegisterPatterns {
 
             // == Modify Stack ==
 
-            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("d", HexDir.EAST), prefix("const/null"), Widget.NULL);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aadaa", HexDir.EAST), prefix("duplicate"),
                 OpDuplicate.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aadaadaa", HexDir.EAST), prefix("duplicate_n"),
                 OpDuplicateN.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwaeawqaeaqa", HexDir.NORTH_WEST), prefix("stack_len"),
+                OpStackSize.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aawdd", HexDir.EAST), prefix("swap"), OpSwap.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ddad", HexDir.WEST), prefix("fisherman"),
                 OpFisherman.INSTANCE);
@@ -106,6 +109,12 @@ public class RegisterPatterns {
                 OpAbsLen.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wedew", HexDir.NORTH_WEST), prefix("pow_proj"),
                 OpPowProj.INSTANCE);
+
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ewq", HexDir.EAST), prefix("floor"),
+                OpFloor.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwe", HexDir.EAST), prefix("ceil"),
+                OpCeil.INSTANCE);
+
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqqqq", HexDir.EAST), prefix("construct_vec"),
                 OpConstructVec.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qeeeee", HexDir.EAST), prefix("deconstruct_vec"),
@@ -113,12 +122,14 @@ public class RegisterPatterns {
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaww", HexDir.NORTH_WEST), prefix("coerce_axial"),
                 OpCoerceToAxial.INSTANCE);
 
+            // == Logic ==
+
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wdw", HexDir.NORTH_EAST), prefix("and"),
-                OpAnd.INSTANCE);
+                OpBoolAnd.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waw", HexDir.SOUTH_EAST), prefix("or"),
-                OpOr.INSTANCE);
+                OpBoolOr.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dwa", HexDir.NORTH_WEST), prefix("xor"),
-                OpXor.INSTANCE);
+                OpBoolXor.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("e", HexDir.SOUTH_EAST), prefix("greater"),
                 new OpCompare((a, b) -> a > b));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("q", HexDir.SOUTH_WEST), prefix("less"),
@@ -132,16 +143,14 @@ public class RegisterPatterns {
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("da", HexDir.EAST), prefix("not_equals"),
                 new OpEquality(true));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dw", HexDir.NORTH_WEST), prefix("not"),
-                OpNot.INSTANCE);
+                OpBoolNot.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aw", HexDir.NORTH_EAST), prefix("identity"),
-                OpIdentityKindOf.INSTANCE);
+                OpBoolIdentityKindOf.INSTANCE);
 
-            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("ewq", HexDir.EAST), prefix("floor"),
-                OpFloor.INSTANCE);
-            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qwe", HexDir.EAST), prefix("ceil"),
-                OpCeil.INSTANCE);
-            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqaqe", HexDir.NORTH_WEST), prefix("logarithm"),
-                OpLog.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqq", HexDir.NORTH_WEST), prefix("random"),
+                OpRandom.INSTANCE);
+
+            // == Advanced Math ==
 
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaa", HexDir.SOUTH_EAST), prefix("sin"),
                 OpSin.INSTANCE);
@@ -156,8 +165,21 @@ public class RegisterPatterns {
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eadeeeeew", HexDir.NORTH_EAST), prefix("arctan"),
                 OpArcTan.INSTANCE);
 
-            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqqq", HexDir.NORTH_WEST), prefix("random"),
-                OpRandom.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("eqaqe", HexDir.NORTH_WEST), prefix("logarithm"),
+                OpLog.INSTANCE);
+
+            // == Sets ==
+
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wdweaqa", HexDir.NORTH_EAST), prefix("and_bit"),
+                OpAnd.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waweaqa", HexDir.SOUTH_EAST), prefix("or_bit"),
+                OpOr.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dwaeaqa", HexDir.NORTH_WEST), prefix("xor_bit"),
+                OpXor.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("dweaqa", HexDir.NORTH_WEST), prefix("not_bit"),
+                OpNot.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aweaqa", HexDir.NORTH_EAST), prefix("to_set"),
+                OpToSet.INSTANCE);
 
             // == Spells ==
 
@@ -205,14 +227,14 @@ public class RegisterPatterns {
                 OpBeep.INSTANCE);
 
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waqqqqq", HexDir.EAST), prefix("craft/cypher"),
-                new OpMakePackagedSpell<>(HexItems.CYPHER.get(), 100_000));
+                new OpMakePackagedSpell<>(HexItems.CYPHER.get(), ManaConstants.CRYSTAL_UNIT));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wwaqqqqqeaqeaeqqqeaeq", HexDir.EAST),
                 prefix("craft/trinket"),
-                new OpMakePackagedSpell<>(HexItems.TRINKET.get(), 500_000));
+                new OpMakePackagedSpell<>(HexItems.TRINKET.get(), 5 * ManaConstants.CRYSTAL_UNIT));
             PatternRegistry.mapPattern(
                 HexPattern.FromAnglesSig("wwaqqqqqeawqwqwqwqwqwwqqeadaeqqeqqeadaeqq", HexDir.EAST),
                 prefix("craft/artifact"),
-                new OpMakePackagedSpell<>(HexItems.ARTIFACT.get(), 1_000_000));
+                new OpMakePackagedSpell<>(HexItems.ARTIFACT.get(), 10 * ManaConstants.CRYSTAL_UNIT));
             PatternRegistry.mapPattern(
                 HexPattern.FromAnglesSig("aqqqaqwwaqqqqqeqaqqqawwqwqwqwqwqw", HexDir.SOUTH_WEST),
                 prefix("craft/battery"),
@@ -221,35 +243,35 @@ public class RegisterPatterns {
 
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaqwawaw", HexDir.NORTH_WEST),
                 prefix("potion/weakness"),
-                new OpPotionEffect(MobEffects.WEAKNESS, 10_000 / 10, true, false, false));
+                new OpPotionEffect(MobEffects.WEAKNESS, ManaConstants.DUST_UNIT / 10, true, false, false));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqawwawawd", HexDir.WEST),
                 prefix("potion/levitation"),
-                new OpPotionEffect(MobEffects.LEVITATION, 10_000 / 5, false, false, false));
+                new OpPotionEffect(MobEffects.LEVITATION, ManaConstants.DUST_UNIT / 5, false, false, false));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqaewawawe", HexDir.SOUTH_WEST),
                 prefix("potion/wither"),
-                new OpPotionEffect(MobEffects.WITHER, 10_000, true, false, false));
+                new OpPotionEffect(MobEffects.WITHER, ManaConstants.DUST_UNIT, true, false, false));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqadwawaww", HexDir.SOUTH_EAST),
                 prefix("potion/poison"),
-                new OpPotionEffect(MobEffects.POISON, 10_000 / 3, true, false, false));
+                new OpPotionEffect(MobEffects.POISON, ManaConstants.DUST_UNIT / 3, true, false, false));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqadwawaw", HexDir.SOUTH_EAST),
                 prefix("potion/slowness"),
-                new OpPotionEffect(MobEffects.MOVEMENT_SLOWDOWN, 10_000 / 3, true, false, false));
+                new OpPotionEffect(MobEffects.MOVEMENT_SLOWDOWN, ManaConstants.DUST_UNIT / 3, true, false, false));
 
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqaawawaedd", HexDir.NORTH_WEST),
                 prefix("potion/regeneration"),
-                new OpPotionEffect(MobEffects.REGENERATION, 10_000, true, true, true), true);
+                new OpPotionEffect(MobEffects.REGENERATION, ManaConstants.DUST_UNIT, true, true, true), true);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqaawawaeqdd", HexDir.WEST),
                 prefix("potion/night_vision"),
-                new OpPotionEffect(MobEffects.NIGHT_VISION, 10_000 / 5, false, true, true), true);
+                new OpPotionEffect(MobEffects.NIGHT_VISION, ManaConstants.DUST_UNIT / 5, false, true, true), true);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqaawawaeqqdd", HexDir.SOUTH_WEST),
                 prefix("potion/absorption"),
-                new OpPotionEffect(MobEffects.ABSORPTION, 10_000, true, true, true), true);
+                new OpPotionEffect(MobEffects.ABSORPTION, ManaConstants.DUST_UNIT, true, true, true), true);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaawawaeqqqdd", HexDir.SOUTH_EAST),
                 prefix("potion/haste"),
-                new OpPotionEffect(MobEffects.DIG_SPEED, 10_000 / 3, true, true, true), true);
+                new OpPotionEffect(MobEffects.DIG_SPEED, ManaConstants.DUST_UNIT / 3, true, true, true), true);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aawawaeqqqqdd", HexDir.EAST),
                 prefix("potion/strength"),
-                new OpPotionEffect(MobEffects.DAMAGE_BOOST, 10_000 / 3, true, true, true), true);
+                new OpPotionEffect(MobEffects.DAMAGE_BOOST, ManaConstants.DUST_UNIT / 3, true, true, true), true);
 
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("waeawae", HexDir.EAST),
                 prefix("sentinel/create"),
@@ -309,12 +331,21 @@ public class RegisterPatterns {
                 OpRead.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deeeee", HexDir.EAST), prefix("write"),
                 OpWrite.INSTANCE);
-            // lorge boy
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("aqqqqqe", HexDir.EAST), prefix("readable"),
+                OpReadable.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("deeeeeq", HexDir.EAST), prefix("writable"),
+                OpWritable.INSTANCE);
+
+            // lorge boyes
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wawqwqwqwqwqw", HexDir.EAST),
                 prefix("read/entity"), OpTheCoolerRead.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wawqwqwqwqwqwew", HexDir.EAST),
+                prefix("readable/entity"), OpTheCoolerReadable.INSTANCE);
 
             // == Consts ==
 
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("d", HexDir.EAST), prefix("const/null"), Widget.NULL);
+
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqea", HexDir.NORTH_WEST), prefix("const/vec/px"),
                 Operator.makeConstantOp(SpellDatum.make(new Vec3(1.0, 0.0, 0.0))));
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qqqqqew", HexDir.NORTH_WEST), prefix("const/vec/py"),
@@ -419,6 +450,10 @@ public class RegisterPatterns {
                 OpIndexOf.INSTANCE);
             PatternRegistry.mapPattern(HexPattern.FromAnglesSig("edqdewaqa", HexDir.SOUTH_WEST), prefix("list_remove"),
                 OpRemove.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("qaeaqwded", HexDir.NORTH_WEST), prefix("slice"),
+                OpSlice.INSTANCE);
+            PatternRegistry.mapPattern(HexPattern.FromAnglesSig("wqaeaqw", HexDir.NORTH_WEST), prefix("modify_in_place"),
+                OpModifyInPlace.INSTANCE);
 
         } catch (PatternRegistry.RegisterPatternException exn) {
             exn.printStackTrace();
@@ -455,13 +490,9 @@ public class RegisterPatterns {
         PatternRegistry.addSpecialHandler(prefix("mask"), pat -> {
             var directions = pat.directions();
 
-            HexDir flatDir;
-            if (pat.angles().isEmpty()) {
-                return null;
-            } else if (pat.angles().get(0) == HexAngle.LEFT_BACK) {
+            HexDir flatDir = pat.startDir();
+            if (!pat.angles().isEmpty() && pat.angles().get(0) == HexAngle.LEFT_BACK) {
                 flatDir = directions.get(0).rotatedBy(HexAngle.LEFT);
-            } else {
-                flatDir = pat.startDir();
             }
 
             var mask = new BooleanArrayList();
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockAxisRaycast.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockAxisRaycast.kt
index f0858f95..26daa608 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockAxisRaycast.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockAxisRaycast.kt
@@ -1,18 +1,19 @@
 package at.petrak.hexcasting.common.casting.operators
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.world.level.ClipContext
 import net.minecraft.world.phys.HitResult
 import net.minecraft.world.phys.Vec3
 
 object OpBlockAxisRaycast : ConstManaOperator {
     override val argc = 2
-    override val manaCost = 10
+    override val manaCost = ManaConstants.DUST_UNIT / 100
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val origin: Vec3 = args.getChecked(0)
         val look: Vec3 = args.getChecked(1)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockRaycast.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockRaycast.kt
index 59500a36..a4a3ff31 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockRaycast.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpBlockRaycast.kt
@@ -1,18 +1,19 @@
 package at.petrak.hexcasting.common.casting.operators
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.world.level.ClipContext
 import net.minecraft.world.phys.HitResult
 import net.minecraft.world.phys.Vec3
 
 object OpBlockRaycast : ConstManaOperator {
     override val argc = 2
-    override val manaCost = 10
+    override val manaCost = ManaConstants.DUST_UNIT / 100
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val origin: Vec3 = args.getChecked(0)
         val look: Vec3 = args.getChecked(1)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityRaycast.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityRaycast.kt
index 12117205..f750c4fa 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityRaycast.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityRaycast.kt
@@ -1,18 +1,19 @@
 package at.petrak.hexcasting.common.casting.operators
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.world.entity.projectile.ProjectileUtil
 import net.minecraft.world.phys.AABB
 import net.minecraft.world.phys.Vec3
 
 object OpEntityRaycast : ConstManaOperator {
     override val argc = 2
-    override val manaCost = 10
+    override val manaCost = ManaConstants.DUST_UNIT / 100
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val origin: Vec3 = args.getChecked(0)
         val look: Vec3 = args.getChecked(1)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityVelocity.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityVelocity.kt
index 845f759f..7bc6f16b 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityVelocity.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpEntityVelocity.kt
@@ -5,9 +5,9 @@ import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.common.misc.PlayerPositionRecorder
+import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.Entity
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.phys.Vec3
 
 object OpEntityVelocity : ConstManaOperator {
     override val argc = 1
@@ -17,9 +17,8 @@ object OpEntityVelocity : ConstManaOperator {
         ctx.assertEntityInRange(e)
 
         // Player velocity is jank. Really jank. This is the best we can do.
-        if (e is Player) {
-            val prevPosition = Vec3(e.xOld, e.yOld, e.zOld)
-            return spellListOf(e.position().subtract(prevPosition))
+        if (e is ServerPlayer) {
+            return spellListOf(PlayerPositionRecorder.getMotion(e))
         }
 
         return spellListOf(e.deltaMovement)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpRead.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpRead.kt
index 6cf747c0..47f15b88 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpRead.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpRead.kt
@@ -1,9 +1,9 @@
 package at.petrak.hexcasting.common.casting.operators
 
+import at.petrak.hexcasting.api.cap.HexCapabilities
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.cap.HexCapabilities
 import at.petrak.hexcasting.api.spell.mishaps.MishapBadOffhandItem
 
 object OpRead : ConstManaOperator {
@@ -11,11 +11,11 @@ object OpRead : ConstManaOperator {
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val (handStack, hand) = ctx.getHeldItemToOperateOn {
-            val datum = it.getCapability(HexCapabilities.DATUM).resolve()
-            datum.isPresent && (datum.get().readDatum(ctx.world) != null || datum.get().emptyDatum() != null)
+            val datum = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
+            !it.isEmpty && datum.isPresent && (datum.get().readDatum(ctx.world) != null || datum.get().emptyDatum() != null)
         }
 
-        val datumHolder = handStack.getCapability(HexCapabilities.DATUM).resolve()
+        val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
         if (!datumHolder.isPresent)
             throw MishapBadOffhandItem.of(handStack, hand, "iota.read")
 
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpReadable.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpReadable.kt
new file mode 100644
index 00000000..e515af7c
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpReadable.kt
@@ -0,0 +1,26 @@
+package at.petrak.hexcasting.common.casting.operators
+
+import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+
+object OpReadable : ConstManaOperator {
+    override val argc = 0
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val (handStack) = ctx.getHeldItemToOperateOn {
+            HexCapabilities.getCapability(it, HexCapabilities.DATUM).isPresent
+        }
+
+        val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
+        if (!datumHolder.isPresent)
+            return spellListOf(0.0)
+
+        if (datumHolder.get().readDatum(ctx.world) == null && datumHolder.get().emptyDatum() == null)
+            return spellListOf(0.0)
+
+        return spellListOf(1.0)
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerRead.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerRead.kt
index 57dfe382..8525f63d 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerRead.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerRead.kt
@@ -16,13 +16,13 @@ object OpTheCoolerRead : ConstManaOperator {
         ctx: CastingContext
     ): List<SpellDatum<*>> {
         val target = args.getChecked<ItemEntity>(0)
-        val stack = target.item
-        val datumHolder = stack.getCapability(HexCapabilities.DATUM).resolve()
-        if (!datumHolder.isPresent)
-            throw MishapBadItem.of(target, "iota.read")
 
         ctx.assertEntityInRange(target)
 
+        val stack = target.item
+        val datumHolder = HexCapabilities.getCapability(stack, HexCapabilities.DATUM)
+        if (!datumHolder.isPresent)
+            throw MishapBadItem.of(target, "iota.read")
 
         val datum = datumHolder.get().readDatum(ctx.world)
             ?: datumHolder.get().emptyDatum()
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerReadable.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerReadable.kt
new file mode 100644
index 00000000..51d2008d
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpTheCoolerReadable.kt
@@ -0,0 +1,32 @@
+package at.petrak.hexcasting.common.casting.operators
+
+import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import net.minecraft.world.entity.item.ItemEntity
+
+object OpTheCoolerReadable : ConstManaOperator {
+    override val argc = 1
+
+    override fun execute(
+        args: List<SpellDatum<*>>,
+        ctx: CastingContext
+    ): List<SpellDatum<*>> {
+        val target = args.getChecked<ItemEntity>(0)
+        ctx.assertEntityInRange(target)
+
+        val stack = target.item
+        val datumHolder = HexCapabilities.getCapability(stack, HexCapabilities.DATUM)
+
+        if (!datumHolder.isPresent)
+            return spellListOf(0.0)
+
+        if (datumHolder.get().readDatum(ctx.world) == null && datumHolder.get().emptyDatum() == null)
+            return spellListOf(0.0)
+
+        return spellListOf(1.0)
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWritable.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWritable.kt
new file mode 100644
index 00000000..f6973bc5
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWritable.kt
@@ -0,0 +1,35 @@
+package at.petrak.hexcasting.common.casting.operators
+
+import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.api.spell.mishaps.MishapOthersName
+
+object OpWritable : ConstManaOperator {
+    override val argc = 1
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val datum = args[0]
+
+        val (handStack) = ctx.getHeldItemToOperateOn {
+            val datumHolder = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
+
+            datumHolder.isPresent && datumHolder.get().writeDatum(datum, true)
+        }
+
+        val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
+        if (!datumHolder.isPresent)
+            return spellListOf(0.0)
+
+        if (!datumHolder.get().writeDatum(datum, true))
+            return spellListOf(0.0)
+
+        val trueName = MishapOthersName.getTrueNameFromDatum(datum, ctx.caster)
+        if (trueName != null)
+            return spellListOf(0.0)
+
+        return spellListOf(1.0)
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWrite.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWrite.kt
index 6dcf0c4e..6ae5bb6a 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWrite.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/OpWrite.kt
@@ -1,11 +1,11 @@
 package at.petrak.hexcasting.common.casting.operators
 
+import at.petrak.hexcasting.api.cap.HexCapabilities
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.cap.HexCapabilities
 import at.petrak.hexcasting.api.spell.mishaps.MishapBadOffhandItem
 import at.petrak.hexcasting.api.spell.mishaps.MishapOthersName
 
@@ -19,12 +19,12 @@ object OpWrite : SpellOperator {
         val datum = args[0]
 
         val (handStack, hand) = ctx.getHeldItemToOperateOn {
-            val datumHolder = it.getCapability(HexCapabilities.DATUM).resolve()
+            val datumHolder = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
 
             datumHolder.isPresent && datumHolder.get().writeDatum(datum, true)
         }
 
-        val datumHolder = handStack.getCapability(HexCapabilities.DATUM).resolve()
+        val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
         if (!datumHolder.isPresent)
             throw MishapBadOffhandItem.of(handStack, hand, "iota.write")
 
@@ -45,12 +45,12 @@ object OpWrite : SpellOperator {
     private data class Spell(val datum: SpellDatum<*>) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
             val (handStack) = ctx.getHeldItemToOperateOn {
-                val datumHolder = it.getCapability(HexCapabilities.DATUM).resolve()
+                val datumHolder = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
 
                 datumHolder.isPresent && datumHolder.get().writeDatum(datum, true)
             }
 
-            val datumHolder = handStack.getCapability(HexCapabilities.DATUM).resolve()
+            val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
 
             if (datumHolder.isPresent) {
                 datumHolder.get().writeDatum(datum, false)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicRead.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicRead.kt
index 203b0fd5..c12655a5 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicRead.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicRead.kt
@@ -1,19 +1,20 @@
 package at.petrak.hexcasting.common.casting.operators.akashic
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicRecord
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
-import at.petrak.hexcasting.api.spell.mishaps.MishapNoAkashicRecord
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.api.spell.mishaps.MishapNoAkashicRecord
+import at.petrak.hexcasting.common.blocks.akashic.BlockEntityAkashicRecord
 import net.minecraft.core.BlockPos
 import net.minecraft.world.phys.Vec3
 
 object OpAkashicRead : ConstManaOperator {
     override val argc = 2
-    override val manaCost = 10_000
+    override val manaCost = ManaConstants.DUST_UNIT
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val pos = args.getChecked<Vec3>(0)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicWrite.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicWrite.kt
index 3ab31b52..73a9ce86 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicWrite.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/akashic/OpAkashicWrite.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.akashic
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -40,7 +41,7 @@ object OpAkashicWrite : SpellOperator {
 
         return Triple(
             Spell(tile, key, datum),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf()
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/circles/OpCircleBounds.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/circles/OpCircleBounds.kt
index 464221f6..334c7702 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/circles/OpCircleBounds.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/circles/OpCircleBounds.kt
@@ -18,9 +18,9 @@ class OpCircleBounds(val max: Boolean) : ConstManaOperator {
 
         return Operator.spellListOf(
             if (max)
-                Vec3(aabb.minX, aabb.minY, aabb.minZ)
+                Vec3(aabb.maxX - 0.5, aabb.maxY - 0.5, aabb.maxZ - 0.5)
             else
-                Vec3(aabb.maxX, aabb.maxY, aabb.maxZ)
+                Vec3(aabb.minX + 0.5, aabb.minY + 0.5, aabb.minZ + 0.5)
         )
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt
index aa79e33f..e29a59ac 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEval.kt
@@ -7,18 +7,19 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.casting.CastingHarness
 import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect
-import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidIota
 import net.minecraft.network.chat.TranslatableComponent
 
 object OpEval : Operator {
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         val instrs: List<SpellDatum<*>> = stack.getChecked(stack.lastIndex)
         stack.removeLastOrNull()
 
         ctx.incDepth()
         val harness = CastingHarness(ctx)
         harness.stack.addAll(stack)
+        harness.localIota = local
 
         val sideEffects = mutableListOf<OperatorSideEffect>()
 
@@ -35,8 +36,7 @@ object OpEval : Operator {
             }
             harness.applyFunctionalData(res.newData)
         }
-        stack.addAll(harness.stack)
 
-        return OperationResult(harness.stack, sideEffects)
+        return OperationResult(harness.stack, harness.localIota, sideEffects)
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEvalDelay.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEvalDelay.kt
index 1c44f774..d48a9845 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEvalDelay.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpEvalDelay.kt
@@ -6,7 +6,7 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 
 object OpEvalDelay : Operator {
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
-        return OperationResult(stack, listOf())
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
+        return OperationResult(stack, local, listOf())
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpForEach.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpForEach.kt
index 3f8e1db5..2dffda08 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpForEach.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/eval/OpForEach.kt
@@ -7,13 +7,13 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.casting.CastingHarness
 import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect
+import at.petrak.hexcasting.api.spell.math.HexPattern
 import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
-import at.petrak.hexcasting.api.spell.math.HexPattern
 import net.minecraft.network.chat.TranslatableComponent
 
 object OpForEach : Operator {
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (stack.size < 2)
             throw MishapNotEnoughArgs(2, stack.size)
 
@@ -25,17 +25,20 @@ object OpForEach : Operator {
         val out = mutableListOf<SpellDatum<*>>()
         val sideEffects = mutableListOf<OperatorSideEffect>()
 
+        var localIota = local
+
         for (subdatum in datums) {
             ctx.incDepth()
             val harness = CastingHarness(ctx)
             harness.stack.addAll(stack)
             harness.stack.add(subdatum)
+            harness.localIota = localIota
             for (pat in instrs) {
                 val pattern = if (pat.payload is HexPattern) {
                     pat.payload
                 } else {
                     throw MishapInvalidIota(
-                        pat,
+                        SpellDatum.make(instrs),
                         1,
                         TranslatableComponent("hexcasting.mishap.invalid_value.list.pattern")
                     )
@@ -43,14 +46,15 @@ object OpForEach : Operator {
                 val res = harness.getUpdate(pattern, ctx.world)
                 sideEffects.addAll(res.sideEffects)
                 if (res.sideEffects.any { it is OperatorSideEffect.DoMishap }) {
-                    return OperationResult(harness.stack, sideEffects)
+                    return OperationResult(harness.stack, harness.localIota, sideEffects)
                 }
                 harness.applyFunctionalData(res.newData)
             }
             out.addAll(harness.stack)
+            localIota = harness.localIota
         }
         stack.add(SpellDatum.make(out))
 
-        return OperationResult(stack, sideEffects)
+        return OperationResult(stack, localIota, sideEffects)
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpLastNToList.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpLastNToList.kt
index 5d762530..7cef17ac 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpLastNToList.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpLastNToList.kt
@@ -6,7 +6,6 @@ import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect
 import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
 import net.minecraft.network.chat.TranslatableComponent
@@ -14,10 +13,7 @@ import kotlin.math.abs
 import kotlin.math.roundToInt
 
 object OpLastNToList : Operator {
-    val manaCost: Int
-        get() = 0
-
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (stack.isEmpty())
             throw MishapNotEnoughArgs(1, 0)
         val arg = stack.takeLast(1).getChecked<Double>(0)
@@ -38,8 +34,6 @@ object OpLastNToList : Operator {
         }
         stack.addAll(spellListOf(output))
 
-        val sideEffects = mutableListOf<OperatorSideEffect>(OperatorSideEffect.ConsumeMana(this.manaCost))
-
-        return OperationResult(stack, sideEffects)
+        return OperationResult(stack, local, listOf())
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpModifyInPlace.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpModifyInPlace.kt
new file mode 100644
index 00000000..7b142d97
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpModifyInPlace.kt
@@ -0,0 +1,29 @@
+package at.petrak.hexcasting.common.casting.operators.lists
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import kotlin.math.roundToInt
+
+object OpModifyInPlace : ConstManaOperator {
+    override val argc = 3
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val list = args.getChecked<List<SpellDatum<*>>>(0)
+        val index = args.getChecked<Double>(1).roundToInt()
+        val iota = args[2]
+
+        if (0 > index || index > list.size)
+            return spellListOf(list)
+
+
+        val newList = list.toMutableList()
+        if (index == list.size)
+            newList.add(iota)
+        else
+            newList[index] = iota
+
+        return spellListOf(newList)
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpSlice.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpSlice.kt
new file mode 100644
index 00000000..195e5b36
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/lists/OpSlice.kt
@@ -0,0 +1,25 @@
+package at.petrak.hexcasting.common.casting.operators.lists
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import net.minecraft.util.Mth
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+object OpSlice : ConstManaOperator {
+    override val argc = 3
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val list = args.getChecked<List<SpellDatum<*>>>(0)
+        val index1 = Mth.clamp(args.getChecked<Double>(1).roundToInt(), 0, list.size)
+        val index2 = Mth.clamp(args.getChecked<Double>(2).roundToInt(), 0, list.size)
+
+        if (index1 == index2)
+            return spellListOf(listOf<SpellDatum<*>>())
+
+        return spellListOf(list.subList(min(index1, index2), max(index1, index2)))
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPeekLocal.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPeekLocal.kt
new file mode 100644
index 00000000..5a0eb86f
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPeekLocal.kt
@@ -0,0 +1,17 @@
+package at.petrak.hexcasting.common.casting.operators.local
+
+import at.petrak.hexcasting.api.spell.OperationResult
+import at.petrak.hexcasting.api.spell.Operator
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+
+object OpPeekLocal : Operator {
+    override fun operate(
+        stack: MutableList<SpellDatum<*>>,
+        local: SpellDatum<*>,
+        ctx: CastingContext
+    ): OperationResult {
+        stack.add(local)
+        return OperationResult(stack, local, listOf())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPushLocal.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPushLocal.kt
new file mode 100644
index 00000000..d97986f8
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/local/OpPushLocal.kt
@@ -0,0 +1,20 @@
+package at.petrak.hexcasting.common.casting.operators.local
+
+import at.petrak.hexcasting.api.spell.OperationResult
+import at.petrak.hexcasting.api.spell.Operator
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
+
+object OpPushLocal : Operator {
+    override fun operate(
+        stack: MutableList<SpellDatum<*>>,
+        local: SpellDatum<*>,
+        ctx: CastingContext
+    ): OperationResult {
+        if (stack.isEmpty())
+            throw MishapNotEnoughArgs(1, 0)
+        val newLocal = stack.removeLast()
+        return OperationResult(stack, newLocal, listOf())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/MathOpUtils.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/MathOpUtils.kt
index 49245675..8665683e 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/MathOpUtils.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/MathOpUtils.kt
@@ -17,4 +17,15 @@ object MathOpUtils {
                 TranslatableComponent("hexcasting.mishap.invalid_value.numvec")
             )
         }
+
+    fun GetNumOrList(datum: SpellDatum<*>, reverseIdx: Int): Either<Double, List<SpellDatum<*>>> =
+        when (datum.payload) {
+            is Double -> Either.left(datum.payload)
+            is List<*> -> Either.right(datum.payload.filterIsInstance<SpellDatum<*>>())
+            else -> throw MishapInvalidIota(
+                datum,
+                reverseIdx,
+                TranslatableComponent("hexcasting.mishap.invalid_value.numlist")
+            )
+        }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt
index d011529a..c6eb073b 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/OpPowProj.kt
@@ -37,9 +37,9 @@ object OpPowProj : ConstManaOperator {
                         Vec3(lvec.x.pow(rnum), lvec.y.pow(rnum), lvec.z.pow(rnum))
                     },
                     { rvec ->
-                        if (rvec == Vec3.ZERO)
+                        if (lvec == Vec3.ZERO)
                             throw MishapDivideByZero.of(lvec, rvec, "project")
-                        rvec.scale(lvec.dot(rvec) / rvec.dot(rvec))
+                        rvec.scale(rvec.dot(lvec) / lvec.dot(lvec))
                     }
                 )
             })
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt
new file mode 100644
index 00000000..c9e9a5b6
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpAnd.kt
@@ -0,0 +1,27 @@
+package at.petrak.hexcasting.common.casting.operators.math.bit
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.common.casting.operators.math.MathOpUtils
+import kotlin.math.roundToInt
+
+object OpAnd : ConstManaOperator {
+    override val argc = 2
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val firstParam = MathOpUtils.GetNumOrList(args[0], 0)
+
+        if (firstParam.right().isPresent) {
+            val list1 = firstParam.right().get()
+            val list2 = args.getChecked<List<SpellDatum<*>>>(1)
+            return spellListOf(list1.filter { it in list2 })
+        }
+
+        val num1 = firstParam.left().get().roundToInt()
+        val num2 = args.getChecked<Double>(1).roundToInt()
+        return spellListOf((num1 and num2).toDouble())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpNot.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpNot.kt
new file mode 100644
index 00000000..24c53162
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpNot.kt
@@ -0,0 +1,17 @@
+package at.petrak.hexcasting.common.casting.operators.math.bit
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import kotlin.math.roundToInt
+
+object OpNot : ConstManaOperator {
+    override val argc = 1
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val num = args.getChecked<Double>(0).roundToInt()
+        return spellListOf((num.inv()).toDouble())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt
new file mode 100644
index 00000000..31f88dd2
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpOr.kt
@@ -0,0 +1,27 @@
+package at.petrak.hexcasting.common.casting.operators.math.bit
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.common.casting.operators.math.MathOpUtils
+import kotlin.math.roundToInt
+
+object OpOr : ConstManaOperator {
+    override val argc = 2
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val firstParam = MathOpUtils.GetNumOrList(args[0], 0)
+
+        if (firstParam.right().isPresent) {
+            val list1 = firstParam.right().get()
+            val list2 = args.getChecked<List<SpellDatum<*>>>(1)
+            return spellListOf(list1 + list2.filter { it !in list1 })
+        }
+
+        val num1 = firstParam.left().get().roundToInt()
+        val num2 = args.getChecked<Double>(1).roundToInt()
+        return spellListOf((num1 or num2).toDouble())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpToSet.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpToSet.kt
new file mode 100644
index 00000000..9386c376
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpToSet.kt
@@ -0,0 +1,16 @@
+package at.petrak.hexcasting.common.casting.operators.math.bit
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+
+object OpToSet : ConstManaOperator {
+    override val argc = 1
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val payload = args.getChecked<List<SpellDatum<*>>>(0)
+        return spellListOf(payload.toSet().toList())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt
new file mode 100644
index 00000000..321b0287
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/bit/OpXor.kt
@@ -0,0 +1,27 @@
+package at.petrak.hexcasting.common.casting.operators.math.bit
+
+import at.petrak.hexcasting.api.spell.ConstManaOperator
+import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
+import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.common.casting.operators.math.MathOpUtils
+import kotlin.math.roundToInt
+
+object OpXor : ConstManaOperator {
+    override val argc = 2
+
+    override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
+        val firstParam = MathOpUtils.GetNumOrList(args[0], 0)
+
+        if (firstParam.right().isPresent) {
+            val list1 = firstParam.right().get()
+            val list2 = args.getChecked<List<SpellDatum<*>>>(1)
+            return spellListOf(list1.filter { it !in list2 } + list2.filter { it !in list1 })
+        }
+
+        val num1 = firstParam.left().get().roundToInt()
+        val num2 = args.getChecked<Double>(1).roundToInt()
+        return spellListOf((num1 xor num2).toDouble())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpAnd.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolAnd.kt
similarity index 93%
rename from src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpAnd.kt
rename to src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolAnd.kt
index 350a42e7..a1ed4220 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpAnd.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolAnd.kt
@@ -2,10 +2,10 @@ package at.petrak.hexcasting.common.casting.operators.math.logic
 
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 
-object OpAnd : ConstManaOperator {
+object OpBoolAnd : ConstManaOperator {
     override val argc = 2
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpIdentityKindOf.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolIdentityKindOf.kt
similarity index 93%
rename from src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpIdentityKindOf.kt
rename to src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolIdentityKindOf.kt
index ddacc7b1..3ff7c0d3 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpIdentityKindOf.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolIdentityKindOf.kt
@@ -7,7 +7,7 @@ import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
 import net.minecraft.world.phys.Vec3
 
-object OpIdentityKindOf : ConstManaOperator {
+object OpBoolIdentityKindOf : ConstManaOperator {
     override val argc = 1
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpNot.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolNot.kt
similarity index 94%
rename from src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpNot.kt
rename to src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolNot.kt
index 7c62b7ba..434375c3 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpNot.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolNot.kt
@@ -7,7 +7,7 @@ import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
 import net.minecraft.world.phys.Vec3
 
-object OpNot : ConstManaOperator {
+object OpBoolNot : ConstManaOperator {
     override val argc = 1
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpOr.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolOr.kt
similarity index 93%
rename from src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpOr.kt
rename to src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolOr.kt
index eb75a5f4..87aa9c34 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpOr.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolOr.kt
@@ -5,7 +5,7 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
 
-object OpOr : ConstManaOperator {
+object OpBoolOr : ConstManaOperator {
     override val argc = 2
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpXor.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolXor.kt
similarity index 94%
rename from src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpXor.kt
rename to src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolXor.kt
index 284fb809..757dede1 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpXor.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/math/logic/OpBoolXor.kt
@@ -5,7 +5,7 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
 
-object OpXor : ConstManaOperator {
+object OpBoolXor : ConstManaOperator {
     override val argc = 2
 
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntitiesBy.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntitiesBy.kt
index 575bf8d5..b9cfc538 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntitiesBy.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntitiesBy.kt
@@ -31,7 +31,7 @@ class OpGetEntitiesBy(val checker: Predicate<Entity>, val negate: Boolean) : Con
         val entitiesGot = ctx.world.getEntities(
             null,
             aabb
-        ) { (checker.test(it) != negate) && ctx.isEntityInRange(it) && it.distanceToSqr(pos) <= radius * radius }
+        ) { (checker.test(it) != negate) && ctx.isEntityInRange(it) && it.isAlive && !it.isSpectator && it.distanceToSqr(pos) <= radius * radius }
             .sortedBy { it.distanceToSqr(pos) }
         return spellListOf(entitiesGot)
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntityAt.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntityAt.kt
index 3d6b1afa..51c6491c 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntityAt.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/selectors/OpGetEntityAt.kt
@@ -4,8 +4,8 @@ import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
 import at.petrak.hexcasting.api.spell.SpellDatum
-import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.spell.Widget
+import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.phys.AABB
 import net.minecraft.world.phys.Vec3
@@ -17,7 +17,8 @@ class OpGetEntityAt(val checker: Predicate<Entity>) : ConstManaOperator {
         val pos = args.getChecked<Vec3>(0)
         ctx.assertVecInRange(pos)
         val aabb = AABB(pos.add(Vec3(-0.5, -0.5, -0.5)), pos.add(Vec3(0.5, 0.5, 0.5)))
-        val entitiesGot = ctx.world.getEntities(null, aabb, checker)
+        val entitiesGot = ctx.world.getEntities(null, aabb)
+            { checker.test(it) && ctx.isEntityInRange(it) && it.isAlive && !it.isSpectator }
 
         val entity = entitiesGot.getOrNull(0) ?: Widget.NULL
         return spellListOf(entity)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpAddMotion.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpAddMotion.kt
index dfd47912..b28cf484 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpAddMotion.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpAddMotion.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -26,7 +27,7 @@ object OpAddMotion : SpellOperator {
         ctx.markEntityAsMotionAdded(target)
         return Triple(
             Spell(target, motion),
-            (motionForCost * 10_000f).toInt(),
+            (motionForCost * ManaConstants.DUST_UNIT).toInt(),
             listOf(
                 ParticleSpray(
                     target.position().add(0.0, target.eyeHeight / 2.0, 0.0),
@@ -41,6 +42,7 @@ object OpAddMotion : SpellOperator {
     private data class Spell(val target: Entity, val motion: Vec3) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
             target.push(motion.x, motion.y, motion.z)
+            target.hurtMarked = true // Whyyyyy
         }
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt
index 1d6ddc71..2519a54c 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBeep.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -27,13 +28,12 @@ object OpBeep : SpellOperator {
 
         return Triple(
             Spell(target, note, NoteBlockInstrument.values()[instrument]),
-            1_000,
+            ManaConstants.DUST_UNIT / 10,
             listOf(ParticleSpray.Cloud(target, 1.0))
         )
     }
 
-    override val hasCastingSound: Boolean
-        get() = false
+    override fun hasCastingSound(ctx: CastingContext) = false
 
     private data class Spell(val target: Vec3, val note: Int, val instrument: NoteBlockInstrument) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt
index 4488abd2..067e395f 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBlink.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -38,7 +39,7 @@ object OpBlink : SpellOperator {
 
         return Triple(
             Spell(target, delta),
-            50_000 * delta.roundToInt(),
+            ManaConstants.SHARD_UNIT * delta.roundToInt(),
             listOf(
                 ParticleSpray.Cloud(targetMiddlePos, 2.0, 50),
                 ParticleSpray.Burst(targetMiddlePos.add(dvec), 2.0, 100)
@@ -51,6 +52,7 @@ object OpBlink : SpellOperator {
             val dvec = targetDelta(ctx, target, delta)
             target.setPos(target.position().add(dvec))
             if (target is ServerPlayer) {
+                target.connection.resetPosition()
                 HexMessages.getNetwork().send(PacketDistributor.PLAYER.with { target }, MsgBlinkAck(dvec))
             }
         }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt
index 48f8aced..b786d8b5 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpBreakBlock.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.mod.HexConfig
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
@@ -25,7 +26,7 @@ object OpBreakBlock : SpellOperator {
         val centered = Vec3.atCenterOf(BlockPos(pos))
         return Triple(
             Spell(pos),
-            20_000,
+            ManaConstants.DUST_UNIT * 2,
             listOf(ParticleSpray.Burst(centered, 1.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpColorize.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpColorize.kt
index f2bb25d4..85cda3c4 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpColorize.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpColorize.kt
@@ -6,6 +6,7 @@ import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import at.petrak.hexcasting.api.misc.FrozenColorizer
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.mishaps.MishapBadOffhandItem
 import at.petrak.hexcasting.api.player.HexPlayerDataHelper
 
@@ -26,14 +27,14 @@ object OpColorize : SpellOperator {
         }
         return Triple(
             Spell,
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf()
         )
     }
 
     private object Spell : RenderedSpell {
         override fun cast(ctx: CastingContext) {
-            val (handStack) = ctx.getHeldItemToOperateOn { FrozenColorizer.isColorizer(it) }.copy()
+            val handStack = ctx.getHeldItemToOperateOn { FrozenColorizer.isColorizer(it) }.first.copy()
             if (FrozenColorizer.isColorizer(handStack)) {
                 if (ctx.withdrawItem(handStack.item, 1, true)) {
                     HexPlayerDataHelper.setColorizer(ctx.caster,
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt
index 99558354..f37f1274 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpConjure.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -26,7 +27,7 @@ class OpConjure(val light: Boolean) : SpellOperator {
 
         return Triple(
             Spell(target, light),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Cloud(Vec3.atCenterOf(BlockPos(target)), 1.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt
index 841120e9..a24249e2 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpCreateWater.kt
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
 import at.petrak.hexcasting.HexMod
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -9,8 +10,17 @@ import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.core.BlockPos
 import net.minecraft.world.item.BucketItem
+import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
+import net.minecraft.world.level.block.AbstractCauldronBlock
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.CauldronBlock
+import net.minecraft.world.level.block.LayeredCauldronBlock
+import net.minecraft.world.level.material.Fluids
 import net.minecraft.world.phys.Vec3
+import net.minecraftforge.fluids.FluidActionResult
+import net.minecraftforge.fluids.FluidStack
+import net.minecraftforge.fluids.FluidUtil
 
 object OpCreateWater : SpellOperator {
     override val argc = 1
@@ -23,7 +33,7 @@ object OpCreateWater : SpellOperator {
 
         return Triple(
             Spell(target),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0))
         )
     }
@@ -34,13 +44,21 @@ object OpCreateWater : SpellOperator {
 
             if (!ctx.world.mayInteract(ctx.caster, pos))
                 return
-            // Just steal bucket code lmao
-            val charlie = Items.WATER_BUCKET
-            if (charlie is BucketItem) {
-                // make the player null so we don't give them a usage statistic for example
-                charlie.emptyContents(null, ctx.world, pos, null)
-            } else {
-                HexMod.getLogger().warn("Items.WATER_BUCKET wasn't a BucketItem?")
+
+            val state = ctx.world.getBlockState(pos)
+
+            if (state.block is AbstractCauldronBlock)
+                ctx.world.setBlock(pos, Blocks.WATER_CAULDRON.defaultBlockState().setValue(LayeredCauldronBlock.LEVEL, 3), 3)
+            else if (FluidUtil.tryPlaceFluid(null, ctx.world, ctx.castingHand, pos, ItemStack(Items.WATER_BUCKET), FluidStack(
+                    Fluids.WATER, 1000)) == FluidActionResult.FAILURE) {
+                // Just steal bucket code lmao
+                val charlie = Items.WATER_BUCKET
+                if (charlie is BucketItem) {
+                    // make the player null so we don't give them a usage statistic for example
+                    charlie.emptyContents(null, ctx.world, pos, null)
+                } else {
+                    HexMod.getLogger().warn("Items.WATER_BUCKET wasn't a BucketItem?")
+                }
             }
         }
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt
index 2b8893d1..f28d69af 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpDestroyWater.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.*
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.casting.CastingContext
@@ -28,7 +29,7 @@ object OpDestroyWater : SpellOperator {
 
         return Triple(
             Spell(target),
-            200_000,
+            2 * ManaConstants.CRYSTAL_UNIT,
             listOf(ParticleSpray.Burst(target, 3.0))
         )
     }
@@ -41,9 +42,11 @@ object OpDestroyWater : SpellOperator {
             // SpongeBlock.java
             val todo = ArrayDeque<BlockPos>()
             val seen = HashSet<BlockPos>()
-            todo.add(BlockPos(target))
-            for (dir in Direction.values()) { // a little extra range on the initial cast to make it feel more intuitive
-                todo.add(BlockPos(target).relative(dir))
+            val basePos = BlockPos(target)
+
+            // a little extra range on the initial cast to make it feel more intuitive
+            for (xShift in -2..2) for (yShift in -2..2) for (zShift in -2..2) {
+                todo.add(basePos.offset(xShift, yShift, zShift))
             }
 
             var successes = 0
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpEdifySapling.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpEdifySapling.kt
index ec0932aa..21b367b8 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpEdifySapling.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpEdifySapling.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -29,7 +30,7 @@ object OpEdifySapling : SpellOperator {
 
         return Triple(
             Spell(bpos),
-            100_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray(Vec3.atCenterOf(bpos), Vec3(0.0, 2.0, 0.0), 0.1, Math.PI / 4, 100))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpErase.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpErase.kt
index dbf084c2..51949fa7 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpErase.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpErase.kt
@@ -1,11 +1,12 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.cap.HexCapabilities
 import at.petrak.hexcasting.api.spell.mishaps.MishapBadOffhandItem
 
 class OpErase : SpellOperator {
@@ -16,14 +17,14 @@ class OpErase : SpellOperator {
         ctx: CastingContext
     ): Triple<RenderedSpell, Int, List<ParticleSpray>> {
         val (handStack, hand) = ctx.getHeldItemToOperateOn {
-            val spellHolder = it.getCapability(HexCapabilities.SPELL).resolve()
-            val datumHolder = it.getCapability(HexCapabilities.DATUM).resolve()
+            val spellHolder = HexCapabilities.getCapability(it, HexCapabilities.SPELL)
+            val datumHolder = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
 
             (spellHolder.isPresent && spellHolder.get().patterns != null) ||
                     (datumHolder.isPresent && datumHolder.get().writeDatum(null, true))
         }
-        val spellHolder = handStack.getCapability(HexCapabilities.SPELL).resolve()
-        val datumHolder = handStack.getCapability(HexCapabilities.DATUM).resolve()
+        val spellHolder = HexCapabilities.getCapability(handStack, HexCapabilities.SPELL)
+        val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
 
         if ((!spellHolder.isPresent || spellHolder.get().patterns == null) &&
             (!datumHolder.isPresent || datumHolder.get().readDatum(ctx.world) == null ||
@@ -31,20 +32,20 @@ class OpErase : SpellOperator {
             throw MishapBadOffhandItem.of(handStack, hand, "eraseable")
         }
 
-        return Triple(Spell, 10_000, listOf())
+        return Triple(Spell, ManaConstants.DUST_UNIT, listOf())
     }
 
     private object Spell : RenderedSpell {
         override fun cast(ctx: CastingContext) {
             val (handStack) = ctx.getHeldItemToOperateOn {
-                val spellHolder = it.getCapability(HexCapabilities.SPELL).resolve()
-                val datumHolder = it.getCapability(HexCapabilities.DATUM).resolve()
+                val spellHolder = HexCapabilities.getCapability(it, HexCapabilities.SPELL)
+                val datumHolder = HexCapabilities.getCapability(it, HexCapabilities.DATUM)
 
                 (spellHolder.isPresent && spellHolder.get().patterns != null) ||
                         (datumHolder.isPresent && datumHolder.get().writeDatum(null, true))
             }
-            val spellHolder = handStack.getCapability(HexCapabilities.SPELL).resolve()
-            val datumHolder = handStack.getCapability(HexCapabilities.DATUM).resolve()
+            val spellHolder = HexCapabilities.getCapability(handStack, HexCapabilities.SPELL)
+            val datumHolder = HexCapabilities.getCapability(handStack, HexCapabilities.DATUM)
 
             if (spellHolder.isPresent && spellHolder.get().patterns != null)
                 spellHolder.get().clearPatterns()
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt
index 43b3917f..83220882 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExplode.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -24,7 +25,7 @@ class OpExplode(val fire: Boolean) : SpellOperator {
         ctx.assertVecInRange(pos)
         return Triple(
             Spell(pos, strength, this.fire),
-            ((1 + Mth.clamp(strength.toFloat(), 0f, 10f) + if (this.fire) 2 else 0) * 50_000.0).toInt(),
+            ((1 + Mth.clamp(strength.toFloat(), 0f, 10f) + if (this.fire) 2 else 0) * ManaConstants.SHARD_UNIT).toInt(),
             listOf(ParticleSpray.Burst(pos, strength, 50))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt
index 196beea2..87618c41 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpExtinguish.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.*
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.casting.CastingContext
@@ -27,7 +28,7 @@ object OpExtinguish : SpellOperator {
 
         return Triple(
             Spell(target),
-            200_000,
+            ManaConstants.CRYSTAL_UNIT,
             listOf(ParticleSpray.Burst(target, 1.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt
index 0428d0ef..0bf49491 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpIgnite.kt
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
 import at.petrak.hexcasting.HexMod
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -28,7 +29,7 @@ object OpIgnite : SpellOperator {
 
         return Triple(
             Spell(target),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt
index 28e959a1..ad5e95fc 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakeBattery.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.mod.HexItemTags
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
@@ -14,10 +15,12 @@ import at.petrak.hexcasting.common.items.HexItems
 import at.petrak.hexcasting.common.items.magic.ItemManaHolder
 import net.minecraft.world.entity.item.ItemEntity
 import net.minecraft.world.item.ItemStack
-import net.minecraft.world.item.Items
 
 object OpMakeBattery : SpellOperator {
     override val argc = 1
+
+    override val isGreat = true
+
     override fun execute(
         args: List<SpellDatum<*>>,
         ctx: CastingContext
@@ -26,7 +29,7 @@ object OpMakeBattery : SpellOperator {
 
         val (handStack, hand) = ctx.getHeldItemToOperateOn { it.`is`(HexItemTags.PHIAL_BASE) }
 
-        if (handStack.`is`(HexItemTags.PHIAL_BASE)) {
+        if (!handStack.`is`(HexItemTags.PHIAL_BASE)) {
             throw MishapBadOffhandItem.of(
                 handStack,
                 hand,
@@ -51,11 +54,11 @@ object OpMakeBattery : SpellOperator {
         ) {
             throw MishapBadItem.of(
                 entity,
-                "mana"
+                "mana_for_battery"
             )
         }
 
-        return Triple(Spell(entity), 100_000, listOf(ParticleSpray.Burst(entity.position(), 0.5)))
+        return Triple(Spell(entity), ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.Burst(entity.position(), 0.5)))
     }
 
     private data class Spell(val itemEntity: ItemEntity) : RenderedSpell {
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt
index 896736f8..70ee955c 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpMakePackagedSpell.kt
@@ -23,11 +23,13 @@ class OpMakePackagedSpell<T : ItemPackagedSpell>(val itemType: T, val cost: Int)
         ctx: CastingContext
     ): Triple<RenderedSpell, Int, List<ParticleSpray>> {
         val entity = args.getChecked<ItemEntity>(0)
-        val patterns = args.getChecked<List<SpellDatum<*>>>(1).map {
+        val patternsRaw = args.getChecked<List<SpellDatum<*>>>(1)
+
+        val patterns = patternsRaw.map {
             if (it.payload is HexPattern)
                 it.payload
             else
-                throw MishapInvalidIota(it, 0, TranslatableComponent("hexcasting.mishap.invalid_value.list.pattern"))
+                throw MishapInvalidIota(SpellDatum.make(patternsRaw), 0, TranslatableComponent("hexcasting.mishap.invalid_value.list.pattern"))
         }
 
         val (handStack, hand) = ctx.getHeldItemToOperateOn { it.`is`(itemType) }
@@ -44,7 +46,7 @@ class OpMakePackagedSpell<T : ItemPackagedSpell>(val itemType: T, val cost: Int)
         ) {
             throw MishapBadItem.of(
                 entity,
-                "mana"
+                "mana_for_battery"
             )
         }
 
@@ -54,7 +56,7 @@ class OpMakePackagedSpell<T : ItemPackagedSpell>(val itemType: T, val cost: Int)
     private inner class Spell(val itemEntity: ItemEntity, val patterns: List<HexPattern>) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
             val (handStack) = ctx.getHeldItemToOperateOn { it.`is`(itemType) }
-            val spellHolder = handStack.getCapability(HexCapabilities.SPELL).resolve()
+            val spellHolder = HexCapabilities.getCapability(handStack, HexCapabilities.SPELL)
             if (spellHolder.isPresent
                 && spellHolder.get().patterns == null
                 && itemEntity.isAlive
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt
index 9a372de6..f921d1e5 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPlaceBlock.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -31,7 +32,7 @@ object OpPlaceBlock : SpellOperator {
         ctx.assertVecInRange(pos)
         return Triple(
             Spell(pos),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Cloud(Vec3.atCenterOf(BlockPos(pos)), 1.0))
         )
     }
@@ -48,39 +49,41 @@ object OpPlaceBlock : SpellOperator {
                 val placeeSlot = ctx.getOperativeSlot { it.item is BlockItem }
                 if (placeeSlot != null) {
                     val placeeStack = ctx.caster.inventory.getItem(placeeSlot).copy()
-                    val placee = placeeStack.item as BlockItem
-                    if (ctx.withdrawItem(placee, 1, false)) {
-                        // https://github.com/VazkiiMods/Psi/blob/master/src/main/java/vazkii/psi/common/spell/trick/block/PieceTrickPlaceBlock.java#L143
-                        val evt = BlockEvent.EntityPlaceEvent(
-                            BlockSnapshot.create(ctx.world.dimension(), ctx.world, pos),
-                            ctx.world.getBlockState(pos.above()),
-                            ctx.caster
-                        )
-                        MinecraftForge.EVENT_BUS.post(evt)
-
-                        // we temporarily give the player the stack, place it using mc code, then give them the old stack back.
-                        val oldStack = ctx.caster.getItemInHand(ctx.castingHand)
-                        val spoofedStack = placeeStack.copy()
-                        spoofedStack.count = 1
-                        ctx.caster.setItemInHand(ctx.castingHand, spoofedStack)
-
-                        val blockHit = BlockHitResult(
-                            Vec3.ZERO, ctx.caster.direction, pos, false
-                        )
-                        val itemUseCtx = UseOnContext(ctx.caster, ctx.castingHand, blockHit)
-                        val res = spoofedStack.useOn(itemUseCtx)
-
-                        ctx.caster.setItemInHand(ctx.castingHand, oldStack)
-                        if (res != InteractionResult.FAIL) {
-                            ctx.withdrawItem(placee, 1, true)
-
-                            ctx.world.playSound(
-                                ctx.caster,
-                                vec.x, vec.y, vec.z, bstate.soundType.placeSound, SoundSource.BLOCKS, 1.0f,
-                                1.0f + (Math.random() * 0.5 - 0.25).toFloat()
+                    if (!placeeStack.isEmpty) {
+                        val placee = placeeStack.item as BlockItem
+                        if (ctx.withdrawItem(placee, 1, false)) {
+                            // https://github.com/VazkiiMods/Psi/blob/master/src/main/java/vazkii/psi/common/spell/trick/block/PieceTrickPlaceBlock.java#L143
+                            val evt = BlockEvent.EntityPlaceEvent(
+                                BlockSnapshot.create(ctx.world.dimension(), ctx.world, pos),
+                                ctx.world.getBlockState(pos.above()),
+                                ctx.caster
                             )
-                            val particle = BlockParticleOption(ParticleTypes.BLOCK, bstate)
-                            ctx.world.sendParticles(particle, vec.x, vec.y, vec.z, 4, 0.1, 0.2, 0.1, 0.1)
+                            MinecraftForge.EVENT_BUS.post(evt)
+
+                            // we temporarily give the player the stack, place it using mc code, then give them the old stack back.
+                            val oldStack = ctx.caster.getItemInHand(ctx.castingHand)
+                            val spoofedStack = placeeStack.copy()
+                            spoofedStack.count = 1
+                            ctx.caster.setItemInHand(ctx.castingHand, spoofedStack)
+
+                            val blockHit = BlockHitResult(
+                                Vec3.ZERO, ctx.caster.direction, pos, false
+                            )
+                            val itemUseCtx = UseOnContext(ctx.caster, ctx.castingHand, blockHit)
+                            val res = spoofedStack.useOn(itemUseCtx)
+
+                            ctx.caster.setItemInHand(ctx.castingHand, oldStack)
+                            if (res != InteractionResult.FAIL) {
+                                ctx.withdrawItem(placee, 1, true)
+
+                                ctx.world.playSound(
+                                    ctx.caster,
+                                    vec.x, vec.y, vec.z, bstate.soundType.placeSound, SoundSource.BLOCKS, 1.0f,
+                                    1.0f + (Math.random() * 0.5 - 0.25).toFloat()
+                                )
+                                val particle = BlockParticleOption(ParticleTypes.BLOCK, bstate)
+                                ctx.world.sendParticles(particle, vec.x, vec.y, vec.z, 4, 0.1, 0.2, 0.1, 0.1)
+                            }
                         }
                     }
                 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt
index bb9e680a..7afac50b 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPotionEffect.kt
@@ -18,11 +18,10 @@ class OpPotionEffect(
     val baseCost: Int,
     val allowPotency: Boolean,
     val potencyCubic: Boolean,
-    val _isGreat: Boolean,
+    override val isGreat: Boolean,
 ) : SpellOperator {
     override val argc: Int
         get() = if (this.allowPotency) 3 else 2
-    override val isGreat = this._isGreat
 
     override fun execute(
         args: List<SpellDatum<*>>,
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPrint.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPrint.kt
index 9ce43330..c3babeca 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPrint.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpPrint.kt
@@ -10,13 +10,13 @@ import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
 import net.minecraft.Util
 
 object OpPrint : Operator {
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (stack.isEmpty()) {
             throw MishapNotEnoughArgs(1, 0)
         }
         val datum = stack[stack.lastIndex]
         return OperationResult(
-            stack, listOf(
+            stack, local, listOf(
                 OperatorSideEffect.AttemptSpell(Spell(datum), false)
             )
         )
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt
index 37e5410f..e562ac30 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpRecharge.kt
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
 import at.petrak.hexcasting.api.cap.HexCapabilities
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -19,11 +20,11 @@ object OpRecharge : SpellOperator {
         ctx: CastingContext
     ): Triple<RenderedSpell, Int, List<ParticleSpray>>? {
         val (handStack, hand) = ctx.getHeldItemToOperateOn {
-            val mana = it.getCapability(HexCapabilities.MANA).resolve()
+            val mana = HexCapabilities.getCapability(it, HexCapabilities.MANA)
             mana.isPresent && mana.get().canRecharge() && mana.get().mana < mana.get().maxMana
         }
 
-        val mana = handStack.getCapability(HexCapabilities.MANA).resolve()
+        val mana = HexCapabilities.getCapability(handStack, HexCapabilities.MANA)
 
         if (!mana.isPresent || !mana.get().canRecharge())
             throw MishapBadOffhandItem.of(
@@ -45,16 +46,16 @@ object OpRecharge : SpellOperator {
         if (mana.get().mana >= mana.get().maxMana)
             return null
 
-        return Triple(Spell(entity), 100_000, listOf(ParticleSpray.Burst(entity.position(), 0.5)))
+        return Triple(Spell(entity), ManaConstants.CRYSTAL_UNIT, listOf(ParticleSpray.Burst(entity.position(), 0.5)))
     }
 
     private data class Spell(val itemEntity: ItemEntity) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
             val (handStack) = ctx.getHeldItemToOperateOn {
-                val mana = it.getCapability(HexCapabilities.MANA).resolve()
+                val mana = HexCapabilities.getCapability(it, HexCapabilities.MANA)
                 mana.isPresent && mana.get().canRecharge() && mana.get().mana < mana.get().maxMana
             }
-            val mana = handStack.getCapability(HexCapabilities.MANA).resolve()
+            val mana = HexCapabilities.getCapability(handStack, HexCapabilities.MANA)
 
             if (mana.isPresent && itemEntity.isAlive) {
                 val entityStack = itemEntity.item.copy()
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt
index c47a0d75..9898c681 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/OpTheOnlyReasonAnyoneDownloadedPsi.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -27,7 +28,7 @@ object OpTheOnlyReasonAnyoneDownloadedPsi : SpellOperator {
 
         return Triple(
             Spell(target),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt
index ecf6230f..c593ba65 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpBrainsweep.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -15,6 +16,7 @@ import net.minecraft.core.BlockPos
 import net.minecraft.sounds.SoundEvents
 import net.minecraft.sounds.SoundSource
 import net.minecraft.world.entity.npc.Villager
+import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.phys.Vec3
 
 object OpBrainsweep : SpellOperator {
@@ -43,15 +45,15 @@ object OpBrainsweep : SpellOperator {
             ?: throw MishapBadBrainsweep(sacrifice, bpos)
 
         return Triple(
-            Spell(bpos, sacrifice, recipe),
-            1_000_000,
+            Spell(bpos, state, sacrifice, recipe),
+            10 * ManaConstants.CRYSTAL_UNIT,
             listOf(ParticleSpray.Cloud(sacrifice.position(), 1.0), ParticleSpray.Burst(Vec3.atCenterOf(bpos), 0.3, 100))
         )
     }
 
-    private data class Spell(val pos: BlockPos, val sacrifice: Villager, val recipe: BrainsweepRecipe) : RenderedSpell {
+    private data class Spell(val pos: BlockPos, val state: BlockState, val sacrifice: Villager, val recipe: BrainsweepRecipe) : RenderedSpell {
         override fun cast(ctx: CastingContext) {
-            ctx.world.setBlockAndUpdate(pos, recipe.result)
+            ctx.world.setBlockAndUpdate(pos, BrainsweepRecipe.copyProperties(state, recipe.result))
             Brainsweeping.brainsweep(sacrifice)
 
             ctx.world.playSound(null, sacrifice, SoundEvents.VILLAGER_DEATH, SoundSource.AMBIENT, 0.8f, 1f)
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt
index 336e0924..c77fe62d 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpCreateLava.kt
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
 import at.petrak.hexcasting.HexMod
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -9,8 +10,15 @@ import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
 import net.minecraft.core.BlockPos
 import net.minecraft.world.item.BucketItem
+import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
+import net.minecraft.world.level.block.AbstractCauldronBlock
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.material.Fluids
 import net.minecraft.world.phys.Vec3
+import net.minecraftforge.fluids.FluidActionResult
+import net.minecraftforge.fluids.FluidStack
+import net.minecraftforge.fluids.FluidUtil
 
 object OpCreateLava : SpellOperator {
     override val argc = 1
@@ -24,7 +32,7 @@ object OpCreateLava : SpellOperator {
 
         return Triple(
             Spell(target),
-            100_000,
+            ManaConstants.CRYSTAL_UNIT,
             listOf(ParticleSpray.Burst(Vec3.atCenterOf(BlockPos(target)), 1.0)),
         )
     }
@@ -36,13 +44,20 @@ object OpCreateLava : SpellOperator {
             if (!ctx.world.mayInteract(ctx.caster, pos))
                 return
 
-            // Just steal bucket code lmao
-            val charlie = Items.LAVA_BUCKET
-            if (charlie is BucketItem) {
-                // make the player null so we don't give them a usage statistic for example
-                charlie.emptyContents(null, ctx.world, pos, null)
-            } else {
-                HexMod.getLogger().warn("Items.LAVA_BUCKET wasn't a BucketItem?")
+            val state = ctx.world.getBlockState(pos)
+
+            if (state.block is AbstractCauldronBlock)
+                ctx.world.setBlock(pos, Blocks.LAVA_CAULDRON.defaultBlockState(), 3)
+            else if (FluidUtil.tryPlaceFluid(null, ctx.world, ctx.castingHand, pos, ItemStack(Items.LAVA_BUCKET), FluidStack(
+                    Fluids.LAVA, 1000)) == FluidActionResult.FAILURE) {
+                // Just steal bucket code lmao
+                val charlie = Items.LAVA_BUCKET
+                if (charlie is BucketItem) {
+                    // make the player null so we don't give them a usage statistic for example
+                    charlie.emptyContents(null, ctx.world, pos, null)
+                } else {
+                    HexMod.getLogger().warn("Items.WATER_BUCKET wasn't a BucketItem?")
+                }
             }
         }
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpFlight.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpFlight.kt
index 248f1926..21f74d52 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpFlight.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpFlight.kt
@@ -1,13 +1,14 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.player.FlightAbility
+import at.petrak.hexcasting.api.player.HexPlayerDataHelper
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.SpellOperator
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.player.HexPlayerDataHelper
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.phys.Vec3
 import net.minecraftforge.event.entity.living.LivingEvent
@@ -31,7 +32,7 @@ object OpFlight : SpellOperator {
         val time = (timeRaw * 20.0).roundToInt()
         return Triple(
             Spell(target, time, radiusRaw, ctx.position),
-            10_000 * (timeRaw * radiusRaw + 1.0).roundToInt(),
+            ManaConstants.DUST_UNIT * (timeRaw * radiusRaw + 1.0).roundToInt(),
             listOf(ParticleSpray(target.position(), Vec3(0.0, 2.0, 0.0), 0.0, 0.1))
         )
     }
@@ -58,6 +59,7 @@ object OpFlight : SpellOperator {
             target.onUpdateAbilities()
             // Launch the player into the air to really emphasize the flight
             target.push(0.0, 1.0, 0.0)
+            target.hurtMarked = true // Whyyyyy
         }
     }
 
@@ -82,8 +84,13 @@ object OpFlight : SpellOperator {
                     abilities.mayfly = false
                     entity.onUpdateAbilities()
                 }
-            } else
-                HexPlayerDataHelper.setFlight(entity,
+            } else {
+                if (!entity.abilities.mayfly) {
+                    entity.abilities.mayfly = true
+                    entity.onUpdateAbilities()
+                }
+                HexPlayerDataHelper.setFlight(
+                    entity,
                     FlightAbility(
                         true,
                         flightTime,
@@ -92,6 +99,7 @@ object OpFlight : SpellOperator {
                         flight.radius
                     )
                 )
+            }
         }
 
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpLightning.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpLightning.kt
index b7953f67..e207ae20 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpLightning.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpLightning.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -23,7 +24,7 @@ object OpLightning : SpellOperator {
         ctx.assertVecInRange(target)
         return Triple(
             Spell(target),
-            150_000,
+            3 * ManaConstants.SHARD_UNIT,
             listOf(ParticleSpray(target.add(0.0, 2.0, 0.0), Vec3(0.0, -1.0, 0.0), 0.5, 0.1))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt
index 2f350f93..c72db443 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpTeleport.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -33,7 +34,7 @@ object OpTeleport : SpellOperator {
 
         return Triple(
             Spell(teleportee, delta),
-            1_000_000,
+            10 * ManaConstants.CRYSTAL_UNIT,
             listOf(ParticleSpray.Cloud(targetMiddlePos, 2.0), ParticleSpray.Burst(targetMiddlePos.add(delta), 2.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpWeather.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpWeather.kt
index dd7272a4..309dabc1 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpWeather.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/great/OpWeather.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.great
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
 import at.petrak.hexcasting.api.spell.SpellDatum
@@ -13,10 +14,13 @@ class OpWeather(val rain: Boolean) : SpellOperator {
     override fun execute(
         args: List<SpellDatum<*>>,
         ctx: CastingContext
-    ): Triple<RenderedSpell, Int, List<ParticleSpray>> {
+    ): Triple<RenderedSpell, Int, List<ParticleSpray>>? {
+        if (ctx.world.isRaining == rain)
+            return null
+
         return Triple(
             Spell(rain),
-            ((if (this.rain) 2 else 1) * 50_000),
+            if (this.rain) ManaConstants.CRYSTAL_UNIT else ManaConstants.SHARD_UNIT,
             listOf()
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt
index 786ed74c..b89c761b 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpCreateSentinel.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.sentinel
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
@@ -23,7 +24,7 @@ class OpCreateSentinel(val extendsRange: Boolean) : SpellOperator {
 
         return Triple(
             Spell(target, this.extendsRange),
-            10_000,
+            ManaConstants.DUST_UNIT,
             listOf(ParticleSpray.Burst(target, 2.0))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt
index 354d7141..57dcd7da 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpDestroySentinel.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.sentinel
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ParticleSpray
 import at.petrak.hexcasting.api.spell.RenderedSpell
 import at.petrak.hexcasting.api.spell.SpellDatum
@@ -23,7 +24,7 @@ object OpDestroySentinel : SpellOperator {
 
         return Triple(
             Spell,
-            1_000,
+            ManaConstants.DUST_UNIT / 10,
             particles
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelPos.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelPos.kt
index 50ae2d23..1ae88b78 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelPos.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelPos.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.sentinel
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
 import at.petrak.hexcasting.api.spell.SpellDatum
@@ -10,7 +11,7 @@ import at.petrak.hexcasting.api.player.HexPlayerDataHelper
 
 object OpGetSentinelPos : ConstManaOperator {
     override val argc = 0
-    override val manaCost = 1_000
+    override val manaCost = ManaConstants.DUST_UNIT / 10
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val sentinel = HexPlayerDataHelper.getSentinel(ctx.caster)
         if (sentinel.dimension != ctx.world.dimension())
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelWayfind.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelWayfind.kt
index 124e08da..16d6b1d8 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelWayfind.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/spells/sentinel/OpGetSentinelWayfind.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.spells.sentinel
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.ConstManaOperator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.Operator.Companion.spellListOf
@@ -12,7 +13,7 @@ import net.minecraft.world.phys.Vec3
 
 object OpGetSentinelWayfind : ConstManaOperator {
     override val argc = 1
-    override val manaCost = 1_000
+    override val manaCost = ManaConstants.DUST_UNIT / 10
     override fun execute(args: List<SpellDatum<*>>, ctx: CastingContext): List<SpellDatum<*>> {
         val from = args.getChecked<Vec3>(0)
 
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpAlwinfyHasAscendedToABeingOfPureMath.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpAlwinfyHasAscendedToABeingOfPureMath.kt
index c3ebdbf7..c4c74064 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpAlwinfyHasAscendedToABeingOfPureMath.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpAlwinfyHasAscendedToABeingOfPureMath.kt
@@ -1,5 +1,6 @@
 package at.petrak.hexcasting.common.casting.operators.stack
 
+import at.petrak.hexcasting.api.misc.ManaConstants
 import at.petrak.hexcasting.api.spell.OperationResult
 import at.petrak.hexcasting.api.spell.Operator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
@@ -16,7 +17,7 @@ import kotlin.math.roundToInt
 
 // "lehmer code"
 object OpAlwinfyHasAscendedToABeingOfPureMath : Operator {
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (stack.isEmpty())
             throw MishapNotEnoughArgs(1, 0) // todo: better message?
 
@@ -51,10 +52,11 @@ object OpAlwinfyHasAscendedToABeingOfPureMath : Operator {
             editTarget = editTarget.subList(1, editTarget.size)
         }
 
-        val cost = (ln((strides.lastOrNull() ?: 0).toFloat()) * 10000).toInt()
+        val cost = (ln((strides.lastOrNull() ?: 0).toFloat()) * ManaConstants.DUST_UNIT).toInt()
 
         return OperationResult(
             stack,
+            local,
             listOf(OperatorSideEffect.ConsumeMana(cost))
         )
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpFisherman.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpFisherman.kt
index 4e5f1c00..b3ea4f63 100644
--- a/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpFisherman.kt
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpFisherman.kt
@@ -5,7 +5,6 @@ import at.petrak.hexcasting.api.spell.Operator
 import at.petrak.hexcasting.api.spell.Operator.Companion.getChecked
 import at.petrak.hexcasting.api.spell.SpellDatum
 import at.petrak.hexcasting.api.spell.casting.CastingContext
-import at.petrak.hexcasting.api.spell.casting.OperatorSideEffect
 import at.petrak.hexcasting.api.spell.mishaps.MishapInvalidIota
 import at.petrak.hexcasting.api.spell.mishaps.MishapNotEnoughArgs
 import net.minecraft.network.chat.TranslatableComponent
@@ -13,17 +12,14 @@ import kotlin.math.abs
 import kotlin.math.roundToInt
 
 object OpFisherman : Operator {
-    val manaCost: Int
-        get() = 0
-
-    override fun operate(stack: MutableList<SpellDatum<*>>, ctx: CastingContext): OperationResult {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
         if (stack.isEmpty())
             throw MishapNotEnoughArgs(1, 0)
         val arg = stack.getChecked<Double>(stack.lastIndex)
         val datum = stack[stack.lastIndex]
         val distance = stack.size - (arg + 1) // because getChecked<Int> just gives me a double for some reason
         stack.removeLast()
-        if (distance < stack.size && abs(distance.roundToInt() - distance) < 0.05f) {
+        if (distance >= 0 && distance < stack.size && abs(distance.roundToInt() - distance) < 0.05f) {
             val fish = stack[distance.roundToInt()]
             stack.removeAt(distance.roundToInt())
             stack.add(stack.size, fish)
@@ -31,12 +27,10 @@ object OpFisherman : Operator {
             throw MishapInvalidIota(
                 datum,
                 0,
-                TranslatableComponent("hexcasting.mishap.invalid_value.int.between", 0, stack.size)
+                TranslatableComponent("hexcasting.mishap.invalid_value.int.between", 1, stack.size)
             )
         }
 
-        val sideEffects = mutableListOf<OperatorSideEffect>(OperatorSideEffect.ConsumeMana(manaCost))
-
-        return OperationResult(stack, sideEffects)
+        return OperationResult(stack, local, listOf())
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpStackSize.kt b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpStackSize.kt
new file mode 100644
index 00000000..0bfc664f
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/casting/operators/stack/OpStackSize.kt
@@ -0,0 +1,13 @@
+package at.petrak.hexcasting.common.casting.operators.stack
+
+import at.petrak.hexcasting.api.spell.OperationResult
+import at.petrak.hexcasting.api.spell.Operator
+import at.petrak.hexcasting.api.spell.SpellDatum
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+
+object OpStackSize : Operator {
+    override fun operate(stack: MutableList<SpellDatum<*>>, local: SpellDatum<*>, ctx: CastingContext): OperationResult {
+        stack.add(SpellDatum.make(stack.size.toDouble()))
+        return OperationResult(stack, local, listOf())
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java b/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java
index 196e81c9..d72594b2 100644
--- a/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java
+++ b/src/main/java/at/petrak/hexcasting/common/entities/EntityWallScroll.java
@@ -1,14 +1,14 @@
 package at.petrak.hexcasting.common.entities;
 
+import at.petrak.hexcasting.api.spell.math.HexPattern;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.client.RenderLib;
 import at.petrak.hexcasting.common.items.HexItems;
 import at.petrak.hexcasting.common.items.ItemScroll;
 import at.petrak.hexcasting.common.lib.HexSounds;
-import at.petrak.hexcasting.api.spell.math.HexPattern;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.protocol.Packet;
 import net.minecraft.network.syncher.EntityDataAccessor;
@@ -58,16 +58,16 @@ public class EntityWallScroll extends HangingEntity implements IEntityAdditional
     private void loadDataFromScrollItem(ItemStack scroll) {
         this.scroll = scroll;
 
-        var tag = scroll.getTag();
-        if (tag != null && tag.contains(ItemScroll.TAG_PATTERN, Tag.TAG_COMPOUND)) {
-            this.pattern = HexPattern.DeserializeFromNBT(tag.getCompound(ItemScroll.TAG_PATTERN));
+        CompoundTag patternTag = NBTHelper.getCompound(scroll, ItemScroll.TAG_PATTERN);
+        if (patternTag != null) {
+            this.pattern = HexPattern.DeserializeFromNBT(patternTag);
             if (this.level.isClientSide) {
                 var pair = RenderLib.getCenteredPattern(pattern, 128, 128, 16f);
                 var dots = pair.getSecond();
                 this.zappyPoints = RenderLib.makeZappy(dots, 10f, 0.8f, 0f);
             }
 
-            this.isAncient = tag.contains(ItemScroll.TAG_OP_ID, Tag.TAG_STRING);
+            this.isAncient = NBTHelper.hasString(scroll, ItemScroll.TAG_OP_ID);
         } else {
             this.pattern = null;
             this.zappyPoints = null;
diff --git a/src/main/java/at/petrak/hexcasting/common/items/HexItems.java b/src/main/java/at/petrak/hexcasting/common/items/HexItems.java
index adbc13bd..297a3493 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/HexItems.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/HexItems.java
@@ -5,8 +5,10 @@ import at.petrak.hexcasting.common.blocks.HexBlocks;
 import at.petrak.hexcasting.common.items.colorizer.ItemDyeColorizer;
 import at.petrak.hexcasting.common.items.colorizer.ItemPrideColorizer;
 import at.petrak.hexcasting.common.items.colorizer.ItemUUIDColorizer;
-import at.petrak.hexcasting.common.items.magic.*;
-import net.minecraft.core.NonNullList;
+import at.petrak.hexcasting.common.items.magic.ItemArtifact;
+import at.petrak.hexcasting.common.items.magic.ItemCypher;
+import at.petrak.hexcasting.common.items.magic.ItemManaBattery;
+import at.petrak.hexcasting.common.items.magic.ItemTrinket;
 import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.CreativeModeTab;
 import net.minecraft.world.item.DyeColor;
@@ -15,6 +17,7 @@ import net.minecraft.world.item.ItemStack;
 import net.minecraftforge.registries.DeferredRegister;
 import net.minecraftforge.registries.ForgeRegistries;
 import net.minecraftforge.registries.RegistryObject;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.EnumMap;
 
@@ -22,26 +25,9 @@ public class HexItems {
     public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, HexMod.MOD_ID);
     public static final CreativeModeTab TAB = new CreativeModeTab(HexMod.MOD_ID) {
         @Override
-        public ItemStack makeIcon() {
+        public @NotNull ItemStack makeIcon() {
             return new ItemStack(SPELLBOOK::get);
         }
-
-        @Override
-        public void fillItemList(NonNullList<ItemStack> items) {
-            super.fillItemList(items);
-
-            var manamounts = new int[]{
-                100_000,
-                1_000_000,
-                10_000_000,
-                100_000_000,
-                1_000_000_000,
-            };
-            for (int manamount : manamounts) {
-                var stack = new ItemStack(BATTERY.get());
-                items.add(ItemManaHolder.withMana(stack, manamount, manamount));
-            }
-        }
     };
 
     public static final RegistryObject<ItemWand> WAND_OAK = ITEMS.register("wand_oak",
@@ -88,7 +74,7 @@ public class HexItems {
         () -> new ItemArtifact(unstackable()));
 
     public static final RegistryObject<ItemManaBattery> BATTERY = ITEMS.register("battery",
-        () -> new ItemManaBattery(new Item.Properties().stacksTo(1)));
+        () -> new ItemManaBattery(props().stacksTo(1)));
 
     public static final EnumMap<DyeColor, RegistryObject<ItemDyeColorizer>> DYE_COLORIZERS = new EnumMap<>(
         DyeColor.class);
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemAbacus.java b/src/main/java/at/petrak/hexcasting/common/items/ItemAbacus.java
index ad83b8dc..b5ef3337 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemAbacus.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemAbacus.java
@@ -2,9 +2,9 @@ package at.petrak.hexcasting.common.items;
 
 import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.spell.SpellDatum;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.lib.HexSounds;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.TranslatableComponent;
 import net.minecraft.world.InteractionHand;
@@ -27,14 +27,7 @@ public class ItemAbacus extends Item implements DataHolderItem {
 
     @Override
     public @Nullable CompoundTag readDatumTag(ItemStack stack) {
-        double num;
-        var tag = stack.getTag();
-        if (tag == null) {
-            num = 0d;
-        } else {
-            num = tag.getDouble(TAG_VALUE);
-        }
-        var datum = SpellDatum.make(num);
+        var datum = SpellDatum.make(NBTHelper.getDouble(stack, TAG_VALUE));
         return datum.serializeToNBT();
     }
 
@@ -52,13 +45,8 @@ public class ItemAbacus extends Item implements DataHolderItem {
     public InteractionResultHolder<ItemStack> use(Level world, Player player, InteractionHand hand) {
         var stack = player.getItemInHand(hand);
         if (player.isShiftKeyDown()) {
-
-            var tag = stack.getOrCreateTag();
-            double oldNum = 0d;
-            if (tag.contains(TAG_VALUE, Tag.TAG_ANY_NUMERIC)) {
-                oldNum = tag.getDouble(TAG_VALUE);
-            }
-            tag.putDouble(TAG_VALUE, 0d);
+            double oldNum = NBTHelper.getDouble(stack, TAG_VALUE);
+            stack.removeTagKey(TAG_VALUE);
 
             player.playSound(HexSounds.ABACUS_SHAKE.get(), 1f, 1f);
 
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemFocus.java b/src/main/java/at/petrak/hexcasting/common/items/ItemFocus.java
index e19c6262..80812f74 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemFocus.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemFocus.java
@@ -4,8 +4,8 @@ import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.spell.SpellDatum;
 import at.petrak.hexcasting.api.spell.Widget;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
@@ -29,15 +29,12 @@ public class ItemFocus extends Item implements DataHolderItem {
 
     @Override
     public @Nullable CompoundTag readDatumTag(ItemStack stack) {
-        if (!stack.hasTag()) {
-            return null;
-        }
-        var tag = stack.getTag();
-        if (!tag.contains(TAG_DATA, Tag.TAG_COMPOUND)) {
-            return null;
-        }
+        return NBTHelper.getCompound(stack, TAG_DATA);
+    }
 
-        return tag.getCompound(TAG_DATA);
+    @Override
+    public String getDescriptionId(ItemStack stack) {
+        return super.getDescriptionId(stack) + (NBTHelper.getBoolean(stack, TAG_SEALED) ? ".sealed" : "");
     }
 
     @Override
@@ -47,18 +44,16 @@ public class ItemFocus extends Item implements DataHolderItem {
 
     @Override
     public boolean canWrite(ItemStack stack, SpellDatum<?> datum) {
-        return datum == null || !stack.hasTag() || !stack.getTag().getBoolean(TAG_SEALED);
+        return datum == null || !NBTHelper.getBoolean(stack, TAG_SEALED);
     }
 
     @Override
     public void writeDatum(ItemStack stack, SpellDatum<?> datum) {
-        CompoundTag tag = stack.getOrCreateTag();
-
         if (datum == null) {
-            tag.remove(TAG_DATA);
-            tag.remove(TAG_SEALED);
-        } else if (!tag.getBoolean(TAG_SEALED))
-            tag.put(TAG_DATA, datum.serializeToNBT());
+            stack.removeTagKey(TAG_DATA);
+            stack.removeTagKey(TAG_SEALED);
+        } else if (!NBTHelper.getBoolean(stack, TAG_SEALED))
+            NBTHelper.put(stack, TAG_DATA, datum.serializeToNBT());
     }
 
     @Override
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java b/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java
index ecfcd4fc..051a192f 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemLens.java
@@ -1,12 +1,18 @@
 package at.petrak.hexcasting.common.items;
 
+import at.petrak.hexcasting.common.network.HexMessages;
+import at.petrak.hexcasting.common.network.MsgUpdateComparatorVisualsAck;
+import com.mojang.datafixers.util.Pair;
+import net.minecraft.core.BlockPos;
 import net.minecraft.core.BlockSource;
 import net.minecraft.core.dispenser.OptionalDispenseItemBehavior;
+import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.sounds.SoundEvent;
 import net.minecraft.sounds.SoundEvents;
 import net.minecraft.stats.Stats;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.EquipmentSlot;
 import net.minecraft.world.entity.Mob;
 import net.minecraft.world.entity.player.Player;
@@ -15,10 +21,19 @@ import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Wearable;
 import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.DispenserBlock;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.HitResult;
+import net.minecraftforge.common.ForgeMod;
+import net.minecraftforge.network.PacketDistributor;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.Map;
+import java.util.WeakHashMap;
+
 public class ItemLens extends Item implements Wearable {
 
     public ItemLens(Properties pProperties) {
@@ -55,7 +70,51 @@ public class ItemLens extends Item implements Wearable {
         }
     }
 
+    @Override
+    public void inventoryTick(ItemStack pStack, Level pLevel, Entity pEntity, int pSlotId, boolean pIsSelected) {
+        if (!pLevel.isClientSide() && pEntity instanceof ServerPlayer player) {
+            if (pStack == player.getItemBySlot(EquipmentSlot.HEAD) ||
+                pStack == player.getItemBySlot(EquipmentSlot.MAINHAND) ||
+                pStack == player.getItemBySlot(EquipmentSlot.OFFHAND))
+                    sendComparatorDataToClient(player);
+        }
+    }
+
+    private static final Map<ServerPlayer, Pair<BlockPos, Integer>> comparatorDataMap = new WeakHashMap<>();
+
+    private void sendComparatorDataToClient(ServerPlayer player) {
+        double reachAttribute = player.getAttribute(ForgeMod.REACH_DISTANCE.get()).getValue();
+        double distance = player.isCreative() ? reachAttribute : reachAttribute - 0.5;
+        var hitResult = player.pick(distance, 0, false);
+        if (hitResult.getType() == HitResult.Type.BLOCK) {
+            var pos = ((BlockHitResult)hitResult).getBlockPos();
+            var state = player.level.getBlockState(pos);
+            if (state.is(Blocks.COMPARATOR)) {
+                syncComparatorValue(player, pos, state.getDirectSignal(player.level, pos, state.getValue(BlockStateProperties.HORIZONTAL_FACING)));
+            } else if (state.hasAnalogOutputSignal()) {
+                syncComparatorValue(player, pos, state.getAnalogOutputSignal(player.level, pos));
+            } else {
+                syncComparatorValue(player, null, -1);
+            }
+        } else
+            syncComparatorValue(player, null, -1);
+    }
+
+    private void syncComparatorValue(ServerPlayer player, BlockPos pos, int value) {
+        var previous = comparatorDataMap.get(player);
+        if (value == -1) {
+            if (previous != null) {
+                comparatorDataMap.remove(player);
+                HexMessages.getNetwork().send(PacketDistributor.PLAYER.with(() -> player), new MsgUpdateComparatorVisualsAck(null, -1));
+            }
+        } else if (previous == null || (!pos.equals(previous.getFirst()) || value != previous.getSecond())) {
+            comparatorDataMap.put(player, new Pair<>(pos, value));
+            HexMessages.getNetwork().send(PacketDistributor.PLAYER.with(() -> player), new MsgUpdateComparatorVisualsAck(pos, value));
+        }
+    }
+
     @Nullable
+    @Override
     public SoundEvent getEquipSound() {
         return SoundEvents.AMETHYST_BLOCK_CHIME;
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java b/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java
index 15ea964c..22c7c387 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemScroll.java
@@ -4,12 +4,12 @@ import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.spell.DatumType;
 import at.petrak.hexcasting.api.spell.SpellDatum;
-import at.petrak.hexcasting.common.entities.EntityWallScroll;
 import at.petrak.hexcasting.api.spell.math.HexPattern;
+import at.petrak.hexcasting.api.utils.NBTHelper;
+import at.petrak.hexcasting.common.entities.EntityWallScroll;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.TranslatableComponent;
 import net.minecraft.resources.ResourceLocation;
@@ -42,26 +42,23 @@ public class ItemScroll extends Item implements DataHolderItem {
 
     @Override
     public @Nullable CompoundTag readDatumTag(ItemStack stack) {
-        var stackTag = stack.getTag();
-        if (stackTag == null || !stackTag.contains(TAG_PATTERN, Tag.TAG_COMPOUND)) {
+        CompoundTag pattern = NBTHelper.getCompound(stack, TAG_PATTERN);
+        if (pattern == null)
             return null;
-        }
-
-        var patTag = stackTag.getCompound(TAG_PATTERN);
         var out = new CompoundTag();
-        out.put(SpellDatum.TAG_PATTERN, patTag);
+        out.put(SpellDatum.TAG_PATTERN, pattern);
         return out;
     }
 
     @Override
     public boolean canWrite(ItemStack stack, SpellDatum<?> datum) {
-        return datum != null && datum.getType() == DatumType.PATTERN && (!stack.hasTag() || !stack.getTag().contains(TAG_PATTERN, Tag.TAG_COMPOUND));
+        return datum != null && datum.getType() == DatumType.PATTERN && !NBTHelper.hasCompound(stack, TAG_PATTERN);
     }
 
     @Override
     public void writeDatum(ItemStack stack, SpellDatum<?> datum) {
         if (this.canWrite(stack, datum) && datum.getPayload() instanceof HexPattern pat) {
-            stack.getOrCreateTag().put(TAG_PATTERN, pat.serializeToNBT());
+            NBTHelper.putCompound(stack, TAG_PATTERN, pat.serializeToNBT());
         }
     }
 
@@ -81,9 +78,9 @@ public class ItemScroll extends Item implements DataHolderItem {
         var scrollEntity = new EntityWallScroll(level, posInFront, direction, scrollStack);
 
         // i guess
-        var compoundtag = itemstack.getTag();
-        if (compoundtag != null) {
-            EntityType.updateCustomEntityTag(level, player, scrollEntity, compoundtag);
+        var stackTag = itemstack.getTag();
+        if (stackTag != null) {
+            EntityType.updateCustomEntityTag(level, player, scrollEntity, stackTag);
         }
 
         if (scrollEntity.survives()) {
@@ -106,11 +103,11 @@ public class ItemScroll extends Item implements DataHolderItem {
 
     @Override
     public Component getName(ItemStack pStack) {
-        var tag = pStack.getOrCreateTag();
-        if (tag.contains(TAG_OP_ID, Tag.TAG_STRING)) {
+        var ancientId = NBTHelper.getString(pStack, TAG_OP_ID);
+        if (ancientId != null) {
             return new TranslatableComponent("item.hexcasting.scroll.of",
-                new TranslatableComponent("hexcasting.spell." + ResourceLocation.tryParse(tag.getString(TAG_OP_ID))));
-        } else if (tag.contains(TAG_PATTERN, Tag.TAG_COMPOUND)) {
+                new TranslatableComponent("hexcasting.spell." + ResourceLocation.tryParse(ancientId)));
+        } else if (NBTHelper.hasCompound(pStack, TAG_PATTERN)) {
             return new TranslatableComponent("item.hexcasting.scroll");
         } else {
             return new TranslatableComponent("item.hexcasting.scroll.empty");
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java b/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java
index c2a3a28f..fa225eae 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemSlate.java
@@ -5,6 +5,7 @@ import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.spell.DatumType;
 import at.petrak.hexcasting.api.spell.SpellDatum;
 import at.petrak.hexcasting.api.spell.math.HexPattern;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.blocks.circles.BlockEntitySlate;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
@@ -33,42 +34,36 @@ public class ItemSlate extends BlockItem implements DataHolderItem {
     }
 
     public static boolean hasPattern(ItemStack stack) {
-        var tag = stack.getTag();
-        if (tag != null && tag.contains("BlockEntityTag", Tag.TAG_COMPOUND)) {
-            var bet = tag.getCompound("BlockEntityTag");
-            return bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND) && !bet.getCompound(
-                BlockEntitySlate.TAG_PATTERN).isEmpty();
+        var bet = NBTHelper.getCompound(stack, "BlockEntityTag");
+        if (bet != null) {
+            return bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND) &&
+                !bet.getCompound(BlockEntitySlate.TAG_PATTERN).isEmpty();
         }
         return false;
     }
 
     @Override
     public boolean onEntityItemUpdate(ItemStack stack, ItemEntity entity) {
-        var tag = stack.getTagElement("BlockEntityTag");
-        if (tag != null && tag.isEmpty())
-            stack.removeTagKey("BlockEntityTag");
+        if (!hasPattern(stack))
+            NBTHelper.remove(stack, "BlockEntityTag");
         return super.onEntityItemUpdate(stack, entity);
     }
 
     @Override
     public void inventoryTick(ItemStack pStack, Level pLevel, Entity pEntity, int pSlotId, boolean pIsSelected) {
-        var tag = pStack.getTagElement("BlockEntityTag");
-        if (tag != null && tag.isEmpty())
-            pStack.removeTagKey("BlockEntityTag");
+        if (!hasPattern(pStack))
+            NBTHelper.remove(pStack, "BlockEntityTag");
     }
 
     @Override
     public @Nullable CompoundTag readDatumTag(ItemStack stack) {
-        var stackTag = stack.getTag();
-        if (stackTag == null || !stackTag.contains("BlockEntityTag")) {
-            return null;
-        }
-        var beTag = stackTag.getCompound("BlockEntityTag");
-        if (!beTag.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND)) {
+        var bet = NBTHelper.getCompound(stack, "BlockEntityTag");
+
+        if (bet == null || !bet.contains(BlockEntitySlate.TAG_PATTERN, Tag.TAG_COMPOUND)) {
             return null;
         }
 
-        var patTag = beTag.getCompound(BlockEntitySlate.TAG_PATTERN);
+        var patTag = bet.getCompound(BlockEntitySlate.TAG_PATTERN);
         if (patTag.isEmpty()) {
             return null;
         }
@@ -86,12 +81,12 @@ public class ItemSlate extends BlockItem implements DataHolderItem {
     public void writeDatum(ItemStack stack, SpellDatum<?> datum) {
         if (this.canWrite(stack, datum))
             if (datum == null) {
-                var beTag = stack.getOrCreateTagElement("BlockEntityTag");
+                var beTag = NBTHelper.getOrCreateCompound(stack, "BlockEntityTag");
                 beTag.remove(BlockEntitySlate.TAG_PATTERN);
                 if (beTag.isEmpty())
-                    stack.removeTagKey("BlockEntityTag");
+                    NBTHelper.remove(stack, "BlockEntityTag");
             } else if (datum.getPayload() instanceof HexPattern pat) {
-                var beTag = stack.getOrCreateTagElement("BlockEntityTag");
+                var beTag = NBTHelper.getOrCreateCompound(stack, "BlockEntityTag");
                 beTag.put(BlockEntitySlate.TAG_PATTERN, pat.serializeToNBT());
             }
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/items/ItemSpellbook.java b/src/main/java/at/petrak/hexcasting/common/items/ItemSpellbook.java
index 6431ddff..a440b959 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/ItemSpellbook.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/ItemSpellbook.java
@@ -3,6 +3,7 @@ package at.petrak.hexcasting.common.items;
 import at.petrak.hexcasting.api.item.DataHolderItem;
 import at.petrak.hexcasting.api.spell.SpellDatum;
 import at.petrak.hexcasting.api.spell.Widget;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import net.minecraft.ChatFormatting;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
@@ -40,20 +41,42 @@ public class ItemSpellbook extends Item implements DataHolderItem {
     @Override
     public void appendHoverText(ItemStack stack, @Nullable Level level, List<Component> tooltip,
         TooltipFlag isAdvanced) {
-        var tag = stack.getOrCreateTag();
-        if (tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            var pageIdx = tag.getInt(TAG_SELECTED_PAGE);
+        boolean sealed = IsSealed(stack);
+        boolean empty = false;
+        if (NBTHelper.hasNumber(stack, TAG_SELECTED_PAGE)) {
+            var pageIdx = NBTHelper.getInt(stack, TAG_SELECTED_PAGE);
             int highest = HighestPage(stack);
             if (highest != 0) {
-                tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.page",
-                    new TextComponent(String.valueOf(pageIdx)).withStyle(ChatFormatting.WHITE),
-                    new TextComponent(String.valueOf(highest)).withStyle(ChatFormatting.WHITE))
-                    .withStyle(ChatFormatting.GRAY));
+                if (sealed)
+                    tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.page.sealed",
+                        new TextComponent(String.valueOf(pageIdx)).withStyle(ChatFormatting.WHITE),
+                        new TextComponent(String.valueOf(highest)).withStyle(ChatFormatting.WHITE),
+                        new TranslatableComponent("hexcasting.tooltip.spellbook.sealed").withStyle(ChatFormatting.GOLD))
+                        .withStyle(ChatFormatting.GRAY));
+                else
+                    tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.page",
+                        new TextComponent(String.valueOf(pageIdx)).withStyle(ChatFormatting.WHITE),
+                        new TextComponent(String.valueOf(highest)).withStyle(ChatFormatting.WHITE))
+                        .withStyle(ChatFormatting.GRAY));
             } else {
-                tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.empty").withStyle(ChatFormatting.GRAY));
+                empty = true;
             }
         } else {
-            tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.empty").withStyle(ChatFormatting.GRAY));
+            empty = true;
+        }
+
+        if (empty) {
+            boolean overridden = NBTHelper.hasString(stack, TAG_OVERRIDE_VISUALLY);
+            if (sealed) {
+                if (overridden) {
+                    tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.sealed").withStyle(ChatFormatting.GOLD));
+                } else {
+                    tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.empty.sealed",
+                        new TranslatableComponent("hexcasting.tooltip.spellbook.sealed").withStyle(ChatFormatting.GOLD))
+                        .withStyle(ChatFormatting.GRAY));
+                }
+            } else if (!overridden)
+                tooltip.add(new TranslatableComponent("hexcasting.tooltip.spellbook.empty").withStyle(ChatFormatting.GRAY));
         }
 
         DataHolderItem.appendHoverText(this, stack, tooltip, isAdvanced);
@@ -63,58 +86,31 @@ public class ItemSpellbook extends Item implements DataHolderItem {
 
     @Override
     public void inventoryTick(ItemStack stack, Level pLevel, Entity pEntity, int pSlotId, boolean pIsSelected) {
-        var tag = stack.getOrCreateTag();
-        int index;
-        if (ArePagesEmpty(stack)) {
-            index = 0;
-        } else if (!tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            index = 1;
-        } else {
-            index = tag.getInt(TAG_SELECTED_PAGE);
-            if (index == 0) index = 1;
-        }
-        tag.putInt(TAG_SELECTED_PAGE, index);
+        int index = GetPage(stack, 0);
+        NBTHelper.putInt(stack, TAG_SELECTED_PAGE, index);
 
         int shiftedIdx = Math.max(1, index);
         String nameKey = String.valueOf(shiftedIdx);
-        CompoundTag names = tag.getCompound(TAG_PAGE_NAMES);
+        CompoundTag names = NBTHelper.getOrCreateCompound(stack, TAG_PAGE_NAMES);
         if (stack.hasCustomHoverName()) {
             names.putString(nameKey, Component.Serializer.toJson(stack.getHoverName()));
         } else {
             names.remove(nameKey);
         }
-        tag.put(TAG_PAGE_NAMES, names);
     }
 
     public static boolean ArePagesEmpty(ItemStack stack) {
-        if (!stack.hasTag())
-            return true;
-        CompoundTag tag = stack.getTag();
-        return !tag.contains(ItemSpellbook.TAG_PAGES, Tag.TAG_COMPOUND) ||
-            tag.getCompound(ItemSpellbook.TAG_PAGES).isEmpty();
+        CompoundTag tag = NBTHelper.getCompound(stack, TAG_PAGES);
+        return tag == null || tag.isEmpty();
     }
 
     @Override
     public @Nullable CompoundTag readDatumTag(ItemStack stack) {
-        if (!stack.hasTag()) {
-            return null;
-        }
-        var tag = stack.getTag();
-
-        int idx;
-        if (tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            idx = tag.getInt(TAG_SELECTED_PAGE);
-        } else {
-            idx = 0;
-        }
+        int idx = GetPage(stack, 1);
         var key = String.valueOf(idx);
-        if (tag.contains(TAG_PAGES, Tag.TAG_COMPOUND)) {
-            var pagesTag = tag.getCompound(TAG_PAGES);
-            if (pagesTag.contains(key)) {
-                return pagesTag.getCompound(key);
-            } else {
-                return null;
-            }
+        var tag = NBTHelper.getCompound(stack, TAG_PAGES);
+        if (tag != null && tag.contains(key, Tag.TAG_COMPOUND)) {
+            return tag.getCompound(key);
         } else {
             return null;
         }
@@ -135,45 +131,42 @@ public class ItemSpellbook extends Item implements DataHolderItem {
         if (datum != null && IsSealed(stack))
             return;
 
-        CompoundTag tag = stack.getOrCreateTag();
-
-        int idx;
-        if (tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            idx = tag.getInt(TAG_SELECTED_PAGE);
-            // But we want to write to page *1* to start if this is our first page
-            if (idx == 0 && ArePagesEmpty(stack)) {
-                idx = 1;
-            }
-        } else {
-            idx = 1;
-        }
+        int idx = GetPage(stack, 1);
         var key = String.valueOf(idx);
-        if (tag.contains(TAG_PAGES, Tag.TAG_COMPOUND)) {
+        CompoundTag pages = NBTHelper.getCompound(stack, TAG_PAGES);
+        if (pages != null) {
             if (datum == null) {
-                tag.getCompound(TAG_PAGES).remove(key);
-                tag.getCompound(TAG_SEALED).remove(key);
+                pages.remove(key);
+                NBTHelper.remove(NBTHelper.getCompound(stack, TAG_SEALED), key);
             } else
-                tag.getCompound(TAG_PAGES).put(key, datum.serializeToNBT());
+                pages.put(key, datum.serializeToNBT());
+
+            if (pages.isEmpty())
+                NBTHelper.remove(stack, TAG_PAGES);
         } else if (datum != null) {
-            var pagesTag = new CompoundTag();
-            pagesTag.put(key, datum.serializeToNBT());
-            tag.put(TAG_PAGES, pagesTag);
+            NBTHelper.getOrCreateCompound(stack, TAG_PAGES).put(key, datum.serializeToNBT());
         } else {
-            tag.getCompound(TAG_SEALED).remove(key);
+            NBTHelper.remove(NBTHelper.getCompound(stack, TAG_SEALED), key);
+        }
+    }
+
+    public static int GetPage(ItemStack stack, int ifEmpty) {
+        if (ArePagesEmpty(stack))
+            return ifEmpty;
+        else if (NBTHelper.hasNumber(stack, TAG_SELECTED_PAGE)) {
+            int index = NBTHelper.getInt(stack, TAG_SELECTED_PAGE);
+            if (index == 0) index = 1;
+            return index;
+        } else {
+            return 1;
         }
     }
 
     public static void SetSealed(ItemStack stack, boolean sealed) {
-        CompoundTag tag = stack.getOrCreateTag();
-
-        int index = 1;
-        if (!ArePagesEmpty(stack) && tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            index = tag.getInt(TAG_SELECTED_PAGE);
-            if (index == 0) index = 1;
-        }
+        int index = GetPage(stack, 1);
 
         String nameKey = String.valueOf(index);
-        CompoundTag names = tag.getCompound(TAG_SEALED);
+        CompoundTag names = NBTHelper.getOrCreateCompound(stack, TAG_SEALED);
 
         if (!sealed)
             names.remove(nameKey);
@@ -181,64 +174,51 @@ public class ItemSpellbook extends Item implements DataHolderItem {
             names.putBoolean(nameKey, true);
 
         if (names.isEmpty())
-            tag.remove(TAG_SEALED);
+            NBTHelper.remove(stack, TAG_SEALED);
         else
-            tag.put(TAG_SEALED, names);
+            NBTHelper.putCompound(stack, TAG_SEALED, names);
 
     }
 
     public static boolean IsSealed(ItemStack stack) {
-        if (!stack.hasTag())
-            return false;
-        CompoundTag tag = stack.getOrCreateTag();
-
-        int index = 1;
-        if (!ArePagesEmpty(stack) && tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            index = tag.getInt(TAG_SELECTED_PAGE);
-            if (index == 0) index = 1;
-        }
+        int index = GetPage(stack, 1);
 
         String nameKey = String.valueOf(index);
-        CompoundTag names = tag.getCompound(TAG_SEALED);
-        return names.getBoolean(nameKey);
+        CompoundTag names = NBTHelper.getCompound(stack, TAG_SEALED);
+        return NBTHelper.getBoolean(names, nameKey);
     }
 
     public static int HighestPage(ItemStack stack) {
-        if (!stack.hasTag())
-            return 0;
-        CompoundTag tag = stack.getTagElement(TAG_PAGES);
+        CompoundTag tag = NBTHelper.getCompound(stack, TAG_PAGES);
         if (tag == null)
             return 0;
-        var highestKey = tag.getAllKeys().stream().flatMap(s -> {
+        return tag.getAllKeys().stream().flatMap(s -> {
             try {
                 return Stream.of(Integer.parseInt(s));
             } catch (NumberFormatException e) {
                 return Stream.empty();
             }
-        }).max(Integer::compare);
-        return highestKey.orElse(0);
+        }).max(Integer::compare).orElse(0);
     }
 
-    public static void RotatePageIdx(ItemStack stack, boolean increase) {
-        CompoundTag tag = stack.getOrCreateTag();
-        int newIdx;
-        if (ArePagesEmpty(stack)) {
-            newIdx = 0;
-        } else if (tag.contains(TAG_SELECTED_PAGE, Tag.TAG_ANY_NUMERIC)) {
-            var delta = increase ? 1 : -1;
-            newIdx = Math.max(1, tag.getInt(TAG_SELECTED_PAGE) + delta);
-        } else {
-            newIdx = 1;
+    public static int RotatePageIdx(ItemStack stack, boolean increase) {
+        int idx = GetPage(stack, 0);
+        if (idx != 0) {
+            idx += increase ? 1 : -1;
+            idx = Math.max(1, idx);
         }
-        tag.putInt(TAG_SELECTED_PAGE, newIdx);
+        NBTHelper.putInt(stack, TAG_SELECTED_PAGE, idx);
 
-        CompoundTag names = tag.getCompound(TAG_PAGE_NAMES);
-        int shiftedIdx = Math.max(1, newIdx);
+        CompoundTag names = NBTHelper.getCompound(stack, TAG_PAGE_NAMES);
+        int shiftedIdx = Math.max(1, idx);
         String nameKey = String.valueOf(shiftedIdx);
-        if (names.contains(nameKey, Tag.TAG_STRING)) {
-            stack.setHoverName(Component.Serializer.fromJson(names.getString(nameKey)));
+        String name = NBTHelper.getString(names, nameKey);
+        if (name != null) {
+            stack.setHoverName(Component.Serializer.fromJson(name));
         } else {
             stack.resetHoverName();
         }
+
+        return idx;
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaBattery.java b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaBattery.java
index 8fb9248f..b26878dc 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaBattery.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaBattery.java
@@ -1,8 +1,12 @@
 package at.petrak.hexcasting.common.items.magic;
 
 import at.petrak.hexcasting.HexMod;
+import at.petrak.hexcasting.api.misc.ManaConstants;
+import net.minecraft.core.NonNullList;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.CreativeModeTab;
 import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
 
 public class ItemManaBattery extends ItemManaHolder {
     public static final ResourceLocation MANA_PREDICATE = new ResourceLocation(HexMod.MOD_ID, "mana");
@@ -21,4 +25,22 @@ public class ItemManaBattery extends ItemManaHolder {
     public boolean canRecharge(ItemStack stack) {
         return true;
     }
+
+    @Override
+    public void fillItemCategory(@NotNull CreativeModeTab tab, @NotNull NonNullList<ItemStack> items) {
+        // who was drunk at the wheel when they named this
+        if (allowdedIn(tab)) {
+            var manamounts = new int[]{
+                ManaConstants.CRYSTAL_UNIT,
+                20 * ManaConstants.CRYSTAL_UNIT,
+                64 * ManaConstants.CRYSTAL_UNIT,
+                640 * ManaConstants.CRYSTAL_UNIT,
+                6400 * ManaConstants.CRYSTAL_UNIT,
+            };
+            for (int manamount : manamounts) {
+                var stack = new ItemStack(this);
+                items.add(ItemManaHolder.withMana(stack, manamount, manamount));
+            }
+        }
+    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaHolder.java b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaHolder.java
index f156ad3f..d86f7a70 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaHolder.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemManaHolder.java
@@ -2,8 +2,8 @@ package at.petrak.hexcasting.common.items.magic;
 
 import at.petrak.hexcasting.api.item.ManaHolderItem;
 import at.petrak.hexcasting.api.utils.ManaHelper;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import net.minecraft.ChatFormatting;
-import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.chat.TranslatableComponent;
 import net.minecraft.util.Mth;
@@ -26,9 +26,8 @@ public abstract class ItemManaHolder extends Item implements ManaHolderItem {
     public static ItemStack withMana(ItemStack stack, int mana, int maxMana) {
         Item item = stack.getItem();
         if (item instanceof ItemManaHolder) {
-            CompoundTag tag = stack.getOrCreateTag();
-            tag.putInt(TAG_MANA, mana);
-            tag.putInt(TAG_MAX_MANA, maxMana);
+            NBTHelper.putInt(stack, TAG_MANA, mana);
+            NBTHelper.putInt(stack, TAG_MAX_MANA, maxMana);
         }
 
         return stack;
@@ -36,21 +35,17 @@ public abstract class ItemManaHolder extends Item implements ManaHolderItem {
 
     @Override
     public int getMana(ItemStack stack) {
-        if (!stack.hasTag())
-            return 0;
-        return stack.getTag().getInt(TAG_MANA);
+        return NBTHelper.getInt(stack, TAG_MANA);
     }
 
     @Override
     public int getMaxMana(ItemStack stack) {
-        if (!stack.hasTag())
-            return 0;
-        return stack.getTag().getInt(TAG_MAX_MANA);
+        return NBTHelper.getInt(stack, TAG_MAX_MANA);
     }
 
     @Override
     public void setMana(ItemStack stack, int mana) {
-        stack.getOrCreateTag().putInt(TAG_MANA, Mth.clamp(mana, 0, getMaxMana(stack)));
+        NBTHelper.putInt(stack, TAG_MANA, Mth.clamp(mana, 0, getMaxMana(stack)));
     }
 
     @Override
diff --git a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedSpell.java b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedSpell.java
index 60d6c3bb..72c17c91 100644
--- a/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedSpell.java
+++ b/src/main/java/at/petrak/hexcasting/common/items/magic/ItemPackagedSpell.java
@@ -4,6 +4,7 @@ import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.api.item.SpellHolderItem;
 import at.petrak.hexcasting.api.spell.casting.CastingContext;
 import at.petrak.hexcasting.api.spell.casting.CastingHarness;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.lib.HexSounds;
 import at.petrak.hexcasting.api.spell.math.HexPattern;
 import net.minecraft.nbt.CompoundTag;
@@ -50,14 +51,12 @@ public abstract class ItemPackagedSpell extends ItemManaHolder implements SpellH
 
     @Override
     public @Nullable List<HexPattern> getPatterns(ItemStack stack) {
-        if (!stack.hasTag())
-            return null;
-        CompoundTag tag = stack.getTag();
-        if (!tag.contains(TAG_PATTERNS, Tag.TAG_LIST))
+        var patsTag = NBTHelper.getList(stack, TAG_PATTERNS, Tag.TAG_COMPOUND);
+
+        if (patsTag == null)
             return null;
 
         var out = new ArrayList<HexPattern>();
-        var patsTag = tag.getList(TAG_PATTERNS, Tag.TAG_COMPOUND);
         for (var patTag : patsTag) {
             out.add(HexPattern.DeserializeFromNBT((CompoundTag) patTag));
         }
@@ -70,14 +69,14 @@ public abstract class ItemPackagedSpell extends ItemManaHolder implements SpellH
         for (HexPattern pat : patterns)
             patsTag.add(pat.serializeToNBT());
 
-        stack.getOrCreateTag().put(ItemPackagedSpell.TAG_PATTERNS, patsTag);
+        NBTHelper.putList(stack, TAG_PATTERNS, patsTag);
 
         withMana(stack, mana, mana);
     }
 
     @Override
     public void clearPatterns(ItemStack stack) {
-        stack.removeTagKey(ItemPackagedSpell.TAG_PATTERNS);
+        NBTHelper.remove(stack, ItemPackagedSpell.TAG_PATTERNS);
         withMana(stack, 0, 0);
     }
 
@@ -119,6 +118,7 @@ public abstract class ItemPackagedSpell extends ItemManaHolder implements SpellH
 
         if (broken) {
             stack.shrink(1);
+            player.broadcastBreakEvent(usedHand);
             return InteractionResultHolder.consume(stack);
         } else {
             return InteractionResultHolder.success(stack);
diff --git a/src/main/java/at/petrak/hexcasting/common/misc/AkashicTreeGrower.java b/src/main/java/at/petrak/hexcasting/common/misc/AkashicTreeGrower.java
index 946214c4..ce92941a 100644
--- a/src/main/java/at/petrak/hexcasting/common/misc/AkashicTreeGrower.java
+++ b/src/main/java/at/petrak/hexcasting/common/misc/AkashicTreeGrower.java
@@ -2,6 +2,7 @@ package at.petrak.hexcasting.common.misc;
 
 import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.common.blocks.HexBlocks;
+import com.google.common.collect.Lists;
 import net.minecraft.core.Holder;
 import net.minecraft.data.worldgen.features.FeatureUtils;
 import net.minecraft.util.valueproviders.ConstantInt;
@@ -16,39 +17,38 @@ import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvi
 import net.minecraft.world.level.levelgen.feature.trunkplacers.FancyTrunkPlacer;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.List;
 import java.util.OptionalInt;
 import java.util.Random;
 
 public class AkashicTreeGrower extends AbstractTreeGrower {
     public static final AkashicTreeGrower INSTANCE = new AkashicTreeGrower();
 
-    public static final Holder<ConfiguredFeature<TreeConfiguration, ?>>[] GROWERS;
+    public static final List<Holder<ConfiguredFeature<TreeConfiguration, ?>>> GROWERS = Lists.newArrayList();
 
     static {
-        var leaves = new Block[]{
-            HexBlocks.AKASHIC_LEAVES1.get(),
-            HexBlocks.AKASHIC_LEAVES2.get(),
-            HexBlocks.AKASHIC_LEAVES3.get()
-        };
-        GROWERS = new Holder[leaves.length];
-        for (int i = 0; i < leaves.length; i++) {
-            GROWERS[i] = FeatureUtils.register(HexMod.MOD_ID + ":akashic_tree" + (i + 1), Feature.TREE,
-                new TreeConfiguration.TreeConfigurationBuilder(
-                    BlockStateProvider.simple(HexBlocks.AKASHIC_LOG.get()),
-                    // baseHeight, heightRandA, heightRandB
-                    new FancyTrunkPlacer(5, 5, 3),
-                    BlockStateProvider.simple(leaves[i]),
-                    // radius, offset, height
-                    new FancyFoliagePlacer(ConstantInt.of(1), ConstantInt.of(5), 5),
-                    // limit, lower size, upper size, minclippedheight
-                    new TwoLayersFeatureSize(0, 0, 0, OptionalInt.of(6))
-                ).build());
-        }
+        GROWERS.add(buildTreeFeature(HexBlocks.AKASHIC_LEAVES1.get(), "1"));
+        GROWERS.add(buildTreeFeature(HexBlocks.AKASHIC_LEAVES2.get(), "2"));
+        GROWERS.add(buildTreeFeature(HexBlocks.AKASHIC_LEAVES3.get(), "3"));
+    }
+
+    private static Holder<ConfiguredFeature<TreeConfiguration, ?>> buildTreeFeature(Block leaves, String name) {
+        return FeatureUtils.register(HexMod.MOD_ID + ":akashic_tree" + name, Feature.TREE,
+            new TreeConfiguration.TreeConfigurationBuilder(
+                BlockStateProvider.simple(HexBlocks.AKASHIC_LOG.get()),
+                // baseHeight, heightRandA, heightRandB
+                new FancyTrunkPlacer(5, 5, 3),
+                BlockStateProvider.simple(leaves),
+                // radius, offset, height
+                new FancyFoliagePlacer(ConstantInt.of(1), ConstantInt.of(5), 5),
+                // limit, lower size, upper size, minclippedheight
+                new TwoLayersFeatureSize(0, 0, 0, OptionalInt.of(6))
+            ).build());
     }
 
     @Nullable
     @Override
     protected Holder<? extends ConfiguredFeature<?, ?>> getConfiguredFeature(Random pRandom, boolean pLargeHive) {
-        return GROWERS[pRandom.nextInt(GROWERS.length)];
+        return GROWERS.get(pRandom.nextInt(GROWERS.size()));
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/misc/Brainsweeping.java b/src/main/java/at/petrak/hexcasting/common/misc/Brainsweeping.java
index 805efff7..464c446f 100644
--- a/src/main/java/at/petrak/hexcasting/common/misc/Brainsweeping.java
+++ b/src/main/java/at/petrak/hexcasting/common/misc/Brainsweeping.java
@@ -2,14 +2,14 @@ package at.petrak.hexcasting.common.misc;
 
 import at.petrak.hexcasting.common.network.HexMessages;
 import at.petrak.hexcasting.common.network.MsgBrainsweepAck;
-import at.petrak.hexcasting.mixin.AccessorLivingEntity;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.ai.Brain;
+import net.minecraft.world.entity.Mob;
 import net.minecraft.world.entity.npc.Villager;
 import net.minecraft.world.entity.npc.VillagerDataHolder;
+import net.minecraft.world.entity.raid.Raider;
 import net.minecraftforge.event.entity.living.LivingConversionEvent;
 import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
@@ -20,25 +20,22 @@ public class Brainsweeping {
 
     public static final String TAG_BRAINSWEPT = "hexcasting:brainswept";
 
+    private static boolean isValidTarget(LivingEntity entity) {
+        return entity instanceof VillagerDataHolder || entity instanceof Raider;
+    }
+
     public static boolean isBrainswept(LivingEntity entity) {
-        return entity instanceof VillagerDataHolder && entity.getPersistentData().getBoolean(TAG_BRAINSWEPT);
+        return isValidTarget(entity) && entity.getPersistentData().getBoolean(TAG_BRAINSWEPT);
     }
 
     public static void brainsweep(LivingEntity entity) {
-        if (entity instanceof VillagerDataHolder) {
+        if (entity instanceof Mob mob && isValidTarget(entity)) {
             entity.getPersistentData().putBoolean(TAG_BRAINSWEPT, true);
 
-            if (entity instanceof Villager villager) {
-                Brain<Villager> brain = villager.getBrain();
-                if (entity.level instanceof ServerLevel slevel) {
-                    brain.stopAll(slevel, villager);
-                }
-                ((AccessorLivingEntity) entity).hex$SetBrain(brain.copyWithoutBehaviors());
-            }
+            mob.removeFreeWill();
 
-            if (entity.level instanceof ServerLevel) {
+            if (entity.level instanceof ServerLevel)
                 HexMessages.getNetwork().send(PacketDistributor.TRACKING_ENTITY.with(() -> entity), MsgBrainsweepAck.of(entity));
-            }
         }
     }
 
@@ -46,7 +43,7 @@ public class Brainsweeping {
     public static void startTracking(PlayerEvent.StartTracking evt) {
         Entity target = evt.getTarget();
         if (evt.getPlayer() instanceof ServerPlayer serverPlayer &&
-                target instanceof VillagerDataHolder && target instanceof LivingEntity living && isBrainswept(living)) {
+                target instanceof LivingEntity living && isBrainswept(living)) {
             HexMessages.getNetwork().send(PacketDistributor.PLAYER.with(() -> serverPlayer), MsgBrainsweepAck.of(living));
         }
     }
@@ -59,11 +56,10 @@ public class Brainsweeping {
     }
 
     @SubscribeEvent
-    public static void copyBrainsweepBetweenZombieAndVillager(LivingConversionEvent.Post evt) {
+    public static void copyBrainsweepBetweenZombieVillagerAndWitch(LivingConversionEvent.Post evt) {
         var outcome = evt.getOutcome();
         var original = evt.getEntityLiving();
-        if (outcome instanceof VillagerDataHolder && original instanceof VillagerDataHolder) {
-            if (isBrainswept(original)) brainsweep(outcome);
-        }
+        if (isValidTarget(outcome) && isBrainswept(original))
+            brainsweep(outcome);
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/misc/PlayerPositionRecorder.java b/src/main/java/at/petrak/hexcasting/common/misc/PlayerPositionRecorder.java
new file mode 100644
index 00000000..fb950411
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/misc/PlayerPositionRecorder.java
@@ -0,0 +1,41 @@
+package at.petrak.hexcasting.common.misc;
+
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.event.TickEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+public final class PlayerPositionRecorder {
+	private static final Map<Player, Vec3> LAST_SECOND_POSITION_MAP = new WeakHashMap<>();
+	private static final Map<Player, Vec3> LAST_POSITION_MAP = new WeakHashMap<>();
+
+	@SubscribeEvent
+	public static void onEntityUpdate(TickEvent.WorldTickEvent evt) {
+		if (evt.phase == TickEvent.Phase.END && evt.world instanceof ServerLevel world) {
+			for (ServerPlayer player : world.players()) {
+				var prev = LAST_POSITION_MAP.get(player);
+				if (prev != null)
+					LAST_SECOND_POSITION_MAP.put(player, prev);
+				LAST_POSITION_MAP.put(player, player.position());
+			}
+		}
+	}
+
+	public static Vec3 getMotion(ServerPlayer player) {
+		Vec3 vec = LAST_POSITION_MAP.get(player);
+		Vec3 prev = LAST_SECOND_POSITION_MAP.get(player);
+
+		if (vec == null)
+			return Vec3.ZERO;
+
+		if (prev == null)
+			return player.position().subtract(vec);
+
+		return vec.subtract(prev);
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/network/ClientPacketHandler.java b/src/main/java/at/petrak/hexcasting/common/network/ClientPacketHandler.java
new file mode 100644
index 00000000..d716760a
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/network/ClientPacketHandler.java
@@ -0,0 +1,166 @@
+package at.petrak.hexcasting.common.network;
+
+import at.petrak.hexcasting.api.client.ScryingLensOverlayRegistry;
+import at.petrak.hexcasting.api.player.HexPlayerDataHelper;
+import at.petrak.hexcasting.client.gui.GuiSpellcasting;
+import at.petrak.hexcasting.common.lib.HexSounds;
+import at.petrak.hexcasting.common.misc.Brainsweeping;
+import at.petrak.hexcasting.common.particles.ConjureParticleOptions;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+import java.util.Random;
+
+// Ah, java classloading, how I hate thee
+public record ClientPacketHandler(Object rawMsg) {
+
+	@OnlyIn(Dist.CLIENT)
+	public void beep() {
+		if (!(rawMsg instanceof MsgBeepAck msg))
+			return;
+
+		var minecraft = Minecraft.getInstance();
+		var world = minecraft.level;
+		if (world != null){
+			float pitch = (float) Math.pow(2, (msg.note() - 12) / 12.0);
+			world.playLocalSound(msg.target().x, msg.target().y, msg.target().z, msg.instrument().getSoundEvent(), SoundSource.PLAYERS, 3, pitch, false);
+			world.addParticle(ParticleTypes.NOTE, msg.target().x, msg.target().y + 0.2, msg.target().z, msg.note() / 24.0, 0, 0);
+		}
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void blink() {
+		if (!(rawMsg instanceof MsgBlinkAck msg))
+			return;
+
+		var player = Minecraft.getInstance().player;
+		player.setPos(player.position().add(msg.addedPosition()));
+	}
+
+
+	@OnlyIn(Dist.CLIENT)
+	public void updateComparator() {
+		if (!(rawMsg instanceof MsgUpdateComparatorVisualsAck msg))
+			return;
+
+		ScryingLensOverlayRegistry.receiveComparatorValue(msg.pos(), msg.value());
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void openSpellGui() {
+		if (!(rawMsg instanceof MsgOpenSpellGuiAck msg))
+			return;
+
+		var mc = Minecraft.getInstance();
+		mc.setScreen(new GuiSpellcasting(msg.hand(), msg.patterns(), msg.components()));
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void brainsweep() {
+		if (!(rawMsg instanceof MsgBrainsweepAck msg))
+			return;
+
+		var level = Minecraft.getInstance().level;
+		if (level != null) {
+			Entity entity = level.getEntity(msg.target());
+			if (entity instanceof LivingEntity living) {
+				Brainsweeping.brainsweep(living);
+			}
+		}
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void newPattern() {
+		if (!(rawMsg instanceof MsgNewSpellPatternAck msg))
+			return;
+
+		var mc = Minecraft.getInstance();
+		if (msg.info().isStackClear()) {
+			// don't pay attention to the screen, so it also stops when we die
+			mc.getSoundManager().stop(HexSounds.CASTING_AMBIANCE.getId(), null);
+		}
+		var screen = Minecraft.getInstance().screen;
+		if (screen instanceof GuiSpellcasting spellGui) {
+			if (msg.info().isStackClear()) {
+				mc.setScreen(null);
+			} else {
+				spellGui.recvServerUpdate(msg.info());
+			}
+		}
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void updateColorizer() {
+		if (!(rawMsg instanceof MsgColorizerUpdateAck msg))
+			return;
+
+		var player = Minecraft.getInstance().player;
+		if (player != null) {
+			HexPlayerDataHelper.setColorizer(player, msg.update());
+		}
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void updateSentinel() {
+		if (!(rawMsg instanceof MsgSentinelStatusUpdateAck msg))
+			return;
+
+		var player = Minecraft.getInstance().player;
+		if (player != null) {
+			HexPlayerDataHelper.setSentinel(player, msg.update());
+		}
+	}
+
+	private static final Random RANDOM = new Random();
+
+	// https://math.stackexchange.com/questions/44689/how-to-find-a-random-axis-or-unit-vector-in-3d
+	private static Vec3 randomInCircle(double maxTh) {
+		var th = RANDOM.nextDouble(0.0, maxTh + 0.001);
+		var z = RANDOM.nextDouble(-1.0, 1.0);
+		return new Vec3(Math.sqrt(1.0 - z * z) * Math.cos(th), Math.sqrt(1.0 - z * z) * Math.sin(th), z);
+	}
+
+	@OnlyIn(Dist.CLIENT)
+	public void particleSpray() {
+		if (!(rawMsg instanceof MsgCastParticleAck msg))
+			return;
+
+		for (int i = 0; i < msg.spray().getCount(); i++) {
+			// For the colors, pick any random time to get a mix of colors
+			var color = msg.colorizer().getColor(RANDOM.nextFloat() * 256f, Vec3.ZERO);
+
+			var offset = randomInCircle(Mth.TWO_PI).normalize()
+				.scale(RANDOM.nextFloat() * msg.spray().getSpread() / 2);
+			var pos = msg.spray().getPos().add(offset);
+
+			var phi = Math.acos(1.0 - RANDOM.nextDouble() * (1.0 - Math.cos(msg.spray().getSpread())));
+			var theta = Math.PI * 2.0 * RANDOM.nextDouble();
+			var v = msg.spray().getVel().normalize();
+			// pick any old vector to get a vector normal to v with
+			Vec3 k;
+			if (v.x == 0.0 && v.y == 0.0) {
+				// oops, pick a *different* normal
+				k = new Vec3(1.0, 0.0, 0.0);
+			} else {
+				k = v.cross(new Vec3(0.0, 0.0, 1.0));
+			}
+			var velUnlen = v.scale(Math.cos(phi))
+				.add(k.scale(Math.sin(phi) * Math.cos(theta)))
+				.add(v.cross(k).scale(Math.sin(phi) * Math.sin(theta)));
+			var vel = velUnlen.scale(msg.spray().getVel().length() / 20);
+
+			Minecraft.getInstance().level.addParticle(
+				new ConjureParticleOptions(color, false),
+				pos.x, pos.y, pos.z,
+				vel.x, vel.y, vel.z
+			);
+		}
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/network/GuiOpener.java b/src/main/java/at/petrak/hexcasting/common/network/GuiOpener.java
deleted file mode 100644
index 8cfe83b6..00000000
--- a/src/main/java/at/petrak/hexcasting/common/network/GuiOpener.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package at.petrak.hexcasting.common.network;
-
-import at.petrak.hexcasting.client.gui.GuiSpellcasting;
-import net.minecraft.client.Minecraft;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-public record GuiOpener(MsgOpenSpellGuiAck msg) {
-    @OnlyIn(Dist.CLIENT)
-    public void openGui() {
-        var mc = Minecraft.getInstance();
-        mc.setScreen(new GuiSpellcasting(msg.hand(), msg.patterns(), msg.components()));
-    }
-}
diff --git a/src/main/java/at/petrak/hexcasting/common/network/HexMessages.java b/src/main/java/at/petrak/hexcasting/common/network/HexMessages.java
index eada965d..e6052b28 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/HexMessages.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/HexMessages.java
@@ -37,11 +37,13 @@ public class HexMessages {
         NETWORK.registerMessage(messageIdx++, MsgCastParticleAck.class, MsgCastParticleAck::serialize,
             MsgCastParticleAck::deserialize, MsgCastParticleAck::handle);
         NETWORK.registerMessage(messageIdx++, MsgOpenSpellGuiAck.class, MsgOpenSpellGuiAck::serialize,
-                MsgOpenSpellGuiAck::deserialize, MsgOpenSpellGuiAck::handle);
+            MsgOpenSpellGuiAck::deserialize, MsgOpenSpellGuiAck::handle);
         NETWORK.registerMessage(messageIdx++, MsgBeepAck.class, MsgBeepAck::serialize,
-                MsgBeepAck::deserialize, MsgBeepAck::handle);
+            MsgBeepAck::deserialize, MsgBeepAck::handle);
         NETWORK.registerMessage(messageIdx++, MsgBrainsweepAck.class, MsgBrainsweepAck::serialize,
-                MsgBrainsweepAck::deserialize, MsgBrainsweepAck::handle);
+            MsgBrainsweepAck::deserialize, MsgBrainsweepAck::handle);
+        NETWORK.registerMessage(messageIdx++, MsgUpdateComparatorVisualsAck.class, MsgUpdateComparatorVisualsAck::serialize,
+            MsgUpdateComparatorVisualsAck::deserialize, MsgUpdateComparatorVisualsAck::handle);
 
         HexApiMessages.setSyncChannel(NETWORK, MsgSentinelStatusUpdateAck::new, MsgColorizerUpdateAck::new, MsgCastParticleAck::new);
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgBeepAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgBeepAck.java
index ce5a8fa5..fca3e35f 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgBeepAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgBeepAck.java
@@ -1,10 +1,7 @@
 package at.petrak.hexcasting.common.network;
 
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
-import net.minecraft.core.particles.ParticleTypes;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.sounds.SoundSource;
 import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
 import net.minecraft.world.phys.Vec3;
 import net.minecraftforge.api.distmarker.Dist;
@@ -37,17 +34,10 @@ public record MsgBeepAck(Vec3 target, int note, NoteBlockInstrument instrument)
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                    var minecraft = Minecraft.getInstance();
-                    var world = minecraft.level;
-                    if (world != null){
-                        float pitch = (float) Math.pow(2, (note - 12) / 12.0);
-                        world.playLocalSound(target.x, target.y, target.z, instrument.getSoundEvent(), SoundSource.PLAYERS, 3, pitch, false);
-                        world.addParticle(ParticleTypes.NOTE, target.x, target.y + 0.2, target.z, note / 24.0, 0, 0);
-                    }
-                })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::beep);
+        });
         ctx.get().setPacketHandled(true);
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgBlinkAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgBlinkAck.java
index 9e51c0e8..74d12e9a 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgBlinkAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgBlinkAck.java
@@ -1,7 +1,6 @@
 package at.petrak.hexcasting.common.network;
 
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.world.phys.Vec3;
 import net.minecraftforge.api.distmarker.Dist;
@@ -11,9 +10,9 @@ import net.minecraftforge.network.NetworkEvent;
 import java.util.function.Supplier;
 
 /**
- * Sent server->client to synchronize OpAddMotion when the target is a player.
+ * Sent server->client to synchronize OpBlink when the target is a player.
  */
-public record MsgBlinkAck(Vec3 addedMotion) {
+public record MsgBlinkAck(Vec3 addedPosition) {
     public static MsgBlinkAck deserialize(ByteBuf buffer) {
         var buf = new FriendlyByteBuf(buffer);
         var x = buf.readDouble();
@@ -24,18 +23,16 @@ public record MsgBlinkAck(Vec3 addedMotion) {
 
     public void serialize(ByteBuf buffer) {
         var buf = new FriendlyByteBuf(buffer);
-        buf.writeDouble(this.addedMotion.x);
-        buf.writeDouble(this.addedMotion.y);
-        buf.writeDouble(this.addedMotion.z);
+        buf.writeDouble(this.addedPosition.x);
+        buf.writeDouble(this.addedPosition.y);
+        buf.writeDouble(this.addedPosition.z);
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                    var player = Minecraft.getInstance().player;
-                    player.setPos(player.position().add(this.addedMotion));
-                })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::blink);
+        });
         ctx.get().setPacketHandled(true);
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgBrainsweepAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgBrainsweepAck.java
index 4f09f004..f1600a6a 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgBrainsweepAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgBrainsweepAck.java
@@ -1,11 +1,8 @@
 package at.petrak.hexcasting.common.network;
 
-import at.petrak.hexcasting.common.misc.Brainsweeping;
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.world.entity.Entity;
-import net.minecraft.world.entity.LivingEntity;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.fml.DistExecutor;
 import net.minecraftforge.network.NetworkEvent;
@@ -33,23 +30,10 @@ public record MsgBrainsweepAck(int target) {
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                IHateJava.handle(target);
-            })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::brainsweep);
+        });
         ctx.get().setPacketHandled(true);
     }
-
-    private static class IHateJava {
-        public static void handle(int target) {
-            var level = Minecraft.getInstance().level;
-            if (level != null) {
-                Entity entity = level.getEntity(target);
-                if (entity instanceof LivingEntity living) {
-                    Brainsweeping.brainsweep(living);
-                }
-            }
-        }
-    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java
index daccb0f5..b170ebaa 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgCastParticleAck.java
@@ -1,25 +1,20 @@
 package at.petrak.hexcasting.common.network;
 
-import at.petrak.hexcasting.api.spell.ParticleSpray;
 import at.petrak.hexcasting.api.misc.FrozenColorizer;
-import at.petrak.hexcasting.common.particles.ConjureParticleOptions;
+import at.petrak.hexcasting.api.spell.ParticleSpray;
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.util.Mth;
 import net.minecraft.world.phys.Vec3;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.fml.DistExecutor;
 import net.minecraftforge.network.NetworkEvent;
 
-import java.util.Random;
 import java.util.function.Supplier;
 
 /**
  * Sent server->client to spray particles everywhere.
  */
 public record MsgCastParticleAck(ParticleSpray spray, FrozenColorizer colorizer) {
-    private static final Random RANDOM = new Random();
 
     public static MsgCastParticleAck deserialize(ByteBuf buffer) {
         var buf = new FriendlyByteBuf(buffer);
@@ -54,48 +49,13 @@ public record MsgCastParticleAck(ParticleSpray spray, FrozenColorizer colorizer)
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                for (int i = 0; i < spray.getCount(); i++) {
-                    // For the colors, pick any random time to get a mix of colors
-                    var color = colorizer.getColor(RANDOM.nextFloat() * 256f, Vec3.ZERO);
-
-                    var offset = randomInCircle(Mth.TWO_PI).normalize()
-                        .scale(RANDOM.nextFloat() * spray.getSpread() / 2);
-                    var pos = spray.getPos().add(offset);
-
-                    var phi = Math.acos(1.0 - RANDOM.nextDouble() * (1.0 - Math.cos(spray.getSpread())));
-                    var theta = Math.PI * 2.0 * RANDOM.nextDouble();
-                    var v = spray.getVel().normalize();
-                    // pick any old vector to get a vector normal to v with
-                    Vec3 k;
-                    if (v.x == 0.0 && v.y == 0.0) {
-                        // oops, pick a *different* normal
-                        k = new Vec3(1.0, 0.0, 0.0);
-                    } else {
-                        k = v.cross(new Vec3(0.0, 0.0, 1.0));
-                    }
-                    var velUnlen = v.scale(Math.cos(phi))
-                        .add(k.scale(Math.sin(phi) * Math.cos(theta)))
-                        .add(v.cross(k).scale(Math.sin(phi) * Math.sin(theta)));
-                    var vel = velUnlen.scale(spray.getVel().length() / 20);
-
-                    Minecraft.getInstance().level.addParticle(
-                        new ConjureParticleOptions(color, false),
-                        pos.x, pos.y, pos.z,
-                        vel.x, vel.y, vel.z
-                    );
-                }
-            })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::particleSpray);
+        });
         ctx.get().setPacketHandled(true);
     }
 
 
-    // https://math.stackexchange.com/questions/44689/how-to-find-a-random-axis-or-unit-vector-in-3d
-    private static Vec3 randomInCircle(double maxTh) {
-        var th = RANDOM.nextDouble(0.0, maxTh + 0.001);
-        var z = RANDOM.nextDouble(-1.0, 1.0);
-        return new Vec3(Math.sqrt(1.0 - z * z) * Math.cos(th), Math.sqrt(1.0 - z * z) * Math.sin(th), z);
-    }
+
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgColorizerUpdateAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgColorizerUpdateAck.java
index f2e327bf..f880f51f 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgColorizerUpdateAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgColorizerUpdateAck.java
@@ -1,9 +1,7 @@
 package at.petrak.hexcasting.common.network;
 
 import at.petrak.hexcasting.api.misc.FrozenColorizer;
-import at.petrak.hexcasting.api.player.HexPlayerDataHelper;
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraftforge.api.distmarker.Dist;
 import net.minecraftforge.fml.DistExecutor;
@@ -29,20 +27,10 @@ public record MsgColorizerUpdateAck(FrozenColorizer update) {
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                IHateJava.handle(this.update);
-            })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::updateColorizer);
+        });
         ctx.get().setPacketHandled(true);
     }
-
-    private static class IHateJava {
-        public static void handle(FrozenColorizer update) {
-            var player = Minecraft.getInstance().player;
-            if (player != null) {
-                HexPlayerDataHelper.setColorizer(player, update);
-            }
-        }
-    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternAck.java
index 64522545..2cff6d38 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgNewSpellPatternAck.java
@@ -1,10 +1,7 @@
 package at.petrak.hexcasting.common.network;
 
-import at.petrak.hexcasting.client.gui.GuiSpellcasting;
 import at.petrak.hexcasting.api.spell.casting.ControllerInfo;
-import at.petrak.hexcasting.common.lib.HexSounds;
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.network.chat.Component;
 import net.minecraftforge.api.distmarker.Dist;
@@ -51,23 +48,10 @@ public record MsgNewSpellPatternAck(ControllerInfo info) {
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                var mc = Minecraft.getInstance();
-                if (this.info.isStackClear()) {
-                    // don't pay attention to the screen, so it also stops when we die
-                    mc.getSoundManager().stop(HexSounds.CASTING_AMBIANCE.getId(), null);
-                }
-                var screen = Minecraft.getInstance().screen;
-                if (screen instanceof GuiSpellcasting spellGui) {
-                    if (this.info.isStackClear()) {
-                        mc.setScreen(null);
-                    } else {
-                        spellGui.recvServerUpdate(this.info);
-                    }
-                }
-            })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::newPattern);
+        });
         ctx.get().setPacketHandled(true);
     }
 
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java
index 0be7aeba..ea50d27e 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgOpenSpellGuiAck.java
@@ -56,8 +56,8 @@ public record MsgOpenSpellGuiAck(InteractionHand hand, List<ResolvedPattern> pat
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
         ctx.get().enqueueWork(() -> {
-            GuiOpener opener = new GuiOpener(this);
-            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> opener::openGui);
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::openSpellGui);
         });
         ctx.get().setPacketHandled(true);
     }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgSentinelStatusUpdateAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgSentinelStatusUpdateAck.java
index 41517c58..8201d570 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgSentinelStatusUpdateAck.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgSentinelStatusUpdateAck.java
@@ -1,9 +1,7 @@
 package at.petrak.hexcasting.common.network;
 
-import at.petrak.hexcasting.api.player.HexPlayerDataHelper;
 import at.petrak.hexcasting.api.player.Sentinel;
 import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
 import net.minecraft.core.Registry;
 import net.minecraft.network.FriendlyByteBuf;
 import net.minecraft.resources.ResourceKey;
@@ -41,20 +39,10 @@ public record MsgSentinelStatusUpdateAck(Sentinel update) {
     }
 
     public void handle(Supplier<NetworkEvent.Context> ctx) {
-        ctx.get().enqueueWork(() ->
-            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
-                IHateJava.handle(this.update);
-            })
-        );
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::updateSentinel);
+        });
         ctx.get().setPacketHandled(true);
     }
-
-    private static class IHateJava {
-        public static void handle(Sentinel update) {
-            var player = Minecraft.getInstance().player;
-            if (player != null) {
-                HexPlayerDataHelper.setSentinel(player, update);
-            }
-        }
-    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java b/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java
index 2302f239..1e66ced0 100644
--- a/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgShiftScrollSyn.java
@@ -1,6 +1,7 @@
 package at.petrak.hexcasting.common.network;
 
 import at.petrak.hexcasting.api.spell.SpellDatum;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.items.HexItems;
 import at.petrak.hexcasting.common.items.ItemAbacus;
 import at.petrak.hexcasting.common.items.ItemSpellbook;
@@ -56,20 +57,34 @@ public record MsgShiftScrollSyn(InteractionHand hand, double scrollDelta, boolea
     }
 
     private void spellbook(ServerPlayer sender, ItemStack stack) {
-        var tag = stack.getOrCreateTag();
-        ItemSpellbook.RotatePageIdx(stack, this.scrollDelta < 0.0);
+        var newIdx = ItemSpellbook.RotatePageIdx(stack, this.scrollDelta < 0.0);
 
-        var newIdx = tag.getInt(ItemSpellbook.TAG_SELECTED_PAGE);
         var len = ItemSpellbook.HighestPage(stack);
 
+        var sealed = ItemSpellbook.IsSealed(stack);
+
         MutableComponent component;
         if (hand == InteractionHand.OFF_HAND && stack.hasCustomHoverName()) {
-            component = new TranslatableComponent("hexcasting.tooltip.spellbook.page_with_name",
+            if (sealed)
+                component = new TranslatableComponent("hexcasting.tooltip.spellbook.page_with_name.sealed",
+                        new TextComponent(String.valueOf(newIdx)).withStyle(ChatFormatting.WHITE),
+                        new TextComponent(String.valueOf(len)).withStyle(ChatFormatting.WHITE),
+                        new TextComponent("").withStyle(stack.getRarity().color, ChatFormatting.ITALIC).append(stack.getHoverName()),
+                    new TranslatableComponent("hexcasting.tooltip.spellbook.sealed").withStyle(ChatFormatting.GOLD));
+            else
+                component = new TranslatableComponent("hexcasting.tooltip.spellbook.page_with_name",
                     new TextComponent(String.valueOf(newIdx)).withStyle(ChatFormatting.WHITE),
                     new TextComponent(String.valueOf(len)).withStyle(ChatFormatting.WHITE),
                     new TextComponent("").withStyle(stack.getRarity().color, ChatFormatting.ITALIC).append(stack.getHoverName()));
+
         } else {
-            component = new TranslatableComponent("hexcasting.tooltip.spellbook.page",
+            if (sealed)
+                component = new TranslatableComponent("hexcasting.tooltip.spellbook.page.sealed",
+                    new TextComponent(String.valueOf(newIdx)).withStyle(ChatFormatting.WHITE),
+                    new TextComponent(String.valueOf(len)).withStyle(ChatFormatting.WHITE),
+                    new TranslatableComponent("hexcasting.tooltip.spellbook.sealed").withStyle(ChatFormatting.GOLD));
+            else
+                component = new TranslatableComponent("hexcasting.tooltip.spellbook.page",
                     new TextComponent(String.valueOf(newIdx)).withStyle(ChatFormatting.WHITE),
                     new TextComponent(String.valueOf(len)).withStyle(ChatFormatting.WHITE));
         }
@@ -79,11 +94,7 @@ public record MsgShiftScrollSyn(InteractionHand hand, double scrollDelta, boolea
 
     private void abacus(ServerPlayer sender, ItemStack stack) {
         var increase = this.scrollDelta < 0;
-        var tag = stack.getTag();
-        double num = 0d;
-        if (tag != null) {
-            num = tag.getDouble(ItemAbacus.TAG_VALUE);
-        }
+        double num = NBTHelper.getDouble(stack, ItemAbacus.TAG_VALUE);
 
         double delta;
         float pitch;
@@ -96,7 +107,7 @@ public record MsgShiftScrollSyn(InteractionHand hand, double scrollDelta, boolea
         }
 
         num += delta * (increase ? 1 : -1);
-        stack.getOrCreateTag().putDouble(ItemAbacus.TAG_VALUE, num);
+        NBTHelper.putDouble(stack, ItemAbacus.TAG_VALUE, num);
 
         pitch *= (increase ? 1.05f : 0.95f);
         pitch += (Math.random() - 0.5) * 0.1;
diff --git a/src/main/java/at/petrak/hexcasting/common/network/MsgUpdateComparatorVisualsAck.java b/src/main/java/at/petrak/hexcasting/common/network/MsgUpdateComparatorVisualsAck.java
new file mode 100644
index 00000000..c0d58c0b
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/network/MsgUpdateComparatorVisualsAck.java
@@ -0,0 +1,43 @@
+package at.petrak.hexcasting.common.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+/**
+ * Sent server->client when a player is looking at a block through a lens whose comparator value is not the same as what they last saw.
+ */
+public record MsgUpdateComparatorVisualsAck(BlockPos pos, int value) {
+
+    public static MsgUpdateComparatorVisualsAck deserialize(ByteBuf buffer) {
+        var buf = new FriendlyByteBuf(buffer);
+
+        int value = buf.readInt();
+        BlockPos pos = value == -1 ? null : buf.readBlockPos();
+
+        return new MsgUpdateComparatorVisualsAck(pos, value);
+    }
+
+    public void serialize(ByteBuf buffer) {
+        var buf = new FriendlyByteBuf(buffer);
+
+        buf.writeInt(this.value);
+        if (this.value != -1) {
+            buf.writeBlockPos(this.pos);
+        }
+    }
+
+    public void handle(Supplier<NetworkEvent.Context> ctx) {
+        ctx.get().enqueueWork(() -> {
+            ClientPacketHandler handler = new ClientPacketHandler(this);
+            DistExecutor.safeRunWhenOn(Dist.CLIENT, () -> handler::updateComparator);
+        });
+        ctx.get().setPacketHandled(true);
+    }
+
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/BrainsweepRecipe.java b/src/main/java/at/petrak/hexcasting/common/recipe/BrainsweepRecipe.java
index c278bfb1..78a6dec5 100644
--- a/src/main/java/at/petrak/hexcasting/common/recipe/BrainsweepRecipe.java
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/BrainsweepRecipe.java
@@ -16,6 +16,7 @@ import net.minecraft.world.item.crafting.RecipeType;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.Property;
 import net.minecraftforge.registries.ForgeRegistryEntry;
 import org.jetbrains.annotations.Nullable;
 
@@ -69,6 +70,19 @@ public record BrainsweepRecipe(
         return ItemStack.EMPTY.copy();
     }
 
+    // Because kotlin doesn't like doing raw, unchecked types
+    // Can't blame it, but that's what we need to do
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    public static BlockState copyProperties(BlockState original, BlockState copyTo) {
+        for (Property prop : original.getProperties()) {
+            if (copyTo.hasProperty(prop)) {
+                copyTo = copyTo.setValue(prop, original.getValue(prop));
+            }
+        }
+
+        return copyTo;
+    }
+
     public static class Serializer extends ForgeRegistryEntry<RecipeSerializer<?>> implements RecipeSerializer<BrainsweepRecipe> {
         @Override
         public BrainsweepRecipe fromJson(ResourceLocation recipeID, JsonObject json) {
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/HexComposting.java b/src/main/java/at/petrak/hexcasting/common/recipe/HexComposting.java
new file mode 100644
index 00000000..693d3476
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/HexComposting.java
@@ -0,0 +1,35 @@
+package at.petrak.hexcasting.common.recipe;
+
+import at.petrak.hexcasting.common.blocks.HexBlocks;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.ComposterBlock;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.registries.RegistryObject;
+
+public final class HexComposting {
+
+	@SubscribeEvent
+	public static void setup(FMLCommonSetupEvent evt) {
+		compostBlock(HexBlocks.AKASHIC_LEAVES1, 0.3F);
+		compostBlock(HexBlocks.AKASHIC_LEAVES2, 0.3F);
+		compostBlock(HexBlocks.AKASHIC_LEAVES3, 0.3F);
+	}
+
+	private static <T extends Item> void compostItem(RegistryObject<T> itemHolder, float chance) {
+		T item = itemHolder.get();
+
+		if (item != Items.AIR)
+			ComposterBlock.COMPOSTABLES.put(item, chance);
+	}
+
+	private static <T extends Block> void compostBlock(RegistryObject<T> blockHolder, float chance) {
+		T block = blockHolder.get();
+		Item item = block.asItem();
+
+		if (item != Items.AIR)
+			ComposterBlock.COMPOSTABLES.put(item, chance);
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/HexRecipeSerializers.java b/src/main/java/at/petrak/hexcasting/common/recipe/HexRecipeSerializers.java
index dde9660c..484dde13 100644
--- a/src/main/java/at/petrak/hexcasting/common/recipe/HexRecipeSerializers.java
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/HexRecipeSerializers.java
@@ -1,9 +1,12 @@
 package at.petrak.hexcasting.common.recipe;
 
 import at.petrak.hexcasting.HexMod;
+import at.petrak.hexcasting.common.recipe.ingredient.UnsealedIngredient;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.crafting.RecipeSerializer;
 import net.minecraft.world.item.crafting.RecipeType;
+import net.minecraftforge.common.crafting.CraftingHelper;
 import net.minecraftforge.event.RegistryEvent;
 import net.minecraftforge.eventbus.api.SubscribeEvent;
 import net.minecraftforge.registries.DeferredRegister;
@@ -22,5 +25,7 @@ public class HexRecipeSerializers {
     @SubscribeEvent
     public static void registerTypes(RegistryEvent.Register<Item> evt) {
         BRAINSWEEP_TYPE = RecipeType.register(HexMod.MOD_ID + ":brainsweep");
+
+        CraftingHelper.register(new ResourceLocation(HexMod.MOD_ID, "unsealed"), UnsealedIngredient.Serializer.INSTANCE);
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/SealFocusRecipe.java b/src/main/java/at/petrak/hexcasting/common/recipe/SealFocusRecipe.java
index 150c4248..f7cd5e87 100644
--- a/src/main/java/at/petrak/hexcasting/common/recipe/SealFocusRecipe.java
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/SealFocusRecipe.java
@@ -1,61 +1,45 @@
 package at.petrak.hexcasting.common.recipe;
 
+import at.petrak.hexcasting.api.item.DataHolderItem;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.items.HexItems;
 import at.petrak.hexcasting.common.items.ItemFocus;
+import at.petrak.hexcasting.common.recipe.ingredient.UnsealedIngredient;
+import net.minecraft.core.NonNullList;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.inventory.CraftingContainer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
-import net.minecraft.world.item.crafting.CustomRecipe;
+import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.ShapelessRecipe;
 import net.minecraft.world.item.crafting.SimpleRecipeSerializer;
-import net.minecraft.world.level.Level;
+import org.jetbrains.annotations.NotNull;
 
-public class SealFocusRecipe extends CustomRecipe {
+public class SealFocusRecipe extends ShapelessRecipe {
     public static final SimpleRecipeSerializer<SealFocusRecipe> SERIALIZER =
         new SimpleRecipeSerializer<>(SealFocusRecipe::new);
 
+    private static ItemStack getSealedStack() {
+        ItemStack output = new ItemStack(HexItems.FOCUS::get);
+        NBTHelper.putBoolean(output, ItemFocus.TAG_SEALED, true);
+        NBTHelper.putString(output, DataHolderItem.TAG_OVERRIDE_VISUALLY, "any");
+        return output;
+    }
+
+    private static NonNullList<Ingredient> createIngredients() {
+        NonNullList<Ingredient> ingredients = NonNullList.createWithCapacity(2);
+        ingredients.add(UnsealedIngredient.of(new ItemStack(HexItems.FOCUS::get)));
+        ingredients.add(Ingredient.of(Items.HONEYCOMB));
+        return ingredients;
+    }
+
     public SealFocusRecipe(ResourceLocation id) {
-        super(id);
+        super(id, "", getSealedStack(), createIngredients());
     }
 
     @Override
-    public boolean matches(CraftingContainer inv, Level world) {
-        var foundWax = false;
-        var foundOkFocus = false;
-
-        for (int i = 0; i < inv.getContainerSize(); i++) {
-            var stack = inv.getItem(i);
-            if (!stack.isEmpty()) {
-                if (stack.is(HexItems.FOCUS.get())) {
-                    if (foundOkFocus) {
-                        return false;
-                    }
-
-                    if (stack.hasTag()
-                        && stack.getTag().contains(ItemFocus.TAG_DATA)
-                        && (!stack.getTag().contains(ItemFocus.TAG_SEALED)
-                        || !stack.getTag().getBoolean(ItemFocus.TAG_SEALED))) {
-                        foundOkFocus = true;
-                    } else {
-                        return false;
-                    }
-                } else if (stack.is(Items.HONEYCOMB)) {
-                    if (foundWax) {
-                        return false;
-                    }
-                    foundWax = true;
-                } else {
-                    return false;
-                }
-            }
-        }
-
-        return foundWax && foundOkFocus;
-    }
-
-    @Override
-    public ItemStack assemble(CraftingContainer inv) {
+    public @NotNull ItemStack assemble(CraftingContainer inv) {
         ItemStack out = ItemStack.EMPTY;
 
         for (int i = 0; i < inv.getContainerSize(); i++) {
@@ -67,7 +51,7 @@ public class SealFocusRecipe extends CustomRecipe {
         }
 
         if (!out.isEmpty()) {
-            out.getOrCreateTag().putBoolean(ItemFocus.TAG_SEALED, true);
+            NBTHelper.putBoolean(out, ItemFocus.TAG_SEALED, true);
             out.setCount(1);
         }
 
@@ -75,12 +59,7 @@ public class SealFocusRecipe extends CustomRecipe {
     }
 
     @Override
-    public boolean canCraftInDimensions(int width, int height) {
-        return width * height >= 2;
-    }
-
-    @Override
-    public RecipeSerializer<?> getSerializer() {
+    public @NotNull RecipeSerializer<?> getSerializer() {
         return SERIALIZER;
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/SealSpellbookRecipe.java b/src/main/java/at/petrak/hexcasting/common/recipe/SealSpellbookRecipe.java
index f256cd93..1be2ae9f 100644
--- a/src/main/java/at/petrak/hexcasting/common/recipe/SealSpellbookRecipe.java
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/SealSpellbookRecipe.java
@@ -1,58 +1,45 @@
 package at.petrak.hexcasting.common.recipe;
 
+import at.petrak.hexcasting.api.item.DataHolderItem;
+import at.petrak.hexcasting.api.utils.NBTHelper;
 import at.petrak.hexcasting.common.items.HexItems;
 import at.petrak.hexcasting.common.items.ItemSpellbook;
+import at.petrak.hexcasting.common.recipe.ingredient.UnsealedIngredient;
+import net.minecraft.core.NonNullList;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.inventory.CraftingContainer;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
-import net.minecraft.world.item.crafting.CustomRecipe;
+import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.ShapelessRecipe;
 import net.minecraft.world.item.crafting.SimpleRecipeSerializer;
-import net.minecraft.world.level.Level;
+import org.jetbrains.annotations.NotNull;
 
-public class SealSpellbookRecipe extends CustomRecipe {
+public class SealSpellbookRecipe extends ShapelessRecipe {
     public static final SimpleRecipeSerializer<SealSpellbookRecipe> SERIALIZER =
         new SimpleRecipeSerializer<>(SealSpellbookRecipe::new);
 
+    private static ItemStack getSealedStack() {
+        ItemStack output = new ItemStack(HexItems.SPELLBOOK::get);
+        ItemSpellbook.SetSealed(output, true);
+        NBTHelper.putString(output, DataHolderItem.TAG_OVERRIDE_VISUALLY, "any");
+        return output;
+    }
+
+    private static NonNullList<Ingredient> createIngredients() {
+        NonNullList<Ingredient> ingredients = NonNullList.createWithCapacity(2);
+        ingredients.add(UnsealedIngredient.of(new ItemStack(HexItems.SPELLBOOK::get)));
+        ingredients.add(Ingredient.of(Items.HONEYCOMB));
+        return ingredients;
+    }
+
     public SealSpellbookRecipe(ResourceLocation id) {
-        super(id);
+        super(id, "", getSealedStack(), createIngredients());
     }
 
     @Override
-    public boolean matches(CraftingContainer inv, Level world) {
-        var foundWax = false;
-        var foundOkSpellbook = false;
-
-        for (int i = 0; i < inv.getContainerSize(); i++) {
-            var stack = inv.getItem(i);
-            if (!stack.isEmpty()) {
-                if (stack.is(HexItems.SPELLBOOK.get())) {
-                    if (foundOkSpellbook) {
-                        return false;
-                    }
-
-                    if (!ItemSpellbook.IsSealed(stack)) {
-                        foundOkSpellbook = true;
-                    } else {
-                        return false;
-                    }
-                } else if (stack.is(Items.HONEYCOMB)) {
-                    if (foundWax) {
-                        return false;
-                    }
-                    foundWax = true;
-                } else {
-                    return false;
-                }
-            }
-        }
-
-        return foundWax && foundOkSpellbook;
-    }
-
-    @Override
-    public ItemStack assemble(CraftingContainer inv) {
+    public @NotNull ItemStack assemble(CraftingContainer inv) {
         ItemStack out = ItemStack.EMPTY;
 
         for (int i = 0; i < inv.getContainerSize(); i++) {
@@ -67,16 +54,12 @@ public class SealSpellbookRecipe extends CustomRecipe {
             ItemSpellbook.SetSealed(out, true);
             out.setCount(1);
         }
+
         return out;
     }
 
     @Override
-    public boolean canCraftInDimensions(int width, int height) {
-        return width * height >= 2;
-    }
-
-    @Override
-    public RecipeSerializer<?> getSerializer() {
+    public @NotNull RecipeSerializer<?> getSerializer() {
         return SERIALIZER;
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/common/recipe/ingredient/UnsealedIngredient.java b/src/main/java/at/petrak/hexcasting/common/recipe/ingredient/UnsealedIngredient.java
new file mode 100644
index 00000000..53296b6f
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/common/recipe/ingredient/UnsealedIngredient.java
@@ -0,0 +1,98 @@
+package at.petrak.hexcasting.common.recipe.ingredient;
+
+import at.petrak.hexcasting.api.cap.DataHolder;
+import at.petrak.hexcasting.api.cap.HexCapabilities;
+import at.petrak.hexcasting.api.item.DataHolderItem;
+import at.petrak.hexcasting.api.spell.DatumType;
+import at.petrak.hexcasting.api.spell.SpellDatum;
+import at.petrak.hexcasting.api.spell.Widget;
+import at.petrak.hexcasting.api.utils.NBTHelper;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraftforge.common.crafting.AbstractIngredient;
+import net.minecraftforge.common.crafting.CraftingHelper;
+import net.minecraftforge.common.crafting.IIngredientSerializer;
+import net.minecraftforge.common.crafting.NBTIngredient;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Optional;
+
+public class UnsealedIngredient extends AbstractIngredient {
+	private final ItemStack stack;
+
+	protected UnsealedIngredient(ItemStack stack) {
+		super(Arrays.stream(DatumType.values())
+			.filter((it) -> it != DatumType.EMPTY && it != DatumType.OTHER)
+			.map((type) -> {
+				ItemStack newStack = stack.copy();
+				NBTHelper.putString(newStack, DataHolderItem.TAG_OVERRIDE_VISUALLY, SpellDatum.GetTagName(type));
+				return new Ingredient.ItemValue(newStack);
+			}));
+		this.stack = stack;
+	}
+
+	/**
+	 * Creates a new ingredient matching the given stack
+	 */
+	public static UnsealedIngredient of(ItemStack stack) {
+		return new UnsealedIngredient(stack);
+	}
+
+	@Override
+	public boolean test(@Nullable ItemStack input) {
+		if (input == null)
+			return false;
+		if(this.stack.getItem() == input.getItem() && this.stack.getDamageValue() == input.getDamageValue()) {
+			Optional<DataHolder> holder = HexCapabilities.getCapability(input, HexCapabilities.DATUM);
+			if (holder.isPresent()) {
+				return holder.get().readRawDatum() != null && holder.get().writeDatum(SpellDatum.make(Widget.NULL), true);
+			}
+		}
+
+		return false;
+	}
+
+	@Override
+	public boolean isSimple() {
+		return false;
+	}
+
+	@Override
+	public @NotNull IIngredientSerializer<? extends Ingredient> getSerializer() {
+		return UnsealedIngredient.Serializer.INSTANCE;
+	}
+
+	@Override
+	public @NotNull JsonElement toJson() {
+		JsonObject json = new JsonObject();
+		json.addProperty("type", Objects.toString(CraftingHelper.getID(NBTIngredient.Serializer.INSTANCE)));
+		json.addProperty("item", Objects.toString(stack.getItem().getRegistryName()));
+		return json;
+	}
+
+
+	public static class Serializer implements IIngredientSerializer<UnsealedIngredient> {
+		public static final UnsealedIngredient.Serializer INSTANCE = new UnsealedIngredient.Serializer();
+
+		@Override
+		public @NotNull UnsealedIngredient parse(FriendlyByteBuf buffer) {
+			return new UnsealedIngredient(buffer.readItem());
+		}
+
+		@Override
+		public @NotNull UnsealedIngredient parse(@NotNull JsonObject json) {
+			return new UnsealedIngredient(CraftingHelper.getItemStack(json, true));
+		}
+
+		@Override
+		public void write(FriendlyByteBuf buffer, UnsealedIngredient ingredient) {
+			buffer.writeItem(ingredient.stack);
+		}
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/datagen/HexAdvancements.java b/src/main/java/at/petrak/hexcasting/datagen/HexAdvancements.java
index 7cd2c710..70547320 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/HexAdvancements.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/HexAdvancements.java
@@ -4,6 +4,7 @@ import at.petrak.hexcasting.HexMod;
 import at.petrak.hexcasting.api.advancements.FailToCastGreatSpellTrigger;
 import at.petrak.hexcasting.api.advancements.OvercastTrigger;
 import at.petrak.hexcasting.api.advancements.SpendManaTrigger;
+import at.petrak.hexcasting.api.misc.ManaConstants;
 import at.petrak.hexcasting.common.items.HexItems;
 import net.minecraft.advancements.Advancement;
 import net.minecraft.advancements.DisplayInfo;
@@ -16,7 +17,6 @@ import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.level.ItemLike;
-import net.minecraft.world.level.block.Blocks;
 import net.minecraftforge.common.data.ExistingFileHelper;
 
 import java.util.function.Consumer;
@@ -37,14 +37,7 @@ public class HexAdvancements extends AdvancementProvider {
                 new ResourceLocation("minecraft", "textures/block/calcite.png"),
                 FrameType.TASK, true, true, true))
             // the only thing making this vaguely tolerable is the knowledge the json files are worse somehow
-            .addCriterion("on_thingy", new TickTrigger.TriggerInstance(EntityPredicate.Composite.wrap(
-                EntityPredicate.Builder.entity()
-                    .steppingOn(LocationPredicate.Builder.location()
-                        .setBlock(BlockPredicate.Builder.block()
-                            .of(Blocks.AMETHYST_BLOCK, Blocks.CALCITE)
-                            .build())
-                        .setY(MinMaxBounds.Doubles.between(-64.0, 30.0)).build())
-                    .build())))
+            .addCriterion("has_charged_amethyst", InventoryChangeTrigger.TriggerInstance.hasItems(HexItems.CHARGED_AMETHYST::get))
             .save(consumer, prefix("root")); // how the hell does one even read this
 
         // weird names so we have alphabetical parity
@@ -53,13 +46,13 @@ public class HexAdvancements extends AdvancementProvider {
             .parent(root)
             .addCriterion("waste_amt", new SpendManaTrigger.Instance(EntityPredicate.Composite.ANY,
                 MinMaxBounds.Ints.ANY,
-                MinMaxBounds.Ints.atLeast(89_000)))
+                MinMaxBounds.Ints.atLeast(89 * ManaConstants.DUST_UNIT / 10)))
             .save(consumer, prefix("aaa_wasteful_cast"));
         Advancement.Builder.advancement()
             .display(simple(HexItems.CHARGED_AMETHYST.get(), "big_cast", FrameType.TASK))
             .parent(root)
             .addCriterion("cast_amt", new SpendManaTrigger.Instance(EntityPredicate.Composite.ANY,
-                MinMaxBounds.Ints.atLeast(6_400_000),
+                MinMaxBounds.Ints.atLeast(64 * ManaConstants.CRYSTAL_UNIT),
                 MinMaxBounds.Ints.ANY))
             .save(consumer, prefix("aab_big_cast"));
 
@@ -92,7 +85,7 @@ public class HexAdvancements extends AdvancementProvider {
                 new OvercastTrigger.Instance(EntityPredicate.Composite.ANY,
                     MinMaxBounds.Ints.ANY,
                     // add a little bit of slop here
-                    MinMaxBounds.Doubles.atLeast(17.95),
+                    MinMaxBounds.Doubles.atLeast(0.8),
                     MinMaxBounds.Doubles.between(0.1, 2.05)))
             .save(consumer, prefix("enlightenment"));
 
diff --git a/src/main/java/at/petrak/hexcasting/datagen/HexBlockTagProvider.java b/src/main/java/at/petrak/hexcasting/datagen/HexBlockTagProvider.java
index fc3b2564..52bd912b 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/HexBlockTagProvider.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/HexBlockTagProvider.java
@@ -33,7 +33,7 @@ public class HexBlockTagProvider extends BlockTagsProvider {
                 HexBlocks.AKASHIC_WOOD.get(), HexBlocks.AKASHIC_WOOD_STRIPPED.get(),
                 HexBlocks.AKASHIC_PLANKS.get(), HexBlocks.AKASHIC_PANEL.get(), HexBlocks.AKASHIC_TILE.get(),
                 HexBlocks.AKASHIC_DOOR.get(), HexBlocks.AKASHIC_TRAPDOOR.get(), HexBlocks.AKASHIC_SLAB.get(),
-                HexBlocks.AKASHIC_BUTTON.get());
+                HexBlocks.AKASHIC_STAIRS.get(), HexBlocks.AKASHIC_BUTTON.get());
 
         tag(BlockTags.MINEABLE_WITH_HOE)
             .add(HexBlocks.AKASHIC_LEAVES1.get(), HexBlocks.AKASHIC_LEAVES2.get(), HexBlocks.AKASHIC_LEAVES3.get());
diff --git a/src/main/java/at/petrak/hexcasting/datagen/HexItemModels.java b/src/main/java/at/petrak/hexcasting/datagen/HexItemModels.java
index 3e01f695..0c301eea 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/HexItemModels.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/HexItemModels.java
@@ -6,7 +6,6 @@ import at.petrak.hexcasting.common.items.*;
 import at.petrak.hexcasting.common.items.magic.ItemManaBattery;
 import at.petrak.hexcasting.common.items.magic.ItemPackagedSpell;
 import at.petrak.paucal.api.datagen.PaucalItemModelProvider;
-import com.mojang.datafixers.util.Pair;
 import net.minecraft.data.DataGenerator;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.DyeColor;
@@ -14,13 +13,15 @@ import net.minecraft.world.item.Item;
 import net.minecraftforge.client.model.generators.ModelBuilder;
 import net.minecraftforge.client.model.generators.ModelFile;
 import net.minecraftforge.common.data.ExistingFileHelper;
-import net.minecraftforge.registries.RegistryObject;
 
 public class HexItemModels extends PaucalItemModelProvider {
     public HexItemModels(DataGenerator generator, ExistingFileHelper existingFileHelper) {
         super(generator, HexMod.MOD_ID, existingFileHelper);
     }
 
+    private static final String[] DATUM_TYPES = {"empty", "entity", "double", "vec3", "widget", "list", "pattern"};
+    private static final String[] PHIAL_SIZES = {"small", "medium", "large"};
+
     @Override
     protected void registerModels() {
         simpleItem(HexItems.AMETHYST_DUST.get());
@@ -50,48 +51,24 @@ public class HexItemModels extends PaucalItemModelProvider {
             "layer0", modLoc("item/wands/old"));
         singleTexture("wand_bosnia", new ResourceLocation("item/handheld_rod"),
             "layer0", modLoc("item/wands/bosnia"));
-        var wands = new Item[]{
-            HexItems.WAND_OAK.get(),
-            HexItems.WAND_BIRCH.get(),
-            HexItems.WAND_SPRUCE.get(),
-            HexItems.WAND_JUNGLE.get(),
-            HexItems.WAND_DARK_OAK.get(),
-            HexItems.WAND_ACACIA.get(),
-            HexItems.WAND_CRIMSON.get(),
-            HexItems.WAND_WARPED.get(),
-            HexItems.WAND_AKASHIC.get(),
-        };
-        var wandKeys = new String[]{
-            "oak", "birch", "spruce", "jungle", "dark_oak", "acacia", "crimson", "warped", "akashic"
-        };
-        for (int i = 0; i < wands.length; i++) {
-            Item wand = wands[i];
-            String wandKey = wandKeys[i];
-            singleTexture(wand.getRegistryName().getPath(), new ResourceLocation("item/handheld_rod"),
-                "layer0", modLoc("item/wands/" + wandKey));
-            getBuilder(wand.getRegistryName().getPath())
-                .override()
-                .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 0)
-                .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_" + wandKey)))
-                .end().override()
-                .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 1)
-                .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_old")))
-                .end().override()
-                .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 2)
-                .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_bosnia")))
-                .end();
-        }
+
+        buildWand(HexItems.WAND_OAK.get(), "oak");
+        buildWand(HexItems.WAND_BIRCH.get(), "birch");
+        buildWand(HexItems.WAND_SPRUCE.get(), "spruce");
+        buildWand(HexItems.WAND_JUNGLE.get(), "jungle");
+        buildWand(HexItems.WAND_DARK_OAK.get(), "dark_oak");
+        buildWand(HexItems.WAND_ACACIA.get(), "acacia");
+        buildWand(HexItems.WAND_CRIMSON.get(), "crimson");
+        buildWand(HexItems.WAND_WARPED.get(), "warped");
+        buildWand(HexItems.WAND_AKASHIC.get(), "akashic");
 
         simpleItem(modLoc("patchouli_book"));
 
-        String[] datumStoredTypes = new String[]{
-            "empty", "entity", "double", "vec3", "widget", "list", "pattern"
-        };
         // For stupid bad reasons we need to do this in ascending order.
         for (int sealedIdx = 0; sealedIdx <= 1; sealedIdx++) {
             var sealed = sealedIdx == 1;
-            for (int i = 0, stringsLength = datumStoredTypes.length; i < stringsLength; i++) {
-                var type = datumStoredTypes[i];
+            for (int i = 0, stringsLength = DATUM_TYPES.length; i < stringsLength; i++) {
+                var type = DATUM_TYPES[i];
 
                 var suffix = type + (sealed ? "_sealed" : "");
 
@@ -117,32 +94,14 @@ public class HexItemModels extends PaucalItemModelProvider {
             }
         }
 
-        Pair<RegistryObject<Item>, String>[] packagers = new Pair[]{
-            new Pair(HexItems.CYPHER, "cypher"),
-            new Pair(HexItems.TRINKET, "trinket"),
-            new Pair(HexItems.ARTIFACT, "artifact"),
-        };
-        for (Pair<RegistryObject<Item>, String> p : packagers) {
-            simpleItem(modLoc(p.getSecond()));
-            simpleItem(modLoc(p.getSecond() + "_filled"));
-            getBuilder(p.getFirst().get().getRegistryName().getPath())
-                .override()
-                .predicate(ItemPackagedSpell.HAS_PATTERNS_PRED, -0.01f)
-                .model(new ModelFile.UncheckedModelFile(modLoc("item/" + p.getSecond())))
-                .end()
-                .override()
-                .predicate(ItemPackagedSpell.HAS_PATTERNS_PRED, 1f - 0.01f)
-                .model(new ModelFile.UncheckedModelFile(modLoc("item/" + p.getSecond() + "_filled")))
-                .end();
-        }
+        buildPackagedSpell(HexItems.CYPHER.get(), "cypher");
+        buildPackagedSpell(HexItems.TRINKET.get(), "trinket");
+        buildPackagedSpell(HexItems.ARTIFACT.get(), "artifact");
 
-        String[] sizeNames = new String[]{
-            "small", "medium", "large",
-        };
         int maxFill = 4;
-        for (int size = 0; size < sizeNames.length; size++) {
+        for (int size = 0; size < PHIAL_SIZES.length; size++) {
             for (int fill = 0; fill <= maxFill; fill++) {
-                String name = "phial_" + sizeNames[size] + "_" + fill;
+                String name = "phial_" + PHIAL_SIZES[size] + "_" + fill;
                 singleTexture(
                     name,
                     new ResourceLocation("item/generated"),
@@ -199,4 +158,34 @@ public class HexItemModels extends PaucalItemModelProvider {
         getBuilder(HexBlocks.AKASHIC_PRESSURE_PLATE.getId().getPath())
             .parent(new ModelFile.UncheckedModelFile(modLoc("block/akashic_pressure_plate")));
     }
+
+    private void buildWand(Item item, String name) {
+        singleTexture(item.getRegistryName().getPath(), new ResourceLocation("item/handheld_rod"),
+            "layer0", modLoc("item/wands/" + name));
+        getBuilder(item.getRegistryName().getPath())
+            .override()
+            .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 0)
+            .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_" + name)))
+            .end().override()
+            .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 1)
+            .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_old")))
+            .end().override()
+            .predicate(ItemWand.FUNNY_LEVEL_PREDICATE, 2)
+            .model(new ModelFile.UncheckedModelFile(modLoc("item/wand_bosnia")))
+            .end();
+    }
+
+    private void buildPackagedSpell(Item item, String name) {
+        simpleItem(modLoc(name));
+        simpleItem(modLoc(name + "_filled"));
+        getBuilder(item.getRegistryName().getPath())
+            .override()
+            .predicate(ItemPackagedSpell.HAS_PATTERNS_PRED, -0.01f)
+            .model(new ModelFile.UncheckedModelFile(modLoc("item/" + name)))
+            .end()
+            .override()
+            .predicate(ItemPackagedSpell.HAS_PATTERNS_PRED, 1f - 0.01f)
+            .model(new ModelFile.UncheckedModelFile(modLoc("item/" + name + "_filled")))
+            .end();
+    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/datagen/HexLootTables.java b/src/main/java/at/petrak/hexcasting/datagen/HexLootTables.java
index f8011e6d..d797593f 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/HexLootTables.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/HexLootTables.java
@@ -11,11 +11,15 @@ import net.minecraft.data.DataGenerator;
 import net.minecraft.world.item.enchantment.Enchantments;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.DoorBlock;
+import net.minecraft.world.level.block.SlabBlock;
 import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
+import net.minecraft.world.level.block.state.properties.SlabType;
 import net.minecraft.world.level.storage.loot.LootPool;
 import net.minecraft.world.level.storage.loot.LootTable;
 import net.minecraft.world.level.storage.loot.entries.LootItem;
+import net.minecraft.world.level.storage.loot.functions.ApplyExplosionDecay;
 import net.minecraft.world.level.storage.loot.functions.CopyNbtFunction;
+import net.minecraft.world.level.storage.loot.functions.SetItemCountFunction;
 import net.minecraft.world.level.storage.loot.predicates.AlternativeLootItemCondition;
 import net.minecraft.world.level.storage.loot.predicates.LootItemBlockStatePropertyCondition;
 import net.minecraft.world.level.storage.loot.predicates.MatchTool;
@@ -45,17 +49,13 @@ public class HexLootTables extends PaucalLootTableProvider {
             HexBlocks.AKASHIC_LOG, HexBlocks.AKASHIC_LOG_STRIPPED, HexBlocks.AKASHIC_WOOD,
             HexBlocks.AKASHIC_WOOD_STRIPPED,
             HexBlocks.AKASHIC_PLANKS, HexBlocks.AKASHIC_TILE, HexBlocks.AKASHIC_PANEL,
-            HexBlocks.AKASHIC_TRAPDOOR);
+            HexBlocks.AKASHIC_TRAPDOOR, HexBlocks.AKASHIC_STAIRS, HexBlocks.AKASHIC_PRESSURE_PLATE, HexBlocks.AKASHIC_BUTTON);
 
-        for (Block block : new Block[] { HexBlocks.AKASHIC_LEAVES1.get(), HexBlocks.AKASHIC_LEAVES2.get(), HexBlocks.AKASHIC_LEAVES3.get()}) {
-            var leafPool = dropThisPool(block, 1)
-                    .when(new AlternativeLootItemCondition.Builder(
-                            CanToolPerformAction.canToolPerformAction(ToolActions.SHEARS_DIG),
-                            MatchTool.toolMatches(ItemPredicate.Builder.item()
-                                    .hasEnchantment(new EnchantmentPredicate(Enchantments.SILK_TOUCH, MinMaxBounds.Ints.atLeast(1))))
-                    ));
-            lootTables.put(block, LootTable.lootTable().withPool(leafPool));
-        }
+        makeSlabTable(lootTables, HexBlocks.AKASHIC_SLAB.get());
+
+        makeLeafTable(lootTables, HexBlocks.AKASHIC_LEAVES1.get());
+        makeLeafTable(lootTables, HexBlocks.AKASHIC_LEAVES2.get());
+        makeLeafTable(lootTables, HexBlocks.AKASHIC_LEAVES3.get());
 
         var slatePool = LootPool.lootPool().name("slate").
             setRolls(ConstantValue.exactly(1))
@@ -70,4 +70,24 @@ public class HexLootTables extends PaucalLootTableProvider {
             ));
         lootTables.put(HexBlocks.AKASHIC_DOOR.get(), LootTable.lootTable().withPool(doorPool));
     }
+
+    private void makeLeafTable(Map<Block, LootTable.Builder> lootTables, Block block) {
+        var leafPool = dropThisPool(block, 1)
+            .when(new AlternativeLootItemCondition.Builder(
+                CanToolPerformAction.canToolPerformAction(ToolActions.SHEARS_DIG),
+                MatchTool.toolMatches(ItemPredicate.Builder.item()
+                    .hasEnchantment(new EnchantmentPredicate(Enchantments.SILK_TOUCH, MinMaxBounds.Ints.atLeast(1))))
+            ));
+        lootTables.put(block, LootTable.lootTable().withPool(leafPool));
+    }
+
+    private void makeSlabTable(Map<Block, LootTable.Builder> lootTables, Block block) {
+        var leafPool = dropThisPool(block, 1)
+            .apply(SetItemCountFunction.setCount(ConstantValue.exactly(2))
+                .when(new LootItemBlockStatePropertyCondition.Builder(block).setProperties(
+                    StatePropertiesPredicate.Builder.properties().hasProperty(SlabBlock.TYPE, SlabType.DOUBLE)
+                )))
+            .apply(ApplyExplosionDecay.explosionDecay());
+        lootTables.put(block, LootTable.lootTable().withPool(leafPool));
+    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/datagen/HexRecipes.java b/src/main/java/at/petrak/hexcasting/datagen/HexRecipes.java
index 36f383ce..53320c02 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/HexRecipes.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/HexRecipes.java
@@ -5,6 +5,7 @@ import at.petrak.hexcasting.api.advancements.OvercastTrigger;
 import at.petrak.hexcasting.api.mod.HexItemTags;
 import at.petrak.hexcasting.common.blocks.HexBlocks;
 import at.petrak.hexcasting.common.items.HexItems;
+import at.petrak.hexcasting.common.items.ItemWand;
 import at.petrak.hexcasting.common.recipe.SealFocusRecipe;
 import at.petrak.hexcasting.common.recipe.SealSpellbookRecipe;
 import at.petrak.hexcasting.common.recipe.ingredient.StateIngredientHelper;
@@ -15,7 +16,6 @@ import net.minecraft.advancements.critereon.EntityPredicate;
 import net.minecraft.advancements.critereon.InventoryChangeTrigger;
 import net.minecraft.advancements.critereon.ItemPredicate;
 import net.minecraft.advancements.critereon.MinMaxBounds;
-import net.minecraft.core.Registry;
 import net.minecraft.data.DataGenerator;
 import net.minecraft.data.recipes.*;
 import net.minecraft.resources.ResourceLocation;
@@ -29,6 +29,7 @@ import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.world.item.crafting.SimpleRecipeSerializer;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraftforge.common.Tags;
+import net.minecraftforge.registries.ForgeRegistries;
 
 import java.util.function.Consumer;
 
@@ -44,39 +45,15 @@ public class HexRecipes extends PaucalRecipeProvider {
         specialRecipe(recipes, SealFocusRecipe.SERIALIZER);
         specialRecipe(recipes, SealSpellbookRecipe.SERIALIZER);
 
-        var wands = new Item[]{
-            HexItems.WAND_OAK.get(),
-            HexItems.WAND_BIRCH.get(),
-            HexItems.WAND_SPRUCE.get(),
-            HexItems.WAND_JUNGLE.get(),
-            HexItems.WAND_DARK_OAK.get(),
-            HexItems.WAND_ACACIA.get(),
-            HexItems.WAND_CRIMSON.get(),
-            HexItems.WAND_WARPED.get(),
-            HexItems.WAND_AKASHIC.get(),
-        };
-        var woods = new Item[]{
-            Items.OAK_PLANKS,
-            Items.BIRCH_PLANKS,
-            Items.SPRUCE_PLANKS,
-            Items.JUNGLE_PLANKS,
-            Items.DARK_OAK_PLANKS,
-            Items.ACACIA_PLANKS,
-            Items.CRIMSON_PLANKS,
-            Items.WARPED_PLANKS,
-            HexBlocks.AKASHIC_PLANKS.get().asItem(),
-        };
-        for (int i = 0; i < wands.length; i++) {
-            ShapedRecipeBuilder.shaped(wands[i])
-                .define('W', woods[i])
-                .define('S', Items.STICK)
-                .define('A', HexItems.CHARGED_AMETHYST.get())
-                .pattern(" SA")
-                .pattern(" WS")
-                .pattern("S  ")
-                .unlockedBy("has_item", has(HexItems.CHARGED_AMETHYST.get()))
-                .save(recipes);
-        }
+        wandRecipe(recipes, HexItems.WAND_OAK.get(), Items.OAK_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_BIRCH.get(), Items.BIRCH_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_SPRUCE.get(), Items.SPRUCE_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_JUNGLE.get(), Items.JUNGLE_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_DARK_OAK.get(), Items.DARK_OAK_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_ACACIA.get(), Items.ACACIA_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_CRIMSON.get(), Items.CRIMSON_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_WARPED.get(), Items.WARPED_PLANKS);
+        wandRecipe(recipes, HexItems.WAND_AKASHIC.get(), HexBlocks.AKASHIC_PLANKS.get().asItem());
 
         ringCornered(HexItems.FOCUS.get(), 1, Ingredient.of(Tags.Items.DUSTS_GLOWSTONE),
             Ingredient.of(Tags.Items.LEATHER), Ingredient.of(HexItems.CHARGED_AMETHYST.get()))
@@ -149,33 +126,22 @@ public class HexRecipes extends PaucalRecipeProvider {
                 .pattern(" B ")
                 .unlockedBy("has_item", has(HexItems.AMETHYST_DUST.get())).save(recipes);
         }
-        Item[] politicsInMyVidya = new Item[]{
-            Items.EGG,
-            Items.STONE_BRICK_WALL,
-            Items.GLASS,
-            Items.BREAD,
-            Items.WHEAT,
-            Items.CARROT,
-            Items.GLASS_BOTTLE,
-            Items.RAW_COPPER,
-            Items.MOSS_BLOCK,
-            Items.HONEYCOMB,
-            Items.RAW_IRON,
-            Items.WATER_BUCKET,
-            Items.AZALEA,
-            Items.ARROW,
-        };
-        for (int i = 0; i < politicsInMyVidya.length; i++) {
-            var item = HexItems.PRIDE_COLORIZERS[i].get();
-            ShapedRecipeBuilder.shaped(item)
-                .define('B', Items.BOWL)
-                .define('D', HexItems.AMETHYST_DUST.get())
-                .define('C', politicsInMyVidya[i])
-                .pattern(" C ")
-                .pattern(" D ")
-                .pattern(" B ")
-                .unlockedBy("has_item", has(HexItems.AMETHYST_DUST.get())).save(recipes);
-        }
+
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[0].get(), Items.EGG); // Trans
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[1].get(), Items.STONE_BRICK_WALL); // Gay
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[2].get(), Items.GLASS); // Agender
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[3].get(), Items.BREAD); // Asexual
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[4].get(), Items.WHEAT); // Bisexual
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[5].get(), Items.CARROT); // Pansexual
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[6].get(), Items.GLASS_BOTTLE); // Genderqueer
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[7].get(), Items.RAW_COPPER); // Demigirl
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[8].get(), Items.MOSS_BLOCK); // Non-Binary
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[9].get(), Items.HONEYCOMB); // Lesbian
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[10].get(), Items.RAW_IRON); // Demiboy
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[11].get(), Items.WATER_BUCKET); // Genderfluid
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[12].get(), Items.AZALEA); // Intersex
+        gayRecipe(recipes, HexItems.PRIDE_COLORIZERS[13].get(), Items.ARROW); // Aroace
+
         ShapedRecipeBuilder.shaped(HexItems.UUID_COLORIZER.get())
             .define('B', Items.BOWL)
             .define('D', HexItems.AMETHYST_DUST.get())
@@ -292,7 +258,7 @@ public class HexRecipes extends PaucalRecipeProvider {
         var enlightenment = new OvercastTrigger.Instance(EntityPredicate.Composite.ANY,
             MinMaxBounds.Ints.ANY,
             // add a little bit of slop here
-            MinMaxBounds.Doubles.atLeast(17.95),
+            MinMaxBounds.Doubles.atLeast(0.8),
             MinMaxBounds.Doubles.between(0.1, 2.05));
 
         ShapedRecipeBuilder.shaped(HexBlocks.EMPTY_IMPETUS.get())
@@ -367,8 +333,31 @@ public class HexRecipes extends PaucalRecipeProvider {
             .save(recipes, modLoc("brainsweep/akashic_record"));
     }
 
+    private void wandRecipe(Consumer<FinishedRecipe> recipes, ItemWand wand, Item plank) {
+        ShapedRecipeBuilder.shaped(wand)
+            .define('W', plank)
+            .define('S', Items.STICK)
+            .define('A', HexItems.CHARGED_AMETHYST.get())
+            .pattern(" SA")
+            .pattern(" WS")
+            .pattern("S  ")
+            .unlockedBy("has_item", has(HexItems.CHARGED_AMETHYST.get()))
+            .save(recipes);
+    }
+
+    private void gayRecipe(Consumer<FinishedRecipe> recipes, Item colorizer, Item material) {
+        ShapedRecipeBuilder.shaped(colorizer)
+            .define('B', Items.BOWL)
+            .define('D', HexItems.AMETHYST_DUST.get())
+            .define('C', material)
+            .pattern(" C ")
+            .pattern(" D ")
+            .pattern(" B ")
+            .unlockedBy("has_item", has(HexItems.AMETHYST_DUST.get())).save(recipes);
+    }
+
     protected void specialRecipe(Consumer<FinishedRecipe> consumer, SimpleRecipeSerializer<?> serializer) {
-        var name = Registry.RECIPE_SERIALIZER.getKey(serializer);
+        var name = ForgeRegistries.RECIPE_SERIALIZERS.getKey(serializer);
         SpecialRecipeBuilder.special(serializer).save(consumer, prefix("dynamic/" + name.getPath()).toString());
     }
 
diff --git a/src/main/java/at/petrak/hexcasting/datagen/lootmods/AmethystShardReducerModifier.java b/src/main/java/at/petrak/hexcasting/datagen/lootmods/AmethystShardReducerModifier.java
index c45c89b5..f6dc85c9 100644
--- a/src/main/java/at/petrak/hexcasting/datagen/lootmods/AmethystShardReducerModifier.java
+++ b/src/main/java/at/petrak/hexcasting/datagen/lootmods/AmethystShardReducerModifier.java
@@ -26,7 +26,7 @@ public class AmethystShardReducerModifier extends LootModifier {
     protected List<ItemStack> doApply(List<ItemStack> generatedLoot, LootContext context) {
         for (var stack : generatedLoot) {
             if (stack.is(Items.AMETHYST_SHARD)) {
-                stack.shrink((int) (stack.getCount() * modifier));
+                stack.setCount((int) (stack.getCount() * (1 + modifier)));
             }
         }
         return generatedLoot;
diff --git a/src/main/java/at/petrak/hexcasting/interop/jei/BrainsweepRecipeCategory.java b/src/main/java/at/petrak/hexcasting/interop/jei/BrainsweepRecipeCategory.java
new file mode 100644
index 00000000..c4e63e96
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/interop/jei/BrainsweepRecipeCategory.java
@@ -0,0 +1,170 @@
+package at.petrak.hexcasting.interop.jei;
+
+import at.petrak.hexcasting.client.ClientTickCounter;
+import at.petrak.hexcasting.common.recipe.BrainsweepRecipe;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Vector3f;
+import mezz.jei.api.gui.builder.IRecipeLayoutBuilder;
+import mezz.jei.api.gui.drawable.IDrawable;
+import mezz.jei.api.gui.drawable.IDrawableStatic;
+import mezz.jei.api.gui.ingredient.IRecipeSlotsView;
+import mezz.jei.api.helpers.IGuiHelper;
+import mezz.jei.api.recipe.IFocusGroup;
+import mezz.jei.api.recipe.RecipeIngredientRole;
+import mezz.jei.api.recipe.RecipeType;
+import mezz.jei.api.recipe.category.IRecipeCategory;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.EntityRenderDispatcher;
+import net.minecraft.core.Registry;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.TranslatableComponent;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.npc.Villager;
+import net.minecraft.world.entity.npc.VillagerProfession;
+import net.minecraft.world.entity.npc.VillagerType;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.registries.ForgeRegistries;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import static at.petrak.hexcasting.common.lib.RegisterHelper.prefix;
+
+public class BrainsweepRecipeCategory implements IRecipeCategory<BrainsweepRecipe> {
+	public static final ResourceLocation UID = prefix("brainsweep");
+
+	private final IDrawableStatic background;
+	private final IDrawable icon;
+	private final Component localizedName;
+
+	public BrainsweepRecipeCategory(IGuiHelper guiHelper) {
+		ResourceLocation location = prefix("textures/gui/brainsweep_jei.png");
+		background = guiHelper.drawableBuilder(location, 0, 0, 118, 86).setTextureSize(128, 128).build();
+		var brainsweep = prefix("brainsweep");
+		localizedName = new TranslatableComponent("hexcasting.spell." + brainsweep);
+		icon = new PatternDrawable(brainsweep, 16, 16);
+	}
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public @NotNull Component getTitle() {
+		return localizedName;
+	}
+
+	@Override
+	public @NotNull IDrawable getBackground() {
+		return background;
+	}
+
+	@Override
+	public @NotNull IDrawable getIcon() {
+		return icon;
+	}
+
+	@Override
+	public @NotNull List<Component> getTooltipStrings(@NotNull BrainsweepRecipe recipe, @NotNull IRecipeSlotsView recipeSlotsView, double mouseX, double mouseY) {
+		if (37 <= mouseX && mouseX <= 37 + 26 && 19 <= mouseY && mouseY <= 19 + 48) {
+			List<Component> tooltip = new ArrayList<>(3);
+			var profession = recipe.villagerIn().profession();
+			if (profession == null) {
+				tooltip.add(new TranslatableComponent("hexcasting.tooltip.brainsweep.profession.any"));
+			} else {
+				var professionKey = "entity.minecraft.villager." + profession.getPath();
+				tooltip.add(new TranslatableComponent("hexcasting.tooltip.brainsweep.profession",
+					new TranslatableComponent(professionKey)));
+			}
+			var biome = recipe.villagerIn().biome();
+			if (biome == null) {
+				tooltip.add(new TranslatableComponent("hexcasting.tooltip.brainsweep.biome.any"));
+			} else {
+				var biomeKey = "biome.minecraft." + biome.getPath();
+				tooltip.add(new TranslatableComponent("hexcasting.tooltip.brainsweep.biome",
+					new TranslatableComponent(biomeKey)));
+			}
+
+			tooltip.add(new TranslatableComponent("hexcasting.tooltip.brainsweep.min_level",
+				recipe.villagerIn().minLevel()));
+			return tooltip;
+		}
+
+		return Collections.emptyList();
+	}
+
+	private Villager villager;
+
+	@Override
+	public void draw(@NotNull BrainsweepRecipe recipe, @NotNull IRecipeSlotsView recipeSlotsView, @NotNull PoseStack stack, double mouseX, double mouseY) {
+		ClientLevel level = Minecraft.getInstance().level;
+		if (level != null) {
+			VillagerProfession profession = Objects.requireNonNullElse(ForgeRegistries.PROFESSIONS.getValue(recipe.villagerIn().profession()),
+				VillagerProfession.TOOLSMITH);
+			VillagerType biome = Objects.requireNonNullElse(Registry.VILLAGER_TYPE.get(recipe.villagerIn().biome()),
+				VillagerType.PLAINS);
+			int minLevel = recipe.villagerIn().minLevel();
+			if (villager == null)
+				villager = new Villager(EntityType.VILLAGER, level);
+
+			villager.setVillagerData(villager.getVillagerData()
+				.setProfession(profession)
+				.setType(biome)
+				.setLevel(minLevel));
+
+			RenderSystem.enableBlend();
+			RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+			renderEntity(stack, villager, level, 50, 62.5f, ClientTickCounter.total, 20, 0);
+		}
+	}
+
+	private static void renderEntity(PoseStack ms, Entity entity, Level world, float x, float y, float rotation, float renderScale, float offset) {
+		entity.level = world;
+		ms.pushPose();
+		ms.translate(x, y, 50.0D);
+		ms.scale(renderScale, renderScale, renderScale);
+		ms.translate(0.0D, offset, 0.0D);
+		ms.mulPose(Vector3f.ZP.rotationDegrees(180.0F));
+		ms.mulPose(Vector3f.YP.rotationDegrees(rotation));
+		EntityRenderDispatcher erd = Minecraft.getInstance().getEntityRenderDispatcher();
+		MultiBufferSource.BufferSource immediate = Minecraft.getInstance().renderBuffers().bufferSource();
+		erd.setRenderShadow(false);
+		erd.render(entity, 0.0D, 0.0D, 0.0D, 0.0F, 1.0F, ms, immediate, 15728880);
+		erd.setRenderShadow(true);
+		immediate.endBatch();
+		ms.popPose();
+	}
+
+	@Override
+	public void setRecipe(@NotNull IRecipeLayoutBuilder builder, @NotNull BrainsweepRecipe recipe, @NotNull IFocusGroup focuses) {
+		builder.addSlot(RecipeIngredientRole.INPUT, 12, 35)
+			.addItemStacks(recipe.blockIn().getDisplayedStacks());
+		builder.addSlot(RecipeIngredientRole.OUTPUT, 87, 35)
+			.addItemStack(new ItemStack(recipe.result().getBlock()));
+	}
+
+	@Override
+	public @NotNull RecipeType<BrainsweepRecipe> getRecipeType() {
+		return HexJEIPlugin.BRAINSWEEPING;
+	}
+
+	@Override
+	@SuppressWarnings("removal")
+	public @NotNull ResourceLocation getUid() {
+		return UID;
+	}
+
+	@Override
+	@SuppressWarnings("removal")
+	public @NotNull Class<? extends BrainsweepRecipe> getRecipeClass() {
+		return BrainsweepRecipe.class;
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/interop/jei/HexJEIPlugin.java b/src/main/java/at/petrak/hexcasting/interop/jei/HexJEIPlugin.java
new file mode 100644
index 00000000..159554de
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/interop/jei/HexJEIPlugin.java
@@ -0,0 +1,60 @@
+package at.petrak.hexcasting.interop.jei;
+
+import at.petrak.hexcasting.HexMod;
+import at.petrak.hexcasting.common.items.HexItems;
+import at.petrak.hexcasting.common.recipe.BrainsweepRecipe;
+import at.petrak.hexcasting.common.recipe.HexRecipeSerializers;
+import mezz.jei.api.IModPlugin;
+import mezz.jei.api.JeiPlugin;
+import mezz.jei.api.recipe.RecipeType;
+import mezz.jei.api.registration.IRecipeCatalystRegistration;
+import mezz.jei.api.registration.IRecipeCategoryRegistration;
+import mezz.jei.api.registration.IRecipeRegistration;
+import net.minecraft.client.Minecraft;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import org.jetbrains.annotations.NotNull;
+
+import static at.petrak.hexcasting.common.lib.RegisterHelper.prefix;
+
+@JeiPlugin
+public class HexJEIPlugin implements IModPlugin {
+	private static final ResourceLocation UID = prefix(HexMod.MOD_ID);
+
+	public static final RecipeType<BrainsweepRecipe> BRAINSWEEPING =
+		RecipeType.create(HexMod.MOD_ID, "brainsweeping", BrainsweepRecipe.class);
+
+	@NotNull
+	@Override
+	public ResourceLocation getPluginUid() {
+		return UID;
+	}
+
+
+	@Override
+	public void registerCategories(IRecipeCategoryRegistration registration) {
+		registration.addRecipeCategories(new BrainsweepRecipeCategory(registration.getJeiHelpers().getGuiHelper()));
+	}
+
+	@Override
+	public void registerRecipes(@NotNull IRecipeRegistration registration) {
+		Level level = Minecraft.getInstance().level;
+		if (level != null) {
+			registration.addRecipes(BRAINSWEEPING, level.getRecipeManager().getAllRecipesFor(HexRecipeSerializers.BRAINSWEEP_TYPE));
+		}
+	}
+
+	@Override
+	public void registerRecipeCatalysts(IRecipeCatalystRegistration registration) {
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_OAK::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_SPRUCE::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_BIRCH::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_JUNGLE::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_ACACIA::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_DARK_OAK::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_CRIMSON::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_WARPED::get), BRAINSWEEPING);
+		registration.addRecipeCatalyst(new ItemStack(HexItems.WAND_AKASHIC::get), BRAINSWEEPING);
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/interop/jei/PatternDrawable.java b/src/main/java/at/petrak/hexcasting/interop/jei/PatternDrawable.java
new file mode 100644
index 00000000..8e0e1c11
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/interop/jei/PatternDrawable.java
@@ -0,0 +1,57 @@
+package at.petrak.hexcasting.interop.jei;
+
+import at.petrak.hexcasting.api.PatternRegistry;
+import at.petrak.hexcasting.api.spell.math.HexCoord;
+import at.petrak.hexcasting.interop.utils.PatternDrawingUtil;
+import at.petrak.hexcasting.interop.utils.PatternEntry;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.datafixers.util.Pair;
+import mezz.jei.api.gui.drawable.IDrawable;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.phys.Vec2;
+
+import java.util.List;
+
+public class PatternDrawable implements IDrawable {
+
+	private final long startTime = System.currentTimeMillis();
+
+	private final int width;
+	private final int height;
+
+	private final boolean strokeOrder;
+
+	private final List<PatternEntry> patterns;
+	private final List<Vec2> pathfinderDots;
+
+	public PatternDrawable(ResourceLocation pattern, int w, int h) {
+		var entry = PatternRegistry.lookupPattern(pattern);
+		this.strokeOrder = !entry.isPerWorld();
+		var data = PatternDrawingUtil.loadPatterns(List.of(new Pair<>(entry.getPrototype(), HexCoord.getOrigin())));
+		this.patterns = data.patterns();
+		this.pathfinderDots = data.pathfinderDots();
+		this.width = w;
+		this.height = h;
+	}
+
+	@Override
+	public int getWidth() {
+		return width;
+	}
+
+	@Override
+	public int getHeight() {
+		return height;
+	}
+
+	@Override
+	public void draw(PoseStack poseStack, int xOffset, int yOffset) {
+		long time = (System.currentTimeMillis() - startTime) / 50;
+		poseStack.pushPose();
+		poseStack.translate(xOffset - 0.5f + width / 2f, yOffset + height / 2f, 0);
+		poseStack.scale(0.25f, 0.25f, 1);
+		PatternDrawingUtil.drawPattern(poseStack, 0, 0, this.patterns, this.pathfinderDots, this.strokeOrder, time,
+			0xff_333030, 0xff_191818, 0xc8_0c0a0c, 0x80_666363);
+		poseStack.popPose();
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java b/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java
index b03015d3..3586b497 100644
--- a/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java
+++ b/src/main/java/at/petrak/hexcasting/interop/patchouli/AbstractPatternComponent.java
@@ -1,25 +1,18 @@
 package at.petrak.hexcasting.interop.patchouli;
 
-import at.petrak.hexcasting.api.utils.HexUtils;
-import at.petrak.hexcasting.client.RenderLib;
 import at.petrak.hexcasting.api.spell.math.HexCoord;
 import at.petrak.hexcasting.api.spell.math.HexPattern;
-import com.mojang.blaze3d.platform.GlStateManager;
-import com.mojang.blaze3d.systems.RenderSystem;
+import at.petrak.hexcasting.interop.utils.PatternDrawingUtil;
+import at.petrak.hexcasting.interop.utils.PatternEntry;
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.datafixers.util.Pair;
-import net.minecraft.client.renderer.GameRenderer;
-import net.minecraft.util.Mth;
 import net.minecraft.world.phys.Vec2;
 import vazkii.patchouli.api.IComponentRenderContext;
 import vazkii.patchouli.api.ICustomComponent;
 import vazkii.patchouli.api.IVariable;
 
-import java.util.ArrayList;
-import java.util.HashSet;
 import java.util.List;
 import java.util.function.UnaryOperator;
-import java.util.stream.Collectors;
 
 /**
  * Page that has a hex pattern on it
@@ -28,7 +21,7 @@ abstract public class AbstractPatternComponent implements ICustomComponent {
     protected transient int x, y;
     protected transient float hexSize;
 
-    private transient List<PatternEntryInternal> patterns;
+    private transient List<PatternEntry> patterns;
     private transient List<Vec2> pathfinderDots;
 
     /**
@@ -40,119 +33,27 @@ abstract public class AbstractPatternComponent implements ICustomComponent {
         this.y = y == -1 ? 70 : y;
     }
 
-    abstract List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup);
+    public abstract List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup);
 
-    abstract boolean showStrokeOrder();
+    public abstract boolean showStrokeOrder();
 
     @Override
     public void render(PoseStack poseStack, IComponentRenderContext ctx, float partialTicks, int mouseX, int mouseY) {
-        poseStack.pushPose();
-        poseStack.translate(this.x, this.y, 1);
-        var mat = poseStack.last().pose();
-        var prevShader = RenderSystem.getShader();
-        RenderSystem.setShader(GameRenderer::getPositionColorShader);
-//        RenderSystem.disableDepthTest();
-        RenderSystem.disableCull();
-        RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
-
-        // mark center
-//        RenderLib.drawSpot(mat, Vec2.ZERO, 0f, 0f, 0f, 1f);
-
-        var strokeOrder = this.showStrokeOrder();
-        for (var pat : this.patterns) {
-            var outer = 0xff_d2c8c8;
-            var innerLight = 0xc8_aba2a2;
-            var innerDark = 0xc8_322b33;
-            RenderLib.drawLineSeq(mat, pat.zappyPoints, 5f, 0, outer, outer, null);
-            RenderLib.drawLineSeq(mat, pat.zappyPoints, 2f, 0,
-                strokeOrder ? innerDark : innerLight,
-                innerLight,
-                strokeOrder ? ctx.getTicksInBook() / 20f : null);
-
-            if (strokeOrder) {
-                RenderLib.drawSpot(mat, pat.zappyPoints.get(0), 2.5f, 1f, 0.1f, 0.15f, 0.6f);
-            }
-        }
-
-        for (var dot : this.pathfinderDots) {
-            RenderLib.drawSpot(mat, dot, 1.5f, 0.82f, 0.8f, 0.8f, 0.5f);
-        }
-
-        RenderSystem.defaultBlendFunc();
-        RenderSystem.setShader(() -> prevShader);
-
-        poseStack.popPose();
+        PatternDrawingUtil.drawPattern(poseStack, this.x, this.y, this.patterns, this.pathfinderDots, this.showStrokeOrder(), ctx.getTicksInBook(),
+            0xff_d2c8c8, 0xc8_aba2a2, 0xc8_322b33, 0x80_d1cccc);
     }
 
-
     @Override
     public void onVariablesAvailable(UnaryOperator<IVariable> lookup) {
-        var patterns = this.getPatterns(lookup);
-        this.patterns = new ArrayList<>(patterns.size());
-
-        // Center the whole thing so the center of all pieces is in the center.
-        // As per PatternTooltipGreeble, we start with a random scale, then re-scale it once we know the COM.
-        var fakeScale = 1;
-        var seenFakePoints = new ArrayList<Vec2>();
-        var seenCoords = new HashSet<HexCoord>();
-        for (var pair : patterns) {
-            var pattern = pair.getFirst();
-            var origin = pair.getSecond();
-            for (var pos : pattern.positions(origin)) {
-                var px = HexUtils.coordToPx(pos, fakeScale, Vec2.ZERO);
-                seenFakePoints.add(px);
-            }
-
-            // And while we're looping add the (COORD ONLY) things internally
-            this.patterns.add(new PatternEntryInternal(pattern, origin, new ArrayList<>()));
-            seenCoords.addAll(pattern.positions(origin));
-        }
-        var fakeCom = HexUtils.FindCenter(seenFakePoints);
-
-        var maxDx = -1f;
-        var maxDy = -1f;
-        for (var dot : seenFakePoints) {
-            var dx = Mth.abs(dot.x - fakeCom.x);
-            if (dx > maxDx) {
-                maxDx = dx;
-            }
-            var dy = Mth.abs(dot.y - fakeCom.y);
-            if (dy > maxDy) {
-                maxDy = dy;
-            }
-        }
-        this.hexSize = Math.min(12, Math.min(120 / 2.5f / maxDx, 70 / 2.5f / maxDy));
-
-        var seenRealPoints = new ArrayList<Vec2>();
-        for (var pat : this.patterns) {
-            for (var pos : pat.pattern.positions(pat.origin)) {
-                var px = HexUtils.coordToPx(pos, this.hexSize, Vec2.ZERO);
-                seenRealPoints.add(px);
-            }
-        }
-        var realCom = HexUtils.FindCenter(seenRealPoints);
-
-        // and NOW for real!
-        for (var pat : this.patterns) {
-            var localOrigin = HexUtils.coordToPx(pat.origin, this.hexSize, realCom.negated());
-            var points = pat.pattern.toLines(this.hexSize, localOrigin);
-            pat.zappyPoints.addAll(RenderLib.makeZappy(points, 10f, 0.8f, 0f));
-        }
-
-        this.pathfinderDots = seenCoords.stream()
-            .map(coord -> HexUtils.coordToPx(coord, this.hexSize, realCom.negated()))
-            .collect(Collectors.toList());
-    }
-
-    private record PatternEntryInternal(HexPattern pattern, HexCoord origin, List<Vec2> zappyPoints) {
+        var data = PatternDrawingUtil.loadPatterns(this.getPatterns(lookup));
+        this.hexSize = data.hexSize();
+        this.patterns = data.patterns();
+        this.pathfinderDots = data.pathfinderDots();
     }
 
     protected static class RawPattern {
-        String startdir;
-        String signature;
-        int q, r;
-
-        RawPattern() {
-        }
+        protected String startdir;
+        protected String signature;
+        protected int q, r;
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java b/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java
index d730c196..f3428f75 100644
--- a/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java
+++ b/src/main/java/at/petrak/hexcasting/interop/patchouli/LookupPatternComponent.java
@@ -8,7 +8,6 @@ import com.mojang.datafixers.util.Pair;
 import net.minecraft.resources.ResourceLocation;
 import vazkii.patchouli.api.IVariable;
 
-import java.util.Collections;
 import java.util.List;
 import java.util.function.UnaryOperator;
 
@@ -23,14 +22,14 @@ public class LookupPatternComponent extends AbstractPatternComponent {
     protected boolean strokeOrder;
 
     @Override
-    List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup) {
+    public List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup) {
         var entry = PatternRegistry.lookupPattern(this.opName);
         this.strokeOrder = !entry.isPerWorld();
-        return Collections.singletonList(new Pair<>(entry.getPrototype(), HexCoord.getOrigin()));
+        return List.of(new Pair<>(entry.getPrototype(), HexCoord.getOrigin()));
     }
 
     @Override
-    boolean showStrokeOrder() {
+    public boolean showStrokeOrder() {
         return this.strokeOrder;
     }
 
diff --git a/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java b/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java
index 51b0e2af..12ce2765 100644
--- a/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java
+++ b/src/main/java/at/petrak/hexcasting/interop/patchouli/ManualPatternComponent.java
@@ -25,7 +25,7 @@ public class ManualPatternComponent extends AbstractPatternComponent {
     protected transient boolean strokeOrder;
 
     @Override
-    List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup) {
+	public List<Pair<HexPattern, HexCoord>> getPatterns(UnaryOperator<IVariable> lookup) {
         this.strokeOrder = lookup.apply(IVariable.wrap(this.strokeOrderRaw)).asBoolean(true);
         var patsRaw = lookup.apply(IVariable.wrap(patternsRaw)).asListOrSingleton();
 
@@ -44,7 +44,7 @@ public class ManualPatternComponent extends AbstractPatternComponent {
     }
 
     @Override
-    boolean showStrokeOrder() {
+    public boolean showStrokeOrder() {
         return this.strokeOrder;
     }
 
diff --git a/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java b/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java
new file mode 100644
index 00000000..18be35f6
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/interop/utils/PatternDrawingUtil.java
@@ -0,0 +1,120 @@
+package at.petrak.hexcasting.interop.utils;
+
+import at.petrak.hexcasting.api.spell.math.HexCoord;
+import at.petrak.hexcasting.api.spell.math.HexPattern;
+import at.petrak.hexcasting.api.utils.HexUtils;
+import at.petrak.hexcasting.client.RenderLib;
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.datafixers.util.Pair;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.util.FastColor;
+import net.minecraft.util.Mth;
+import net.minecraft.world.phys.Vec2;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+public final class PatternDrawingUtil {
+	public static void drawPattern(PoseStack poseStack, int x, int y, List<PatternEntry> patterns, List<Vec2> dots, boolean strokeOrder, long animTicks, int outer, int innerLight, int innerDark, int dotColor) {
+		poseStack.pushPose();
+		poseStack.translate(x, y, 1);
+		var mat = poseStack.last().pose();
+		var prevShader = RenderSystem.getShader();
+		RenderSystem.setShader(GameRenderer::getPositionColorShader);
+//        RenderSystem.disableDepthTest();
+		RenderSystem.disableCull();
+		RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA);
+
+		// mark center
+//        RenderLib.drawSpot(mat, Vec2.ZERO, 0f, 0f, 0f, 1f);
+
+		for (var pat : patterns) {
+			RenderLib.drawLineSeq(mat, pat.zappyPoints(), 5f, 0, outer, outer, null);
+			RenderLib.drawLineSeq(mat, pat.zappyPoints(), 2f, 0,
+				strokeOrder ? innerDark : innerLight,
+				innerLight,
+				strokeOrder ? animTicks / 20f : null);
+
+			if (strokeOrder) {
+				RenderLib.drawSpot(mat, pat.zappyPoints().get(0), 2.5f, 1f, 0.1f, 0.15f, 0.6f);
+			}
+		}
+
+		float dotR = FastColor.ARGB32.red(dotColor) / 255f;
+		float dotG = FastColor.ARGB32.green(dotColor) / 255f;
+		float dotB = FastColor.ARGB32.blue(dotColor) / 255f;
+		float dotA = FastColor.ARGB32.alpha(dotColor) / 255f;
+
+		for (var dot : dots) {
+			RenderLib.drawSpot(mat, dot, 1.5f, dotR, dotG, dotB, dotA);
+		}
+
+		RenderSystem.defaultBlendFunc();
+		RenderSystem.setShader(() -> prevShader);
+
+		poseStack.popPose();
+	}
+
+	public static PatternRenderingData loadPatterns(List<Pair<HexPattern, HexCoord>> patterns) {
+		var patternEntries = new ArrayList<PatternEntry>(patterns.size());
+
+		var fakeScale = 1;
+		var seenFakePoints = new ArrayList<Vec2>();
+		var seenCoords = new HashSet<HexCoord>();
+		for (var pair : patterns) {
+			var pattern = pair.getFirst();
+			var origin = pair.getSecond();
+			for (var pos : pattern.positions(origin)) {
+				var px = HexUtils.coordToPx(pos, fakeScale, Vec2.ZERO);
+				seenFakePoints.add(px);
+			}
+
+			// And while we're looping add the (COORD ONLY) things internally
+			patternEntries.add(new PatternEntry(pattern, origin, new ArrayList<>()));
+			seenCoords.addAll(pattern.positions(origin));
+		}
+		var fakeCom = HexUtils.FindCenter(seenFakePoints);
+
+		var maxDx = -1f;
+		var maxDy = -1f;
+		for (var dot : seenFakePoints) {
+			var dx = Mth.abs(dot.x - fakeCom.x);
+			if (dx > maxDx) {
+				maxDx = dx;
+			}
+			var dy = Mth.abs(dot.y - fakeCom.y);
+			if (dy > maxDy) {
+				maxDy = dy;
+			}
+		}
+		var hexSize = Math.min(12, Math.min(120 / 2.5f / maxDx, 70 / 2.5f / maxDy));
+
+		var seenRealPoints = new ArrayList<Vec2>();
+		for (var pat : patternEntries) {
+			for (var pos : pat.pattern().positions(pat.origin())) {
+				var px = HexUtils.coordToPx(pos, hexSize, Vec2.ZERO);
+				seenRealPoints.add(px);
+			}
+		}
+		var realCom = HexUtils.FindCenter(seenRealPoints);
+
+		// and NOW for real!
+		for (var pat : patternEntries) {
+			var localOrigin = HexUtils.coordToPx(pat.origin(), hexSize, realCom.negated());
+			var points = pat.pattern().toLines(hexSize, localOrigin);
+			pat.zappyPoints().addAll(RenderLib.makeZappy(points, 10f, 0.8f, 0f));
+		}
+
+		var pathfinderDots = seenCoords.stream()
+			.map(coord -> HexUtils.coordToPx(coord, hexSize, realCom.negated())).toList();
+
+		return new PatternRenderingData(patternEntries, pathfinderDots, hexSize);
+	}
+
+	public record PatternRenderingData(List<PatternEntry> patterns, List<Vec2> pathfinderDots, float hexSize) {
+		// NO-OP
+	}
+}
diff --git a/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java b/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java
new file mode 100644
index 00000000..4f6850d0
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/interop/utils/PatternEntry.java
@@ -0,0 +1,11 @@
+package at.petrak.hexcasting.interop.utils;
+
+import at.petrak.hexcasting.api.spell.math.HexCoord;
+import at.petrak.hexcasting.api.spell.math.HexPattern;
+import net.minecraft.world.phys.Vec2;
+
+import java.util.List;
+
+public record PatternEntry(HexPattern pattern, HexCoord origin, List<Vec2> zappyPoints) {
+	// NO-OP
+}
diff --git a/src/main/java/at/petrak/hexcasting/mixin/AccessorLivingEntity.java b/src/main/java/at/petrak/hexcasting/mixin/AccessorLivingEntity.java
deleted file mode 100644
index eb845d24..00000000
--- a/src/main/java/at/petrak/hexcasting/mixin/AccessorLivingEntity.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package at.petrak.hexcasting.mixin;
-
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.ai.Brain;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(LivingEntity.class)
-public interface AccessorLivingEntity {
-    @Accessor("brain")
-    void hex$SetBrain(Brain<?> brain);
-}
diff --git a/src/main/java/at/petrak/hexcasting/mixin/MixinMob.java b/src/main/java/at/petrak/hexcasting/mixin/MixinMob.java
index 4fc642d4..9fa7af63 100644
--- a/src/main/java/at/petrak/hexcasting/mixin/MixinMob.java
+++ b/src/main/java/at/petrak/hexcasting/mixin/MixinMob.java
@@ -1,15 +1,13 @@
 package at.petrak.hexcasting.mixin;
 
 import at.petrak.hexcasting.common.misc.Brainsweeping;
-import net.minecraft.sounds.SoundEvent;
 import net.minecraft.world.entity.Mob;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-// Prevents the villager from any of its brain goals or making ambient noise
+// Prevents brainswept mobs from having an AI tick
 @Mixin(Mob.class)
 public class MixinMob {
     @Inject(method = "serverAiStep", at = @At("HEAD"), cancellable = true)
@@ -20,11 +18,11 @@ public class MixinMob {
         }
     }
 
-    @Inject(method = "getAmbientSound", at = @At("HEAD"), cancellable = true)
-    protected void onGetAmbientSound(CallbackInfoReturnable<SoundEvent> ci) {
+    @Inject(method = "playAmbientSound", at = @At("HEAD"), cancellable = true)
+    protected void onPlayAmbientSound(CallbackInfo ci) {
         var self = (Mob) (Object) this;
         if (Brainsweeping.isBrainswept(self)) {
-            ci.setReturnValue(null);
+            ci.cancel();
         }
     }
 }
diff --git a/src/main/java/at/petrak/hexcasting/mixin/MixinRaider.java b/src/main/java/at/petrak/hexcasting/mixin/MixinRaider.java
new file mode 100644
index 00000000..e7a6eaf6
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/mixin/MixinRaider.java
@@ -0,0 +1,17 @@
+package at.petrak.hexcasting.mixin;
+
+import at.petrak.hexcasting.common.misc.Brainsweeping;
+import net.minecraft.world.entity.raid.Raider;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+// Prevents the witch from joining a raid
+@Mixin(Raider.class)
+public class MixinRaider {
+    @Redirect(method = "aiStep", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/raid/Raider;isAlive()Z"))
+    private boolean isAliveForAiPurposes(Raider instance) {
+        var self = (Raider) (Object) this;
+        return self.isAlive() && !Brainsweeping.isBrainswept(self);
+    }
+}
diff --git a/src/main/java/at/petrak/hexcasting/mixin/MixinVillager.java b/src/main/java/at/petrak/hexcasting/mixin/MixinVillager.java
index 9e509d42..f9084bc3 100644
--- a/src/main/java/at/petrak/hexcasting/mixin/MixinVillager.java
+++ b/src/main/java/at/petrak/hexcasting/mixin/MixinVillager.java
@@ -6,8 +6,9 @@ import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
-// Prevents the villager from any of its brain goals or making ambient noise
+// Prevents the villager from any of its brain goals
 @Mixin(Villager.class)
 public class MixinVillager {
     @Inject(method = "registerBrainGoals", at = @At("HEAD"), cancellable = true)
@@ -17,4 +18,12 @@ public class MixinVillager {
             ci.cancel();
         }
     }
+
+    @Inject(method = "canBreed", at = @At("HEAD"), cancellable = true)
+    private void preventBreeding(CallbackInfoReturnable<Boolean> cir) {
+        var self = (Villager) (Object) this;
+        if (Brainsweeping.isBrainswept(self)) {
+            cir.setReturnValue(false);
+        }
+    }
 }
diff --git a/src/main/java/at/petrak/hexcasting/mixin/MixinWitch.java b/src/main/java/at/petrak/hexcasting/mixin/MixinWitch.java
new file mode 100644
index 00000000..17174979
--- /dev/null
+++ b/src/main/java/at/petrak/hexcasting/mixin/MixinWitch.java
@@ -0,0 +1,17 @@
+package at.petrak.hexcasting.mixin;
+
+import at.petrak.hexcasting.common.misc.Brainsweeping;
+import net.minecraft.world.entity.monster.Witch;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+// Prevents the witch from drinking potions
+@Mixin(Witch.class)
+public class MixinWitch {
+    @Redirect(method = "aiStep", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/monster/Witch;isAlive()Z"))
+    private boolean isAliveForAiPurposes(Witch instance) {
+        var self = (Witch) (Object) this;
+        return self.isAlive() && !Brainsweeping.isBrainswept(self);
+    }
+}
diff --git a/src/main/resources/META-INF/mods.toml b/src/main/resources/META-INF/mods.toml
index df347fb9..18d5383e 100644
--- a/src/main/resources/META-INF/mods.toml
+++ b/src/main/resources/META-INF/mods.toml
@@ -7,7 +7,7 @@ issueTrackerURL = "https://github.com/gamma-delta/HexMod/issues"
 [[mods]]
 modId = "hexcasting"
 version = "${file.jarVersion}"
-displayName = "Hexcasting"
+displayName = "Hex Casting"
 displayURL = "https://github.com/gamma-delta/HexMod"
 logoFile = "logo.png"
 credits = "Falkory for textures; Wiresegal for lots of polish; Alwinfy for visual effects, proofreading, and code help; Kra3tor for sound effects; naj77 for the nice logo; and all of my wonderful patrons for supporting me!"
diff --git a/src/main/resources/assets/hexcasting/lang/en_us.json b/src/main/resources/assets/hexcasting/lang/en_us.json
index 3e04b288..42dc69e7 100644
--- a/src/main/resources/assets/hexcasting/lang/en_us.json
+++ b/src/main/resources/assets/hexcasting/lang/en_us.json
@@ -10,6 +10,7 @@
   "item.hexcasting.wand_warped": "Warped Staff",
   "item.hexcasting.wand_akashic": "Edified Staff",
   "item.hexcasting.focus": "Focus",
+  "item.hexcasting.focus.sealed": "Sealed Focus",
   "item.hexcasting.spellbook": "Spellbook",
   "item.hexcasting.cypher": "Cypher",
   "item.hexcasting.trinket": "Trinket",
@@ -97,8 +98,12 @@
   "itemGroup.hexcasting": "Hexcasting",
 
   "hexcasting.tooltip.spellbook.page": "Selected Page %d/%d",
+  "hexcasting.tooltip.spellbook.page.sealed": "Selected Page %d/%d (%s)",
   "hexcasting.tooltip.spellbook.page_with_name": "Selected Page %d/%d (\"%s\")",
+  "hexcasting.tooltip.spellbook.page_with_name.sealed": "Selected Page %d/%d (\"%s\") (%s)",
+  "hexcasting.tooltip.spellbook.sealed": "Sealed",
   "hexcasting.tooltip.spellbook.empty": "Empty",
+  "hexcasting.tooltip.spellbook.empty.sealed": "Empty (%s)",
   "hexcasting.tooltip.abacus": "%d",
   "hexcasting.tooltip.abacus.reset": "Reset to 0",
   "hexcasting.tooltip.abacus.reset.nice": "nice",
@@ -115,28 +120,29 @@
   "hexcasting.tooltip.brainsweep.biome.any": "Any Biome",
   "hexcasting.tooltip.brainsweep.min_level": "Level %d or higher",
   "hexcasting.spelldata.onitem": "Contains: %s",
+  "hexcasting.spelldata.anything": "Anything",
   "hexcasting.spelldata.entity.whoknows": "An Entity (this should only show up if this was stored before the 0.5.0 update, use Scribe's Reflection, Scribe's Gambit to fix)",
   "hexcasting.spelldata.akashic.nopos": "The owning record does not know of any iota here (this is a bug)",
 
   "advancement.hexcasting:root": "Hexcasting Research",
-  "advancement.hexcasting:root.desc": "Enter an amethyst geode deep underground, a concentrated source of media.",
+  "advancement.hexcasting:root.desc": "Find a concentrated form of media growing deep beneath the earth.",
   "advancement.hexcasting:enlightenment": "Achieve Enlightenment",
-  "advancement.hexcasting:enlightenment.desc": "Go nearly insane from casting a hexcasting from almost all of your health.",
+  "advancement.hexcasting:enlightenment.desc": "Go nearly insane from casting a hex from almost all of your health.",
   "advancement.hexcasting:wasteful_cast": "Waste Not...",
-  "advancement.hexcasting:wasteful_cast.desc": "Waste a large amount of Media when casting a hexcasting.",
+  "advancement.hexcasting:wasteful_cast.desc": "Waste a large amount of media when casting a hex.",
   "advancement.hexcasting:big_cast": "... Want Not",
-  "advancement.hexcasting:big_cast.desc": "Cast a spell requiring a truly huge amount of Media.",
+  "advancement.hexcasting:big_cast.desc": "Cast a spell requiring a truly huge amount of media.",
   "advancement.hexcasting:y_u_no_cast_angy": "Blind Diversion",
   "advancement.hexcasting:y_u_no_cast_angy.desc": "Try to cast a spell from a scroll, but fail.",
   "advancement.hexcasting:opened_eyes": "Opened Eyes",
-  "advancement.hexcasting:opened_eyes.desc": "Have nature take just a little of your mind as payment for a hexcasting.",
+  "advancement.hexcasting:opened_eyes.desc": "Have nature take a piece of your mind in payment for a hex.",
 
   "stat.hexcasting.mana_used": "Media consumed (in dust)",
   "stat.hexcasting.mana_overcasted": "Media overcast (in dust)",
   "stat.hexcasting.patterns_drawn": "Patterns Drawn",
   "stat.hexcasting.spells_cast": "Spells Cast",
 
-  "death.attack.hexcasting.overcast": "%s's mind was consumed into energy",
+  "death.attack.hexcasting.overcast": "%s's mind was subsumed into energy",
 
   "command.hexcasting.pats.listing": "Patterns in this world:",
   "command.hexcasting.pats.all": "Gave you all %d scrolls",
@@ -190,6 +196,8 @@
   "hexcasting.spell.hexcasting:splat": "Flock's Disintegration",
   "hexcasting.spell.hexcasting:index_of": "Locator's Distillation",
   "hexcasting.spell.hexcasting:list_remove": "Excisor's Distillation",
+  "hexcasting.spell.hexcasting:slice": "Selection Exaltation",
+  "hexcasting.spell.hexcasting:modify_in_place": "Surgeon's Exaltation",
   "hexcasting.spell.hexcasting:get_entity": "Entity Purification",
   "hexcasting.spell.hexcasting:get_entity/animal": "Entity Prfn.: Animal",
   "hexcasting.spell.hexcasting:get_entity/monster": "Entity Prfn.: Monster",
@@ -207,10 +215,10 @@
   "hexcasting.spell.hexcasting:zone_entity/not_item": "Zone Dstl.: Non-Item",
   "hexcasting.spell.hexcasting:zone_entity/not_player": "Zone Dstl.: Non-Player",
   "hexcasting.spell.hexcasting:zone_entity/not_living": "Zone Dstl.: Non-Living",
-  "hexcasting.spell.hexcasting:undo": "Novice's Gambit",
   "hexcasting.spell.hexcasting:const/null": "Nullary Reflection",
   "hexcasting.spell.hexcasting:duplicate": "Gemini Decomposition",
   "hexcasting.spell.hexcasting:duplicate_n": "Gemini's Gambit",
+  "hexcasting.spell.hexcasting:stack_len": "Flock's Reflection",
   "hexcasting.spell.hexcasting:swap": "Jester's Gambit",
   "hexcasting.spell.hexcasting:fisherman": "Fisherman's Gambit",
   "hexcasting.spell.hexcasting:swizzle": "Swindler's Gambit",
@@ -222,6 +230,11 @@
   "hexcasting.spell.hexcasting:pow_proj": "Power Distillation",
   "hexcasting.spell.hexcasting:construct_vec": "Vector Exaltation",
   "hexcasting.spell.hexcasting:deconstruct_vec": "Vector Disintegration",
+  "hexcasting.spell.hexcasting:and_bit": "Intersection Distillation",
+  "hexcasting.spell.hexcasting:or_bit": "Unifying Distillation",
+  "hexcasting.spell.hexcasting:xor_bit": "Exclusionary Distillation",
+  "hexcasting.spell.hexcasting:not_bit": "Inversion Purification",
+  "hexcasting.spell.hexcasting:to_set": "Uniqueness Purification",
   "hexcasting.spell.hexcasting:and": "Conjunction Distillation",
   "hexcasting.spell.hexcasting:or": "Disjunction Distillation",
   "hexcasting.spell.hexcasting:xor": "Exclusion Distillation",
@@ -294,8 +307,13 @@
   "hexcasting.spell.hexcasting:escape": "Consideration",
   "hexcasting.spell.hexcasting:eval": "Hermes' Gambit",
   "hexcasting.spell.hexcasting:eval/delay": "Secret Gambit!",
+  "hexcasting.spell.hexcasting:read_local": "Muginn's Reflection",
+  "hexcasting.spell.hexcasting:write_local": "Huginn's Gambit",
   "hexcasting.spell.hexcasting:read": "Scribe's Reflection",
   "hexcasting.spell.hexcasting:write": "Scribe's Gambit",
+  "hexcasting.spell.hexcasting:readable": "Auditor's Reflection",
+  "hexcasting.spell.hexcasting:readable/entity": "Auditor's Purification",
+  "hexcasting.spell.hexcasting:writable": "Auditor's Purification II",
   "hexcasting.spell.hexcasting:akashic/read": "Akasha's Distillation",
   "hexcasting.spell.hexcasting:akashic/write": "Akasha's Gambit",
   "hexcasting.spell.hexcasting:read/entity": "Scribe's Purification",
@@ -317,7 +335,6 @@
   "hexcasting.spell.unknown": "Special Handler",
 
   "hexcasting.mishap.invalid_pattern": "That pattern isn't associated with any action",
-  "hexcasting.mishap.invalid_spell_datum_type": "Tried to use a value of invalid type as a SpellDatum: %s (class %s). This is a bug in the mod.",
   "hexcasting.mishap.invalid_value": "%s expected %s at index %s of the stack, but got %s",
   "hexcasting.mishap.invalid_value.class.double": "a number",
   "hexcasting.mishap.invalid_value.class.vector": "a vector",
@@ -331,6 +348,7 @@
   "hexcasting.mishap.invalid_value.class.entity": "an entity",
   "hexcasting.mishap.invalid_value.class.unknown": "(unknown, uh-oh, this is a bug)",
   "hexcasting.mishap.invalid_value.numvec": "a number or vector",
+  "hexcasting.mishap.invalid_value.numlist": "a number or list",
   "hexcasting.mishap.invalid_value.list.pattern": "a list of patterns",
   "hexcasting.mishap.invalid_value.int": "an integer",
   "hexcasting.mishap.invalid_value.double.between": "a number between %d and %d",
@@ -344,13 +362,14 @@
   "hexcasting.mishap.eval_too_deep": "Recursively evaluated too deep",
   "hexcasting.mishap.no_item": "%s needs %s but got nothing",
   "hexcasting.mishap.no_item.offhand": "%s needs %s in the other hand but got nothing",
-  "hexcasting.mishap.bad_item": "%s needs %s but got %s",
+  "hexcasting.mishap.bad_item": "%s needs %s but got %dx %s",
   "hexcasting.mishap.bad_item.offhand": "%s needs %s in the other hand but got %dx %s",
   "hexcasting.mishap.bad_item.iota": "a place to store iotas",
   "hexcasting.mishap.bad_item.iota.read": "a place to read iotas from",
   "hexcasting.mishap.bad_item.iota.write": "a place to write iotas to",
   "hexcasting.mishap.bad_item.iota.readonly": "a place that will accept %s",
   "hexcasting.mishap.bad_item.mana": "a media-containing item",
+  "hexcasting.mishap.bad_item.mana_for_battery": "a raw media item",
   "hexcasting.mishap.bad_item.only_one": "exactly one item",
   "hexcasting.mishap.bad_item.eraseable": "an eraseable item",
   "hexcasting.mishap.bad_item.bottle": "a glass bottle",
@@ -371,8 +390,10 @@
   "hexcasting.mishap.divide_by_zero.power": "power of %s",
   "hexcasting.mishap.divide_by_zero.sin": "the sine of %s",
   "hexcasting.mishap.divide_by_zero.cos": "the cosine of %s",
-  "hexcasting.mishap.no_akashic_record": "No akashic record at %s",
+  "hexcasting.mishap.no_akashic_record": "No Akashic Record at %s",
   "hexcasting.mishap.disallowed": "%s has been disallowed by the server admins",
+  "hexcasting.mishap.invalid_spell_datum_type": "Tried to use a value of invalid type as a SpellDatum: %s (class %s). This is a bug in the mod.",
+  "hexcasting.mishap.unknown": "%s threw an exception (%s). This is a bug in the mod.",
 
   "hexcasting.landing": "I seem to have discovered a new method of magical arts, in which one draws patterns strange and wild onto a hexagonal grid. It fascinates me. I've decided to start a journal of my thoughts and findings.$(br2)$(l:https://discord.gg/4xxHGYteWk)Discord Server Link/$",
 
@@ -402,14 +423,14 @@
   "_comment": "Basics",
 
   "hexcasting.entry.media": "Media",
-  "hexcasting.page.media.1": "_Media is a form of mental energy external to a mind. All living creatures generate trace amounts of _media when thinking about anything; after the thought is finished, the media is released into the environment.$(br2)The art of casting $(thing)Hexes/$ is all about manipulating _media to do your bidding.",
-  "hexcasting.page.media.2": "_Media can exert influences on other media-- the strength and type of influence can be manipulated by drawing _media out into patterns.$(p)Scholars of the art used a concentrated blob of _media on the end of a stick: by waving it in the air in precise configurations, they were able to manipulate enough _media with enough precision to influence the world itself, in the form of a Hex.",
+  "hexcasting.page.media.1": "_Media is a form of mental energy external to a mind. All living creatures generate trace amounts of _media when thinking about anything; after the thought is finished, the media is released into the environment.$(br2)The art of casting _Hexes is all about manipulating _media to do your bidding.",
+  "hexcasting.page.media.2": "_Media can exert influences on other media-- the strength and type of influence can be manipulated by drawing _media out into patterns.$(p)Scholars of the art used a concentrated blob of _media on the end of a stick: by waving it in the air in precise configurations, they were able to manipulate enough _media with enough precision to influence the world itself, in the form of a _Hex.",
   "hexcasting.page.media.3": "Sadly, even a fully sentient being (like myself, presumably) can only generate miniscule amounts of _media. It would be quite impractical to try and use my own brainpower to cast Hexes.$(br2)But legend has it that there are underground deposits where _media slowly accumulates, growing into crystalline forms.$(p)If I could just find one of those...",
 
   "hexcasting.entry.geodes": "Geodes",
-  "hexcasting.page.geodes.1": "Aha! While mining deep underground, I found an enormous geode resonating with energy-- energy which pressed against my skull and my thoughts. This $(italic)must/$ be the place spoken about in legends where _media accumulates.$(br2)These $(l:items/amethyst)$(item)amethyst crystals/$ must contain a $(l:items/amethyst)$(thing)convenient, solidified form of _Media/$.",
-  "hexcasting.page.geodes.2": "It appears that, in addition to the $(l:items/amethyst)$(item)Amethyst Shards/$ I usually see, these crystals can also drop $(l:items/amethyst)$(item)Amethyst Dust/$ and $(l:items/amethyst)$(item)Charged Amethyst Crystals/$. It looks like I'll have a better chance of finding $(l:items/amethyst)$(item)Charged Amethyst Crystals/$ by using a Fortune pickaxe.",
-  "hexcasting.page.geodes.3": "As I take the beauty of the geode in, I can feel connections flashing wildly in my mind. It's like the _media in the air is entering me, empowering me, elucidating me... It feels wonderful.$(br2)Finally, my study into the arcane is starting to make some sense!$(p)Let me reread those old legends again, now that I know what I'm looking at.",
+  "hexcasting.page.geodes.1": "Aha! While mining deep underground, I found an enormous geode resonating with energy-- energy which pressed against my skull and my thoughts. And now, I hold that pressure in my hand, in solid form. That proves it. This $(italic)must/$ be the place spoken about in legends where _media accumulates.$(br2)These $(l:items/amethyst)$(item)amethyst crystals/$ must be a $(l:items/amethyst)$(thing)convenient, solidified form of _Media/$.",
+  "hexcasting.page.geodes.2": "It appears that, in addition to the $(l:items/amethyst)$(item)Amethyst Shards/$ I have seen in the past, these crystals can also drop bits of powdered $(l:items/amethyst)$(item)Amethyst Dust/$, as well as these $(l:items/amethyst)$(item)Charged Amethyst Crystals/$. It looks like I'll have a better chance of finding the $(l:items/amethyst)$(item)Charged Amethyst Crystals/$ by using a Fortune pickaxe.",
+  "hexcasting.page.geodes.3": "As I take the beauty of the crystal in, I can feel connections flashing wildly in my mind. It's like the _media in the air is entering me, empowering me, elucidating me... It feels wonderful.$(br2)Finally, my study into the arcane is starting to make some sense!$(p)Let me reread those old legends again, now that I know what I'm looking at.",
 
   "hexcasting.entry.couldnt_cast": "A Frustration",
   "hexcasting.page.couldnt_cast.1": "Argh! Why won't it let me cast the spell?!$(br2)The scroll I found rings with authenticity. I can $(italic)feel/$ it humming in the scroll-- the pattern is true, or as true as it can be. The spell is $(italic)right there/$.$(p)But it feels if it's on the other side of some thin membrane. I called it-- it tried to manifest-- yet it $(italic)COULD NOT/$.",
@@ -429,7 +450,7 @@
   "hexcasting.entry.101": "Hexing 101",
   "hexcasting.page.101.1": "Casting a _Hex is quite difficult-- no wonder this art was lost to time! I'll have to re-read my notes carefully.$(br2)I can start a _Hex by pressing $(k:use) with a $(l:items/staff)$(item)Staff/$ in my hand-- this will cause a hexagonal grid of dots to appear in front of me. Then I can click and drag from dot to dot to draw patterns in the _media of the grid; finishing a pattern will run its corresponding action (more on that later).",
   "hexcasting.page.101.2": "Once I've drawn enough patterns to cast a spell, the grid will disappear as the _media I've stored up is released. Holding $(k:sneak) while using my $(l:items/staff)$(item)staff/$ will also clear the grid, if I don't mind the chance of mishap. (It seems that the more _media I've built up, the more likely I'll meet misfortune.)$(br2)So how do patterns work? In short:$(li)$(italic)Patterns/$ will execute...$(li)$(italic)Actions/$, which manipulate...$(li)$(l:casting/stack)$(italic)The Stack/$, which is a list of...$(li)$(italic)Iotas/$, which are simply units of information.",
-  "hexcasting.page.101.3": "First, $(thing)patterns/$. These are essential-- they're what I use to manipulate the _media around me. Certain patterns, when drawn, will cause $(thing)actions/$ to happen. Actions are what actually $(italic)do/$ the magic; all patterns influence _media in particular ways, and when those influences end up doing something useful, we call it an action.$(br2)_Media can be fickle: if I draw an invalid pattern, I'll get some garbage result somewhere on my stack (read on...)",
+  "hexcasting.page.101.3": "First, $(thing)patterns/$. These are essential-- they're what I use to manipulate the _media around me. Certain patterns, when drawn, will cause $(thing)actions/$ to happen. Actions are what actually $(italic)do/$ the magic; all patterns influence _media in particular ways, and when those influences end up doing something useful, we call it an action.$(br2)_Media can be fickle: if I draw an invalid pattern, I'll get some $(l:casting/influences)$(action)garbage/$ result somewhere on my stack (read on...)",
   "hexcasting.page.101.4.header": "An Example",
   "hexcasting.page.101.4": "It's interesting to note that the $(italic)rotation/$ of a pattern doesn't seem to matter at all. These two patterns both perform an action called $(l:patterns/basics#hexcasting:get_caster)$(action)Mind's Reflection/$, for example.",
   "hexcasting.page.101.5": "A _Hex is cast by drawing (valid) actions in sequence. Each action might do one of a few things:$(li)Gather some information about the environment, leaving it on the top of the stack;$(li)manipulate the info gathered (e.g. adding two numbers); or$(li)perform some magical effect, like summoning lightning or an explosion. (These actions are called \"spells.\")$(p)When I start casting a _Hex, it creates an empty stack. Actions manipulate the top of that stack.",
@@ -477,13 +498,13 @@
   "hexcasting.page.mishaps.retrospection.title": "Hasty Retrospection",
   "hexcasting.page.mishaps.retrospection": "I attempted to draw $(l:patterns/patterns_as_iotas#hexcasting:close_paren)$(action)Retrospection/$ without first drawing $(l:patterns/patterns_as_iotas#hexcasting:open_paren)$(action)Introspection/$.$(br2)Causes orange sparks, and pushes the pattern for $(l:patterns/patterns_as_iotas#hexcasting:close_paren)$(action)Retrospection/$ to the stack as a pattern iota.",
   "hexcasting.page.mishaps.too_deep.title": "Delve Too Deep",
-  "hexcasting.page.mishaps.too_deep": "Evaluated too many patterns from one action.$(br2)Causes dark blue sparks, and chokes all the air out of me.",
+  "hexcasting.page.mishaps.too_deep": "Evaluated too many spells with meta-evaluation from one spell.$(br2)Causes dark blue sparks, and chokes all the air out of me.",
   "hexcasting.page.mishaps.true_name.title": "Transgress Other",
-  "hexcasting.page.mishaps.true_name": "I attempted to $(l:patterns/readwrite#hexcasting:read)$(action)save a reference/$ to another player to a permanent medium.$(br2)Causes black sparks, and robs me of my sight for approximately one minute.",
+  "hexcasting.page.mishaps.true_name": "I attempted to $(l:patterns/readwrite#hexcasting:write)$(action)save a reference/$ to another player to a permanent medium.$(br2)Causes black sparks, and robs me of my sight for approximately one minute.",
   "hexcasting.page.mishaps.disabled.title": "Disallowed Action",
   "hexcasting.page.mishaps.disabled": "I tried to cast an action that has been disallowed by a server administrator.$(br2)Causes black sparks.",
-  "hexcasting.page.mishaps.invalid_iota.title": "Invalid Iota Type",
-  "hexcasting.page.mishaps.invalid_iota": "A bug in the mod caused an iota of an invalid type. $(l:https://https://github.com/gamma-delta/HexMod/issues)Please open a bug report!/$$(br2)Causes black sparks.",
+  "hexcasting.page.mishaps.other.title": "Catastrophic Failure",
+  "hexcasting.page.mishaps.other": "A bug in the mod caused an iota of an invalid type or otherwise caused the spell to crash. $(l:https://https://github.com/gamma-delta/HexMod/issues)Please open a bug report!/$$(br2)Causes black sparks.",
 
   "hexcasting.entry.stack": "Stacks",
   "hexcasting.page.stack.1": "A $(thing)Stack/$, also known as a \"LIFO\", is a concept borrowed from computer science. In short, it's a collection of things designed so that you can only interact with the most recently used thing.$(br2)Think of a stack of plates, where new plates are added to the top: if you want to interact with a plate halfway down the stack, you have to remove the plates above it in order to get ahold of it.",
@@ -494,17 +515,17 @@
   "hexcasting.entry.naming": "Naming Actions",
   "hexcasting.page.naming.1": "The names given to actions by the ancients were certainly peculiar, but I think there's a certain kind of logic to them.$(br2)There seem to be certain groups of actions with common names, named for the number of iotas they remove from and add to the stack.",
   "hexcasting.page.naming.2": "$(li)A $(thing)Reflection/$ pops nothing and pushes one iota.$(li)A $(thing)Purification/$ pops one and pushes one.$(li)A $(thing)Distillation/$ pops two and pushes one.$(li)An $(thing)Exaltation/$ pops three or more and pushes one.$(li)A $(thing)Decomposition/$ pops one argument and pushes two.$(li)A $(thing)Disintegration/$ pops one and pushes three or more.$(li)Finally, a $(thing)Gambit/$ pushes or pops some other number (or rearranges the stack in some other manner).",
-  "hexcasting.page.naming.3": "Spells seem to be exempt from this nomenclature and are more or less named after what they do-- after all, why call it a $(action)Demoman's Gambit/$ when you could just say $(l:patterns/spells/basic_spell#hexcasting:explode)$(action)Explosion/$?",
+  "hexcasting.page.naming.3": "Spells seem to be exempt from this nomenclature and are more or less named after what they do-- after all, why call it a $(action)Demoman's Gambit/$ when you could just say $(l:patterns/spells/basic#hexcasting:explode)$(action)Explosion/$?",
 
   "hexcasting.entry.influences": "Influences",
-  "hexcasting.page.influences.1": "Influences are ... strange, to say the least. Whereas most iotas seem to represent something about the world, influences represent something more... abstract, or formless.$(br2)For example, one influence I've named $(thing)Null/$ seems to represent nothing at all. It's created when there isn't a suitable answer to a question asked, such as an $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation/$ facing the sky.",
+  "hexcasting.page.influences.1": "Influences are ... strange, to say the least. Whereas most iotas seem to represent something about the world, influences represent something more... abstract, or formless.$(br2)For example, one influence I've named $(l:casting/influences)$(thing)Null/$ seems to represent nothing at all. It's created when there isn't a suitable answer to a question asked, such as an $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation/$ facing the sky.",
   "hexcasting.page.influences.2": "In addition, I've discovered a curious triplet of influences I've named $(l:patterns/patterns_as_iotas#hexcasting:escape)$(action)Consideration/$, $(l:patterns/patterns_as_iotas#hexcasting:open_paren)$(action)Introspection/$, and $(l:patterns/patterns_as_iotas#hexcasting:close_paren)$(action)Retrospection/$. They seem to have properties of both patterns and other influences, yet act very differently. I can use these to add patterns to my stack as iotas, instead of matching them to actions. $(l:patterns/patterns_as_iotas)My notes on the subject are here/$.",
-  "hexcasting.page.influences.3": "Finally, there seems to be an infinite family of influences that just seem to be a tangled mess of _media. I've named them $(action)Garbage/$, as they are completely useless. They seem to appear in my stack at various places in response to $(l:casting/mishaps)mishaps/$. They appear to my senses as a nonsense jumble.",
+  "hexcasting.page.influences.3": "Finally, there seems to be an infinite family of influences that just seem to be a tangled mess of _media. I've named them $(l:casting/influences)$(action)Garbage/$, as they are completely useless. They seem to appear in my stack at various places in response to $(l:casting/mishaps)$(thing)mishaps/$. They appear to my senses as a nonsense jumble.",
 
   "hexcasting.entry.mishaps2": "Enlightened Mishaps",
   "hexcasting.page.mishaps2.1": "I have discovered new and horrifying modes of failure. I must not succumb to them.",
   "hexcasting.page.mishaps2.bad_mindflay.title": "Inert Mindflay",
-  "hexcasting.page.mishaps2.bad_mindflay": "Attempted to flay the mind of a villager that I have either already used, or of a character not suitable for the target block.$(br2)Causes dark green sparks, and kills the subject.",
+  "hexcasting.page.mishaps2.bad_mindflay": "Attempted to flay the mind of a villager that I have either already used, or of a character not suitable for the target block.$(br2)Causes dark green sparks, and kills the subject. If another villager sees that, I doubt they would look on it favorably.",
   "hexcasting.page.mishaps2.no_circle.title": "Lack Spell Circle",
   "hexcasting.page.mishaps2.no_circle": "Tried to cast an action requiring a spell circle without a spell circle.$(br2)Causes light blue sparks, and upends my inventory onto the ground.",
   "hexcasting.page.mishaps2.no_record.title": "Lack Akashic Record",
@@ -557,35 +578,35 @@
   "hexcasting.page.slate.3": "I'm also aware of other types of $(l:items/slate)$(item)Slates/$, slates that do not contain patterns but seem to be inlaid with other ... strange ... oddities. It hurts my brain to think about them, as if my thoughts get bent around their designs, following their pathways, bending and wefting through their labyrinthine depths, through and through and through channeled through and processed and--$(br2)... I almost lost myself. Maybe I should postpone my studies of those.",
 
   "hexcasting.entry.hexcasting": "Casting Items",
-  "hexcasting.page.hexcasting.1": "Although the flexibility that casting _Hexes \"on the go\" with my $(l:items/staff)$(item)Staff/$ is quite helpful, it's a huge pain to have to wave it around repeatedly just to accomplish a common task. If I could save a common spell for later reuse, it would simplify things a lot-- and allow me to share my _Hexes with friends, too.",
+  "hexcasting.page.hexcasting.1": "Although the flexibility of casting _Hexes \"on the go\" with my $(l:items/staff)$(item)Staff/$ is quite helpful, it's a huge pain to have to wave it around repeatedly just to accomplish a basic task. If I could save a common spell for later reuse, it would simplify things a lot-- and allow me to share my _Hexes with friends, too.",
   "hexcasting.page.hexcasting.2": "To do this, I can craft one of three types of magic items: $(l:items/hexcasting)$(item)Cyphers/$, $(l:items/hexcasting)$(item)Trinkets/$, or $(l:items/hexcasting)$(item)Artifacts/$. All of them hold the patterns of a given _Hex inside, along with a small battery containing _media.$(br2)Simply holding one and pressing $(thing)$(k:use)/$ will cast the patterns inside, as if the holder had cast them out of a staff, using its internal battery.",
-  "hexcasting.page.hexcasting.3": "Each item has its own quirks:$(br2)$(item)Cyphers/$ are fragile, destroyed after their internal _media reserves are gone, and $(italic)cannot/$ be recharged;$(br2)$(item)Trinkets/$ can be cast as much as the holder likes, as long as there's enough _media left, but become useless afterwards until recharged;",
+  "hexcasting.page.hexcasting.3": "Each item has its own quirks:$(br2)$(l:items/hexcasting)$(item)Cyphers/$ are fragile, destroyed after their internal _media reserves are gone, and $(italic)cannot/$ be recharged;$(br2)$(l:items/hexcasting)$(item)Trinkets/$ can be cast as much as the holder likes, as long as there's enough _media left, but become useless afterwards until recharged;",
   "hexcasting.page.hexcasting.4": "$(l:items/hexcasting)$(item)Artifacts/$ are the most powerful of all-- after their _media is depleted, they can use $(l:items/amethyst)$(item)Amethyst/$ from the holder's inventory to pay for the _Hex, just as I do when casting with a $(l:items/staff)$(item)Staff/$. Of course, this also means the spell might consume their mind if there's not enough $(l:items/amethyst)$(item)Amethyst/$.$(br2)Once I've made an empty magic item in a mundane crafting bench, I infuse the _Hex into it using (what else but) a spell appropriate to the item. $(l:patterns/spells/hexcasting)I've catalogued the patterns here./$",
   "hexcasting.page.hexcasting.5": "Each infusion spell requires an entity and a list of patterns on the stack. The entity must be a _media-holding item entity (i.e. $(l:items/amethyst)$(item)amethyst/$ crystals, dropped on the ground); the entity is consumed and forms the battery.$(br2)Usefully, it seems that the _media in the battery is not consumed in chunks as it is when casting with a $(l:items/staff)$(item)Staff/$-- rather, the _media \"melts down\" into one continuous pool. Thus, if I store a _Hex that only costs one $(l:items/amethyst)$(item)Amethyst Dust/$'s worth of mana, a $(l:items/amethyst)$(item)Charged Crystal/$ used as the battery will allow me to cast it 10 times.",
   "hexcasting.page.hexcasting.crafting.desc": "$(italic)We have a saying in our field: \"Magic isn't\". It doesn't \"just work,\" it doesn't respond to your thoughts, you can't throw fireballs or create a roast dinner from thin air or turn a bunch of muggers into frogs and snails./$",
 
   "hexcasting.entry.phials": "Phials of Media",
-  "hexcasting.page.phials.1": "I find it quite ... irritating, how Nature refuses to give me change for my work. If all I have on hand is $(l:items/amethyst)$(item)Charged Crystals/$, even the tiniest $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Purification/$ will consume the entire crystal, wasting the remaining _media.$(br2)Fortunately, it seems I've found a way to somewhat allay this problem.",
+  "hexcasting.page.phials.1": "I find it quite ... irritating, how Nature refuses to give me change for my work. If all I have on hand is $(l:items/amethyst)$(item)Charged Amethyst/$, even the tiniest $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Purification/$ will consume the entire crystal, wasting the remaining _media.$(br2)Fortunately, it seems I've found a way to somewhat allay this problem.",
   "hexcasting.page.phials.2": "I've found old scrolls describing a $(item)Glass Bottle/$ infused with _media. When casting _Hexes, my spells would then draw _media out of the phial. The liquid form of the _media would let me take exact change, so to speak; nothing would be wasted. It's quite like the internal battery of a $(l:items/hexcasting)$(item)Trinket/$, or similar; I can even $(l:patterns/spells/hexcasting#hexcasting:recharge)$(action)Recharge/$ them in the same manner.",
   "hexcasting.page.phials.3": "Unfortunately, the art of actually $(italic)making/$ the things seems to have been lost to time. I've found a $(l:patterns/great_spells/make_battery#hexcasting:craft/battery)$(thing)hint at the pattern used to craft it/$, but the technique is irritatingly elusive, and I can't seem to do it successfully. I suspect I will figure it out with study and practice, though. For now, I will simply deal with the wasted _media...$(br2)But I won't settle for it forever.",
   "hexcasting.page.phials.desc": "$(italic)Drink the milk./$",
 
   "hexcasting.entry.pigments": "Pigments",
   "hexcasting.page.pigments.1": "Although their names were lost to time, the old practitioners of my art seem to have identified themselves by a color, emblematic of them and their spells. It seems a special kind of pigment, offered to Nature in the right way, would \"[...] paint one's thoughts in a manner pleasing to Nature, inducing a miraculous change in personal colour.\"",
-  "hexcasting.page.pigments.2": "I'm not certain on the specifics of how it works, but I believe I have isolated the formulae for many different colors of pigments. To use a pigment, I hold it in one hand while casting $(l:patterns/spells/colorize)$(action)Internalize Pigment/$ with the other, consuming the pigment and marking my mind with its color.$(br2)The pigments seem to affect the color of the sparks of media emitted out of a staff when I cast a _Hex, as well as my $(l:patterns/spells/sentinels)$(action)Sentinel/$.",
+  "hexcasting.page.pigments.2": "I'm not certain on the specifics of how it works, but I believe I have isolated the formulae for many different colors of pigments. To use a pigment, I hold it in one hand while casting $(l:patterns/spells/colorize)$(action)Internalize Pigment/$ with the other, consuming the pigment and marking my mind with its color.$(br2)The pigments seem to affect the color of the sparks of media emitted out of a staff when I cast a _Hex, as well as my $(l:patterns/spells/sentinels)$(thing)sentinel/$.",
   "hexcasting.page.pigments.colored.crafting.header": "Chromatic Pigments",
   "hexcasting.page.pigments.colored.crafting.desc": "Pigments in all the colors of the rainbow.",
   "hexcasting.page.pigments.uuid.crafting.desc": "And finally, a pigment with a color wholly unique to me.$(br2)$(italic)And all the colors I am inside have not been invented yet./$",
 
   "hexcasting.entry.edified": "Edified Trees",
-  "hexcasting.page.edified.1": "By infusing _media into a sapling via the use of $(l:patterns/spells/blockworks#hexcasting:edify)$(action)Edify Sapling/$, I can create what is called an $(thing)Edified Tree/$. They tend to be tall and pointy, with ridged bark and wood that grows in a strange spiral pattern. Their leaves come in three pretty colors.",
+  "hexcasting.page.edified.1": "By infusing _media into a sapling via the use of $(l:patterns/spells/blockworks#hexcasting:edify)$(action)Edify Sapling/$, I can create what is called an $(l:items/edified)$(thing)Edified Tree/$. They tend to be tall and pointy, with ridged bark and wood that grows in a strange spiral pattern. Their leaves come in three pretty colors.",
   "hexcasting.page.edified.2": "I would assume the wood would have some properties relevant to _Hexcasting. But, if it does, I cannot seem to find them. For all intents and purposes it appears to be just wood, albeit of a very strange color.$(br2)I suppose for now I will use it for decoration; the full suite of standard wood blocks can be crafted from them.$(br2)Of course, I can strip them with an axe as well.",
   "hexcasting.page.edified.crafting.desc": "$(italic)Their smooth trunks, with white bark, gave the effect of enormous columns sustaining the weight of an immense foliage, full of shade and silence./$",
 
   "hexcasting.entry.decoration": "Decorative Blocks",
   "hexcasting.page.decoration.1": "In the course of my studies I have discovered some building blocks and trifles that I may find aesthetically pleasing. I've compiled the methods of making them here.",
   "hexcasting.page.decoration.ancient_scroll.crafting.desc": "Brown dye works well enough to simulate the look of an $(l:items/scroll)$(item)ancient scroll/$.",
-  "hexcasting.page.decoration.tiles.crafting.desc": "$(l:items/decoration)$(item)Amethyst Tiles/$ can also be made in a Stonecutter.$(br2)$(item)Blocks of Amethyst Dust/$ (next page) will fall like sand.",
+  "hexcasting.page.decoration.tiles.crafting.desc": "$(l:items/decoration)$(item)Amethyst Tiles/$ can also be made in a Stonecutter.$(br2)$(l:items/decoration)$(item)Blocks of Amethyst Dust/$ (next page) will fall like sand.",
   "hexcasting.page.decoration.sconce.crafting.desc": "$(l:items/decoration)$(item)Amethyst Sconces/$ emit light and particles, as well as a pleasing chiming sound.",
 
 
@@ -598,7 +619,7 @@
   "hexcasting.entry.brainsweeping": "On the Flaying of Minds",
   "hexcasting.page.brainsweeping.1": "A secret was revealed to me. I saw it. I cannot forget its horror. The idea skitters across my brain.$(br2)I believed-- oh, foolishly, I $(italic)believed/$ --that _Media is the spare energy left over by thought. But now I $(italic)know/$ what it is: the energy $(italic)of/$ thought.",
   "hexcasting.page.brainsweeping.2": "It is produced by thinking sentience and allows sentience to think. It is a knot tying that braids into its own string. The Entity I naively anthromorphized as Nature is simply a grand such tangle, or perhaps the set of all tangles, or ... if I think it hurts I have so many synapses and all of them can think pain at once ALL OF THEM CAN SEE$(br2)I am not holding on. My notes. Quickly.",
-  "hexcasting.page.brainsweeping.3": "The villagers of this world have enough consciousness left to be extracted. Place it into a block, warp it, change it. Intricate patterns caused by different patterns of thought, the abstract neural pathways of their jobs and lives mapped into the cold physic of solid atoms.$(br2)This is what $(l:patterns/great_spells/brainsweep)$(action)Flay Mind/$ does, the extraction. Target the villager entity and the destination block. Ten $(l:items/amethyst)$(item)Charged Crystals/$ for this perversion of will.",
+  "hexcasting.page.brainsweeping.3": "The villagers of this world have enough consciousness left to be extracted. Place it into a block, warp it, change it. Intricate patterns caused by different patterns of thought, the abstract neural pathways of their jobs and lives mapped into the cold physic of solid atoms.$(br2)This is what $(l:patterns/great_spells/brainsweep)$(action)Flay Mind/$ does, the extraction. Target the villager entity and the destination block. Ten $(l:items/amethyst)$(item)Charged Amethyst/$ for this perversion of will.",
   "hexcasting.page.brainsweeping.budding_amethyst": "And an application. For this flaying, any sort of villager will do, if it has developed enough. Other recipes require more specific types. NO MORE must I descend into the hellish earth for my _media.",
 
   "hexcasting.entry.spellcircles": "Spell Circles",
@@ -649,11 +670,11 @@
   "hexcasting.page.basics_pattern.get_entity_height": "Transforms an entity on the stack into its height.",
   "hexcasting.page.basics_pattern.get_entity_velocity": "Transforms an entity on the stack into the direction in which it's moving, with the speed of that movement as that direction's magnitude.",
   "hexcasting.page.basics_pattern.print": "Displays the top iota of the stack to me.",
-  "hexcasting.page.basics_pattern.raycast.1": "Combines two vectors (a position and a direction) into the answer to the question: If I stood at the position and looked in the direction, what block would I be looking at?",
+  "hexcasting.page.basics_pattern.raycast.1": "Combines two vectors (a position and a direction) into the answer to the question: If I stood at the position and looked in the direction, what block would I be looking at? Costs a negligible amount of _media.",
   "hexcasting.page.basics_pattern.raycast.2": "For example, casting this with my own position and look vectors will return the coordinates of the block I am looking at.$(br2)If it doesn't hit anything, the vectors will combine into $(l:casting/influences)$(thing)Null/$.",
-  "hexcasting.page.basics_pattern.raycast/axis.1": "Like $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation$(/l), but instead returns a vector representing the answer to the question: Which $(italic)side/$ of the block am I looking at?",
+  "hexcasting.page.basics_pattern.raycast/axis.1": "Like $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation$(/l), but instead returns a vector representing the answer to the question: Which $(italic)side/$ of the block am I looking at? Costs a negligible amount of _media.",
   "hexcasting.page.basics_pattern.raycast/axis.2": "More specifically, it returns the $(italic)normal vector/$ of the face hit, or a unit vector pointing perpendicular to the face.$(li)If I am looking at a floor, it will return (0, 1, 0).$(li)If I am looking at the south face of a block, it will return (0, 0, 1).",
-  "hexcasting.page.basics_pattern.raycast/entity": "Like $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation$(/l), but instead returns the $(italic)entity/$ I am looking at.",
+  "hexcasting.page.basics_pattern.raycast/entity": "Like $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation$(/l), but instead returns the $(italic)entity/$ I am looking at. Costs a negligible amount of _media.",
 
   "hexcasting.entry.numbers": "Number Literals",
   "hexcasting.page.numbers.1.header": "Numerical Reflection",
@@ -683,20 +704,33 @@
   "hexcasting.page.math.abs_len.2": "Replaces a number with its absolute value, or a vector with its length.",
   "hexcasting.page.math.pow_proj.1": "Perform exponentiation or vector projection.",
   "hexcasting.page.math.pow_proj.2": "With two numbers, combines them by raising the first to the power of the second.$(li)With a number and a vector, removes the number and raises each component of the vector to the number's power.$(li)With two vectors, combines them into the $(l:https://en.wikipedia.org/wiki/Vector_projection)vector projection/$ of the top of the stack onto the second-from-the-top.$(br2)In the first and second cases, the first argument or its components are the base, and the second argument or its components are the exponent.",
-  "hexcasting.page.math.logarithm": "Removes the number at the top of the stack, then takes the logarithm of the number at the top using the other number as its base.",
   "hexcasting.page.math.floor": "\"Floors\" a number, cutting off the fractional component and leaving an integer value.",
   "hexcasting.page.math.ceil": "\"Ceilings\" a number, raising it to the next integer value if it has a fractional component.",
   "hexcasting.page.math.construct_vec": "Combine three numbers at the top of the stack into a vector's X, Y, and Z components (top to bottom).",
   "hexcasting.page.math.deconstruct_vec": "Split a vector into its X, Y, and Z components (top to bottom).",
   "hexcasting.page.math.coerce_axial": "Coerces a vector to its nearest axial direction, a unit vector. The zero vector is unaffected.",
-  "hexcasting.page.math.sin": "Take the sine of an angle in radians, yielding the vertical component of that angle drawn on a unit circle.",
-  "hexcasting.page.math.cos": "Take the cosine of an angle in radians, yielding the horizontal component of that angle drawn on a unit circle.",
-  "hexcasting.page.math.tan": "Take the tangent of an angle in radians, yielding the slope of that angle drawn on a circle.",
-  "hexcasting.page.math.arcsin": "Take the inverse sine of a value with absolute value 1 or less, yielding the angle whose sine is that value.",
-  "hexcasting.page.math.arccos": "Take the inverse cosine of a value with absolute value 1 or less, yielding the angle whose cosine is that value.",
-  "hexcasting.page.math.arctan": "Take the inverse tangent of a value, yielding the angle whose tangent is that value.",
   "hexcasting.page.math.random": "Creates a random number between 0 and 1.",
 
+  "hexcasting.entry.advanced_math": "Advanced Mathematics",
+  "hexcasting.page.advanced_math.sin": "Takes the sine of an angle in radians, yielding the vertical component of that angle drawn on a unit circle. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.cos": "Takes the cosine of an angle in radians, yielding the horizontal component of that angle drawn on a unit circle. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.tan": "Takes the tangent of an angle in radians, yielding the slope of that angle drawn on a circle. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.arcsin": "Takes the inverse sine of a value with absolute value 1 or less, yielding the angle whose sine is that value. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.arccos": "Takes the inverse cosine of a value with absolute value 1 or less, yielding the angle whose cosine is that value. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.arctan": "Takes the inverse tangent of a value, yielding the angle whose tangent is that value. Related to the values of $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ and $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+  "hexcasting.page.advanced_math.logarithm": "Removes the number at the top of the stack, then takes the logarithm of the number at the top using the other number as its base. Related to the value of $(l:patterns/consts#hexcasting:const/double/e)$(thing)$(italic)e/$.",
+
+  "hexcasting.entry.sets": "Sets",
+  "hexcasting.page.sets.numlist": "Set operations are odd, in that some of them can accept two numbers or two lists, but not a combination thereof. Such arguments will be written as \"num, num/list, list\".$(br2)When numbers are used in those operations, they are being used as so-called binary \"bitsets\", lists of 1 and 0, true and false, \"on\" and \"off\".",
+  "hexcasting.page.sets.or.1": "Unifies two sets.",
+  "hexcasting.page.sets.or.2": "As such:$(li)With two numbers at the top of the stack, combines them into a bitset containing every \"on\" bit in either bitset.$(li)With two lists, this creates a list of every element from the first list, plus every element from the second list that is not in the first list. This is similar to $(l:patterns/lists#hexcasting:concat)$(action)Combination Distillation/$.",
+  "hexcasting.page.sets.and.1": "Takes the intersection of two sets.",
+  "hexcasting.page.sets.and.2": "As such:$(li)With two numbers at the top of the stack, combines them into a bitset containing every \"on\" bit present in $(italics)both/$ bitsets.$(li)With two lists, this creates a list of every element from the first list that is also in the second list.",
+  "hexcasting.page.sets.xor.1": "Takes the exclusive disjunction of two sets.",
+  "hexcasting.page.sets.xor.2": "As such:$(li)With two numbers at the top of the stack, combines them into a bitset containing every \"on\" bit present in $(italics)exactly one/$ of the bitsets.$(li)With two lists, this creates a list of every element in both lists that is $(italics)not/$ in the other list.",
+  "hexcasting.page.sets.not": "Takes the inversion of a bitset, changing all \"on\" bits to \"off\" and vice versa. In my experience, this will take the form of that number negated and decreased by one. For example, 0 will become -1, and -100 will become 99.",
+  "hexcasting.page.sets.to_set": "Removes duplicate entries from a list.",
+
   "hexcasting.entry.consts": "Constants",
   "hexcasting.page.consts.const/vec/x": "The left-hand counter-clockwise pattern adds [1, 0, 0] to the stack; the right-hand clockwise pattern adds [-1, 0, 0].",
   "hexcasting.page.consts.const/vec/y": "The left-hand counter-clockwise pattern adds [0, 1, 0] to the stack; the right-hand clockwise pattern adds [0, -1, 0].",
@@ -708,14 +742,18 @@
   "hexcasting.page.consts.const/null": "Adds the $(l:casting/influences)$(thing)Null/$ influence to the top of the stack.",
 
   "hexcasting.entry.stackmanip": "Stack Manipulation",
+  "hexcasting.page.stackmanip.stack": "These patterns concern the $(l:casting/stack)$(thing)Stack/$ itself. Many of them pop different numbers of arguments and push different numbers of outputs depending on the inputs you give them. Such occurrences are written as \"many\".",
   "hexcasting.page.stackmanip.swap": "Swaps the top two iotas of the stack.",
   "hexcasting.page.stackmanip.fisherman": "Grabs the element in the stack indexed by the number and brings it to the top.",
+  "hexcasting.page.stackmanip.stack_len": "Pushes the size of the stack as a number to the top of the stack. (For example, a stack of [0, 1] will become [0, 1, 2].)",
+  "hexcasting.page.stackmanip.last_n_list": "Remove $(italic)num/$ elements from the stack, then add them to a list at the top of the stack.",
+  "hexcasting.page.stackmanip.splat": "Remove the list at the top of the stack, then push its contents to the stack.",
   "hexcasting.page.stackmanip.duplicate": "Duplicates the top iota of the stack.",
   "hexcasting.page.stackmanip.duplicate_n": "Removes the number at the top of the stack, then copies the top iota of the stack that number of times. (A count of 2 results in two of the iota on the stack, not three.)",
   "hexcasting.page.stackmanip.mask.header": "Bookkeeper's Gambits",
   "hexcasting.page.stackmanip.mask.1": "An infinite family of actions that keep or remove elements at the top of the stack based on the sequence of dips and lines.",
   "hexcasting.page.stackmanip.mask.2": "Assuming that I draw a Bookkeeper's Gambit pattern left-to-right, the number of iotas the action will require is determined by the horizontal distance covered by the pattern. From deepest in the stack to shallowest, a flat line will keep the iota, whereas a triangle dipping down will remove it.$(br2)If my stack contains $(italic)0, 1, 2/$ from deepest to shallowest, drawing the first pattern opposite will give me $(italic)1/$, the second will give me $(italic)0/$, and the third will give me $(italic)0, 2/$ (the 0 at the bottom is left untouched).",
-  "hexcasting.page.stackmanip.swizzle.1": "Rearranges the top elements of the stack based on the given numerical code, which is the index of the permutation wanted.",
+  "hexcasting.page.stackmanip.swizzle.1": "Rearranges the top elements of the stack based on the given numerical code, which is the index of the permutation wanted. Costs an amount of media that starts negligible and scales up as the numerical code does.",
   "hexcasting.page.stackmanip.swizzle.2": "Although I can't pretend to know the mathematics behind calculating this permutation code, I have managed to dig up an extensive chart of them, enumerating all permutations of up to six elements.$(br2)If I wish to do further study, the key word is \"Lehmer Code.\"",
   "hexcasting.page.stackmanip.swizzle.link": "Table of Codes",
 
@@ -752,17 +790,17 @@
   "hexcasting.page.entities.zone_entity": "Take a position and maximum distance on the stack, and combine them into a list of all entities near the position.",
 
   "hexcasting.entry.lists": "List Manipulation",
-  "hexcasting.page.lists.1": "Remove the number at the top of the stack, then replace the list at the top with the nth element of that list (where n is the number you removed). Replaces the list with $(l:casting/influences)$(thing)Null/$ if the number is out of bounds.",
-  "hexcasting.page.lists.2": "Remove the top of the stack, then add it to the end of the list at the top of the stack.",
-  "hexcasting.page.lists.3": "Remove the list at the top of the stack, then add all its elements to the end of the list at the top of the stack.",
-  "hexcasting.page.lists.4": "Push an empty list to the top of the stack.",
-  "hexcasting.page.lists.5": "Remove the top of the stack, then push a list containing only that element.",
-  "hexcasting.page.lists.6": "Remove $(italic)num/$ elements from the stack, then add them to a list at the top of the stack.",
-  "hexcasting.page.lists.7": "Remove the list at the top of the stack, then push its contents to the stack.",
-  "hexcasting.page.lists.8": "Remove the list at the top of the stack, then push the number of elements in the list to the stack.",
-  "hexcasting.page.lists.9": "Reverse the list at the top of the stack.",
-  "hexcasting.page.lists.10": "Remove the iota at the top of the stack, then replace the list at the top with the first index of that iota within the list (starting from 0). Replaces the list with -1 if the iota doesn't exist in the list.",
-  "hexcasting.page.lists.11": "Remove the number at the top of the stack, then remove the nth element of the list at the top of the stack (where n is the number you removed).",
+  "hexcasting.page.lists.index": "Remove the number at the top of the stack, then replace the list at the top with the nth element of that list (where n is the number you removed). Replaces the list with $(l:casting/influences)$(thing)Null/$ if the number is out of bounds.",
+  "hexcasting.page.lists.slice": "Remove the two numbers at the top of the stack, then take a sublist of the list at the top of the stack between those indices, lower bound inclusive, upper bound exclusive. For example, the 0, 2 sublist of [0, 1, 2, 3, 4] would be [0, 1].",
+  "hexcasting.page.lists.append": "Remove the top of the stack, then add it to the end of the list at the top of the stack.",
+  "hexcasting.page.lists.concat": "Remove the list at the top of the stack, then add all its elements to the end of the list at the top of the stack.",
+  "hexcasting.page.lists.empty_list": "Push an empty list to the top of the stack.",
+  "hexcasting.page.lists.singleton": "Remove the top of the stack, then push a list containing only that element.",
+  "hexcasting.page.lists.list_size": "Remove the list at the top of the stack, then push the number of elements in the list to the stack.",
+  "hexcasting.page.lists.reverse_list": "Reverse the list at the top of the stack.",
+  "hexcasting.page.lists.index_of": "Remove the iota at the top of the stack, then replace the list at the top with the first index of that iota within the list (starting from 0). Replaces the list with -1 if the iota doesn't exist in the list.",
+  "hexcasting.page.lists.list_remove": "Remove the number at the top of the stack, then remove the nth element of the list at the top of the stack (where n is the number you removed).",
+  "hexcasting.page.lists.modify_in_place": "Remove the top iota of the stack and the number at the top, then set the nth element of the list at the top of the stack to that iota (where n is the number you removed). Does nothing if the number is out of bounds.",
 
   "hexcasting.entry.patterns_as_iotas": "Patterns as Iotas",
   "hexcasting.page.patterns_as_iotas.1": "One of the many peculiarities of this art is that $(italic)patterns themselves/$ can act as iotas-- I can even put them onto my stack when casting.$(br2)This raises a fairly obvious question: how do I express them? If I simply drew a pattern, it would hardly tell Nature to add it to my stack-- rather, it would simply be matched to an action.",
@@ -775,14 +813,17 @@
 
   "hexcasting.entry.readwrite": "Reading and Writing",
   "hexcasting.page.readwrite.read": "Copy the iota stored in the item (such as a $(l:items/scroll)$(item)Scroll/$, $(l:items/focus)$(item)Focus/$, $(l:items/abacus)$(item)Abacus/$ or $(l:items/spellbook)$(item)Spellbook/$) in my other hand, and add it to the stack.",
+  "hexcasting.page.readwrite.readable": "If the item in my other hand holds an iota I can read, returns 1. Otherwise, returns 0.",
   "hexcasting.page.readwrite.read/entity": "Like $(l:patterns/readwrite#hexcasting:read)$(action)Scribe's Reflection/$, but the iota is read out of an item entity instead of my other hand.",
+  "hexcasting.page.readwrite.readable/entity": "Also like $(l:patterns/readwrite#hexcasting:readable)$(action)Auditor's Reflection/$, but the status is once again read out of an item entity instead of my other hand.",
   "hexcasting.page.readwrite.write.1": "Remove the top iota from the stack, and save it into the item in my other hand.",
   "hexcasting.page.readwrite.write.2": "I can use this spell to save iotas into an (unsealed) $(l:items/focus)$(item)Focus/$ or $(l:items/spellbook)$(item)Spellbook/$, or I can copy patterns onto $(l:items/scroll)$(item)Scrolls/$ or $(l:items/slate)$(item)Slates/$ with the help of $(l:patterns/patterns_as_iotas#hexcasting:escape)$(action)Consideration/$.$(br2)However, it seems I am unable to save a reference to another player, only me. I suppose an entity reference is similar to the idea of a True Name; perhaps Nature is helping to keep our Names out of the hands of enemies. If I want a friend to have my Name I can make a $(l:items/focus)$(item)Focus/$ for them.",
+  "hexcasting.page.readwrite.writable": "If I could save the given iota into the item in my other hand, returns 1. Otherwise, returns 0.",
 
   "hexcasting.entry.meta": "Meta-evaluation",
-  "hexcasting.page.meta.eval.1": "Remove a list of patterns from the stack, then cast them sequentially, as if I had drawn them myself with my $(l:items/staff)$(item)Staff/$.$(br)Costs about one $(l:items/amethyst)$(item)Amethyst Shard/$.",
+  "hexcasting.page.meta.eval.1": "Remove a list of patterns from the stack, then cast them sequentially, as if I had drawn them myself with my $(l:items/staff)$(item)Staff/$.",
   "hexcasting.page.meta.eval.2": "This can be $(italic)very/$ powerful in tandem with $(l:items/focus)$(item)Foci/$.$(br2)It also makes the bureaucracy of Nature a \"Turing-complete\" system, according to one esoteric scroll I found.$(br2)However, it seems there's a limit to how many times a _Hex can cast itself-- Nature doesn't look kindly on runaway spells!$(br2)In addition, with the energies of the patterns occurring without me to guide them, any mishap will cause the remaining actions to become too unstable and immediately unravel.",
-  "hexcasting.page.meta.for_each.1": "Remove a list of patterns and a list from the stack, then cast the given pattern over each element of the second list.$(br)Costs about one $(l:items/amethyst)$(item)Charged Amethyst/$.",
+  "hexcasting.page.meta.for_each.1": "Remove a list of patterns and a list from the stack, then cast the given pattern over each element of the second list.",
   "hexcasting.page.meta.for_each.2": "More specifically, for each element in the second list, it will:$(li)Create a new stack, with everything on the current stack plus that element$(li)Draw all the patterns in the first list$(li)Save all the iotas remaining on the stack to a list$(br)Then, after all is said and done, pushes the list of saved iotas onto the main stack.$(br2)No wonder all the practitioners of this art go mad.",
 
   "hexcasting.entry.circle_patterns": "Spell Circle Patterns",
@@ -809,21 +850,21 @@
   "hexcasting.page.basic_spell.explode.fire.1": "Remove a number and vector from the stack, then create a fiery explosion at the given location with the given power.",
   "hexcasting.page.basic_spell.explode.fire.2": "Costs three $(l:items/amethyst)$(item)Amethyst Shards/$, plus about one extra $(l:items/amethyst)$(item)Amethyst Shard/$ per point of explosion power. Otherwise, the same as $(l:patterns/spells/basic#hexcasting:explode)$(action)Explosion/$, except with fire.",
   "hexcasting.page.basic_spell.add_motion": "Remove an entity and direction from the stack, then give a shove to the given entity in the given direction. The strength of the impulse is determined by the length of the vector.$(br)Costs units of $(l:items/amethyst)$(item)Amethyst Dust/$ equal to the square of the length of the vector.",
-  "hexcasting.page.basic_spell.blink": "Remove an entity and length from the stack, then teleport the given entity along its look vector by the given length.$(br)Costs about 1 $(l:items/amethyst)$(item)Amethyst Shard/$ per block travelled.",
-  "hexcasting.page.basic_spell.beep.1": "Remove a vector and two numbers from the stack. Plays a instrument defined by the first number at the given location, with a note defined by the second number. Costs a negligible amount of _media.",
-  "hexcasting.page.basic_spell.beep.2": "There appear to be 16 different instruments and 25 different notes. Both are indexed by zero.$(br2)These seem to be the same instruments I can produce with a $(item)Note Block/$, though the reason for each instrument's number being what it is eludes me.",
+  "hexcasting.page.basic_spell.blink": "Remove an entity and length from the stack, then teleport the given entity along its look vector by the given length.$(br)Costs about one $(l:items/amethyst)$(item)Amethyst Shard/$ per block travelled.",
+  "hexcasting.page.basic_spell.beep.1": "Remove a vector and two numbers from the stack. Plays an $(thing)instrument/$ defined by the first number at the given location, with a $(thing)note/$ defined by the second number. Costs a negligible amount of _media.",
+  "hexcasting.page.basic_spell.beep.2": "There appear to be 16 different $(thing)instruments/$ and 25 different $(thing)notes/$. Both are indexed by zero.$(br2)These seem to be the same instruments I can produce with a $(item)Note Block/$, though the reason for each instrument's number being what it is eludes me.$(br2)Either way, I can find the numbers I need to use by inspecting a $(item)Note Block/$ through a $(l:items/lens)$(item)Scrying Lens/$.",
 
   "hexcasting.entry.blockworks": "Blockworks",
-  "hexcasting.page.blockworks.place_block": "Remove a location from the stack, then pick a block item and place it at the given location.$(br)Costs about 1 $(l:items/amethyst)$(item)Amethyst Dust/$.",
-  "hexcasting.page.blockworks.break_block": "Remove a location from the stack, then break the block at the given location. This spell can break nearly anything a Diamond Pickaxe can break.$(br)Costs about 3 $(l:items/amethyst)$(item)Amethyst Dust/$.",
+  "hexcasting.page.blockworks.place_block": "Remove a location from the stack, then pick a block item and place it at the given location.$(br)Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
+  "hexcasting.page.blockworks.break_block": "Remove a location from the stack, then break the block at the given location. This spell can break nearly anything a Diamond Pickaxe can break.$(br)Costs about two $(l:items/amethyst)$(item)Amethyst Dust/$.",
   "hexcasting.page.blockworks.create_water": "Summon a block of water (or insert a bucket's worth) into a block at the given position. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
-  "hexcasting.page.blockworks.destroy_water": "Destroy a great deal of liquid (not just water) around the given position. Costs about two $(l:items/amethyst)$(item)Charged Crystals/$.",
+  "hexcasting.page.blockworks.destroy_water": "Destroy a great deal of liquid (not just water) around the given position. Costs about two $(l:items/amethyst)$(item)Charged Amethyst/$.",
   "hexcasting.page.blockworks.conjure_block": "Conjure an ethereal, but solid, block that sparkles with my pigment at the given position. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
   "hexcasting.page.blockworks.conjure_light": "Conjure a magical light that softly glows with my pigment at the given position. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
   "hexcasting.page.blockworks.bonemeal": "Encourage a plant or sapling at the target position to grow, as if $(item)Bonemeal/$ was applied. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
   "hexcasting.page.blockworks.edify": "Forcibly infuse _media into the sapling at the target position, causing it to grow into an $(l:items/edified)$(thing)Edified Tree/$. Costs about one $(l:items/amethyst)$(item)Charged Crystal/$.",
   "hexcasting.page.blockworks.ignite": "Start a fire on top of the given location, as if a $(item)Fire Charge/$ was applied. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
-  "hexcasting.page.blockworks.extinguish": "Extinguish blocks in a large area. Costs about two $(l:items/amethyst)$(item)Charged Crystals/$.",
+  "hexcasting.page.blockworks.extinguish": "Extinguish blocks in a large area. Costs about one $(l:items/amethyst)$(item)Charged Amethyst/$.",
 
   "hexcasting.entry.nadirs": "Nadirs",
   "hexcasting.page.nadirs.1": "This family of spells all impart a negative potion effect upon an entity. They all take an entity, the recipient, and one or two numbers, the first being the duration and the second, if present, being the potency (starting at 1).$(br2)Each one has a \"base cost;\" the actual cost is equal to that base cost, multiplied by the potency squared.",
@@ -845,28 +886,28 @@
   "hexcasting.page.hexcasting_spell.erase.2": "The spell will also void all the _media stored inside the item, releasing it back to Nature and returning the item to a perfectly clean slate. This way, I can re-use $(l:items/hexcasting)$(item)Trinkets/$ I have put an erroneous spell into, for example.$(br2)This also works to clear a $(l:items/focus)$(item)Focus/$ or $(l:items/spellbook)$(item)Spellbook/$, unsealing them in the process.",
 
   "hexcasting.entry.sentinels": "Sentinels",
-  "hexcasting.page.sentinels.1": "$(italic)Hence, away! Now all is well,$(br)One aloof stand sentinel./$$(br2)A $(thing)Sentinel/$ is a mysterious force I can summon to assist in the casting of _Hexes, like a familiar or guardian spirit. It appears as a spinning geometric shape to my eyes, but is invisible to everyone else.",
-  "hexcasting.page.sentinels.2": "It has several interesting properties:$(li)It does not appear to be tangible; no one else can interact with it.$(li)Once summoned, it stays in place until banished.$(li)I am always able to see it, even through solid objects.",
-  "hexcasting.page.sentinels.sentinel/create": "Summons my $(thing)sentinel/$ at the given position. Costs about 1 $(l:items/amethyst)$(item)Amethyst Dust/$.",
-  "hexcasting.page.sentinels.sentinel/destroy": "Banish my $(thing)sentinel/$, and remove it from the world. Costs a negligible amount of _media.",
-  "hexcasting.page.sentinels.sentinel/get_pos": "Add the position of my $(thing)sentinel/$ to the stack, or $(l:casting/influences)$(thing)Null/$ if it isn't summoned. Costs a negligible amount of _media.",
-  "hexcasting.page.sentinels.sentinel/wayfind": "Transform the position vector on the top of the stack into a unit vector pointing from that position to my $(thing)sentinel/$, or $(l:casting/influences)$(thing)Null/$ if it isn't summoned. Costs a negligible amount of _media.",
+  "hexcasting.page.sentinels.1": "$(italic)Hence, away! Now all is well,$(br)One aloof stand sentinel./$$(br2)A $(l:patterns/spells/sentinels)$(thing)Sentinel/$ is a mysterious force I can summon to assist in the casting of _Hexes, like a familiar or guardian spirit. It appears as a spinning geometric shape to my eyes, but is invisible to everyone else.",
+  "hexcasting.page.sentinels.2": "It has several interesting properties:$(li)It does not appear to be tangible; no one can touch it.$(li)Only my _Hexes can interact with it.$(li)Once summoned, it stays in place until banished.$(li)I am always able to see it if I'm close enough, even through solid objects.",
+  "hexcasting.page.sentinels.sentinel/create": "Summons my $(l:patterns/spells/sentinels)$(thing)sentinel/$ at the given position. Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
+  "hexcasting.page.sentinels.sentinel/destroy": "Banish my $(l:patterns/spells/sentinels)$(thing)sentinel/$, and remove it from the world. Costs a negligible amount of _media.",
+  "hexcasting.page.sentinels.sentinel/get_pos": "Add the position of my $(l:patterns/spells/sentinels)$(thing)sentinel/$ to the stack, or $(l:casting/influences)$(thing)Null/$ if it isn't summoned. Costs a negligible amount of _media.",
+  "hexcasting.page.sentinels.sentinel/wayfind": "Transform the position vector on the top of the stack into a unit vector pointing from that position to my $(l:patterns/spells/sentinels)$(thing)sentinel/$, or $(l:casting/influences)$(thing)Null/$ if it isn't summoned. Costs a negligible amount of _media.",
 
-  "hexcasting.page.colorize": "I must be holding a $(l:items/pigments)$(item)Pigment/$ in my other hand to cast this spell. When I do, it will consume the dye and permanently change my mind's coloration (at least, until I cast the spell again). Costs about 1 $(l:items/amethyst)$(item)Amethyst Dust/$.",
+  "hexcasting.page.colorize": "I must be holding a $(l:items/pigments)$(item)Pigment/$ in my other hand to cast this spell. When I do, it will consume the dye and permanently change my mind's coloration (at least, until I cast the spell again). Costs about one $(l:items/amethyst)$(item)Amethyst Dust/$.",
 
   "hexcasting.page.create_lava.1": "Summon a block of lava or insert a bucket's worth into a block at the given position. Costs about one $(l:items/amethyst)$(item)Charged Amethyst/$.",
   "hexcasting.page.create_lava.2": "It may be advisable to keep my knowledge of this spell secret. A certain faction of botanists get... touchy about it, or so I've heard.$(br2)Well, no one said tracing the deep secrets of the universe was going to be an easy time.",
 
   "hexcasting.entry.weather_manip": "Weather Manipulation",
-  "hexcasting.page.weather_manip.lightning": "I command the heavens! This spell will summon a bolt of lightning to strike the earth where I direct it. Costs about 3 $(l:items/amethyst)$(item)Amethyst Shards/$.",
-  "hexcasting.page.weather_manip.summon_rain": "I control the clouds! This spell will summon rain across the world I cast it upon. Costs about 2 $(l:items/amethyst)$(item)Amethyst Shards/$. Does nothing if it is already raining.",
-  "hexcasting.page.weather_manip.dispel_rain": "A counterpart to summoning rain. This spell will dispel rain across the world I cast it upon. Costs about 1 $(l:items/amethyst)$(item)Amethyst Shard/$. Does nothing if the skies are already clear.",
+  "hexcasting.page.weather_manip.lightning": "I command the heavens! This spell will summon a bolt of lightning to strike the earth where I direct it. Costs about three $(l:items/amethyst)$(item)Amethyst Shards/$.",
+  "hexcasting.page.weather_manip.summon_rain": "I control the clouds! This spell will summon rain across the world I cast it upon. Costs about one $(l:items/amethyst)$(item)Charged Amethyst/$. Does nothing if it is already raining.",
+  "hexcasting.page.weather_manip.dispel_rain": "A counterpart to summoning rain. This spell will dispel rain across the world I cast it upon. Costs about one $(l:items/amethyst)$(item)Amethyst Shard/$. Does nothing if the skies are already clear.",
 
   "hexcasting.page.flight.1": "The power of flight! I have wrestled Nature to its knees. But Nature is vengeful, and itches for me to break its contract so it may break my shins.",
-  "hexcasting.page.flight.2": "The entity (which must be a player) will be endowed with flight. The first number is the number of seconds they may fly for, and the second number is the radius of the zone they may fly in. If the recipient exits that zone, or their timer runs out while midair, the gravity that they spurned will get its revenge. Painfully.$(br2)It costs approximately 1 $(l:items/amethyst)$(item)Amethyst Dust/$ multiplied by the radius per second of flight.",
+  "hexcasting.page.flight.2": "The entity (which must be a player) will be endowed with flight. The first number is the number of seconds they may fly for, and the second number is the radius of the zone they may fly in. If the recipient exits that zone, or their timer runs out while midair, the gravity that they spurned will get its revenge. Painfully.$(br2)It costs approximately one $(l:items/amethyst)$(item)Amethyst Dust/$ multiplied by the radius per second of flight.",
 
   "hexcasting.page.teleport.1": "Far more powerful than $(l:patterns/spells/basic#hexcasting:blink)$(action)Blink/$, this spell lets me teleport nearly anywhere in the entire world! There does seem to be a limit, but it is $(italic)much/$ greater than the normal radius of influence I am used to.",
-  "hexcasting.page.teleport.2": "The entity will be teleported by the given vector, which is an offset from its given position. No matter the distance, it always seems to cost about ten $(l:items/amethyst)$(item)Charged Crystals/$.$(br2)The transference is not perfect, and it seems when teleporting something as complex as a player, their inventory doesn't $(italic)quite/$ stay attached, and tends to splatter everywhere at the destination.",
+  "hexcasting.page.teleport.2": "The entity will be teleported by the given vector, which is an offset from its given position. No matter the distance, it always seems to cost about ten $(l:items/amethyst)$(item)Charged Amethyst/$.$(br2)The transference is not perfect, and it seems when teleporting something as complex as a player, their inventory doesn't $(italic)quite/$ stay attached, and tends to splatter everywhere at the destination.",
 
   "hexcasting.entry.zeniths": "Zeniths",
   "hexcasting.page.zeniths.1": "This family of spells all impart a positive potion effect upon an entity, similar to the $(l:patterns/spells/nadirs)$(action)Nadirs/$. However, these have their _media costs increase with the $(italic)cube/$ of the potency.",
@@ -876,11 +917,11 @@
   "hexcasting.page.zeniths.potion/haste": "Bestows $(thing)haste/$. Base cost is one $(l:items/amethyst)$(item)Amethyst Dust/$ per 3 seconds.",
   "hexcasting.page.zeniths.potion/strength": "Bestows $(thing)strength/$. Base cost is one $(l:items/amethyst)$(item)Amethyst Dust/$ per 3 seconds.",
 
-  "hexcasting.page.greater_sentinel.1": "Summon a greater version of my $(l:patterns/spells/sentinels)$(thing)Sentinel/$. Costs about 2 $(l:items/amethyst)$(item)Amethyst Dust/$.",
+  "hexcasting.page.greater_sentinel.1": "Summon a greater version of my $(l:patterns/spells/sentinels)$(thing)Sentinel/$. Costs about two $(l:items/amethyst)$(item)Amethyst Dust/$.",
   "hexcasting.page.greater_sentinel.2": "The stronger $(l:patterns/spells/sentinels)$(thing)sentinel/$ acts like the normal one I can summon without the use of a Great Spell, if a little more visually interesting. However, the range in which my spells can work is extended to a small region around my greater $(l:patterns/spells/sentinels)$(thing)sentinel/$, about 16 blocks. In other words, no matter where in the world I am, I can interact with things around my $(l:patterns/spells/sentinels)$(thing)sentinel/$ (the mysterious forces of chunkloading notwithstanding).",
 
   "hexcasting.page.make_battery.1": "Infuse a bottle with _media to form a $(l:items/phials)$(item)Phial./$",
-  "hexcasting.page.make_battery.2": "Similarly to the spells for $(l:patterns/spells/hexcasting)$(action)Crafting Casting Items/$, I must hold a $(item)Glass Bottle/$ in my other hand, and provide the spell with a dropped stack of $(l:items/amethyst)$(item)Amethyst/$. See $(l:items/phials)this page/$ for more information.$(br2)Costs about 1 $(l:items/amethyst)$(item)Charged Amethyst/$.",
+  "hexcasting.page.make_battery.2": "Similarly to the spells for $(l:patterns/spells/hexcasting)$(action)Crafting Casting Items/$, I must hold a $(item)Glass Bottle/$ in my other hand, and provide the spell with a dropped stack of $(l:items/amethyst)$(item)Amethyst/$. See $(l:items/phials)this page/$ for more information.$(br2)Costs about one $(l:items/amethyst)$(item)Charged Amethyst/$.",
 
   "hexcasting.page.brainsweep_spell.1": "I cannot make heads or tails of this spell... To be honest, I'm not sure I want to know what it does."
 }
diff --git a/src/main/resources/assets/hexcasting/textures/gui/brainsweep_jei.png b/src/main/resources/assets/hexcasting/textures/gui/brainsweep_jei.png
new file mode 100644
index 00000000..b756b180
Binary files /dev/null and b/src/main/resources/assets/hexcasting/textures/gui/brainsweep_jei.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/double.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/double.png
index 6c9d52fe..9241b159 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/double.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/double.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/double_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/double_sealed.png
index e0bf3766..b66ced29 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/double_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/double_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/empty.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/empty.png
index 324bd265..0b919d27 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/empty.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/empty.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/empty_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/empty_sealed.png
index 86f2a4b3..c5a5c642 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/empty_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/empty_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/entity.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/entity.png
index b8c44291..1332ae6d 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/entity.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/entity.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/entity_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/entity_sealed.png
index f06cfc23..fec01c29 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/entity_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/entity_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/list.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/list.png
index df9188f8..b8872f7a 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/list.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/list.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/list_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/list_sealed.png
index f63c383b..02553f38 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/list_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/list_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern.png
index 236eae63..65ca7d05 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern_sealed.png
index df9c54d1..8c458496 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/pattern_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3.png
index 04592d38..a4886c82 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3_sealed.png
index ae2e2ed3..766704e9 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/vec3_sealed.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/widget.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/widget.png
index 2bda2c94..8adec2af 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/widget.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/widget.png differ
diff --git a/src/main/resources/assets/hexcasting/textures/item/spellbook/widget_sealed.png b/src/main/resources/assets/hexcasting/textures/item/spellbook/widget_sealed.png
index a1876b33..5feb35dd 100644
Binary files a/src/main/resources/assets/hexcasting/textures/item/spellbook/widget_sealed.png and b/src/main/resources/assets/hexcasting/textures/item/spellbook/widget_sealed.png differ
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/book.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/book.json
index 33050bae..b2b875dd 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/book.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/book.json
@@ -13,6 +13,9 @@
     "$(action)": "$(#fc77be)",
     "_Media": "$(#74b3f2)Media/$",
     "_media": "$(#74b3f2)media/$",
+    "_Hexcasters": "$(#b38ef3)Hexcasters/$",
+    "_Hexcaster": "$(#b38ef3)Hexcaster/$",
+    "_Hexcasting": "$(#b38ef3)Hexcasting/$",
     "_Hexes": "$(#b38ef3)Hexes/$",
     "_Hex": "$(#b38ef3)Hex/$"
   }
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json
index 4970170b..a5b59840 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json
@@ -85,8 +85,8 @@
     },
     {
       "type": "patchouli:text",
-      "title": "hexcasting.page.mishaps.invalid_iota.title",
-      "text": "hexcasting.page.mishaps.invalid_iota"
+      "title": "hexcasting.page.mishaps.other.title",
+      "text": "hexcasting.page.mishaps.other"
     }
   ]
 }
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/advanced_math.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/advanced_math.json
new file mode 100644
index 00000000..1e846266
--- /dev/null
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/advanced_math.json
@@ -0,0 +1,66 @@
+{
+  "name": "hexcasting.entry.advanced_math",
+  "category": "hexcasting:patterns",
+  "icon": "minecraft:quartz",
+  "sortnum": 11,
+  "advancement": "hexcasting:root",
+  "read_by_default": true,
+  "pages": [
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:sin",
+      "anchor": "hexcasting:sin",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.sin"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:cos",
+      "anchor": "hexcasting:cos",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.cos"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:tan",
+      "anchor": "hexcasting:tan",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.tan"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:arcsin",
+      "anchor": "hexcasting:arcsin",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.arcsin"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:arccos",
+      "anchor": "hexcasting:arccos",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.arccos"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:arctan",
+      "anchor": "hexcasting:arctan",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.arctan"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:logarithm",
+      "anchor": "hexcasting:logarithm",
+      "input": "num, num",
+      "output": "num",
+      "text": "hexcasting.page.advanced_math.logarithm"
+    }
+  ]
+}
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/akashic_patterns.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/akashic_patterns.json
index 7d3d7a67..fab91f4a 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/akashic_patterns.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/akashic_patterns.json
@@ -2,7 +2,7 @@
   "name": "hexcasting.entry.akashic_patterns",
   "category": "hexcasting:patterns",
   "icon": "hexcasting:akashic_bookshelf",
-  "sortnum": 12,
+  "sortnum": 14,
   "advancement": "hexcasting:enlightenment",
   "entry_color": "54398a",
   "pages": [
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/circle.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/circle.json
index 48203996..c8ab79d2 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/circle.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/circle.json
@@ -2,7 +2,7 @@
   "name": "hexcasting.entry.circle_patterns",
   "category": "hexcasting:patterns",
   "icon": "hexcasting:empty_impetus",
-  "sortnum": 11,
+  "sortnum": 13,
   "advancement": "hexcasting:enlightenment",
   "entry_color": "54398a",
   "pages": [
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/consts.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/consts.json
index 2b3de451..4d6508dd 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/consts.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/consts.json
@@ -9,6 +9,7 @@
     {
       "type": "hexcasting:manual_pattern",
       "header": "hexcasting.spell.hexcasting:const/vec/x",
+      "anchor": "hexcasting:const/vec/x",
       "input": "",
       "output": "vector",
       "text": "hexcasting.page.consts.const/vec/x",
@@ -28,6 +29,7 @@
     {
       "type": "hexcasting:manual_pattern",
       "header": "hexcasting.spell.hexcasting:const/vec/y",
+      "anchor": "hexcasting:const/vec/y",
       "input": "",
       "output": "vector",
       "text": "hexcasting.page.consts.const/vec/y",
@@ -47,6 +49,7 @@
     {
       "type": "hexcasting:manual_pattern",
       "header": "hexcasting.spell.hexcasting:const/vec/z",
+      "anchor": "hexcasting:const/vec/z",
       "input": "",
       "output": "vector",
       "text": "hexcasting.page.consts.const/vec/z",
@@ -66,6 +69,7 @@
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:const/vec/0",
+      "anchor": "hexcasting:const/vec/0",
       "input": "",
       "output": "vector",
       "text": "hexcasting.page.consts.const/vec/0"
@@ -73,6 +77,7 @@
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:const/double/tau",
+      "anchor": "hexcasting:const/double/tau",
       "input": "",
       "output": "num",
       "text": "hexcasting.page.consts.const/double/tau"
@@ -80,6 +85,7 @@
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:const/double/pi",
+      "anchor": "hexcasting:const/double/pi",
       "input": "",
       "output": "num",
       "text": "hexcasting.page.consts.const/double/pi"
@@ -87,6 +93,7 @@
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:const/double/e",
+      "anchor": "hexcasting:const/double/e",
       "input": "",
       "output": "num",
       "text": "hexcasting.page.consts.const/double/e"
@@ -94,6 +101,7 @@
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:const/null",
+      "anchor": "hexcasting:const/null",
       "input": "",
       "output": "influence",
       "text": "hexcasting.page.consts.const/null"
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/entities.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/entities.json
index de433b19..c7cf30b4 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/entities.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/entities.json
@@ -59,7 +59,7 @@
       "op_id": "hexcasting:zone_entity/animal",
       "anchor": "hexcasting:zone_entity/animal",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/animal"
     },
     {
@@ -67,7 +67,7 @@
       "op_id": "hexcasting:zone_entity/not_animal",
       "anchor": "hexcasting:zone_entity/not_animal",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/not_animal"
     },
     {
@@ -75,7 +75,7 @@
       "op_id": "hexcasting:zone_entity/monster",
       "anchor": "hexcasting:zone_entity/monster",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/monster"
     },
     {
@@ -83,7 +83,7 @@
       "op_id": "hexcasting:zone_entity/not_monster",
       "anchor": "hexcasting:zone_entity/not_monster",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/not_monster"
     },
     {
@@ -91,7 +91,7 @@
       "op_id": "hexcasting:zone_entity/item",
       "anchor": "hexcasting:zone_entity/item",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/item"
     },
     {
@@ -99,7 +99,7 @@
       "op_id": "hexcasting:zone_entity/not_item",
       "anchor": "hexcasting:zone_entity/not_item",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/not_item"
     },
     {
@@ -107,7 +107,7 @@
       "op_id": "hexcasting:zone_entity/player",
       "anchor": "hexcasting:zone_entity/player",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/player"
     },
     {
@@ -115,7 +115,7 @@
       "op_id": "hexcasting:zone_entity/not_player",
       "anchor": "hexcasting:zone_entity/not_player",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/not_player"
     },
     {
@@ -123,7 +123,7 @@
       "op_id": "hexcasting:zone_entity/living",
       "anchor": "hexcasting:zone_entity/living",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/living"
     },
     {
@@ -131,7 +131,7 @@
       "op_id": "hexcasting:zone_entity/not_living",
       "anchor": "hexcasting:zone_entity/not_living",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity/not_living"
     },
     {
@@ -139,7 +139,7 @@
       "op_id": "hexcasting:zone_entity",
       "anchor": "hexcasting:zone_entity",
       "input": "vector, number",
-      "output": "list of entities",
+      "output": "list",
       "text": "hexcasting.page.entities.zone_entity"
     }
   ]
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/lists.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/lists.json
index fe03c426..b61edaf1 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/lists.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/lists.json
@@ -12,7 +12,15 @@
       "anchor": "hexcasting:index",
       "input": "list, number",
       "output": "any",
-      "text": "hexcasting.page.lists.1"
+      "text": "hexcasting.page.lists.index"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:slice",
+      "anchor": "hexcasting:slice",
+      "input": "list, num, num",
+      "output": "list",
+      "text": "hexcasting.page.lists.slice"
     },
     {
       "type": "hexcasting:pattern",
@@ -20,7 +28,7 @@
       "anchor": "hexcasting:append",
       "input": "list, any",
       "output": "any",
-      "text": "hexcasting.page.lists.2"
+      "text": "hexcasting.page.lists.append"
     },
     {
       "type": "hexcasting:pattern",
@@ -28,7 +36,7 @@
       "anchor": "hexcasting:concat",
       "input": "list, list",
       "output": "list",
-      "text": "hexcasting.page.lists.3"
+      "text": "hexcasting.page.lists.concat"
     },
     {
       "type": "hexcasting:pattern",
@@ -36,7 +44,7 @@
       "anchor": "hexcasting:empty_list",
       "input": "",
       "output": "list",
-      "text": "hexcasting.page.lists.4"
+      "text": "hexcasting.page.lists.empty_list"
     },
     {
       "type": "hexcasting:pattern",
@@ -44,23 +52,7 @@
       "anchor": "hexcasting:singleton",
       "input": "any",
       "output": "list",
-      "text": "hexcasting.page.lists.5"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:last_n_list",
-      "anchor": "hexcasting:last_n_list",
-      "input": "num",
-      "output": "list",
-      "text": "hexcasting.page.lists.6"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:splat",
-      "anchor": "hexcasting:splat",
-      "input": "list",
-      "output": "many",
-      "text": "hexcasting.page.lists.7"
+      "text": "hexcasting.page.lists.singleton"
     },
     {
       "type": "hexcasting:pattern",
@@ -68,7 +60,7 @@
       "anchor": "hexcasting:list_size",
       "input": "list",
       "output": "num",
-      "text": "hexcasting.page.lists.8"
+      "text": "hexcasting.page.lists.list_size"
     },
     {
       "type": "hexcasting:pattern",
@@ -76,7 +68,7 @@
       "anchor": "hexcasting:reverse_list",
       "input": "list",
       "output": "list",
-      "text": "hexcasting.page.lists.9"
+      "text": "hexcasting.page.lists.reverse_list"
     },
     {
       "type": "hexcasting:pattern",
@@ -84,7 +76,7 @@
       "anchor": "hexcasting:index_of",
       "input": "list, any",
       "output": "num",
-      "text": "hexcasting.page.lists.10"
+      "text": "hexcasting.page.lists.index_of"
     },
     {
       "type": "hexcasting:pattern",
@@ -92,7 +84,15 @@
       "anchor": "hexcasting:list_remove",
       "input": "list, num",
       "output": "list",
-      "text": "hexcasting.page.lists.11"
+      "text": "hexcasting.page.lists.list_remove"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:modify_in_place",
+      "anchor": "hexcasting:modify_in_place",
+      "input": "list, num, any",
+      "output": "list",
+      "text": "hexcasting.page.lists.modify_in_place"
     }
   ]
 }
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/math.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/math.json
index 7d3ad6a7..1ffc2111 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/math.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/math.json
@@ -85,22 +85,6 @@
       "type": "patchouli:text",
       "text": "hexcasting.page.math.pow_proj.2"
     },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:logarithm",
-      "anchor": "hexcasting:logarithm",
-      "input": "num, num",
-      "output": "num",
-      "text": "hexcasting.page.math.logarithm"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:random",
-      "anchor": "hexcasting:random",
-      "input": "",
-      "output": "num",
-      "text": "hexcasting.page.math.random"
-    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:floor",
@@ -133,54 +117,6 @@
       "output": "num, num, num",
       "text": "hexcasting.page.math.deconstruct_vec"
     },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:sin",
-      "anchor": "hexcasting:sin",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.sin"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:cos",
-      "anchor": "hexcasting:cos",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.cos"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:tan",
-      "anchor": "hexcasting:tan",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.tan"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:arcsin",
-      "anchor": "hexcasting:arcsin",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.arcsin"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:arccos",
-      "anchor": "hexcasting:arccos",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.arccos"
-    },
-    {
-      "type": "hexcasting:pattern",
-      "op_id": "hexcasting:arctan",
-      "anchor": "hexcasting:arctan",
-      "input": "num",
-      "output": "num",
-      "text": "hexcasting.page.math.arctan"
-    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:coerce_axial",
@@ -188,6 +124,14 @@
       "input": "vec",
       "output": "vec",
       "text": "hexcasting.page.math.coerce_axial"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:random",
+      "anchor": "hexcasting:random",
+      "input": "",
+      "output": "num",
+      "text": "hexcasting.page.math.random"
     }
   ]
 }
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/meta.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/meta.json
index 4a61f766..3bb0f701 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/meta.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/meta.json
@@ -2,7 +2,7 @@
   "name": "hexcasting.entry.meta",
   "category": "hexcasting:patterns",
   "icon": "minecraft:shulker_box",
-  "sortnum": 10,
+  "sortnum": 12,
   "advancement": "hexcasting:root",
   "read_by_default": true,
   "pages": [
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/readwrite.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/readwrite.json
index 0d671444..7cacf7e4 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/readwrite.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/readwrite.json
@@ -14,6 +14,14 @@
       "output": "any",
       "text": "hexcasting.page.readwrite.read"
     },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:readable",
+      "anchor": "hexcasting:readable",
+      "input": "",
+      "output": "num",
+      "text": "hexcasting.page.readwrite.readable"
+    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:read/entity",
@@ -22,6 +30,14 @@
       "output": "any",
       "text": "hexcasting.page.readwrite.read/entity"
     },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:readable/entity",
+      "anchor": "hexcasting:readable/entity",
+      "input": "entity",
+      "output": "num",
+      "text": "hexcasting.page.readwrite.readable/entity"
+    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:write",
@@ -33,6 +49,14 @@
     {
       "type": "patchouli:text",
       "text": "hexcasting.page.readwrite.write.2"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:writable",
+      "anchor": "hexcasting:writable",
+      "input": "any",
+      "output": "num",
+      "text": "hexcasting.page.readwrite.writable"
     }
   ]
 }
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/sets.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/sets.json
new file mode 100644
index 00000000..293e9d31
--- /dev/null
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/sets.json
@@ -0,0 +1,69 @@
+{
+  "name": "hexcasting.entry.sets",
+  "category": "hexcasting:patterns",
+  "icon": "minecraft:bundle",
+  "sortnum": 11,
+  "advancement": "hexcasting:root",
+  "read_by_default": true,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.sets.numlist"
+    },
+    {
+      "type": "patchouli:empty"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:or_bit",
+      "anchor": "hexcasting:or_bit",
+      "input": "num, num/list, list",
+      "output": "num/list",
+      "text": "hexcasting.page.sets.or.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.sets.or.2"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:and_bit",
+      "anchor": "hexcasting:and_bit",
+      "input": "num, num/list, list",
+      "output": "num/list",
+      "text": "hexcasting.page.sets.and.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.sets.and.2"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:xor_bit",
+      "anchor": "hexcasting:xor_bit",
+      "input": "num, num/list, list",
+      "output": "num/list",
+      "text": "hexcasting.page.sets.xor.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.sets.xor.2"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:not_bit",
+      "anchor": "hexcasting:not_bit",
+      "input": "num",
+      "output": "num",
+      "text": "hexcasting.page.sets.not"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:to_set",
+      "anchor": "hexcasting:to_set",
+      "input": "list",
+      "output": "list",
+      "text": "hexcasting.page.sets.to_set"
+    }
+  ]
+}
diff --git a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/stackmanip.json b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/stackmanip.json
index 679ddc1f..6ddab4c2 100644
--- a/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/stackmanip.json
+++ b/src/main/resources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/patterns/stackmanip.json
@@ -6,6 +6,10 @@
   "advancement": "hexcasting:root",
   "read_by_default": true,
   "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.stackmanip.stack"
+    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:swap",
@@ -22,6 +26,30 @@
       "output": "any",
       "text": "hexcasting.page.stackmanip.fisherman"
     },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:stack_len",
+      "anchor": "hexcasting:stack_len",
+      "input": "",
+      "output": "num",
+      "text": "hexcasting.page.stackmanip.stack_len"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:last_n_list",
+      "anchor": "hexcasting:last_n_list",
+      "input": "many, num",
+      "output": "list",
+      "text": "hexcasting.page.stackmanip.last_n_list"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:splat",
+      "anchor": "hexcasting:splat",
+      "input": "list",
+      "output": "many",
+      "text": "hexcasting.page.stackmanip.splat"
+    },
     {
       "type": "hexcasting:pattern",
       "op_id": "hexcasting:duplicate",
diff --git a/src/main/resources/hexcasting.mixins.json b/src/main/resources/hexcasting.mixins.json
index 28d419c5..eb4c78e9 100644
--- a/src/main/resources/hexcasting.mixins.json
+++ b/src/main/resources/hexcasting.mixins.json
@@ -5,8 +5,9 @@
   "refmap": "hexcasting.mixins.refmap.json",
   "package": "at.petrak.hexcasting.mixin",
   "mixins": [
-    "AccessorLivingEntity",
     "MixinMob",
-    "MixinVillager"
+    "MixinRaider",
+    "MixinVillager",
+    "MixinWitch"
   ]
 }