• Project Context
• My Contributions
  • 1. Modular Game Architecture
  • 2. Interactive Tutorial
• Gameplay Snapshot
• Technical Highlights
• Reflection
• Link

Project Context

Developed collaboratively as a master’s final project, the goal was to showcase advanced programming, design a modular, scalable architecture, and deliver a replayable demo ready for future features like node-based maps or asynchronous PvP.

The demo serves as a proof of concept for both strategic mechanics and modular content.

My Contributions

1. Modular Game Architecture

• Core systems built with Scriptable Objects, separating data from behavior.
• Easily add new creatures, abilities, or mechanics without touching the core code.
• Designed and implemented the attack priority system, which dynamically calculates the main target and affected targets based on multiple criteria (lane, HP, HP ratio, randomness, etc.).

2. Interactive Tutorial

• Guided players step by step through mechanics.
• Highlighted UI and actions with tooltips and optional videos.
• Built modularly to support future additions.

Gameplay Snapshot

Vorax Breakout operates in three main phases per round:

1. Preparation: Organize team, rest Vorax, place on combat grid.
2. Combat: Automated resolution of abilities, damage, and status effects.
3. Rewards: Choose new Vorax to add or replace in the team.

Technical Highlights

• Scalable, modular architecture with Scriptable Objects, separating data from behavior.
• Dynamic attack priority system: determines targets based on lane, HP, or randomness, fully supporting new abilities and Vorax types.
• Integrated, interactive tutorial for new players.
• Dynamic combat system managing multiple Vorax interactions and effects.
• UI/UX optimizations for clarity in a visually rich autobattler interface.

Reflection

Working on Vorax Breakout strengthened my skills in system architecture, data-driven design, and player onboarding.
It also showed how modular thinking and teamwork can transform a student prototype into a polished, expandable foundation.

Link

• 🕹️ Try out Vorax Breakout!

• Project Context
• C++ SFML Version
  • Key Advantages
  • Challenges
• Unity C# Version
  • Key Advantages
• Technical Challenges:
• Reflection
• Links

Project Context

The objective was to create a 2D Tower Defense game where players strategically place turrets to defend against waves of enemies. The game includes:

• Multiple tower types with unique mechanics.
• Enemy waves with varying behaviors and health.
• A gold-based economy for building and upgrading towers.
• Projectile mechanics including homing, area damage, and slowing effects.

The two implementations differ in tools and workflow:

• C++ with SFML (3–4 weeks): Everything built from scratch, including rendering, UI, object lifecycle, and game logic.
• Unity with C# (1 week): Leveraging engine features such as prefabs, Scriptable Objects, and built-in UI to recreate the game faster and more polished.

• 💻 C++ version on github

C++ SFML Version

Focused on low-level control and modularity:

• Game Architecture: Managers for rendering, objects, UI, input, and assets. Object lifecycles handled manually with std::unique_ptr.
• Data-Driven Design: Stats, properties, waves, and animations stored in JSON.
• Animation & Events: Frame-based callbacks to sync attacks with animations.
• Custom UI: HUD fully built with SFML primitives.

Key Advantages

1. Full Control: Every object and memory allocation explicit.
2. Performance: No engine overhead.
3. Flexibility: Freedom to implement mechanics exactly as intended.

Challenges

• Manual memory management required caution.
• Slower development due to coding every system.
• Complex systems demanded careful design.

• 💻 Unity version on github

Unity C# Version

The Unity version prioritized rapid development and polish:

• Scriptable Objects & Prefabs: Modular data-driven design.
• Built-in UI: Quick setup of HUD, tower bar, and menus.
• Improved Visuals: Multiple levels, animations, effects.
• Reusable Systems: Health, towers, enemies, and attacks designed for easy expansion.

Key Advantages

1. Fast Development: 1 week vs 3–4 weeks.
2. Quick Iteration: Drag-and-drop workflow.
3. Engine Tools: Animation and UI built-in.
4. Automatic Lifecycle: Garbage collection simplifies memory handling, reducing potential errors.

Technical Challenges:

