"Should" and "Could" and "would" things for this release.

Must

ALL DONE.

Should

ALL DONE.

Could

Glyph Crafting

System Crafting

Countering

Countering

• Two types: Dampen and scramble.
• Dampen lowers field excitations in a specific area and causes modifying effects to be harder.
• Scramble causes random spikes in the fields in a specific area and causes creation effects to be harder.
• Both have a value attached. Each 1 increase increases power cost for that type of automata with 100.

Glyph Crafting

Glyphs are the building blocks of automata, but each glyph itself consists of smaller instructions that modify reality in some small way. These instructions are provided by the spark.

Glyph crafting is the ability to create new glyphs built from the base instructions.

Creating a Glyph

Creating Dominant Glyphs

During glyph creation, you can mark a glyph as a dominant glyph of a certain element. There are two drawbacks to this. First, you are not allowed to manipulate the element's opposite type. If you do, either directly or through inputs, the glyph's code in the automata will fall apart and the flow will be interrupted, causing all stored intermediaries to be released at random. The second drawback of making a dominant glyph is that you are only allowed to use constant values of the dominant type.

Deciphering

A mage that knows how the internals of most automata work can use this knowledge to decipher automata and glyphs. However, a mage with this knowledge can only see the raw instruction chain of the automata, not the actual glyphs. This raw chain contains additional code used for handling IN/OUT parameters of glyphs and does not contain any label definitions. Jump instructions have their label destination replaced with a four dimensional coordinate that is relative to the surface of the device the automata is inscribed on and is generally impossible for mortals to figure out.

Glyph Language

Glyph Language Rules:

• Expressions are the basic element.
• Expressions are separated by whitespace. Additional whitespace is ignored. Whitespace includes space, tab and newlines.
• Comments are written using #

Expressions

• Type:Value => Register
  Defines a constant value and stores it in Register.
• Register1 => Register2
  Retrieves the value from Register1 and stores it in Register2.
• processing_operation(parameter1 .. parameterN) => Register
  Performs operation with parameter1 to parameterN and stores the result in Register.
• -> label
  Label declaration. Provides a point where jump instructions can jump to.
• when comparison_operation(parameter1 .. parameterN) jump label
  If the comparison operation returns true, perform a jump to the named label. Otherwise, normal program flow continues.
• jump label
  Jump unconditionally to the specified label.

Processing Operations

• combine(param1, param2)
  Combines param1 with param2 and returns the result.
  The following happens when combining:
  • type(param1) == type(param2) > param1 + param2
  • type(param1) == inv(param2) > param1 - param2
  • else > param1
• append(param1, param2)
  Creates an aggregate from param1 and param2.
  The following happens with an aggregate:
  • If param1 and param2 are particles, the result becomes an atom.
  • If param1 or param2 are atoms the result becomes a molecule.,

Comparison Operations

• empty(param1)
  Returns true if param1 is empty, false if not.
• notempty(param1)
  Returns true if param1 is not empty.
• equals(param1, param2)
  Returns true if param1 equals param2, both in number and type. Will always return false if either param1 or param2 is empty.
• greater(param1, param2)
  Returns true if param1 is the same type as param2 and param1 is greater than param2. Will return false if either param1 or param2 is empty or if the types do not match.
• less(param1, param2)
  Returns true if param1 is the same type as param2 and param1 is less than param2. Will return false if either param1 or param2 is empty or if the types do not match.
• same_type(param1, param2)
  Returns true if the type of param1 is the same as the type of param2.

Implementation Details

These pages contain details about how the system is implemented.

# Program start
start ->                    # 0;

# Gather energy
set R1 => 2 : Fire          # 3;
set R2 => 1 : Water         # 5;

# Wait until a target is chosen then execute the rest, this sets TARGET register
on target jump target       # 10;

target ->                   # 10;

# Combine Fire and Water to get Fire and Energy
set R1, R2 => R1 + R2       # 15;

# Combine Energy with Direction to get Force
set R2 => R2 + TARGET       # 19;

# Apply force to fire to gain a missile
set R1 => R1 + R2           # 23;

# Release the energy of the missile to finish the spell
release R1                  # 24;

$identifier ::=     [a-z][a-zA-Z0-9_]*
$number     ::=     [0-9]+
$comment    ::=     #.*\n
$typeID     ::=     [A-Z][a-z]*
$register   ::=     R[0-7] | TARGET
$eventID    ::=     touch | target

@label      ::=     $identifier

@label_def  ::=     @label ->
             
@jump       ::=     jump @label
             
@event      ::=     on $eventType jump @label; 
# Blocking, sets TARGET when activated

@branch     ::=     branch @expr jump @label;
             |      branch @expr jump @label else @label;

@expr       ::=     $register
             |      @constant
             |      @comparison
             |      @expr + @expr
             |      !@expr
             |      isnull @expr
             
             
@comparison ::=     @expr < @expr
             |      @expr <= @expr
             |      @expr = @expr
             |      @expr > @expr
             |      @expr >= @expr
             
@constant   ::=     $number : $typeID

@set        ::=     set $register(, $register)* => @expr

@release    ::=     release $register

Specialised Glyphs

System Crafting

Systems are combinations of automata that together form a larger whole.

System crafting is the ability to create systems from a number of automata.