Summary
This project page collects my first practical experiences with game engines, focusing on small gameplay prototypes built in Unity and Godot.
The goal is not to present a fully polished commercial game, but to show my learning path from player to developer: experimenting with engine workflows, implementing basic gameplay systems, building small interactive prototypes and connecting technical implementation with game design thinking.
The two main prototypes are a small Unity first-person prototype and a Godot card-based roguelike combat prototype.
What This Project Shows
- Practical experience with Unity and Godot
- Gameplay prototyping
- First-person movement and level interaction
- Turn-based combat flow
- Card-based gameplay systems
- UI and player interaction basics
- Learning mindset and self-driven iteration
- Transition from player perspective toward game development and game systems design
Unity First-Person Prototype
My first contact with game programming was through a university Unity course and a small personal prototype. Before that, I mainly engaged with games from a player perspective. Working in Unity helped me understand the development side for the first time: scene setup, player control, simple level design and interactive gameplay elements.
The prototype was a small first-person experience created to practice basic engine skills and build confidence with real-time interaction.
What I Worked On
- Basic Unity scene setup
- Simple first-person movement
- Level layout and navigation
- Basic interactive elements
- Camera/player perspective
- Testing and adjusting game feel
What I Learned
This was my first step from playing games to building them. It introduced me to Unity, scene setup, first-person movement, simple level design, interaction and basic real-time game feel. I also experimented with Blender and simple 3D asset workflows, which helped me understand how much production work exists beyond programming.
Early Unity first-person prototype focused on movement, level layout and basic interaction.
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 this project in a two-person team and took the lead on most implementation tasks. My main focus was gameplay implementation, including card logic, turn-based combat flow, UI interaction, enemy actions, resource handling and core game state management.
For our project, we chose to recreate the core feel of Slay the Spire as closely as possible within the short timeframe. The goal was not to create a commercial product or an original art direction, but to learn Godot, understand card-based combat systems and implement a working gameplay loop.
The prototype used Slay the Spire assets as placeholder assets for this internal university learning project. It was not distributed or sold. The focus was on gameplay implementation, combat flow, UI interaction and understanding how deckbuilding combat systems are structured.
During the project, I realized that game development itself was becoming genuinely interesting to me. I spent significantly more time on the prototype outside the course because I wanted to implement more systems, improve the combat flow and better understand how the mechanics worked together.
Implemented Systems
- Turn-based combat flow
- Card-based actions
- Basic player and enemy turns
- Enemy actions and attack patterns
- Resource handling
- Card UI and interaction
- Win/loss conditions
- Basic combat feedback
What I Learned
This project helped me understand how quickly complexity grows when implementing card logic, enemy behavior, combat flow, UI interaction and feedback at the same time.
Because the course duration was short, the architecture and feature scope were not perfect. However, the project gave me practical Godot experience and helped me move from a player perspective toward a developer and systems-design perspective.
Godot deckbuilding roguelike prototype with turn-based card combat and enemy actions. Created for an internal university course using placeholder assets for learning purposes.
Follow-Up Learning: Advanced Godot Card Roguelike
After the university project, I continued learning Godot through an advanced tutorial series focused on building a card-based roguelike structure similar to Slay the Spire. I invested a significant amount of time into working through the full project and understanding how the systems were structured, rather than only copying the code.
The tutorial project covered many of the systems that make this genre work at a larger scale, including map generation, relics, modifiers, buffs/debuffs, enemy encounters, card rewards and a more scalable project architecture. While the content depth was still limited compared to a full commercial game, the structure gave me a much better understanding of how a deckbuilding roguelike can be organized technically.
This was a tutorial-based learning project, not a separate original portfolio project. However, it helped me revisit similar mechanics with more time and structure after the university crash course. It also strengthened my own ideas for a future multiplayer-focused deckbuilding game, including competitive elements rather than only single-player progression.
Tutorial reference: GodotLab card roguelike tutorial series
Current Status
The Unity and Godot projects are learning prototypes rather than finished products. They show my practical exposure to game engines, gameplay implementation and prototyping.
The Godot card-combat direction is the stronger foundation for future work. I plan to continue building on this experience, especially in the direction of turn-based combat systems, deckbuilding mechanics, multiplayer ideas and game systems design.