Both versions required a predictive health system to optimize turret behavior:

• Turrets calculate expected enemy health immediately when firing.
• Enemies marked as “doomed” by incoming attacks are skipped by subsequent turrets.
• Dirty flags mark enemies to be removed once damage reaches them visually.

This system ensures no wasted projectiles and efficient targeting. The implementation is conceptually the same in C++ and Unity, though in C++ it required explicit memory and lifecycle handling.

Reflection

Developing the same game twice highlighted the trade-offs of low-level vs engine-driven development:

Key Takeaways:

• C++ gives maximum control and performance, but at higher cost in time and complexity.
• Unity enables fast prototyping, polish, and modular expansion.
• Both reinforce principles of game architecture and optimization.

Links

• 🕹️ Try both versions on itch.io!

The goal was to experiment with how different behaviours interact when combined, and to provide a way to tune their influence in real time through sliders.

• Introduction
• Implemented Behaviours in Unreal Engine
• Final Movement (Black)
• Conclusion

Introduction

Steering behaviours are a classic set of techniques in artificial intelligence for games, especially when dealing with groups of agents (commonly called boids).
They allow autonomous agents to move in a way that feels natural, organic, and responsive, without needing predefined paths or animations.

👉 Try it out yourself!

In the demo, you can move sliders to define how much each behaviour (from 0 to 1) affects the movement of the agents (balls).

• Black arrow → final resulting movement.
• Red arrow → separation force.
• Green arrow → cohesion force.
• Blue arrow → alignment force.
• Yellow arrow → obstacle avoidance.

Implemented Behaviours in Unreal Engine

All behaviours are calculated every tick in Blueprints and combined into a final movement vector.

• Cohesion (Green): pulls each agent towards the center of its neighbors. In Unreal, this is done by averaging neighbor positions and generating a force in that direction.

• Separation (Red): pushes agents apart to prevent collisions. Implemented by calculating repulsion vectors that grow stronger the closer two agents are.

• Alignment (Blue): aligns each agent with the average heading of its neighbors. In Blueprints, this means weighting neighbors’ velocities and steering towards that combined direction.

• Obstacle Avoidance (Yellow): prevents collisions with objects. A forward Line Trace detects obstacles and applies a repulsion force based on the hit normal.

Final Movement (Black)

The four vectors are summed and normalized into a single final direction. This direction is then applied as torque and velocity to the physics component of each agent.
Forces reset each tick, ensuring smooth and dynamic motion that depends only on the current state of the environment.

Conclusion

This project was a great way to practice both vector math and agent-based AI programming.
Even with just four behaviours, the result feels dynamic and lifelike. Real-time tuning with sliders makes the demo an effective tool for learning, testing, and experimenting.

• Project Context
• My Contributions
• Reflection
• Link

Project Context

Supermarket Rush is a fast-paced runner with a third-person perspective. Players automatically move forward, gradually accelerating, and must:

• Avoid cars traveling down three parallel lanes.
• Collect coins to boost score.
• Use power-ups strategically to gain an advantage or slow the opponent.
• Compete in local multiplayer or against AI, aiming to reach the supermarket first.

The main goal is to outpace your opponent, combining quick reflexes with strategic collection and use of power-ups.

My Contributions

I focused on the player character and core gameplay systems, making interactions responsive and consistent:

• Character Movement: Lane switching, forward progression, acceleration, and input handling for both single and local multiplayer.
• Collision Handling: Programmed reactions to crashes, including triggering the death animation and resetting the player.
• Power-Up & Coin Integration: Built the collection system and feedback UI. I connected power-ups to the player, while a teammate implemented their specific effects.
• Animation Integration: Created Blueprint-based animations for running, switching, and collisions to ensure clear visual feedback.

Reflection

Developing Supermarket Rush in one week was an excellent exercise in rapid prototyping, teamwork, and iteration:

• Unreal Engine Blueprints enabled quick implementation of movement, collisions, and pickups.
• Coordinating with teammates showed the value of modular design and careful integration.
• Despite its simplicity, the project demonstrates how polished mechanics and competitive elements can create engaging gameplay in a short timeframe.

