Downloadable Games
Professional Games
Personal Games
Color v. 1
Color v. 2
Pokémon Tabletop Legends
Need For Speed Payback
School of Fish
Ivanhoe Digital
Machi Koro Digital
Fallen Star

Professional Games

Need for Speed Payback - 2017
Target Platforms:PS4, XBox One and PC
Development Platforms and Languages: Java, SQL, Mongo    
Game Genre: Racing, AAA   
Employment: Associate Developer at Electronic Arts Canada

Need for Speed Payback is the next entry into the massive Need for Speed franchise.

I was a part of a team that worked on the back-end database and multiplayer code that supports all internet related actions the game team wanted to implement.
As the game is not yet released as of the time of writing this; I cannot go into more detail.

Target Platforms: iPhone, iPad, Android, PC
Development Platforms and Languages: Unity, C#, php, MySQL
Game Genre: Children, Educational
Employment: Game Designer at 30ptDesign

School of Fish is a childrens educational game created for iPhone, iPad, Android and PC, built using Unity.
The player answers quiz style questions to gain fish and objects which they use to fill up their aquarium. They can also share fish with other players, move the objects around, sell fish, and buy other fish in the store for in-game currency. There is no out of game currency, the game is buy to play.

The basic gameplay loop is fairly simple:
1) Answer Question
2) Receive Reward

The reward system is based off of the skinner box, with rarer fish requiring a higher difficulty to have a chance at getting one after each question. The in game currency (coins) gives the player a constant small drip of rewards for each question, while the fish and items are the large randomly appearing burst rewards.
As the game was built for children, there was no punishment system in place for getting a question wrong. This slight drip of small rewards, with occasional large reward that get increasingly rare (as the player gets more types of fish, the number of new types increasingly diminishes) has proven effective in Action RPG's in recent years (Diablo 3, Torchlight, etc.), and remains effective in School of Fish. The goal is to keep the player wanting to play, and in this case, answer educational questions.

The core of the game was built in Unity using C# for scripting. While most of the game is a fairly simple MVC architecture, there is a split in the location of data, between the images (stored locally), and the questions, which are stored on a MySQL server.
Splitting the data this way allowed for a light internet footprint, but still allows for updating and adding questions on a server, without needing to push out a patch. The database was connected to with php middleware scripts.

Completed Personal Games

Target Platforms: Windows, iOS and Android Tablets
Development Platforms and Languages: Java
Game Genre: Card Game, Board Game   
Credits: Alex Lane, Julian Hunt

Ivanhoe was built for a term-long class project, but developed into so much more than that.  By the end of the project, the extra effort poured in resulted in a 119% grade, and an extremely fun digital game that could be played locally on one computer, across multiple computers, or versus 1-3 AI opponents.

The basic premise is that you play cards to win 'tournaments' of different colours.  Many of these cards only have a value on them, but some have special effects that, if used carefully, can win you the tournament.  The first player to win 4 different coloured tournaments, wins.

While the design for the game itself was set in stone (we were porting a physical game to a digital medium, after all), the UI was highly flexible, and that was the part I was in charge of.  Throughout designing the UI, I used a principle I call "hyper-responsitivity", which just means that everything that can be interacted with needs at least 3 unique visual states.  One when the mouse is over it, another when the mouse is not over it, and one when it is being activated.  This simple design decision made the whole game feel responsive and fluid.  Players always knew what could be used, and how, without the need for a lengthy tutorial.

In addition, the use of alpha values and transparencies increased the smooth feel of the game; as menu's and options could pop up without fear of the information behind them being hidden while the decision was made.

The final key part of designing the UI was extensive testing.  Every time I made a significant change, I got some people to try it out.  Each time I made sure that I got at least 1 brand new player who hadn't seen it before.  This resulted in a UI that I am extremely proud of.

Other Highlights
I voice acted each card, typically with multiple lines.  Each card had a base line that was run when you played it, and several context dependent lines.  These clips were only played if certain conditions were met, and added a lot of fun and exploration, as playtesters would attempt to create contrived situations to see what lines I hid there.

I also added some text lines to the AI opponents, so that they would use the built in chat function to taunt and praise you depending on your actions and theirs.

