The patterns in this chapter allow me to manipulate Constructs: living machines capable of carrying out my orders and even casting some limited Hexes on their own.
Constructs are a type of machine used by Hexbinders in ages past, and, following meticulous study of surviving blueprints, are now at my disposal.
What puts Constructs apart from simpler machines such as the Golems employed by villages of this world is their ability to process Hexes and use special patterns to interpret Hexes as physical actions to perform. While the limitations are many, these ''commands'' allow me to encode as Construct instructions a variety of tasks I'd personally find too mundane or dangerous (unless I find myself getting attached to these inanimate objects).
First, the limitations:
Constructs are too sensitive to use their own media for casting Hexes. It should be assumed they do not possess any media to spend.
Most patterns, especially Spells, directly affecting the outside world simply cannot be processed by their limited pseudo-minds.
Said pseudo-minds behave as any other Figment: Mind's Reflection will push Null, Pigments and Sentinels will not function.
Now, for some details about the casting mechanism:
Construct instructions are a list of iotas and are executed immediately after each other, not unlike those contained within Casting Items.
Constructs start new instructions with an empty stack and Ravenmind.
Encountering a Mishap or an error in executing the command, cancels both the execution and any issued command, as well as clear the stack and Ravenmind.
Send Instructions (entity, [pattern] →)
Some basic patterns to close off the introduction. Remove a reference to a Construct and a list of patterns from the stack and send the list as instructions to the Construct.
Automaton's Reflection (→ entity)
If executed by a Construct, puts a reference to it on the stack. Otherwise, causes a Mishap. Should be used instead of Mind's Reflection for Hexes executed by Constructs.
The core component of any Hex executed by a Construct will be its commands, however there is an issue that needs to be addressed first. Construct instructions, like any Hex packaged into a list, execute instantly after each other. While normally not an issue, this causes multiple commands issued in a row to replace each other, not giving even the shortest ones a moment to be executed.
The solution lies in the last argument to any command pattern. Once the command has finished, the construct will execute the list passed to it next. Stack and Ravenmind remain intact between these executions, and they can be chained to execute whole sequences of commands. However, each command will bring the spell closer to its execution limit, like Hermes' Gambit would.
Finally, a few notes on evaluating commands:
Commands can only be evaluated by a Construct. Doing so myself will cause a Mishap to occur.
Some commands require the Construct be able to perform certain actions like picking up items or harvesting crops.
Should I, eventually, discover a Construct incapable of such actions, evaluating such a command will cause a Mishap.
Some commands require the target be directly next to the Construct. I can expect about two blocks of leeway within which the Construct can figure the details out.
Should a Mishap or a command error occur, I can examine the Construct by using a Scrying Lens on it while sneaking to find the issue.
Now, for the commands themselves.
Command: Move To Position (vector, [pattern] →)
Removes a vector from the stack and instructs the Construct to go to the position represented by that vector. The position must be within 32 blocks of the Construct.
Command: Pick Up Item (entity, [pattern] →)
Removes an entity representing a dropped item from the stack and instructs the Construct to pick it up. The item must be next to the Construct, the construct must be able to pick items up and not be carrying one already.
Command: Drop Item ([pattern] →)
Instructs the Construct to drop the item it is currently carrying. The construct must be able carrying an item.
Command: Harvest (vector, [pattern] →)
Removes a vector from the stack and instructs the Construct to harvest crops or berries at the position represented by that vector. If harvesting the block destroys it, it will be replanted by the Construct. The position must be next to the Construct, and the Construct must be capable of interacting with the world.
Command: Use On Block (vector, vector, [pattern] →)
Removes two vectors from the stack and instructs the Construct to use the currently held item, if any, on the block represented by the first vector.
If the second vector is not zero, the block is used from the side indicated by it. If it is zero, it will be used from the side closest to the Construct. The position must be next to the Construct, the Construct must be capable of carrying items, and interacting with the world.
After careful study, experimentation, and filling in both figurative and literal holes in what blueprints I could find, I believe I'm ready to create a Construct of my own.
Spider Constructs, as I've taken to calling them, are small, but nimble assistants capable of interacting with their surroundings, and carrying items.
One of the blueprints contained an alternate design for this Construct, which I replicated as best I could. The two designs can be switched by using an Iron Block or Amethyst Block on the Construct while sneaking or, should I find the Spider form not to my taste, by enabling a form of perception filter in configuration files to make all Constructs appear to me as their alternate design.
Spider Construct Core
Click to show recipes
Click to hide recipes
The first of the three components required to create this Construct is the Core, a composite of the lenses, motivators, and inert media required for the Construct's base form.
Spider Construct Battery
Click to show recipes
Click to hide recipes
The battery is the second component. While already made of a fair amount of media, it will have to be amplified further. Standard usage of Recharge will do, and I will be able to see the amount of Amethyst Dust required on the battery itself.
Some notes on the final component. The evidence I found clearly shows it is meant to be created artificially, but is not detailed enough to do so.
Fortunately, I managed to work a replacement into the process: a living Allay. A creature well-attuned to media and already capable of carrying items makes this process almost too easy.
Sometimes I wonder if the Allay's fate should concern me more than a passing thought.
Create Spider Construct (entity, entity, entity →)
The inputs represent, starting from deepest on the stack, the Allay, a dropped Core, and a dropped fully-charged Battery. The items are consumed, and the Allay is converted into a Construct.
I have run into several problems issuing orders to my Constructs: controlling several of them requires I pass orders to each individually, it is quite challenging to send order to only some of the Constructs in an area, and, finally, it occurred to me other Hexcasters can order my Constructs to do anything they please!
Construct Broadcaster
Click to show recipes
Click to hide recipes
The Construct Broadcaster is a small structure capable of broadcasting my orders 16 blocks around itself, solving the first two of my issues.
Broadcast Instructions (vector, [pattern] →)
Removes a vector and a list of patterns. Broadcasts the list as instructions through the Broadcaster located at the indicated position.
Broadcasting orders should save me from a few headaches in the long run, even if the range is still limited. However that is not all: a Slate containing a pattern can be placed in front of the Broadcaster, associating the instructions sent through it with that pattern.
To make use of that association, a Construct must be bound to a pattern.
Artificer's Gambit (pattern | entity | null →)
Removes a reference to a player, a pattern, or Null from the stack, and binds the Construct to it.
If bound to a pattern, the Construct will ignore broadcast orders (but not direct orders!) unless they are associated with the same pattern.
If bound to a player, the Construct will refuse orders, direct or broadcast, from anyone other than that player.
Finally, passing Null removes both the pattern and the player the Construct is bound to.
Entity Prfn.: Construct (vector → entity or null)
Transform the position on the stack into the Construct at that location (or Null if there isn't one).
Zone Dstl.: Construct (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of Constructs near the position.
Zone Dstl.: Non-Construct (vector, number → list)
Take a position and maximum distance on the stack, and combine them into a list of non-Construct entities near the position.