⚔️🖥️ Battle Coder 🎮

A 2D vectorial game and scripting app to teach programming.

Written in C++ 20 and powered by embedded Python 3 scripting, Battle Coder turns first-year computing lessons into fast-paced coding duels. Students tackle level-based challenges by writing Python that directly manipulates game objects and logic.

Thanks to Pybind11, key C++ classes, functions and entities are surfaced to Python, delivering a smooth bridge between native gameplay and user scripts. Progression, scores and content drops are delivered via Firebase (JSON), giving lecturers live oversight and automated grading.

Our goal: an engaging educational tool that motivates learning through gameplay, scoring, and automated code tests.

Features

My Role in this Project

Gallery

Main Menu

Running Program

My Vector Figure Editor

Identifiers & Keywords

Error Feedback & Highlighting

Vector Shape Editor

Pikmin-Like Game

A cooperative puzzle-platformer developed on PS5 devkits using our custom engine.

Designed for two players on a shared screen, the game features asymmetric gameplay mechanics and a variety of interactive elements that encourage teamwork and creative problem-solving. It was developed entirely with our own custom engine, taking full advantage of its flexibility to deliver smooth and dynamic local co-op gameplay.

Features

My Role in this Project

Gallery

Menu

Collaborate

Grass

Grass

Grass: Compute Shader

Our Engine Editor

Credits

An Optimised Voxel Engine for the Nintendo GameCube

This is my final individual university project, focused on creating a voxel engine optimised for the Nintendo GameCube from scratch using its native Graphic API Nintendo GX. The main goal was to maximise performance and memory efficiency to render the highest number of chunks while maintaining a stable 60 FPS on the console’s limited hardware.

Optimisations in the Voxel Engine

To achieve a smooth 60 FPS while rendering as many chunks as possible, I focused on both performance and memory efficiency with these key optimisations:

Distance vs Frustum Culling

Distance from Camera

Distance + Frustum Culling

Stages of Optimisation

Structure

All Stages

• Stage 0: No Optimisations
• Stage 1: Batching
• Stage 2: Occlusion Culling L1 (Blocks — Game Loop)
• Stage 3: Occlusion Culling L2 (Faces — Game Loop)
• Stage 4: Occlusion Culling L3 (Blocks — Precalculated)
• Stage 5: Occlusion Culling L4 (Faces — Precalculated)
• Stage 6: Structs Level 1
• Stage 7: Display List
• Stage 8: Structs Level 2
• Stage 9: Further Memory Usage
• Stage 10: Achieve 60 FPS

Stages of Optimisation: Summary

Stage 0: No Optimisations

FPS: 15

N° Chunks: 9

Draw Calls: 20488

Free Memory: 17.785 KB

Stage 10: All Optimisations

FPS: 60

N° Chunks: 289

Draw Calls: ~100

Free Memory: 2.663 KB

What Knowledge Have I Acquired?

Memory Optimisation: Struct Sizes

Struct Cubito (Initial Version)

Struct CubeFace: 5 bytes

Struct Cubito: 38 bytes

Baseline version: no memory optimisation applied.

Structs Level 1

Struct CubeFace: 2 bytes

Struct Cubito: 16 bytes

Memory usage reduced by 57.89% in Cubito and 60% in CubeFace.

Structs Level 2

Struct CubeFace: 1 byte

Struct Cubito: 10 bytes

Maximum optimisation: 73.68% reduction in Cubito and 80% in CubeFace!

🚧 Post-TFG Improvements

After submitting my final project, I’ve continued working on the engine. Here are some of the features I’ve been adding:

A TopDown “Soulslike” game made with Unreal Engine 4

Invicta: The Next Queen is a top-down “soulslike” game inspired by titles like “Death’s Door,” “Tunic,” and “Dark Souls.” You play as the “Moma,” a fierce warrior who, after losing a battle, dies and has their soul fragmented into pieces, each guarded by one of the seven deadly sins in Hell.

Your quest is to reclaim your lost soul, with one piece guarded by King Midas, the sin of greed. To recover it, you’ll face off against King Midas and his soldiers in a deadly battle for your redemption.

This project was developed by a group of students from ESAT Valencia (Escuela Superior de Arte y Tecnología).

My Role in this Project

In this project, my main responsibility was implementing all in-game animations for every character provided by the artists. This included creating state machines, setting up blending and blend spaces (both 2D and 3D), allowing for smooth character movement in different directions such as forward, backward, left, and right. I also implemented layered animations, allowing for simultaneous animations, like blending a crouching animation for the lower body with a walking animation for the upper body.

Additionally, I handled the event system linked to animations, including using animation notifies in Unreal Engine to trigger actions based on specific frames within animations. I also worked on the implementation of projectiles and their unique trajectory behaviors, such as arc trajectories for fire projectiles.

Another important task I contributed to was the parry system, allowing players to reflect projectiles with their original trajectory. Finally, I helped develop hazard zones like fire, ice, and oil, which interact with both the environment and the player, adding another layer of challenge to the game.

Gallery

Special Attack: A lifesaver when you're surrounded!

Turn the mages' projectiles against them!

🚧 Page in Development – project, content and visuals are still evolving.

Phazon Engine

My own Graphics Engine built for the PlayStation 5 using Sony’s native graphics APIs AGC. Developed as a university project to gain hands-on experience with console-level graphics programming.

Features

My first Graphics Engine 🍗

Poyo Engine is a custom-built video game engine crafted entirely using C++ and OpenGL. It is structured around components, utilising an Entity Component System (ECS) and offers various features.

Features

Gallery

Water & Caustics

Skeletal Animation

Deferred Shading

PBR Materials + Emissive

Entity Component System (ECS)

Entities are the core game objects, and components define their behaviour. The available components are:

What Knowledge Have I Acquired?

Code Example

#include "poyo_engine.h"

using namespace poyo;

int main(int argc, char** argv) {

    //1º Declare a Window variable:
    auto maybe_window = Window::create("Poyo Version X", 1600, 900);
    if (!maybe_window) return -1;

    Window& currentWindow = *maybe_window;

    //2º Declare an Input variable
    Input& currentInput = currentWindow.getInput();

    while (!currentWindow.shouldClose()) {
        UpdateEngine(currentWindow); //Updates Delta Time & Commands

        if (currentInput.isPressed(Keys::KEY_F11))
            currentWindow.makeFullScreen();     //Makes Full Screen

        //Finally, call the render function
        currentWindow.render();
    }
    return 0;
}

Upcoming Enhancements

In the pipeline for PoyoEngine is the integration of a robust Physics Engine. This enhancement aims to elevate the engine’s capabilities by introducing realistic physics simulations, enabling dynamic object interactions and immersive gameplay experiences.

Radial Sinewave

An effect that evokes the shape of a droplet hitting water, built entirely in assembly language.

A grid of points is generated radially around the center. Each circle has a height derived from a sinusoidal function. For every frame, the heights of the rings are varied, causing a wave-like rotation and projection onto the screen.

A Procedurally Generated Pokemon City

A procedurally generated city with three distinct types of lights: directional, spot, and point. Incorporates environment fog and transparent materials for a polished visual experience.

Features

Robo Space Runner

An infinite runner game developed using Unity and released on the Google Play Store. Features a procedurally generated grid with autonomous entities capable of traversing the dynamically created environment.

Features

Our first Game made in Unreal Engine 4

A Metroid Prime recreation built in Unreal Engine 4, featuring Samus’ iconic mechanics — beam switching, morph ball, lock-on targeting, and the curved HUD visor effect.

Features

My Role in this Project

Samus’ Curved HUD

Original HUD

Our HUD

Kirby DJ Equaliser

An equalizer crafted using OpenGL and C++, featuring illumination, a particle system, and objects that respond to music in real time. Includes an automated camera executing rotations around the scene and real-time mesh transformation.

Features

🚧 Page in Development – project, content and visuals are still evolving.

Toy Tanks

A GameCube game made with DevkitPro and GRRLIB. Two tanks must destroy each other to win using two weapons: the tank gun and bombs. Each player has five lives. Works on both GameCube and Wii.

My Role in this Project