Game AI Developer in Oakville, ON, Canada

Wild Shape is a student capstone project made in 12 weeks by a team of three designers, two programmers, and two artists.

Features
Use natural powers to solve puzzles and evade enemies. Interact with NPC characters living in Wild Shape. Find collectibles throughout the world of Wild Shape. Switch between forms to traverse obstacles. Explore the world of Wild Shape.

Responsibilities
Organized remote development by leading daily scrums and weekly sprints as the project manager. Created agile tasks for programming and assigned them to the programming team members. Developed Melee and Ranged Enemy Behavior Trees with a complex detection system, different attacking functions, pathfinding, and occlusion detection. Programmed Guide NPC Finite State Machines with multiple states and dialogue options. Created shaders for special effects on player characters, interactable objects, and the environment. Developed and unit tested all mechanics of both player characters. Common mechanics included shapeshift, walk, run, and look. Shape-specific mechanics included hide, crawl, teleport for the raccoon shape, and push and freeze for the bear shape. Implemented custom input binding using the Unity new input system.

This project was completed as a mini-capstone for a post-graduate game programming course. The game had three different perspectives: namely, Hololens World Space AR, Apple iPhone X iOS 2D Third Person Top Down, and PC PlayStation Controller First Person.

The project was completed with the help of one other developer who was responsible for development of iPhone X 2D logic, PC Camera controls, and initial setup of the enemy AI.

Responsibilities included:
- Enemy AI using FSM
- Bot AI using behavior tree
- Hololens AR UI
- Hololens input and device setup
- Overall integration and lifecycle
- Project management and version control merging

Tower of God is a match-3 game with story elements. It has multiple mini-games to keep the gameplay refreshing and continuously changing. The game was developed during my employment with Ironcode Gaming.

Features
Pick up and play, 100 levels of fun match-making, fun mini-games included. New types of runes and tiles, climb the tower of God!

Responsibilities
Optimized existing instantiation logic for match-3 runes by implementing object pooling. Developed independent mini-games that can be plugged into other games. Implemented a jigsaw puzzle mini-game that allows a player to solve the puzzle for an image—created a memory card mini-game that enables the player to discover pairs of face-down cards with the same sprites. Developed a move slider game where the player needs to remove obstacles and move the main slider to the other edge. Added mini-games to the level editor to ensure the final level JSON has mini-game levels as well. Implemented dynamic tower generation so that the tower of God is different for each player.

Rough Waters was completed in a 48-hour game jam. The game had a simple switch and row mechanics as you controlled three rafts through a treacherous river. Play solo or co-op and try to get all three rafts to the end together.

Features
Single-player and two-player games. Swap between rafts when raft energy gets drained. Protect rafts from treacherous objects. Created moving NPCs and collectibles scattered through the level.

Responsibilities
Tested and integrated controlling raft through running water that is already exerting some force to the rafts. Developed physics jointed chains that interconnected the rafts and could be extended and reduced by the player. Made functional 2D AI steering behavior for crocodile hazards in the game. Implemented blocking objects that damaged specific rafts, such as drainpipes and line barriers. Added obstacles that damaged players and collectibles that either gave extra scores or were multipliers for the score.

A 2D game engine that uses SFML and Box2D underneath. It can be used to make simple games. The engine was developed by the entire class of GDAP 2019 at Sheridan College. The engine had a render and collision system and a GameObject, file, input, and asset manager.

I designed and developed a collision system with one other developer. The collision system tried to mimic the Unity physics system by providing virtual functions that each component can override. These functions include trigger and collision functions for enter, stay, and exit events. The collision system only checked collisions if there was a rigid body involved. Box2D shapes and a static, rigid body was used to implement this. I developed the rigid body component and the collision system. The collision system checks through colliders of each rigid body against all the colliders in the world. If there is a collision, it caches it and sends the enter event. It calls stay for all cached events if they are still in collision and exit if they are no longer in collision. Collision events are sent before the render system update to allow for collision handling.

Created a Gauntlet 2D game replica with three enemies and spawn factories. The game used JSON to generate levels and C++ as a programming language. This game leveraged the 2D game engine, but the rest of the game was worked on individually.

I created a Unity editor window for the game architecture's Gauntlet 2D game, which leveraged Unity's IMGUI system as well as UI elements, including UXML and USS. The tool allowed the designer to create levels for the gauntlet game and different entities and pickables that would reside in the game. The tile map editor was a visual editor where you can place objects on a grid-based layout. The game exported all game data to JSON and stored all entities as scriptable objects internally.

Created a C# WinForm tool for the game architecture's text-based adventure game.

The tool comprised all the entities of the game and a way to load and save previously set game data in JSON format. I also created an analytics tool for the same game to visualize the actions in a visual graph. I built a text- ased adventure game similar to Zork using JSON as game data and C++ as the programming language. The game understood basic sentence combinations and using function pointers, called the appropriate action functions.

A server-based multi-player casino game comprising of games such as Ludo, Teen Patti, and Poker needed another game mode, i.e., card exchange mode.

