Getting Started
The practitioners of this art would cast their so-called Hexes by drawing strange patterns in the air with a staff-- or craft powerful magical items to do the casting for them. How might I do the same?
Slipways
I have heard tales of some geodes in which glowing portals called slipways lie. These slipways are regularly depicted with glowing sparks surrounding them that bear an incredible resemblance to the wisps that I have heard tell of, which may be a connection to look into.
Items
I devote this section to the magical and mysterious items I might encounter in my studies.
It seems like many of these items have uses when held alongside my staff. I suppose I will have to choose what goes in my other hand carefully.
Relay
Often I wish to link together multiple wisps, so that they can share media and information over long distances. However running long chains of wisps to transfer these over great distances is inconvenient, and has great upkeep costs. To resolve this issue I have made Relays. Since they are solid blocks rather than media constructs themselves, they are able to maintain the links without any upkeep costs at all.
Any relays connected together will form a network, with any wisps connected to a relay network able to share media between each other as if they were directly connected. Further, any iota sent to one relay in the network is passed on to every other non-relay connected to the network. Relays have a range of 32 blocks (this means two relays can connect at a distance of 64 blocks). The colour of a network's links can be changed by right clicking on any relay with a colouriser.
Depicted in the book: The crafting recipe for the Relay.Relays have no owner, so if you want your wisps to transfer media with them you must specifically allow them to do so.
Cross-Mod Compatibility
It appears I have installed some mods Hexcasting interoperates with! I've detailed them here.
Fabric-Only Hexal Spells
Phase Block (vec, num →)
Takes a position and a number, and phases the block at that position out for that many seconds. Costs one ten-thousandth of an Amethyst Dust times the square of the time to phase out for.
Patterns
A list of all the patterns I've discovered, as well as what they do.
Hexal Basic Patterns
Timekeeper's Reflection (→ number)
Adds a number to the stack which seems to be related to how Nature represents time; If I cast the pattern, then cast the same pattern a second later, the number it adds has increased by 20.
Thanatos' Reflection (→ number)
Adds the number of evaluations a hex is still capable of to the stack. This is reduced by Hermes' Gambit and Thoth's Gambit.
Diver's Purification (entity → num)
Removes a Living entity from the stack and returns how much breath it has left (i.e., how close it is to drowning).
Nurse's Purification (entity → num)
Removes a Living entity from the stack and returns how much health it has left (i.e., how close it is to dying).
Squire's Purification (entity → num)
Removes a Living entity from the stack and returns how much armour it has.
Boxer's Purification (entity → num)
Removes a Living entity from the stack and returns how much toughness it has (another property of armour).
Lamplighter's Purification (vec → num)
Removes a position vector from the stack and returns the light level at that position.
Hexal Maths
Factorial Purification (num → num)
Takes a number from the stack and computes its factorial, for example inputting 4 would return 4*3*2*1=24.
Running Sum Purification ([num] → [num])
Takes a list from the stack and computes its running sum, for example inputting [1,2,5] would return [1,3,8].
Running Product Purification ([num] → [num])
Takes a list from the stack and computes its running product, for example inputting [1,2,5] would return [1,2,10].
Types
Classifier's Purification (any → iotatype)
Remove an iota from the stack, and adds the type of that iota to the stack.
Physician's Purification (entity → entitytype)
Remove an entity from the stack, and adds the type of the entity at that location to the stack.
Sorter's Purification (itemtypable → itemtype)
Remove a location, mote, item entity, or item frame from the stack, and adds the type of the block at that location, or type of that item, to the stack (e.g. Grass, Stone, Stick, etc.).
Sorter's Reflection (→ itemtype)
Adds the type of the item in the caster's offhand to the stack if there is one present, or the type of the casting hand otherwise.
Entity Distillation: Type (entitytype, pos → entity | null)
Remove an entity type and a position from the stack, and returns an entity of that type at that position if one exists.
Zone Exaltation: Type (entitytype, pos, num → [entity])
Remove an entity type, a position, and a radius from the stack, and returns a list of all entities of that type within that radius of that position.
Zone Exaltation: Not-Type (entitytype, pos, num → [entity])
Remove an entity type, a position, and a radius from the stack, and returns a list of all entities not of that type within that radius of that position
Everbook
Your Everbook is a strange space that your broken mind can now reach. There are many yous that seem to share this record, worlds and worlds of progress, beginning again and again. Your Everbook can store patterns paired with iotas like an Akashic Record, though the fragile nature of your mind these days makes it best to route all access to your Everbook through an Akashic Record. Any world that you reach enlightenment in, you will have access to the entries you add to it now.
Mnemosyne's Gambit (vector, pattern →)
Takes the position of an Akashic Record, as well as a Pattern as a key, and retrieves the iota at that key from your Everbook, storing it in the given Akashic Record if able.
Elysium's Gambit (vector, pattern →)
Takes the position of an Akashic Record, as well as a Pattern as a key, and stores the iota in that record at that key to your Everbook at the same key.
Lethe's Gambit (pattern →)
Takes a pattern and removes the entry with that pattern key from your Everbook.
Brigh's Gambit (pattern →)
Takes a pattern and marks that entry of your Everbook as a Pattern that when drawn by your hand will be treated as any other of Nature's patterns.
When you draw the key of an Everbook entry that has been marked as a Pattern, if that entry is a list Nature will execute each element of the list as it would with Hermes' Gambit, though it does not use up an evaluation. Attempting to mark an entry as a Pattern if it is non-existent or infinitely recursive will fail.
Everbook Entries
Every page in this entry displays the pattern key for one of the entries of your Everbook.
Spells
Patterns and actions that perform a magical effect on the world.
Hexal Spells
Smelt (vec | entity | mote →)
Remove a location, item entity, or mote from the stack, then either smelt the block at the location or smelt all the items in the item entity or mote.
Costs three quarters of an Amethyst Dust per item smelted (i.e. three quarters of an Amethyst Dust for smelting a block, 6 Amethyst Dust to smelt a stack of 8 items.)
Freeze (vec →)
Freezes the block at a block location. For example, turns water into ice, and ice into packed ice. Costs one Amethyst Dust.
Falling Block (vec →)
Remove a location from the stack, and force the block there to fall as if it were sand or gravel. Costs one and a half Amethyst Dust.
Place Block II ((itemtype | mote), vec →)
Accepts an item type or mote and a location, and attempts to place a block of that item type at that location. If a mote was passed it will instead place from the record referenced by that mote. Costs an eighth of an Amethyst Dust.
Particles (vec | [vec] →)
Accepts a location or a list of locations, and either creates a particle at the location, or creates lines of particles between the locations in the list. Costs two thousandths of an Amethyst Dust per location.
Wisps
I have discovered a way to create constructs from the media itself, visible to others and able to move and act somewhat on their own. They are able to cast hexes in my place, similar to how a Hermes' Gambit evaluates patterns. They do take some of my attention to operate this however, and if too many try and execute at once I will only be able to run some of them, leaving the rest for the next instant.
When they are created I assign them a 'reservoir' of media that they have access to, which is taken from me and used to form the wisp. A wisp uses up part of its reservoir simply existing, and when it evaluates the pattern list it is carrying any costs incurred are removed from its reservoir. All wisps seem to take three Amethyst Dust to summon, in addition to whatever media is used for their reservoir.
Summon Projectile Wisp ([pattern], vec, vec, number →)
This wisp is summoned and launched like an arrow, casting its hex on whatever it hits. The initial stack when it executes will be a reference to itself, then a reference to what it hit.
This could be a block position or an entity reference. The first vector accepted is the location the wisp will be summoned, while the direction of the second is the direction the wisp will be launched, and the second's magnitude seems to affect the wisp's velocity. The cost of the spell increases with the squared magnitude of velocity. The number accepted determines the wisp's reservoir in Amethyst Dust. It loses approximately 3 tenths of an Amethyst Dust of media every second once summoned, and has a range of influence of 4 blocks.
Summon Cyclic Wisp ([pattern], vec, number →)
Similar to Summon Projectile Wisp, but with only one vector input for the position to summon the wisp. Cyclic wisps are unmoving once summoned, instead executing their hex up to 20 times each second.
The first time it casts the stack will start with a reference to itself, from which point it will always start with the stack and ravenmind in the state they finished on the last cast. This wisp has a less stable form making it lose significantly more media every second, losing approximately seven tenths of an Amethyst Dust per second once summoned. It has a range of influence of 8 blocks.
Identity Reflection (→ entity)
Add a reference to the casting wisp to the stack. This must be cast by a wisp; trying to cast it through a staff will fail rather spectacularly.
Reservoir Reflection (→ num)
Add the amount of media in the wisp's reservoir to the stack. This must be cast by a wisp; trying to cast it through a staff will fail rather spectacularly.
Manager's Purification (entity → [pattern])
Removes a reference to a wisp from the stack, and replaces it with the wisp's contained hex. Must be a wisp you summoned, or a wisp that has allowed transfer with the caster or caster's owner.
Allegiance Distillation (entity, entity → bool)
Removes a reference to a wisp and an entity from the stack, and returns true if that entity owns that wisp, and false otherwise.
Pathfinder's Gambit (vec →)
Removes a position vector from the stack; The Cyclic Wisp that executed this pattern will move in a straight line towards that position (colliding with terrain in its path) until it reaches it.
Pathfinder's Reflection (→ vec)
Adds to the stack the position vector that the executing Cyclic Wisp is currently moving towards.
Haste (num →)
Removes a number from the stack, and sets the executing Cyclic Wisp's maximum speed to that number.
Allow Transfer (num →)
When two wisps are linked together, they transfer media between each other until they are balanced. By default this only happens between wisps with the same owner. This takes an index, and explicitly allows the wisp to exchange media with the linkable at that index.
Disallow Transfer (num →)
Correspondingly, this takes an index and disallows the wisp from exchanging media with the linkable at that index.
Allow Transfer Others (wisp, num →)
This takes a wisp that you own and an index, and allows the wisp to exchange media with the linkable at that index.
Disallow Transfer Others (wisp, num →)
This takes a wisp that you own and an index, and disallows the wisp from exchanging media with the linkable at that index.
Entity Purification: Wisp (vec → entity | null)
Transform the position on the stack into the wisp at that location (or Null if there isn't one).
Zone Distillation: Wisp (vec, num → [entity])
Take a position and maximum distance on the stack, and combine them into a list of wisps near the position.
Zone Distillation: Non-Wisp (vec, num → [entity])
Take a position and maximum distance on the stack, and combine them into a list of non-wisp entities near the position.
Delay Wisp (number →)
Removes an integer from the stack, then delays the wisp's next cast until at least that many twentieth's of a second have passed. This and other triggers like it will halve the wisp's upkeep cost while it isn't casting.
Wander
The wisp's next cast will not occur until it has reached the position it is navigating towards.
Links
These patterns outline a system that I have found for communicating information from one wisp to another, among other things. There are a number of patterns related to creating these links, and a number of patterns related to sending and receiving iotas over a link once it is created. A wisp can have any number of links active, with each costing a negligible amount of media to maintain each twentieth of a second.
The links of a given linkable are indexed by the order they are created, with this number used by a number of patterns. "Linkable" is not its own type, but a shorthand for any type that can be coerced into a linkable (e.g. Entity -> Linkable entities, Vec -> Linkable blocks, ...). Links can span up to double the sum of the two linkable's ranges. To connect linkables over truly vast distances I would do well to look into building some Relays.
Link (linkable →)
Links the caster to the entity removed from the stack, which must be linkable. This costs one Amethyst Shard.
Link Others (linkable, linkable →)
May be evaluated by any casting instrument. Links two entities, which must be linkable. This costs one Amethyst Shard.
Unlink (num →)
Removes the link at the given index from the caster's links. This costs two Amethyst Dust.
Unlink Others (linkable, linkable →)
Takes two linkables and unlinks them if they are linked. This costs two Amethyst Dust.
Phonebook Purification (num → linkable)
Removes an index from the stack, and adds the entity connected to the link at that index to the stack.
Recognition Purification (linkable → num)
Removes an entity from the stack, and adds the index to the link to that entity to the stack (or -1 if the caster isn't linked to that entity).
Send Iota (num, any →)
Removes an iota from the stack, then removes an index from the stack and sends the iota along the link at the given index. This costs one hundredth of an Amethyst Dust.
Recitation Reflection (→ any)
When something receives an iota along a link it is added to a queue. This pattern adds the first iota in the queue to the stack, removing it from the queue.
Postmaster's Reflection (→ num)
Adds to the stack the number of unread iota in the caster's received iota queue.
Open Transmit (num →)
Similar to Introspection, until drawing a Close Transmit all patterns I draw are sent along the link whose index is at the top of the stack.
Close Transmit
When drawn after Open Transmit I stop transmitting drawn patterns. If either Open Transmit or Close Transmit are executed by an intermediary caster such as a wisp, they will mishap.
Motes
This entry deals with bringing items into the media, making them referencable, countable, bringing order to them and to me and to my mind and-. A mediafied item iota (known as a mote) that has been added to the stack references a specific mote record in a Mote Nexus, since without something holding the thought-pattern of the item to this world it will wither away -away like my cognition is flensing-.
Any duplicate of that first mote iota referencing a record references the same record, and any change to one affects them all for they all point to the one and only in the media. Splitting and merging and crafting and trading all affect all affect all-.
A Mote Nexus is limited in some ways, but only some. It can contain 1023 different records, but each record can store items innumerable. I have yet to find any limit, I can merge and merge and merge forever and the record keeps growing and growing and growing...
Depicted in the book: A mind-flaying recipe producing the Mote Nexus.The Mote Nexus is built from the mind of a cartographer endlessly mapping the contents of the Shulker Box that it has been flayed into.
Bind Storage (vec →)
Target a Mote Nexus block in the world and bind yourself to it, meaning all items you mediafy will be added to that nexus' capacity. Targeting any other block will unbind you from your currently bound nexus. Costs 32 Amethyst Dust.
Bind Storage - Temporary (vec →)
Target a Mote Nexus block in the world and bind to it for the remainder of this cast, temporarily overriding your primary binding. Costs one thousandth of an Amethyst Dust.
Stocktake Reflection (→ [itemtype])
Gets all the types of motes contained in the currently bound Mote Nexus.
Stocktake Purification (mote | itemtype → [mote])
Gets all the mote records from the currently bound Mote Nexus that match the passed item type or could be combined with the passed mote.
Containment Distillation (vec, (itemtype | mote) → bool)
Returns true if the Mote Nexus at the given position contains a mote of the given type, or that would stack with the given mote, and false otherwise.
Mediafy Item (item | item, mote → mote)
Convert an item in the world (either an item entity or an item frame) into a mote on your stack. If passed an existing mote instead adds the items from the entity to the mote. Mediafying an item costs a tenth of an Amethyst Dust.
Return Item (mote, vec | mote, vec, num →)
Returns all the items from a mote to the world at the location of your choosing. If passed a number returns at most that many items. Costs a tenth of an Amethyst Dust.
Weighing Purification (mote → int)
Accepts a mote and returns the number of items in the record referenced by that mote.
Stacking Distillation (mote, mote → mote)
Combines two motes into one, merging the mote records they point to. Any pointers to the second mote will become null, any pointers to the first will remain. This can make motes holding many more items than I could carry in a stack naturally!
Stacking Distillation II (mote, (mote | item) → bool)
Returns true if the first mote can be combined with the items in the second argument (which can be a mote, item entity, or item frame), and false otherwise.
Splitting Gambit (mote, int → mote, mote)
Splits the specified number of items off of the passed mote, creating a new mote pointing to a new mote record.
Depot Gambit (mote, vec → mote)
Move the record referenced by the passed mote to the Mote Nexus at the passed position. This returns a new mote pointing to that record, and invalidates all previous motes pointing to that record.
Craft (mote | [mote] | [[mote]] → [mote])
Takes a mote, list of motes, or list of list of motes. returns a list containing the results of crafting with those items. For example, the input Stone x128 would return [Stone Button x128].
For more complex crafts, inserting nulls to space items properly will be required. A diamond pickaxe for example would require [[Diamond x2, Diamond x2, Diamond x2], [null, Stick x2], [null, Stick x2]] to get [Diamond Pickaxe x2]. Costs a tenth of an Amethyst Dust.
Seniority Purification (villager → int)
Accepts a villager, returns a number representing that villager's seniority and skill at their craft.
Offering Purification (villager → [complicated!])
Accepts a villager and returns all of the trades that villager is offering. This is a list of lists of lists. Each trade comprises two lists, the cost, and the returned items. The returned items is a list containing the type of item, and the number of items.
The cost is a list of one or two pairs of item and number of items required by the villager for the trade to be accepted. For example, one trade offer could be [[[Emerald, 1]], [Redstone, 1]].
Trade (villager, [mote], int? → item)
Accepts a villager, a list of motes to trade with to villager, and optionally an int for which of that villager's trades to attempt. (int? above means that you can pass 2 or 3 arguments, the optional 3rd being an int).
If no trade number was passed, it will try each of the villager's trade until finding one that accepts the passed items. If a trade number was passed it will skip straight to using that trade. It will then repeat that trade for as long as it has enough items and the villager is still willing to trade. It will then return the items the villager traded away as a mote to the stack.
The villager will find this trade to be a learnable experience as it would if trading with you directly, and will improve its skills and trade offerings commensurately. Costs a tenth of an Amethyst Dust.
Use Item On (mote, (entity | vec, vec) →)
Accepts a mote, and either an entity, or a target block and a normal vector. Uses the item on the entity/block. The mote must either only have one item in it, or the items contained must be extremely simple (no NBT data).
Great Spells
The spells catalogued here are purported to be of legendary difficulty and power. They seem to have been recorded only sparsely (for good reason, the texts claim). It's probably just the hogwash of extinct traditionalists, though-- a pattern's a pattern. What could possibly go wrong?
Accelerate
Accelerate (vec →)
Causes the block at the passed vector to perform its normal actions faster in the instant that this spell is cast.
Casting it costs a tenth of an Amethyst Dust, plus a thousandth of an Amethyst Dust for each time it has previously been cast on that block in this hex.
Great Wisp Spells
Consume Wisp (entity →)
Remove a wisp from the stack, and disassemble the wisp. The patterns contained are lost, but the media that it contained can be repurposed if this spell is cast by another wisp.
Costs either an Amethyst Shard if the wisp is owned by you or has allowed transfer with the caster or caster's owner, or half again as much media as the consumed wisp contains if the wisp is owned by another and has now allowed it. Repurposing the media is not completely efficient, losing one twentieth of the consumed wisp's reserve in transfer.
Bind Wisp (entity →)
Bind one of my wisps closer to me; I may only have one bound wisp at a time, but whichever wisp is bound costs significantly less upkeep and increased range.
Familiar's Reflection (→ entity | null)
Returns my currently bound wisp. A new wisp can only be bound when this returns null. (This is not a great spell, I have simply placed it here for convenience.)
Gates
Gates are the latest in my long line of experimentation with breaking space to connect distant points and allow instantaneous travel. What gates allow me to do, that none of my previous attempts have succeeded at, is to do it efficiently. There are three varieties of gates that I have learned how to construct, all of which take a large amount of media to burn into reality, but are significantly cheaper to operate afterwards.
Location Anchored Gates are bound to a specific position in the world, and send all that move through them to that position. Entity Anchored Gates are bound to a being that inhabits the world, and send those moving through them to the position of that being (plus an offset, chosen when burning in the gate).
Drifting Gates are not bound at all, and can be used to send entities anywhere, however they lose efficiency as a result, and can only send entities to places that are in my ambit. When a gate is burnt in I will obtain on my stack a reference to that gate. With that gate reference, I can mark entities with that gate, and I can close the gate, which sends all entities marked with that gate to the gate's destination. Note that closing a gate doesn't use it up; once I have acquired a gate iota I can use it in perpetuity.
Gate's Reflection (null | vec | vec, entity → gate)
Adds a new gate iota to the stack. Any copy of this iota will point to the same numbered gate. Costs 32 Charged Amethyst. If passed null, makes a Drifting Gate. If passed a vector, makes a Location Anchored Gate, If passed a vector and an entity, makes an Entity Anchored Gate.
Gate's Opening (gate, entity →)
Consumes a gate iota and an entity. Marks that entity to be teleported the next time that gate is closed. Costs one twentieth of an Amethyst Dust.
Gate's Dismissal (gate, entity →)
Consumes a gate iota and an entity. Unmarks that entity so that if it was marked with Gate's Opening it will no longer be teleported the next time that gate is closed.
Marked Purification (gate → num)
Consumes a gate iota, returns how many entities are marked by that gate.
Marked Distillation (gate, entity → bool)
Consumes a gate iota and an entity, returns whether that entity is marked by that gate.
Gate's Closing (gate | gate, vec →)
Consumes a non-drifing gate iota, or a drifting gate iota and a position. Transports all the entities marked with the passed gate to the stored or given position, as relevant. Costs half an Amethyst Shard, plus an Amethyst Dust per metre transported per entity, if the gate was drifting.