Link

• 🕹️ Try out Supermarket Rush!

• Project Context
• My Contributions
• Technical Highlights
• Link

Project Context

The game focuses on combat variety and enemy AI. Players can choose from multiple weapons:

• Melee: Katana (with parry system) and bare-handed combos (punches, kicks).
• Ranged: Bazooka, shotgun, and machine gun.

Enemies patrol the castle, react to sound and sight, and display distinct behaviors. As the player progresses through the castle’s halls and rooms, they gather ammo and health packs dropped by enemies or placed in corners.

At the end lies the final boss, designed around katana combat, where the parry mechanic becomes essential to succeed.

My Contributions

I was responsible for:

• Designing and implementing all enemy AI behaviors (Ambusher, Cautious, Guardian, Sassy).
• Programming the melee combat system, including modular combos and parries.
• Integrating animations for both player and enemies.
• Preparing the full castle/dungeon layout, placing resources and encounter spaces.

Technical Highlights

This project stood out because of two core systems I built from scratch:

• Custom Modular Combat System
  • Allowed chaining of primary and secondary attacks into fluid combos, instead of relying on Unity’s default Animator state machines.
  • Attacks were completely interchangeable: developers could add, remove, or swap animations without touching the core logic.
  • The parry mechanic was tightly integrated into this system, giving precise timing windows and rewarding player skill.
• AI with Distinct Archetypes
  • Four behaviors were implemented (Ambusher, Cautious, Guardian, Sassy), each requiring specific movement logic and animation handling.
  • Enemies combined sight and sound detection, forcing players to consider both stealth and positioning.
  • This diversity of AI created varied encounters, from sudden ambushes to territorial defenses.
• Boss Fight Design
  • The final boss exploited the parry mechanic, requiring mastery of the katana to succeed.

Link

• 🕹️ Try out Katanas and Chaos!

The project, made in Unity, came to me in a broken state: dialogues, animations, and much of the code needed to be reviewed and rebuilt. My role was to take what wasn’t working, make it functional again, and then improve it. It was both a programming challenge and a chance to learn how to rescue an idea with potential and give it new life.

• Context
• Improvements in the Remake
• …plus many other polish details that elevated the experience.
• Gameplay
• Reflection
• Links

Context

Arima Lodge was originally created during the Indie Spain Jam 2022. Later, the studio decided to revisit it, adding quality improvements and officially releasing it on Steam in December 2024.

It’s a short 10-minute story, set in a near-future dystopia inside a single elevator. You play as Kai, the bellhop, when a mysterious man forces him to ride straight to the 100th floor, things quickly spiral into tension and mystery.

Improvements in the Remake

During the remake I implemented a wide range of improvements, including:

• 🌍 Localization to multiple languages
• ✍️ Better text handling
• 📖 Expanded narrative options
• 🎭 Improved animations
• ⏱️ Refined timing
• 💬 Updated dialogues
• 🔀 Multiple endings

• …plus many other polish details that elevated the experience.

Gameplay

The experience is simple but effective:

• Limited dialogue choices from Kai’s perspective.
• Quick Time Events (QTEs) to open and close the elevator doors at the right moment.
• A compressed narrative structure, where each stop and each passenger adds to the atmosphere.

The result is short, immersive, and full of urgency. It makes you feel both trapped and curious about what’s waiting at the top.

Reflection

Working on Arima Lodge in Unity was both a technical challenge and creative rediscovery. I had to rebuild broken systems while aligning them with the narrative, but it was rewarding to see how a jam-born idea found a polished second life.

It’s a short, free, and highly recommendable experience. You can finish it in under ten minutes, but it leaves you wanting more.

Links

• 🎮 Arima Lodge (Steam, 2024 release)

• 🕹️ Arima Lodge (Itch.io, original 2022 version)

Every aspect of the game—programming, mechanics, design, art, and animation—was developed by me. Players control “tool-humans,” cursed by the demon Bael, battling through the underworld on grid-based maps using strategic card-based abilities. Each run is procedurally generated, offering unique challenges and requiring constant adaptation.

