Built from the ground up, my engine is backboned by a Scope and Datum system, a hierarchical key-value store (Scope) paired with a versatile data container (Datum). Datum and Scope are extremely light weight a provide a great foundation for creating the concept of game objects.

The engine used Json as the content facing driver. That means content creators are able to create games purely with json due to the engines deserialization process.

Under the hood, this engine employs modern software-engineering practices: a single global singleton for service registration; templated interfaces for type-safe service retrieval; macro-driven binding; lazy initialization with caching; and a fully decoupled architecture.

Crimson Knight drops you into a looping realm ruled by The Absolute, a goddess who forces you to relive your own brutal past. You wield a heavy, blood-soaked greatsword—absorbing enemy life to fuel special attacks—while mastering dodge-rolls, parries and stamina management. Each death reshapes the arena and teases out fragments of who you once were.

Crimson Knight is in development at Squinky Studios. I led the implementation of Unreal’s Gameplay Ability System—designing core abilities, building custom calculation classes, and fine-tuning every skill to feel responsive and impactful. This project has taught me GAS from the ground up.

I also built our in-game debug menu and hooked all GAS effects into custom calculators with SetByCaller parameters tied to DataTables, so designers can tweak ability values directly without touching the effect blueprints.

This early graduate project involved developing a procedurally generated tile-based world using OpenGL and C. The tilemap engine calculated walkable surfaces, rendering randomized tiles at runtime. Players explored vast dynamic maps while managing real-time navigation, showcasing early work in spatial logic and grid-based systems.

Implemented A* pathfinding to govern enemy behavior, using a grid-based evaluation to select optimal paths. Debug lines visualized search trees and final routes, providing tangible insight into algorithm efficiency. Directional animation states responded dynamically to path outputs, supporting an 8-direction locomotion system through ENUM-controlled animation playback.

Designed a randomized power-up system rewarding exploration and enemy defeat. Drops applied gameplay-modifying buffs directly to player attributes, emphasizing strategic collection. Although full loot systems weren't completed, modular pickup effects and timed buffs created a compelling sense of progression leading up to a climactic boss encounter with Diablo.

Developed an object-oriented C framework that tracked thousands of game entities using a custom object manager. This architecture abstracted drawing, updating, and deletion into a virtual table design, allowing reusable logic across players, enemies, projectiles, and tiles. Centralized update loops maintained performance across large-scale enemy swarms.

Built a frame-based animation system supporting 8-directional movement and attacks using texture atlases. States were enumerated and mapped to specific sprite coordinates, dynamically switching based on direction vectors. Implemented non-looping animations for deaths and special effects, enhancing visual feedback and player immersion.

Entity System and Memory Efficiency: Entities are stored in a contiguous memory block and indexed using address registers for fast iteration, minimizing instruction count per frame. The EntityManager leverages direct address manipulation and register reuse to optimize CPU cycles during update and draw phases.

Input Handling Through Bitmasking: Player input is decoded via bitmask operations on controller state registers, allowing for extremely fast checks and compact logic. Inputs are then passed to the InputHandler through specific data register conventions, avoiding stack operations and keeping input latency low.

Optimized Rendering with Direct VRAM Access: The game’s rendering system writes directly to screen memory using calculated offsets in address registers. Primitive drawing functions, like rectangles and bitmap blits, use tight loops with precomputed deltas to avoid costly multiplications, conserving clock cycles on the 68k.

Game State Transitions via Vector Tables: Game states (e.g., title, gameplay, pause) are managed using a jump table stored in memory, allowing fast O(1) dispatch with a simple jmp through an offset. This design avoids long conditional chains and keeps control flow clean and efficient in raw assembly.

Collision and Movement with Fixed-Point Math: To support smooth motion without floating-point overhead, entity movement and physics use fixed-point arithmetic with shifted integers. Collision routines rely on branch-free AABB checks using cmp and bhi instructions, ensuring consistency at minimal instruction cost.

High Concept: Project DeathDealer is a Vampire Survivor game (wave horde survival game) featuring static and unique rifts (difficult areas) and boss fights. Unlike most horde games where bosses spawn at random intervals, DeathDealer includes difficult bosses to aspire and kill faster each run.

Leveling: In Project DeathDealer, players switch between selecting spells and passives when they level up. Players can have unlimited spells to choose from when leveling up but are incentivized to select the same spell multiple times to increase its base damage. Levels 2, 5, 10, 20, 30, 40, and 50 are for picking spells, while every other level grants a passive bonus to the character.

Gameplay: You start the game in the middle of a giant map. Your character begins with a basic attack that you can use with your mouse click to gain initial experience. Spells you acquire are fired automatically at a set interval (reduced by cooldown) and have interesting interactions. You must defend against waves of multiple types of enemies.

Future Prospects: I plan to implement more items in the data tables and introduce custom drop rates for certain enemy types. Additionally, I aim to add boss portals to provide pinnacle content for players to aspire to.

Solo Project: This project was undertaken to get my feet wet with Unreal Engine. Everything, except for VFX and some sprites, has been done solely by me. However, I hope to involve other talented individuals in the future.

Here is my implementation of an RRT, or a Rapidly-exploring Random Tree. This was a project undertaken during my undergrad in which I had to create an RRT from scratch (using journals talking about RRT for reference) and then visualize the process on screen. I used pygame to generate the visuals.

This was my first AI project that used hard coded nodes that referenced each other. These nodes only referenced other nodes that it could "see", which means that there is no drawn lines blocking its visibility. In retrospect, I wish I implemented a method that used collision detection. Still a reasonably fun project.

This was my first solo project. Almost all the work was done by me with a ton of help from the Web Ascender team. On this project the whole creative process was undertaken by me. I used Wordpress specifically on this project which was a nice change from actually writing all base HTML myself and it exposed me to the quick workflow it provides.