I developed the entire mode, including the server and client-side code. The card exchange game uses the Monte Carlo algorithm to determine the probability of winning each hand according to the round of the respective poker or Teen Patti game. There can be either two or four hands in the game. Each hand is dealt cards from a shuffled deck of cards and increased as rounds progress. Each round is on a timer and the players are allowed to bet on each hand's win or loss condition. Based on the probability of that hand winning, the player will either win or lose the bet money.

The entire game was calculated on the server-side with results sent to the client. The game also exposed callbacks that could be registered by third-party applications to get the current round's values. New games start constantly so players can join in at any time. The game was developed under the employment of Ironcode Gaming for a client.

Enhanced an existing game created in Legacy Unity UI and scripts to include multiple games from the same company and enable the company to sell recharge, food, shopping, and travel coupons, using the game score as currency.

Responsibilities
Transformed the legacy GUI to the Unity Canvas system and integrated UI hooks into the game. Fixed minor bugs in the legacy scripts and made a simple 2D game functional. Added tracking of player profiles and scores on the server using Nakama Server, Lua, and PHP. Integrated Google Play Games and implemented leaderboard, achievements and player count. Developed a coupon management system that allowed Just Game to add, update, or delete existing coupons in the server-side database and automatically refresh the feed of available coupons on the client, i.e., player. Added a way to keep track of all the coupons the player purchased using the game score and prompting the user about the expiry of each of the coupons. Created and designed the UI for coupons, games, the main menu, and user login.

Built a tutorial on how to create a zombie wave shooter in Google VR and Unity3D. The outline of the topics taught in the tutorial was as follows:

*Setting up the Unity game engine and Google VR SDK for Unity.
*Unity Game Engine Basics, including common unity windows and views along with C# scripting for Unity.
*Virtual reality basics, Google VR prefabs, different XR devices, common scripts, and VR audio.
*Creating the main menu scene, serialization, persistence, 2D UI to VR scene, and initial setup of a VR scene, game objects, lighting and place objects, effects and gun control, object pooling for bullets, enemy prefabs and animation, physics implementation, NavMesh navigation for enemies, game over and scoring, sounds, game win, and final setup.
*Testing, optimization and build settings of games.
*Unity built-in profilers, player, quality, audio settings, and building games.

Corporate Espionage is a game about stealing important information from your bar clients. This is done in two steps; first, you get the clients drunk by giving them the poison of their liking. Second, eavesdrop on their conversation while they drunkenly spill the beans. Run with the secrets and become rich.

I developed the game AI, i.e., the clients. Clients were implemented using FSM, where each had multiple states. The states were idle, decision, bar, move, and wait for a server. The idle state chooses a random time to wait before going to the decision state. The decision state is responsible for deciding whether the NPC would go to the bar and call a server or go to a random table. Move will be active when the NPC is walking. The bar state is only active in level one, i.e., the bartender and the server state is only active in mode two, i.e., the server. Game over occurs in level two if an NPC keeps waiting for the server and the server doesn't come. You go to level two after all NPCs have visited bar.

In the bar state, the NPC waits at the bar for the player to attend them. If the player attends them, they drink and get inebriated, or leave. Inebriated clients take less time to show secrets to the eavesdropping server.

The game was submitted as an entry for the Global Game Jam at Sheridan College, Oakville. The theme was 'repair,' and our general idea was to make the player mend their brain traumas by joining broken pathways to the light in the game. Our team comprised of three designers and two programmers, including me.

I created all AI and the complete circle of life. One AI was a dream walking persona that wandered through waypoints on the active platform. The waypoints were randomly selected from a pre-placed list. No waypoint was repeated; therefore, the persona starts moving to the edge when the end of the list is reached. The player has to stop the person AI from falling off. If the player places another platform on time, the waypoint list would automatically be populated with the waypoints on the new connecting platform. Players have to left-click to lift and join and right-click to rotate the platform.

Other NPCs were the nightmares. The nightmares would start marching towards the persona. The player has to steer the persona away from them. The goal of the game is to create a path to the light.

I also made the circle of life for this game, i.e., win, loss, death, game over, main menu, and scene transition.

Bestie Jumble is a mobile game that has two game modes, 2D and VR. In the game, the player chooses an image from their gallery and plays a jumbled puzzle either in VR or 2D.

The 2D puzzle has three orientations depending on the image resolution, portrait, landscape, or square. They will tap on the puzzle pieces they want to swap and solve the puzzle. The VR puzzle scatters cube-sized puzzle pieces in a 3D virtual world. The player has to go and find the puzzle pieces and place them on the 3D puzzle board. Once all pieces are in place, the puzzle is solved, after which they get a certificate they can store as a PNG in their phone. The game features VR UI, 2D UI, Sprite manipulation and effects, 3D particle effects, Google VR integration, VR head tracking, and ray tracing. I developed the entire game including multiple art assets.

The Adventures of Little Rebel is a mobile VR game with multiple levels that have entirely different mechanics. The game was designed and developed by me as an anniversary present for my girlfriend.

