🎮Copilot Made Me a Game Developer — How I Built Pixel Siege from an Old Python Prototype 👾🚀

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

Pixel Siege is a fast-paced 8-bit arcade shooter game where players battle relentless enemy fleets, collect powerful upgrades, and survive increasingly chaotic waves for as long as possible. Every stage ramps up the intensity, turning each run into a frantic mix of reflexes, strategy, and survival.

But the real story behind this project began long before this hackathon.

Pixel Siege originally started as a small Python-based Space Invaders clone I built as part of a university project. It was my very first introduction to game development, and I remember having an amazing time experimenting with gameplay mechanics, enemy movement, and player combat systems. Even though I eventually moved away from game development, the domain always stayed somewhere in the back of my mind.

For this Finish-Up-A-Thon, I decided to revisit that forgotten prototype and completely rebuild it from scratch — transforming it from a rough local Python script into a polished browser-based arcade experience that anyone can instantly jump into and play.

What began as a simple university experiment evolved into Pixel Siege: an endlessly scaling retro shooter packed with enemy swarms, tactical power-ups, arcade chaos, and intense survival gameplay.

Watching an old archived idea evolve into a fully playable retro arcade game has been one of the most satisfying and rewarding projects I’ve ever worked on.

Demo

🕹️ Play the game here

💻 Github Repo

NOTE: The old version of the project is in the 'main' branch and the revamp is in the 'v2' branch of the repo.

👾 Check out some gameplay below!

Watch the Gameplay Video Here

The Comeback Story

Before this hackathon, the game lived inside a single monolithic Python file. It had basic movement and shooting mechanics, but lacked structure, balance, replayability, and that satisfying “just one more run” arcade feeling.

To truly finish the project, I rebuilt the game engine from scratch using Phaser 3 and modern JavaScript ES6 modules.

Here’s what changed:

Infinite Progressive Difficulty

Instead of static levels, the game now features endlessly scaling waves that gradually introduce new enemy classes:

• 🔵 Blue Grunts
• 🟢 Green Wobblers
• 🔴 Red Kamikaze Tanks

Enemy counts and aggression scale over time, turning each run into escalating chaos.

Tactical Power-Ups

I implemented an RNG-based drop system that rewards aggressive gameplay:

• 🟢 Green Capsules → Double Laser Upgrade
• 🔴 Red Capsules → +20 Health Repair

These drops create clutch moments where players must decide between survival and risk-taking.

Modern Game Architecture

The original spaghetti code was refactored into clean, modular ES6 classes and Phaser scenes like:

• MenuScene.js
• GameScene.js

This made the project significantly easier to scale and maintain.

Arcade “Game Juice”

To make the gameplay feel satisfying and alive, I added:

• Retro arcade sound effects
• Background music
• Particle explosions
• Screen shake on impact
• Responsive visual feedback

These small details completely transformed the feel of the game.

My Experience with GitHub Copilot

One of the biggest challenges was migrating an old Python prototype into a modern browser-based game framework. Copilot became less of a code generator and more of a pair programmer, debugger, and game design mentor throughout the process.

I primarily used GitHub Copilot to accelerate development, brainstorm mechanics, debug issues, and better understand Phaser 3 architecture.

Copilot supported the project in several major ways:

Debugging Complex Issues

At one point, the game consistently crashed during higher levels. GitHub Copilot helped me trace the issue back to an asynchronous tween animation attempting to manipulate enemy objects that had already been destroyed.

It also helped me diagnose and rebalance a “Wave Overlap Bug” that accidentally made later stages nearly impossible to survive.

Brainstorming Gameplay Mechanics

I knew I wanted power-ups, but wasn’t sure how to make them meaningful.

GitHub Copilot helped me iterate on ideas like the Health Repair drop system by explaining how it reduces unavoidable “chip damage” and encourages players to make high-risk plays for recovery items.

Learning Modern Game Development

Beyond writing snippets of code, GitHub Copilot helped explain:

• Phaser 3 scene architecture
• Game loop pacing
• Object lifecycle management
• Collision handling
• Deployment workflows

Conclusion

Using Copilot didn’t just help me finish the game faster — it helped me understand why things worked, turning this project into both a finished game and a huge learning experience.

What started as a forgotten university prototype is now a fully playable retro arcade shooter — proving that some side projects just need one more life.