Navigate a mysterious island overtaken by monsters in this fantasy adventure game.

In progress, 2022 – present. MFA thesis project, accepted. Now continuing development independently. I am the sole developer. Washed Ashore was a finalist in the Full Game category at Academy of Art University’s 2024 Spring Show.

Genre: Adventure RPG
Platform: PC
Made with Unity and Ink

Washed Ashore features turn-based combat with light tactics, branching player choices, and a fog-of-war system that provides the feeling of an exciting new discovery with each step.

This game started from the idea to blend two game modes into one: it is both a digital book and an 8-bit adventure game. The game uses an interface for hypertext fiction inspired by the gamebook style of play featured in titles like Disco Elysium and other CRPGs, but the game is also influenced by adventure titles like The Legend of Zelda (1986) and Rogue (1980).

In the game, you explore one section of a vast island, making your way across beaches, through a lakeside forest, and even delving underground. You encounter other inhabitants of the island and speak with them, choosing from an array of dialog options.

The reason I made this game was to develop and showcase my skills in systems and narrative design. By continuously working on Washed Ashore over a period of 2 years to capstone my MFA, I have gained a deeper understanding of the game development process.

Design Focus: Exploration

One of the most important developments early on in the project was the idea to use fog-of-war to obscure the environment as the player explored. Through playtesting, I discovered that this mechanic helped the player feel that they were uncovering the unknown, which greatly improved the feeling of exploration.

Though it was a challenge to get the math and programming to work correctly for tiles of differing visibility, prototypes were promising, and the final system was worth the effort. Below is an abridged snippet of a C# script I wrote for the fog-of-war mechanic that works with Unity’s tilemaps. Click here to view the entire script.

    // UpdateFog function called whenever player moves to new position
    public void UpdateFog()
    {
        // set tile color at current position to transparent
        SetCurrentPositionVisited();
    }

    void SetCurrentPositionVisited()
    {
        // find the tile the player is standing on,
        // unlock color restriction, and set tile to transparent
        playerPos = playerMove.transform.position;
        tilePlayerMapPos = fogTilemap.layoutGrid.WorldToCell(playerPos);
        fogTilemap.SetTileFlags(tilePlayerMapPos, TileFlags.None);
        fogTilemap.SetColor(tilePlayerMapPos, transparentColor);

        // move to next sequence
        FindCurrentPositionAttributes();
    }

    // get reference to the TileAttributes gameObject at this tilePosition
    void FindCurrentPositionAttributes()
    {
        // declare the collider we are looking for
        Collider2D positionAttributesCollider;

        // Use OverlapPointAll to find all colliders at player's current position
        Collider2D[] colliders = Physics2D.OverlapPointAll(playerPos);

        // filter for PositionAttributes gameObject (which has a trigger box collider)
        foreach (Collider2D collider in colliders)
        {
            // if the collider is attached to position attributes game object
            if (collider.gameObject.GetComponent<PositionAttributes>())
            {
                positionAttributesCollider = collider;

                // assign reference for the position attributes component at the player's position
                if (positionAttributesCollider.gameObject.GetComponent<PositionAttributes>())
                {
                    currentPosAttributes =
                        positionAttributesCollider.gameObject.GetComponent<PositionAttributes>();
                }
                else
                {
                    Debug.LogWarning("couldn't find any overlapping position attribute colliders");
                    break;
                }

                if (currentPosAttributes.wasVisited != true)
                {
                    // mark that this tile has been visited
                    currentPosAttributes.wasVisited = true;

                    // handle whether to load flavor text
                    if (flavorTextHandler == null)
                    {
                        flavorTextHandler = FindObjectOfType<FlavorTextHandler>();
                    }
                    if (flavorTextHandler != null &&
                        currentPosAttributes.shouldAllowFlavorText)
                    {
                        flavorTextHandler.HandleTextCheck(currentPosAttributes.myTerrainEnum);
                    }
                }
            }
        }

        // move to next function in sequence
        // uses the current pos attributes to get all tiles the player should be allowed to see
        // under ideal conditions (nothing blocks view)
        GetVisibleTilesAtIdeal();
    }

// and so on....

Design Focus: Dialog

Washed Ashore contains one extensive conversation with a non-playable character as well as a few other shorter conversations. The dialog branches based on the player’s choice. My philosophy in interactive fiction is to allow the player to express themselves at all times. This is achieved usually by giving the player an option to accept, reject, deflect, or ignore any situation at any time (a model adapted from Jon Ingold’s “Sparkling Dialog” talk).

Although the story or dialog doesn’t branch away from the main drift every single time the player selects a new option, the illusion of a real conversation is maintained because the player is given the means to express themselves in every situation, with the possibility of a more extensive alternate path always possible. Below is a peek behind the curtain at one of my scripts, which uses Ink, a narrative scripting editor. I use Ink in tandem with Unity to implement most text in the game.

Design Documentation

Although Washed Ashore is a solo-dev project, documentation remains important. Keeping design documents up-to-date allows me to stay consistent with the game’s vision. Below is a one-pager, one of the first documents I made before beginning in-engine work on the project. Although many aspects of the game have yet to be implemented, and some details have changed since time-of-writing, I’ve maintained the core concepts of exploration, combat, and investigation throughout development.

One-pager begins.

Click here to view the devlogs for Washed Ashore