Alikay - Games

Slipstream

2026-12-31T00:00:00+00:00

Slipstream is a top-down racing game where you control a bubble. It's momentum based, so you click to eject a small bubble from yourself and get pushed in the opposite direction with no friction, until you bounce off of a wall. Each time you shoot off a part of yourself you shrink in size, and when you run into bubbles from other people you can absorb them into yourself to grow. We're still working on this game, but it started as a submission to the Global Game Jam 2025. I've been developing this game as part of Daisy Chain Games</a> as a Programmer and UI Designer.</p>

As UI designer, one of the main challenges I've faced working on Slipstream is the need for first-class support for both Keyboard + Mouse and Controller navigation. Since our game is playable with one button (shoot) and a single analogue input (aiming), it is playable equally well on either control scheme and we are unable to allow the UI to lean towards the player using one or the other. To accomplish this, I've tended towards using flat lists and modals to display information, since they offer a good tradeoff between allowing UI elements to remain equally sized for mouse users and maintaining a single clear focus point and intuitive navigation neighbours for controller.</p>

</a>

An image of the settings menu in Slipstream, implemented as a modal with a flat list of settings categories.</p> </div> </div>

Predictably, the hardest part of developing this game has been making the online multiplayer work consistently. For the game jam version we implemented delay based networking, with the server as the sole authority and players sending inputs rather than their own position, but this introduced input lag onto all clients equal to the round trip delay, which is not ideal for a fast-paced racing game. We wanted to avoid client-authoritative networking since we did not want to deal with cheating or ship a heavy anticheat system, so we instead implemented predicted networking (rollback). This made the implementation of online features much more difficult for us, but allows clients to play with perceptually no input lag while still keeping the server as sole authority over the game state, which reduces cheating. For more information, one of my teammates wrote a more in-depth article about our networking on medium</a>.</p>

Since the true game state lives only on the server, it is often the case (by design) that the clients are not aware of critical information, such as what lap they are on or how much time has elapsed since the start of the race. This isn't a problem for gameplay since the server will still simulate it correctly, but it does pose problems for the UI which needs to be able to display this information. We've had to be careful to have the server send relevant information to the clients to keep them up to date with the current state of the game.</p>

The Distinguished Salvager

2026-02-23T00:00:00+00:00

The Distinguished Salvager is a 3D spot-the-difference game where you search a submarine for changes to it's various rooms, and use them to progress through each level. It was made in one week for the Renewal Game Jam hosted by the Games Den. I did all of the programming and some of the 3D modelling (mainly the level geometry, the fish and the submarine) and my teammate did the other 3D modelling (all the objects in rooms) as well as the audio and music.</p>

You play as a submarine inspector who has been recruited to steal an item from one of the submarines you inspect. You have unlimited time as an inspector to wander the submarine and remember the layout, and then get sent on your mission. Each floor of the submarine the guards will patrol at night, and if they find you will catch and apprehend you. However, one guard on each floor is a plant, and will instead give you the access code to a lower floor. They will indicate which room they patrol by slightly changing an object, and it is up to you to identify the room with changed objects and sleep there to progress down the floors.</p>

The game also features a memory mechanic, where you are able to hold the Tab key to view the state of the submarine as it was during inspection. This can let you verify if you're correct or not, and lasts for 2.5 seconds per level.</p>

The presentation of the game is deliberately restrictive to allow for quicker asset creation, since we only had a week to complete the game. The game runs at a resolution of 400x300, with posterized colours.</p>

The primary challenge of this game I had to solve was that there are, for each floor, three different states the player can be in (Inspecting, Remembering, and Searching). I did not want to have to create each level three times, or duplicate the level scene so I needed each level to be able to handle all three of the different states. To solve this, I added a flag to each level to specify whether it should have it's items randomized or not (more on how that works later), and created a container called the Level System. Inspection mode is a simple case, since I just have to spawn a new level with the randomization flag off for it to work properly. This works on top of the level system I already had to handle the main menu and cutscenes, so the entire Level System is treated as one "level" the same as any other, which then in turn spawns the actual game level.</p>

