Beltrunner: A Game Design Postmortem

Last week, I showcased an arcade-accurate recreation of Asteroids to highlight a brand-new approach to game development I've been refining. This system is called Jinks—a hybrid of a lightweight engine, an IDE, and a specialized language.

BELTRUNNER is an original title built using the same foundational logic as that Asteroids clone, serving as my submission for the #GMTKjam 2026.

Technical Overview

The entire project consists of approximately 1,300 lines of code. Crucially, it is a finished experience with a definitive end. While it utilizes the same succinct syntax as my previous work, I'm keeping the inner workings of Jinks a secret for now; it's evolving daily, and I want the tool to stabilize before I formally document its architecture.

For this postmortem, I want to focus on the evolutionary path of the game: the ideas that survived, the ones that were cut, and the lessons Jinks learned during the process. My design philosophy is heavily rooted in the mechanics of vintage gaming.

---

🛠️ The Evolutionary Process

The initial version of the game bore no resemblance to Asteroids.

Prototype 1: The Orbital Shooter I originally built a game similar to Space Duel, featuring fixed concentric shells around a central sun with numbered targets. While Jinks made the initial build incredibly fast, the actual gameplay felt stagnant.

"I always say that no work is truly wasted; it’s simply put aside until its usefulness or suitability becomes apparent."

I realized I missed the chaotic, unpredictable drift and the necessity of dodging found in Asteroids. I scrapped the orbital layout but retained two key elements: numbered targets and the concept of a chain. I was also mentally looping the song "Countdown" by Phoenix, which influenced the final direction.

The "Masquerade" Design

I pivoted back toward an Asteroids feel, transforming the targets into something akin to the gates in Wave Race 64 or the rings in Pilotwings. I also employed a design trick from Donkey Kong '94: The Masquerade. The game pretends to be a familiar classic before revealing its true identity.

• Wave 1: Pure Asteroids. You have the classic thrust, drift, and splitting rocks.
• The Twist: There are no lives on the first collision, and a race clock appears the moment you land your first hit.
• The Transition: Once the field is clear, a black hole opens. You can use a dash to accelerate into the void, warping you to the next stage.

The Core Tension

The gameplay revolves around two converging countdowns:

1. The Gate Count: This is the player's objective (driven by the player).
2. The Race Clock: This is the pressure (driving the player).

The relationship can be expressed as: $\text{Time}_{\text{final}} = \text{Time}_{\text{start}} + \sum(\text{Gate Bonuses}) - \sum(\text{Collision Penalties})$

---

🍄 The "Nintendo Way" of Difficulty

I avoided a linear, endless difficulty ramp. Instead, I structured the game into four acts of four waves (16 total), ensuring the game is winnable and structured.

I follow a specific cadence: $\text{Introduce} \rightarrow \text{Practice} \rightarrow \text{Practice} \rightarrow \text{Close}$. This ensures the player doesn't just see a mechanic once, but actually learns to strategize around it.

Implementation Detail: In the Jinks code, I only define the changes between waves. If a wave is a practice round, the code block for that wave remains empty.

• Implement elliptical slots (replaced side-on grazes).
• Add directional routing problems.
• Add timing-based spinning gates.
• Create "toast" notifications for new mechanics.

---

🕹️ The "Arcade Way" of Determinism

I am inspired by the "course-like" feel of Pac-Man or Flicky, where success comes from memorizing patterns. To achieve this, BELTRUNNER is entirely deterministic.

Every "random" element—from where rocks spawn to where gates are placed—is derived from a single seeded stream.

// Conceptual logic for deterministic spawning
let gameSeed = 12345; 
let spawnPoint = seededRandom(gameSeed); 
// Same seed + same input = identical gameplay session

Why this matters:

• Learning: The field becomes a map the player can master.
• Replays: Recordings are viable because the stream is consistent.
• Tuning: I can adjust rules against a specific seed rather than relying on luck.

Finally, I replaced "random chance" power-ups with a fixed cycle. Every eighth rock destroyed arms a power-up in a strict sequence: [T] $\rightarrow$ [I] $\rightarrow$ [S].