Summary
This page collects my first practical game engine projects, with a focus on gameplay implementation and learning how multiple systems interact inside a playable prototype.
The main project is a Godot deckbuilding roguelike prototype developed in a two-person university team. An earlier Unity first-person prototype represents my first experience with real-time game development and engine workflows.
These projects are learning prototypes rather than polished commercial games. Their value is in the practical experience they gave me with gameplay logic, combat flow, UI interaction, game state and iterative implementation.
What This Project Shows
- Gameplay implementation in Godot and Unity
- Turn-based combat flow
- Card-based gameplay systems
- Enemy actions and resource handling
- UI and player interaction
- Gameplay prototyping and iteration
- Early real-time movement and level interaction
- Practical understanding of interacting gameplay systems
Godot Deckbuilding Roguelike Prototype
This prototype was created during a special Godot course at Freie Universität Berlin, taught in collaboration with a visiting professor and students from the University of Montana. The course lasted about one month and ended with a small team-based game project.
I worked on the project in a two-person team and took the lead on most implementation tasks. My main contribution was gameplay implementation, including card logic, turn-based combat flow, resources, enemy actions, UI interaction and core game state management.
For the course project, we used Slay the Spire as a reference to explore how a deckbuilding combat loop is structured and implemented. The goal was to learn Godot and build a working gameplay loop within the short course timeframe rather than create an original commercial product or art direction.
I continued working on the prototype beyond the required course time because I wanted to implement more systems, improve the combat flow and better understand how the mechanics interacted with each other.
Implemented Systems
- Turn-based combat flow
- Card-based actions and effects
- Player and enemy turns
- Enemy actions and attack patterns
- Resource handling
- Card UI and interaction
- Win/loss conditions
- Combat feedback
What I Learned
The project showed me how quickly complexity grows when gameplay systems begin interacting. Card logic, resources, enemy behavior, combat flow and UI feedback are manageable in isolation, but their interactions require clear state handling and repeated testing.
It was also one of the projects that shifted my interest from simply playing games toward understanding how gameplay systems are built, connected and iterated.
Godot deckbuilding roguelike prototype with turn-based card combat and enemy actions. Created for an internal university course using placeholder assets for learning purposes.
Prototype asset note: The university prototype used temporary Slay the Spire assets for this non-commercial learning project. My contribution focused on gameplay implementation and system interactions.
Follow-Up Godot Learning
After the university project, I continued working with Godot through a structured card-roguelike tutorial series. This gave me exposure to larger-scale systems such as map generation, relics, modifiers, buffs and debuffs, enemy encounters, card rewards and a more scalable project structure.
This was a tutorial-based learning exercise rather than a separate original portfolio project. It helped me revisit similar mechanics with more time and structure after the short university course.
Tutorial reference: GodotLab card roguelike tutorial series
Early Unity First-Person Prototype
My first practical experience with game development came through a university Unity course and a small first-person prototype. I implemented basic movement, level navigation and interactive elements while learning scene setup, cameras and real-time gameplay workflows.
Although technically simple, the prototype was my first opportunity to approach games from a developer rather than purely a player perspective. I also experimented with Blender and basic 3D asset workflows, which gave me an early view of the broader production process.
Early Unity first-person prototype focused on movement, level layout and basic interaction.
Current Direction
These prototypes provided my first practical experience with gameplay implementation and game engines. My later work increasingly shifted toward game design, balancing and iterative playtesting, while this technical foundation continues to help me prototype and reason about gameplay systems.