Started in winter of 2018/2019
By Trevor Thacker
Runic Scrollery is a currently work-in-progress game designed and programmed by me, with temporary art also by me.
Currently, the primary part of the game, magic scroll writing, is being worked on, with progress on all of its base systems nearing completion.
Full information about the game can be found on it’s game design document here:
Drawing
Drawing is done by placing down vertices of a line renderer every X distance traveled while holding down left mouse button. Every time left mouse button is lifted, a line in the current rune is placed.
Control Runes
Control Runes are saved scriptable objects containing the information and functions necessary to detect which rune the player’s drawing is and to process the chain of runes as more are added. They are containers referenced by functions outside of their own code, and are the implementation of an individual rune. The Control Rune base class has only information and no base functions, and is extended to child classes that implement functions over the virtual ones.
Rune Detection
A large challenge in programming the game was detecting symbols drawn by the player and correctly attributing them to the saved control rune data. Each control rune contains an array of lines with arrays of vertices that corresponds to each line of the pattern. Once a rune is drawn, it is compared to each control rune using the Pattern Recognition Function. This function checks each vertex in line in each control rune to see if the squared distance between it and the drawn rune are within a definable range. If a vertex does not match, then that line is marked as not matching. A drawn rune must have the same number of lines (to be changed later), and must contain a close match of each line in a control rune for it to considered a match. Once a match is found, the loop is broken out of.
Scroll Processing
After a rune is detected, the object is linked to its parent output object, creating a chain. If it is a smaller subrune, it is linked to its greater rune. Upon each rune being added, it searches for the “start” rune as an initial start point in the processing. To process the current scroll, it loops through all of a runes inputs (each rune linked in the outer circle), then continues to loop through each, until it reaches runes that have no inputs. Once these are reached, they are processed based on what type of rune they are, then after all of these are processed, the rune that takes in them as inputs is processed based on which are connected, and so on.
public void Activate()
{
type.Setup(this);
Debug.Log(name + " setup done!");
if (inputs.Count > 0)
foreach (Rune input in inputs)
if (input != null) input.Activate();
type.Process(inputs, this);
Debug.Log(name + " processed!");
}The processing of the scroll is difficult to show because it is only used to calculate the statistics of the scroll that will later be used to compare against. The current Scroll Info class has most of the main ideas and logic of how a spell scroll would work, but may be changed in the future.
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
[System.Serializable]
public class SpellInfo //All of the scroll's statistics, used to determine if a scroll is what a customer wants
{
public bool processed;
public List<SpellEffect> effects = new List<SpellEffect>();//Simultanous spell effects
//Cast Info
public int castTime;//Time it takes to cast the spell
public bool channel;//Do you have to continue "casting" the spell after the initial cast for it to continue?
public bool verbal;
public bool somatic;
public List<string> materials = new List<string>();//Does it need any materials to cast?
public List<Condition> conditions = new List<Condition>();//What specific nearby conditions must be met for the spell to be cast?
public SpellInfo()
{
}
[System.Serializable]
public class Condition
{
public string condition;
public int amount;//How much of the condition must be met?
public int range;//How close must the condition be?
public Condition() { }
}
[System.Serializable]
public class SpellEffect//Everything pertaining to what a spell does
{
public List<Command> commands = new List<Command>();
public SpellEffect() { }
[System.Serializable]
public class Command
{
public string command;
public int triggerOrder;
public string type;//The name or ID of the type
public List<SpellTargeter> targeters = new List<SpellTargeter>();
//public List<SpellEffect> followUpEffects = new List<SpellEffect>();//Spell effects that happen after this effect has finished
public List<GameObject> imprints = new List<GameObject>();//Used for spells that can conjure, display, or search
public Vector3 location;//A set location for spatial spells
public int intensity;//Intensity of the command
public int duration;//How long the command lasts for
public int delay;//How much time before the command happens after triggering
}
[System.Serializable]
public class SpellTargeter
{
public string targetType;//Single target, area shape, or projectile
public int radius;//If its a cone or a sphere, what is it's radius?
public Vector3 edgeLengths;//If its a cube or rectangular prism, what are its dimensions?
public bool startAtScroll;//Else, it is assumed that the caster can choose the start position
public int speed;//Projectile speed
public SpellTargeter() { }
}
}
}