Noise Hunters | Pablo Gomez Platon

Overview

Noise Hunters is an experimental third-person action game where the player takes control of Mevye, a lone spy infiltrating a secret underground base shrouded in darkness. To navigate it, Mevye must rely on sound waves to visualize her surroundings.

But she’s not alone... The complex is filled with sound-sensitive enemies lurking in the dark, waiting and guarding something.

Game Programmer / Designer

Sept 2019 – Jun 2020

4

+75k downloads

Mostly Positive reviews

Unity

Steam

Introduction

Noise Hunters was an experimental final-year degree project developed during my time at U-tad. The project was created by a team of 4 students using Unity 2019.2.5f1. In addition to co-designing the game, I took full responsibility for the programming side, as I was the team member with the most experience coding in C#. I single-handedly implemented all core systems, including:

Gameplay systems (character controller, animations, combat mechanics, etc...)
Enemy AI, built using a Finite State Machine (FSM) architecture
Interactable elements (buttons, doors, collectibles, and other world interactions)
Game managers (player state handling, level objectives, and overall game flow)
HUD and UI menus
Pre-rendered cutscenes integration
Game settings, including audio options, language selection, and a save system
Achievements, implemented via the Steamworks.NET C# library

Before starting this project, I realized there was a strong need to continue studying programming in my free time and during summers. I had many ideas I wanted to bring to life, but at the time I lacked the technical skills to execute them properly. Thanks to this extra effort, I reached a level that allowed me to take on larger and more complex projects, and to stand out among my peers as one of the best programmers in my class.

This project was one of the best experiences I have had as a game developer. It felt like the culmination of everything I had studied up to that point. I learned an enormous amount from it and discovered new ways to keep improving, both technically and creatively. And we surpassed +75,000 downloads and gathered enough user reviews to achieve a Mostly Positive rating on Steam!

There is a lot more I could talk about this game, but I will only share what I think is the most important highlights.

The sound waves emitted in the world are mainly composed of two core elements:

A camera shader that takes a world position, a maximum radius, a total lifetime until it fully expires, and the wave’s visual style, including emitted color and optional additional textures.
A GameObject that contains all the sound logic, using a trigger to detect every entity that produces sound and only alerting those that have a SoundListener component.

There are three types of sound waves in the game: a standard one used for detecting the player or other entities, one that silences up to 95% of all sound generators within its area, and one that tracks the player regardless of whether they are moving or producing sound.

Sound Detection

Given the large number of different sound generators, I created a general static script responsible for building sound waves from a ScriptableObject. This asset contains all relevant data, such as the audio to be played, the wave type, and references to the instigator, allowing the system to remain centralized, flexible, and easy to extend.

Code Snippet: Sound "Factory"

By design, the character is not able to defend or attack enemies directly. However, they can instantly kill enemies from behind, or throw a special electric dagger that stuns enemies and creates a short window to assassinate them quickly. If the player is outnumbered, the dagger can also be thrown at a nearby surface to distract enemies instead, although that will only work if the player doesn't get tracked by the red scanner.

The character automatically locks onto enemies when both the reticle and the player are close to a target. Once thrown, the dagger can be recalled to the player's hand by pressing the throw input again, but it has a cooldown to prevent abusing this mechanic.

As a minor but important detail, Mevye's armor begins to flicker and glow more intensely when enemies are nearby, warning the player and making encounters feel more tense and suspenseful.

Assassin Combat

Finite State Machines and AI sensors

Enemies follow a typical stealth game behavior: they patrol, investigate sounds, and chase and attack a target once it is detected. To support this, I implemented a Finite State Machine (FSM) dedicated primarily to enemy AI. The system is built around modular actions that transition from one to another based on clearly defined conditions, which made it easy to tweak or modify enemy behavior without rewriting core logic.

Additionally, as in most games, enemies have distinct behaviors that set them apart. In this project, those differences come from their sensors or senses. Since it was unclear how many enemy types might be added over time, the system was designed to be fully modular, with sensors invoking events and the enemy's brain processing those signals to decide how to react.

Level Objectives

Objectives are generated by a mission manager and are composed of intermediate goals, which are essentially the tasks the player must complete. These can range from eliminating enemies, traveling to a specific location, collecting items, or interacting with elements in the world.

These goals are displayed on the compass to guide the player, and are also communicated through on-screen text that appears as if it were being typed on a terminal. This creates a decryption-style effect, where special characters such as %, #, or @ appear briefly before resolving into the actual objective text.

What I Learned!

I learned how to handle almost every type of programming task typically involved in a single-player game. Even though the time available to implement each planned feature was limited, the project gave me valuable insight into how larger productions operate, even if my contribution represented only a small fraction of what is done in those environments. This experience significantly boosted my self-confidence and allowed me to believe that I can aim for more ambitious games in the future.
I learned how to write clean and maintainable code. By investing a large amount of my free time into learning C# and programming patterns such as SOLID, I was able to work with a flexible, readable, and scalable workflow. I achieved this through extensive use of:
- Interfaces, to manage shared behavior across multiple entities and to interact with different elements without explicit references.
- ScriptableObjects, to implement the Lightweight pattern, where shared data points to a single instance or asset.
- Events, to execute logic without tightly coupling scripts to one another.
I also learned how little I truly knew. Even though I am happy with how the game turned out, it is still unpolished and has plenty of room for improvement. The game lacks object pooling, which makes scenes with many noise generators less performant overall. It also lacks occlusion culling or any system to manage off-screen objects, as well as several much-needed quality-of-life improvements and additional polish.
I learned the full process of releasing a game on Steam. I handled every aspect related to meeting Steam's guidelines and requirements for launch approval, updating the game's store page presentation, uploading builds, adding achievements, and creating community posts.

I will always remember this project. Carrying the responsibility of programming an entire game on my own was extremely demanding, but I do not regret it at all. I learned an incredible amount, and I truly enjoyed working on a game that feels very different from what is usually seen in the industry. Despite its flaws, I am proud of having delivered the best result I could with the knowledge and experience I had at the time.