Mobile Point & Click Adventures


Tools, Build & Gameplay Programmer


Made in Unity, coded in C#


  4 months (ongoing), 3-man team


The Game

Simpleton is a collection of short point & click adventures you can play on your phone.

Our vision to the project is to have highly interactible scenarios with seemingly infinite possibilities, to make for 5-to-10 minute unpredictable experiences.

The stories are based on The Wandering Worlds anthology, as the project is being developed by myself, the author Brian Woodruff, and Gabriel LaForge

My Responsibilities

My role in the project is primarily Software Development, although we keep the Design of the game open for contribution by anyone. Since I'm responsible for all things technical, here's a short summary of my work so far in this project

  • Tools Programming - Unity tool for creating node-based dialogue systems
  • Gameplay Programming
  • Network Programming (some stories are multiplayer)

A Node-based editor to create dialogue trees


I realised right away that the success of this project would hinge on my ability to empower our Writing workflow to produce stories with a huge possibility space, while maintaining it cheap, fast, and effective.

Right away what anyone would think is a Node-based Dialogue Editor Tool, and I was no different

An overview of the dialogue tool producing in-game dialogue, with a conditional flow, branching paths, and event handling

An overview of the dialogue tool producing in-game dialogue, with a conditional flow, branching paths, and event handling


The tool's goals

The Tool has 4 main goals:

  1. Allow for rapid development of standard dialogue routines
  2. Allow for a very malleable flow, with the ability to set global and local states on characters, scenes, and the current story
  3. Allow for custom behaviours to be added effortlessly

Custom Behaviours

The third goal was the main reason to have developed our own tool, rather than using an external one.

The fact that we wanted to keep a very high possibility space meant that no tool could ever be able to encompass all of the features that we wanted to have in game. However, it is possible to abstract these features away as "custom nodes" that are scripted to run a specific behaviour, and simply fire off an event when the dialogue is ready to move on


the code

Because tool nodes need to have their specific Editor GUI and handlers, they need access to the UnityEditor namespace, meaning they can't be used in gameplay (the UnityEditor namespace doesn't build)

So, each Tool Node class maps to a specific ScriptableObject-derived class that is a data wrapper for that node.

When making a new node in the tool, all we have to do is override a few methods. Namely:

  1. Contructor to handle initialization
  2. OnDraw to render specific GUI
  3. BuildToScriptableObject to handle Exporting data
  4. BuildFromScriptableObject to handle Importing data
public class GenericNode : DialogueNode
    public GenericNode();
    public override void UpdateNode();
    public override void Write(
            RectTransform intoFrame)
        // The main function that triggers when the dialogue
        // reaches this node
        // Call this function to segue into the next node.
        // Usually this is the first of a list of segue nodes,
        // But nodes can also branch out to multiple

    public override void BuildFromScriptableObject(
            DialogueNodeInfo_SO nodeData);
public class DT_GenericNode : DT_Node
    public DT_GenericNode() : base()
        windowTitle = "Just a Generic Node!";

    protected override void OnDraw(int windowId)
        // Draw this node's specific GUI
        // The base class takes care of overarching GUI

    public override DialogueNodeInfo_SO 
        // Build this node into a Scriptable Object data wrapper
        // which will be used in-game

    public override DT_Node 
        BuildFromScriptableObject(DialogueNodeInfo_SO nodeData)
        // Build this node from the data 
        //provided by a scriptable object
        return this;

This lightweight structure allows for full control over how a node initializes, updates, and finishes seguing into another node, as per determined by the Tool's tree diagram.