🎮 Game Dev and the Rockstar Illusion

At some point, many aspiring game developers ask the same question:

"Should I pursue game development as a career?"

It’s a fair question — and one I’ve heard dozens of times over the years. My usual answer goes something like this:

 Game development, for many of us, is the modern-day rockstar path. The huge potential upsides suspend people’s disbelief. Sheer optimism draws people into making life-changing career decisions on flimsy grounds.

And I still stand by that.

The Seductive Myth

There’s a dream attached to game development that’s hard to shake.

Make a hit indie game. Build a loyal community. Quit your day job. Maybe even go viral and rake in millions. We've all seen it happen. Stardew Valley. Undertale. Minecraft. Those stories are real — and they’re incredibly inspiring.

But here’s the thing: they’re not the rule. They’re the outliers. The exceptions. The lottery wins.

The Reality Check

Making software is difficult.

Making successful software? Even harder.

Now try making a successful game in one of the most oversaturated creative markets on the planet.

It’s not just about writing code or drawing sprites. It’s game design, storytelling, marketing, community building, testing, patching, supporting — usually with limited time, resources, or income. Even with passion and dedication, a great game can vanish in the noise of the marketplace.

This isn’t meant to scare you off — but it is meant to snap the illusion. Because game development isn’t a shortcut to fame or fortune. It’s work. Deep, complex, and often unpredictable work.

Why Do It Then?

Because you love it. Because it fascinates you. Because making something interactive — something playable — is uniquely satisfying.

For many of us, that’s reason enough. But the key is understanding that passion alone isn’t a business model. The most sustainable developers I know treat game dev like a long game. They build skills slowly. They wear many hats. They take breaks. They fail, adapt, and keep going.

Career vs. Calling

You can make a career in game development — but go in with your eyes open.

Ask yourself:

1. BASIC Isn't Dead. It Just Grew Up.

If you learned to program in the 80s or 90s, chances are your first line of code looked something like this:

PRINT "Hello, World!"

To many, BASIC feels like a relic of computing’s early days—an outdated teaching tool overshadowed by modern languages like Python or JavaScript. But that assumption couldn't be more wrong. BASIC never disappeared. It diversified. It evolved. And today, it lives on in a wide range of powerful, practical dialects still being used to build games, web tools, business systems, and more.

2. What Made BASIC Great Then Still Matters Today

BASIC was designed to be accessible. Its name stands for Beginner's All-purpose Symbolic Instruction Code, and its creators wanted students to focus on learning to solve problems, not memorizing syntax. That simplicity, that clarity, is what makes BASIC surprisingly relevant even now.

Today's developers value code that is readable, quick to write, and easy to maintain. Sound familiar? That’s the same philosophy behind modern favorites like Python, Lua, and even aspects of Swift. BASIC got there decades earlier.

3. Visual Basic: The Face Everyone Recognizes

No conversation about BASIC is complete without mentioning Visual Basic (VB). Introduced by Microsoft in the early 90s, VB turned BASIC into a powerhouse for Windows development. Its visual form designer and event-driven model made it the go-to language for building business applications and internal tools.

Even today, VB.NET is still supported in Visual Studio, and VBA (Visual Basic for Applications) remains deeply embedded in Microsoft Office, driving automation and macros across the business world.

But here’s the key point: Visual Basic is just one dialect. BASIC’s legacy didn’t stop with VB—it blossomed into a wide ecosystem of modern tools, many of which continue to be actively developed.

4. Beyond VB: The Modern BASIC Landscape

🎮 Game Development

REM BASIC
PRINT "Hello, World!"

# Python
print("Hello, World!")

The idea behind this project was simple: Could I recreate a Wolfenstein 3D-style engine in PlayBASIC while maintaining good perspective but using affine texture-mapped polygons instead of traditional raycasting?

Floors and Ceilings: Subdivision for Perspective

Classic Wolfenstein 3D engines rely on raycasting, but I wanted to explore using polygons. This introduced two key challenges: rendering walls and handling floors/ceilings. I tackled floors first by subdividing floor tiles near the camera, ensuring that closer surfaces were represented with a denser set of polygons. This approach worked well, maintaining an accurate perspective without excessive computational overhead.

Walls: Adaptive Subdivision

I applied the same technique to walls, subdividing them based on their distance from the camera. Surfaces closer to the viewer were represented with more polygons, while those farther away used fewer. This adaptive approach preserved scene perspective while optimizing performance.

Ensuring Proper Polygon Order

A major challenge with polygon-based rendering is ensuring proper drawing order. Since walls, floors, and ceilings are drawn as independent polygons, z-fighting (incorrect layering of polygons) can be an issue. To address this, I implemented a two-pass rendering system:

1. 1. First, floors and ceilings are drawn.
2. 2. Then, walls are rendered on top.

This method prevents z-popping artifacts commonly seen in painters’ algorithms and produces a visually appealing scene.

Enhancing the Classic Wolf 3D Look: Adding Light Mapping

To push beyond the classic Wolfenstein 3D aesthetic, I added a light mapping pass. Implementing this in PlayBASIC required rendering the scene twice—essentially brute force—but the cost was only around a 20% performance hit. The visual improvement, however, was well worth it.

The process involved:

1. 1. Drawing the texture-mapped scene.
2. 2. Overlaying a Gouraud-shaded version of each triangle, where each pixel’s color was alpha-blended with the background.

This resulted in a real-time light-mapped scene with a Doom-like atmosphere, enhancing immersion and depth.

Pushing Further: 3D Polygonal Characters Instead of Sprites

A long-standing idea I wanted to explore was replacing traditional 2D sprites with 3D polygon-based characters. This concept originated from my work on a rendering engine called "Reality" for Amiga computers back in 1995, which aimed to integrate both sprites and 3D objects within a scene.

Implementing 3D Objects

To bring this concept into PlayBASIC’s Wolf 3D engine, I needed a way to load and render 3D models. I chose the DirectX ASCII format due to its simplicity. The loader extracted three key components: