Bugs N’ Guns | Pablo Gomez Platon

Overview

Bugs N' Guns is a third-person co-op shooter videogame where players take on the role of interplanetary garbage disposers tasked with escorting a train full of trash through a hostile alien environment. Players use special elemental weapons to fight against a mysterious race of bugs and must work together to unlock the full potential of the elements and safely deliver the trash to a garbage disposal unit.

Gameplay Programmer

Jan – Nov 2023

BIG Conference:

Best Students Game 2023

Unreal Engine

C++

Steam

Introduction

This is my first complete project done in Unreal Engine, developed with a group of awesome people at U-tad. I was in charge of developing the player's Character Controller and Gunplay using Unreal's Gameplay Ability System (GAS), tracking player state information using Unreal's Gameplay Framework, and some UI work, specifically on the HUD.

I also did quite a bit of mediating for many of the development issues. Whenever the team got stuck with creative or technical decisions, I was always there to intervene and propose a solution that benefited everyone. The most decisive call I made was intervening in a serious problem of creative differences early in the project and I ended up suggesting a unified idea of what everyone wanted. The result was what Bugs N' Guns ended up being.

We were a team of 6 programmers, 7 designers, and 5 artists, and we got the award for best student game at the BIG Conference 2023! (Unfortunately, I couldn't be present for the awards ceremony, but I leave here a picture of my team collecting the trophy).

Gameplay Ability System (GAS)

GAS, in short, is a framework based on Abilities (decoupled gameplay mechanics), Effects (which can apply buffs, debuffs, special states...), Attributes (all the important values such as health, energy, defense, damage...), and GameplayTags (flags basically). Obviously it has a lot more functionality than what I just mentioned and it is something complex that took us a long time to learn, but that allowed us to implement several behaviors in a “simple” way.

Using this system, I took care of implementing simple mechanics like jumping, double jumping, and sprinting, the “blinkshot" ability and weapon management (shooting modes, overheat state, weapon switching...).

I was in charge of how the weapons worked, while one of the programmers developed the elemental projectiles and their interactions between elements and enemies. The weapons, in a nutshell, work like this:

With each shot, the weapon receives a heat charge.
If there is a pause between shots, the weapon begins to cool.
If it reaches a maximum heat value, the weapon goes into an overheated state and takes longer to cool down.

I prepared a basic diagram laying out everything needed and developed the functional mechanics of the guns in less than a week. Also, because the initial idea was to represent overheating diegetically, I implemented events so that the rest of the team could handle any overheating state as they wished. In the end, the most we did was triggering smoke particles whenever the weapon overheated.

What took the most time was migrating all the functionality to the GAS and Gameplay Tags system, and managing weapon data through a PlayerState.

We wanted to implement 4 types of firing modes: Automatic, Semi-Auto, Burst Firing, and Charged Shot (by holding the Shoot input). I made a base ability named UGA_Shoot which handled everything from actually shooting projectiles and recoil, to handling multiplayer prediction windows. Then, through inheritance, I easily created the behaviours for those firing modes by overriding the Shoot function with a few lines.

Heat-Based Weapons

Our inspiration for the weapons was a combination of the Covenant weapons from Halo (weapons that can overheat if used without pausing) and player interactions like It Takes Two (specifically a section where one player can pour honey, and the other can shoot fire arrows).

Code Snippet: Semi-Automatic Shoot Ability

Also, I needed to manage the recoil of the guns. While we didn't want to have horizontal recoil, we did want to have camera shakes for the weapons and, when finished firing, the camera to return to the origin point from where it started firing. I had to deal with a few cases like manually interrupting the return to the original point if a significant input was introduced, or how to make it return smoothly if the player counteracted the recoil.

Handling the Camera

To maintain a better angle of view in third person, we wanted certain camera and springarm values (e.g. springarm length, FOV...) to be modified according to the player's state. It occurred to me that I could use DataAssets to pass the information of the new camera values along with the transition times between the current and new values. All this information is stored in an actor component named UBLSPlayerCameraHandler, and it's Tick function would be enabled whenever a new Camera State is set and disabled when it fully transitioned from one state to the other.

Code Snippet: Recoil Decay

What I Learned!

I learned quite a lot about C++ and how Unreal Engine works internally. Learning about memory management, raw / smart pointers, macros... made me realize that I still had a lot more to learn. It's complex, and often times confusing, but I understand how everything works internally and how C# handles background processes (like automatically freeing unused memory through Garbage Collection).
I learned Unreal's Gameplay Ability System, which gave me a great general idea of how these systems are used in general. By decoupling behaviours to "ability containers", it allows developers to easily create and expand a character's action pool, and handle states through effects / cooldowns. Not to mention the modularity it brings by allowing other characters or NPCs use the same abilities granted to the player.
I learned how multiplayer games are handled. Though, I would like to learn more and try to do another multiplayer project in the future. Our time to properly research Unreal Engine's multiplayer system was rather short, so we lacked the knowledge to implement some complicated features and to further optimize the game's replication of events.
I learned how to more effectively manage and lead a large team and the programming team to implement meaningful and beneficial changes. I've never worked with so many people at the same time; not even at Sync Games! Sharing my own experience with the team, discussing the next steps forward, and learning and observing the growing talent in our group humbled me in so many ways. Wherever they are now, I hope the best for them!

It was quite a fun project with an excellent team full of passion and ambition (perhaps too ambitious). Although I had some grievances about the final product (polish, bugs, optimizations...), in the end, it all worked well and we made something that succeded our expectations!

Pablo Gómez Platón