Features
It has a hidden object game where the player has to find objects that are scattered in a VR room. In the jigsaw puzzle game, the player has to correctly position cubes made of image parts to make an entire image in a VR space. In the roller coaster experience, the player experiences being in a simulated roller coaster ride. The memory room objects placement game has the player place objects in their correct place in the room. Dialogues between the player and NPC in the objects placement game Guard Dog AI has waypoints and player detection.

Each game had different mechanics and assets. I developed the game and all assets.

Developed a Unity scene setup, UI setup, and completed the programming of the hyper casual 2D mobile game.

In this game, aliens fell from a mother ship trying to invade Earth. The goal of the player is to tap on the screen to create a shield that would destroy the aliens. There were different types of aliens, and each required a different number of shields to be stopped. Players got power-ups by tapping on special earthly ships and by continuously saving the Earth from a set number of aliens. The game doesn't end until Earth gets invaded.

I built the entire game except for the conceptualizations and graphics. The level management had aliens being spawned at certain probabilities, which changed as the levels progressed. The speed of the spawning, as well as falling, was varied as the levels progressed. The game implemented Unity analytics and a collision system. Persistent data was also handled. Special effects were created using the Lean Tween Unity plugin.

The Outliver game was designed and developed by four developers, including me. In the game, the player was a scientist who created a portal to other worlds, but the portal gets destroyed on the first jump, and the player has to collect pieces of the portal to get back home.

Features
*Three levels with completely different environments.
*Base level to familiarize the story, i.e., the scientist's lab.
*Underwater level with oxygen deprivation mechanic.
*Fire world level with fire breathing dragon and fire pits.

Responsibilities
I created the circle of life and interconnected all the levels. I designed and developed the base level, developed teleportation and scene transition logic, and modeled the teleporter pieces. I created game over, scoring, underwater oxygen deprivation, fire breathing dragon fires, and the fire pit logic.

The theme for the capstone project of the nanodegree was emotion, so I decided to create an app that lets users experience fear in VR. The application had two types of entertainment media to scare players. The first entertainment media were short scary movies that can be watched inside the VR headset to provide a sensory distraction-free experience. The second was a mobile VR game where the player had to escape a maze by finding the key to the door, but there are zombies patrolling the maze, and if the zombies find the player, it's game over.

Features
*Fully functional floating UI in VR world.
*Option to select the movie that is to be played.
*Complete video-player with options to fast forward, increase decrease volume, seeking video location, time display, play, pause, and stop functionality.
*A raytracing and waypoint movement system for the player to navigate the maze.
*Unity NavMesh path finding for the zombie to find the shortest path in the maze to the player.
*Game timer implemented as the scoring and ranking mechanism on a leaderboard.
*Persistent leaderboard, score, and player level.
*Level progression and maze design.

I developed the entire project.

I developed a clicker hyper-casual 2D mobile game with another developer on the team.

In this game, you are a budding politician trying to expand your party and become the prime minister of India. You campaign for votes, one state at a time, while raising money and influence by adding party members and unlocking political activities using the same votes/cash/influence you have already gathered by campaigning. Once you have enough votes to win a state election, you unlock adjacent states. After winning state elections in all states, you get to run for prime minister. Gather enough votes to become the Prime Minister.

I was responsible for creating maximum back-end code while other team members handled much of the Unity setup. I used big integers to handle out-of-scope numbers and ensured quick and efficient calculations with minimal overhead. I created a persistent data handler, activity manager, state manager, and player statistics manager. I integrated Unity ads and made a reward ad system in the back end and added code for the automatic generation of the game currency for bot states.

Assisted on the Unity scene and UI setup and the programming portion of this hyper casual 2.5D mobile game.

In this game, police are swarming your zig-zag path and you have to stop them from filling the entire path. Each of these police are of different levels; therefore, a different number of walls need to be used to stop them. You swipe on the screen to make a wall, and the wall fades away with time. The police are colorful. If three of the same color reach the path column/row wise, you get a power-up that can be used to help you get rid of them. Special glowing police give you power-ups as well.

I developed the entire game except for the conceptualization and graphics. I worked on level management, i.e., setting up probability, randomization, speed, and other parameters for spawning police. I used Unity's 3D physics engine for collision detection and resolution and worked on special match 3 mechanisms for pathway police. I added 2D and 3D effects, including animations. The game used Facebook analytics as well as Unity analytics, as that was required by the client.

This game was a single death match where you play against a computer player. You send your army ready for deployment after a short cooldown time by tapping on the lane of your choosing. There are four lanes, and the computer will send their army in the same lanes. Lane changing is also possible with swiping but is only possible when there is no active collision between the troop and the lane beside it is empty. The troops have different levels of strength. The stronger troop chain can push the weaker troop chain back to the starting point. The goal of the game is to capture the computer's side by making your troops reach the computer.

I developed the collision system to ensure that there are fixed joints between the same player's troops, and the push starts happening as soon as opponents collide. I made a health system that tracks the troops of both sides to calculate the player's updated health. If you take your troops to the opponent, the opponent loses health. If you take an opponent's troop to the opponent, you gain health. I created the lane management mechanism and the spawning mechanism as well as the random troop selection mechanism. I also created a bot AI to mimic the playstyle of the player for the computer side.