make the mod

2023-03-11 09:46:34 -06:00 · 2023-03-11 09:46:34 -06:00 · 56bbde734b
commit 56bbde734b
151 changed files with 9055 additions and 0 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,5 @@
+# Disable autocrlf on generated files, they always generate with LF
+# Add any extra files or paths here to make git stop saying they
+# are changed when only line endings change.
+src/generated/**/.cache/cache text eol=lf
+src/generated/**/*.json text eol=lf
--- a/.github/workflows/build_docs.yml
+++ b/.github/workflows/build_docs.yml
@ -0,0 +1,29 @@
+name: Build the Python doc-gen
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  build_docs:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+    - uses: actions/checkout@v3
+    - name: Generate file
+      run: doc/collate_data.py Common/src/main/resources doc/HexCastingResources hexucasting hexucastingbook doc/template.html index.html.uncommitted
+    - name: Check out gh-pages
+      uses: actions/checkout@v3
+      with:
+        clean: false
+        ref: gh_pages
+    - name: Overwrite file and commmit
+      run: |
+          mv index.html.uncommitted index.html
+          git config user.name "Documentation Generation Bot"
+          git config user.email "noreply@github.com"
+          git add index.html
+          git diff-index --quiet HEAD || git commit -m "Update docs at index.html from $GITHUB_REF"
+    - name: Upload changes
+      run: git push
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,32 @@
+# eclipse
+bin
+*.launch
+.settings
+.metadata
+.classpath
+.project
+
+# idea
+out
+*.ipr
+*.iws
+*.iml
+.idea
+
+# gradle
+build
+.gradle
+keys.properties
+changelog.md
+
+# other
+eclipse
+run
+
+# Files from Forge MDK
+forge*changelog.txt
+
+Session.vim
+plot/
+
+doc/out.html
--- a/Common/build.gradle
+++ b/Common/build.gradle
@ -0,0 +1,72 @@
+plugins {
+    id 'org.spongepowered.gradle.vanilla' version '0.2.1-SNAPSHOT'
+}
+
+archivesBaseName = getArtifactID("common")
+
+minecraft {
+    version(minecraftVersion)
+    accessWideners 'src/main/resources/hexucastingplat.accesswidener'
+}
+
+repositories {
+    mavenCentral()
+
+    // If you have mod jar dependencies in ./libs, you can declare them as a repository like so:
+    // flatDir {
+    //     dir 'libs'
+    // }
+
+    maven { url 'https://maven.blamejared.com' }
+
+    maven {
+        // location of the maven that hosts JEI files
+        name = "Progwml6 maven"
+        url = "https://dvs1.progwml6.com/files/maven/"
+    }
+    maven {
+        // location of a maven mirror for JEI files, as a fallback
+        name = "ModMaven"
+        url = "https://modmaven.dev"
+    }
+}
+
+dependencies {
+    compileOnly group: 'org.spongepowered', name: 'mixin', version: '0.8.5'
+    implementation group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.1'
+
+    compileOnly "at.petra-k.paucal:paucal-common-$minecraftVersion:$paucalVersion"
+    compileOnly "at.petra-k.hexcasting:hexcasting-common-$minecraftVersion:$hexcastingVersion"
+    compileOnly "vazkii.patchouli:Patchouli-xplat:$minecraftVersion-$patchouliVersion"
+
+    testImplementation "at.petra-k.paucal:paucal-common-$minecraftVersion:$paucalVersion"
+    testImplementation "at.petra-k.hexcasting:hexcasting-common-$minecraftVersion:$hexcastingVersion"
+    testImplementation "vazkii.patchouli:Patchouli-xplat:$minecraftVersion-$patchouliVersion"
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+}
+
+test {
+    useJUnitPlatform()
+}
+
+processResources {
+    def buildProps = project.properties.clone()
+
+    filesMatching(['pack.mcmeta']) {
+        expand buildProps
+    }
+}
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+setupJar(this)
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/api/HexucastingAPI.java
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/api/HexucastingAPI.java
@ -0,0 +1,33 @@
+package net.touhoudiscord.hexucasting.api;
+
+import com.google.common.base.Suppliers;
+import net.minecraft.resources.ResourceLocation;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.function.Supplier;
+
+public interface HexucastingAPI
+{
+	String MOD_ID = "hexucasting";
+	Logger LOGGER = LogManager.getLogger(MOD_ID);
+	
+	Supplier<HexucastingAPI> INSTANCE = Suppliers.memoize(() -> {
+		try {
+			return (HexucastingAPI) Class.forName("net.touhoudiscord.hexucasting.common.impl.YourModAPIImpl")
+								 .getDeclaredConstructor().newInstance();
+		} catch (ReflectiveOperationException e) {
+			LogManager.getLogger().warn("Unable to find YourModAPIImpl, using a dummy");
+			return new HexucastingAPI() {
+			};
+		}
+	});
+	
+	static HexucastingAPI instance() {
+		return INSTANCE.get();
+	}
+	
+	static ResourceLocation modLoc(String s) {
+		return new ResourceLocation(MOD_ID, s);
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/api/config/HexucastingConfig.kt
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/api/config/HexucastingConfig.kt
@ -0,0 +1,63 @@
+package net.touhoudiscord.hexucasting.api.config
+
+import at.petrak.hexcasting.api.HexAPI
+import net.minecraft.resources.ResourceLocation
+
+object HexucastingConfig {
+    interface CommonConfigAccess { }
+
+    interface ClientConfigAccess { }
+
+    interface ServerConfigAccess { }
+
+    // Simple extensions for resource location configs
+    fun anyMatch(keys: List<String>, key: ResourceLocation): Boolean {
+        for (s in keys) {
+            if (ResourceLocation.isValidResourceLocation(s)) {
+                val rl = ResourceLocation(s)
+                if (rl == key) {
+                    return true
+                }
+            }
+        }
+        return false
+    }
+
+    fun noneMatch(keys: List<String>, key: ResourceLocation): Boolean {
+        return !anyMatch(keys, key)
+    }
+
+    private object DummyCommon : CommonConfigAccess {  }
+    private object DummyClient : ClientConfigAccess {  }
+    private object DummyServer : ServerConfigAccess {  }
+
+    @JvmStatic
+    var common: CommonConfigAccess = DummyCommon
+        set(access) {
+            if (field != DummyCommon) {
+                HexAPI.LOGGER.warn("CommonConfigAccess was replaced! Old {} New {}",
+                        field.javaClass.name, access.javaClass.name)
+            }
+            field = access
+        }
+
+    @JvmStatic
+    var client: ClientConfigAccess = DummyClient
+        set(access) {
+            if (field != DummyClient) {
+                HexAPI.LOGGER.warn("ClientConfigAccess was replaced! Old {} New {}",
+                        field.javaClass.name, access.javaClass.name)
+            }
+            field = access
+        }
+
+    @JvmStatic
+    var server: ServerConfigAccess = DummyServer
+        set(access) {
+            if (field != DummyServer) {
+                HexAPI.LOGGER.warn("ServerConfigAccess was replaced! Old {} New {}",
+                        field.javaClass.name, access.javaClass.name)
+            }
+            field = access
+        }
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/client/RegisterClientStuff.java
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/client/RegisterClientStuff.java
@ -0,0 +1,22 @@
+package net.touhoudiscord.hexucasting.client;
+
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import org.jetbrains.annotations.NotNull;
+import net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions;
+
+public class RegisterClientStuff {
+	public static void init () {
+		var x = IClientXplatAbstractions.INSTANCE;
+	}
+	
+	public static void registerBlockEntityRenderers(@NotNull BlockEntityRendererRegisterer registerer) {
+
+	}
+	
+	@FunctionalInterface
+	public interface BlockEntityRendererRegisterer {
+		<T extends BlockEntity> void registerBlockEntityRenderer(BlockEntityType<T> type, BlockEntityRendererProvider<? super T> berp);
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/Patterns.kt
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/Patterns.kt
@ -0,0 +1,54 @@
+@file:Suppress("unused")
+
+package net.touhoudiscord.hexucasting.common.casting
+
+import at.petrak.hexcasting.api.PatternRegistry
+import at.petrak.hexcasting.api.spell.Action
+import at.petrak.hexcasting.api.spell.iota.PatternIota
+import at.petrak.hexcasting.api.spell.math.HexDir
+import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.common.casting.operators.selectors.*
+import net.minecraft.resources.ResourceLocation
+import net.touhoudiscord.hexucasting.api.HexucastingAPI.modLoc
+import net.touhoudiscord.hexucasting.common.casting.actions.spells.OpDaylightAction
+import net.touhoudiscord.hexucasting.common.casting.actions.spells.OpStarlightAction
+
+object Patterns {
+
+	@JvmField
+	var PATTERNS: MutableList<Triple<HexPattern, ResourceLocation, Action>> = ArrayList()
+	@JvmField
+	var PER_WORLD_PATTERNS: MutableList<Triple<HexPattern, ResourceLocation, Action>> = ArrayList()
+
+	@JvmStatic
+	fun registerPatterns() {
+		try {
+			for ((pattern, location, action) in PATTERNS) {
+				PatternRegistry.mapPattern(pattern, location, action)
+			}
+			for ((pattern, location, action) in PER_WORLD_PATTERNS) {
+				PatternRegistry.mapPattern(pattern, location, action, true)
+			}
+		} catch (e: PatternRegistry.RegisterPatternException) {
+			e.printStackTrace()
+		}
+	}
+
+	// ========================== Examples =================================
+	//@JvmField
+	//val EXAMPLE_CONST = make(HexPattern.fromAngles("qawde", HexDir.SOUTH_WEST), modLoc("patterns/const"), OpExampleConstMediaAction)
+
+	@JvmField
+	val DAYLIGHT = make(HexPattern.fromAngles("wewewewewewaaweedeewedeewedeewedeewedeee", HexDir.EAST), modLoc("spells/daylight"), OpDaylightAction, true)
+	@JvmField
+	val STARLIGHT = make(HexPattern.fromAngles("wwwwwdwewwwewaqaeewaqddqaweeaqwadqwwqda", HexDir.EAST), modLoc("spells/starlight"), OpStarlightAction, true)
+
+	private fun make (pattern: HexPattern, location: ResourceLocation, operator: Action, isPerWorld: Boolean = false): PatternIota {
+		val triple = Triple(pattern, location, operator)
+		if (isPerWorld)
+			PER_WORLD_PATTERNS.add(triple)
+		else
+			PATTERNS.add(triple)
+		return PatternIota(pattern)
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/OpExampleConstMediaAction.kt
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/OpExampleConstMediaAction.kt
@ -0,0 +1,31 @@
+package net.touhoudiscord.hexucasting.common.casting.actions
+
+import at.petrak.hexcasting.api.spell.ConstMediaAction
+import at.petrak.hexcasting.api.spell.asActionResult
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.api.spell.getEntity
+import at.petrak.hexcasting.api.spell.getPlayer
+import at.petrak.hexcasting.api.spell.iota.Iota
+
+object OpExampleConstMediaAction : ConstMediaAction {
+	/**
+	 * The number of arguments from the stack that this action requires.
+	 */
+	override val argc = 1
+
+	/**
+	 * The method called when this Action is actually executed. Accepts the [args]
+	 * that were on the stack (there will be [argc] of them), and the [ctx],
+	 * which contains things like references to the caster, the ServerLevel,
+	 * methods to determine whether locations and entities are in ambit, etc.
+	 * Returns the list of iotas that should be added back to the stack as the
+	 * result of this action executing.
+	 */
+	override fun execute(args: List<Iota>, ctx: CastingContext): List<Iota> {
+		val otherEntity = args.getEntity(0, argc)
+		val isAlly = otherEntity.isAlliedTo(ctx.caster)
+		// all types that can be converted to an iota will have .asActionResult
+		// defined for them to make them easy to return as the result of an Action.
+		return isAlly.asActionResult
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/spells/OpDaylightAction.kt
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/spells/OpDaylightAction.kt
@ -0,0 +1,59 @@
+package net.touhoudiscord.hexucasting.common.casting.actions.spells
+
+import at.petrak.hexcasting.api.misc.MediaConstants
+import at.petrak.hexcasting.api.spell.ParticleSpray
+import at.petrak.hexcasting.api.spell.RenderedSpell
+import at.petrak.hexcasting.api.spell.SpellAction
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.api.spell.getVec3
+import at.petrak.hexcasting.api.spell.iota.Iota
+import at.petrak.hexcasting.xplat.IXplatAbstractions
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.phys.Vec3
+import net.touhoudiscord.hexucasting.api.config.HexucastingConfig
+import net.touhoudiscord.hexucasting.common.casting.actions.OpExampleConstMediaAction.argc
+
+object OpDaylightAction : SpellAction {
+	/**
+	 * The number of arguments from the stack that this action requires.
+	 */
+	override val argc = 0
+
+	/**
+	 * The method called when this Action is actually executed. Accepts the [args]
+	 * that were on the stack (there will be [argc] of them), and the [ctx],
+	 * which contains things like references to the caster, the ServerLevel,
+	 * methods to determine whether locations and entities are in ambit, etc.
+	 * Returns a triple of things. The [RenderedSpell] is responsible for the spell actually
+	 * doing things in the world, the [Int] is how much media the spell should cost,
+	 * and the [List] of [ParticleSpray] renders particle effects for the result of the SpellAction.
+	 *
+	 * The [execute] method should only contain code to find the targets of the spell and validate
+	 * them. All the code that actually makes changes to the world (breaking blocks, teleporting things,
+	 * etc.) should be in the private [Spell] data class below.
+	 */
+	override fun execute(args: List<Iota>, ctx: CastingContext): Triple<RenderedSpell, Int, List<ParticleSpray>> {
+		return Triple(
+			Spell(),
+			MediaConstants.CRYSTAL_UNIT*2,
+			listOf()
+		)
+	}
+
+	/**
+	 * This class is responsible for actually making changes to the world. It accepts parameters to
+	 * define where/what it should affect (for this example the parameter is [vec]), and the
+	 * [cast] method within is responsible for using that data to alter the world.
+	 */
+	private data class Spell(val thisisgivingmeanerrorifidontputsomethinghere: Int = 0) : RenderedSpell {
+		override fun cast(ctx: CastingContext) {
+			val w = ctx.world
+			val relativeTime = w.dayTime%24000
+			if (relativeTime > 23459) {
+				w.dayTime += 24000
+			}
+			w.dayTime = w.dayTime-relativeTime+23459
+		}
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/spells/OpStarlightAction.kt
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/common/casting/actions/spells/OpStarlightAction.kt
@ -0,0 +1,59 @@
+package net.touhoudiscord.hexucasting.common.casting.actions.spells
+
+import at.petrak.hexcasting.api.misc.MediaConstants
+import at.petrak.hexcasting.api.spell.ParticleSpray
+import at.petrak.hexcasting.api.spell.RenderedSpell
+import at.petrak.hexcasting.api.spell.SpellAction
+import at.petrak.hexcasting.api.spell.casting.CastingContext
+import at.petrak.hexcasting.api.spell.getVec3
+import at.petrak.hexcasting.api.spell.iota.Iota
+import at.petrak.hexcasting.xplat.IXplatAbstractions
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.phys.Vec3
+import net.touhoudiscord.hexucasting.api.config.HexucastingConfig
+import net.touhoudiscord.hexucasting.common.casting.actions.OpExampleConstMediaAction.argc
+
+object OpStarlightAction : SpellAction {
+	/**
+	 * The number of arguments from the stack that this action requires.
+	 */
+	override val argc = 0
+
+	/**
+	 * The method called when this Action is actually executed. Accepts the [args]
+	 * that were on the stack (there will be [argc] of them), and the [ctx],
+	 * which contains things like references to the caster, the ServerLevel,
+	 * methods to determine whether locations and entities are in ambit, etc.
+	 * Returns a triple of things. The [RenderedSpell] is responsible for the spell actually
+	 * doing things in the world, the [Int] is how much media the spell should cost,
+	 * and the [List] of [ParticleSpray] renders particle effects for the result of the SpellAction.
+	 *
+	 * The [execute] method should only contain code to find the targets of the spell and validate
+	 * them. All the code that actually makes changes to the world (breaking blocks, teleporting things,
+	 * etc.) should be in the private [Spell] data class below.
+	 */
+	override fun execute(args: List<Iota>, ctx: CastingContext): Triple<RenderedSpell, Int, List<ParticleSpray>> {
+		return Triple(
+			Spell(),
+			MediaConstants.CRYSTAL_UNIT,
+			listOf()
+		)
+	}
+
+	/**
+	 * This class is responsible for actually making changes to the world. It accepts parameters to
+	 * define where/what it should affect (for this example the parameter is [vec]), and the
+	 * [cast] method within is responsible for using that data to alter the world.
+	 */
+	private data class Spell(val thisisgivingmeanerrorifidontputsomethinghere: Int = 0) : RenderedSpell {
+		override fun cast(ctx: CastingContext) {
+			val w = ctx.world
+			val relativeTime = w.dayTime%24000
+			if (relativeTime > 12542) {
+				w.dayTime += 24000
+			}
+			w.dayTime = w.dayTime-relativeTime+12542
+		}
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/xplat/IClientXplatAbstractions.java
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/xplat/IClientXplatAbstractions.java
@ -0,0 +1,53 @@
+package net.touhoudiscord.hexucasting.xplat;
+
+import at.petrak.hexcasting.common.network.IMessage;
+import net.minecraft.client.particle.ParticleProvider;
+import net.minecraft.client.particle.SpriteSet;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.item.ItemPropertyFunction;
+import net.minecraft.client.renderer.texture.AbstractTexture;
+import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.core.particles.ParticleType;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.item.Item;
+import net.touhoudiscord.hexucasting.api.HexucastingAPI;
+
+import java.util.ServiceLoader;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public interface IClientXplatAbstractions {
+	void sendPacketToServer(IMessage packet);
+	
+	void initPlatformSpecific();
+	
+	<T extends Entity> void registerEntityRenderer(EntityType<? extends T> type, EntityRendererProvider<T> renderer);
+	
+	<T extends ParticleOptions> void registerParticleType(ParticleType<T> type,
+														  Function<SpriteSet, ParticleProvider<T>> factory);
+	
+	void registerItemProperty(Item item, ResourceLocation id, ItemPropertyFunction func);
+	
+	// On Forge, these are already exposed; on Fabric we do a mixin
+	void setFilterSave(AbstractTexture texture, boolean filter, boolean mipmap);
+	
+	void restoreLastFilter(AbstractTexture texture);
+	
+	IClientXplatAbstractions INSTANCE = find();
+	
+	private static IClientXplatAbstractions find() {
+		var providers = ServiceLoader.load(IClientXplatAbstractions.class).stream().toList();
+		if (providers.size() != 1) {
+			var names = providers.stream().map(p -> p.type().getName()).collect(
+							Collectors.joining(",", "[", "]"));
+			throw new IllegalStateException(
+							"There should be exactly one IClientXplatAbstractions implementation on the classpath. Found: " + names);
+		} else {
+			var provider = providers.get(0);
+			HexucastingAPI.LOGGER.debug("Instantiating client xplat impl: " + provider.type().getName());
+			return provider.get();
+		}
+	}
+}
--- a/Common/src/main/java/net/touhoudiscord/hexucasting/xplat/IXplatAbstractions.java
+++ b/Common/src/main/java/net/touhoudiscord/hexucasting/xplat/IXplatAbstractions.java
@ -0,0 +1,73 @@
+package net.touhoudiscord.hexucasting.xplat;
+
+import at.petrak.hexcasting.api.HexAPI;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+
+import java.util.ServiceLoader;
+import java.util.stream.Collectors;
+
+public interface IXplatAbstractions {
+//    Platform platform();
+//
+//    boolean isModPresent(String id);
+
+    boolean isPhysicalClient();
+//
+//    void initPlatformSpecific();
+
+    // Blocks
+
+//    <T extends BlockEntity> BlockEntityType<T> createBlockEntityType(BiFunction<BlockPos, BlockState, T> func,
+//        Block... blocks);
+//
+//    boolean tryPlaceFluid(Level level, InteractionHand hand, BlockPos pos, ItemStack stack, Fluid fluid);
+
+
+    // misc
+
+
+//    boolean isCorrectTierForDrops(Tier tier, BlockState bs);
+//
+//    ResourceLocation getID(Block block);
+//
+//    ResourceLocation getID(Item item);
+//
+//    ResourceLocation getID(VillagerProfession profession);
+//
+//    Ingredient getUnsealedIngredient(ItemStack stack);
+//
+//    IXplatTags tags();
+//
+//    LootItemCondition.Builder isShearsCondition();
+//
+//    String getModName(String namespace);
+//
+    boolean isBreakingAllowed(Level level, BlockPos pos, BlockState state, Player player);
+//
+//    boolean isPlacingAllowed(Level world, BlockPos pos, ItemStack blockStack, Player player);
+
+    // interop
+
+//    PehkuiInterop.ApiAbstraction getPehkuiApi();
+
+    ///
+
+    IXplatAbstractions INSTANCE = find();
+
+    private static IXplatAbstractions find() {
+        var providers = ServiceLoader.load(IXplatAbstractions.class).stream().toList();
+        if (providers.size() != 1) {
+            var names = providers.stream().map(p -> p.type().getName()).collect(Collectors.joining(",", "[", "]"));
+            throw new IllegalStateException(
+                "There should be exactly one IXplatAbstractions implementation on the classpath. Found: " + names);
+        } else {
+            var provider = providers.get(0);
+            HexAPI.LOGGER.debug("Instantiating xplat impl: " + provider.type().getName());
+            return provider.get();
+        }
+    }
+
+}
--- a/Common/src/main/resources/assets/hexucasting/lang/en_us.json
+++ b/Common/src/main/resources/assets/hexucasting/lang/en_us.json
@ -0,0 +1,21 @@
+{
+  "hexcasting.spell.hexucasting:spells/daylight": "Daylight",
+  "hexcasting.spell.hexucasting:spells/starlight": "Starlight",
+
+  "hexcasting.spell.book.hexucasting:spells/daylight": "Daylight",
+  "hexcasting.spell.book.hexucasting:spells/starlight": "Starlight",
+
+  "hexucasting.entry.daytime_manip": "Daytime Manipulation",
+  "hexucasting.page.daytime_manip.spells/daylight": "This spell will cast time forward to day in the world I cast it upon. Costs two $(l:items/amethyst)$(item)Charged Amethyst/$",
+  "hexucasting.page.daytime_manip.spells/starlight": "This spell will cast time forward to night in the world I cast it upon. Costs two $(l:items/amethyst)$(item)Charged Amethyst/$",
+
+  "_comment": "Config Entries",
+  "text.autoconfig.hexucasting.title": "Your Mod Configs",
+  "text.autoconfig.hexucasting.category.common": "Common",
+  "text.autoconfig.hexucasting.category.client": "Client",
+  "text.autoconfig.hexucasting.category.server": "Server",
+
+  "text.autoconfig.hexucasting.option.server.exampleSpells": "Example Spells Costs",
+  "text.autoconfig.hexucasting.option.server.exampleSpells.exampleConstActionCost": "Example Const Action Cost",
+  "text.autoconfig.hexucasting.option.server.exampleSpells.exampleSpellActionCost": "Example Spell Action Cost"
+}
--- a/Common/src/main/resources/data/hexucasting/patchouli_books/hexubook/book.json
+++ b/Common/src/main/resources/data/hexucasting/patchouli_books/hexubook/book.json
@ -0,0 +1,6 @@
+{
+  "name": "item.hexcasting.book",
+  "landing_text": "hexcasting.landing",
+  "version": 1,
+  "extend": "hexcasting:thehexbook"
+}
--- a/Common/src/main/resources/data/hexucasting/patchouli_books/hexubook/en_us/entries/patterns/spells/daytime_manip.json
+++ b/Common/src/main/resources/data/hexucasting/patchouli_books/hexubook/en_us/entries/patterns/spells/daytime_manip.json
@ -0,0 +1,26 @@
+{
+  "name": "hexucasting.entry.daytime_manip",
+  "category": "hexcasting:patterns/great_spells",
+  "icon": "minecraft:clock",
+  "sortnum": 8,
+  "advancement": "hexcasting:root",
+  "read_by_default": true,
+  "pages": [
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexucasting:spells/daylight",
+      "anchor": "hexucasting:spells/daylight",
+      "input": "",
+      "output": "",
+      "text": "hexucasting.page.daytime_manip.spells/daylight"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexucasting:spells/starlight",
+      "anchor": "hexucasting:spells/starlight",
+      "input": "",
+      "output": "",
+      "text": "hexucasting.page.daytime_manip.spells/starlight"
+    }
+  ]
+}
--- a/Common/src/main/resources/hexucastingplat.accesswidener
+++ b/Common/src/main/resources/hexucastingplat.accesswidener
@ -0,0 +1,7 @@
+accessWidener  v1  named
+accessible  class net/minecraft/client/renderer/RenderType$CompositeRenderType
+accessible  class net/minecraft/client/renderer/RenderType$CompositeState
+accessible  field net/minecraft/client/renderer/RenderType$CompositeState textureState Lnet/minecraft/client/renderer/RenderStateShard$EmptyTextureStateShard;
+accessible  class net/minecraft/client/renderer/RenderStateShard$EmptyTextureStateShard
+accessible  method net/minecraft/world/entity/projectile/Projectile <init>    (Lnet/minecraft/world/entity/EntityType;Lnet/minecraft/world/level/Level;)V
+extendable  method net/minecraft/server/PlayerAdvancements load (Lnet/minecraft/server/ServerAdvancementManager;)V
--- a/Common/src/main/resources/hexucastingplat.mixins.json
+++ b/Common/src/main/resources/hexucastingplat.mixins.json
@ -0,0 +1,11 @@
+{
+  "minVersion": "0.8",
+  "required": true,
+  "compatibilityLevel": "JAVA_17",
+  "refmap": "hexucasting.mixins.refmap.json",
+  "package": "net.touhoudiscord.hexucasting.mixin",
+  "mixins": [
+  ],
+  "client": [
+  ]
+}
--- a/Common/src/main/resources/logo.png
+++ b/Common/src/main/resources/logo.png
--- a/Common/src/main/resources/pack.mcmeta
+++ b/Common/src/main/resources/pack.mcmeta
@ -0,0 +1,6 @@
+{
+    "pack": {
+        "description": "Your Mod resources",
+        "pack_format": 8
+    }
+}
--- a/Fabric/build.gradle
+++ b/Fabric/build.gradle
@ -0,0 +1,171 @@
+plugins {
+    id 'fabric-loom' version "$loomVersion"
+    id "com.modrinth.minotaur" version "2.+"
+    // It's safest to have this on 2.+ to get the latest features and
+    // bug fixes without having to worry about breaking changes.
+}
+
+archivesBaseName = getArtifactID("fabric")
+
+loom {
+    mixin.defaultRefmapName = "hexucasting.mixins.refmap.json"
+
+    accessWidenerPath = file("src/main/resources/hexucasting.accesswidener")
+
+    runs {
+        client {
+            client()
+            setConfigName("Fabric Client")
+        }
+        server {
+            server()
+            setConfigName("Fabric Server")
+        }
+        datagen {
+            client()
+            vmArg "-Dfabric-api.datagen"
+            vmArg "-Dfabric-api.datagen.modid=${modID}"
+            vmArg "-Dfabric-api.datagen.output-dir=${file("src/generated/resources")}"
+        }
+
+        configureEach {
+            runDir "Fabric/run"
+            ideConfigGenerated(true)
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    maven { url "https://maven.shedaniel.me/" }
+    maven {
+        url 'https://ladysnake.jfrog.io/artifactory/mods'
+    }
+    maven {
+        name "entity reach"
+        url "https://maven.jamieswhiteshirt.com/libs-release/"
+    }
+    maven { url "https://mvn.devos.one/snapshots/" }
+    maven {
+        name = "TerraformersMC"
+        url = "https://maven.terraformersmc.com/"
+    }
+}
+
+dependencies {
+    minecraft "com.mojang:minecraft:${minecraftVersion}"
+    mappings loom.officialMojangMappings()
+    modImplementation("net.fabricmc:fabric-language-kotlin:1.7.4+kotlin.1.6.21")
+    modImplementation "net.fabricmc:fabric-loader:${fabricLoaderVersion}"
+    modImplementation "net.fabricmc.fabric-api:fabric-api:${fabricVersion}"
+
+    // Reqs
+    compileOnly "com.demonwav.mcdev:annotations:1.0"
+
+    implementation group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.1'
+    compileOnly project(":Common")
+
+    modImplementation "at.petra-k.paucal:paucal-fabric-$minecraftVersion:$paucalVersion"
+    modImplementation("at.petra-k.hexcasting:hexcasting-fabric-$minecraftVersion:$hexcastingVersion") {
+        exclude module: "phosphor"
+    }
+    modImplementation "vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion-FABRIC"
+
+    modImplementation "me.zeroeightsix:fiber:$fiberVersion"
+    include "me.zeroeightsix:fiber:$fiberVersion"
+
+    modImplementation "dev.onyxstudios.cardinal-components-api:cardinal-components-api:$cardinalComponentsVersion"
+    include "dev.onyxstudios.cardinal-components-api:cardinal-components-api:$cardinalComponentsVersion"
+
+    modImplementation "com.jamieswhiteshirt:reach-entity-attributes:2.1.1"
+    include "com.jamieswhiteshirt:reach-entity-attributes:2.1.1"
+
+    modImplementation "io.github.tropheusj:serialization-hooks:$serializationHooksVersion"
+    include "io.github.tropheusj:serialization-hooks:$serializationHooksVersion"
+
+    // Optional integrations
+
+    modCompileOnly "me.shedaniel:RoughlyEnoughItems-api-fabric:$reiVersion"
+
+    modApi("me.shedaniel.cloth:cloth-config-fabric:$clothConfigVersion") {
+        exclude(group: "net.fabricmc.fabric-api")
+    }
+
+    modImplementation "dev.emi:emi:${emiVersion}"
+
+    modImplementation "maven.modrinth:gravity-api:$gravityApiVersion"
+    modApi("com.github.Virtuoel:Pehkui:${pehkuiVersion}", {
+        exclude group: "net.fabricmc.fabric-api"
+    })
+
+    implementation 'org.jetbrains:annotations:23.0.0'
+
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+}
+
+tasks.withType(JavaCompile) {
+    source(project(":Common").sourceSets.main.allSource)
+}
+compileKotlin {
+    source(project(":Common").sourceSets.main.kotlin)
+}
+
+sourcesJar {
+    from project(":Common").sourceSets.main.allJava
+}
+
+sourceSets {
+    main.resources.srcDirs += ['src/generated/resources', '../Common/src/generated/resources']
+}
+
+processResources {
+    from project(":Common").sourceSets.main.resources
+    inputs.property "version", project.version
+
+    filesMatching("fabric.mod.json") {
+        expand "version": project.version
+    }
+}
+
+def loadProperties = { filename ->
+    def properties = new Properties()
+    rootProject.file(filename).withInputStream {
+        properties.load(it)
+    }
+    return properties
+}
+
+/**
+ * To setup automatic modrinth exporting, get your API key from the modrinth website and place it in a
+ * file in the root project directory called keys.properties
+ * e.g.
+ * MODRINTH_TOKEN=exampletoken
+ * Then, uncomment the modrinth blocks in every build.gradle. When you run the modrinth build task
+ * in the base project task space, it will upload both Forge and Fabric versions of the mod to
+ * modrinth automatically, with the changelog from the changelog.md file in the base project directory.
+ */
+//modrinth {
+//    token = loadProperties("keys.properties").MODRINTH_TOKEN
+//    projectId = "$modID" // This can be the project ID or the slug. Either will work!
+//    versionNumber = "$modVersion" // You don't need to set this manually. Will fail if Modrinth has this version already
+//    versionName = "$modVersion-fabric"
+//    changelog = rootProject.file("changelog.md").text
+//
+//    versionType = "release" // This is the default -- can also be `beta` or `alpha`
+//    uploadFile = remapJar // With Loom, this MUST be set to `remapJar` instead of `jar`!
+//    gameVersions = ["1.19.2"] // Must be an array, even with only one version
+//    loaders = ["fabric"] // Must also be an array - no need to specify this if you're using Loom or ForgeGradle
+//    dependencies { // A special DSL for creating dependencies
+//        // scope.type
+//        // The scope can be `required`, `optional`, `incompatible`, or `embedded`
+//        // The type can either be `project` or `version`
+//        required.project "hex-casting" // Creates a new required dependency on Hex Casting
+//        required.project "paucal"
+//        required.project "patchouli"
+//        required.project "fabric-language-kotlin"
+//        required.project "cardinal-components-api"
+//    }
+//}
+
+setupJar(this)
--- a/Fabric/gradle.properties
+++ b/Fabric/gradle.properties
@ -0,0 +1,14 @@
+loomVersion=1.0-SNAPSHOT
+fabricVersion=0.64.0+1.19.2
+fabricLoaderVersion=0.14.10
+
+fiberVersion=0.23.0-2
+cardinalComponentsVersion=5.0.2
+serializationHooksVersion=0.3.24
+entityReachVersion=2.3.0
+
+reiVersion=8.0.442
+emiVersion=0.4.0+1.19
+gravityApiVersion=0.7.12+fabric
+clothConfigVersion=8.2.88
+trinketsVersion=3.4.0
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingClientInitializer.kt
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingClientInitializer.kt
@ -0,0 +1,20 @@
+package net.touhoudiscord.hexucasting.fabric
+
+import net.fabricmc.api.ClientModInitializer
+import net.fabricmc.fabric.api.client.rendering.v1.BlockEntityRendererRegistry
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityType
+import net.touhoudiscord.hexucasting.client.RegisterClientStuff
+
+object FabricHexucastingClientInitializer : ClientModInitializer {
+    override fun onInitializeClient() {
+        RegisterClientStuff.init()
+
+        RegisterClientStuff.registerBlockEntityRenderers(object : RegisterClientStuff.BlockEntityRendererRegisterer {
+            override fun <T : BlockEntity> registerBlockEntityRenderer(type: BlockEntityType<T>, berp: BlockEntityRendererProvider<in T>) {
+                BlockEntityRendererRegistry.register(type, berp)
+            }
+        })
+    }
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingConfig.java
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingConfig.java
@ -0,0 +1,54 @@
+package net.touhoudiscord.hexucasting.fabric;
+
+import at.petrak.hexcasting.api.misc.MediaConstants;
+import me.shedaniel.autoconfig.AutoConfig;
+import me.shedaniel.autoconfig.ConfigData;
+import me.shedaniel.autoconfig.annotation.Config;
+import me.shedaniel.autoconfig.annotation.ConfigEntry;
+import me.shedaniel.autoconfig.serializer.JanksonConfigSerializer;
+import me.shedaniel.autoconfig.serializer.PartitioningSerializer;
+import net.touhoudiscord.hexucasting.api.HexucastingAPI;
+import net.touhoudiscord.hexucasting.api.config.HexucastingConfig;
+import net.touhoudiscord.hexucasting.xplat.IXplatAbstractions;
+
+@SuppressWarnings({"FieldCanBeLocal", "FieldMayBeFinal"})
+@Config(name = HexucastingAPI.MOD_ID)
+@Config.Gui.Background("minecraft:textures/block/calcite.png")
+public class FabricHexucastingConfig extends PartitioningSerializer.GlobalData {
+    @ConfigEntry.Category("common")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Common common = new Common();
+    @ConfigEntry.Category("client")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Client client = new Client();
+    @ConfigEntry.Category("server")
+    @ConfigEntry.Gui.TransitiveObject
+    public final Server server = new Server();
+
+    public static FabricHexucastingConfig setup() {
+        AutoConfig.register(FabricHexucastingConfig.class, PartitioningSerializer.wrap(JanksonConfigSerializer::new));
+        var instance = AutoConfig.getConfigHolder(FabricHexucastingConfig.class).getConfig();
+
+        HexucastingConfig.setCommon(instance.common);
+        // We care about the client only on the *physical* client ...
+        if (IXplatAbstractions.INSTANCE.isPhysicalClient()) {
+            HexucastingConfig.setClient(instance.client);
+        }
+        // but we care about the server on the *logical* server
+        // i believe this should Just Work without a guard? assuming we don't access it from the client ever
+        HexucastingConfig.setServer(instance.server);
+
+        return instance;
+    }
+
+
+    @Config(name = "common")
+    private static class Common implements ConfigData, HexucastingConfig.CommonConfigAccess { }
+
+    @Config(name = "client")
+    private static class Client implements ConfigData, HexucastingConfig.ClientConfigAccess { }
+
+
+    @Config(name = "server")
+    private static class Server implements ConfigData, HexucastingConfig.ServerConfigAccess { }
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingInitializer.kt
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/FabricHexucastingInitializer.kt
@ -0,0 +1,31 @@
+package net.touhoudiscord.hexucasting.fabric
+
+import net.fabricmc.api.ModInitializer
+import net.minecraft.core.Registry
+import net.minecraft.resources.ResourceLocation
+import net.touhoudiscord.hexucasting.api.HexucastingAPI
+import net.touhoudiscord.hexucasting.common.casting.Patterns
+import java.util.function.BiConsumer
+
+object FabricHexucastingInitializer : ModInitializer {
+
+    override fun onInitialize() {
+        HexucastingAPI.LOGGER.info("Hello Fabric World!")
+
+        FabricHexucastingConfig.setup()
+
+        initListeners()
+
+        initRegistries()
+
+        Patterns.registerPatterns()
+    }
+
+    private fun initListeners() {}
+
+    private fun initRegistries() {}
+
+
+    private fun <T> bind(registry: Registry<in T>): BiConsumer<T, ResourceLocation> =
+        BiConsumer<T, ResourceLocation> { t, id -> Registry.register(registry, id, t) }
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/ModMenuInterop.kt
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/ModMenuInterop.kt
@ -0,0 +1,16 @@
+package net.touhoudiscord.hexucasting.fabric.interop
+
+import com.terraformersmc.modmenu.api.ConfigScreenFactory
+import com.terraformersmc.modmenu.api.ModMenuApi
+import me.shedaniel.autoconfig.AutoConfig
+import net.fabricmc.api.EnvType
+import net.fabricmc.api.Environment
+import net.minecraft.client.gui.screens.Screen
+import net.touhoudiscord.hexucasting.fabric.FabricHexucastingConfig
+
+@Environment(EnvType.CLIENT)
+class ModMenuInterop : ModMenuApi {
+    override fun getModConfigScreenFactory(): ConfigScreenFactory<*> {
+        return ConfigScreenFactory { parent: Screen -> AutoConfig.getConfigScreen(FabricHexucastingConfig::class.java, parent).get() }
+    }
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/emi/HexucastingEMIPlugin.java
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/emi/HexucastingEMIPlugin.java
@ -0,0 +1,12 @@
+package net.touhoudiscord.hexucasting.fabric.interop.emi;
+
+import dev.emi.emi.api.EmiPlugin;
+import dev.emi.emi.api.EmiRegistry;
+
+public class HexucastingEMIPlugin implements EmiPlugin {
+	
+	@Override
+	public void register (EmiRegistry registry) {
+		return;
+	}
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/rei/HexucastingREIPlugin.java
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/interop/rei/HexucastingREIPlugin.java
@ -0,0 +1,15 @@
+package net.touhoudiscord.hexucasting.fabric.interop.rei;
+
+import me.shedaniel.rei.api.client.plugins.REIClientPlugin;
+import me.shedaniel.rei.api.client.registry.category.CategoryRegistry;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+@Environment(EnvType.CLIENT)
+public class HexucastingREIPlugin implements REIClientPlugin {
+	
+	@Override
+	public void registerCategories (CategoryRegistry registry) {
+		return;
+	}
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/xplat/FabricClientXplatImpl.java
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/xplat/FabricClientXplatImpl.java
@ -0,0 +1,77 @@
+package net.touhoudiscord.hexucasting.fabric.xplat;
+
+import at.petrak.hexcasting.common.network.IMessage;
+import at.petrak.hexcasting.fabric.client.ExtendedTexture;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.client.particle.v1.ParticleFactoryRegistry;
+import net.fabricmc.fabric.api.client.rendering.v1.EntityRendererRegistry;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.particle.ParticleProvider;
+import net.minecraft.client.particle.SpriteSet;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.item.ClampedItemPropertyFunction;
+import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.client.renderer.item.ItemPropertyFunction;
+import net.minecraft.client.renderer.texture.AbstractTexture;
+import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.core.particles.ParticleType;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.Nullable;
+import net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions;
+
+import java.util.function.Function;
+
+public class FabricClientXplatImpl implements IClientXplatAbstractions {
+	@Override
+	public void sendPacketToServer (IMessage packet) {
+		ClientPlayNetworking.send(packet.getFabricId(), packet.toBuf());
+	}
+	
+	@Override
+	public void initPlatformSpecific () {
+	
+	}
+	
+	@Override
+	public <T extends Entity> void registerEntityRenderer (EntityType<? extends T> type, EntityRendererProvider<T> renderer) {
+		EntityRendererRegistry.register(type, renderer);
+	}
+	
+	@Override
+	public <T extends ParticleOptions> void registerParticleType (ParticleType<T> type, Function<SpriteSet, ParticleProvider<T>> factory) {
+		ParticleFactoryRegistry.getInstance().register(type, factory::apply);
+	}
+	
+	// suck it fabric trying to be "safe"
+	private record UnclampedClampedItemPropFunc(ItemPropertyFunction inner) implements ClampedItemPropertyFunction {
+		@Override
+		public float unclampedCall (ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int seed) {
+			return inner.call(stack, level, entity, seed);
+		}
+		
+		@Override
+		public float call (ItemStack stack, @Nullable ClientLevel level, @Nullable LivingEntity entity, int seed) {
+			return this.unclampedCall(stack, level, entity, seed);
+		}
+	}
+	
+	@Override
+	public void registerItemProperty (Item item, ResourceLocation id, ItemPropertyFunction func) {
+		ItemProperties.register(item, id, new UnclampedClampedItemPropFunc(func));
+	}
+	
+	@Override
+	public void setFilterSave (AbstractTexture texture, boolean filter, boolean mipmap) {
+		((ExtendedTexture) texture).setFilterSave(filter, mipmap);
+	}
+	
+	@Override
+	public void restoreLastFilter (AbstractTexture texture) {
+		((ExtendedTexture) texture).restoreLastFilter();
+	}
+}
--- a/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/xplat/FabricXplatImpl.java
+++ b/Fabric/src/main/java/net/touhoudiscord/hexucasting/fabric/xplat/FabricXplatImpl.java
@ -0,0 +1,181 @@
+package net.touhoudiscord.hexucasting.fabric.xplat;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.touhoudiscord.hexucasting.xplat.IXplatAbstractions;
+
+public class FabricXplatImpl implements IXplatAbstractions {
+//    @Override
+//    public Platform platform() {
+//        return Platform.FABRIC;
+//    }
+
+    @Override
+    public boolean isPhysicalClient() {
+        return FabricLoader.getInstance().getEnvironmentType() == EnvType.CLIENT;
+    }
+//
+//    @Override
+//    public boolean isModPresent(String id) {
+//        return FabricLoader.getInstance().isModLoaded(id);
+//    }
+//
+//    @Override
+//    public void initPlatformSpecific() {
+//        if (this.isModPresent(HexInterop.Fabric.GRAVITY_CHANGER_API_ID)) {
+//            GravityApiInterop.init();
+//        }
+//        if (this.isModPresent(HexInterop.Fabric.TRINKETS_API_ID)) {
+//            TrinketsApiInterop.init();
+//        }
+//    }
+
+//    @Override
+//    public double getReachDistance(Player player) {
+//        return ReachEntityAttributes.getReachDistance(player, 5.0);
+//    }
+
+    @Override
+    public boolean isBreakingAllowed (Level level, BlockPos pos, BlockState state, Player player) {
+        return PlayerBlockBreakEvents.BEFORE.invoker().beforeBlockBreak(level, player, pos, state, level.getBlockEntity(pos));
+    }
+    
+    //    @Override
+//    public <T extends BlockEntity> BlockEntityType<T> createBlockEntityType(BiFunction<BlockPos, BlockState, T> func,
+//        Block... blocks) {
+//        return FabricBlockEntityTypeBuilder.create(func::apply, blocks).build();
+//    }
+//
+//    @Override
+//    @SuppressWarnings("UnstableApiUsage")
+//    public boolean tryPlaceFluid(Level level, InteractionHand hand, BlockPos pos, ItemStack stack, Fluid fluid) {
+//        Storage<FluidVariant> target = FluidStorage.SIDED.find(level, pos, Direction.UP);
+//        Storage<FluidVariant> emptyFrom = FluidStorage.ITEM.find(stack, ContainerItemContext.withInitial(stack));
+//        return StorageUtil.move(emptyFrom, target, (f) -> true, FluidConstants.BUCKET, null) > 0;
+//    }
+//
+//    @Override
+//    public ResourceLocation getID(Block block) {
+//        return Registry.BLOCK.getKey(block);
+//    }
+//
+//    @Override
+//    public ResourceLocation getID(Item item) {
+//        return Registry.ITEM.getKey(item);
+//    }
+//
+//    @Override
+//    public ResourceLocation getID(VillagerProfession profession) {
+//        return Registry.VILLAGER_PROFESSION.getKey(profession);
+//    }
+//
+//    @Override
+//    public Ingredient getUnsealedIngredient(ItemStack stack) {
+//        return FabricUnsealedIngredient.of(stack);
+//    }
+//
+//    private static CreativeModeTab TAB = null;
+//
+//    @Override
+//    public CreativeModeTab getTab() {
+//        if (TAB == null) {
+//            TAB = FabricItemGroupBuilder.create(modLoc("creative_tab"))
+//                .icon(HexItems::tabIcon)
+//                .build();
+//        }
+//
+//        return TAB;
+//    }
+//
+//    // do a stupid hack from botania
+//    private static List<ItemStack> stacks(Item... items) {
+//        return Stream.of(items).map(ItemStack::new).toList();
+//    }
+//
+//    private static final List<List<ItemStack>> HARVEST_TOOLS_BY_LEVEL = List.of(
+//        stacks(Items.WOODEN_PICKAXE, Items.WOODEN_AXE, Items.WOODEN_HOE, Items.WOODEN_SHOVEL),
+//        stacks(Items.STONE_PICKAXE, Items.STONE_AXE, Items.STONE_HOE, Items.STONE_SHOVEL),
+//        stacks(Items.IRON_PICKAXE, Items.IRON_AXE, Items.IRON_HOE, Items.IRON_SHOVEL),
+//        stacks(Items.DIAMOND_PICKAXE, Items.DIAMOND_AXE, Items.DIAMOND_HOE, Items.DIAMOND_SHOVEL),
+//        stacks(Items.NETHERITE_PICKAXE, Items.NETHERITE_AXE, Items.NETHERITE_HOE, Items.NETHERITE_SHOVEL)
+//    );
+//
+//    @Override
+//    public boolean isCorrectTierForDrops(Tier tier, BlockState bs) {
+//        if (!bs.requiresCorrectToolForDrops()) {
+//            return true;
+//        }
+//
+//        int level = HexConfig.server()
+//            .opBreakHarvestLevelBecauseForgeThoughtItWasAGoodIdeaToImplementHarvestTiersUsingAnHonestToGodTopoSort();
+//        for (var tool : HARVEST_TOOLS_BY_LEVEL.get(level)) {
+//            if (tool.isCorrectToolForDrops(bs)) {
+//                return true;
+//            }
+//        }
+//
+//        return false;
+//    }
+//
+//    @Override
+//    public Item.Properties addEquipSlotFabric(EquipmentSlot slot) {
+//        return new FabricItemSettings().equipmentSlot(s -> slot);
+//    }
+//
+//    private static final IXplatTags TAGS = new IXplatTags() {
+//        @Override
+//        public TagKey<Item> amethystDust() {
+//            return HexItemTags.create(new ResourceLocation("c", "amethyst_dusts"));
+//        }
+//
+//        @Override
+//        public TagKey<Item> gems() {
+//            return HexItemTags.create(new ResourceLocation("c", "gems"));
+//        }
+//    };
+//
+//    @Override
+//    public IXplatTags tags() {
+//        return TAGS;
+//    }
+//
+//    @Override
+//    public LootItemCondition.Builder isShearsCondition() {
+//        return AlternativeLootItemCondition.alternative(
+//            MatchTool.toolMatches(ItemPredicate.Builder.item().of(Items.SHEARS)),
+//            MatchTool.toolMatches(ItemPredicate.Builder.item().of(
+//                HexItemTags.create(new ResourceLocation("c", "shears"))))
+//        );
+//    }
+//
+//    @Override
+//    public String getModName(String namespace) {
+//        if (namespace.equals("c")) {
+//            return "Common";
+//        }
+//        Optional<ModContainer> container = FabricLoader.getInstance().getModContainer(namespace);
+//        if (container.isPresent()) {
+//            return container.get().getMetadata().getName();
+//        }
+//        return namespace;
+//    }
+//
+//    @Override
+//    public boolean isBreakingAllowed(Level world, BlockPos pos, BlockState state, Player player) {
+//        return PlayerBlockBreakEvents.BEFORE.invoker().beforeBlockBreak(world, player, pos, state, world.getBlockEntity(pos));
+//    }
+//
+//    @Override
+//    public boolean isPlacingAllowed(Level world, BlockPos pos, ItemStack blockStack, Player player) {
+//        ItemStack cached = player.getMainHandItem();
+//        player.setItemInHand(InteractionHand.MAIN_HAND, blockStack.copy());
+//        var success = UseItemCallback.EVENT.invoker().interact(player, world, InteractionHand.MAIN_HAND);
+//        player.setItemInHand(InteractionHand.MAIN_HAND, cached);
+//        return success.getResult() == InteractionResult.PASS; // No other mod tried to consume this
+//    }
+}
--- a/Fabric/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions
+++ b/Fabric/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions
@ -0,0 +1 @@
+net.touhoudiscord.hexucasting.fabric.xplat.FabricClientXplatImpl
--- a/Fabric/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IXplatAbstractions
+++ b/Fabric/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IXplatAbstractions
@ -0,0 +1 @@
+net.touhoudiscord.hexucasting.fabric.xplat.FabricXplatImpl
--- a/Fabric/src/main/resources/borp.png
+++ b/Fabric/src/main/resources/borp.png
--- a/Fabric/src/main/resources/fabric.mod.json
+++ b/Fabric/src/main/resources/fabric.mod.json
@ -0,0 +1,59 @@
+{
+  "schemaVersion": 1,
+  "id": "hexucasting",
+  "version": "${version}",
+
+  "name": "Hexucasting",
+  "description": "we do a little ruining it",
+  "authors": [
+    "Hexugory"
+  ],
+  "contact": {
+    "homepage": "",
+    "sources": "https://git.touhoudiscord.net/Hexugory/hexucasting"
+  },
+
+  "license": "MIT",
+  "icon": "borp.png",
+
+  "environment": "*",
+  "entrypoints": {
+    "main": [
+      {"adapter": "kotlin", "value": "net.touhoudiscord.hexucasting.fabric.FabricHexucastingInitializer"}
+    ],
+    "client": [
+      {"adapter": "kotlin", "value": "net.touhoudiscord.hexucasting.fabric.FabricHexucastingClientInitializer"}
+    ],
+    "rei_client": [
+      "net.touhoudiscord.hexucasting.fabric.interop.rei.HexucastingREIPlugin"
+    ],
+    "emi": [
+      "net.touhoudiscord.hexucasting.fabric.interop.emi.HexucastingEMIPlugin"
+    ],
+    "modmenu": [
+      "net.touhoudiscord.hexucasting.fabric.interop.ModMenuInterop"
+    ]
+  },
+  "mixins": [
+    "hexucastingplat.mixins.json",
+    "hexucasting.mixins.json"
+  ],
+  "accessWidener": "hexucasting.accesswidener",
+
+  "depends": {
+    "minecraft": "=1.19.2",
+    "java": ">=17",
+    "fabricloader": ">=0.14",
+    "fabric": ">=0.64",
+    "fabric-language-kotlin": ">=1.7.4+kotlin.1.6.21",
+    "cardinal-components": ">=5.0.2",
+    "patchouli": ">=1.19.2-77",
+    "paucal": "0.5.x",
+    "hexcasting": ">=0.10.3"
+  },
+
+  "custom": {
+    "cardinal-components": [
+    ]
+  }
+}
--- a/Fabric/src/main/resources/hexucasting.accesswidener
+++ b/Fabric/src/main/resources/hexucasting.accesswidener
@ -0,0 +1,13 @@
+accessWidener  v1  named
+extendable  class  net/minecraft/world/item/crafting/Ingredient
+accessible  class  net/minecraft/world/item/crafting/Ingredient$ItemValue
+accessible  class  net/minecraft/world/item/crafting/Ingredient$TagValue
+accessible  class  net/minecraft/world/item/crafting/Ingredient$Value
+accessible  method net/minecraft/world/item/crafting/Ingredient$ItemValue <init> (Lnet/minecraft/world/item/ItemStack;)V
+accessible  method net/minecraft/world/item/crafting/Ingredient$TagValue <init> (Lnet/minecraft/tags/TagKey;)V
+accessible  method net/minecraft/world/item/crafting/Ingredient <init> (Ljava/util/stream/Stream;)V
+accessible  class net/minecraft/client/renderer/RenderType$CompositeRenderType
+accessible  class net/minecraft/client/renderer/RenderType$CompositeState
+accessible  field net/minecraft/client/renderer/RenderType$CompositeState textureState Lnet/minecraft/client/renderer/RenderStateShard$EmptyTextureStateShard;
+accessible  class net/minecraft/client/renderer/RenderStateShard$EmptyTextureStateShard
+accessible  method net/minecraft/world/entity/projectile/Projectile <init> (Lnet/minecraft/world/entity/EntityType;Lnet/minecraft/world/level/Level;)V
--- a/Fabric/src/main/resources/hexucasting.mixins.json
+++ b/Fabric/src/main/resources/hexucasting.mixins.json
@ -0,0 +1,13 @@
+{
+  "minVersion": "0.8",
+  "required": true,
+  "compatibilityLevel": "JAVA_17",
+  "refmap": "hexucasting.mixins.refmap.json",
+  "package": "net.touhoudiscord.hexucasting.fabric.mixin",
+  "mixins": [
+
+  ],
+  "client": [
+
+  ]
+}
--- a/Forge/build.gradle
+++ b/Forge/build.gradle
@ -0,0 +1,314 @@
+buildscript {
+    repositories {
+        maven { url = 'https://maven.minecraftforge.net' }
+        maven {
+            url = 'https://repo.spongepowered.org/repository/maven-public/'
+            content { includeGroup "org.spongepowered" }
+        }
+        mavenCentral()
+    }
+    dependencies {
+        classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
+        classpath 'org.spongepowered:mixingradle:0.7-SNAPSHOT'
+    }
+}
+
+plugins {
+    id "com.modrinth.minotaur" version "2.+"
+    // It's safest to have this on 2.+ to get the latest features and
+    // bug fixes without having to worry about breaking changes.
+}
+
+apply plugin: 'net.minecraftforge.gradle'
+apply plugin: 'org.spongepowered.mixin'
+
+archivesBaseName = getArtifactID("forge")
+
+println "asdf"
+
+// Adds KFF as dependency and Kotlin libs to the runtime classpath
+// 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-${kotlinForForgeVersion}.gradle"
+
+minecraft {
+    mappings channel: 'official', version: minecraftVersion
+    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+
+    if (project.hasProperty('forge_ats_enabled') && project.findProperty('forge_ats_enabled').toBoolean()) {
+        // This location is hardcoded in Forge and can not be changed.
+        // https://github.com/MinecraftForge/MinecraftForge/blob/be1698bb1554f9c8fa2f58e32b9ab70bc4385e60/fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFile.java#L123
+        accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+        project.logger.debug('Forge Access Transformers are enabled for this project.')
+    }
+
+    runs {
+        client {
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            mods {
+                create(modID) {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+
+        server {
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            mods {
+                create(modID) {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+
+        // 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')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+
+            // 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'
+
+            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
+            property 'forge.enabledGameTestNamespaces', 'hexucasting'
+
+            mods {
+                create(modID) {
+                    source sourceSets.main
+                    source sourceSets.test
+                    source project(":Common").sourceSets.test
+                }
+            }
+        }
+
+        // We have to have a dummy data run to be parented from
+        data {}
+
+        xplatDatagen {
+            parent minecraft.runs.data
+
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            args '--mod', modID, '--all', '--output', file('../Common/src/generated/resources/'), '--existing', file('../Common/src/main/resources/')
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            property 'hexucasting.xplat_datagen', 'true'
+            mods {
+                create(modID) {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+
+        forgeDatagen {
+            parent minecraft.runs.data
+
+            workingDirectory project.file('run')
+            ideaModule "${rootProject.name}.${project.name}.main"
+            args '--mod', modID, '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
+            property 'mixin.env.remapRefMap', 'true'
+            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
+            property 'hexucasting.forge_datagen', 'true'
+            mods {
+                create(modID) {
+                    source sourceSets.main
+                    source project(":Common").sourceSets.main
+                }
+            }
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    // Put repositories for dependencies here
+    // ForgeGradle automatically adds the Forge maven and Maven Central for you
+
+    // If you have mod jar dependencies in ./libs, you can declare them as a repository like so:
+     flatDir {
+         dir 'libs'
+     }
+
+    maven {
+        // location of the maven that hosts JEI files
+        name = "Progwml6 maven"
+        url = "https://dvs1.progwml6.com/files/maven/"
+    }
+    maven {
+        // location of a maven mirror for JEI files, as a fallback
+        name = "ModMaven"
+        url = "https://modmaven.dev"
+    }
+}
+
+dependencies {
+    // 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:${minecraftVersion}-${forgeVersion}"
+    compileOnly project(":Common")
+
+    annotationProcessor 'org.spongepowered:mixin:0.8.5:processor'
+
+    compileOnly fg.deobf("at.petra-k.paucal:paucal-forge-$minecraftVersion:$paucalVersion")
+    runtimeOnly fg.deobf("at.petra-k.paucal:paucal-forge-$minecraftVersion:$paucalVersion")
+    compileOnly fg.deobf("${modID}:hexcasting-forge-$minecraftVersion:$hexcastingVersion")
+    runtimeOnly fg.deobf("${modID}:hexcasting-forge-$minecraftVersion:$hexcastingVersion")
+
+    compileOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion")
+    runtimeOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion")
+
+    // Testing dependencies:
+    testCompileOnly project(":Common")
+
+    testAnnotationProcessor 'org.spongepowered:mixin:0.8.5:processor'
+
+    testCompileOnly fg.deobf("at.petra-k.paucal:paucal-forge-$minecraftVersion:$paucalVersion")
+    testRuntimeOnly fg.deobf("at.petra-k.paucal:paucal-forge-$minecraftVersion:$paucalVersion")
+    testCompileOnly fg.deobf("${modID}:hexcasting-forge-$minecraftVersion:$hexcastingVersion")
+    testRuntimeOnly fg.deobf("${modID}:hexcasting-forge-$minecraftVersion:$hexcastingVersion")
+    testCompileOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion")
+    testRuntimeOnly fg.deobf("vazkii.patchouli:Patchouli:$minecraftVersion-$patchouliVersion")
+
+    testCompileOnly 'org.junit.jupiter:junit-jupiter-api:5.9.0'
+    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
+}
+
+mixin {
+    add sourceSets.main, "hexucasting.mixins.refmap.json"
+    add sourceSets.test, "hexucasting.test.mixins.refmap.json"
+    config "hexucastingplat.mixins.json"
+    config "hexucasting_forge.mixins.json"
+}
+
+tasks.withType(JavaCompile) {
+    source(project(":Common").sourceSets.main.allSource)
+}
+compileKotlin {
+    source(project(":Common").sourceSets.main.kotlin)
+}
+compileTestKotlin {
+    source(project(":Common").sourceSets.test.kotlin)
+}
+
+// This task is here for debugging purposes, running it tells you what directories each sourceSet is setup to look at.
+task printSourceSetInformation(){
+    doLast{
+        sourceSets.each { srcSet ->
+            println "["+srcSet.name+"]"
+            print "-->Java Source directories: "+srcSet.allJava.srcDirs+"\n"
+            print "-->Kotlin Source directories: "+srcSet.kotlin.srcDirs+"\n"
+            print "-->Resource directories: "+srcSet.resources.srcDirs+"\n"
+            print "-->Output directories: "+srcSet.output.classesDirs.files+"\n"
+//            print "-->Compile classpath:\n"
+//            srcSet.compileClasspath.files.each {
+//                print "  "+it.path+"\n"
+//            }
+            println ""
+        }
+    }
+}
+
+
+// https://discord.com/channels/313125603924639766/733055378371117127/980968358658838540
+// > It won't generate a refmap if there are no changes source files
+// > Since the last build
+// > Gradle task execution avoidance breaks it that way
+// > At one point i got it to work reliably but forcing some specific task to always run i just don't remember the syntax and which task it was
+// > It might have been compileJava
+build {
+    println "Forcing re-compile of Java to include refmap"
+    tasks.withType(JavaCompile) {
+        outputs.upToDateWhen { false }
+    }
+    compileKotlin {
+        outputs.upToDateWhen { false }
+    }
+}
+
+sourceSets {
+    main.resources.srcDirs += ['src/generated/resources', '../Common/src/generated/resources']
+    test.resources.srcDirs += ['src/generated/resources', '../Common/src/generated/resources', 'src/main/resources', '../Common/src/main/resources']
+    main.kotlin.srcDirs += 'src/main/java'
+    test.kotlin.srcDirs += 'src/main/java'
+}
+
+processResources {
+    from project(":Common").sourceSets.main.resources
+    inputs.property "version", project.version
+
+    filesMatching("mods.toml") {
+        expand "version": project.version
+    }
+}
+
+processTestResources {
+    from project(":Common").sourceSets.test.resources
+    inputs.property "version", project.version
+
+    filesMatching("mods.toml") {
+        expand "version": project.version
+    }
+}
+
+def loadProperties = { filename ->
+    def properties = new Properties()
+    rootProject.file(filename).withInputStream {
+        properties.load(it)
+    }
+    return properties
+}
+
+/**
+ * To setup automatic modrinth exporting, get your API key from the modrinth website and place it in a
+ * file in the root project directory called keys.properties
+ * e.g.
+ * MODRINTH_TOKEN=exampletoken
+ * Then, uncomment the modrinth blocks in every build.gradle. When you run the modrinth build task
+ * in the base project task space, it will upload both Forge and Fabric versions of the mod to
+ * modrinth automatically, with the changelog from the changelog.md file in the base project directory.
+ */
+//modrinth {
+//    token = loadProperties("keys.properties").MODRINTH_TOKEN
+//    projectId = "$modID" // This can be the project ID or the slug. Either will work!
+//    versionNumber = "$modVersion" // You don't need to set this manually. Will fail if Modrinth has this version already
+//    versionName = "$modVersion-forge"
+//    changelog = rootProject.file("changelog.md").text
+//    versionType = "release" // This is the default -- can also be `beta` or `alpha`
+//    uploadFile = jar // With Loom, this MUST be set to `remapJar` instead of `jar`!
+//    gameVersions = ["1.19.2"] // Must be an array, even with only one version
+//    loaders = ["forge"] // Must also be an array - no need to specify this if you're using Loom or ForgeGradle
+//    dependencies { // A special DSL for creating dependencies
+//        // scope.type
+//        // The scope can be `required`, `optional`, `incompatible`, or `embedded`
+//        // The type can either be `project` or `version`
+//        required.project "hex-casting" // Creates a new required dependency on Hex Casting
+//        required.project "paucal"
+//        required.project "patchouli"
+//        required.project "kotlin-for-forge"
+//    }
+//}
+
+jar.finalizedBy('reobfJar')
+setupJar(this)
--- a/Forge/gradle.properties
+++ b/Forge/gradle.properties
@ -0,0 +1,3 @@
+forgeVersion=43.1.1
+
+kotlinForForgeVersion=3.7.1
--- a/Forge/libs/hexcasting-forge-1.19.2-0.10.3.jar
+++ b/Forge/libs/hexcasting-forge-1.19.2-0.10.3.jar
--- a/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingClientInitializer.java
+++ b/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingClientInitializer.java
@ -0,0 +1,18 @@
+package net.touhoudiscord.hexucasting.forge;
+
+import net.minecraftforge.client.event.EntityRenderersEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.touhoudiscord.hexucasting.client.RegisterClientStuff;
+
+public class ForgeHexucastingClientInitializer {
+	@SubscribeEvent
+	public static void clientInit(FMLClientSetupEvent event) {
+		event.enqueueWork(RegisterClientStuff::init);
+	}
+	
+	@SubscribeEvent
+	public static void registerRenderers(EntityRenderersEvent.RegisterRenderers evt) {
+		RegisterClientStuff.registerBlockEntityRenderers(evt::registerBlockEntityRenderer);
+	}
+}
--- a/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingConfig.java
+++ b/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingConfig.java
@ -0,0 +1,24 @@
+package net.touhoudiscord.hexucasting.forge;
+
+
+import at.petrak.hexcasting.api.misc.MediaConstants;
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.touhoudiscord.hexucasting.api.config.HexucastingConfig;
+
+public class ForgeHexucastingConfig implements HexucastingConfig.CommonConfigAccess {
+    public ForgeHexucastingConfig(ForgeConfigSpec.Builder builder) {
+
+    }
+
+    public static class Client implements HexucastingConfig.ClientConfigAccess {
+        public Client(ForgeConfigSpec.Builder builder) {
+
+        }
+    }
+
+    public static class Server implements HexucastingConfig.ServerConfigAccess {
+        public Server(ForgeConfigSpec.Builder builder) {
+
+        }
+    }
+}
--- a/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingInitializer.java
+++ b/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/ForgeHexucastingInitializer.java
@ -0,0 +1,75 @@
+package net.touhoudiscord.hexucasting.forge;
+
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.config.ModConfig;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.registries.RegisterEvent;
+import org.apache.commons.lang3.tuple.Pair;
+import thedarkcolour.kotlinforforge.KotlinModLoadingContext;
+import net.touhoudiscord.hexucasting.api.HexucastingAPI;
+import net.touhoudiscord.hexucasting.api.config.HexucastingConfig;
+import net.touhoudiscord.hexucasting.common.casting.Patterns;
+
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+@Mod(HexucastingAPI.MOD_ID)
+public class ForgeHexucastingInitializer {
+	
+	public ForgeHexucastingInitializer() {
+		HexucastingAPI.LOGGER.info("Hello Forge World!");
+		initConfig();
+		initRegistry();
+		initListeners();
+	}
+	
+	private static void initConfig () {
+		Pair<ForgeHexucastingConfig, ForgeConfigSpec> config = (new ForgeConfigSpec.Builder()).configure(ForgeHexucastingConfig::new);
+		Pair<ForgeHexucastingConfig.Client, ForgeConfigSpec> clientConfig = (new ForgeConfigSpec.Builder()).configure(ForgeHexucastingConfig.Client::new);
+		Pair<ForgeHexucastingConfig.Server, ForgeConfigSpec> serverConfig = (new ForgeConfigSpec.Builder()).configure(ForgeHexucastingConfig.Server::new);
+		HexucastingConfig.setCommon(config.getLeft());
+		HexucastingConfig.setClient(clientConfig.getLeft());
+		HexucastingConfig.setServer(serverConfig.getLeft());
+		ModLoadingContext mlc = ModLoadingContext.get();
+		mlc.registerConfig(ModConfig.Type.COMMON, config.getRight());
+		mlc.registerConfig(ModConfig.Type.CLIENT, clientConfig.getRight());
+		mlc.registerConfig(ModConfig.Type.SERVER, serverConfig.getRight());
+	}
+	
+	private static void initRegistry () {
+	}
+	
+	private static void initListeners () {
+		IEventBus modBus = getModEventBus();
+		IEventBus evBus = MinecraftForge.EVENT_BUS;
+		
+		modBus.register(ForgeHexucastingClientInitializer.class);
+		
+		modBus.addListener((FMLCommonSetupEvent evt) -> evt.enqueueWork(Patterns::registerPatterns));
+	}
+	
+	// https://github.com/VazkiiMods/Botania/blob/1.18.x/Forge/src/main/java/vazkii/botania/forge/ForgeCommonInitializer.java
+	private static <T> void bind (ResourceKey<Registry<T>> registry, Consumer<BiConsumer<T, ResourceLocation>> source) {
+		getModEventBus().addListener((RegisterEvent event) -> {
+			if (registry.equals(event.getRegistryKey())) {
+				source.accept((t, rl) -> event.register(registry, rl, () -> t));
+			}
+		});
+	}
+	
+	// This version of bind is used for BuiltinRegistries.
+	private static <T> void bind(Registry<T> registry, Consumer<BiConsumer<T, ResourceLocation>> source) {
+		source.accept((t, id) -> Registry.register(registry, id, t));
+	}
+	
+	private static IEventBus getModEventBus () {
+		return KotlinModLoadingContext.Companion.get().getKEventBus();
+	}
+}
--- a/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/xplat/ForgeClientXplatImpl.java
+++ b/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/xplat/ForgeClientXplatImpl.java
@ -0,0 +1,58 @@
+package net.touhoudiscord.hexucasting.forge.xplat;
+
+import at.petrak.hexcasting.common.network.IMessage;
+import at.petrak.hexcasting.forge.network.ForgePacketHandler;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.particle.ParticleProvider;
+import net.minecraft.client.particle.SpriteSet;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.entity.EntityRenderers;
+import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.client.renderer.item.ItemPropertyFunction;
+import net.minecraft.client.renderer.texture.AbstractTexture;
+import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.core.particles.ParticleType;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.item.Item;
+import net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions;
+
+import java.util.function.Function;
+
+public class ForgeClientXplatImpl implements IClientXplatAbstractions {
+	@Override
+	public void sendPacketToServer (IMessage packet) {
+		ForgePacketHandler.getNetwork().sendToServer(packet);
+	}
+	
+	@Override
+	public void initPlatformSpecific () {
+		// NO-OP
+	}
+	
+	@Override
+	public <T extends Entity> void registerEntityRenderer (EntityType<? extends T> type, EntityRendererProvider<T> renderer) {
+		EntityRenderers.register(type, renderer);
+	}
+	
+	@Override
+	public <T extends ParticleOptions> void registerParticleType (ParticleType<T> type, Function<SpriteSet, ParticleProvider<T>> factory) {
+		Minecraft.getInstance().particleEngine.register(type, factory::apply);
+	}
+	
+	@Override
+	public void registerItemProperty (Item item, ResourceLocation id, ItemPropertyFunction func) {
+		ItemProperties.register(item, id, func);
+	}
+	
+	@Override
+	public void setFilterSave (AbstractTexture texture, boolean filter, boolean mipmap) {
+		texture.setBlurMipmap(filter, mipmap);
+	}
+	
+	@Override
+	public void restoreLastFilter (AbstractTexture texture) {
+		texture.restoreLastBlurMipmap();
+	}
+}
--- a/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/xplat/ForgeXplatImpl.java
+++ b/Forge/src/main/java/net/touhoudiscord/hexucasting/forge/xplat/ForgeXplatImpl.java
@ -0,0 +1,24 @@
+package net.touhoudiscord.hexucasting.forge.xplat;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.level.BlockEvent;
+import net.minecraftforge.fml.loading.FMLLoader;
+import net.touhoudiscord.hexucasting.xplat.IXplatAbstractions;
+
+public class ForgeXplatImpl implements IXplatAbstractions {
+
+	@Override
+	public boolean isPhysicalClient() {
+		return FMLLoader.getDist() == Dist.CLIENT;
+	}
+
+	@Override
+	public boolean isBreakingAllowed (Level level, BlockPos pos, BlockState state, Player player) {
+		return !MinecraftForge.EVENT_BUS.post(new BlockEvent.BreakEvent(level, pos, state, player));
+	}
+}
--- a/Forge/src/main/resources/META-INF/accesstransformer.cfg
+++ b/Forge/src/main/resources/META-INF/accesstransformer.cfg
@ -0,0 +1,3 @@
+public net.minecraft.client.renderer.RenderType$CompositeRenderType
+public net.minecraft.client.renderer.RenderType$CompositeState f_110576_ # textureState
+public net.minecraft.core.Registry$RegistryBootstrap
--- a/Forge/src/main/resources/META-INF/mods.toml
+++ b/Forge/src/main/resources/META-INF/mods.toml
@ -0,0 +1,50 @@
+modLoader = "kotlinforforge"
+loaderVersion = "[3,)"
+license = "MIT"
+
+issueTrackerURL = "https://git.touhoudiscord.net/Hexugory/hexucasting/issues"
+
+[[mods]]
+modId = "hexucasting"
+version = "${file.jarVersion}"
+displayName = "Hexucasting"
+displayURL = "https://git.touhoudiscord.net/Hexugory/hexucasting"
+logoFile = "borp.png"
+credits = "petrak@ and other developers of Hex Casting for the mod that this is an addon for. Talia for setting up the empty project structure that this is based on."
+authors = "Hexugory"
+description = "we do a little ruining it"
+
+[[dependencies.hexucasting]]
+modId = "forge"
+mandatory = true
+versionRange = "[40,)"
+ordering = "NONE"
+side = "BOTH"
+
+[[dependencies.hexucasting]]
+modId = "minecraft"
+mandatory = true
+versionRange = "[1.19.2,1.20)"
+ordering = "NONE"
+side = "BOTH"
+
+[[dependencies.hexucasting]]
+modId = "paucal"
+mandatory = true
+versionRange = "[0.5.0,0.6.0)"
+ordering = "NONE"
+side = "BOTH"
+
+[[dependencies.hexucasting]]
+modId = "patchouli"
+mandatory = true
+versionRange = "[1.19.2-77,)"
+ordering = "NONE"
+side = "BOTH"
+
+[[dependencies.hexucasting]]
+modId = "hexcasting"
+mandatory = true
+versionRange = "[0.10.1,)"
+ordering = "NONE"
+side = "BOTH"
--- a/Forge/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions
+++ b/Forge/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IClientXplatAbstractions
@ -0,0 +1 @@
+net.touhoudiscord.hexucasting.forge.xplat.ForgeClientXplatImpl
--- a/Forge/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IXplatAbstractions
+++ b/Forge/src/main/resources/META-INF/services/net.touhoudiscord.hexucasting.xplat.IXplatAbstractions
@ -0,0 +1 @@
+net.touhoudiscord.hexucasting.forge.xplat.ForgeXplatImpl
--- a/Forge/src/main/resources/borp.png
+++ b/Forge/src/main/resources/borp.png
--- a/Forge/src/main/resources/hexucasting_forge.mixins.json
+++ b/Forge/src/main/resources/hexucasting_forge.mixins.json
@ -0,0 +1,8 @@
+{
+  "minVersion": "0.8",
+  "required": true,
+  "compatibilityLevel": "JAVA_17",
+  "refmap": "hexucasting.mixins.refmap.json",
+  "package": "net.touhoudiscord.hexucasting.forge.mixin",
+  "mixins": [], "client": []
+}
--- a/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/ExampleTests.java
+++ b/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/ExampleTests.java
@ -0,0 +1,15 @@
+package net.touhoudiscord.hexucasting.forge;
+
+import net.minecraft.gametest.framework.*;
+import net.touhoudiscord.hexucasting.api.HexucastingAPI;
+
+public class ExampleTests {
+	@GameTest(templateNamespace = HexucastingAPI.MOD_ID, template = "basic")
+	public static void exampleTest(GameTestHelper helper) {
+		HexucastingAPI.LOGGER.debug("running example test");
+		
+		helper.onEachTick(() -> {
+			HexucastingAPI.LOGGER.debug("current tick: " + helper.getTick());
+		});
+	}
+}
--- a/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/OtherPatterns.kt
+++ b/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/OtherPatterns.kt
@ -0,0 +1,66 @@
+package net.touhoudiscord.hexucasting.forge
+
+import at.petrak.hexcasting.api.HexAPI
+import at.petrak.hexcasting.api.PatternRegistry
+import at.petrak.hexcasting.api.spell.Action
+import at.petrak.hexcasting.api.spell.iota.PatternIota
+import at.petrak.hexcasting.api.spell.math.HexDir
+import at.petrak.hexcasting.api.spell.math.HexPattern
+import at.petrak.hexcasting.common.casting.operators.eval.OpEval
+import at.petrak.hexcasting.common.casting.operators.lists.OpIndex
+import at.petrak.hexcasting.common.casting.operators.lists.OpSplat
+import at.petrak.hexcasting.common.casting.operators.math.logic.OpBoolIf
+import at.petrak.hexcasting.common.casting.operators.spells.OpPrint
+import net.minecraft.resources.ResourceLocation
+
+object OtherPatterns {
+	@JvmField
+	val REVEAL = patternOf(OpPrint)
+
+	@JvmField
+	val COMPASS = patternOf(HexAPI.modLoc("entity_pos/foot"))
+
+	@JvmField
+	val NOOP = PatternIota(HexPattern.fromAngles("", HexDir.SOUTH_EAST))
+	@JvmField
+	val DROP = PatternIota(HexPattern.fromAngles("a", HexDir.SOUTH_EAST))
+	@JvmField
+	val SWAP = patternOf(HexAPI.modLoc("swap"))
+
+	@JvmField
+	val EQUALITY = patternOf(HexAPI.modLoc("equals"))
+	@JvmField
+	val INEQUALITY = patternOf(HexAPI.modLoc("not_equals"))
+	@JvmField
+	val AUGERS = patternOf(OpBoolIf)
+
+	@JvmField
+	val NULLARY = patternOf(HexAPI.modLoc("const/null"))
+
+	@JvmField
+	val ZERO = PatternIota(HexPattern.fromAngles("aqaa", HexDir.EAST))
+	@JvmField
+	val ONE = PatternIota(HexPattern.fromAngles("aqaaw", HexDir.EAST))
+	@JvmField
+	val FOUR = PatternIota(HexPattern.fromAngles("aqaawaa", HexDir.EAST))
+
+	@JvmField
+	val GEMINIS_DISINTEGRATION = patternOf(HexAPI.modLoc("duplicate"))
+	@JvmField
+	val FLOCKS_DISINTEGRATION = patternOf(OpSplat)
+
+	@JvmField
+	val SELECTION_DISTILLATION = patternOf(OpIndex)
+
+	@JvmField
+	val HERMES = patternOf(OpEval)
+
+	@JvmField
+	val INTRO = PatternIota(HexPattern.fromAngles("qqq", HexDir.WEST))
+	@JvmField
+	val RETRO = PatternIota(HexPattern.fromAngles("eee", HexDir.EAST))
+
+
+	private fun patternOf(op: Action): PatternIota = PatternIota(PatternRegistry.lookupPattern(PatternRegistry.lookupPattern(op)!!).prototype)
+	private fun patternOf(loc: ResourceLocation): PatternIota = PatternIota(PatternRegistry.lookupPattern(loc).prototype)
+}
--- a/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/YourModGameTests.kt
+++ b/Forge/src/test/java/net/touhoudiscord/hexucasting/forge/YourModGameTests.kt
@ -0,0 +1,15 @@
+package net.touhoudiscord.hexucasting.forge
+
+import net.minecraftforge.event.RegisterGameTestsEvent
+import net.minecraftforge.eventbus.api.SubscribeEvent
+import net.minecraftforge.fml.common.Mod.EventBusSubscriber
+import net.touhoudiscord.hexucasting.api.HexucastingAPI
+
+@EventBusSubscriber(modid = HexucastingAPI.MOD_ID, bus = EventBusSubscriber.Bus.MOD)
+public object HexucastingGameTests {
+	@SubscribeEvent
+	public fun registerTests(event: RegisterGameTestsEvent) {
+		HexucastingAPI.LOGGER.debug("registering tests")
+		event.register(ExampleTests::class.java)
+	}
+}
--- a/Forge/src/test/resources/gameteststructures/yourmodgametests.exampletest.nbt
+++ b/Forge/src/test/resources/gameteststructures/yourmodgametests.exampletest.nbt
--- a/Forge/src/test/resources/gameteststructures/yourmodgametests.exampletest_1.nbt
+++ b/Forge/src/test/resources/gameteststructures/yourmodgametests.exampletest_1.nbt
--- a/Forge/temp/gameteststructures/exampletests.exampletest_0.snbt
+++ b/Forge/temp/gameteststructures/exampletests.exampletest_0.snbt
@ -0,0 +1,80 @@
+{
+    size: [3, 1, 3],
+    entities: [],
+    blocks: [
+        {
+            pos: [0, 0, 0],
+            state: 0
+        },
+        {
+            pos: [0, 0, 1],
+            state: 0
+        },
+        {
+            pos: [0, 0, 2],
+            state: 0
+        },
+        {
+            pos: [2, 0, 0],
+            state: 0
+        },
+        {
+            pos: [2, 0, 1],
+            state: 0
+        },
+        {
+            pos: [2, 0, 2],
+            state: 0
+        },
+        {
+            nbt: {
+                record_pos: {
+                    X: -10,
+                    Y: 56,
+                    Z: -1
+                },
+                pattern: {},
+                id: "hexcasting:akashic_bookshelf_tile"
+            },
+            pos: [1, 0, 0],
+            state: 1
+        },
+        {
+            nbt: {
+                lookup: {},
+                id: "hexcasting:akashic_record_tile"
+            },
+            pos: [1, 0, 1],
+            state: 2
+        },
+        {
+            nbt: {
+                record_pos: {
+                    X: -10,
+                    Y: 56,
+                    Z: -1
+                },
+                pattern: {},
+                id: "hexcasting:akashic_bookshelf_tile"
+            },
+            pos: [1, 0, 2],
+            state: 1
+        }
+    ],
+    palette: [
+        {
+            Name: "minecraft:air"
+        },
+        {
+            Properties: {
+                facing: "west",
+                datum_type: "empty"
+            },
+            Name: "hexcasting:akashic_bookshelf"
+        },
+        {
+            Name: "hexcasting:akashic_record"
+        }
+    ],
+    DataVersion: 2975
+}
--- a/Forge/temp/gameteststructures/wisptests.basic.snbt
+++ b/Forge/temp/gameteststructures/wisptests.basic.snbt
@ -0,0 +1,51 @@
+{
+    size: [3, 1, 3],
+    entities: [],
+    blocks: [
+        {
+            pos: [0, 0, 0],
+            state: 0
+        },
+        {
+            pos: [0, 0, 1],
+            state: 1
+        },
+        {
+            pos: [0, 0, 2],
+            state: 2
+        },
+        {
+            pos: [1, 0, 0],
+            state: 1
+        },
+        {
+            pos: [1, 0, 1],
+            state: 3
+        },
+        {
+            pos: [1, 0, 2],
+            state: 1
+        },
+        {
+            pos: [2, 0, 0],
+            state: 4
+        },
+        {
+            pos: [2, 0, 1],
+            state: 1
+        },
+        {
+            pos: [2, 0, 2],
+            state: 5
+        }
+    ],
+    palette: [
+        "minecraft:iron_ore",
+        "minecraft:stone",
+        "minecraft:emerald_ore",
+        "minecraft:gold_ore",
+        "minecraft:grass_block",
+        "minecraft:spruce_planks"
+    ],
+    DataVersion: 2975
+}
--- a/40
+++ b/40
@ -0,0 +1,40 @@
+#!/usr/bin/env groovy
+
+pipeline {
+    agent any
+    tools {
+        jdk "jdk-17.0.1"
+    }
+    environment {
+        discordWebhook = credentials('discordWebhook')
+    }
+    stages {
+        stage('Clean') {
+            steps {
+                echo 'Cleaning Project'
+                sh 'chmod +x gradlew'
+                sh './gradlew clean'
+            }
+        }
+        stage('Build') {
+            steps {
+                echo 'Building'
+                sh './gradlew build'
+            }
+        }
+        stage('Publish') {
+            when { branch 'main' }
+            steps {
+                echo 'Deploying to Maven'
+                sh './gradlew publish sendWebhook'
+            }
+        }
+    }
+    post {
+        always {
+            archiveArtifacts 'Common/build/libs/**.jar'
+            archiveArtifacts 'Forge/build/libs/**.jar'
+            archiveArtifacts 'Fabric/build/libs/**.jar'
+        }
+    }
+}
--- a/LICENSE.txt
+++ b/LICENSE.txt
@ -0,0 +1,17 @@
+The MIT License (MIT)
+Copyright © 2022 talia-12
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+and associated documentation files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@ -0,0 +1,30 @@
+# Empty Hex Casting Addon Framework
+
+This is a stripped-down template for 1.92.2 Fabric+Forge Hex Casting addons.  It's heavily derived (aka, taken wholesale) from [HexCasting](https://www.curseforge.com/minecraft/mc-mods/hexcasting)'s excellent project layout, and was created by stripping everything from [Hexal](https://modrinth.com/mod/hexal)'s repository that wasn't relevant.
+
+This has all the dependencies _necessary_ for functioning as an addon, as well as the dependencies and code for a config system that will work for both forge and fabric. There is an example Action, and an example Spell, and you can look at the existing HexCasting or Hexal code to see how actual Actions and Spells are written.
+
+The approach here does not actually avoid the various complexities of cross-modloader programming.  You still need to very carefully maintain functions that are distinct between the two environments.  It's just a very well-designed approach for separating these fields, without having to duplicate a lot of work.
+
+There will be some follow-up work to turn it from a generic "Hello World" mod into _your_ Generic "Hello World" mod.  Some keywords to look at:
+
+``yourmod.name.here`` is the default package name.  While valid for test purposes, you _will_ need to change this before release (and ideally immediately after forking) or risk (near-certain) collisions and annoying bugs, and it's easier the earlier you change it.
+IntelliJ (and most other IDEAs) will allow bulk refactoring, though expect to need to change a few ``package`` settings at the top of files.
+
+See [this page](https://docs.oracle.com/javase/specs/jls/se6/html/packages.html#7.7) for information about package naming rules, particularly _don't use a popular TLD that you don't actually own or control_.
+
+``yourmod`` is the default modID.  _AFTER_ you've refactored your package name, this is the next thing to change.  It's only referenced in a few places, but other mods, compile-time behavior (both Forge and Fabric) and maven will interact with it heavily.
+
+See [this page](https://maven.apache.org/guides/mini/guide-naming-conventions.html) for some naming conventions specific to this ID.
+
+After you've made these changes, it's safe to leave ``YourAPI`` and ``YourConfig`` as their current names, but do feel free to rename them; something specific to your modId or your package will make regularly importing them less obnoxious.
+
+``Your Mod`` is the default mod name.  This is more for aesthetics than code relevance, but it does show up in a good few places and it's kinda embarrassing if it's left at default.
+
+Check your ``mods.toml`` (for Forge) and ``fabric.mod.json`` (for Fabric) regarding other mod-specific settings, such as author, icon, dependencies you want presented to the user, so on.  There's a lot I'm not going to summarize here.
+
+Actually Running:
+
+Once you've made those updates, you'll need to reload Gradle.  Do it a couple of times, for safety's sake.
+
+The automatically generated Run configurations won't work.  Sorry.  You'll need to use Gradle->Fabric>Tasks->Fabric->run* or Gradle->Forge->Tasks->forgegradle runs->run*.  There's probably a way to fix this, but good luck.
--- a/addon_guide.md
+++ b/addon_guide.md
@ -0,0 +1,2 @@
+# Guide to Starting a Hex Casting Addon
+
--- a/build.gradle
+++ b/build.gradle
@ -0,0 +1,241 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath group: 'com.diluv.schoomp', name: 'Schoomp', version: '1.2.6'
+    }
+}
+
+//import com.diluv.schoomp.Webhook
+//import com.diluv.schoomp.message.Message
+
+plugins {
+    id 'java'
+    id "org.jetbrains.kotlin.jvm"
+    id 'idea'
+}
+
+def isRelease() {
+    try {
+        def stdout = new ByteArrayOutputStream()
+        def gitHash = System.getenv('GIT_COMMIT')
+        def gitPrevHash = System.getenv('GIT_PREVIOUS_COMMIT')
+        def travisRange = System.getenv('TRAVIS_COMMIT_RANGE')
+        if (gitHash && gitPrevHash) {
+            exec {
+                commandLine 'git', 'log', '--pretty=tformat:- %s', '' + gitPrevHash + '...' + gitHash
+                standardOutput = stdout
+            }
+            return stdout.toString().toLowerCase().contains("[release")
+        } else if (travisRange) {
+            exec {
+                commandLine 'git', 'log', '--pretty=tformat:- %s', '' + travisRange
+                standardOutput = stdout
+            }
+            return stdout.toString().toLowerCase().contains("[release")
+        } else {
+            return false
+        }
+    } catch (ignored) {
+        return false
+    }
+}
+
+String getArtifactID(String platform) {
+    return "${modID}-${platform}-${minecraftVersion}"
+}
+
+void setupJar(Object project) {
+    project.jar {
+        manifest {
+            attributes([
+                    'Specification-Title'     : modID,
+                    'Specification-Vendor'    : "talia",
+                    'Specification-Version'   : project.jar.archiveVersion,
+                    'Implementation-Title'    : project.name,
+                    'Implementation-Version'  : project.jar.archiveVersion,
+                    'Implementation-Vendor'   : "talia",
+                    'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
+                    'Timestampe'              : System.currentTimeMillis(),
+                    'Built-On-Java'           : "${System.getProperty('java.vm.version')} (${System.getProperty('java.vm.vendor')})",
+                    'Build-On-Minecraft'      : minecraftVersion
+            ])
+        }
+    }
+
+    project.publishing {
+        publications {
+            mavenJava(MavenPublication) {
+                groupId project.group
+                artifactId project.archivesBaseName
+                version project.version
+                from project.components.java
+            }
+        }
+
+        repositories {
+            maven {
+                url "file://" + System.getenv("local_maven")
+            }
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+}
+
+subprojects {
+    apply plugin: 'java'
+    apply plugin: 'kotlin'
+    apply plugin: 'maven-publish'
+
+    group = "ram.talia.$modID" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+    version = "${modVersion}"
+    if (!isRelease() && System.getenv('BUILD_NUMBER') != null) {
+        version += "-pre-" + System.getenv('BUILD_NUMBER')
+    } else if (System.getenv('TAG_NAME') != null) {
+        version = System.getenv('TAG_NAME').substring(1)
+        println 'Version overridden to tag version ' + version
+    }
+    // archivesBaseName set in each gradle
+
+    repositories {
+        maven { url "https://libraries.minecraft.net/" }
+
+        mavenCentral()
+
+        maven {
+            name = 'Sponge / Mixin'
+            url = 'https://repo.spongepowered.org/repository/maven-public/'
+        }
+
+        maven {
+            name = 'BlameJared Maven'
+            url = 'https://maven.blamejared.com'
+        }
+
+        maven {
+            name = "Modrinth"
+            url = "https://api.modrinth.com/maven"
+            content {
+                includeGroup "maven.modrinth"
+            }
+        }
+
+        maven {
+            url = "https://jitpack.io"
+        }
+    }
+
+
+    tasks.withType(JavaCompile).configureEach {
+        it.options.encoding = 'UTF-8'
+        it.options.release = 17
+    }
+
+    // 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
+    }
+
+    sourceSets.main.kotlin.srcDirs += 'src/main/java'
+
+    java.toolchain.languageVersion = JavaLanguageVersion.of(17)
+    java.withSourcesJar()
+    java.withJavadocJar()
+
+    processResources {
+        exclude '.cache'
+    }
+    processTestResources {
+        exclude '.cache'
+    }
+    sourcesJar {
+        duplicatesStrategy 'exclude'
+    }
+}
+
+allprojects { gradle.projectsEvaluated { tasks.withType(JavaCompile) { options.compilerArgs << "-Xmaxerrs" << "1000" } } }
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+private void createReleaseTag() {
+    def tagName = "$modVersion"
+    ("git tag $tagName").execute()
+    ("git push --tags").execute()
+}
+
+/**
+ * To setup automatic modrinth exporting, get your API key from the modrinth website and place it in a
+ * file in the root project directory called keys.properties
+ * e.g.
+ * MODRINTH_TOKEN=exampletoken
+ * Then, uncomment the modrinth blocks in every build.gradle. When you run the modrinth build task
+ * in the base project task space, it will upload both Forge and Fabric versions of the mod to
+ * modrinth automatically, with the changelog from the changelog.md file in the base project directory.
+ */
+task modrinth {
+    dependsOn ":Fabric:modrinth"
+    dependsOn ":Forge:modrinth"
+    createReleaseTag()
+}
+
+def getGitChangelog = { ->
+    try {
+        def stdout = new ByteArrayOutputStream()
+        def gitHash = System.getenv('GIT_COMMIT')
+        def gitPrevHash = System.getenv('GIT_PREVIOUS_COMMIT')
+        def travisRange = System.getenv('TRAVIS_COMMIT_RANGE')
+        if (gitHash && gitPrevHash) {
+            exec {
+                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
+                standardOutput = stdout
+            }
+            return stdout.toString().trim()
+        } else {
+            return ""
+        }
+    } catch (ignored) {
+        return ""
+    }
+}
+
+//task sendWebhook {
+//    doLast {
+//        try {
+//            if (System.getenv('discordWebhook') == null || System.getenv("BUILD_URL") == null) {
+//                println "Cannot send the webhook without the webhook url or the build url"
+//                return
+//            }
+//            def webhook = new Webhook(System.getenv('discordWebhook'), 'Petrak@ Patreon Gradle')
+//
+//            def message = new Message()
+//            message.setUsername("Patreon Early Access")
+//            message.setContent("New **$modName** release! Download it here: ${System.getenv("BUILD_URL")}\nChangelog:\n${getGitChangelog()}")
+//
+//            webhook.sendMessage(message)
+//        } catch (ignored) {
+//            project.logger.error("Failed to push Discord webhook.")
+//        }
+//    }
+//}
--- a/doc/HexCastingResources/assets/hexcasting/lang/en_us.json
+++ b/doc/HexCastingResources/assets/hexcasting/lang/en_us.json
--- a/doc/HexCastingResources/assets/hexcasting/lang/ru_ru.json
+++ b/doc/HexCastingResources/assets/hexcasting/lang/ru_ru.json
@ -0,0 +1,888 @@
+{
+	"item.hexcasting.book": "Рунный блокнот",
+	"item.hexcasting.wand_oak": "Дубовый Посох",
+	"item.hexcasting.wand_spruce": "Еловый Посох",
+	"item.hexcasting.wand_birch": "Берёзовый Посох",
+	"item.hexcasting.wand_jungle": "Посох джунглей",
+	"item.hexcasting.wand_acacia": "Посох акации",
+	"item.hexcasting.wand_dark_oak": "Тёмно-дубовый Посох",
+	"item.hexcasting.wand_crimson": "Багровый Посох",
+	"item.hexcasting.wand_warped": "Искажённый Посох",
+	"item.hexcasting.wand_akashic": "Потусторонний Посох",
+	"item.hexcasting.focus": "Талисман",
+	"item.hexcasting.focus.sealed": "Залипший талисман",
+	"item.hexcasting.spellbook": "Книга знаний",
+	"item.hexcasting.cypher": "Побрякушка",
+	"item.hexcasting.trinket": "Штуковина",
+	"item.hexcasting.artifact": "Амулет",
+	"item.hexcasting.battery": "Бутыль мыслей",
+	"item.hexcasting.manaholder.amount": "§7Мысли: %s/%s (%.0f%%)§r",
+	"item.hexcasting.amethyst_dust": "Аметистовая пыль",
+	"item.hexcasting.charged_amethyst": "Заряженный осколок аметиста",
+	"item.hexcasting.lens": "Линза прозрения",
+	"item.hexcasting.scroll": "Свиток",
+	"item.hexcasting.scroll.of": "Древний Свиток - %s",
+	"item.hexcasting.scroll.empty": "Чистый свиток",
+	"item.hexcasting.abacus": "Рунные счёты",
+	"item.hexcasting.sub_sandwich": "Зубодробительный сэндвич",
+	"item.hexcasting.dye_colorizer_white": "Белый оттенок",
+	"item.hexcasting.dye_colorizer_orange": "Оранжевый оттенок",
+	"item.hexcasting.dye_colorizer_magenta": "Пурпурный оттенок",
+	"item.hexcasting.dye_colorizer_light_blue": "Голубой оттенок",
+	"item.hexcasting.dye_colorizer_yellow": "Жёлтый оттенок",
+	"item.hexcasting.dye_colorizer_lime": "Светло-зеленый оттенок",
+	"item.hexcasting.dye_colorizer_pink": "Розовый оттенок",
+	"item.hexcasting.dye_colorizer_gray": "Серый оттенок",
+	"item.hexcasting.dye_colorizer_light_gray": "Светло-серый оттенок",
+	"item.hexcasting.dye_colorizer_cyan": "Бирюзовый оттенок",
+	"item.hexcasting.dye_colorizer_purple": "Фиолетовый оттенок",
+	"item.hexcasting.dye_colorizer_blue": "Синий оттенок",
+	"item.hexcasting.dye_colorizer_brown": "Коричневый оттенок",
+	"item.hexcasting.dye_colorizer_green": "Зелёный оттенок",
+	"item.hexcasting.dye_colorizer_red": "Красный оттенок",
+	"item.hexcasting.dye_colorizer_black": "Чёрный оттенок",
+	"item.hexcasting.pride_colorizer_0": "Transgender оттенок",
+	"item.hexcasting.pride_colorizer_1": "Gay оттенок",
+	"item.hexcasting.pride_colorizer_2": "Agender оттенок",
+	"item.hexcasting.pride_colorizer_3": "Asexual оттенок",
+	"item.hexcasting.pride_colorizer_4": "Bisexual оттенок",
+	"item.hexcasting.pride_colorizer_5": "Pansexual оттенок",
+	"item.hexcasting.pride_colorizer_6": "Genderqueer оттенок",
+	"item.hexcasting.pride_colorizer_7": "Demigirl оттенок",
+	"item.hexcasting.pride_colorizer_8": "Non-Binary оттенок",
+	"item.hexcasting.pride_colorizer_9": "Lesbian оттенок",
+	"item.hexcasting.pride_colorizer_10": "Demiboy оттенок",
+	"item.hexcasting.pride_colorizer_11": "Genderfluid оттенок",
+	"item.hexcasting.pride_colorizer_12": "Intersex оттенок",
+	"item.hexcasting.pride_colorizer_13": "Aroace оттенок",
+	"item.hexcasting.uuid_colorizer": "Оттенок души",
+
+	"block.hexcasting.conjured": "Магический барьер",
+	"block.hexcasting.slate.blank": "Пустая скрижаль",
+	"block.hexcasting.slate.written": "Рунная скрижаль",
+	"block.hexcasting.empty_impetus": "Empty Impetus",
+	"block.hexcasting.directrix_redstone": "Mason Directrix",
+	"block.hexcasting.empty_directrix": "Empty Directrix",
+	"block.hexcasting.impetus_rightclick": "Toolsmith Impetus",
+	"block.hexcasting.impetus_look": "Fletcher Impetus",
+	"block.hexcasting.impetus_storedplayer": "Cleric Impetus",
+	"block.hexcasting.akashic_record": "Запись акаши",
+	"block.hexcasting.akashic_bookshelf": "Книжный шкаф акаши",
+	"block.hexcasting.akashic_connector": "Akashic Ligature",
+
+	"block.hexcasting.slate_block": "Блок скрижали",
+	"block.hexcasting.amethyst_dust_block": "Аметистовый песок",
+	"block.hexcasting.amethyst_tiles": "Аметистовые плитки",
+	"block.hexcasting.scroll_paper": "Свиточная бумага",
+	"block.hexcasting.ancient_scroll_paper": "Бумага древних свитков",
+	"block.hexcasting.scroll_paper_lantern": "Фонарь из бумаги свитков",
+	"block.hexcasting.ancient_scroll_paper_lantern": "Фонарь из бумаги древних свитков",
+	"block.hexcasting.amethyst_sconce": "Аметистовая свеча",
+	"block.hexcasting.akashic_log": "Потустороннее бревно",
+	"block.hexcasting.akashic_log_stripped": "Бритое потустороннее бревно",
+	"block.hexcasting.akashic_wood": "Потустороннее дерево",
+	"block.hexcasting.akashic_wood_stripped": "Бритое потустороннее дерево",
+	"block.hexcasting.akashic_planks": "Потусторонние доски",
+	"block.hexcasting.akashic_panel": "Потусторонние панели",
+	"block.hexcasting.akashic_tile": "Потусторонние резные доски",
+	"block.hexcasting.akashic_door": "Дверь из потусторонних досок",
+	"block.hexcasting.akashic_trapdoor": "Люк из потусторонних досок",
+	"block.hexcasting.akashic_stairs": "Ступени из потусторонних досок",
+	"block.hexcasting.akashic_slab": "Полублок потусторонних досок",
+	"block.hexcasting.akashic_button": "Кнопки из потусторонних досок",
+	"block.hexcasting.akashic_pressure_plate": "Потусторонняя нажимная плита",
+	"block.hexcasting.akashic_leaves1": "Листва аметиста",
+	"block.hexcasting.akashic_leaves2": "Листва авантюрина",
+	"block.hexcasting.akashic_leaves3": "Янтарная листва",
+
+	"itemGroup.hexcasting": "Hexcasting",
+
+	"hexcasting.tooltip.spellbook.page": "Текущая страница %d/%d",
+	"hexcasting.tooltip.spellbook.page.sealed": "Текущая страница %d/%d (%s)",
+	"hexcasting.tooltip.spellbook.page_with_name": "Текущая страница %d/%d (\"%s\")",
+	"hexcasting.tooltip.spellbook.page_with_name.sealed": "Текущая страница %d/%d (\"%s\") (%s)",
+	"hexcasting.tooltip.spellbook.sealed": "Залипло",
+	"hexcasting.tooltip.spellbook.empty": "Пусто",
+	"hexcasting.tooltip.spellbook.empty.sealed": "Пусто (%s)",
+	"hexcasting.tooltip.abacus": "§d",
+	"hexcasting.tooltip.abacus.reset": "Вернуть к 0",
+	"hexcasting.tooltip.abacus.reset.nice": "Норм",
+	"hexcasting.tooltip.lens.impetus.mana": "%s пылинок",
+	"hexcasting.tooltip.lens.impetus.storedplayer": "Привязано к %s",
+	"hexcasting.tooltip.lens.impetus.storedplayer.none": "Привязка убрана",
+	"hexcasting.tooltip.lens.pattern.invalid": "Неизвестная руна",
+	"hexcasting.tooltip.brainsweep.profession": "Профессия: %s",
+	"hexcasting.tooltip.lens.akashic.bookshelf.location": "Запись %s",
+  "hexcasting.tooltip.lens.akashic.record.count": "%s записей",
+  "hexcasting.tooltip.lens.akashic.record.count.single": "%s запись",
+	"hexcasting.tooltip.brainsweep.profession.any": "Любая профессия",
+	"hexcasting.tooltip.brainsweep.biome": "Биом: %s",
+	"hexcasting.tooltip.brainsweep.biome.any": "Любой биом",
+	"hexcasting.tooltip.brainsweep.min_level": "Уровень %d или выше",
+	"hexcasting.spelldata.onitem": "§7Содержит: §r%s",
+  "hexcasting.spelldata.anything": "Что угодно",
+	"hexcasting.spelldata.entity.whoknows": "Сущность из 0.5.0",
+	"hexcasting.spelldata.akashic.nopos": "The owning record does not know of any iota here (this is a bug)",
+
+	"advancement.hexcasting:root": "Исследование рунных заклинаний",
+	"advancement.hexcasting:root.desc": "Войдите в аметистовую залежь - сконцентрированный источник мысли.",
+	"advancement.hexcasting:enlightenment": "Прорицание",
+	"advancement.hexcasting:enlightenment.desc": "Получите безумный урон от рунного заклинания, ходя по грани жизни и смерти.",
+	"advancement.hexcasting:wasteful_cast": "Сорить аметистами",
+	"advancement.hexcasting:wasteful_cast.desc": "Потратьте немалое количество аметистов на заклинание",
+	"advancement.hexcasting:big_cast": "Вы - Банкрот",
+	"advancement.hexcasting:big_cast.desc": "Потратьте огромное количество мысли для исполнения рунного заклинания.",
+	"advancement.hexcasting:y_u_no_cast_angy": "Не по плану",
+	"advancement.hexcasting:y_u_no_cast_angy.desc": "Исполнить сложное заклинание из свитка и потерпеть неудачу.",
+	"advancement.hexcasting:opened_eyes": "Открытие",
+	"advancement.hexcasting:opened_eyes.desc": "Потеряйте часть своего разума в качестве оплаты рунного заклинания.",
+
+	"stat.hexcasting.mana_used": "Поглощено мысли (в пылинках)",
+	"stat.hexcasting.mana_overcasted": "Сверхзатраты мысли (в пылинках)",
+	"stat.hexcasting.patterns_drawn": "Написано рун",
+	"stat.hexcasting.spells_cast": "Использовано заклинаний",
+
+	"death.attack.hexcasting.overcast": "Разум %s был полноценно поглощён как оплата заклинания",
+
+	"command.hexcasting.pats.listing": "Руны в этом мире:",
+	"command.hexcasting.pats.all": "Дал тебе %d свитков",
+	"command.hexcasting.pats.specific.success": "Получен свиток %s ( %s )",
+	"command.hexcasting.recalc": "Пересчёт рун в мире",
+  "command.hexcasting.brainsweep": "Разум очищен %s",
+  "command.hexcasting.brainsweep.fail.badtype": "%s - не житель!",
+  "command.hexcasting.brainsweep.fail.already": "%s уже пуст",
+  "hexcasting.pattern.unknown": "Unknown pattern resource location %s",
+
+	"hexcasting.message.cant_overcast": "Руны потребовали больше мысли чем у меня было... Возможно следовало дополнительно проверить расчёты.",
+  "hexcasting.message.cant_great_spell": "Заклинание не сработало, должно быть у меня не хватает знаний.?",
+
+	"hexcasting.subtitles.start_pattern": "Пишем руну",
+  "hexcasting.subtitles.add_line": "Пишем линию",
+	"hexcasting.subtitles.add_pattern": "Руна окончена",
+	"hexcasting.subtitles.fail_pattern": "Допущена ошибка в руне",
+	"hexcasting.subtitles.ambiance": "Рунные линии трещат",
+	"hexcasting.subtitles.cast": "Руна исполняется",
+	"hexcasting.subtitles.abacus": "Счёты переведены",
+	"hexcasting.subtitles.abacus.shake": "Счёты трясутся",
+	"hexcasting.subtitles.spellcircle.add_pattern": "Заклинание круга трещит",
+	"hexcasting.subtitles.spellcircle.fail": "Заклинание круга громко трещит",
+	"hexcasting.subtitles.spellcircle.cast": "Заклинание круга применяется",
+	"hexcasting.subtitles.scroll.dust": "Свиток покрывается пылью",
+	"hexcasting.subtitles.scroll.scribble": "Свиток очищен",
+	"hexcasting.subtitles.impetus.fletcher.tick": "Fletcher Impetus ticks",
+	"hexcasting.subtitles.impetus.cleric.register": "Cleric Impetus dings",
+
+	"hexcasting.spell.hexcasting:get_caster": "Зеркало нарцисса",
+	"hexcasting.spell.hexcasting:get_entity_pos": "Положение сущности",
+	"hexcasting.spell.hexcasting:get_entity_look": "Взгляд алидады",
+	"hexcasting.spell.hexcasting:get_entity_height": "Высота сущности",
+  "hexcasting.spell.hexcasting:get_entity_velocity": "Скорость сущности",
+	"hexcasting.spell.hexcasting:raycast": "Столкновение: стена",
+	"hexcasting.spell.hexcasting:raycast/axis": "Столкновение: компас",
+	"hexcasting.spell.hexcasting:raycast/entity": "Столкновение: сущность",
+	"hexcasting.spell.hexcasting:circle/impetus_pos": "Зеркало путевого камня",
+	"hexcasting.spell.hexcasting:circle/impetus_dir": "Взгляд путевого камня",
+	"hexcasting.spell.hexcasting:circle/bounds/min": "Отражение меньшей стопки",
+	"hexcasting.spell.hexcasting:circle/bounds/max": "Отражение большей стопки",
+	"hexcasting.spell.hexcasting:append": "Вступление в очередь",
+	"hexcasting.spell.hexcasting:concat": "Комбинация очередей",
+	"hexcasting.spell.hexcasting:index": "Выборка из очереди",
+	"hexcasting.spell.hexcasting:for_each": "Рунный перебор",
+	"hexcasting.spell.hexcasting:list_size": "Очередные счёты",
+	"hexcasting.spell.hexcasting:singleton": "Одиночное вхождение",
+	"hexcasting.spell.hexcasting:empty_list": "Пустотная очередь",
+	"hexcasting.spell.hexcasting:reverse_list": "Очередной переполох",
+	"hexcasting.spell.hexcasting:last_n_list": "Множественное вступление",
+	"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:get_entity": "Обнаружение сущности",
+	"hexcasting.spell.hexcasting:get_entity/animal": "Обнаруж. сущн.: Животные",
+	"hexcasting.spell.hexcasting:get_entity/monster": "Обнаруж. сущн.: Монстры",
+	"hexcasting.spell.hexcasting:get_entity/item": "Обнаруж. сущн.: Предметы",
+	"hexcasting.spell.hexcasting:get_entity/player": "Обнаруж. сущн.: Игроки",
+	"hexcasting.spell.hexcasting:get_entity/living": "Обнаруж. сущн.: Живое",
+	"hexcasting.spell.hexcasting:zone_entity": "Поиск по площади: Any",
+	"hexcasting.spell.hexcasting:zone_entity/animal": "Поиск по площади: Животные",
+	"hexcasting.spell.hexcasting:zone_entity/monster": "Поиск по площади: Монстры",
+	"hexcasting.spell.hexcasting:zone_entity/item": "Поиск по площади: Предметы",
+	"hexcasting.spell.hexcasting:zone_entity/player": "Поиск по площади: Игроки",
+	"hexcasting.spell.hexcasting:zone_entity/living": "Поиск по площади: Живое",
+	"hexcasting.spell.hexcasting:zone_entity/not_animal": "Поиск по площади: Не животные",
+	"hexcasting.spell.hexcasting:zone_entity/not_monster": "Поиск по площади: Не монстры",
+	"hexcasting.spell.hexcasting:zone_entity/not_item": "Поиск по площади: Не предметы",
+	"hexcasting.spell.hexcasting:zone_entity/not_player": "Поиск по площади: Не игроки",
+	"hexcasting.spell.hexcasting:zone_entity/not_living": "Поиск по площади: Неживое",
+	"hexcasting.spell.hexcasting:const/null": "Нуль константа",
+	"hexcasting.spell.hexcasting:duplicate": "Дублировать",
+	"hexcasting.spell.hexcasting:duplicate_n": "Множественное дублирование",
+	"hexcasting.spell.hexcasting:stack_len": "Размер стэка",
+	"hexcasting.spell.hexcasting:swap": "Верхний переход",
+	"hexcasting.spell.hexcasting:fisherman": "Значение по индексу",
+  "hexcasting.spell.hexcasting:swizzle": "Swindler's Gambit",
+	"hexcasting.spell.hexcasting:add": "Сложение",
+	"hexcasting.spell.hexcasting:sub": "Убавление",
+	"hexcasting.spell.hexcasting:mul_dot": "Умножение",
+	"hexcasting.spell.hexcasting:div_cross": "Деление",
+	"hexcasting.spell.hexcasting:abs_len": "Length Purification",
+	"hexcasting.spell.hexcasting:pow_proj": "Возведение в степень",
+	"hexcasting.spell.hexcasting:construct_vec": "Создать вектоа",
+	"hexcasting.spell.hexcasting:deconstruct_vec": "Разбить вектор",
+  "hexcasting.spell.hexcasting:and_bit": "Побитовое И",
+  "hexcasting.spell.hexcasting:or_bit": "Побитовое ИЛИ",
+  "hexcasting.spell.hexcasting:xor_bit": "Побитовое исключающее ИЛИ",
+  "hexcasting.spell.hexcasting:not_bit": "Побитовое НЕ",
+  "hexcasting.spell.hexcasting:to_set": "Uniqueness Purification",
+	"hexcasting.spell.hexcasting:and": "Логическое И (&&)",
+	"hexcasting.spell.hexcasting:or": "Логическое ИЛИ (||)",
+	"hexcasting.spell.hexcasting:xor": "Логическое исключающее ИЛИ (^)",
+  "hexcasting.spell.hexcasting:floor": "Опущение дроби",
+  "hexcasting.spell.hexcasting:ceil": "Доведение дроби",
+	"hexcasting.spell.hexcasting:greater": "Логическое больше (>)",
+	"hexcasting.spell.hexcasting:less": "Логическое меньше (<)",
+	"hexcasting.spell.hexcasting:greater_eq": "Логическое больше или равно (>=)",
+	"hexcasting.spell.hexcasting:less_eq": "Логическое меньше или равно (<=)",
+	"hexcasting.spell.hexcasting:equals": "Логическое равенство (==)",
+	"hexcasting.spell.hexcasting:not_equals": "Логическое неравенство (!=)",
+	"hexcasting.spell.hexcasting:not": "Логическое НЕ (!)",
+	"hexcasting.spell.hexcasting:identity": "id",
+  "hexcasting.spell.hexcasting:sin": "Синус",
+  "hexcasting.spell.hexcasting:cos": "Косинус",
+  "hexcasting.spell.hexcasting:tan": "Тангенс",
+  "hexcasting.spell.hexcasting:arcsin": "Арксинус",
+  "hexcasting.spell.hexcasting:arccos": "Аркосинус",
+  "hexcasting.spell.hexcasting:arctan": "Арктангенс",
+  "hexcasting.spell.hexcasting:random": "Энтропийное значение",
+  "hexcasting.spell.hexcasting:logarithm": "Логарифм",
+  "hexcasting.spell.hexcasting:coerce_axial": "Axial",
+	"hexcasting.spell.hexcasting:print": "Вывод в чат",
+	"hexcasting.spell.hexcasting:beep": "Издать ноту",
+	"hexcasting.spell.hexcasting:explode": "Взрыв",
+	"hexcasting.spell.hexcasting:explode/fire": "Огненный взрыв",
+	"hexcasting.spell.hexcasting:add_motion": "Импульс",
+	"hexcasting.spell.hexcasting:blink": "Мини-телепорт",
+	"hexcasting.spell.hexcasting:break_block": "Сломать блок",
+	"hexcasting.spell.hexcasting:place_block": "Поставить блок",
+	"hexcasting.spell.hexcasting:craft/cypher": "Создать побрякушку",
+	"hexcasting.spell.hexcasting:craft/trinket": "Создать штуковину",
+	"hexcasting.spell.hexcasting:craft/artifact": "Создать амулет",
+	"hexcasting.spell.hexcasting:craft/battery": "Создать пузырь мыслей",
+	"hexcasting.spell.hexcasting:recharge": "Перезарядка предмета",
+	"hexcasting.spell.hexcasting:erase": "Очистка предмета",
+	"hexcasting.spell.hexcasting:create_water": "Вылить воды",
+	"hexcasting.spell.hexcasting:destroy_water": "Зачерпнуть воды",
+	"hexcasting.spell.hexcasting:ignite": "Поджог",
+	"hexcasting.spell.hexcasting:extinguish": "Массовый поджог",
+	"hexcasting.spell.hexcasting:conjure_block": "Магический барьер",
+	"hexcasting.spell.hexcasting:conjure_light": "Магический свет",
+	"hexcasting.spell.hexcasting:bonemeal": "Удобрить",
+  "hexcasting.spell.hexcasting:edify": "Наполнить саженец",
+	"hexcasting.spell.hexcasting:colorize": "Установить оттенок",
+	"hexcasting.spell.hexcasting:sentinel/create": "Поставить Метку",
+	"hexcasting.spell.hexcasting:sentinel/destroy": "Убрать Метку",
+	"hexcasting.spell.hexcasting:sentinel/get_pos": "Позиция Метки",
+	"hexcasting.spell.hexcasting:sentinel/wayfind": "Путь к Метке",
+	"hexcasting.spell.hexcasting:potion/weakness": "Эффект слабости",
+	"hexcasting.spell.hexcasting:potion/levitation": "Эффект левитации",
+	"hexcasting.spell.hexcasting:potion/wither": "Эффект иссушения",
+	"hexcasting.spell.hexcasting:potion/poison": "Эффект отравления",
+	"hexcasting.spell.hexcasting:potion/slowness": "Эффект замедления",
+	"hexcasting.spell.hexcasting:potion/regeneration": "Эффект регенерации",
+	"hexcasting.spell.hexcasting:potion/night_vision": "Эффект ночного зрения",
+	"hexcasting.spell.hexcasting:potion/absorption": "Эффект поглощения",
+	"hexcasting.spell.hexcasting:potion/haste": "Эффект спешки",
+	"hexcasting.spell.hexcasting:potion/strength": "Эффект силы",
+	"hexcasting.spell.hexcasting:flight": "Полёт",
+	"hexcasting.spell.hexcasting:lightning": "Громовержец",
+	"hexcasting.spell.hexcasting:summon_rain": "Призвать дождь",
+	"hexcasting.spell.hexcasting:dispel_rain": "Гнать дождь",
+	"hexcasting.spell.hexcasting:create_lava": "Создать лаву",
+	"hexcasting.spell.hexcasting:teleport": "Телепорт",
+	"hexcasting.spell.hexcasting:brainsweep": "Чистый разум",
+	"hexcasting.spell.hexcasting:sentinel/create/great": "Призвать чанк-лоадер метку",
+	"hexcasting.spell.hexcasting:open_paren": "Начало функции",
+	"hexcasting.spell.hexcasting:close_paren": "Конец функции",
+	"hexcasting.spell.hexcasting:escape": "Лямбда выражение",
+	"hexcasting.spell.hexcasting:eval": "Исполнить заклинание",
+	"hexcasting.spell.hexcasting:eval/delay": "Секрет!",
+	"hexcasting.spell.hexcasting:read": "Чтение предмета",
+	"hexcasting.spell.hexcasting:write": "Запись в предмет",
+  "hexcasting.spell.hexcasting:readable": "Проверка чтимости",
+  "hexcasting.spell.hexcasting:readable/entity": "Проверка чтимости II",
+  "hexcasting.spell.hexcasting:writable": "Проверка вписываемости",
+	"hexcasting.spell.hexcasting:read/entity": "Чтение сущности",
+	"hexcasting.spell.hexcasting:akashic/read": "Чтение акаши",
+  "hexcasting.spell.hexcasting:akashic/write": "Запись акаши",
+	"hexcasting.spell.hexcasting:const/vec/px": "Взгляд +X",
+	"hexcasting.spell.hexcasting:const/vec/py": "Взгляд +Y",
+	"hexcasting.spell.hexcasting:const/vec/pz": "Взгляд +Z",
+	"hexcasting.spell.hexcasting:const/vec/nx": "Взгляд -X",
+	"hexcasting.spell.hexcasting:const/vec/ny": "Взгляд -Y",
+	"hexcasting.spell.hexcasting:const/vec/nz": "Взгляд -Z",
+	"hexcasting.spell.hexcasting:const/vec/0": "Взгляд 0",
+	"hexcasting.spell.hexcasting:const/vec/x": "Vector Rfln. +X/-X",
+	"hexcasting.spell.hexcasting:const/vec/y": "Vector Rfln. +Y/-Y",
+	"hexcasting.spell.hexcasting:const/vec/z": "Vector Rfln. +Z/-Z",
+	"hexcasting.spell.hexcasting:const/double/pi": "Значение Пифагора",
+	"hexcasting.spell.hexcasting:const/double/tau": "Значение Тау",
+	"hexcasting.spell.hexcasting:const/double/e": "Значение эйлера",
+	"hexcasting.spell.hexcasting:number": "Число",
+	"hexcasting.spell.hexcasting:mask": "Bookkeeper's Gambit",
+	"hexcasting.spell.unknown": "чё-то специальное",
+
+	"hexcasting.mishap.invalid_pattern": "Эти линии не образуют правильную руну",
+	"hexcasting.mishap.invalid_spell_datum_type": "Попытка использовать неверный тип как SpellDatum: %s (тип %s). Баг детектед.",
+	"hexcasting.mishap.invalid_value": "%s ожидал %s по индексу %s стэка, но получил %s",
+	"hexcasting.mishap.invalid_value.class.double": "число",
+	"hexcasting.mishap.invalid_value.class.vector": "вектор",
+	"hexcasting.mishap.invalid_value.class.list": "последовательность",
+	"hexcasting.mishap.invalid_value.class.widget": "абстракция",
+	"hexcasting.mishap.invalid_value.class.pattern": "руна",
+	"hexcasting.mishap.invalid_value.class.entity.item": "предмет",
+	"hexcasting.mishap.invalid_value.class.entity.player": "игрок",
+	"hexcasting.mishap.invalid_value.class.entity.villager": "житель",
+	"hexcasting.mishap.invalid_value.class.entity.living": "живое существо",
+	"hexcasting.mishap.invalid_value.class.entity": "существо",
+	"hexcasting.mishap.invalid_value.class.unknown": "БАГ ДЕТЕКТЕД",
+	"hexcasting.mishap.invalid_value.numvec": "число или вектор",
+	"hexcasting.mishap.invalid_value.numlist": "число или очередь",
+	"hexcasting.mishap.invalid_value.list.pattern": "последовательность рун",
+  "hexcasting.mishap.invalid_value.int": "целое число",
+	"hexcasting.mishap.invalid_value.double.between": "число между %d и %d",
+	"hexcasting.mishap.invalid_value.int.between": "целое число между %d и %d",
+	"hexcasting.mishap.not_enough_args": "%s ожидалось %s или больше аргументов, но стэк имеет %s",
+	"hexcasting.mishap.too_many_close_parens": "Лишняя скобка закрытия функции",
+	"hexcasting.mishap.wrong_dimension": "%s не может увидеть %s из %s",
+	"hexcasting.mishap.location_too_far": "%s слишком далеко для %s",
+	"hexcasting.mishap.entity_too_far": "%s слишком далеко для %s",
+  "hexcasting.mishap.immune_entity": "%s не может отобразить %s",
+	"hexcasting.mishap.eval_too_deep": "Достигнут предел рекурсии",
+	"hexcasting.mishap.no_item": "%s ожидал %s, но получил ничего",
+	"hexcasting.mishap.no_item.offhand": "%s ожидал %s в другой руке, но получил ничего",
+	"hexcasting.mishap.bad_item": "%s ожидал %s, но получил %s",
+	"hexcasting.mishap.bad_item.offhand": "%s ожидал %s в другой руке, но получил %dx %s",
+	"hexcasting.mishap.bad_item.iota": "информация",
+	"hexcasting.mishap.bad_item.iota.read": "место чтения информации",
+	"hexcasting.mishap.bad_item.iota.write": "a place to write iotas to",
+	"hexcasting.mishap.bad_item.iota.readonly": "принимает только %s",
+	"hexcasting.mishap.bad_item.mana": " предмет-хранилище мысли",
+	"hexcasting.mishap.bad_item.mana_for_battery": "предмет сырой мысли",
+	"hexcasting.mishap.bad_item.only_one": "ровно один предмет",
+	"hexcasting.mishap.bad_item.eraseable": "очищаемый предмет",
+	"hexcasting.mishap.bad_item.bottle": "стекляный пузырь",
+	"hexcasting.mishap.bad_item.rechargable": "перезаряжаемый предмет",
+	"hexcasting.mishap.bad_block": "Ожидал %s на %s, но получил %s",
+	"hexcasting.mishap.bad_block.sapling": "саженец",
+	"hexcasting.mishap.bad_brainsweep": "%s отклонил разум жителя",
+	"hexcasting.mishap.already_brainswept": "Житель уже был использован",
+	"hexcasting.mishap.no_spell_circle": "%s требует рунный круг",
+	"hexcasting.mishap.others_name": "Пытался внедриться в конфиденциальность %s",
+	"hexcasting.mishap.divide_by_zero.divide": "Попытался делить %s на %s",
+	"hexcasting.mishap.divide_by_zero.project": "%s на %s",
+	"hexcasting.mishap.divide_by_zero.exponent": "Попытался возвести %s в %s",
+	"hexcasting.mishap.divide_by_zero.logarithm": "Попытался получить логарифм %s с основанием %s",
+	"hexcasting.mishap.divide_by_zero.zero": "нуль",
+	"hexcasting.mishap.divide_by_zero.zero.power": "нулевая степень",
+	"hexcasting.mishap.divide_by_zero.zero.vec": "нулевой вектор",
+	"hexcasting.mishap.divide_by_zero.power": "степень %s",
+	"hexcasting.mishap.divide_by_zero.sin": "сунус %s",
+	"hexcasting.mishap.divide_by_zero.cos": "косинус %s",
+	"hexcasting.mishap.no_akashic_record": "Отсутсвует Запись Акаши на %s",
+	"hexcasting.mishap.disallowed": "%s админ запретил.",
+
+	"hexcasting.landing": "Кажется я познал новый способ магического искусства, оно предпологает хаотичное написание рун. Это очаровывает. Я решил начать вести записи моих мыслей и находок.$(br2)$(l:https://discord.gg/4xxHGYteWk)Discord сервер(там большинство англичане)/$",
+
+	"hexcasting.entry.basics": "Вводный урок",
+	"hexcasting.entry.basics.desc": "Практикующие это искусство могут исполнять заклинания написанием странных комбинаций посохом в воздухе ( их называют рунами ) или создают могущественные магические предметы чтобы мнгновенно исполнять заклинания. Я хочу достить того же.",
+
+	"hexcasting.entry.casting": "Рунные заклинания",
+	"hexcasting.entry.casting.desc": "Я начинаю понимать как древние мастера исполняли свои заклинания. Это довольно времезатратный проект, уверен у меня получится всё понять. Посмотрим...",
+
+	"hexcasting.entry.items": "Магические предметы",
+	"hexcasting.entry.items.desc": "Я посвящаю эту секцию загадочным предметам, которые я обнаружил в ходе моего обучения.$(br2)Похоже множество этих предметов используется при совместном удержании с посохом. Думаю мне следует тщательно выбирать что находится в моей неведущей руке.",
+
+	"hexcasting.entry.greatwork": "Великое деяние (перевода 0%)",
+	"hexcasting.entry.greatwork.desc": "I have seen... so much. I have... experienced... annihilation and deconstruction and reconstruction. I have seen the atoms of the world screaming as they were inverted and subverted and demoted to energy. I have seen I have seen I have s$(k)get stick bugged lmao/$",
+
+	"hexcasting.entry.patterns": "Руны",
+	"hexcasting.entry.patterns.desc": "Список всех рун, в использовании которых я уверен.",
+
+	"hexcasting.entry.spells": "Продвинутые руны",
+	"hexcasting.entry.spells.desc": "Руны, которые совершают магические взаимодействия с окружающим миром.",
+
+	"hexcasting.entry.great_spells": "Сложные руны",
+	"hexcasting.entry.great_spells.desc": "Руны, изложенные здесь считаются легендарно сложными и мощными. Кажется они были использованы очень редко (к счастью, в древних текстах они упоминаются). Вероятно это просто трактирные байки, но попробовать стоит. Разве могут возникнуть проблемы?",
+
+
+	"_comment": "Основы",
+
+	"hexcasting.entry.media": "Мысли",
+	"hexcasting.page.media.1": "Мысли это вариант ментальной энергии, привязанная к разуму. Каждое живое существо генерирует потоки мысли при мозговой активности; после окончания цикла мозговой активности, потоки мысли выделяются в окружающую среду.$(br2)Искусство $(thing)Рунных/$ заклинаний о том как использовать мысли в своих целях.",
+	"hexcasting.page.media.2": "Мысли могут взаимодействовать с другими с помощью написания Мыслей в руны.$(p)Последователи этого искусства использовали сконцентрированную сферу Мыслей на конце палки - с помощью размахивания ей в воздухе в нужных комбинациях они были способны использовать достаточно Мыслей, чтобы взаимодействовать с миром с помощью рунных заклинаний.",
+	"hexcasting.page.media.3": "К сожалению даже такое живое существо как могу генерировать крайне малое количество Мыслей. Будет крайне непрактично использовать мои естественные Мысли для практики заклинаний.$(br2)Но древние текста говорят, что под землёй есть некие залежи кристализованные источники Мыслей, которые медленно пополняются.$(p)Я бы был очень рад найти такое.",
+
+	"hexcasting.entry.geodes": "Жеоды",
+	"hexcasting.page.geodes.1": "При копании глубоко под землёй я нашёл жеоду, которая наполнена кристализованными залежами энергии, сжимающая мой череп и мысли. $(italic)Должно быть это место/$, о котором было написано в древних текстах. Эти криссалы аметиста должно быть содержат $(thing)физическую форму Мыслей./$",
+	"hexcasting.page.geodes.2": "Похоже, в дополнение к $(item)Осколкам аметиста/$, которые я вижу чаще всего, эти кристалы так же могут дать мне $(item)Аметистовую пыль/$ и $(item)Заряженные кристалы аметиста/$. С зачарованием удачи на кирке шанс получения заряженных кристалов выше.",
+	"hexcasting.page.geodes.3": "При погружении в красоту жеоды я чувствую потоки ветряных Мыслей, посещающих мой разум с невероятной скоростью. Это великолепное чувство.$(br2)Наконец-таки моё погружение в эту бездну обретает некий смысл.$(p) Мне следует перепрочесть старые текста, так как теперь я имею большее понимание с чем работаю.",
+
+	"hexcasting.entry.couldnt_cast": "Бессилие",
+	"hexcasting.page.couldnt_cast.1": "Чёрт! Почему я не могу использовать эту руну?!$(br2)Свиток, который я нашёл, отвечает аутентично. Я могу $(italic)почувствовать/$ его треск в свитке - порядок верный, или настолько верный насколько есть возможность. Заклинание $(italic)уже должно было исполниться/$.$(p)Но кажется, что по ту сторону некая тонкая мембрана. Заклинание почти исполнилось, но что-то мешало, мне необходимо преодолеть этот барьер.",
+	"hexcasting.page.couldnt_cast.2": "Кажется барьер ослабляется с приложенной силой заклинания; не смотря на мои усилия, мою концентрацию, мои лучшие аметисты, мои великолепные зарисовки - оно $(italic)отказывается/$ пресечь барьер. Это сводит с ума.$(p)$(italic)Неужели это/$ конец моего обучения? Проклятие слабости, проклятие потерять мою мощь?$(br2)Мне следует глубоко вздохнуть. Мне следует сконцентрироваться на том что мешает мне...",
+	"hexcasting.page.couldnt_cast.3": "После тщательного обдумывания я нашёл изменение в себе.$(p)Будучи в окружении $(item)аметистов/$, Я научился исполнять руны используя мою энергию разума и жизни - как было написано в древних текстах.$(p)Не знаю почему теперь я могу. Это бремя знания истины и я ношу его всегда. Я знаю. Я обременён.$(br2)К счастью, я чувствую свои пределы, с меня получилось бы около двух $(item)Заряженных кристалов аметиста/$ Мысли из моего здоровья, разума.",
+	"hexcasting.page.couldnt_cast.4": "Я содрагаю в понимании этого... До этого мой разум был практически цел до сей поры, в моих исследованиях. Но оказалось что я формирую одну сторону тонской связи.$(p)Я присоединен к некой другой стороне - сторона, которая была практически истощена этой болью. Место где простые действия даруют великую славу.$(p)Неужели так плохо хотеть этого для себя?",
+
+	"hexcasting.entry.start_to_see": "ЧТО Я ВИДЕЛ",
+	"hexcasting.page.start_to_see.1": "Тексты не лгали. Природа взяла свою положенную долю.",
+	"hexcasting.page.start_to_see.2": "Это... это было...$(p)...это были самые ужасные чувства, которые я испытывал. Я предложила природе свой план и почуствовал лёгкую улыбку и плачевное чувство взамен - часть меня, моего разума растворилась, как аметистовая пыль под дождём.$(p)Моё $(italic)выживание на грани/$ это невероятная удача, несмотря на это мне хватает сил что писать это, следует закрыть этот вопрос, перепроверять мои расчёты и больше не допускать такой ужасающей ошибки",
+	"hexcasting.page.start_to_see.3": "...Но.$(br2) Но на мнгновение, часть меня... $(italic)видела/$... нечто. Место....$(p)И мембранный барьер, отделяющий меня от сырой реальности, наполненной лёгкой, светлой энергией Мысли. Я помню, я видел, чувствовал, вспоминал барьер, слегка трещащий на гранях.$(p)Я хотел $(italic)туда, сквозь./$",
+	"hexcasting.page.start_to_see.4": "Мне не следует этого делать. Я $(italic)знаю/$, это будет слишком опасно. Мне не следует. Опасно. Попытка этого поставит меня на мост, с огромной возможностью сорваться в низ, к безумию, к смерти.$(br2)Но я так близок...$(italic)Близок/$.$(p)$(italic)Это/$ кульминация моих исследований. Это $(#54398a)Прорицание/$, которого я искал. $(br2)Я хочу больше. Я должен испытать это снова. Я $(italic)увижу/$ это ещё раз.$(p) Как моожно не мечтать о вечной славе, о великой силе?",
+
+
+	"_comment": "Исполнение рун",
+
+	"hexcasting.entry.101": "Урок первый.",
+	"hexcasting.page.101.1": "Исполнение рунных заклинаний немного сложный процесс, неудивительно, что это искусство было практически забыто. Я перепрочту мои записи тщательно.$(br2)Я могу начать писать Руну зажав $(k:use) с $(item)Посохом/$ в моей руке, я увижу диагональную сетку точек в воздухе, передо мной. Дальше я могу зажимать и двигать посохом от точки до точки, чтобы писать руны в Мыслях сетки; завершение руны запустит её действие, описанное во вкладке Руны.",
+	"hexcasting.page.101.2": "Как только я написал достаточное количество рун для исполнения заклинания сетка исчезнет как Мысли, которые я сохранил будут выпущены. Я также могут нажать Escape если хочу покинуть сетку заранее, если я конечно не опасаюсь некоторой ошибки, которая может привести к неприятностям ( чем больше Мыслей я использовал тем выше шанс, что последствия будут ).$(br2) Так как работают Руны? В кратце:$(li)$(italic)Руны/$ будут испольнять...$(li)$(italic)Действия/$, которые используют $(li)$(italic)Стэк/$, являющийся очередью... Из различной $(li)$(italic)Информации/$.",
+	"hexcasting.page.101.3": "Во первых, $(thing)Руны/$. Они основополагающие - их я использую чтобы взаимодействовать с Мыслями вокруг меня. Некоторые руны, когда написаны, совершат $(thing)действия/$. Действия на самом деле и $(italic)делают всю магию/$; все руны манипулируют Мыслями разными методами и если метод оканчивается чем-то полезным это называется действием.$(br2)Мысли могут быть изменчивыми: если я напишу неправильную руну то получу в результате мусор где-то в моём стэке",
+	"hexcasting.page.101.4.header": "Пример",
+	"hexcasting.page.101.4": "Следует заметить что $(italic)направление/$ этих рун не важно. Обе этих руны исполняют действие $(l:patterns/basics#hexcasting:get_caster)$(action)Зеркало нарцисса/$",
+	"hexcasting.page.101.5": "Заклинания исполняются написанием (верных) рун по очереди. 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.",
+	"hexcasting.page.101.6": "$(l:patterns/basics#hexcasting:get_caster)$(action)Зеркало нарцисса/$ поместит на верх стэка информацию об игроке, который исполняет заклинание. $(l:patterns/basics#hexcasting:get_entity_pos)$(action)Положение сущности/$ возьмёт информацию о сущности с верха стэка и вернёт её положение на верх стэка. $(br2)Так что написание рун в этом порядке положит на верх стэка моё положение.",
+	"hexcasting.page.101.7": "$(thing)Информация/$ может представлять такие вещи как я или моя позиция, но есть другие типы которыми я могу управлять с помощью $(thing)Действий$(0). Список типов информации:$(li)Числа (\"doubles\");$(li)Вектора (\"vector\") 3 числа представляющие позицию или направление",
+	"hexcasting.page.101.8": "$(li)Сущности, как я, куры, вагонетки, валяющиеся предметы;$(li)Абстракции;$(li)Очередь из рун, использующаяся для создания магических предметов и мозговыносящих заклинаний как $(italic)заклинания, которые вызывают другие/$; И$(li)Очередь с любыми типами информации",
+	"hexcasting.page.101.9": "Естественно все заклинания тратят Мысли в качестве оплаты.$(br2)Как я понимаю заклинания это план действий, представленный Природе - в этой аналогии Мысли используются для соединения с Природой, передачи ей информации.",
+	"hexcasting.page.101.10": "К слову, похоже никто не делал исследований по поводу того $(italic)сколько Мысли хранит аметист/$. $(item)Осколок аметиста/$ около пяти $(item)Аметистовой Пыли/$, и $(item)Заряженный кристал аметиста/$ около 10.(br2)Достаточно странно, видимо другие формы аметиста не подходят для исполнения заклинаний. Цельные блоки кристалов и цельные кристалы слишком большие чтобы запросто конвертироваться в Мысли.",
+	"hexcasting.page.101.11": "Следует отметить, что Действие потребляет Мысли сразу, а не когда заклинание окончено. Так же Действие всегда потребляет цельный предмет, к примеру, если руна требует 1 $(item)Аметистовую пыль/$ заберёт в оплату целый $(item)Заряженный кристал аметиста/$, если это единственный источник Мысли в моём инвентаре.$(br2)Хорошей идеей будет брать немного пыли для заклинаний, чтобы не тратить лишнего.",
+	"hexcasting.page.101.12": "Судя по древним текстам, недостаток Мысли в инвентаре для заклинания может вызвать ужасные последствия - в качестве оплаты, будет принята часть разума. Ощущения описываются как - слабость, жуткая боль, страдания, растворение плоти...\"$(br)Вероятно из-за этого все последователи этой магии сошли с ума. Я не могу представить себе плавление $(italic)частей моего разума/$.",
+	"hexcasting.page.101.13": "Возможно что-то поменялось, наверное. В моих экспериментах у меня не получалось потратить больше Мысли чем есть у меня в виде аметистов, будто что-то оберегает меня.$(br2)Было бы интересно достичь дна этой мистики, но сейчас что-то оберегает меня...",
+	"hexcasting.page.101.14": "I have also found an amusing tidbit on why so many practitioners of magic in general seem to go mad, which I may like as some light and flavorful reading not canonical to my world.$(br2)$(italic)Content Warning: some body horror and suggestive elements./$",
+	"hexcasting.page.101.14.link_text": "Goblin Punch",
+	"hexcasting.page.101.15": "Похоже, все руны имеют ограничение в дистанции работы, около 32 блоков радиуса, если попытаться активировать заклинание за пределами этого круга руна не сработает.",
+
+	"hexcasting.entry.vectors": "A Primer on Vectors",
+	"hexcasting.page.vectors.1": "It seems I will need to be adroit with vectors if I am to get anywhere in my studies. I have compiled some resources here on vectors if I find I do not know how to work with them.$(br2)First off, an enlightening video on the topic.",
+	"hexcasting.page.vectors.1.link_text": "3blue1brown",
+	"hexcasting.page.vectors.2": "Additionally, it seems that the mages who manipulated $(thing)Psi energy/$ (the so-called \"spellslingers\"), despite their poor naming sense, had some quite-effective lessons on vectors to teach their acolytes. I've taken the liberty of linking to one of their texts on the next page.$(br2)They seem to have used different language for their spellcasting:$(li)A \"Spell Piece\" was their name for an action;$(li)a \"Trick\" was their name for a spell; and$(li)an \"Operator\" was their name for a non-spell action.",
+	"hexcasting.page.vectors.3": "Link here.",
+	"hexcasting.page.vectors.3.link_text": "Psi Codex",
+
+	"hexcasting.entry.mishaps": "Ошибки и последствия",
+	"hexcasting.page.mishaps.1": "Я не идеален, я делаю ошибки время от времени во время обучения и исполнения заклинаний; например если допустить ошибку в написании руны или использовать руну без нужных аргументов. Ошибки не прощаются, допуская ошибку я получу $(italic)неприятности/$.",
+	"hexcasting.page.mishaps.2": "Неверная руна будет подсвечена красным на сетке. Основываясь на типе ошибки можно ожидать различные эффекты и разноцветные искорки. $(br2)Так же я получу полезное сообщение в чате ( грядёт обновление и это вырежут!).",
+	"hexcasting.page.mishaps.3": "Fortunately, although the bad effects of mishaps are certainly $(italic)annoying/$, none of them are especially destructive in the long term. Nothing better to do than dust myself off and try again ... but I should strive for better anyways.$(br2)Following is a list of mishaps I have compiled.",
+	"hexcasting.page.mishaps.invalid_pattern.title": "Invalid Pattern",
+	"hexcasting.page.mishaps.invalid_pattern": "The pattern drawn is not associated with any action.$(br2)Causes yellow sparks, and a $(l:casting/influences)$(action)Garbage/$ will be pushed to the top of my stack.",
+	"hexcasting.page.mishaps.not_enough_iotas.title": "Not Enough Iotas",
+	"hexcasting.page.mishaps.not_enough_iotas": "The action required more iotas than were on the stack.$(br2)Causes light gray sparks, and as many $(l:casting/influences)$(action)Garbages/$ as would be required to fill up the argument count will be pushed.",
+	"hexcasting.page.mishaps.incorrect_iota.title": "Incorrect Iota",
+	"hexcasting.page.mishaps.incorrect_iota": "The action that was executed expected an iota of a certain type for an argument, but it got something invalid. If multiple iotas are invalid, the error message will only tell me about the error deepest in the stack.$(br2)Causes dark gray sparks, and the invalid iota will be replaced with $(l:casting/influences)$(action)Garbage/$.",
+	"hexcasting.page.mishaps.vector_out_of_range.title": "Vector Out of Ambit",
+	"hexcasting.page.mishaps.vector_out_of_range": "The action tried to affect the world at a point that was out of my range.$(br2)Causes magenta sparks, and the items in my hands will be yanked out and flung towards the offending location.",
+	"hexcasting.page.mishaps.entity_out_of_range.title": "Entity Out of Ambit",
+	"hexcasting.page.mishaps.entity_out_of_range": "The action tried to affect an entity that was out of my range.$(br2)Causes pink sparks, and the items in my hands will be yanked out and flung towards the offending entity.",
+	"hexcasting.page.mishaps.entity_immune.title": "Entity is Immune",
+	"hexcasting.page.mishaps.entity_immune": "The action tried to affect an entity that cannot be altered by it.$(br2)Causes blue sparks, and the items in my hands will be yanked out and flung towards the offending entity.",
+	"hexcasting.page.mishaps.math_error.title": "Mathematical Error",
+	"hexcasting.page.mishaps.math_error": "The action did something offensive to the laws of mathematics, such as dividing by zero.$(br2)Causes red sparks, pushes a $(l:casting/influences)$(action)Garbage/$ to my stack, and my mind will be ablated, stealing half the vigor I have remaining. It seems that Nature takes offense to such operations, and divides $(italic)me/$ in retaliation.",
+	"hexcasting.page.mishaps.incorrect_item.title": "Incorrect Item",
+	"hexcasting.page.mishaps.incorrect_item": "The action requires some sort of item, but the item I supplied was not suitable.$(br2)Causes brown sparks. If the offending item was in my hand, it will be flung to the floor. If it was in entity form, it will be flung in the air.",
+	"hexcasting.page.mishaps.incorrect_block.title": "Incorrect Block",
+	"hexcasting.page.mishaps.incorrect_block": "The action requires some sort of block at a target location, but the block supplied was not suitable.$(br2)Causes bright green sparks, and causes an ephemeral explosion at the given location; it will harm me and others, but will not destroy any blocks.",
+	"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 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": "Я попытался $(l:patterns/readwrite#hexcasting:write)$(action)сохранить информацию/$ о другом игроке.$(br2)Вызывает чёрные искрыs, 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.entry.stack": "Стэк",
+	"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.",
+	"hexcasting.page.stack.2": "Because a stack is so simple, there's only so many things you can do with it:$(li)$(italic)Adding something to it/$, known formally as pushing,$(li)$(italic)Removing the last added element/$, known as popping, or$(li)$(italic)Examining or modifying the last added element/$, known as peeking.$(br)We call the last-added element the \"top\" of the stack, in accordance with the dinner plate analogy.$(p)As an example, if we push 1 to a stack, then push 2, then pop, the top of the stack is now 1.",
+	"hexcasting.page.stack.3": "Actions are (on the most part) restricted to interacting with the casting stack in these ways. They will pop some iotas they're interested in (known as \"arguments\" or \"parameters\"), process them, and push some number of results.$(br2)Of course, some actions (e.g. $(l:patterns/basics#hexcasting:get_caster)$(action)Mind's Reflection/$) might pop no arguments, and some actions (particularly spells) might push nothing afterwards.",
+	"hexcasting.page.stack.4": "Even more complicated actions can be expressed in terms of pushing, popping, and peeking. For example, $(l:patterns/stackmanip#hexcasting:swap)$(action)Jester's Gambit/$ swaps the top two items of the stack. This can be thought of as popping two items and pushing them in opposite order. For another, $(l:patterns/stackmanip#hexcasting:duplicate)$(action)Gemini Decomposition/$ duplicates the top of the stack-- in other words, it peeks the stack and pushes a copy of what it finds.",
+
+	"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 $(thing)Demoman's Gambit/$ when you could just say $(thing)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 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 Consideration, Introspection, and Retrospection. 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 random, like pests, when I drawn an invalid pattern. Turning my (admittedly very poor) ethereal senses towards them, I see only a nonsense jumble.",
+
+
+	"_comment": "Предметы",
+
+	"hexcasting.entry.amethyst": "Аметист",
+	"hexcasting.page.amethyst.1": "Похоже существует 3 разных типа аметиста, который я могу получить ломая кристалы внутри жеоды. Самая маленькая форма из них - пыль, имеющая в себе крайне незначительное количество мысли.",
+	"hexcasting.page.amethyst.2": "Второй - цельный осколок аметиста, который может быть использован не только колдуны. В осколке содержится столько же мысли сколько находится в 5 штуках $(item)Аметистовой Пыли/$s.",
+	"hexcasting.page.amethyst.3": "Наконец, редко я буду находить болшьшие куски кристалов, переполняющиеся энергией. В них находится объем 10 $(item)Аметистовой Пыли/$s (или двух $(item)Осколков Аметиста/$s).",
+	"hexcasting.page.amethyst.4": "$(italic)The old man sighed and raised a hand toward the fire. He unlocked a part of his brain that held the memories of the mountains around them. He pulled the energies from those lands, as he learned to do in Terisia City with Drafna, Hurkyl, the archimandrite, and the other mages of the Ivory Towers. He concentrated, and the flames writhed as they rose from the logs, twisting upon themselves until they finally formed a soft smile./$",
+
+	"hexcasting.entry.Посох": "Посох",
+	"hexcasting.page.staff.1": "$(item)Посох/$ это моя точка входа в использовании рун всех типов. Если держать его в руке и нажать $(thing)$(k:use)/$, я начну писать руну; тогда я смогу зажать любую кнопку мыши чтобы писать руны.$(br2)Это нечто большее чем просто кусок мысли на конце палки; в конечном счётё это всё что нужно.",
+	"hexcasting.page.staff.crafting.header": "Вставки",
+	"hexcasting.page.staff.crafting.desc": "Посох можно создать из различных видов дерева и он будет выглядеть по-разному, это $(italic)не влияет на руны/$",
+
+	"hexcasting.entry.lens": "Линза прозрения",
+	"hexcasting.page.lens.1": "Мысли могут иметь эффект на любом типе информации, в особых условиях. Покрытие стекляшки тонкий слоем из мыслей может помочь узнать множество нового.$(br2)Удерживая $(item)Линзу прозрения/$ в моей руке, некоторые блоки будут показывать дополнительную информацию когда я смотрю на них.",
+	"hexcasting.page.lens.2": "К примеру, смотря на редстоун пылинку я увижу силу её сигнала. Я предполагаю, что узнаю множество других блоков, с которыми взаимодействует линза.$(br2)В дополнение, удерживая её при написании рун сильно уменьшит расстояние между точками на рунной сетке, что позволит мне написать куда больше рун.",
+	"hexcasting.page.lens.3": "$(italic)You must learn... to see what you are looking at./$",
+
+	"hexcasting.entry.focus": "Талисман",
+	"hexcasting.page.focus.1": "$(item)Талисман/$ может хранить одну единицу информации.$(br2)При создании она имеет внутри Null абстракцию. Используя $(l:patterns/readwrite#hexcasting:write)$(action)Scribe's Gambit/$ while holding a $(item)Focus/$ in my other hand will remove the top of the stack and save it into the $(item)Focus/$. Using $(l:patterns/readwrite#hexcasting:read)$(action)Запись в предмет/$ можно сохранить любую информацию в $(item)Талисман/$ и добавить её в стэк позже.",
+	"hexcasting.page.focus.2": "Вероятно я могу хранить целую очередь из рун в $(item)Талисмане/$, а затем вызывать их и использовать с помощью $(l:patterns/meta#hexcasting:eval)$(action)/$. Таким образом я могу исполнять комплексные заклинани, или части заклинаний, без необходимости постоянно их писать.$(br2)Думаю я могу сильно укоротить заклинания, положив часто встречающиеся очереди рун в $(item)Талисман/$, например быстрый доступ к координатам блока на который я смотрю.",
+	"hexcasting.page.focus.3": "Также, если я сохраню сущность в $(item)Талисмане/$ и попробую получить её после того как сущность погибла или исчезла $(action)Чтение из предмета/$ вернёт Null абстракцию заместо сущности.$(br2)С помощью медовых сот я могу защитить талисман от случайной перезаписи. Попытавшись использоватоь $(action)Запись в предмет/$ на залипшем талисмане провалится.",
+	"hexcasting.page.focus.4": "$(italic)Poison apples, poison worms./$",
+
+	"hexcasting.entry.abacus": "Счёты",
+	"hexcasting.page.abacus.1": "Числа могут быть выражены не только с помощью рун, старые мастера рунного ремесла создали предмет, позволяющий быстро получать числа с помощью $(item)Счётов/$. Просто установить число на счётах и прочесть его с помощью $(l:patterns/readwrite#hexcasting:read)$(action)Чтения из предмета/$, будто я получаю информацию из $(item)Талисмана/$.",
+	"hexcasting.page.abacus.2": "Чтобы управлять счётами, нужно держать их, присесть и использовать колесо мыши. В основной руке число будет изменяться на 1 или 10 если я удерживаю Ctrl(Command для Эпл). В другой руке число измениться на 0.1 или 0.001.$(br2)Я могу встрясти счёты чтобы вернуть их к 0 с помощью приседания+правая кнопка мыши.",
+	"hexcasting.page.abacus.3": "$(italic)Mathematics? That's for eggheads!/$",
+
+	"hexcasting.entry.spellbook": "Книга заклинаний",
+	"hexcasting.page.spellbook.1": "A $(item)Spellbook/$ is the culmination of my art-- it acts like an entire library of $(l:items/focus)$(item)Foci/$.$(br2)Each page can hold a single iota, and I can select the active page (the page that iotas are saved to and copied from) by sneak-scrolling while holding it, or simply holding it in my off-hand and scrolling while casting a _Hex.",
+	"hexcasting.page.spellbook.2": "$(italic)Wizards love words. Most of them read a great deal, and indeed one strong sign of a potential wizard is the inability to get to sleep without reading something first.",
+
+	"hexcasting.entry.scroll": "Scrolls",
+	"hexcasting.page.scroll.1": "A $(item)Scroll/$ is a convenient method of sharing a pattern with others. I can copy a pattern onto one with $(l:patterns/readwrite#hexcasting:write)$(action)Scribe's Gambit/$, after which it will display in a tooltip.$(br2)I can also place them on the wall as decoration, like a Painting. Using $(item)Amethyst Dust/$ on such a scroll will have it display the stroke order.",
+	"hexcasting.page.scroll.2": "In addition, I can also find so-called $(item)Ancient Scrolls/$ in the dungeons and strongholds of the world. These contain the stroke order of Great Spells, powerful magicks rumored to be too powerful for the hands and minds of mortals...$(br2)If those \"mortals\" couldn't cast them, I'm not sure they deserve to know them.",
+	"hexcasting.page.scroll.3": "$(italic)I write upon clean white parchment with a sharp quill and the blood of my students, divining their secrets./$",
+
+	"hexcasting.entry.slate": "Slates",
+	"hexcasting.page.slate.1": "$(item)Slate/$s are similar to $(l:items/scroll)$(item)Scroll/$s; I can copy a pattern to them and place them in the world to display the pattern.$(br2)However, I have read vague tales of grand assemblies of $(item)Slate/$s, used to cast great rituals more powerful than can be handled by a $(item)Посох/$.",
+	"hexcasting.page.slate.2": "Perhaps this knowledge will be revealed to me with time. But for now, I suppose they make a quaint piece of decor.$(br2)At the least, they can be placed on any side of a block, unlike $(item)Scroll/$s.",
+	"hexcasting.page.slate.3": "$(italic)This is the letter \"a.\" Learn it./$",
+	"hexcasting.page.slate.4": "I'm also aware of other types of $(item)Slate/$s, 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": "Hexcasting Items",
+	"hexcasting.page.hexcasting.1": "Although the flexibility that casting _Hexes \"on the go\" with my $(l:items/Staff)$(item)Посох/$ 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.2": "To do this, I can craft one of three types of magic items: $(item)Cypher/$s, $(item)Trinket/$s, or $(item)Artifact/$s. 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 Посох, using its internal battery.",
+	"hexcasting.page.hexcasting.3": "Each item has its own quirks:$(br2)$(item)Cypher/$s are single-use, destroyed after the _Hex is cast;$(br2)$(item)Trinket/$s can be cast as much as the holder likes, as long as there's enough _media left, but become useless afterwards;",
+	"hexcasting.page.hexcasting.4": "$(item)Artifact/$s 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 $(item)Посох/$. Of course, this also means the spell might consume their mind if there's not enough $(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. 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 $(item)Посох/$-- rather, the _media \"melts down\" into one continuous pool. Thus, if I store a _Hex that only costs one $(item)Amethyst Dust/$'s worth of mana, a $(item)Charged Crystal/$ used as the battery will allow me to cast it 10 times.",
+	"hexcasting.page.hexcasting.6": "$(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 $(item)Charged Crystal/$s, even the tiniest $(action)Archer's Purification/$ will consume the entire crystal, wasting the remaining _media.$(br2)Fortunately, it seems I've found a way 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 $(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 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.4": "$(italic)Drink the milk./$",
+
+	"hexcasting.entry.dyes": "Оттенки",
+	"hexcasting.page.dyes.1": "Оттенки позволяют менять цвет моей магии, круто!",
+
+	"hexcasting.page.dyes.2": "Чтобы использовать оттенок, нужно держать его в другой рука пока я исполняю $(l:patterns/spells/colorize)$(action)Использовать оттенок/$, оттенок будет поглощён.",
+	"hexcasting.page.оттенокs.3.header": "Необычные оттенки",
+	"hexcasting.page.оттенокs.3": "Оттенки всех цветов радуги.",
+	"hexcasting.page.оттенокs.4": "Оттенок полностью уникальный для каждого.",
+
+	"hexcasting.entry.decoration": "Декорации",
+	"hexcasting.page.decoration.1": "За время моего обучения я открыл некоторые строительные блоки и вещи, которые я нахожу подходящими для декорирования. Ниже я описал способы их создания.",
+	"hexcasting.page.decoration.2": "Коричневый краситель может использоваться чтобы симулировать вид древнего свитка.",
+	"hexcasting.page.decoration.3": "$(item)Аметистовая плитка/$s может быть создана в камнерезе.$(br2)$(item)Аметистовый песок/$ - из него нельзя сделать стекло.",
+	"hexcasting.page.decoration.4": "$(item)Аметистовые свечи/$s издают свет и частицы, а также приятный, успокаивающий звук.",
+
+
+	"_comment": "The Work",
+
+	"hexcasting.entry.the_work": "The Work",
+	"hexcasting.page.the_work.1": "I have seen so many things. Unspeakable things. Innumerable things. I could write three words and turn my mind inside-out and smear my brains across the shadowed walls of my skull to decay into fluff and nothing.",
+	"hexcasting.page.the_work.2": "I have seen staccato-needle patterns and acid-etched schematics written on the inside of my eyelids. They smolder there-- they dance, they taunt, they $(italic)ache/$. I'm possessed by an intense $(italic)need/$ to draw them, create them. Form them. Liberate them from the gluey shackles of my mortal mind-- present them in their Glory to the world for all to see.$(p)All shall see.$(p)All will see.",
+
+	"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 belived-- 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 $(item)Charged Crystals/$ for this perversion of will.",
+	"hexcasting.page.brainsweeping.4": "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",
+	"hexcasting.page.spellcircles.1": "I KNOW what the $(item)slates/$ are for. The grand assemblies lost to time. The patterns scribed on them can be actuated in sequence, automatically. Thought and power ricocheting through, one by one by one by one by one by through and through and THROUGH AND -- I must not I must not I should know better than to think that way.",
+	"hexcasting.page.spellcircles.2": "To start the ritual I need an $(item)Impetus/$ to create a self-sustaining wave of _media. That wave travels along a track of $(item)slate/$s or other blocks suitable for the energies, one by one, collecting any patterns it finds. Once the wave circles back around to the $(item)Impetus/$, all the patterns encountered are cast in order.$(br2)The direction the _media exits any given block MUST be unambiguous, or the casting will fail at the block with too many neighbors.",
+	"hexcasting.page.spellcircles.3": "As a result, the outline of the spell \"circle\" may be any closed shape, concave or convex, and it may face any direction. In fact, with the application of certain other blocks it is possible to make a spell circle that spans all three dimensions. I doubt such an oddity has very much use, but I must allocate myself a bit of vapid levity to encourage my crude mind to continue my work.",
+	"hexcasting.page.spellcircles.4": "Miracle of miracles, the circle will withdraw _media neither from my inventory nor my mind. Instead, crystallized shards of _media must be provided to the $(item)Impetus/$ via hopper, or other such artifice.$(br2)The application of a $(item)Scrying Lens/$ will show how much _media is inside an $(item)Impetus/$, in units of dust.",
+	"hexcasting.page.spellcircles.5": "However, a spell cast from a circle does have one major limitation: it is unable to affect anything outside of the circle's bounds. That is, it cannot interact with anything outside of the cuboid of minimum size which encloses every block composing it (so a concave spell circle can still affect things in the concavity).",
+	"hexcasting.page.spellcircles.6": "There is also a limit on the number of blocks the wave can travel through before it disintegrates, but it is large enough I doubt I will have any trouble.$(br2)Conversely, there are some actions that can only be cast from a circle. Fortunately, none of them are spells; they all seem to deal with components of the circle itself. My notes on the subject are $(l:patterns/circle)here/$.",
+	"hexcasting.page.spellcircles.7": "I also found a sketch of a spell circle used by the ancients buried in my notes. Facing this page is my (admittedly poor) copy of it.$(br2)The patterns there would have been executed counter-clockwise, starting with $(action)Mind's Reflection/$ and ending with $(action)Greater Teleport/$.",
+	"hexcasting.page.spellcircles.8.title": "Teleportation Circle",
+
+	"hexcasting.entry.impetus": "Impetuses",
+	"hexcasting.page.impetus.1": "The fluctuation of _media required to actuate a spell circle is complex. Even the mortal with sharpest eyes and steadiest hands could not serve as an $(item)Impetus/$ and weave _media into the self-sustaining ourobouros required.$(br2)The problem is that the mind is too full of other useless $(italics)garbage/$.",
+	"hexcasting.page.impetus.2": "At a ... metaphysical level-- I must be careful with these thoughts, I cannot lose myself, I have become too valuable --moving _media moves the mind, and the mind must be moved for the process to work. But, the mind is simply too $(italic)heavy/$ with other thoughts to move nimbly enough.$(br2)It is like an artisan trying to repair a watch while wearing mittens.",
+	"hexcasting.page.impetus.3": "There are several solutions to this conundrum: through meditative techniques one can learn to blank the mind, although I am not certain a mind free enough to actuate a circle can concentrate hard enough to do the motions.$(br2)Certain unsavory compounds can create a similar effect, but I know nothing of them and do not plan to learn. I must not rely on the chemicals of my brain.",
+	"hexcasting.page.impetus.4": "The solution I aim for, then, is to specialize a mind. Remove it from the tyranny of nerves, clip all outputs but delicate splays of _media-manipulating apparati, cauterize all inputs but the signal to start its work.$(br2)The process of $(action)mindflaying/$ I am now familiar with will do excellently; the mind of a villager is complex enough to do the work, but not so complex as to resist its reformation.",
+	"hexcasting.page.impetus.5": "First, the cradle. Although it does not work as an $(item)Impetus/$, the flow of _media in a circle will only exit out the side pointed to by the arrows. This allows me to change the plane in which the wave flows, for example.",
+	"hexcasting.page.impetus.6": "Then, to transpose the mind. Villagers of different professions will lend different actuation conditions to the resulting $(item)Impetus/$. A Toolsmith's activates on a simple $(k:use).",
+	"hexcasting.page.impetus.7": "A Cleric Impetus must be bound to a player by using an item with a reference to that player, like a $(item)Focus/$, on the block. Then, it activates when receiving a redstone signal.$(br2)",
+	"hexcasting.page.impetus.8": "Peculiarly to this Impetus, the bound player, as well as a small region around them, are always accessible to the spell circle. It's as if they were standing within the bounds of the circle, no matter how far away they might stand.$(br2)The bound player is shown when looking at a Cleric Impetus through a $(item)Scrying Lens/$.",
+	"hexcasting.page.impetus.9": "A Fletcher Impetus activates when looked at for a short time.",
+
+	"hexcasting.entry.directrix": "Directrices",
+	"hexcasting.page.directrix.1": "Simpler than the task of creating a self-sustaining wave of _media is the task of directing it. Ordinarily the wave disintegrates when coming upon a crossroads, but with a mind to guide it, an exit direction can be controlled.$(br2)This manipulation is not nearly so fine as the delicacy of actuating a spell circle. In fact, it might be possible to do it by hand... but the packaged minds I have access to now would be so very convenient.",
+	"hexcasting.page.directrix.2": "A Directrix accepts a wave of _media and determines to which of the arrows it will exit from, depending on the villager mind inside.$(br2)I am not certain if this idea was bestowed upon me, or if my mind is bent around the barrier enough to splint off its own ideas now... but if the idea came from my own mind, if I thought it, can it be said it was bestowed? The brain is a vessel for the mind and the mind is a vessel for ideas and the ideas vessel thought and thought sees all and knows all-- I MUST N O T",
+	"hexcasting.page.directrix.3": "Firstly, a design for the cradle ... although, perhaps \"substrate\" would be more accurate a word. Without a mind guiding it, the output direction is determined by microscopic fluctuations in the _media wave and surroundings, making it effectively random.",
+	"hexcasting.page.directrix.4": "A Mason Directrix switches output side based on a redstone signal. Without a signal, the exit is the _media-color side; with a signal, the exit is the redstone-color side.",
+
+	"_comment": "Руны",
+
+	"hexcasting.entry.readers_guide": "Как читать эту секцию",
+	"hexcasting.page.readers_guide.1": "I've divided all the valid patterns I've found into sections based on what they do, more or less. I've written down the stroke order of the patterns as well, if I managed to find it in my studies, with the start of the pattern marked with a red dot.$(br2)If an action is cast by multiple patterns, as is the case with some, I'll write them all side-by-side.",
+	"hexcasting.page.readers_guide.2": "For a few patterns, however, I was $(italic)not/$ able to find the stroke order, just the shape. I suspect the order to draw them in are out there, locked away in the ancient libraries and dungeons of the world.$(br2)In such cases I just draw the pattern without any information on the order to draw it in.",
+	"hexcasting.page.readers_guide.3": "I also write the types of iota that the action will consume or modify, a \"\u2192\", and the types of iota the action will create.$(p)For example, \"$(n)vector, number/$ \u2192 $(n)vector/$\" means the action will remove a vector and a number from the top of the stack, and then add a vector; or, put another way, will remove a number from the stack, and then modify the vector at the top of the stack. (The number needs to be on the top of the stack, with the vector right below it.)",
+	"hexcasting.page.readers_guide.4": "\"\u2192 $(n)entity/$\" means it'll just push an entity. \"$(n)entity, vector/$ \u2192\" means it removes an entity and a vector, and doesn't push anything.$(br2)Finally, if I find the little dot marking the stroke order too slow or confusing, I can press $(thing)Control/Command/$ to display a gradient, where the start of the pattern is darkest and the end is lightest. This works on scrolls and when casting, too!",
+
+	"hexcasting.entry.basics_pattern": "Простые руны",
+	"hexcasting.page.basics_pattern.1": "Добавляет меня в стэк.",
+	"hexcasting.page.basics_pattern.2": "Превращает сущность в её позицию на верху стэка.",
+	"hexcasting.page.basics_pattern.3": "Превращает сущность в её направление взгляда на верху стэка.",
+	"hexcasting.page.basics_pattern.4": "Выводит верх стэка в чат.",
+	"hexcasting.page.basics_pattern.5": "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.6": "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 Null.",
+	"hexcasting.page.basics_pattern.7": "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.8": "More specifically, it returns the $(italic)normal vector/$ of the face hit, or a vector with length 1 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).$(br)",
+	"hexcasting.page.basics_pattern.9": "Like $(l:patterns/basics#hexcasting:raycast)$(action)Archer's Distillation$(/l), but instead returns the $(italic)entity/$ I am looking at.",
+
+	"hexcasting.entry.numbers": "Числа в рунах",
+	"hexcasting.page.numbers.1.header": "Написание числа",
+	"hexcasting.page.numbers.1": "Нет какого-то простейшего способа писать числа. Этот метод в теории является рабочим для любого числа и единственное ограничение - размер сетки.",
+	"hexcasting.page.numbers.2": "Сначала я пишу одну из двух вариаций руны показанной на следующей странице. Далее $(italic)угол/$ следующих линий будет изменять счётчик, который начинается с 0.$(li)Вперёд: Добавить 1$(li)Влево: Добавить 5$(li)Вправо: Добавить 10$(li)Ещё левее: Умножить на 2$(li)Ещё правее: Делить на 2.$(br)Развернутая руна на правой части страницы используется для отрицательных чисел.$(p) Как только руна написана число добавляется вверх стэка.",
+	"hexcasting.page.numbers.example.10.header": "Пример 1",
+	"hexcasting.page.numbers.example.10": "Руна для 10.",
+	"hexcasting.page.numbers.example.7.header": "Пример 2",
+	"hexcasting.page.numbers.example.7": "Руна для 7: 5 + 1 + 1.",
+	"hexcasting.page.numbers.example.-32.header": "Пример 3",
+	"hexcasting.page.numbers.example.-32": "Руна для -32: - ( 1 + 5 + 10 * 2 ).",
+	"hexcasting.page.numbers.example.4.5.header": "Пример 4",
+	"hexcasting.page.numbers.example.4.5": "Руна для 4.5: 5 / 2 + 1 + 1.",
+	"hexcasting.page.numbers.3": "Некоторые, для которых это сложно используют $(l:items/abacus)$(item)Счёты/$",
+
+	"hexcasting.entry.math": "Матем. операции",
+	"hexcasting.page.math.numvec": "Множество рун для математических операций для векторов и чисел. Аргументы написаны как \"num/vec\".",
+	"hexcasting.page.math.add.1": "Выполнить сложение.",
+	"hexcasting.page.math.add.2": "$(li)Вынимает два числа из верха стэка, складывает и вставляет результат на верх стэка.$(li)С числом и вектором вынимает число с верха стэка и добавляет его в каждый элемент направления.$(li)С двумя направлениями вынимает их из стэка и складывает, после чего новое вектором вставляется вверх стэка ([1, 2, 3] + [0, 4, -1] = [1, 6, 2]).",
+	"hexcasting.page.math.sub.1": "Выполнить вычитание.",
+	"hexcasting.page.math.sub.2": "$(li)Вынимает два числа из верха стэка, вычитает и вставляет результат на верх стэка.$(li)С числом и вектором вынимает число с верха стэка и вычитает его из каждого элемента направления.$(li)С двумя направлениями вынимает их из стэка и вычитает, после чего новое вектором вставляется вверх стэка$(br2)Во всех случаях верх стэка вычитается $(italic)из второго числа в стэке/$.",
+	"hexcasting.page.math.mul_dot.1": "Выполнить умножение.",
+	"hexcasting.page.math.mul_dot.2": "$(li)With two numbers, combines them into their product.$(li)With a number and a vector, removes the number from the stack and multiplies each component of the vector by that number.$(li)With two vectors, combines them into their $(l:https://www.mathsisfun.com/algebra/vectors-dot-product.html)dot product/$.",
+	"hexcasting.page.math.div_cross.1": "Деление или пересечение векторов.",
+	"hexcasting.page.math.div_cross.2": "$(li)Деление двух чисел.$(li)С числом и вектором, убирает число и делит его на каждый элемент вектора.$(li)С двумя векторами ищет их $(l:https://www.mathsisfun.com/algebra/vectors-cross-product.html)пересечение/$.WARNING: Не дели на ноль!!!",
+	"hexcasting.page.math.abs_len.1": "Посчитать abs(num) или длину вектора",
+	"hexcasting.page.math.abs_len.2": "Высчитывает абсолютное значение числа или длину вектора",
+	"hexcasting.page.math.pow_proj.1": "Посчитать pow(num, num) или vector projection.",
+	"hexcasting.page.math.pow_proj.2": "$(li)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.floor": "Убирает дробную часть числа, 4.5 -> 4",
+	"hexcasting.page.math.ceil": "Добивает число до потолка, 4.5 -> 5",
+	"hexcasting.page.math.construct_vec": "Объединяет 3 числа на верху стэка в вектор XYZ (сверху вниз).",
+	"hexcasting.page.math.deconstruct_vec": "Делит вектор на компоненты X, Y, Z сверху вниз.",
+	"hexcasting.page.math.coerce_axial": "Скругляет вектор до ближайших значений.",
+	"hexcasting.page.math.random": "Случайное число от 0 до 1.",
+
+	"hexcasting.entry.advanced_math": "Продвинутая математика",
+	"hexcasting.page.advanced_math.sin": "Синус угла в радианах. Выражается в $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ и $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+	"hexcasting.page.advanced_math.cos": "Косинус угла в радианах. Выражается в $(l:patterns/consts#hexcasting:const/double/pi)$(thing)π/$ и $(l:patterns/consts#hexcasting:const/double/tau)$(thing)τ/$.",
+	"hexcasting.page.advanced_math.tan": "Тангенс угла в радианах. Выражается в $(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": "Множество",
+	"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": "Константы",
+	"hexcasting.page.consts.1": "(1, 0, 0) или (-1, 0, 0).",
+	"hexcasting.page.consts.2": "(0, 1, 0) или (0, -1, 0).",
+	"hexcasting.page.consts.3": "(0, 0, 1) или (0, 0, -1).",
+	"hexcasting.page.consts.4": "Вставляет вектор (0, 0, 0) на верх стэка.",
+	"hexcasting.page.consts.5": "Вставляет NULL абстракцию на верх стэка.",
+
+	"hexcasting.entry.stackmanip": "Управление стэком",
+	"hexcasting.page.stackmanip.del": "Просто убирает верх стэка.",
+	"hexcasting.page.stackmanip.duplicate": "Дублирует верх стэка.",
+	"hexcasting.page.stackmanip.splat": "Убирает очередь с верха стэка и добавляет его элементы отдельно на верх стэка.",
+	"hexcasting.page.stackmanip.swap": "Меняет местами 2 верхние части стэка.",
+	"hexcasting.page.stackmanip.stack_len": "Добавляет на верх стэка длину стэка. ([0, 1] -> [0, 1, 2])",
+	"hexcasting.page.stackmanip.last_n_list": "Убирает $(italic)n'ное/$ кол-во элементов из стэка, а потом добавляет их в очередь на верху стэка.",
+	"hexcasting.page.stackmanip.fisherman": "Захватывает n'ый элемент со стэка и приводит к верху стэка.",
+	"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.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",
+
+	"hexcasting.entry.logic": "Логические операторы",
+	"hexcasting.page.logic.greater": "arg1 > arg2 -> return 1 else 0",
+	"hexcasting.page.logic.less": "arg1 < arg2 -> return 1 else 0",
+	"hexcasting.page.logic.greater_eq": "arg1 >= arg2 -> return 1 else 0",
+	"hexcasting.page.logic.less_eq": "arg1 <= arg2 -> return 1 else 0",
+	"hexcasting.page.logic.equals": "arg1 == arg2 -> return 1 else 0",
+	"hexcasting.page.logic.not_equals": "arg1 != arg2 -> return 1 else 0",
+	"hexcasting.page.logic.not": "arg == 0 or Null -> return 1 else 0",
+	"hexcasting.page.logic.identity": "arg == 0 -> return Null arg == Null -> return 0 else arg",
+	"hexcasting.page.logic.or": "arg1 != Null -> return arg1 else arg2",
+	"hexcasting.page.logic.and": "arg1 == Null -> return Null else arg2",
+	"hexcasting.page.logic.xor": "xor(arg1, arg2) -> non-Null else Null",
+
+	"hexcasting.entry.entities": "Сущности",
+	"hexcasting.page.entities.get_entity": "Сущность на этом месте или null.",
+	"hexcasting.page.entities.get_entity/animal": "Животное на этом месте или null.",
+	"hexcasting.page.entities.get_entity/monster": "Монстр на этом месте или null.",
+	"hexcasting.page.entities.get_entity/item": "Предмет на этом месте или null.",
+	"hexcasting.page.entities.get_entity/player": "Игрок на этом месте или null.",
+	"hexcasting.page.entities.get_entity/living": "Живое существо на этом месте или null.",
+	"hexcasting.page.entities.zone_entity/animal": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь животных около позиции.",
+	"hexcasting.page.entities.zone_entity/not_animal": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь не животных около позиции.",
+	"hexcasting.page.entities.zone_entity/monster": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь монстров около позиции.",
+	"hexcasting.page.entities.zone_entity/not_monster": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь не монстров около позиции.",
+	"hexcasting.page.entities.zone_entity/item": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь предметов около позиции.",
+	"hexcasting.page.entities.zone_entity/not_item": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь не предметов около позиции.",
+	"hexcasting.page.entities.zone_entity/player": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь игроков около позиции.",
+	"hexcasting.page.entities.zone_entity/not_player": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь не игроков около позиции.",
+	"hexcasting.page.entities.zone_entity/living": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь живых существ около позиции.",
+	"hexcasting.page.entities.zone_entity/not_living": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь не живых существ около позиции.",
+	"hexcasting.page.entities.zone_entity": "$(br)Берет позицию и максимальную дистанцию со стэка и возвращает очередь существ около позиции.",
+
+	"hexcasting.entry.lists": "Очереди",
+	"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 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 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 the number of elements in the list to the stack.",
+	"hexcasting.page.lists.8": "Reverse the list at the top of the stack.",
+
+	"hexcasting.entry.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.",
+	"hexcasting.page.patterns_as_iotas.2": "Fortunately, Nature has provided me with a set of $(l:casting/influences)influences/$ that I can use to work with patterns directly.$(br2)In short, $(action)Consideration/$ lets me add one pattern to the stack, and $(action)Introspection/$ and $(action)Retrospection/$ let me add a whole list.",
+	"hexcasting.page.patterns_as_iotas.3": "To use $(action)Consideration/$, I draw it, then another arbitrary pattern. That second pattern is added to the stack.",
+	"hexcasting.page.patterns_as_iotas.4": "One may find it helpful to think of this as \"escaping\" the pattern onto the stack, if they happen to be familiar with the science of computers.$(br2)The usual use for this is to copy the pattern to a $(l:items/scroll)$(item)Scroll/$ or $(l:items/slate)$(item)Slate/$ using $(l:patterns/readwrite#hexcasting:write)$(action)Scribe's Gambit/$, and then perhaps decorating with them.",
+	"hexcasting.page.patterns_as_iotas.5": "Drawing $(action)Introspection/$ makes my drawing of patterns act differently, for a time. Until I draw $(action)Retrospection/$, the patterns I draw are saved. Then, when I draw $(action)Retrospection/$, they are added to the stack as a list iota.",
+	"hexcasting.page.patterns_as_iotas.6": "If I draw another $(action)Introspection/$, it'll still be saved to the list, but I'll then have to draw $(italic)two/$ $(action)Retrospection/$s to get back to normal casting.",
+	"hexcasting.page.patterns_as_iotas.7": "Also, I can escape the special behavior of $(action)Intro-/$ and $(action)Retrospection/$ by drawing a $(action)Consideration/$ before them, which will simply add them to the list without affecting which the number of Retrospections I need to return to casting.$(br2)If I draw two $(action)Consideration/$s in a row while introspecting, it will add a single $(action)Consideration/$ to the list.",
+
+	"hexcasting.entry.readwrite": "Чтение и запись",
+	"hexcasting.page.readwrite.read": "Скопировать информацию из предмета (к примеру $(l:items/focus)$(item)Талисман/$, $(l:items/abacus)$(item)Счёты/$ или $(l:items/spellbook)$(item)Книга знаний/$) в моей другой руке, и добавить на верх стэка.",
+	"hexcasting.page.readwrite.readable": "Если прочесть информацию из другой руки можно - вернёт 1, нет - 0.",
+	"hexcasting.page.readwrite.read/entity": "Типо $(action)/$, но информация читается из сущности предмета.",
+	"hexcasting.page.readwrite.write.1": "Убирает верх стэка и записывает его в предмет в моей другой руке.",
+	"hexcasting.page.readwrite.write.2": "Можно записать информацию в (не закрытый) $(l:items/focus)$(item)Талисман/$ или $(l:items/spellbook)$(item)Книгу знаний/$, или я могу записать руну на $(l:items/scroll)$(item)Свиток/$s или $(l:items/slate)$(item)Плиту/$s с помощью $(l:patterns/patterns_as_iotas#hexcasting:escape)$(action)Лямбда-выражение/$.$(br2)Сохранить сущность игрока невозможно, только меня. Чтобы иметь ссылку на игрока нужно чтобы он самостоятельно добавился в $(item)Талисман/$.",
+	"hexcasting.page.readwrite.writable": "Если сохранить информацию можно - возвращает 1 если нет - 0.",
+
+
+	"hexcasting.entry.meta": "Работа с очередями рун",
+	"hexcasting.page.meta.eval.1": "Убирает очередь рун со стэка и поочерёдно их использует.$(br)Cтоит около одного $(item)Осколка Аметиста/$.",
+	"hexcasting.page.meta.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 occuring without me to guide them, any mishap will cause the remaining actions to become too unstable and immediately unravel.",
+	"hexcasting.page.meta.3": "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 $(item)Charged Amethyst/$.",
+	"hexcasting.page.meta.4": "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",
+	"hexcasting.page.circle_patterns.1": "These patterns must be cast from a $(item)Spell Circle/$; trying to cast them through a $(item)Посох/$ will fail.",
+	"hexcasting.page.circle_patterns.2": "Returns the position of the $(item)Impetus/$ of this spell circle.",
+	"hexcasting.page.circle_patterns.3": "Returns the direction the $(item)Impetus/$ of this spell circle is facing as a unit vector.",
+	"hexcasting.page.circle_patterns.4": "Returns the position of the lower-north-west corner of the bounds of this spell circle.",
+	"hexcasting.page.circle_patterns.5": "Returns the position of the upper-south-east corner of the bounds of this spell circle.",
+
+	"_comment": "Продвинутые руны",
+
+	"hexcasting.entry.itempicking": "Работа с предметами",
+	"hexcasting.page.itempicking.1": "Некоторые руны, такие как $(l:hexcasting:patterns/spells/blockworks#OpPlaceBlock)$(action)Поставить блок/$, потребляют дополнительные предметы из инвентаря. Руна ищёт предмет для использования.",
+	"hexcasting.page.itempicking.2": "$(li)Сначала, руна ищёт первый подходящий предмет в хотбаре около $(italic)Посоха/$.$(li)Во вторых, руна использует $(italic)самый далёкий предмет из инвентаря/$.",
+	"hexcasting.page.itempicking.3": "Так можно выбрать какой предмет какое заклинание будет использовать.",
+
+	"hexcasting.entry.basic_spell": "Продвинутые руны",
+	"hexcasting.page.basic_spell.explode.1": "Создает взрыв на месте вектора с силой данного числа.",
+	"hexcasting.page.basic_spell.explode.2": "Сила 3 как взрыв крипера; 4 как ТНТ. Больше 10 нельзя.$(br2)Стоит 1 $(item)Аметистовый осколок/$, и ещё $(item)Аметистовый осколок/$ за каждую единицу силы взрыва.",
+	"hexcasting.page.basic_spell.explode.fire.1": "Создаёт огненный взрыв на данных координатах с данной силой.",
+	"hexcasting.page.basic_spell.explode.fire.2": "Стоит 3 $(item)Осколка аметиста/$, и ещё один за каждую единицу силы взрыва.",
+	"hexcasting.page.basic_spell.add_motion": "Даёт импульс данному существу в данном направлении, сила обозначается длиной вектора.$(br)Стоит количество $(item)Aметистовой пыли/$ равное квадрату длины вектора.",
+	"hexcasting.page.basic_spell.blink": "Телепортирует существо по направлению её взгляда на данную длину.$(br)Стоит 1 $(item)Аметистовый осколок/$ за каждый блок.",
+	"hexcasting.page.basic_spell.beep.1": "Требует вектор и 2 числа. Проигрывает $(thing)инструмент/$ основанный на первом числе на указаной позиции, с $(thing)нотой/$ основанной на втором числе. Стоит малое количество мысли.",
+	"hexcasting.page.basic_spell.beep.2": "Существует 16 различных $(thing)инструментов/$ и 25 различных $(thing)нот/$. Отсчёт начинается с нуля.$(br2)Это те же самые инструменты, которые может воспроизвести $(item)нотный блок/$.$(br2)Узнать числа разных инструментов можно используя линзу прозрения на $(item)нотном блоке/$.",
+
+	"hexcasting.entry.blockworks": "Работа с блоками",
+	"hexcasting.page.blockworks.1": "Ставит блок на данные координаты.$(br)Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.2": "Ломает блок на данных координатах. Можно сломать всё, что алмазная кирка может сломать.$(br)Стоит около 3 $(item)Аметистовой пыли/$s.",
+	"hexcasting.page.blockworks.3": "Из ниоткуда ставит блок воды на данные координаты. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.4": "Убирает жидкость на данных координатах. Стоит около 2 $(item)Осколков аметиста/$s.",
+	"hexcasting.page.blockworks.5": "Создаёт магический барьер на данных координатах, который издаёт частицы моего цвета. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.6": "Создаёт магический свет на данных коориднатах, который светится и издаёт частицы моего цвета. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.7": "Удобряет растение на данных координатах, как $(item)Костная мука/$. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.8": "Поджигает блок на данных координатах, как $(item)Огненный заряд/$. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.blockworks.9": "Устраивает большой поджог на данных координатах. Стоит около 2 $(item)Аметистовых осколков/$.",
+
+	"hexcasting.entry.nadirs": "Негативные зелья",
+	"hexcasting.page.nadirs.1": "Они берут сущность и 2 или 1 число, первое - длительность, второе - уровень(от 1).$(br2)Каждый имеет обычную стоимость, она будет умножаться на уровень зелья .",
+	"hexcasting.page.nadirs.2": "According to certain legends, these spells and their sisters, the $(l:patterns/great_spells/zeniths)$(action)Положительные зелья/$, were \"[...] inspired by a world near to this one, where powerful wizards would gather magic from the land and hold duels to the death. Unfortunately, much was lost in translation...\"$(br2)Perhaps that is the reason for their peculiar names.",
+	"hexcasting.page.nadirs.3": "Даёт слабость. Обычная стоимость 1 $(item)Аметистовая пыль/$ за 10 секунд.",
+	"hexcasting.page.nadirs.4": "Даёт левитацию. Обычная стоимость 1 $(item)Amethyst Dust/$ за 5 секунд.",
+	"hexcasting.page.nadirs.5": "Даёт иссушение. Обычная стоимость 1 $(item)Amethyst Dust/$ за секунду.",
+	"hexcasting.page.nadirs.6": "Даёт отравление. Обычная стоимость 1 $(item)Amethyst Dust/$ за 3 секунд.",
+	"hexcasting.page.nadirs.7": "Даёт медлительность. Обычная стоимость 1 $(item)Amethyst Dust/$ за 5 секунд.",
+
+	"hexcasting.entry.hexcasting_spell": "Обработка магических предметов",
+	"hexcasting.page.hexcasting_spell.1": "Все эти 3 руны используются для исполнения рунных заклинаний.$(br)They all require me to hold the empty item in my off-hand, and require two things: the list of patterns to be cast, and an entity representing a dropped stack of $(item)Amethyst/$ to form the item's battery.$(br2)See $(l:items/hexcasting)this entry/$ for more information.",
+	"hexcasting.page.hexcasting_spell.2": "Стоит около 1 $(item)Заряженных осколков аметиста/$.",
+	"hexcasting.page.hexcasting_spell.3": "Стоит около 5 $(item)Заряженных осколков аметиста/$s.",
+	"hexcasting.page.hexcasting_spell.4": "Стоит около 10 $(item)Заряженных осколков аметиста/$s.",
+	"hexcasting.page.hexcasting_spell.5": "Перезарядить контейнер мыслей в моей другой руке. Стоит около 1 $(item)Заряженного осколка аметиста/$.",
+	"hexcasting.page.hexcasting_spell.6": "Также необходима сущность вида предмета, содержащего чистые мысли. Нельзя зарядить предмет сверх нормы, данной при первом создании.",
+	"hexcasting.page.hexcasting_spell.7": "Очищает предмет в моей другой руке. Стоит около 1 $(item)Аметистовой пыли/$.",
+	"hexcasting.page.hexcasting_spell.8": "Хранилище мыслей будет опустошено, полностью. Так можно исправить к примеру $(item)Штуковины/$s с ошибками.",
+
+	"hexcasting.entry.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.3": "Summon my sentinel at the given position. Costs about 1 $(item)Amethyst Dust/$.",
+	"hexcasting.page.sentinels.4": "Banish my sentinel, and remove it from the world. Costs a negligible amount of _media.",
+	"hexcasting.page.sentinels.5": "Add the position of my sentinel to the stack, or Null if it isn't summoned. Costs a negligible amount of _media.",
+	"hexcasting.page.sentinels.6": "Transform the position vector on the top of the stack into a unit vector pointing from that position to my sentinel, or Null if it isn't summoned. Costs a negligible amount of _media.",
+
+	"hexcasting.page.colorize.1": "Я должен держать $(item)оттенок/$ в моей другой руке чтобы исполнить заклинание. После исполнения оттенок будет поглощён и цвет моей магии поменяется (пока я не поменяю его снова). Стоит около 1 $(item)Аметистовой пыли/$.",
+
+	"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 $(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.1": "I command the heavens! This spell will summon a bolt of lightning to strike the earth where I direct it. Costs about 3 $(item)Amethyst Shard/$s.",
+	"hexcasting.page.weather_manip.2": "I control the clouds! This spell will summon rain across the world I cast it upon. Costs about 2 $(item)Amethyst Shard/$s. Does nothing if it is already raining.",
+	"hexcasting.page.weather_manip.3": "A counterpart to summoning rain. This spell will dispel rain across the world I cast it upon. Costs about 1 $(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 $(item)Amethyst Dust/$ multiplied by the radius, per second of flight.",
+
+	"hexcasting.page.teleport.1": "Куда мощнее $(l:patterns/spells/basic#OpBlink)$(action)Блинка/$, это позволит мне телепортироваться на невероятные расстония, пускай ограничение и есть, но оно $(italic)куда больше/$.",
+	"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 $(item)Charged Crystal/$s.$(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.",
+	"hexcasting.page.zeniths.2": "Bestows regeneration. Base cost is one $(item)Amethyst Dust/$ per second.",
+	"hexcasting.page.zeniths.3": "Bestows night vision. Base cost is one $(item)Amethyst Dust/$ per 5 seconds.",
+	"hexcasting.page.zeniths.4": "Bestows absorption. Base cost is one $(item)Amethyst Dust/$ per second.",
+	"hexcasting.page.zeniths.5": "Bestows haste. Base cost is one $(item)Amethyst Dust/$ per 3 seconds.",
+	"hexcasting.page.zeniths.6": "Bestows strength. Base cost is one $(item)Amethyst Dust/$ per 3 seconds.",
+
+	"hexcasting.page.greater_sentinel.1": "Summon a greater version of my $(l:patterns/sentinels)$(thing)Sentinel/$. Costs about 2 $(item)Amethyst Dust/$s.",
+	"hexcasting.page.greater_sentinel.2": "The stronger 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 sentinel, about 16 blocks. In other words, no matter where in the world I am, I can interact with things around my sentinel (the mysterious forces of chunkloading notwithstanding).",
+
+	"hexcasting.page.make_battery.1": "Infuse a bottle with _media to form a $(item)Phial./$",
+	"hexcasting.page.make_battery.2": "Similarly to the spells for $(l:patterns/spells/hexcasting)$(action)Crafting Hexcasting Items/$, I must hold a $(item)Glass Bottle/$ in my other hand, and provide the spell with a dropped stack of $(item)Amethyst/$. See $(l:items/phials)this page/$ for more information.$(br2)Costs about 1 $(item)Charged Amethyst Crystal/$.",
+
+	"hexcasting.page.brainsweep_spell.1": "Я не могу узнать начало или конец этой руны... Честно говоря мне страшно узнать что оно сделает..."
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/book.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/book.json
@ -0,0 +1,22 @@
+{
+  "name": "item.hexcasting.book",
+  "landing_text": "hexcasting.landing",
+  "version": 1,
+  "show_progress": false,
+  "creative_tab": "hexcasting",
+  "model": "hexcasting:patchouli_book",
+  "book_texture": "patchouli:textures/gui/book_purple.png",
+  "filler_texture": "hexcasting:textures/gui/patchi_filler.png",
+  "i18n": true,
+  "macros": {
+    "$(thing)": "$(#8d6acc)",
+    "$(action)": "$(#fc77be)",
+    "_Media": "$(#74b3f2)Media/$",
+    "_media": "$(#74b3f2)media/$",
+    "_Hexcasters": "$(#b38ef3)Hexcasters/$",
+    "_Hexcaster": "$(#b38ef3)Hexcaster/$",
+    "_Hexcasting": "$(#b38ef3)Hexcasting/$",
+    "_Hexes": "$(#b38ef3)Hexes/$",
+    "_Hex": "$(#b38ef3)Hex/$"
+  }
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/basics.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/basics.json
@ -0,0 +1,6 @@
+{
+  "name": "hexcasting.entry.basics",
+  "icon": "minecraft:amethyst_shard",
+  "description": "hexcasting.entry.basics.desc",
+  "sortnum": 0
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/casting.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/casting.json
@ -0,0 +1,6 @@
+{
+  "name": "hexcasting.entry.casting",
+  "icon": "hexcasting:wand_oak",
+  "description": "hexcasting.entry.casting.desc",
+  "sortnum": 1
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/greatwork.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/greatwork.json
@ -0,0 +1,7 @@
+{
+  "name": "hexcasting.entry.greatwork",
+  "description": "hexcasting.entry.greatwork.desc",
+  "icon": "minecraft:music_disc_11",
+  "sortnum": 3,
+  "entry_color": "54398a"
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/interop.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/interop.json
@ -0,0 +1,8 @@
+{
+  "name": "hexcasting.entry.interop",
+  "icon": "minecraft:chain",
+  "description": "hexcasting.entry.interop.desc",
+  "sortnum": 99,
+
+  "flag": "hexcasting:any_interop"
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/items.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/items.json
@ -0,0 +1,6 @@
+{
+  "name": "hexcasting.entry.items",
+  "icon": "hexcasting:focus",
+  "description": "hexcasting.entry.items.desc",
+  "sortnum": 2
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns.json
@ -0,0 +1,6 @@
+{
+  "name": "hexcasting.entry.patterns",
+  "icon": "minecraft:bookshelf",
+  "description": "hexcasting.entry.patterns.desc",
+  "sortnum": 100
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns/great_spells.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns/great_spells.json
@ -0,0 +1,7 @@
+{
+  "name": "hexcasting.entry.great_spells",
+  "icon": "minecraft:textures/mob_effect/conduit_power.png",
+  "description": "hexcasting.entry.great_spells.desc",
+  "parent": "hexcasting:patterns",
+  "sortnum": 1
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns/spells.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/categories/patterns/spells.json
@ -0,0 +1,7 @@
+{
+  "name": "hexcasting.entry.spells",
+  "icon": "minecraft:textures/item/enchanted_book.png",
+  "description": "hexcasting.entry.spells.desc",
+  "parent": "hexcasting:patterns",
+  "sortnum": 0
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/couldnt_cast.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/couldnt_cast.json
@ -0,0 +1,25 @@
+{
+  "name": "hexcasting.entry.couldnt_cast",
+  "category": "hexcasting:basics",
+  "icon": "minecraft:textures/mob_effect/nausea.png",
+  "sortnum": 0,
+  "advancement": "hexcasting:y_u_no_cast_angy",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.couldnt_cast.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.couldnt_cast.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.couldnt_cast.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.couldnt_cast.4"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/geodes.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/geodes.json
@ -0,0 +1,22 @@
+{
+  "name": "hexcasting.entry.geodes",
+  "icon": "minecraft:amethyst_block",
+  "category": "hexcasting:basics",
+  "priority": true,
+  "sortnum": 1,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.geodes.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.geodes.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.geodes.3"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/media.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/media.json
@ -0,0 +1,21 @@
+{
+  "name": "hexcasting.entry.media",
+  "icon": "hexcasting:amethyst_dust",
+  "category": "hexcasting:basics",
+  "priority": true,
+  "sortnum": 0,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.media.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.media.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.media.3"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/start_to_see.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/basics/start_to_see.json
@ -0,0 +1,25 @@
+{
+  "name": "hexcasting.entry.start_to_see",
+  "category": "hexcasting:basics",
+  "icon": "minecraft:textures/mob_effect/blindness.png",
+  "sortnum": 1,
+  "advancement": "hexcasting:opened_eyes",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.start_to_see.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.start_to_see.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.start_to_see.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.start_to_see.4"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/101.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/101.json
@ -0,0 +1,83 @@
+{
+  "name": "hexcasting.entry.101",
+  "category": "hexcasting:casting",
+  "icon": "hexcasting:wand_akashic",
+  "advancement": "hexcasting:root",
+  "priority": true,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.3"
+    },
+    {
+      "type": "hexcasting:manual_pattern_nosig",
+      "header": "hexcasting.page.101.4.header",
+      "text": "hexcasting.page.101.4",
+      "patterns": [
+        {
+          "startdir": "NORTH_EAST",
+          "signature": "qaq"
+        },
+        {
+          "startdir": "EAST",
+          "signature": "qaq",
+          "q": 2
+        }
+      ]
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.5"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.6"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.7"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.8"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.9"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.10"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.11"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.12"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.13"
+    },
+    {
+      "type": "patchouli:link",
+      "text": "hexcasting.page.101.14",
+      "link_text": "hexcasting.page.101.14.link_text",
+      "url": "https://goblinpunch.blogspot.com/2014/05/a-digression-about-wizards.html"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.101.15"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/influences.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/influences.json
@ -0,0 +1,21 @@
+{
+  "name": "hexcasting.entry.influences",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:spyglass",
+  "sortnum": 2,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.influences.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.influences.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.influences.3"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps.json
@ -0,0 +1,92 @@
+{
+  "name": "hexcasting.entry.mishaps",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:textures/mob_effect/poison.png",
+  "priority": true,
+  "sortnum": 2,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.mishaps.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.mishaps.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.mishaps.3"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.invalid_pattern.title",
+      "text": "hexcasting.page.mishaps.invalid_pattern"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.not_enough_iotas.title",
+      "text": "hexcasting.page.mishaps.not_enough_iotas"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.incorrect_iota.title",
+      "text": "hexcasting.page.mishaps.incorrect_iota"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.vector_out_of_range.title",
+      "text": "hexcasting.page.mishaps.vector_out_of_range"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.entity_out_of_range.title",
+      "text": "hexcasting.page.mishaps.entity_out_of_range"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.entity_immune.title",
+      "text": "hexcasting.page.mishaps.entity_immune"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.math_error.title",
+      "text": "hexcasting.page.mishaps.math_error"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.incorrect_item.title",
+      "text": "hexcasting.page.mishaps.incorrect_item"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.incorrect_block.title",
+      "text": "hexcasting.page.mishaps.incorrect_block"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.retrospection.title",
+      "text": "hexcasting.page.mishaps.retrospection"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.too_deep.title",
+      "text": "hexcasting.page.mishaps.too_deep"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.true_name.title",
+      "text": "hexcasting.page.mishaps.true_name"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.disabled.title",
+      "text": "hexcasting.page.mishaps.disabled"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps.other.title",
+      "text": "hexcasting.page.mishaps.other"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps2.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/mishaps2.json
@ -0,0 +1,29 @@
+{
+  "name": "hexcasting.entry.mishaps2",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:flint_and_steel",
+  "sortnum": 3,
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.mishaps2.1"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps2.bad_mindflay.title",
+      "text": "hexcasting.page.mishaps2.bad_mindflay"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps2.no_circle.title",
+      "text": "hexcasting.page.mishaps2.no_circle"
+    },
+    {
+      "type": "patchouli:text",
+      "title": "hexcasting.page.mishaps2.no_record.title",
+      "text": "hexcasting.page.mishaps2.no_record"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/naming.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/naming.json
@ -0,0 +1,21 @@
+{
+  "name": "hexcasting.entry.naming",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:name_tag",
+  "sortnum": 1,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.naming.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.naming.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.naming.3"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/stack.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/stack.json
@ -0,0 +1,25 @@
+{
+  "name": "hexcasting.entry.stack",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:piston",
+  "sortnum": 0,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.stack.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.stack.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.stack.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.stack.4"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/vectors.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/casting/vectors.json
@ -0,0 +1,26 @@
+{
+  "name": "hexcasting.entry.vectors",
+  "category": "hexcasting:casting",
+  "icon": "minecraft:arrow",
+  "priority": true,
+  "sortnum": 1,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:link",
+      "text": "hexcasting.page.vectors.1",
+      "link_text": "hexcasting.page.vectors.1.link_text",
+      "url": "https://www.youtube.com/watch?v=fNk_zzaMoSs"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.vectors.2"
+    },
+    {
+      "type": "patchouli:link",
+      "text": "hexcasting.page.vectors.3",
+      "link_text": "hexcasting.page.vectors.3.link_text",
+      "url": "https://psi.vazkii.us/codex.php#vectorPrimer"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/akashiclib.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/akashiclib.json
@ -0,0 +1,32 @@
+{
+  "name": "hexcasting.entry.akashiclib",
+  "category": "hexcasting:greatwork",
+  "icon": "hexcasting:akashic_record",
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "sortnum": 4,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.akashiclib.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.akashiclib.2"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/akashic_record",
+      "text": "hexcasting.page.akashiclib.akashic_record"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_bookshelf",
+      "recipe2": "hexcasting:akashic_connector"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.akashiclib.3"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/brainsweeping.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/brainsweeping.json
@ -0,0 +1,27 @@
+{
+  "name": "hexcasting.entry.brainsweeping",
+  "category": "hexcasting:greatwork",
+  "icon": "minecraft:wither_skeleton_skull",
+  "advancement": "hexcasting:enlightenment",
+  "sortnum": 0,
+  "entry_color": "54398a",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.brainsweeping.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.brainsweeping.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.brainsweeping.3"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/budding_amethyst",
+      "text": "hexcasting.page.brainsweeping.budding_amethyst"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/directrix.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/directrix.json
@ -0,0 +1,28 @@
+{
+  "name": "hexcasting.entry.directrix",
+  "category": "hexcasting:greatwork",
+  "icon": "hexcasting:directrix_redstone",
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "sortnum": 3,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.directrix.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.directrix.2"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:empty_directrix",
+      "text": "hexcasting.page.directrix.empty_directrix"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/directrix_redstone",
+      "text": "hexcasting.page.directrix.directrix_redstone"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/impetus.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/impetus.json
@ -0,0 +1,50 @@
+{
+  "name": "hexcasting.entry.impetus",
+  "category": "hexcasting:greatwork",
+  "icon": "hexcasting:impetus_rightclick",
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "sortnum": 2,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.impetus.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.impetus.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.impetus.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.impetus.4"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:empty_impetus",
+      "text": "hexcasting.page.impetus.empty_impetus"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/impetus_rightclick",
+      "text": "hexcasting.page.impetus.impetus_rightclick"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/impetus_storedplayer",
+      "text": "hexcasting.page.impetus.impetus_storedplayer.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.impetus.impetus_storedplayer.2"
+    },
+    {
+      "type": "hexcasting:brainsweep",
+      "recipe": "hexcasting:brainsweep/impetus_look",
+      "text": "hexcasting.page.impetus.impetus_look"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/spellcircles.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/spellcircles.json
@ -0,0 +1,44 @@
+{
+  "name": "hexcasting.entry.spellcircles",
+  "category": "hexcasting:greatwork",
+  "icon": "minecraft:lodestone",
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "sortnum": 1,
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.4"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.5"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.6"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.spellcircles.7"
+    },
+    {
+      "type": "patchouli:image",
+      "images": ["hexcasting:textures/gui/entries/spell_circle.png"],
+      "border": true,
+      "title": "hexcasting.page.spellcircles.teleport_circle.title"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/the_work.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/greatwork/the_work.json
@ -0,0 +1,18 @@
+{
+  "name": "hexcasting.entry.the_work",
+  "category": "hexcasting:greatwork",
+  "icon": "minecraft:nether_star",
+  "priority": true,
+  "advancement": "hexcasting:enlightenment",
+  "entry_color": "54398a",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.the_work.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.the_work.2"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/gravity.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/gravity.json
@ -0,0 +1,26 @@
+{
+  "name": "hexcasting.entry.interop.gravity",
+  "icon": "minecraft:anvil",
+  "category": "hexcasting:interop",
+  "advancement": "hexcasting:root",
+  "flag": "mod:gravitychanger",
+  "pages": [
+    "hexcasting.page.interop.gravity.1",
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:interop/gravity/get",
+      "anchor": "hexcasting:interop/gravity/get",
+      "input": "entity",
+      "output": "vector",
+      "text": "hexcasting.page.interop.gravity.get"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:interop/gravity/set",
+      "anchor": "hexcasting:interop/gravity/set",
+      "input": "entity, vector",
+      "output": "",
+      "text": "hexcasting.page.interop.gravity.set"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/interop.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/interop.json
@ -0,0 +1,11 @@
+{
+  "name": "hexcasting.entry.interop",
+  "icon": "minecraft:chain",
+  "category": "hexcasting:interop",
+  "flag": "hexcasting:any_interop",
+  "pages": [
+    "hexcasting.page.interop.1",
+    "hexcasting.page.interop.2",
+    "hexcasting.page.interop.3"
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/pehkui.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/interop/pehkui.json
@ -0,0 +1,26 @@
+{
+  "name": "hexcasting.entry.interop.pehkui",
+  "icon": "minecraft:red_mushroom",
+  "category": "hexcasting:interop",
+  "advancement": "hexcasting:root",
+  "flag": "mod:pehkui",
+  "pages": [
+    "hexcasting.page.interop.pehkui.1",
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:interop/pehkui/get",
+      "anchor": "hexcasting:interop/pehkui/get",
+      "input": "entity",
+      "output": "double",
+      "text": "hexcasting.page.interop.pehkui.get"
+    },
+    {
+      "type": "hexcasting:pattern",
+      "op_id": "hexcasting:interop/pehkui/set",
+      "anchor": "hexcasting:interop/pehkui/set",
+      "input": "entity, double",
+      "output": "",
+      "text": "hexcasting.page.interop.pehkui.set"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/abacus.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/abacus.json
@ -0,0 +1,22 @@
+{
+  "name": "hexcasting.entry.abacus",
+  "category": "hexcasting:items",
+  "icon": "hexcasting:abacus",
+  "sortnum": 2,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.abacus.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.abacus.2"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:abacus",
+      "text": "hexcasting.page.abacus.crafting.desc"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/amethyst.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/amethyst.json
@ -0,0 +1,35 @@
+{
+  "name": "hexcasting.entry.amethyst",
+  "icon": "minecraft:amethyst_shard",
+  "category": "hexcasting:items",
+  "priority": true,
+  "sortnum": 0,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:spotlight",
+      "item": "hexcasting:amethyst_dust",
+      "anchor": "dust",
+      "link_recipe": true,
+      "text": "hexcasting.page.amethyst.dust"
+    },
+    {
+      "type": "patchouli:spotlight",
+      "item": "minecraft:amethyst_shard",
+      "anchor": "shard",
+      "link_recipe": true,
+      "text": "hexcasting.page.amethyst.shard"
+    },
+    {
+      "type": "patchouli:spotlight",
+      "item": "hexcasting:charged_amethyst",
+      "anchor": "charged",
+      "link_recipe": true,
+      "text": "hexcasting.page.amethyst.crystal"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.amethyst.lore"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/decoration.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/decoration.json
@ -0,0 +1,48 @@
+{
+  "name": "hexcasting.entry.decoration",
+  "icon": "hexcasting:ancient_scroll_paper",
+  "category": "hexcasting:items",
+  "sortnum": 10,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.decoration.1"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:slate_block",
+      "recipe2": "hexcasting:slate_block_from_slates"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:scroll_paper",
+      "recipe2": "hexcasting:ancient_scroll_paper"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:scroll_paper_lantern",
+      "recipe2": "hexcasting:ancient_scroll_paper_lantern"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:ageing_scroll_paper_lantern",
+      "text": "hexcasting.page.decoration.ancient_scroll.crafting.desc"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:amethyst_tiles",
+      "text": "hexcasting.page.decoration.tiles.crafting.desc"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:amethyst_dust_packing",
+      "recipe2": "hexcasting:amethyst_dust_unpacking"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:amethyst_sconce",
+      "text": "hexcasting.page.decoration.sconce.crafting.desc"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/edified.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/edified.json
@ -0,0 +1,55 @@
+{
+  "name": "hexcasting.entry.edified",
+  "icon": "hexcasting:akashic_log",
+  "category": "hexcasting:items",
+  "sortnum": 9,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.edified.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.edified.2"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_planks",
+      "recipe2": "hexcasting:akashic_wood"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_stairs",
+      "recipe2": "hexcasting:akashic_slab"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_panel",
+      "recipe2": "hexcasting:akashic_tile"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_door",
+      "recipe2": "hexcasting:akashic_trapdoor"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:akashic_button",
+      "recipe2": "hexcasting:akashic_pressure_plate"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.edified.crafting.desc"
+    }
+  ],
+  "extra_recipe_mappings": {
+    "hexcasting:akashic_log": 0,
+    "hexcasting:akashic_log_stripped": 0,
+    "hexcasting:akashic_wood": 0,
+    "hexcasting:akashic_wood_stripped": 0,
+    "hexcasting:akashic_leaves1": 0,
+    "hexcasting:akashic_leaves2": 0,
+    "hexcasting:akashic_leaves3": 0
+  }
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/focus.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/focus.json
@ -0,0 +1,26 @@
+{
+  "name": "hexcasting.entry.focus",
+  "icon": "hexcasting:focus",
+  "category": "hexcasting:items",
+  "sortnum": 1,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.focus.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.focus.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.focus.3"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:focus",
+      "text": "hexcasting.page.focus.crafting.desc"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/hexcasting.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/hexcasting.json
@ -0,0 +1,41 @@
+{
+  "name": "hexcasting.entry.hexcasting",
+  "category": "hexcasting:items",
+  "icon": "hexcasting:artifact{patterns:[]}",
+  "sortnum": 6,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.hexcasting.1"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.hexcasting.2"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.hexcasting.3"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.hexcasting.4"
+    },
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.hexcasting.5"
+    },
+    {
+      "type": "patchouli:crafting",
+      "anchor": "cypher_trinket",
+      "recipe": "hexcasting:cypher",
+      "recipe2": "hexcasting:trinket"
+    },
+    {
+      "type": "patchouli:crafting",
+      "anchor": "artifact",
+      "recipe": "hexcasting:artifact",
+      "text": "hexcasting.page.hexcasting.crafting.desc"
+    }
+  ]
+}
--- a/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/jeweler_hammer.json
+++ b/doc/HexCastingResources/data/hexcasting/patchouli_books/thehexbook/en_us/entries/items/jeweler_hammer.json
@ -0,0 +1,18 @@
+{
+  "name": "hexcasting.entry.jeweler_hammer",
+  "category": "hexcasting:items",
+  "icon": "hexcasting:jeweler_hammer",
+  "sortnum": 9,
+  "advancement": "hexcasting:root",
+  "pages": [
+    {
+      "type": "patchouli:text",
+      "text": "hexcasting.page.jeweler_hammer.1"
+    },
+    {
+      "type": "patchouli:crafting",
+      "recipe": "hexcasting:jeweler_hammer",
+      "text": "hexcasting.page.jeweler_hammer.crafting.desc"
+    }
+  ]
+}
--- a/Show More
+++ b/Show More
				`@ -0,0 +1 @@`
				`net.touhoudiscord.hexucasting.fabric.xplat.FabricClientXplatImpl`
				`@ -0,0 +1 @@`
				`net.touhoudiscord.hexucasting.forge.xplat.ForgeClientXplatImpl`