You can see a series of videos of me demoing the game here!

Pokémon Tabletop Legends - 2015
Game Genre: Tabletop
Credits: Nintendo for Pokémon, Pokémon Tabletop Adventures for Inspiration for Character Sheets, Paizo for Pathfinder, Wizards of the Coast for D&D3.5

Pokémon Tabletop Legends was designed as a system for me and a group of friends to play a
Dungeons and Dragons 3.5/Pathfinder style Pokémon tabletop campaign. To that end, it functions as an adapter system to Pathfinder, heavily using data from Bulbapedia to fill in the information about what stats each Pokémon should have.

The most difficult part of designing the game was figuring out how to generally preserve the soul of each Pokémon, while not needing to change each separately. This means that a Metapod should still be pathetic when attacking, and annoying when defending, or a Pikachu should be fast and highly damaging. This needed to be done while transfering the rules to be playable on pen and paper, rather than relying on a computer.

Download Link
You can download the rulebook pdf here.
You can download a small app to help calculate experience here.

Emerald - 2014
Target Platforms: Windows
Development Platforms and Languages: OpenGL, C++, Processing, Java
Game Genre: Stealth, Exploration
Credits: Alex Lane, Cameron Gilroy, Maverick Mailhot, Game Maker for Images

Emerald was built as a term long project for a second year game development course. It is a stealth game, with an emphasis on open world exploration as the player attempts to escape the city, dodging guards along the way.

The player plays as an unnamed protagonist, who has stolen some precious emeralds from the king. While fleeing, you dropped the emeralds around the city, and were then caught. You must escape from prison, reclaim the emeralds around the city, dodges the guards and make it out the main gates.

The primary challenge in the game is avoiding the guards who are spread around the city. Exploring is rewarded with additional points for each piece of blackspace, which is spent when you die. Each emerald is a small reward, but the primary motivator is exploring the world.

We knew from the start that we wanted a large world, so we needed to build a tool to make our worlds scale up quickly. While most of the game was built in C++ (OpenGL), I created a separate level editor using Java (Processing). This level editor allowed us to drag and drop, adding any number of images and types, set collision, guard paths and AI, and place the emeralds. This let us ramp up the scale of the game well beyond the scope of what we had initally beleived possible, as new levels could be designed, built and implemented in a matter of hours.

Target Platforms: Windows, Web
Development Platforms and Languages: Processing, Java
Game Genre: Platformer, Puzzle, Performance, Challenging
Credits: Alex Lane, Abdulganiyu Yusufu

Color was built to be a difficult 2D platformer, along the lines of Super Meat Boy or I Wanna Be The Guy / I Wanna Be The Boshy . The intended target was players aged 16-25 who are already fairly invested into video games.

The player plays as Boxel, the box who one day, comes to life. The player sets out in search of answers, wandering through levels in a Metroidvania style open world. Along the way, the player collects new colors, which allow them to interact with previous parts of the world in new ways, such as freezing over previously deadly water, and growing plants to solve puzzles. The game ends when the player finds a way to leave the levels they appear locked in.

This game runs off of a carefully balanced reward system, inducing frustration and feelings of impossibility at first, but rewarding mastery of problems and systems presented. The mental rewards come fairly regularly, in the form of white paint pellets (3 pictured above). While some of these are fairly trivial to obtain (The one directly to the left of the player in the image simply requires a jump), each one is intended to teach the player a new skill. The 3 pictured require that the players learns basic movement, rotation of the box and how to use a trampoline. As the player develops mastery over each new system, their enjoyment grows and builds into a desire for the next challenge.

In addition to the white pellets, there are two other rewards. The first is new Colors, which provide a large reward and a burst of enjoyment for exploration players, who can retrace their steps and use their new tool to locate new challenges and areas. The second are secrets, which are signifigantly harder than white pellets, and reward the player with a glimpse into the design of the game. These include pages such as "Cut Ideas", "Most Amusing Bugs While Developing" and "Origional Design for this Level".

This game was built during first year University, using a library overlay of Java called Processing. I led a team of 3, including myself, to build this game in a term. This was the largest project I had worked on to date, and I learned a lot about software architecture and the importance of good design.