For searching, I actually spawn the level twice, once with randomizations and once without. Each level renders to it's own SubViewport, with the searching level layered above the memory level. To show the memory effect, I fade out the searching viewport to reveal the memory one underneath.</p>

I have the player exist outside the level so that there's always only one, and the search camera pushes it's transform to another camera in the memory level so that they're always synced. This means that the player will always respect geometry in the searching level even when remembering, which works for this game since the only dynamic collision is the doors which I designed to call to their versions in the other levels to also open at the same time, ensuring the collisions are always in sync.</p>

</a>

An example of the games hierarchy in search mode, where the level system has spawned two level instances.</p> </div> </div>

When a level loads, if it should be randomized it selects one of it's rooms as the correct one. Each room has a "randomization budget" and it will spend this budget on random elements which have their own cost until it's out of budget. This allows us to design rooms with only one obstacle that can change, or many, and to be able to control their probabilities and frequencies easily. To allow an object to be randomized, I created a RandomDifference component I can add as a child of an object which exposes an array of RandomEffect resources and a cost. The random difference will apply all RandomEffects when purchased by it's room, which are implemented by extending RandomEffect with a child class for each effect, including offsetting the object, rotating it, scaling it, and disabling/enabling it.</p>

</a>

The RandomDifference component for this window costs 25 units, and is able to enable the window cover and disable the god rays.</p> </div> </div>

For the colour posterization I wrote a shader that accepts a sampler2D uniform to be used as a colour palette, and sets it's colour to the closest matching colour found in the palette. This shader is applied to each level's SubViewport, which allows for the different types of level to have their own palette. If I wanted to use the colour palette authentically I could have set the filter mode on the palette to closest, but I opted instead to use linear filtering with more steps than there were colours in the palette to get control over how many in-between colours there are between defined colours in the palette. I found this to look better, since I have less direct control over each pixel on the screen in 3D than in 2D and the filter would sometimes pick unnatural colours for certain objects (for example, without this the water would occasionally be green since it was closer in distance than the nearest blue in the palette). The colour palettes are all from lospec</a>, specifically:</p>

Chromeostasis

2026-01-30T00:00:00+00:00

Chromeostasis is a puzzle game where parts of the world can be either hidden or revealed by shining projectors at them. The game was made in 48 hours for the 2026 Global Game Jam, which had the theme of "mask". We were inspired by this theme to make a game where you use additive and subtractive projectors to mask various parts of the terrain.</p>

We had many puzzle ideas for this game, but due to the strict time constraints we were forced to cut many of them from the game.</p>

</a>

This subtractive projector is hiding parts of the wall that it's pointed at.</p> </div> </div>

We used Godot for this project so that we could make use of it's CSG (Constructive Solid Geometry) features for the terrain features. All the terrain is made up of CSG geometry, and the projectors have a pyramid in front of them with a CSG modifier object. We set up objects in the hierarchy to parent terrain to, so that any platform that should be hidden until revealed by a projector can be a CSG object as a child of the Revealable node. All subtractive terrain in the game has to first be revealed by an additive projector, which is why some levels feature unobtainable projectors.</p>

</a>

The node hierarchy used to determine how terrain is revealed.</p> </div> </div>

Using Godot's CSGs allows us to have the collision of revealed objects change as well as the visuals when a projector is shined on it, which better matches player expectation and allows us to make puzzles involving small parts of a large object. This was used most notably for the bridge levels and the stacked projectors level, which require partially collideable terrain.</p>

Drakeonfly

2025-11-16T00:00:00+00:00

Drakeonfly was made for the Hibernation Jam 2025, put on by the University of Alberta Games Den.</p>

For this jam I wanted to try and push myself to make a rail shooter since I had a full week, and I think it paid off since this is the jam game I'm the most proud of.</p>

The central element of the game is the Level Path, which is just a Path3D node. I am able to place event objects on the path with a PathFollower3D node to control their exact position, and when the player crosses these events they trigger a signal on an event bus with a resource housing additional data for the event. I'm able to use this system for all events that happen as the player progresses through a level, such as spawning enemies, triggering radio chatter and ending the level.</p>

