Elevator Pitch
Expeditions is a rogue-lite deckbuilder in which the player leads a party of three explorers, braving a hellish landscape of fog in the hunt for valuable artifacts and the dark secrets at the heart of the mist.
Inspirations: Hades (Supergiant Games), Inscryption (Daniel Mullins Games), STALKER (various), Annihilation (2018 film), SCP Foundation (various)
Core Gameplay
The core gameplay is in the form of a card battle, for which I have coded a prototype using Unity (more on that later). The gameplay is best explained in a video:
Extensions to the core gameplay
The video shows a prototype which has some features of the final design, but not all. Here are a couple of the main ways I want to develop the core gameplay:
Firstly, I want to create a sense of speed and urgency in the gameplay, and the intention is to do this thematically with “madness”. A character’s madness is a value from 0 to 10. When it is above zero, then the player has a ticking clock when selecting that character’s action, with less time to do so at higher madness. Failure to select an action in time results in a random action, representing the characters’ tendency to behave erratically when their minds fray. Madness can be increased by certain enemies and anomalies, and can be reduced with items. Lastly, characters’ attacks will become more deadly when at higher madness levels - meaning that more experienced or skillful players are incentivised to run a high risk/reward, high-madness party.
I also want to add different types of action card, especially a “use skill” card and a “use item” card. This will then change based on the special skill/item of the character currently acting - one character might have a healing item, another might have a grenade - and will be a key way to differentiate different characters.
Obviously there is also more work to do on player card types, enemy types and baheviours, and so on, as well as the graphics (which are very basic at the moment) but this was all out of scope for a simple prototype.
Building the prototype
I have made a simple prototype of this game in Unity, both as a proof of concept and a learning exercise (it is my first real project with Unity engine).
The architecture can be summarized fairly simply:
A BattleController object acts like an orchestra’s conductor. It controls the flow of the encounter, by reading and updating a BattleState enum when different parts of the process have finished.
The BattleController manages a constellation of objects responsible for individual parts of the process, such as moving the camera (CameraController), creating, moving and destroying character cards (CharacterCardsController), creating, moving and destroying the action cards (HandController), choosing enemy actions (EnemyActionSelector) and displaying them (EnemyActionDisplayer).
A Player object is intended to represent the player’s state that will persist and update over the course of many battles. It contains information about the player’s character cards and deck of actions, which is then read by the objects in the BattleController system.
There’s more to it of course, but this is the general idea. Most of the classes are MonoBehaviour scripts attached to dummy objects in the unity editor, as they need to perform actions on a frame-by-frame basis such as moving objects.
Challenges and Learnings
The first and most obvious challenge was learning to use Unity, which I haven’t had any experience with before. I was happy with how quickly I was able to pick it up, which I put down to my experience with Java (C# syntax is basically the same). A big breakthrough came when I started to understand that the game object hierarchy in the Unity editor could be thought of as the “main'' script in the sorts of applications I usually make - responsible for instantiating the key top-level objects, tying them together and then allowing their methods to get on with the rest. I learned to wire gameobjects together in the editor and then extract their MonoBehaviour scripts as class instances within the scripts. (I have no idea if this is best practice but it did work!). I still often trip up, such as when the code hits an exception but Unity carries on running (I’m not used to this behaviour, though it does make sense in the context of a video game). But this is happening increasingly less often.
A couple of game design learnings came up quickly when making the prototype as well.
Firstly, I originally planned for an eight-tile setup with four spaces for player cards and four for enemies. However I found that there were limited opportunities for interacting with planned enemy actions (such as moving the targeted card out of the way). Moving to a 6-tile setup naturally helped this by increasing the chance that the current acting enemy would be positioned within reach of the currently acting player card.
Secondly, I added the exclamation point to indicate the enemy card that will act next turn, when it became clear that this would open up interesting tactical possibilities for the player. I intend to keep the enemy AI simple (at the moment it will attack if possible, and move if not) so that the player can plan strategies around knowing roughly what the enemy will do not just this round, but the next as well. Because there are only three enemies at most, the exclamation point gives the player complete information about the order of enemy actions.
Further Game Design - Narrative/The Overworld Map
The fog arrived from nowhere. The few who escaped ahead of it refused to consider returning, haunted by terrible visions which still cling to the backs of their eyelids at night. The Interior Ministry sent in soldiers; they didn’t come back. Now even animals shun the place, skitting nervously from the edge of the mist, defying the silver tendrils that beckon so sweetly.
Six years on, and it hasn’t gone, but it at least shows no signs of growing, seemingly content with the morsel of reality it has stolen, a python slowly turning an antelope into mulch in its belly.
There are stories, of course. For every horror said to live within the Fog, there are tales of miracles and priceless treasures, of impossible wonders glimpsed in the deepest mists. Most don’t give much credence to tall tales, but enough do. Those who brave the Fog in search of its riches sometimes even return, weighed down by arcane artifacts and even taller tales, and so the Fog’s legend grows.
Each day, the player starts at their base on the edge of the Fog, a checkpoint where different factions - the military, government spies, scientists, criminals - all coexist awkwardly, united by their fear of and interest in the Fog just beyond the perimeter fence.
There, the player assembles a new expedition to send into the fog, recruiting from amongst these factions and choosing their equipment. The goal of the expedition is not to survive (life is cheap out here in the mists), but to get as far as possible, while obtaining artifacts which can be sold on the black market to upgrade the base, and advance the story.
Expeditions advance by moving between different nodes, which result in different encounters - these might be anomalies, dilemmas, treasures, or combat. Success at each node will present rewards to upgrade the party, such as skill improvements or new items. In this way the party improves and specializes as it advances.
As the expeditions proceed, they will reach different areas, each with their own unique visual style, anomalies and enemies: A formidable boss will cap exploration in each area.
Next Steps for the Project
I want to flesh out the prototype combat encounter so that it starts to resemble more closely the vision I outlined above, and to tidy up the code now I have a clearer idea of best practices and the tools available.
Next I want to work on menu systems for saving, loading, victory and defeat, as well as management of player cards.
Then, I will work on the overworld map and the node structure for expeditions, as well as other encounter types such as treasure and anomalies, rewards/upgrades, and a boss battle.
The next step will be to work on the perimeter base, and the overall progression of the game and narrative over a sequence of expeditions.
It’s a big project, but broken down into small pieces, it’s so far proven quite manageable and I am enjoying it immensely.
