Final Bounty is a sci-fi themed roguelike bullet hell game featuring procedurally generated levels, permadeath, and an exciting lineup of foes to exterminate. The player is a bounty hunter on the cusp of retirement who sets out on one last mission to secure their legacy. Traveling from planet to planet, they must vanquish enemies and collect supplies while they get ever closer to achieving their goal. Between planets, the player can purchase upgrades at the shopkeeper’s space station and choose their next battle. After conquering three solar systems, the only thing that stands between the player and collecting their final bounty is an exhilarating boss fight.
The game was developed using Unity by a team of six programmers and one musician. My primary contributions included designing, developing, and implementing the behavior of multiple AI agents and seamlessly integrating them into the game to provide the player with dynamic and engaging battles.
Trailer
Features at a Glance:
AI Agents
The AI system in Final Bounty is built around a modular architecture which utilizes a virtual Enemy class as the base for all agents. Each unique enemy class inherits the class’s logic and overrides key attributes such as weapon type, kill value, health, and damage enabling easy customization and scalability. The weapon type is based on a shared abstract GunType class, which is also utilized by the player. This ensures weapon mechanics are consistent between the player and AI while also streamlines weapon implementation.
All enemy types utilize a unified, custom A* pathfinding implementation that allows for navigation across the spherical surfaces of the planets. When an enemy spots the player, however, its own unique reaction takes over, creating varied and engaging gameplay experience. AI agents also utilize finite state machines which are optimized for efficiency, allowing for hundreds of agents to be active at once.
Drone
Drones are the basic enemy type. A single drone is no problem, but when attacking the player in numbers they creates an impressive volley of shots for the player to dodge.
Ram
Rams are a specialty enemy type that will set a self-destructing charge and attempt to ram into the player once spotted. On their own Ram ships are trivial to dodge, but when combined with the other ship types they present an unanticipated challenge.
Missile Cruiser
Missile Cruisers are large, slow, but powerful ships that fire volleys of missiles at the player.
Collisions
The player ship is heavily armored and well made when compared to the mass produced enemy ships. Due to this, any enemy ships that collide with the player are instantly destroyed and deal damage to the player ship.
Data Driven Spawning
Each level has a set number of rooms, each hosting unique combinations of AI agents to fight. The specific combination of enemies for any given room, or planet, are defined in a JSON file, which includes:
- The level where a specific room can spawn.
- The specific type of enemy or enemies that can spawn in a specific room.
- The probability of each enemy type spawning at a given node in the room.
The planet bodies themselves are completely random and are determined by the specific level seed, but the combination of enemies that can spawn on the planets are carefully controlled. This data-driven spawning system provides scalability and the ability to easily modify values in the spawning system, making it incredibly simple to tweak difficulty and make additions across levels.
Pathfinding on a Sphere
AI Agents utilize a custom A* algorithm to navigate across the planet. The motivation for using A* over a simpler system, such as agent vision combined with random wandering, was to allow for complex environmental hazards to affect regions of certain planets. While the navigation system was fully implemented to support these hazards, they were ultimately cut from the game due to time constraints. To keep paths interesting and still utilize some of this feature, nodes in the graphs were given random weights that are utilized in the A* algorithm.
One of the main challenges of adapting the A* algorithm to work on spherical surfaces was designing a grid-based system of nodes for it to utilize. The team opted to use a quad sphere for this implementation. A quad sphere consists of 6 planes connected like cube but “blown up” to be a sphere.
Generating a quad sphere involves creating an array of vertices to define the mesh, which are grouped into quads. These vertices are then grouped into quads which act as nodes for the A* system.
Traditionally, A* navigation operates on a flat, 2D grid with strictly defined borders. Because of this, adapting A* for a 3D sphere required some adjustments. For each quad generated from the vertex array, its neighbors are detected by determining quads that share edges with each other. Due to the nature of a sphere, there will not be a single quad which borders an “out of bounds” region like there would be on a 2D plane. Therefore, quads which would normally border an “out of bounds” region on a plane are cyclically connected to quads on the opposite side in the spherical implementation. This creates a seamless node graph which allows for the A* algorithm to function as normal and find paths on the spherical surface.
Integration with Core Systems
To bring everything together seamlessly, AI agents were designed to integrate with several of the core systems already used by the player’s ship. This approach simplifies development and allows for consistency across all mechanics, creating a cohesive gameplay experience.
-
Planet Generation System: The A* system used for AI navigation directly integrates with the planet generation system. This integration, which is described in the above section, provides a graph of nodes that allow the AI agents to navigate across the spherical planets.
-
Gravity System: AI ships and the player ship share the same gravity class, ensuring consistency between the was they orbit planets. This ensures that when an AI ship moves forward, they remain bounded to the planet in the same way the player would be and are prevented from floating off into space.
-
Weapons System: AI agents and the player utilize the same weapons framework, creating parity between the player’s attacks and the AI’s attacks. By sharing this system, enemy attacks are balanced and have the same mechanics as the player’s attacks. It also allows AI agents to re-use weapons designed for the player, such as missiles and lasers.