</a>

The level path for the first level, with the level events in the hierarchy.</p> </div> </div>

The other interesting thing about this game is that the enemy spawners spawn a swarm object instead of individual enemies, and the swarm objects in turn spawn enemies, and are responsible for their spawning positions. This allows me to reuse enemies unchanged in different pre-authored enemy formations. I didn't end up getting to put this system to much use since the game only ended up having four different patterns, but it means the game is very extensible should I ever desire to add more content in the future.</p>

Never Stop Typing

2025-04-11T00:00:00+00:00

Never Stop Typing is a game where you work for Company LTD as a word farmer. Every 5 seconds, you must submit a new word, forever, and if you go over time you'll be fired.</p>

The list of words the game uses is from this GitHub repo of English words.</a>. The game parses this list into a hashmap when starting the game, and uses the map to store whether each word has been used or not.</p>

To assign scores to the words, I use the two competing systems of world length and time spent entering words. Each letter adds a flat 50 to the score total, and the time score starts at 500 and decreases to 0 at the moment you would lose. I tested the balance for these values and found that (for my typing speed at least) they were roughly equivalent, with word length slightly overpowering time loss. This encourages the player to submit longer words, but with string punishments for waiting to think of one. I did this to enhance the frantic feeling of the game since I don't want players to be able to easily farm lower length words for large amounts of points, particularly chains of words that naturally lead into each other such as the numbers.</p>

So Long Gay Bowser

2025-02-28T00:00:00+00:00

So Long Gay Bowser is a narrative romhack for Super Mario 64, where the player has to navigate three simple platforming levels that take place in Mario's memories of time he spent with Bowser, before Bowser has to move to another country.</p>

This romhack is based on the excellent Hacker64</a> library, which is a fork of the Super Mario 64 decompilation project with a number of quality of life features added. The 3D models were added to the game using fast64</a>, a blender plugin that adds support for Mario 64 materials and exporting models to C source files used in the decompilation.</p>

</a>

A screenshot from the first level inside Blender + Fast64. On the grass patch, I've placed some blender 3D markers with object data to make them piranha plants in the game.</p> </div> </div>

This was not my first time experimenting with making a romhack for Mario 64, but it was the first full one I released and has some oddities with how it works. The bowser that you talk to throughout the game is a model-swapped Pink Bob-omb with the dialogue changed. I'm still not exactly sure why, but doing it this way made the Bowser model fail to load (even though other models did?) when selected as the actor model, so I had to model my own Bowser to replace the bob-omb. I took this opportunity to change bowser's appearance to be less menacing, so I think it was worthwhile.</p>

Merleap - The Wizard of Legend

2024-11-03T00:00:00+00:00

This was a game jam game made in 48 hours for the Games Den Quickening game jam. It's a bullet heaven game where you play as the last frog with magic, in a post-apocalypse where the world has been taken over by machines.</p>

The main technical hurdle I had for this game was that I wanted it to be able to run on the web, but this genre of game relies on a high number of entities being spawned and despawned (both the players bullets and the enemies). For that reason I chose to implement an object pool for both. Enemies are just a Godot resource specifying their stats, sprite, and spawning cost (more on that later), and projectiles are a resource specifying their damage, speed, and homing characteristics. When an object would be "despawned", I just disable it's hitbox and visuals, and mark the slot as free. When a new object needs to be spawned in its place I just set a free object's properties to the given resource, reset its position and re-enable it. That way I can skip the costly process of removing and adding nodes to the Godot node tree, as well as extra memory allocations and deallocations. An initial pool of objects is spawned at the game's start, and should the pool be filled I can spawn a new pool slot through traditional instantiation and add it to the pool for reuse. Since this setup is similar to an ECS model, I could have implemented enemy and projectile logic as a system for improved performance, although I did not do that for this jam. This game unfortunately suffers from pretty bad performance characteristics around 300 seconds in, because I made the initial enemy pool too small and it gets filled up around 300 seconds of gameplay, after which it has to resort to traditional spawning mechanics. It's also coincidentally around this point that Godot's physics starts becoming a serious bottleneck to the game's performance. In a full game project I would have fixed these issues, but I ran out of time to in the 48 hours.</p>

