Passion for Videogames
I love the fact that games connect with people, and I am always excited to work on new projects to achieve that goal, whether it be in programming or design.
Low Batt
Top-Down Shooter game in Unreal Engine 5 as Degree Final Project.
Low Batt
08/2023 - 07/2024
Unreal Engine 5
Low Batt is a Top-Down Shooter game made in Unreal 5 by a multidisciplinary team formed by 2 game designers, 8 artist, and 7 programmers.
What I did
- Player Weapon
- Mines & Explosives
- Normal & rotating buttons with cable spline
- Bridges, doors, elevators & traffic lights
- Laser trap
- Simple Checkpoints & level transitions
Features
My first task was to start implementing the various player weapons (now there are fewer), but as the project progressed, I worked on other necessary systems, such as interactables (hittable and activatable objects). Like all my colleagues, I also helped fix bugs that arose elsewhere during development, and helped finalize the menus towards the end of development.
Things learned
In this game, I have been able to get as close as possible to the video game industry, working collaboratively with designers, artists, and producers, discussing and helping to implement their ideas. Although I had previously worked with other programmers, I had never been part of a team of this size, where I had to deal with different programmers working on parts of my code and vice versa. Along the way, I have learned to work better with Unreal, understand its features, and how to address them.
Player's Weapons
The player's gun was intended to have different types of bullets that would change with certain modifications, but in the end, these were discarded and others were added instead. However, the structure remains the same, allowing new functionalities to be added easily. To manage its different bullets, UActorComponents have been created for each characteristic, ensuring that they are portable to other actors.
Currently, the gun and the player have:
Basic Shoot
Mine
Atomic Explosion
Basic Shoot
Since it's just a single gun, it manages a pool of bullets that are generated at the start, and all possible systems they might have, such as collisions, mesh, ticks, etc., are deactivated. When the player triggers the gun to fire a bullet, it simply follows an iterator that calls the bullet's activation method, activating everything necessary and putting it in motion. Once the bullet collides with something or after a certain number of seconds, it returns to the pool, deactivating completely.
To ensure that the shots and effects come from the desired location, I have placed a socket on the barrel of the gun to use as a reference when firing bullets or creating muzzle flashes.
Like in Low Batt, everything is activated with shots, and the bullet has two types of collisions:
- A large one for enemies and activatables.
- A small one for environmental elements.
Feedback
To add more feedback while shooting, some things have been implemented:
Animation
Muzzle Flash
Movement electricity
Decals
Explosive Things
Having two elements that caused radial damage, I decided to create a UActorComponent that would be URadialDamage. This component would handle
everything related to the damage to be applied to an area, and you would only need to pass the area of effect to it. Additionally, it would
also take care of the particles and the detection of other explosive elements to make them explode.I tried to use the radial damage feature
in Unreal from the FDamage class, but since it wasn't working as expected, I created a custom class to implement that damage.
When an element explodes, it will overlap with all the elements that have the explosive tag, and then categorize them by their collision channel.
- Enemies that will receive damage.
- Elements that will explode.
Mine
The mine is a limited object that the player can deploy when they obtain ammunition. The mine arms itself when it touches the ground, and from that moment, it scans within its activation area. When an enemy enters it, the scanning will speed up to indicate the imminent detonation.
Deploy Mine
Scanning
Activate & Detonate
Activate Other Mines
I had to create both the expanding circle and the blinking material myself. For the blinking light, it involved creating a material with a parameterizable timer. For the expanding circles, a Torus from Unreal was created, and all parts were removed to leave only the outer circle. For the inner area, a simple Unreal disk was created.
With those elements, it was only necessary to parameterize the mesh in the Niagara system and modify it through code.
Atomic Explosion
The atomic explosion shares many similarities with a mine, but it differs in its activation method and response.
When the player kills an enemy, it drops an yellow energy orb that moves toward the player. Once the ability bar is filled, the player can use the atomic explosion, but when you use it there will be a cooldown before you can gain more energy.
The player needs to hold down the ability button and surpass a yellow circle to detonate it. The explosion will continue to expand until it reaches a red circle, which is the maximum range. Once the player releases the button, the explosion occurs. However, if the yellow circle is not surpassed, the explosion will be canceled.
The area of effect for this weapon is always visible. While with the mine we only see the activation radius, the nuclear explosion shows the effect radius, which increases as the circle expands. If the mine explosion encounters obstacles like walls or boxes, it won't affect objects behind them. However, the nuclear explosion can pass through elements marked as "cover".
Not energy
Getting energy
Cancel explosion
Charging Ability
Explosion
Energy Cooldown
Activate Other Explosive Objects
Uncovered and Covered Scenario
Laser
The laser is a trap that forces the player to move more carefully through the environment, having to evade it to avoid taking damage.
In the editor, the laser is inactive. When activated, it casts a raycast forward and activates the Niagara particle, having a decal at the end of the hit.
When the player collides with the laser, they take a certain amount of damage and are pushed in the opposite direction, Additionally, a red spark will appear.
This trap will only affect the player; no enemies will be affected by the laser.
Interactables
Different elements that will help or block our way. These actors are separated by two UInterface.
Hittables
- Normal Buttons
- Rotating Buttons
- Bridges
- Doors
- Elevators
- Traffic Lights
Buttons & Cables
Although there are two different buttons, they have the same functions: activating elements in the scene.
The class has a TArray with all the actors that need to be activated. Once we press the button, we check if this button is active. If it is,
we iterate through the array to activate their respective systems.
The button will be in standby mode until activated, with a flashing red light, and the same applies to the cable associated with the button.
The cable is a Spline that was already created in BP, so to reuse the existing work, I reparented it with a class I had created to
implement functionalities through code.
In addition to the light change, the rotating buttons will receive an impulse to rotate their structure until all the force is lost.
The trapdoors are always linked to a rotary button. To make their use more believable and organic, there is a variable that you can set to
true. If you do this, the button linked to a trap will take the reactivation time of the trapdoor to reactivate at the same time.
No matter how much we shoot at it, it cannot be used again until the trapdoor closes.
The buttons are parameterized to:
Activate once
Activate as many times as you want
Activate other buttons
Movable Platforms
I needed to create an actor that could move around the scene but could take many forms, so I created the Movable Platform class to unify all its forms into a generic one, as the functionality would be the same: moving from point A to point B.
The actor has a TArray with all the possible locations it needs to go to, although in Low Batt, only two are used. When activated, a movement is generated between its current point and the next point in the list. When there are no more points in the list, it loops back to the beginning. To add these points, I use empty actors that can be generated through an editor tool I created.
The movement is made possible by a library from Tween.
Using a reference graph, we can choose how we want the movement to be executed, adding specific animations to the different platforms.
The mathematical formula is also provided, allowing us to understand how it works and replicate it outside the library.
To add a bit more feedback, when the platform reaches its destination, sparks are emitted, simulating a collision.
Let's see how these platforms look in motion:
Door
Bridge
Elevator
Door Frames
As I didn't know what type of entities the movable platforms would be at the time, and since it was a generic form, they weren't designed to be attached to another element. Even so, I tried to put the platform within the door frame class, but some things didn't work out, so I decided to keep it separate.
The door frames have only two states: closed and open. To differentiate between these two states, the frames have both an emissive light and a spotlight pointing towards the ground. And as with all the elements I've created, these colors are customizable in the BP.
Traffic Lights
At certain times, we will need to activate more than one button to open a door. For this, we will have a traffic light as visual support, indicating how many remaining buttons need to be activated.
The traffic light is just another activatable element, but to activate the final element, it must validate all the lights. The traffic light is designed to have as many lights as you want, and the lights will turn on in order as you activate them. Once you activate the last light, you will activate the desired platform.
Simple Checkpoints
At the beginning, it was just a fall checkpoint, but once that was implemented, we realized we didn't have death checkpoints. So, when I moved on to another task, a teammate took the base I created and added everything related to the player's death.
The checkpoints consist of two BP triggers: one to delimit the fall zone and another to obtain the next checkpoint.
The fall BP only needs to be linked to the empty actors that will serve as the locations of the checkpoints. The checkpoint BP only needs
the fall BP to link to it, so each time you pass through one, it increments the current checkpoint iterator by one.
In the event you fall through a gap, you'll be teleported to the current checkpoint, and in my teammates' update with death, the level's
state will revert to the state before the conflict zone.
Level Transitions
Until nearly the end of development, there were no transitions between levels; you couldn't organically move from one to the other. So, taking advantage of the fade in/out effect a teammate created for entering the game, I was asked to make those transitions.
The class will just be a trigger volume to detect the player. When detected, it will start the fade in, and upon completion, teleport the
player to the next zone, initiating the fade out while simultaneously activating the pertinent platform (usually an elevator).
For map changes, a boolean will need to be activated to indicate this. The only procedural change will be that at the end of the fade in, it
will switch maps, calling the transition scene.
Things to improve
Now, there are different things I would change or rather improve from the start. The system for connecting points with movable platforms was not very designer-friendly, and although I created a tool to improve this task towards the end of development, it was too late to be useful.
From the beginning, I tried to structure the code and variables well so that it would be more readable. In a way, it is like that, but I would have liked to have worked more on this aspect to follow best practices more closely.
Overall, I am happy with the work done and everything I learned in the project. I know I could do much better now, applying this knowledge to future projects.