My most current project is a casual word game based around anagrams.
I have carefully curated a dictionary of over 60,000 words to provide over 6000 levels of gameplay. Each game starts with a randomly selected 7-letter word, unknown to the player. An algorithm then extracts all 3, 4, 5, 6 and 7 letter words from the selection and lists them as blank entries for the player to find.
There are 10 tiers of difficulty, based on commonality of the words and repeated letters.
Player collects persistent Gold Stars and Hint Stars.
Drag letters onto the central panel to build a word and then submit. If the word is there it is revealed otherwise a mistake is logged. Player has a limited number of mistakes they can make after which the Enter button will be locked (unlocked by spending hints).
Found words are rewarded with stars (Bronze for half the words in a block, Silver for 3/4, Gold for all). Each level requires a basic number of stars to be collected to allow progress to next level, Gold Stars are persistent and when 5 have been collected, a Hint Star is awarded.
Hints can be spent on revealing certain letters or words, or to increase mistakes allowed (and unlock a locked Enter button). Hints can be gained by collecting 5 Gold Stars, by watching rewarded advertisements, or by direct purchase. Banner adverts can be displayed on each page and interstitial adverts can be displayed in between levels.
An implementation of a classically simple dice puzzle. Roll the dice around the board to try to match the top faces of adjacent dice.
Keeping track of rotations in all 3 axes is tricky. I solved the inherent problem of detecting the top face of a die by rounding the euler angles to the nearest 90 degrees (wrapping 360 to 0), then finding the dot products of Vector3.up and each of the x, y and z axes, and using this set of dot products as a look up vector in a dictonary with the 6 faces. Dice are recursively checked against their neighbours for top-face matches after each player move.
Levels are designed in Unity editor by simply dropping prefabs onto a special grid object. The grid object has a method on its OnValidate callback which automatically updates itself when properties (width, length, etc.) are changed. New dice types can be easily created with behaviours and properties added to the Dice.cs script. At this stage I have many mechanics ideas such as: decals on certain faces of the dice which have properties like sticky or explosive; floor tile variation - drop away tiles, water or sliding surface, etc.
The mechanic in this demo is rotating tiles to form 'safe' paths through the level. The level is procedurally generated, clustering tiles to define a town, a couple of forests and a couple of bodies of water. The player is allowed to walk in most directions on most tiles, however rocks, water and thick forest will prevent travel. When walking off the paths, there is a random chance of an encounter with enemies specific to the tile type (spiders in the forests, goblins in the towns, etc.), losing hearts when damaged but gaining coins when the enemy is defeated. Hearts can be restored at the healer and tools can be bought at the smith. There is an axe that can be found for free in the woods; once the player has an axe, trees can be chopped down to create new paths (tree stumps grow back over time) and collect timber which can be used to build a raft in the town. The raft will allow the player to travel from a jetty across water tiles.
The paths on the tiles are procedurally generated using a bitmask which is fed into a shader. The shader operates on a single texture file, sampling a basic albedo from the grass texture quarter or the path texture quarter according to the correct path shaped mask (the index of which is the bitmask).
The core design in EXEO is centred around ancient stone statues with gemstones set into their features. On each level there is a large crystal which collects light and shines it into any gemstones it can reach. Whilst a statue has a light shining on its gemstone it is motionless, but when the light is broken the statue comes to life. Some statues simply move around or block entrances (implemented in this demo), but the classes I designed for the statues are adaptable for different behaviours such as aggression, destruction, sentry (will attack if approached), etc.
The player is judged at the end of a level on speed and number of coins collected and awarded an achievement star for the level. Some levels cannot be completed if the statue moves to a certain square - there is a reset option in the menu.
Levels can be designed in the Unity editor by setting the properties of a dynamic grid and dropping prefabs into starting places. Statues have a 'Program' script: arrays of instructions such as 'Walk Forward', 'Turn Right', which are grouped into sequences that in turn can be played once, looped, ping-ponged, etc.
Sim Raiders was my degree final year project which I documented throughout on its own promo website so I'll keep this description brief. The concept I was aiming for was a 3D rogue-like where you have partial control over a party of semi-autonomous characters. Items you find in the dungeons primarily would improve each character architype so that when a character dies and is replaced, they would behave more like you wanted. At the time, it took all of my time to implement the basic procedural dungeon system (I worked on the entire project alone, creating all the assets myself) and this became my major focus and the subject of my dissertation. I would like to return to this project and tackle the character behaviour mechanics.
This is my first exploration of the pen-and-paper RPG setting of Paranoia (1984, Mongoose) as a video game. There are 3 concepts from the original RPG which I have started to design as game-systems:
As I am going to be procedurally generating the environments, the proportions of each room are based on 1/3s and 12s (for maximum modularity). There are extremly simple colliders as a standard nav-mesh system cannot be baked; this is the same for light-maps so the strip-lighting in each room uses a custom shader to reflect and multiply a masked area of light from a cheap point light source in the centre of the room.
This is a spying game inspired by Spy Vs. Spy (1984, First Star). It was based on old ideas I had about an update of this classic, then inspired by the release of Invisible Inc. (2015, Klei). Rogue Spy will be a roguelike stealth game where sneaking is not the only stealthy activity - research the people and the businesses to find and exploit motivations and personality traits.
This demo shows basic office-space and staff generation, furniture inventories and mission objective placement. At this stage The people have no AI other than random-target movement as I have yet to implement a dynamic navigation system. The level is generated via placement of overlapping boxes, followed by a drunken-walk algorithm to make sure every room is accessible from every other room.
This is the office generation system for my Rogue Spy game. Behind the scenes there are database objects which define fragments of business and people names, as well as business and room types, occupations, histories, etc. The room layouts are constructed by the same method (refined) from the main game demo; I've also put some time into designing a system of generated air-conditioning ducts between each floor (not implemented in this demo).