</a>

The projectile resource for Reflective Orb, with it's exposed data properties. Projectile objects will get passed this resource, which informs it how to behave.</p> </div> </div>

Another bug in this game is the was healing works. Currently, in the game the heal spell exists, but is only accessible after the player has enough upgrades that it is the only upgrade left in the pool, since it can never be randomly selected and only exists as a fallback. I had intended for this spell to also be in the random pool, but ran out of time to implement it. This affects the game balance since damage is effectively permanent, which also negatively harms the shield spell since it's hard to justify it since each point of health the player has can only be lost once.</p>

To handle enemy spawning, I added an enemy cost system. The enemies spawn in waves, where each wave has a certain budget it must spend on enemies which increases every wave. Waves will pick a random enemy they can afford, spawn it, and then decrease their budget by the cost of the enemy. This way waves can be randomly determined, but still follow a pre-authored difficulty curve. For example, the reason tanks do not spawn immediately is that their cost is more than the starting budget a wave has to spawn enemies. Once the wave budget is equal to the cost of a tank they may</strong> spawn with a 33% chance, but this budget may also instead be spent on other enemies. Once more rounds have passed, the tank will be much more likely to spawn.</p>

Rex Justice

2024-09-19T00:00:00+00:00

In this game you play as Rex Justice, on a mission to stop the world from ending.</p>
Unfortunately I was unable to finish everything I wanted to have included in the game before the deadline, so the intended plot is largely missing. There are also unfinished elements such as the player animations and enemy variety.</p>
The primary technical hurdle involved in making this game was achieving the intended artstyle I was aiming for, namely trying to emulate the graphical output of the Wii with a lower texture resolution. To do this, I implemented an interlacing shader which is drawn over the game. Every frame, this shader's quad is set to the contents of the previous rendered frame, and only draws either it's even or odd rows of pixels, alternating every frame. I also added a setting to the game to control the intensity of this effect since it is highly opinionated, which adjusts the alpha of the fullscreen quad.</p>

</a>
An example screenshot with the interlacing filter at max intensity, where the player is walking toward the camera. Notice how every other simulated scanline is from the frame previous.</p> </div> </div>
Like some of my other projects, I also intentionally lowered the internal resolution to 640x480 with a scale factor of 2 to make the window appropriately sized on modern displays. I opted to not</em> allow the player to configure the resolution settings, besides making the game window fullscreen. This was done to increase the speed I could develop UI for the game, since I had a limited amount of time to work on it, but also reinforces the artstyle since the game cannot be played at a modern resolution.</p>
I am particularly proud of the UI design I did for this game, since I feel it is both very easy to navigate on controller and evocative of the time period and game genre I am trying to emulate, while still being original. The player can navigate up and down to select from top level categories, which when hovered reveal the menus inside them. These can be navigated into either by pressing the confirm button or simply by navigating right, and can be exited out of similarly. This solution would not work for more complicated UI requirements, since you might eventually run out of screen space and need to scroll the UI view but for this game it was a very good fit.</p>
</a>
An example of the UI, where the player cam move left and right to navigate into submenus which appear when hovering their parent menu.</p> </div> </div>
For the game's music, I used public domain and CC0 music from the mod archive</a>, which is an incredible resource for sequenced music that I often use in my projects. This project was unique however, because I incorporated this Godot extension</a> which allows direct playback of common tracker formats instead of converting it first to a traditional audio file. This means that I was able to gain the size on disk savings from this format, which is how the game is able to be only 70MB on disk.</p>
I also used pre-rendered video wherever possible, instead of in-engine cutscenes. This sped up the development time for the game since all cutscenes just have to play a video instead of running any logic themselves. This solution also matches the intended aesthetic, since FMV cutscenes were common on the Wii. To further add to this feeling, I intentionally added some lag on the last frame of the videos, to simulate the disk loading the data. This behaviour is inspired primarily by the Xenosaga trilogy, although other games exhibited it as well.</p>

