RIT Project
Digital Game - Capture the Flag
Controls a group of school kids who are engaged in a game of capture the flag. With the use of their unique abilities and various school environments it’s your job to command your forces to capture the flag and bring it back to your base!
My Contributions:
Implement a grid based map to be leveraged through the player, enemies, and abilities
Implement players including their controls, automatic movement, and interactions
Implement core game loop with player and enemy turns, capturing the flag, and various game checks
Design ability framework to be used by players and implement specific abilities that either effect players, enemies, or the map
Design and implement enemies, their decision making, and interactions with the player and map
Implement A* from scratch to work with the grid based map for enemy and player movement
Tools Used:
Unity (C#)
The Challenge:
For this game, I was the only core gameplay developer along with being tasked to develop AI. Since we had 3 weeks to find an idea and flesh it out, ideas were constantly changing. With 3 weeks, spending too much time finding the exact design and then starting development would not give me enough time to create the game. I had to develop simultaneously to be on pace to finish in 3 weeks. Once we had the basic idea, I started off by creating many frameworks that could be leveraged and easily modified. After playtesting and further design, we would have a ton of changes. With the proper framework, I was able to quickly modify the code to meet the needs of the design team.
Game Requirements:
The Process
3 weeks to create a game from scratch with a group of 4
There must be data tracking
It must be a data-driven RPG where players control more than one character meaningfully and the characters should synergize with each other
The Implementation:
I wanted to focus on a game with grid. The setup of the grid is a crucial part that can be leveraged by the player characters, enemies, pathfinding, abilities, and so on. My goal was to make it adaptable and easy to use for my level designer. To do this I leveraged the Unity Tilemap system. This allowed the level designer to create the level sizes that they needed and this code would grab the bounds, available tiles for movement, and set a grid to be used by many other components.
Once the grid was built out, I had to develop movement for both the players and enemies. Since the movement is grid based, A* was an effective way to tackle movement. Leveraging the grid, I used the A* algorithm with Manhattan Distance to determine the best way to reach specific tiles. This system could also be used when highlighting tiles for possible spaces to move or place abilities. Just by determining the distance of the tiles from the player and the player’s range, it could easily display which tiles were available.
We wanted to implement abilities into our game and iterate on them quickly. I wanted to have a proper system that could easily be reused to create many new abilities in a short time frame. I used object oriented principles by abstracting a parent class so that child classes could easily leverage methods defined here and be forced to implement methods that needed to be custom. This consistency allowed for me to quickly create need abilities, when working in a short time frame with lots of changes, this was essentially for our team to constantly test new things.