Source note: Local copy of a Summer Into AI 2026 submission originally published on Substack. Screenshots, video, and audio found in the post body are mirrored locally when publicly accessible; profile and avatar images are intentionally not copied. Read the canonical post.
If you have ever shipped a game prototype fast, you know this pattern:
You start with a neat idea, then by day three you are deep in turn logic, text overlap bugs, and terminal commands you swore you would never need to memorize.
That was Week18Bit for me.
I set out to build a small turn-based RPG in Phaser + TypeScript with a retro feel. The scope looked simple. The execution was not. The result is a playable project with a working combat loop, enemy retaliation, generated 8-bit visuals, chiptune battle audio, turn-order animation, and a much cleaner UI.
Here is what I built, what broke, and what actually mattered.
## The Core Goal
I wanted a game that felt like a real RPG loop, not a menu simulator:
1. Player turn with attacks and abilities
2. Enemy turn with meaningful response
3. Visual feedback for turn flow
4. Battle music that feels retro
5. Enough style to feel intentional, not placeholder
The stack was intentionally lean:
1. Phaser 3
2. TypeScript
3. Vite
4. JSON-driven game data
## What Changed in Combat
The biggest gameplay fix was enemy interaction. Enemies were not reliably feeling like active participants, so I reworked turn progression and AI flow.
What got fixed:
1. Turn progression now advances to the next combatant consistently
2. Enemy AI target selection got safer and more predictable
3. Cooldown behavior was corrected to avoid weird immediate refreshes
4. Enemy turns now fire in a way that feels continuous with the player loop
Small logic issues in turn systems create huge perception issues. If enemies hesitate or skip once, players read the whole system as broken.
## The “8-Bit” Layer: Sprites and Backgrounds
I added runtime-generated pixel-art assets for both heroes and enemies, plus background textures for multiple scenes.
This solved two problems at once:
1. The game gained visual identity immediately
2. I did not need to hand-author every asset before testing combat feel
Instead of waiting on art production, I used generation to keep iteration speed high.
## Procedural Battle Music (No Audio Files Needed)
Battle scenes now trigger a custom chiptune-style track generated with WebAudio oscillators.
Why this mattered:
1. Battles felt alive the moment they started
2. No external soundtrack pipeline required
3. Music lifecycle is tied to scene lifecycle, so audio stops cleanly when combat ends
It is lightweight, but it makes the game feel dramatically more “finished.”
## Turn-Order Animation: Tiny Feature, Big Perception Shift
I added a turn stage where active characters perform a quick animation:
1. Step forward
2. Raise arm
3. Step back
That single motion made the whole turn system easier to read. People no longer needed to decode text to understand who is acting.
In turn-based games, clarity is game feel.
## UI Cleanup Was Not Optional
After adding visuals and animation, text started colliding with panels and controls. I had to do a focused layout pass:
1. Repositioned combat info and panel geometry
2. Reduced and wrapped long text lines
3. Fixed mission board layering and stale button artifacts
4. Improved spacing in hub and credits screens
No matter how good your systems are, overlapping UI can make your game feel unfinished in seconds.
## The GitHub Push Problem Nobody Talks About, Especially when you’re still learning
I hit a push failure with HTTP 400 sideband disconnects after a large tracked artifact set.
Root causes:
1. Generated folders had been tracked earlier (`node_modules`, `dist`)
2. Transport was unstable over default settings
Fixes that worked:
1. Remove generated artifacts from tracking with cached deletes
2. Commit cleanup
3. Force HTTP/1.1 transport and increase post buffer
4. Push again successfully
This was a good reminder that `.gitignore` is preventative, not retroactive.
## What I Took Away
Fast game prototyping is less about one perfect feature and more about sequencing:
1. Get the loop working
2. Add readability
3. Add feedback
4. Fix friction
5. Ship
Week18Bit became useful the moment I stopped treating polish as “final phase” work and started treating it as core functionality.
Because in turn-based games, feedback is functionality.
Github: https://github.com/MegaSF/summerAIcomp/tree/main/Week18Bit
Original source
Canonical Substack URL: https://evanrhea.substack.com/p/i-built-an-8-bit-turn-based-rpg-in.