• Project Goal & Methodology
• Core Gameplay
• Production Highlights
• Reflection
• Link

Project Goal & Methodology

The main goal was to learn Unity independently while producing a playable demo. My methodology included:

1. Game Design Document (GDD): Defined the story, visual style, core mechanics, characters, levels, and interfaces.
2. Knowledge Assessment: Identified skills required, from C# programming to pixel art, and learned them through tutorials and experimentation.
3. Practical Exercises: Applied concepts in small prototypes to solve potential technical and design challenges.
4. Demo Development: Built the final demo with all core mechanics, balancing gameplay and producing content iteratively.

This approach allowed me to develop both technical and creative skills simultaneously, reinforcing my self-learning abilities and project management.

Core Gameplay

• Turn-Based Strategy: Grid-based combat emphasizes positioning and card management.
• Deck-Building: Characters’ abilities are represented by cards, which evolve during each run.
• Roguelite Progression: Randomized events, levels, and rewards ensure replayability and strategic depth.

Production Highlights

Programming:

• Characters’ movement, attacks, health system, enemy AI.
• Card and energy system, turn system, menus, tutorials, and sound management.

Art & Animation:

• 10 characters with idle, movement, and damage animations.
• Pixel art backgrounds, level tiles, and menus created in Aseprite.
• 60 skill cards with visual effects for attacks, feedback indicators, and UI elements.

Learning Process:

• Overcame technical challenges such as pixel-perfect rendering, managing Unity’s Animator efficiently, and separating visual objects from logic to prevent conflicts.
• Learned to iterate on art and animations, balancing aesthetics with gameplay functionality.
• Gained confidence in self-directed problem-solving, independent learning, and project planning.

Reflection

Completing Proyecto Manthanō allowed me to:

• Combine Unity, C#, and pixel art into a complete project.
• Understand scope management in solo projects.
• Prove my adaptability and independence as a developer.

The final demo is not only a game but also a showcase of end-to-end production experience.

Link

• 🕹️ Try out Doom of tools!

• Project Context
  • Gameplay Overview
• My Contributions
• Development Process
• Link

Project Context

The game tells the story of Neon Johnson, a researcher specializing in network cases, who receives new information about his sister, Neon Smith, a former top agent who died under mysterious circumstances. To uncover the truth, Neon Johnson dives into the darkest sectors of the network.

The world of Neon N Bullets imagines a society where internet access is a basic necessity, and VR pods allow users to fulfill nearly all daily needs without leaving their cabins. Players explore this digital underworld while advancing through the story.

Gameplay Overview

• Isometric perspective with fully 3D environments.
• Player movement: WASD for navigation, mouse for aiming.
• Combat: Shoot, dash (Space), and survive waves of enemies.
• Objectives: Advance through levels while neutralizing enemies, avoiding damage, and discovering the story.
• Levels: Each stage offers multiple routes, all converging at a single exit.
• Enemies: Diverse and challenging, programmed with Behavior Trees.
• Bullet Hell Mechanics: Avoid being hit while managing positioning and timing.

My Contributions

I handled all gameplay programming and player mechanics using Unreal Blueprints:

• Player Control: Movement, aiming, shooting, dashing, and camera interaction.
• Enemy AI: Implemented using Behavior Trees for pathfinding and attacks.
• Health & Regeneration: Player life, orbs, and regeneration effects.
• Visibility System: Material effect that fades objects between the camera and player.
• Particle Effects: Dash particles and hit effects.
• Game Settings & Adjustments: Configurations for gameplay balance and feel.

Development Process

The demo for the first level was developed in four months:

1. Preproduction: Concept art, sound design, GDD, level design documents, and narrative.
2. Production: 3D modeling, rigging, animation, programming, music composition, UI, and voice-over.
3. Polishing: Refined gameplay, visuals, and balanced mechanics.

Despite time constraints forcing the team to cut some original GDD features, the project lays the foundation for a full game with rich narrative and advanced mechanics.

Link

• 🕹️ Try out NeonNBullets!