A major mistake made in the programming of this game was building it all in one class. As we got closer to the end of the project, adding features became increasingly difficult, and some proved effectivly impossible given the time restraints. This was a mistake, but one that was learned from very effectivly. Unfortunatly, this hamstrung several critical features as we neared release including issues with resizing based on monitor size (primarily with secrets), and an inability to work on certain computers. This prompted me to begin work on Color v. 2

Instructions to Play
Warning: v. 1 Only works for 64bit Windows computers. You will also need to agree to let it run on your computer, as it is not signed. For neither of the above, download the link in step 3.
1) Download the ZIP for the original here
2) Unzip it, and click through the files until you find Color.exe
3) If it does not work on your PC, click here for the current version of the remake, which should run. (The remake is much less polished, and not complete, as it is still a work in progress).

WASD movement
Space swaps between colors once you have them.
In v. 1 Left Shift activates a color power, in v. 2 Left Shift also swaps between colors once you have them.
W when at the bottom of a trampoline jump to go higher
There are 15 white pellets to collect.
In v. 2(Press P if you get stuck in a bug)

Target Platforms: Windows
Development Platforms and Languages: Java
Game Genre: RPG, 2D, Action
Credits: Bailey Robison, Jake Taylor, Maplestory for Images

A monk is sent out from his monastery by his mentor to conquer a great evil rising out in the world. The player fights through 7 dark bosses only to face betrayal.

The name Monastory comes from a merge of Monastery (where the story begins), and Maplestory where most of the images and basic concept for a 2D RPG came from. The player receives small constant rewards in the form of combo and experience points for hitting and defeating (respectivly) enemies. Combo points allow the player to heal and continue moving quickly, while experience points grant the player levels, increasing their health and damage.

The most important part of the design, however, is the bosses. Each boss was designed to be a unique fight, with 1-4 mechanics that had been present in the levels leading up to the boss. This gave the players a progression of mastery over each mechanic, and then allowed them to test their skill against a boss. Defeating these bosses was a large mental reward for the player, as they move on to a new area with a much different visual pallet.

This game was built using basic Java. Many of the lessons I learned from this game were lessons I would carry on through my future games.

In Progress Personal Games

Target Platforms: PC, iPhone, iPad, Android, Web 
Development Platforms and Languages: Unity, C# 
Game Genre:  Board Game, Online Game

Machi Koro is one of my favourite board games, and so when the time came to choose an honours project, the idea of digitalizing Machi Koro came into my mind.  This bears quite a few similarities to Ivanhoe Digital (see above), and so I have been able to take many of the lessons I learned from that project, and improve upon them for this one.

Target Platforms: iPhone, Android
Development Platforms and Languages: Unity, C# 
Game Genre:  Augmented Reality, RPG

After working on the augmented reality app for 30pt Design, I started thinking that this would be a really interesting technology for an RPG game. So I started working on it, and right around that time, news of Pokemon Go started to appear everywhere. The Pokemon Go craze swept the world, but then vanished just as fast, as the game was entirely based on walking around. There was very minimal gameplay beyond that. Fallen Star is a fully fledged RPG that takes advantage of the critically underused ARG (Augmented Reality Game) features that are currently possible. The core of the game is leveling up your character, obtaining new gear, and fighting ever greater foes; the twist is that they are out in the real world, and you must find the enemies and treasure!

Built under this, however, is a deep and complex RPG system.  The combat is quasi-turn based, with an energy system constantly charging for both you and your opponent.  Whenever you level up, you select a class to level up in, and that class will grant you a new ability (passive or active) to use either in combat, or outside of it.  This means that all players will, to at least some extent, be a mixture of classes.

Enemies are also derived in the same way, leveraging the massive player class system to procedurally generate enemies with unique fighting styles.

Content Currently Implemented
  • 44 Unique playable classes
  • 75 different playable races (all with unique skills and starting stats)
  • 350 Magic items with different effects ranging from simple (+1 Strength) to complex (Grants you a shield based on your Wisdom whenever you hit an enemy with an attack that costs more than 10 energy).
  • 50 Dungeon Rooms (Trials meant to be the progression system for the game)
  • 200 Recipe Items used for crafting magic items or one of 90 different consumables.
  • 200 Unique active skills and 450 Unique passive skills

