I've started to understand how the old masters cast their Hexes! It's a bit complicated, but I'm sure I can figure it out. Let's see...
Casting a Hex is quite difficult-- no wonder this art was lost to time! I'll have to re-read my notes carefully.
I can start a Hex by pressing Use Item/Place Block with a Staff in my hand-- this will cause a hexagonal grid of dots to appear in front of me. Then I can click and drag from dot to dot to draw patterns in the media of the grid; finishing a pattern will run its corresponding action (more on that later).
Once I've drawn enough patterns to cast a spell, the grid will disappear as the media I've stored up is released. Holding Sneak while using my staff will also clear the grid.
So how do patterns work? In short:
Patterns will execute...
Actions, which manipulate...
The Stack, which is a list of...
Iotas, which are simply units of information.
First, patterns. These are essential-- they're what I use to manipulate the media around me. Certain patterns, when drawn, will cause actions to happen. Actions are what actually do the magic; all patterns influence media in particular ways, and when those influences end up doing something useful, we call it an action.
Media can be fickle: if I draw an invalid pattern, I'll get some garbage result somewhere on my stack (read on...)
An Example
It's interesting to note that the rotation of a pattern doesn't seem to matter at all. These two patterns both perform an action called Mind's Reflection, for example.
A Hex is cast by drawing (valid) actions in sequence. Each action might do one of a few things:
Gather some information about the environment, leaving it on the top of the stack;
manipulate the info gathered (e.g. adding two numbers); or
perform some magical effect, like summoning lightning or an explosion. (These actions are called "spells.")
When I start casting a Hex, it creates an empty stack. Actions manipulate the top of that stack.
For example, Mind's Reflection will create an iota representing me, the caster, and add it to the top of the stack. Compass Purification will take the iota at the top the stack, if it represents an entity, and transform it into an iota representing that entity's location.
So, drawing those patterns in that order would result in an iota on the stack representing my position.
Iotas can represent things like myself or my position, but there are several other types I can manipulate with Actions. Here's a comprehensive list:
Numbers (which some legends called "doubles");
Vectors, a collection of three numbers representing a position, movement, or direction in the world;
Booleans or "bools" for short, representing an abstract True or False,
Entities, like myself, chickens, and minecarts;
Influences, peculiar types of iota that seem to represent abstract ideas;
Patterns themselves, used for crafting magic items and truly mind-boggling feats like spells that cast other spells; and
A list of several of the above, gathered into a single iota.
Of course, there's no such thing as a free lunch. All spells, and certain other actions, require media as payment.
The best I can figure, a Hex is a little bit like a plan of action presented to Nature-- in this analogy, the media is used to provide the arguments to back it up, so Nature will accept your plan and carry it out.
That aside, it doesn't seem like anyone has done much research on exactly how much any particular piece of amethyst is valued. The best I can tell, an Amethyst Shard is worth about five pieces of Amethyst Dust, and a Charged Amethyst Crystal is worth about ten.
Strangely enough, it seems like no other form of amethyst is suitable to be used in the casting of a Hex. I suspect that whole blocks or crystals are too solid to be easily unraveled into media.
It's also worth noting that each action will consume the media it needs immediately, rather than all at once when the Hex finishes. Also, an action will always consume entire items-- an action that only requires one Amethyst Dust's worth of media will consume an entire Charged Amethyst Crystal, if that's all that's present in my inventory.
Thus, it might be a good idea to bring dust for spellcasting too-- waste not, want not...
I should also be careful to make sure I actually have enough Amethyst in my inventory-- some old texts say that Nature is happy to use one's own mind as payment instead. They describe the feeling as awful but strangely euphoric, "[...] an effervescent dissolution into light and energy..." Perhaps that's why all the old practitioners of the art went mad. I can't imagine burning pieces of my mind for power is healthy.
Maybe something's changed, though. In my experiments, I've never managed to do it; if I run out of media, the spell will simply fail to cast, as if some barrier is blocking it from harming me.
It would be interesting to get to the bottom of that mystery, but for now I suppose it'll keep me safe.
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.
Content Warning: some body horror and suggestive elements.
Finally, it seems spells have a maximum range of influence, about 32 blocks from my position. Trying to affect anything outside of that will cause the spell to fail.
Despite this, if I have a player's reference, I can affect them from anywhere. This only applies to affecting them directly, though; I cannot use this to affect the world around them if they're outside of my range.
I ought to be careful when giving out a reference like that. While friendly Hexcasters could use them to great effect and utility, I shudder to think of what someone malicious might do with this.
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.
First off, an enlightening video on the topic.
Additionally, it seems that the mages who manipulated 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.
They seem to have used different language for their spellcasting:
A "Spell Piece" was their name for an action;
a "Trick" was their name for a spell; and
an "Operator" was their name for a non-spell action.
Link here.
Unfortunately, I am not (yet) a perfect being. I make mistakes from time to time in my study and casting of Hexes; for example, misdrawing a pattern, or trying to an invoke an action with the wrong iotas. And Nature usually doesn't look too kindly on my mistakes-- causing what is called a mishap.
A pattern that causes a mishap will glow red in my grid. Depending on the type of mistake, I can also expect a certain deleterious effect and a spray of red and colorful sparks as the mishandled media curdles into light of a given color.
Fortunately, although the bad effects of mishaps are certainly 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.
Following is a list of mishaps I have compiled.
Invalid Pattern
The pattern drawn is not associated with any action.
Causes yellow sparks, and a Garbage will be pushed to the top of my stack.
Not Enough Iotas
The action required more iotas than were on the stack.
Causes light gray sparks, and as many Garbages as would be required to fill up the argument count will be pushed.
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.
Causes dark gray sparks, and the invalid iota will be replaced with Garbage.
Vector Out of Ambit
The action tried to affect the world at a point that was out of my range.
Causes magenta sparks, and the items in my hands will be yanked out and flung towards the offending location.
Entity Out of Ambit
The action tried to affect an entity that was out of my range.
Causes pink sparks, and the items in my hands will be yanked out and flung towards the offending entity.
Entity is Immune
The action tried to affect an entity that cannot be altered by it.
Causes blue sparks, and the items in my hands will be yanked out and flung towards the offending entity.
Mathematical Error
The action did something offensive to the laws of mathematics, such as dividing by zero.
Causes red sparks, pushes a 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 me in retaliation.
Incorrect Item
The action requires some sort of item, but the item I supplied was not suitable.
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.
Incorrect Block
The action requires some sort of block at a target location, but the block supplied was not suitable.
Causes bright green sparks, and causes an ephemeral explosion at the given location. The explosion doesn't seem to harm me, the world, or anything else though; it's just startling.
Hasty Retrospection
I attempted to draw Retrospection without first drawing Introspection.
Causes orange sparks, and pushes the pattern for Retrospection to the stack as a pattern iota.
Delve Too Deep
Evaluated too many spells with meta-evaluation from one spell.
Causes dark blue sparks, and chokes all the air out of me.
Transgress Other
I attempted to save a reference to another player to a permanent medium.
Causes black sparks, and robs me of my sight for approximately one minute.
Disallowed Action
I tried to cast an action that has been disallowed by a server administrator.
Causes black sparks.
Catastrophic Failure
A bug in the mod caused an iota of an invalid type or otherwise caused the spell to crash. Please open a bug report!
Causes black sparks.
A 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.
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.
Because a stack is so simple, there's only so many things you can do with it:
Adding something to it, known formally as pushing,
Removing the last added element, known as popping, or
Examining or modifying the last added element, known as peeking.
We call the last-added element the "top" of the stack, in accordance with the dinner plate analogy.
As an example, if we push 1 to a stack, then push 2, then pop, the top of the stack is now 1.
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.
Of course, some actions (e.g. Mind's Reflection) might pop no arguments, and some actions (particularly spells) might push nothing afterwards.
Even more complicated actions can be expressed in terms of pushing, popping, and peeking. For example, 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, Gemini Decomposition duplicates the top of the stack-- in other words, it peeks the stack and pushes a copy of what it finds.
The names given to actions by the ancients were certainly peculiar, but I think there's a certain kind of logic to them.
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.
A Reflection pops nothing and pushes one iota.
A Purification pops one and pushes one.
A Distillation pops two and pushes one.
An Exaltation pops three or more and pushes one.
A Decomposition pops one argument and pushes two.
A Disintegration pops one and pushes three or more.
Finally, a Gambit pushes or pops some other number (or rearranges the stack in some other manner).
Spells seem to be exempt from this nomenclature and are more or less named after what they do-- after all, why call it a Demoman's Gambit when you could just say Explosion?
Influences are ... strange, to say the least. Whereas most iotas seem to represent something about the world, influences represent something more... abstract, or formless.
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 Archer's Distillation facing the sky.
In addition, I've discovered a curious quartet of influences I've named Consideration, Introspection, Retrospection, and Evanition. They seem to have properties of both patterns and other influences, yet act very differently. I can use these to add patterns to my stack as iotas, instead of matching them to actions. My notes on the subject are here.
Finally, there seems to be an infinite family of influences that just seem to be a tangled mess of media. I've named them Garbage, as they are completely useless. They seem to appear in my stack at various places in response to mishaps, and appear to my senses as a nonsense jumble.
I have discovered new and horrifying modes of failure. I must not succumb to them.
Inert Mindflay
Attempted to flay the mind of something that I have either already used, or of a character not suitable for the target block.
Causes dark green sparks, and kills the subject. If a villager sees that, I doubt they would look on it favorably.
Lack Spell Circle
Tried to cast an action requiring a spell circle without a spell circle.
Causes light blue sparks, and upends my inventory onto the ground.
Lack Akashic Record
Tried to access an Akashic Record at a location where there isn't one.
Causes purple sparks, and steals away some of my experience.
I devote this section to the magical and mysterious items I might encounter in my studies.
It seems that I'll find three different forms of amethyst when breaking a crystal inside a geode. The smallest denomination seems to be a small pile of shimmering dust, worth a relatively small amount of media.
The second is a whole shard of amethyst, of the type non-Hexcasters might be used to. This has about as much media inside as five Amethyst Dust.
Finally, I'll rarely find a large crystal crackling with energy. This has about as much media inside as ten units of Amethyst Dust (or two Amethyst Shards).
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.
A Staff is my entry point into casting all Hexes, large and small. By holding it and pressing Use Item/Place Block, I begin casting a Hex; then I can click and drag to draw patterns.
It's little more than a chunk of media on the end of a stick; that's all that's needed, after all.
Staves
Click to show recipes
Click to hide recipes
Don't fight; flame, light; ignite; burn bright.
Media can have peculiar effects on any type of information, in specific circumstances. Coating a glass in a thin film of it can lead to ... elucidating insights.
By holding a Scrying Lens in my hand, certain blocks will display additional information when I look at them.
For example, looking at a piece of Redstone will display its signal strength. I suspect I will discover other blocks with additional insight as my studies into my art progress.
In addition, holding it while casting using a Staff will shrink the spacing between dots, allowing me to draw more on my grid.
I can also wear it on my head as a strange sort of monocle.
Click to show recipes
Click to hide recipes
You must learn... to see what you are looking at.
The forgetful often tie a piece of string about their finger to help them remember something important. I believe this idea might be of use in my art. A specially knotted piece of string should be able to hold a single iota stably, irregardless of my stack.
I will call my invention a Thought-Knot.
When I craft it, it stores no iota. Using Scribe's Gambit while holding a Thought-Knot in my other hand will remove the top of the stack and save it into the Thought-Knot. Using Scribe's Reflection will copy whatever iota's in the Thought-Knot and add it to the stack.
Once a Thought-Knot has been written to, the string is indelibly tangled; the iota can be read any number of times, but there is no way to erase or overwrite it. Fortunately, they are not expensive.
Also, if I store an entity in a Thought-Knot and try to recall it after the referenced entity has died or otherwise disappeared, the Scribe's Reflection will add Null to the stack instead.
Click to show recipes
Click to hide recipes
How would you feel if someone saw you wearing a sign that said, "I am dashing and handsome?"
A Focus is like a Thought-Knot, in that iota can be written to or read from it. However, the advantage of a focus is that it is reusable. If I make a mistake in the iota I write to a Focus, I can simply cast Scribe's Gambit again and write over the iota inside.
If I wish to protect a focus from accidentally being overwritten, I can seal it with wax by crafting it with a Honeycomb. Attempting to use Scribe's Gambit on a sealed focus will fail.
Erase Item will remove this seal along with the contents.
Indeed, the only advantage of my Thought-Knots have over Foci is that Foci are more expensive to produce. My research indicates that the early practitioners of the art used exclusively Foci, with the Thought-Knot being an original creation of mine.
Whoever those ancient people were, they must have been very prosperous.
Click to show recipes
Click to hide recipes
Poison apples, poison worms.
Although there are patterns for drawing numbers, I find them ... cumbersome, to say the least.
Fortunately, the old masters of my craft invented an ingenious device called an Abacus to provide numbers to my casting. I simply set the number to what I want, then read the value using Scribe's Reflection, just like I would read a Thought-Knot or Focus.
To operate one, I simply hold it, sneak, and scroll. If in my main hand, the number will increment or decrement by 1, or 10 if I am also holding Control/Command. If in my off hand, the number will increment or decrement by 0.1, or 0.001 if I am also holding Control/Command.
I can shake the abacus to reset it to zero by sneak-right-clicking.
Click to show recipes
Click to hide recipes
Mathematics? That's for eggheads!
A Spellbook is the culmination of my art-- it acts like an entire library of Foci. Up to sixty-four of them, to be exact.
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.
Like a Focus, there exists a simple method to prevent accidental overwriting. Crafting it with a Honeycomb will lacquer the current page, preventing Scribe's Gambit from modifying its contents. Also like a Focus, using Erase Item will remove the lacquer along with the page's contents.
I can also name each page individually in an anvil. Naming it will change only the name of the currently selected page, for easy browsing.
Click to show recipes
Click to hide recipes
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.
A Scroll is a convenient method of sharing a pattern with others. I can copy a pattern onto one with Scribe's Gambit, after which it will display in a tooltip.
I can also place them on the wall as decoration or edification, like a painting, in sizes from 1x1 to 3x3 blocks. Using Amethyst Dust on such a scroll will have it display the stroke order.
In addition, I can also find so-called 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...
If those "mortals" couldn't cast them, I'm not sure they deserve to know them.
Click to show recipes
Click to hide recipes
I write upon clean white parchment with a sharp quill and the blood of my students, divining their secrets.
Slates are similar to Scrolls; I can copy a pattern to them and place them in the world to display the pattern.
However, I have read vague tales of grand assemblies of Slates, used to cast great rituals more powerful than can be handled by a Staff.
Perhaps this knowledge will be revealed to me with time. But for now, I suppose they make a quaint piece of decor.
At the least, they can be placed on any side of a block, unlike Scrolls.
Click to show recipes
Click to hide recipes
Blank Slate
6
This is the letter "a." Learn it.
I'm also aware of other types of Slates, slates that do not contain patterns but seem to be inlaid with other ... strange ... oddities. It hurts my brain to think about them, as if my thoughts get bent around their designs, following their pathways, bending and wefting through their labyrinthine depths, through and through and through channeled through and processed and--
... I almost lost myself. Maybe I should postpone my studies of those.
Although the flexibility of casting Hexes "on the go" with my Staff is quite helpful, it's a huge pain to have to wave it around repeatedly just to accomplish a basic task. If I could save a common spell for later reuse, it would simplify things a lot-- and allow me to share my Hexes with friends, too.
To do this, I can craft one of three types of magic items: Cyphers, Trinkets, or Artifacts. All of them hold the patterns of a given Hex inside, along with a small battery containing media.
Simply holding one and pressing Use Item/Place Block will cast the patterns inside, as if the holder had cast them out of a staff, using its internal battery.
Each item has its own quirks:
Cyphers are fragile, destroyed after their internal media reserves are gone, and cannot be recharged;
Trinkets can be cast as much as the holder likes, as long as there's enough media left, but become useless afterwards until recharged;
Artifacts are the most powerful of all-- after their media is depleted, they can use Amethyst from the holder's inventory to pay for the Hex, just as I do when casting with a Staff. Of course, this also means the spell might consume their mind if there's not enough Amethyst.
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. I've catalogued the patterns here.
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.
Usefully, it seems that the media in the battery is not consumed in chunks as it is when casting with a Staff-- rather, the media "melts down" into one continuous pool. Thus, if I store a Hex that only costs one Amethyst Dust's worth of media, a Charged Crystal used as the battery will allow me to cast it 10 times.
Click to show recipes
Click to hide recipes
Click to show recipes
Click to hide recipes
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.
I find it quite ... irritating, how Nature refuses to give me change for my work. If all I have on hand is Charged Amethyst, even the tiniest Archer's Purification will consume the entire crystal, wasting the remaining media.
Fortunately, it seems I've found a way to somewhat allay this problem.
I've found old scrolls describing a 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 Trinket, or similar; I can even Recharge them in the same manner.
Unfortunately, the art of actually 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...
But I won't settle for it forever.
Drink the milk.
The old practitioners of my art sometimes identified themselves by a color, emblematic of them and their Hexes. Although their names have faded, their colors remain. It seems a special kind of pigment, offered to Nature in the right way, would "[...] paint one's thoughts in a manner pleasing to Nature, inducing a miraculous change in personal colour."
I'm not certain on the specifics, but I believe I have isolated the formulae for many different colors and blends of pigments. To apply a pigment, I hold it in one hand and cast Internalize Pigment with the other; this consumes the pigment.
The pigments seem to affect the color of the sparks of media emitted when I cast a Hex and my sentinel, but I don't doubt that the color will show up elsewhere.
Chromatic Pigments
Click to show recipes
Click to hide recipes
Pigments in all the colors of the rainbow.
Click to show recipes
Click to hide recipes
And finally, a pair of special pigments. Soulglimmer Pigment shines with colors wholly unique to me, and Vacant Pigment restores my original purplish-orange spread.
And all the colors I am inside have not been invented yet.
Click to show recipes
Click to hide recipes
By infusing media into a sapling via the use of Edify Sapling, I can create what is called an Edified Tree. They tend to be tall and pointy, with ridged bark and wood that grows in a strange spiral pattern. Their leaves come in three pretty colors.
I would assume the wood would have some properties relevant to Hexcasting. But, if it does, I cannot seem to find them. For all intents and purposes it appears to be just wood, albeit of a very strange color.
I suppose for now I will use it for decoration; the full suite of standard wood blocks can be crafted from them.
Of course, I can strip them with an axe as well.
Click to show recipes
Click to hide recipes
Their smooth trunks, with white bark, gave the effect of enormous columns sustaining the weight of an immense foliage, full of shade and silence.
After being careless with the sources of my media one too many times, I have devised a tool to work around my clumsiness.
Using the delicate nature of crystallized media as a fixture for a pickaxe, I can create the Jeweler's Hammer. It acts like an Iron Pickaxe, for the most part, but can't break anything that takes up an entire block's space.
Click to show recipes
Click to hide recipes
Carefully, she cracked the half ruby, letting the spren escape.
In the course of my studies I have discovered some building blocks and trifles that I may find aesthetically pleasing. I've compiled the methods of making them here.
Click to show recipes
Click to hide recipes
Brown dye works well enough to simulate the look of an ancient scroll.
Click to show recipes
Click to hide recipes
Amethyst Tiles
8
Amethyst Tiles can also be made in a Stonecutter.
Blocks of Amethyst Dust (next page) will fall like sand.
Click to show recipes
Click to hide recipes
Amethyst Sconces emit light and particles, as well as a pleasing chiming sound.
A list of all the patterns I've discovered, as well as what they do.
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.
If an action is cast by multiple patterns, as is the case with some, I'll write them all side-by-side.
For a few patterns, however, I was 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.
In such cases I just draw the pattern without any information on the order to draw it in.
I also write the types of iota that the action will consume or modify, a "→", and the types of iota the action will create.
For example, "vector, number → 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.)
"→ entity" means it'll just push an entity. "entity, vector →" means it removes an entity and a vector, and doesn't push anything.
Finally, if I find the little dot marking the stroke order too slow or confusing, I can press 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!
Mind's Reflection (→ entity | null)
Adds me, the caster, to the stack.
Compass' Purification (entity → vector)
Transforms an entity on the stack into the position of its eyes. I should probably use this on myself.
Alidade's Purification (entity → vector)
Transforms an entity on the stack into the direction it's looking in, as a unit vector.
Archer's Distillation (vector, vector → vector | null)
Combines two vectors (a position and a direction) into the answer to the question: If I stood at the position and looked in the direction, what block would I be looking at? Costs a negligible amount of media.
If it doesn't hit anything, the vectors will combine into Null.
A common sequence of patterns, the so-called "raycast mantra," is Mind's Reflection, Compass Purification, Mind's Reflection, Alidade Purification, Archer's Distillation. Together, they return the vector position of the block I am looking at.
Architect's Distillation (vector, vector → vector | null)
Like Archer's Distillation, but instead returns a vector representing the answer to the question: Which side of the block am I looking at? Costs a negligible amount of media.
More specifically, it returns the normal vector of the face hit, or a unit vector pointing perpendicular to the face.
If I am looking at a floor, it will return (0, 1, 0).
If I am looking at the south face of a block, it will return (0, 0, 1).
Scout's Distillation (vector, vector → entity | null)
Like Archer's Distillation, but instead returns the entity I am looking at. Costs a negligible amount of media.
Reveal (any → any)
Displays the top iota of the stack to me.
Stadiometer's Prfn. (entity → num)
Transforms an entity on the stack into its height.
Pace Purification (entity → vector)
Transforms an entity on the stack into the direction in which it's moving, with the speed of that movement as that direction's magnitude.
Numerical Reflection (→ number)
Irritatingly, there is no easy way to draw numbers. Here is the method Nature deigned to give us.
First, I draw one of the two shapes shown on the other page. Next, the angles following will modify a running count starting at 0.
Forward: Add 1
Left: Add 5
Right: Add 10
Sharp Left: Multiply by 2
Sharp Right: Divide by 2.
The clockwise version of the pattern, on the right of the other page, will negate the value at the very end. (The left-hand counter-clockwise version keeps the number positive).
Once I finish drawing, the number's pushed to the top of the stack.
Example 1
This pattern pushes 10.
Example 2
This pattern pushes 7: 5 + 1 + 1.
Example 3
This pattern pushes -32: negate 1 + 5 + 10 * 2.
Example 4
This pattern pushes 4.5: 5 / 2 + 1 + 1.
In certain cases it might be easier to just use an Abacus. But, it's worth knowing the "proper" way to do things.
Many mathematical operations function on both numbers and vectors. Such arguments are written as "num|vec".
Additive Distillation (num|vec, num|vec → num|vec)
Perform addition.
As such:
With two numbers at the top of the stack, combines them into their sum.
With a number and a vector, removes the number from the stack and adds it to each element of the vector.
With two vectors, combines them by summing corresponding components into a new vector (i.e. [1, 2, 3] + [0, 4, -1] = [1, 6, 2]).
Subtractive Distillation (num|vec, num|vec → num|vec)
Perform subtraction.
As such:
With two numbers at the top of the stack, combines them into their difference.
With a number and a vector, removes the number from the stack and subtracts it from each element of the vector.
With two vectors, combines them by subtracting each component.
In all cases, the top of the stack or its components are subtracted from the second-from-the-top.
Multiplicative Dstl. (num|vec, num|vec → num|vec)
Perform multiplication or the dot product.
As such:
With two numbers, combines them into their product.
With a number and a vector, removes the number from the stack and multiplies each component of the vector by that number.
With two vectors, combines them into their dot product.
Division Dstl. (num|vec, num|vec → num|vec)
Perform division or the cross product.
As such:
With two numbers, combines them into their quotient.
With a number and a vector, removes the number and divides it by each element of the vector.
With two vectors, combines them into their cross product.
In the first and second cases, the top of the stack or its components comprise the dividend, and the second-from-the-top or its components are the divisor.
WARNING: Never divide by zero!
Length Purification (num|vec → number)
Compute the absolute value or length.
Replaces a number with its absolute value, or a vector with its length.
Power Distillation (num|vec, num|vec → num|vec)
Perform exponentiation or vector projection.
With two numbers, combines them by raising the first to the power of the second.
With a number and a vector, removes the number and raises each component of the vector to the number's power.
With two vectors, combines them into the vector projection of the top of the stack onto the second-from-the-top.
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.
Floor Purification (num|vec → num|vec)
"Floors" a number, cutting off the fractional component and leaving an integer value. If passed a vector, instead floors each of its components.
Ceiling Purification (num|vec → num|vec)
"Ceilings" a number, raising it to the next integer value if it has a fractional component. If passed a vector, instead ceils each of its components.
Vector Exaltation (num, num, num → vector)
Combine three numbers at the top of the stack into a vector's X, Y, and Z components (top to bottom).
Vector Disintegration (vector → num, num, num)
Split a vector into its X, Y, and Z components (top to bottom).
Modulus Distillation (num|vec, num|vec → num|vec)
Takes the modulus of two numbers. This is the amount remaining after division - for example, 5 % 2 is 1, and 5 % 3 is 2. When applied on vectors, performs the above operation elementwise.
Axial Purification (vec|num → vec|num)
For a vector, coerce it to its nearest axial direction, a unit vector. For a number, return the sign of the number; 1 if positive, -1 if negative. In both cases, zero is unaffected.
Entropy Reflection (→ num)
Creates a random number between 0 and 1.
True Reflection (→ bool)
Adds True to the top of the stack.
False Reflection (→ bool)
Adds False to the top of the stack.
Nullary Reflection (→ null)
Adds the Null influence to the top of the stack.
Vector Reflection Zero (→ vector)
Adds [0, 0, 0] to the stack.
Vector Rfln. +X/-X (→ vector)
The left-hand counter-clockwise pattern adds [1, 0, 0] to the stack; the right-hand clockwise pattern adds [-1, 0, 0].
Vector Rfln. +Y/-Y (→ vector)
The left-hand counter-clockwise pattern adds [0, 1, 0] to the stack; the right-hand clockwise pattern adds [0, -1, 0].
Vector Rfln. +Z/-Z (→ vector)
The left-hand counter-clockwise pattern adds [0, 0, 1]; the right-hand clockwise pattern adds [0, 0, -1].
Circle's Reflection (→ num)
Adds τ, the radial representation of a complete circle, to the stack.
Arc's Reflection (→ num)
Adds π, the radial representation of half a circle, to the stack.
Euler's Reflection (→ num)
Adds e, the base of natural logarithms, to the stack.
Novice's Gambit (any →)
Removes the first iota from the stack.
This seems to be a special case of Bookkeeper's Gambit.
Jester's Gambit (any, any → any, any)
Swaps the top two iotas of the stack.
Rotation Gambit (any, any, any → any, any, any)
Yanks the iota third from the top of the stack to the top. [0, 1, 2] becomes [1, 2, 0].
Rotation Gambit II (any, any, any → any, any, any)
Yanks the top iota to the third position. [0, 1, 2] becomes [2, 0, 1].
Gemini Decomposition (any → any, any)
Duplicates the top iota of the stack.
Prospector's Gambit (any, any → any, any, any)
Copy the second-to-last iota of the stack to the top. [0, 1] becomes [0, 1, 0].
Undertaker's Gambit (any, any → any, any, any)
Copy the top iota of the stack, then put it under the second iota. [0, 1] becomes [1, 0, 1].
Gemini Gambit (any, number → many)
Removes the number at the top of the stack, then copies the top iota of the stack that number of times. (A count of 2 results in two of the iota on the stack, not three.)
Dioscuri Gambit (any, any → any, any, any, any)
Copy the top two iotas of the stack. [0, 1] becomes [0, 1, 0, 1].
Flock's Reflection (→ number)
Pushes the size of the stack as a number to the top of the stack. (For example, a stack of [0, 1] will become [0, 1, 2].)
Fisherman's Gambit (number → any)
Grabs the element in the stack indexed by the number and brings it to the top. If the number is negative, instead moves the top element of the stack down that many elements.
Fisherman's Gambit II (number → any)
Like Fisherman's Gambit, but instead of moving the iota, copies it.
Bookkeeper's Gambit (many → many)
An infinite family of actions that keep or remove elements at the top of the stack based on the sequence of dips and lines.
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.
If my stack contains 0, 1, 2 from deepest to shallowest, drawing the first pattern opposite will give me 1, the second will give me 0, and the third will give me 0, 2 (the 0 at the bottom is left untouched).
Swindler's Gambit (many, number → many)
Rearranges the top elements of the stack based on the given numerical code, which is the index of the permutation wanted.
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.
If I wish to do further study, the key word is "Lehmer Code."
Augur's Purification (any → bool)
Convert an argument to a boolean. The number 0, Null, and the empty list become False; everything else becomes True.
Length Purification (bool → number)
Convert a boolean to a number; True becomes 1, and False becomes 0.
Negation Purification (bool → bool)
If the argument is True, return False; if it is False, return True.
Disjunction Distillation (bool, bool → bool)
Returns True if at least one of the arguments are True; otherwise returns False.
Conjunction Distillation (bool, bool → bool)
Returns True if both arguments are true; otherwise returns False.
Exclusion Distillation (bool, bool → bool)
Returns True if exactly one of the arguments is true; otherwise returns False.
Augur's Exaltation (bool, any, any → any)
If the first argument is True, keeps the second and discards the third; otherwise discards the second and keeps the third.
Equality Distillation (any, any → bool)
If the first argument equals the second (within a small tolerance), return True. Otherwise, return False.
Inequality Distillation (any, any → bool)
If the first argument does not equal the second (outside a small tolerance), return True. Otherwise, return False.
Maximus Distillation (number, number → bool)
If the first argument is greater than the second, return True. Otherwise, return False.
Minimus Distillation (number, number → bool)
If the first argument is less than the second, return True. Otherwise, return False.
Maximus Distillation II (number, number → bool)
If the first argument is greater than or equal to the second, return True. Otherwise, return False.
Minimus Distillation II (number, number → bool)
If the first argument is less than or equal to the second, return True. Otherwise, return False.
Entity Purification (vector → entity or null)
Transform the position on the stack into the entity at that location (or Null if there isn't one).
Entity Prfn.: Animal (vector → entity or null)
Transform the position on the stack into the animal at that location (or Null if there isn't one).
Entity Prfn.: Monster (vector → entity or null)
Transform the position on the stack into the monster at that location (or Null if there isn't one).
Entity Prfn.: Item (vector → entity or null)
Transform the position on the stack into the dropped item at that location (or Null if there isn't one).
Entity Prfn.: Player (vector → entity or null)
Transform the position on the stack into the player at that location (or Null if there isn't one).
Entity Prfn.: Living (vector → entity or null)
Transform the position on the stack into the living creature at that location (or Null if there isn't one).
Zone Dstl.: Animal (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of animals near the position.
Zone Dstl.: Non-Animal (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-animal entities near the position.
Zone Dstl.: Monster (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of monsters near the position.
Zone Dstl.: Non-Monster (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-monster entities near the position.
Zone Dstl.: Item (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of dropped items near the position.
Zone Dstl.: Non-Item (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-dropped-item entities near the position.
Zone Dstl.: Player (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of players near the position.
Zone Dstl.: Non-Player (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-player characters near the position.
Zone Dstl.: Living (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of living creatures near the position.
Zone Dstl.: Non-Living (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-living entities near the position.
Zone Dstl.: Any (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of all entities near the position.
Selection Distillation (list, number → any)
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.
Selection Exaltation (list, num, num → list)
Remove the two numbers at the top of the stack, then take a sublist of the list at the top of the stack between those indices, lower bound inclusive, upper bound exclusive. For example, the 0, 2 sublist of [0, 1, 2, 3, 4] would be [0, 1].
Integration Distillation (list, any → list)
Remove the top of the stack, then add it to the end of the list at the top of the stack.
Derivation Distillation (list → list, any)
Remove the iota on the end of the list at the top of the stack, and add it to the top of the stack.
Additive Distillation (list, list → list)
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.
Vacant Reflection (→ list)
Push an empty list to the top of the stack.
Single's Purification (any → list)
Remove the top of the stack, then push a list containing only that element.
Length Purification (list → num)
Remove the list at the top of the stack, then push the number of elements in the list to the stack.
Retrograde Purification (list → list)
Reverse the list at the top of the stack.
Locator's Distillation (list, any → num)
Remove the iota at the top of the stack, then replace the list at the top with the first index of that iota within the list (starting from 0). Replaces the list with -1 if the iota doesn't exist in the list.
Excisor's Distillation (list, num → list)
Remove the number at the top of the stack, then remove the nth element of the list at the top of the stack (where n is the number you removed).
Surgeon's Exaltation (list, num, any → list)
Remove the top iota of the stack and the number at the top, then set the nth element of the list at the top of the stack to that iota (where n is the number you removed). Does nothing if the number is out of bounds.
Flock's Gambit (many, num → list)
Remove num elements from the stack, then add them to a list at the top of the stack.
Flock's Disintegration (list → many)
Remove the list at the top of the stack, then push its contents to the stack.
Speaker's Distillation (list, any → list)
Remove the top iota, then add it as the first element to the list at the top of the stack.
Speaker's Decomposition (list → list, any)
Remove the first iota from the list at the top of the stack, then push that iota to the stack.
One of the many peculiarities of this art is that patterns themselves can act as iotas-- I can even put them onto my stack when casting.
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.
Fortunately, Nature has provided me with a set of influences that I can use to work with patterns directly.
In short, Consideration lets me add one pattern to the stack, and Introspection and Retrospection let me add a whole list.
Consideration
To use Consideration, I draw it, then another arbitrary pattern. That second pattern is added to the stack.
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.
The usual use for this is to copy the pattern to a Scroll or Slate using Scribe's Gambit, and then perhaps decorating with them.
Introspection
Drawing Introspection makes my drawing of patterns act differently, for a time. Until I draw Retrospection, the patterns I draw are saved. Then, when I draw Retrospection, they are added to the stack as a list iota.
Retrospection
If I draw another Introspection, it'll still be saved to the list, but I'll then have to draw two Retrospections to get back to normal casting.
Also, I can escape the special behavior of Intro- and Retrospection by drawing a Consideration before them, which will simply add them to the list without affecting which the number of Retrospections I need to return to casting.
If I draw two Considerations in a row while introspecting, it will add a single Consideration to the list.
Evanition
Finally, if I make a mistake while drawning patterns inside Intro- and Retrospection I can draw Evanition to remove the last pattern that I drew from the pattern list that is being constructed.
This section deals with the storage of Iotas in a more permanent medium. Nearly any iota can be stored to a suitable item, such as a Focus or Spellbook), and read back later. Certain items, such as an Abacus, can only be read from.
Iotas are usually read and written from the other hand, but it is also possible to read and write with an item when it is sitting on the ground as an item entity, or when in an item frame.
There may be other entities I can interact with in this way. For example, a Scroll hung on the wall can have its pattern read off of it.
However, it seems I am unable to save a reference to another player, only me. I suppose an entity reference is similar to the idea of a True Name; perhaps Nature is helping to keep our Names out of the hands of enemies. If I want a friend to have my Name I can make a Focus for them.
Scribe's Reflection (→ any)
Copy the iota stored in the item in my other hand and add it to the stack.
Scribe's Gambit (any →)
Remove the top iota from the stack, and save it into the item in my other hand.
Chronicler's Prfn. (entity → any)
Like Scribe's Reflection, but the iota is read out of an entity instead of my other hand.
Chronicler's Gambit (entity, any →)
Like Scribe's Gambit, but the iota is written to an entity instead of my other hand.
Interestingly enough, it looks like I cannot write my own Name using this spell. I get a sense that I might be endangered if I could.
Auditor's Reflection (→ bool)
If the item in my other hand holds an iota I can read, returns True. Otherwise, returns False.
Auditor's Purification (entity → bool)
Like Auditor's Reflection, but the readability of an entity is checked instead of my other hand.
Assessor's Reflection (→ bool)
If I could save an iota into the item in my other hand, returns True. Otherwise, returns False.
Assessor's Purification (entity → bool)
Like Assessor's Reflection, but the writability of an entity is checked instead of my other hand.
The Ravenmind
Items are not the only places I can store information, however. I am also able to store that information in the media of the Hex itself, much like the stack, but separate. Texts refer to this as the ravenmind. It holds a single iota, much like a Focus, and begins with Null like the same. It is preserved between iterations of Thoth's Gambit, but only lasts as long as the Hex it's a part of. Once I stop casting, the value will be lost.
Huginn's Gambit (any →)
Removes the top iota from the stack, and saves it to my ravenmind, storing it there until I stop casting the Hex.
Muninn's Reflection (→ any)
Copy the iota out of my ravenmind, which I likely just wrote with Huginn's Gambit.
Sine Purification (num → num)
Takes the sine of an angle in radians, yielding the vertical component of that angle drawn on a unit circle. Related to the values of π and τ.
Cosine Purification (num → num)
Takes the cosine of an angle in radians, yielding the horizontal component of that angle drawn on a unit circle. Related to the values of π and τ.
Tangent Purification (num → num)
Takes the tangent of an angle in radians, yielding the slope of that angle drawn on a circle. Related to the values of π and τ.
Inverse Sine Prfn. (num → num)
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 π and τ.
Inverse Cosine Prfn. (num → num)
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 π and τ.
Inverse Tangent Prfn. (num → num)
Takes the inverse tangent of a value, yielding the angle whose tangent is that value. Related to the values of π and τ.
Inverse Tan. Prfn. II (num, num → num)
Takes the inverse tangent of a Y and X value, yielding the angle between the X-axis and a line from the origin to that point.
Logarithmic Distillation (num, num → num)
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 e.
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)".
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".
Disjunction Distillation ((num, num)|(list, list) → num|list)
Unifies two sets.
As such:
With two numbers at the top of the stack, combines them into a bitset containing every "on" bit in either bitset.
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 Combination Distillation.
Conjunction Distillation ((num, num)|(list, list) → num|list)
Takes the intersection of two sets.
As such:
With two numbers at the top of the stack, combines them into a bitset containing every "on" bit present in both bitsets.
With two lists, this creates a list of every element from the first list that is also in the second list.
Exclusion Distillation ((num, num)|(list, list) → num|list)
Takes the exclusive disjunction of two sets.
As such:
With two numbers at the top of the stack, combines them into a bitset containing every "on" bit present in exactly one of the bitsets.
With two lists, this creates a list of every element in both lists that is not in the other list.
Negation Purification (num → num)
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.
Uniqueness Purification (list → list)
Removes duplicate entries from a list.
This can be very powerful in tandem with Foci.
It also makes the bureaucracy of Nature a "Turing-complete" system, according to one esoteric scroll I found.
However, it seems there's a limit to how many times a Hex can cast itself-- Nature doesn't look kindly on runaway spells!
In addition, with the energies of the patterns occurring without me to guide them, any mishap will cause the remaining actions to become too unstable and immediately unravel.
When the "Jump"-iota is executed, it'll skip the rest of the patterns and jump directly to the end of the pattern list.
While this may seem redundant given Charon's Gambit exists, this allows you to exit nested Hermes' invocations in a controlled way, where Charon only allows you to exit one.
The "Jump" iota will apparently stay on the stack even after execution is finished... better not think about the implications of that.
More specifically, for each element in the second list, it will:
Create a new stack, with everything on the current stack plus that element
Draw all the patterns in the first list
Save all the iotas remaining on the stack to a list
Then, after all is said and done, pushes the list of saved iotas onto the main stack.
No wonder all the practitioners of this art go mad.
But when combined with Hermes' or Thoth's Gambits, it becomes far more interesting. Those patterns serve to 'contain' that halting, and rather than ending the entire Hex, those gambits end instead. This can be used to cause Thoth's Gambit not to operate on every iota it's given. An escape from the madness, as it were.
These patterns must be cast from a Spell Circle; trying to cast them through a Staff will fail rather spectacularly.
Waystone Reflection (→ vector)
Returns the position of the Impetus of this spell circle.
Lodestone Reflection (→ vector)
Returns the direction the Impetus of this spell circle is facing as a unit vector.
Lesser Fold Reflection (→ vector)
Returns the position of the lower-north-west corner of the bounds of this spell circle.
Greater Fold Reflection (→ vector)
Returns the position of the upper-south-east corner of the bounds of this spell circle.
Akasha's Distillation (vector, pattern → any)
Read the iota associated with the given pattern out of the Akashic Library with its Record at the given position. This has no range limit. Costs about one Amethyst Dust.
Akasha's Gambit (vector, pattern, any →)
Associate the iota with the given pattern in the Akashic Library with its Record at the given position. This does have a range limit. Costs about one Amethyst Dust.
Patterns and actions that perform a magical effect on the world.
Certain spells, such as Place Block, will consume additional items from my inventory. When this happens, the spell will first look for the item to use, and then draw from all such items in my inventory.
This process is called "picking an item."
More specifically:
First, the spell will search for the first valid item in my hotbar to the right of my staff, wrapping around at the right-hand side, and starting at the first slot if my staff is in my off-hand.
Second, the spell will draw that item from as far back in my inventory as possible, prioritizing the main inventory over the hotbar.
This way, I can keep a "chooser" item on my hotbar to tell the spell what to use, and fill the rest of my inventory with that item to keep the spell well-stocked.
Explosion (vector, number →)
Remove a number and vector from the stack, then create an explosion at the given location with the given power.
A power of 3 is about as much as a Creeper's blast; 4 is about as much as a TNT blast. Nature refuses to give me a blast of more than 10 power, though.
Strangely, this explosion doesn't seem to harm me. Perhaps it's because I am the one exploding?
Costs a negligible amount at power 0, plus 3 extra Amethyst Dust per point of explosion power.
Fireball (vector, number →)
Remove a number and vector from the stack, then create a fiery explosion at the given location with the given power.
Costs one Amethyst Dust, plus about 3 extra Amethyst Dusts per point of explosion power. Otherwise, the same as Explosion, except with fire.
Impulse (entity, vector →)
Remove an entity and direction from the stack, then give a shove to the given entity in the given direction. The strength of the impulse is determined by the length of the vector.
Costs units of Amethyst Dust equal to the square of the length of the vector, plus one for every Impulse except the first targeting an entity.
Blink (entity, number →)
Remove an entity and length from the stack, then teleport the given entity along its look vector by the given length.
Costs about one Amethyst Shard per two blocks travelled.
Make Note (vector, number, number →)
Remove a vector and two numbers from the stack. Plays an instrument defined by the first number at the given location, with a note defined by the second number. Costs a negligible amount of media.
There appear to be 16 different instruments and 25 different notes. Both are indexed by zero.
These seem to be the same instruments I can produce with a Note Block, though the reason for each instrument's number being what it is eludes me.
Either way, I can find the numbers I need to use by inspecting a Note Block through a Scrying Lens.
Place Block (vector →)
Remove a location from the stack, then pick a block item and place it at the given location.
Costs about an eighth of one Amethyst Dust.
Break Block (vector →)
Remove a location from the stack, then break the block at the given location. This spell can break nearly anything a Diamond Pickaxe can break.
Costs about an eighth of one Amethyst Dust.
Create Water (vector →)
Summon a block of water (or insert up to a bucket's worth) into a block at the given position. Costs about one Amethyst Dust.
Destroy Liquid (vector →)
Drains either a liquid container at, or a body of liquid around, the given position. Costs about two Charged Amethyst.
Conjure Block (vector →)
Conjure an ethereal, but solid, block that sparkles with my pigment at the given position. Costs about one Amethyst Dust.
Conjure Light (vector →)
Conjure a magical light that softly glows with my pigment at the given position. Costs about one Amethyst Dust.
Overgrow (vector →)
Encourage a plant or sapling at the target position to grow, as if Bonemeal was applied. Costs a bit more than one Amethyst Dust.
Edify Sapling (vector →)
Forcibly infuse media into the sapling at the target position, causing it to grow into an Edified Tree. Costs about one Charged Amethyst.
Ignite Block (vector →)
Start a fire on top of the given location, as if a Fire Charge was applied. Costs about one Amethyst Dust.
Extinguish Area (vector →)
Extinguish blocks in a large area. Costs about six Amethyst Dust.
This family of spells all impart a negative potion effect upon an entity. They all take an entity, the recipient, and one or two numbers, the first being the duration and the second, if present, being the potency (starting at 1).
Each one has a "base cost;" the actual cost is equal to that base cost, multiplied by the potency squared.
According to certain legends, these spells and their sisters, the Zeniths, 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..."
Perhaps that is the reason for their peculiar names.
White Sun's Nadir (entity, number, number →)
Inflicts weakness. Base cost is one Amethyst Dust per 10 seconds.
Blue Sun's Nadir (entity, number →)
Inflicts levitation. Base cost is one Amethyst Dust per 5 seconds.
Black Sun's Nadir (entity, number, number →)
Inflicts withering. Base cost is one Amethyst Dust per second.
Red Sun's Nadir (entity, number, number →)
Inflicts poison. Base cost is one Amethyst Dust per 3 seconds.
Green Sun's Nadir (entity, number, number →)
Inflicts slowness. Base cost is one Amethyst Dust per 5 seconds.
These three spells each create an item that casts a Hex.
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 Amethyst to form the item's battery.
See this entry for more information.
Craft Cypher (entity, [pattern] →)
Costs about one Charged Amethyst.
Craft Trinket (entity, [pattern] →)
Costs about five Charged Amethysts.
Craft Artifact (entity, [pattern] →)
Costs about ten Charged Amethysts.
Recharge Item (entity →)
Recharge a media-containing item in my other hand. Costs about one Amethyst Shard.
This spell is cast in a similar method to the crafting spells; an entity representing a dropped stack of Amethyst is provided, and recharges the media battery of the item in my other hand.
This spell cannot recharge the item farther than its original battery size.
Erase Item
Clear a Hex-containing item in my other hand. Costs about one Amethyst Dust.
The spell will also void all the media stored inside the item, releasing it back to Nature and returning the item to a perfectly clean slate. This way, I can re-use Trinkets I have put an erroneous spell into, for example.
This also works to clear a Focus or Spellbook page, unsealing them in the process.
Hence, away! Now all is well,
One aloof stand sentinel.
A 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.
It has several interesting properties:
It does not appear to be tangible; no one can touch it.
Only my Hexes can interact with it.
Once summoned, it stays in place until banished.
I am always able to see it if I'm close enough, even through solid objects.
Summon Sentinel (vector →)
Summons my sentinel at the given position. Costs about one Amethyst Dust.
Banish Sentinel
Banish my sentinel, and remove it from the world. Costs a negligible amount of media.
Locate Sentinel (→ vector)
Add the position of my sentinel to the stack, or Null if it isn't summoned. Costs a negligible amount of media.
Wayfind Sentinel (vector → vector)
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.
Internalize Pigment
I must be holding a Pigment in my other hand to cast this spell. When I do, it will consume the dye and permanently change my mind's coloration (at least, until I cast the spell again). Costs about one Amethyst Dust.
Although it seems that true, limitless flight is out of my grasp, I have nonetheless found some methods of holding one in the sky, each with their respective drawbacks.
All forms produce a shimmer of excess media; as the spell gets closer to ending, the sparks are shot through with more red and black.
Other forms of flight do exist, of course. For example, a combination of Impulse and Blue Sun's Nadir has been used since antiquity for a flight of sorts.
I've also heard tell of a thin membrane worn on the back that allows the ability to glide. From my research, I believe the Great spell Altiora may be used to mimic it.
Anchorite's Flight (entity, number →)
A flight limited in its range.
The second argument is a horizontal radius, in meters, in which the spell is stable. Moving outside of that radius will end the spell, dropping me out of the sky. As long as I stay inside the safe zone, however, the spell lasts indefinitely. An additional shimmer of media marks the origin point of the safe zone.
Costs about 1 Amethyst Dust per meter of safety.
Wayfarer's Flight (entity, number →)
A flight limited in its duration.
The second argument is an amount of time in seconds for which the spell is stable. After that time, the spell ends and I am dropped from the sky.
It is relatively expensive at about 1 Charged Crystal per second of flight; I believe it is best suited for travel.
Getting Started
Media
Geodes
A Frustration
WHAT DID I SEE
Hex Casting
Hex Casting 101
A Primer On Vectors
Mishaps
The Stack
Naming Actions
Influences
Enlightened Mishaps
Items
Scrying Lens
Thought-Knot
Abacus
Spellbook
Scrolls
Casting Items
Phials of Media
Edified Trees
Jeweler's Hammer
Decorative Blocks
The Great Work
The Work
On The Flaying of Minds
Villager must be a Journeyman or higher
Spell Circles
Impeti
Directrices
Akashic Libraries
Fanciful Staves
Lore
Cross-Mod Compatibility
Pehkui
Patterns
How to Read This Section
Basic Patterns
Mathematics
Constants
Entities
List Manipulation
Escaping Patterns
Advanced Mathematics
Sets
Meta-Evaluation
Spells
Working with Items
Block Manipulation
Nadirs
Sentinels
Flight
Great Spells
Create Lava
Weather Manipulation
Altiora
Greater Teleport
Summon Greater Sentinel