Spring Cleaning

2024-04-22T00:00:00+00:00

In Spring Cleaning you play as a literal "dust bunny" on a quest to save your burrow from an evil vacuum cleaner. You have to platform, collect dust to grow and shrink, and dash to progress through the three levels to stop the "Earthshaker"!</p>
On this game I was primarily a musician and sound effect designer, but I also implemented some features in the game myself. I created the credits sequence and implemented all the audio I made into the game myself. This worked out well for me, since I was able to implement the SFX I made in the way I had intended.</p>
I was also the level designer for the game, which presented it's own challenges. Since the player is able to be any size in a very large range, I had to design levels that were mostly compatible with any size of player. We had intended for the player to intentionally shrink and grow at parts in order to make the platforming challenges easier, so I also included some sections that were very difficult when either large or small. Some of these points ended up being problematic for players however, since I did not tutorialize that players should be thinking about their size as a mechanic that interacts with the platforming enough. This is most prominent during the wall jump segment in the boss fight, which repeatedly came up as a pain point in playtesting, despite our attempts to make it more lenient.</p>

Night Rail

2024-03-14T00:00:00+00:00

For this game jam I was a composer, and I didn't contribute heavily to the code of the project. You can listen to the song I composed here</a>. That being said, I still did add one feature of my own, being the dynamic music present in the game.</p>
Throughout the game the music will change to reflect the current state of the player. Every instrument playing in the game is actually a separate audio source playing its own channel, which lets me freely change the song's mix during gameplay. This is accomplished through two internal tracking variables, goodness</code> and energy</code>. Goodness is increased through taking good actions and avoiding bad actions, and the music will interpolate the volumes of two "good" instruments and two "bad" instruments depending on this variable. The energy variable represents the players current energy (basically their health) and is similarly used to interpolate the volumes of two high-energy and two low-energy instruments.</p>
This system worked for the game jam, but it's not without drawbacks. Namely, since each track is not any less difficult to play than a full song I pay the performance cost of essentially having 8 music tracks playing at once. It also means I pay the cost of having 8 songs on disk, and in memory during runtime, all of which are severe limitations and only work in this game since the rest of it is very light. Since I composed this song in a tracker (namely Renoise</a>), it would have been trivial to implement this instead by converting the VST instruments used into a soundbank and exporting the song as a MIDI file which used the soundbank. Had I done this, I could have saved almost all the size both on disk and in memory (it would be much smaller than even a single audio file!) and also had more freedom with regards to changing parts of the track other than volume. Outside the context of a 48-hour game jam this is the approach I would have taken, but the time did not allow for it.</p>
Pilgrimage 2024-01-21T00:00:00+00:00 Pilgrimage is a game where you play as a contract photographer exploring an island to take pictures of points of interest for clients. You are scored based on if your picture met the clients needs or not, and the game ends once you've taken all the pictures and gives you a final score. The game was made for the 2023 games den anthology game jam. This was my first game made in Godot, and I made it as a way to learn the engine after the Unity Runtime fee announcement in late 2023.</p> This is the game where I feel I first found my own personal artstyle. I had made low poly, low resolution games before (namely Generate the Day</a>) but that game's UI and presentation were substantially different to what I tend to do now. While I was working on Love Crafters</a> and Cosmurier</a> I was forced into the Nintendo DS's characteristic artstyle by technical limitations, but I found I actually enjoyed its look and have preserved it in my future games.</p> </a> A screenshot from the game.</p> </div> </div> For this game I opted not to attempt an implementation of image recognition in order to score the player's photographs, since I had limited time to complete it. Instead, each required photograph has a preset position and allowable range of angles the photo may be taken from, and a configurable falloff if the photograph is taken outside these angles. Along with this, I paid special attention to the photograph requests and environment design to ensure there was only one way to take the correct pictures, to not confuse a player why their picture didn't work despite it looking like it should have.</p> </a> An example of taking a photo where the player must be lined up with a target. Here, the tolerance for being offset from the target position and angle is very small.</p> </div> </div> This system worked well for the jam and while watching other people play I didn't witness any occurrences where a player took a photograph that didn't count. That being said, I made the system more generous than would be expected and so a bad faith player may find ways to abuse the scoring. For example, since the sharks may be approached at any angle they are configured to accept any photograph angle and are scored only by distance to the centre of the object. This means that the player can easily take a photo where the sharks are not visible at all, and still receive full points. Additionally, since the cave is close to the surface in worldspace and may also be approached in a variety of angles, it is possible to stand in the right place and take a picture from the surface that is nonetheless rewarded a high score. I believe that these trade-offs were worth it in order to finish the game in the allotted time, but If I had more time to work on it adding proper image recognition to alleviate these problems would likely be what I spend it on.</p> Cosmurier 2023-07-29T00:00:00+00:00 Cosmurier was made in 48 hours for the games den wildcard game jam.</p> The positions of objects in the game all use spherical coordinates, which get converted into Cartesian worldspace positions in the draw routine. This allows me to reason easier about game logic, like moving the packages into the planet over time since I only have to animate their radius distance inward over time. This does lead to some distortion of movement around the poles, which I ordinarily would have fixed either by rethinking the coordinate system or just restricting movement around the poles, but being a game jam I ran out of time to implement it.</p> The locations of the cities are from this database of world cities</a>. I wrote a python script to filter the dataset, primarily to find cities that have > 15 million population. The dataset also has the notion of administrative cities, and primary cities, to capture data about capital cities. I added a 2x multiplier to the population of admin cities and a 15x multiplier to primary cities, meaning capital cities are more likely to appear in the game even if they do not meet the 15 million population requirement.</p> Since this is a game built for the Nintendo DS, I used a combination of NFLib</a>, which is built on-top of libnds</a>, and NitroEngine</a>. NFLib was used for initialization and to handle all the 2D assets on the secondary screen, and the primary screen is run with NitroEngine in 3D mode. This setup was the same as the one I used for Love Crafters</a>, which was my earlier DS game. During gameplay the primary screen is the top screen, but to achieve the pre-rendered title and game over screens as well as the rotating earth on the title and game over screens, I swap the primary to be the bottom screen. To parse the assets into the Nintendo DS format, I used the script I had made for Love Crafters</a> to convert various assets into their required formats, with some changes for the new assets.</p> Since the DS only has 4MB of ram, texture size was a serious limitation. Additionally, this memory is split up into different texture banks, where each texture must only reside in one bank. Because of this, I could not make the earth's surface texture any higher resolution as it takes up a complete texture bank on its own in its current form. I could have achieved a higher resolution earth texture by splitting the model up into hemispheres or quarter spheres and texturing each one, but I did not have time to do this for the jam.</p> On my itch page</a> Cosmurier is playable in the browser. This is due to my use of the Desmond</a> project, which provides an embeddable version of the DeSmuMe</a> DS emulator.</p> Love Crafters 2023-06-01T00:00:00+00:00 Love Crafters is a game made for the Nintendo DS. It was made for the Games Den Anthology Jam, which took place over 3 months from March 2023 to May 2023.</p> I had planned for the game to feature more content, but I ran out of time near the deadline and so only was able to finish implementing one type of pet and one minigame.</p> This game was made with a combination of NFLib</a>, which is build on-top of libnds</a>, and NitroEngine</a>. NFLib was used for initialization and to handle all the 2D assets on the secondary screen, and the primary screen is run with NitroEngine in 3D mode.</p> Despite using C libraries, I opted to write this game in C++ to allow for the use of inheritance to represent game scenes. Each scene inherits from a generic scene class, which has its update and draw methods called once per frame. This was made to emulate the semantics of higher level game engines and sped up development.</p> Since these libraries require specific formats for assets, I wrote a script that I run as part of the build process that converts all the assets in the game to the required formats. This lets me place conventional assets in folders and still build the game with the specialized formats required by each library.</p> The music in the game is all from the Mod Archive</a>, which hosts a collection of music made with tracker software, with licensing information for each song. This was a required resource for this project, since the Nintendo DS has severe restrictions on playing streamed audio, bit I ended up enjoying the music collection and went on to use it in other projects in the future where it was not required.</p> Generate The Day 2022-11-07T00:00:00+00:00 Generate the Day is a game where you play as a robot, in a village where all light has gone out. Your goal is to collect all the generator parts, and bring them back to the generator to restore power to the village. This game was made for the Games Den Quicker game jam, and was made in 48 hours.</p> I chose to implement tank controls for this game since most of the time the player will be walking in a straight line, and I found it easier to just let the player hold down forward rather than alternate holding a strafe key to emulate analogue movement.</p> The way the pixel filter was achieved is that the game's viewport is a fullscreen quad low resolution render texture that the game's main camera renders to. This way, instead of downscaling the rendered image in a shader, the game is able to actually render at the low resolution internally, which speeds up rendering.</p> This game was my first attempt at making a 3D game in Unity, so the character controller is pretty underdeveloped. Gravity is only applied to the character while standing still, and is a linear movement down rather than having an acceleration, which was a quick fix to a collision problem that came up right before the submission deadline. If I had more time to work on the game this would be the main issue I try to resolve.</p> Dine & Dash 2021-11-07T00:00:00+00:00 This was one of my first games made for a game jam, and was submitted to the Games Den Quick jam in 2021. You play as a chef, but instead of a pantry you have a dungeon. You explore the procedurally generated dungeon to slay enemy monsters and collect ingredients to make into food orders for the restaurant.</p> One of the diversifiers for this jam, which I followed, was that we use art from these two asset packs by 0x72: Dungeon Pack I</a> and Dungeon Pack II</a>.</p> Bread Heist 2021-04-19T00:00:00+00:00 Bread Heist is a stealth rhythm game where you sneak into a corporation to steal their dough, and engage in DDR like dance battles with various enemies. The game was made as a capstone project for the CMPUT 250 course at the University of Alberta, as a part of the game Dev Certificate program. I made it with 5 peers, where I worked as a programmer focusing on the rhythm battles and the enemy guards.</p> The most difficult challenge making this game was the restriction of using RPG Maker, which was a course requirement. RPG maker is excellent for making RPG's, but we were straying far outside of it's expected use-case and had to struggle to make it work for us.</p> The rhythm battles are a standalone RPG maker plugin written purely in JavaScript. They interact with RPG Maker only through collecting input, and placing images on the screen. RPG Maker exposes a 100 image buffer that is intended to be used mostly for key art, but we used it to display the cascading notes, particles, and health bars for the UI. This did impose a limitation that there was a maximum number of notes on-screen that we can support. In hindsight, this system would have been easier to implement if we instead integrated an existing JavaScript library for rendering images into RPG Maker, and then made the rhythm battles with that.</p> There's No I In Rhythm 2020-11-12T00:00:00+00:00 There's No I In Rhythm was made for the Let's Jam Together game jam, hosted by the University of Alberta games den. It's a high-score based rhythm game where enemies approach from the right, and you must press the keyboard key corresponding to their lane to attack them with a character. Since the game was made in 48 hours, there is only one song which speeds up over time until you eventually miss enough enemies and lose.</p> We found partway through development that a player could perform very well in the game by constantly attacking all the lanes by button mashing instead of timing attacks to the beat of the music. To prevent just mashing the lane buttons, we implemented a system where if you attack too early in a lane and miss an enemy, the enemies nearby will rush forward and attack quicker.</p> We also implemented a system where each time the player defeats an enemy they gain some mana, and once filling the mana bar they will heal some damage taken. We implemented the system like this instead of having each enemy heal the player by a small amount since we felt that would not be noticeable to the player, whereas filling a mana bar by a large amount per enemy gave more feedback to the player.</p>