Content Still to Create

Fallen Star is set for release in early Summer 2018.

Target Platforms: PC, iPhone, iPad, Android, Web
Development Platforms and Languages: Unity, C#
Game Genre: Platformer, Puzzle, Performance, Challenging

Color v. 2 is the sequel of Color v. 1. The concept and design remain from the first Color. The purpose of the sequel is building a new backend, in a new program that will allow for easier exporting and eventual sale.

Color was built to be a difficult 2D platformer, along the lines of Super Meat Boy or I Wanna Be The Guy / I Wanna Be The Boshy . The intended target was players aged 16-25 who are already fairly invested into video games.

The player plays as Boxel, the box who one day, comes to life. The player sets out in search of answers, wandering through levels in a Metroidvania style open world. Along the way, the player collects new colors, which allow them to interact with previous parts of the world in new ways, such as moving through previously deadly water, double jumping and inverting gravity for every object.

The design for this game remains similar to Color v. 1 with the exception of the following.

The white paint pellets allow access to more areas in a style reminiscent of Super Mario 64's star system. Furthermore the colors all changed.

Currently Implemented Colors:
Blue - Don't die to water
Gray - Double Jump
Purple - Invert Gravity for everything

The secrets were cut from the game, as the expansion of the color power system has opened up more avenues for rewards. The most ambitious part of the project is currently in progress: Implementing a Color that turns the game 3D while you are in it.

Unlike Color v. 1, this game is built in Unity for easy porting, which will allow it to be made for PC and mobile.

Instructions to Play
1) Download the ZIP here
2) Unzip it, and navigate to the Builds folder. Double click on Color.
3) Select your monitor resolution and click "Play!"

WASD movement
Left Shift or Space swaps between colors once you have them.
W when at the bottom of a trampoline jump to go higher
There are 15 white pellets to collect.
(Press P if you get stuck in a bug)

Target Platforms: PC, iPhone, iPad, Android
Development Platforms and Languages: Unity, C#, JavaScript, MySQL
Game Genre: TCG, Online, Board Game, Multiplayer

Sapphire is an online TCG with a twist: there's a board. Players place units, buildings and cast spells on a turn based battlefield to attempt to capture over half of the crystals on each map before their opponent can.

The profit model for the game is pack based, along the lines of the physical Magic: The Gathering or the digital Hearthstone.

The design is split into 2 parts, in game and out of game.

In Game
The reward is a simple mastery over an opponent reward. It's the same drive that pushes players through each League of Legends or Hearthstone game. In the game, the thrill of planning and an outplay drive the moment to moment, while the anticipation of the joy of a victory drives the whole rest of the in game design.

Each turn is a series of choices. Players have 5 energy, plus 1 for each captured crystal, with which to play cards. Buildings and units can only be played inside the zone around either the player's starting point, or a captured crystal, while spells can be played anywhere. This provides extra power to defense, while also allowing snowballing through increased pressure applied through more energy per turn.

Units are what is used to capture points, and fight other units and buildings. Buildings are used to improve units and defend stationary points. Spells are used to break fortifications of buildings and units. Spells have a mechanic similar to the overload mechanic in Hearthstone, where energy is locked the turn after a spell is cast equal to the amount of energy expended on spells. This is to ensure that spells must be used efficiently, and they do not take over due to their immediate effect as they did in the early years of Magic: The Gathering.

Out of Game
The player receives a small reward of gold after each game, more for a win. This gold can be used to purchase packs of cards, which contain a random assortment of cards. There is also a premium currency of Sapphires, which cost real money and can be used to purchase packs.
There will also be a supported third party market, where players can sell cards to each other for gold or sapphires, with a 10% cut taken from each transaction.

The base for the game is built in Unity for easy porting, which will allow it to be made for both PC and mobile.

The server will be a JavaScript dedicated server, and player data will be stored on a MySQL server. This architecture should allow players to play on various devices using the same collection of cards and rating when a ranked system is implemented.