In my game Table of Fates, Karma is very valuable and heavily influences how a run plays out.

If you keep bothering NPCs without helping them or buying anything, they slowly start getting annoyed with you, causing you to lose Karma.

Your Karma affects how the tavern reacts to you: which NPCs are willing to help, how often events appear, and even how valuable certain offers become during a run.

Edit: I now see the concerns about discouraging interaction and immersion breaking. I appreciate the feedback and will definitely revisit how these interactions work.

I’ve been a gamer for as long as I can remember, growing up alongside the industry.
But about 3 years ago, a random thought hit me: “How hard is it to actually make something like Flappy Bird from scratch?”

Instead of doing the sensible thing and downloading Unity to follow a tutorial, I went down a rabbit hole. I wanted to understand how a pixel actually ends up on the screen.

The “No-Engine” Phase

I started with SFML and C++.

I spent weeks just learning how to handle keyboard inputs, basic rendering, and how a game loop even works. Eventually I built a typing game where words fall from the sky, with a combo system inspired by OSU! and a few different modes. I was pretty satisfied with it, but I wanted more.

Then I moved to Pygame (Python) and tried to build a 2D roguelike.

Looking back, the scope was way too big, but it forced me to build everything manually:

• grid-based map system (and a map editor)
• collision logic from scratch (harder than I expected)
• enemy “brains” (so called "AI")
• projectiles, health bars, animations

During university, I even tried recreating Super Mario Bros in Python and built a Genetic Algorithm to play it. The AI would learn half the map perfectly (speedrun level type gameplay) and then just randomly die every time.

Moving to Engines Phase (Unity and Godot)

At some point I wanted to understand 3D, so I moved to Unity and built a small horror/puzzler in an asylum setting. (So original I know)

That’s where I learned about things like:

• inventory systems
• spatial audio
• structuring an actual “game” instead of just mechanics

But it didn’t really “click” until I found Godot.

I fell in love with the node system and ended up spending about a year on a Brotato-like project. (A long time but at least I finished it)

That’s where I really started understanding game feel, the small things no one notices individually, but everyone feels, such as:

• bullet impacts and snow footprints
• slightly varied audio so it doesn’t become repetitive
• smooth UI and camera transitions using tweens
• making walls fade when the player goes behind them
• complex enemy behavior and even a boss fight

Stuff that seems minor until they're missing.

The Reality Check (Game Jam)

While working on that project, I joined the Brackeys 2025.1 Game Jam and made a 60 Seconds!-inspired game. It ended up being ~350th place out of 2000+ entries. (looking back, it's decent for a first jam, but back then I felt sad)

That was the real lesson in scope.

It’s one thing to build a mechanic. It’s another thing entirely to turn it into a complete game in 7 days, with menus, audio, assets, balancing, and replayability.

It was chaotic, but incredibly valuable.

The Result: Table of Fates

Everything I’ve learned, from C++ experiments to Godot polish, led me here, working on my first Steam release. (I never knew I would get this far)

Table of Fates is a roguelike deckbuilder set in a medieval tavern. You play as a Traveler facing various NPCs in card-based encounters.

But it’s not just about the cards. I wanted it to be unique in some aspects.

You also interact with the tavern itself, locals can help you with items, upgrades, potions, and hints. But there’s also a Karma system: how you treat the locals can come back later in your run… and sometimes even reshape it.

It’s been a long 3 years of learning, failing, and restarting things, but seeing my own Steam page live still feels surreal.

TL;DR

Started with raw C++ just trying to understand how games work under the hood -> failed at a big Python 2D roguelike that taught me a lot of valuable stuff -> built a Mario AI experiment that was half great -> moved to engines -> got comfortable in Godot -> now building my first Steam game.

If you’re into deckbuilders or just want to support a fellow dev, you can find Table of Fates on Steam. Wishlists would genuinely help a lot, and feedback is always appreciated.

(Also, the Steam page is due for a visual update soon, the game has evolved quite a bit since the current trailer and screenshots were uploaded)

I recently added a small detail where NPCs subtly turn their heads toward the player when you walk past them.

It started as a simple way to make interaction zones feel clearer, but it also made the tavern feel much more alive instead of having NPCs stand there like static mannequins.

It ended up being a bit trickier to implement than I initially expected, so I wanted to share the result.

(The game is called Table of Fates)

Table of Fates is a roguelike deckbuilder I'm currently working on.

This is the rewards screen that appears after winning an encounter. The general structure is inspired by games like Slay the Spire, but I'm trying to make it fit the medieval tavern atmosphere of my game.

I'd especially love feedback on:

• readability
• pacing / flow of the rewards selection
• whether anything feels visually cluttered or unintuitive

Any suggestions on what would make it better are really appreciated.