Press the icon on the right for the game
Project
Introduction
This project started as a personal learning goal during my Urban Interaction Design minor. The idea originated from one of the first programming projects I worked on during the first semester of my first year in Game Development: a Space Invaders clone.
At the time, that project did not go very well. I had very little programming knowledge and relied heavily on tutorials without fully understanding the code behind them. For this reason, I decided to revisit the project as a “redemption project” and use it as an opportunity to measure my growth as a developer.
The game was developed using HTML, CSS, and JavaScript and is hosted through GitHub Pages.
Current Features
- Multiple levels
- Victory after reaching level 5
- Infinite progression
- Enemies increase in speed each level
- Bullets increase in speed each level until level 5
- Player shooting cooldown decreases until level 5
- Four shields with three health points each
- Three player lives
- Start, pause, and restart buttons
- Current score and high score tracking
- Different enemy formations for each level
Goal
The original goal of this project was not only to remake Space Invaders, but also to combine it with physical interaction through a micro controller.
My plan was to create a controller that could react to environmental factors such as movement, light, or shadows. These inputs would influence gameplay and create a connection between physical interaction and a digital game experience.
By doing this, I wanted to connect my Game Development background with concepts from Urban Interaction Design. The project would explore how physical environments can influence digital experiences through interactive technology.
At the same time, I wanted to create a significantly better version of Space Invaders than the one I built during my first year and improve my programming skills by working independently rather than relying entirely on tutorials.
Press the icon on the right for the code
Development Process
The project started with recreating the basic gameplay loop of Space Invaders. Initially, I followed several tutorials to rebuild the fundamental mechanics.
However, I quickly discovered a problem. Although I understood what the code was doing, I struggled to modify it or add new functionality myself. This made me realise that following tutorials from start to finish is not the same as understanding how a system works.
From that point onwards, I started researching solutions independently, experimenting with different implementations, and modifying systems myself. This allowed me to gain a much deeper understanding of JavaScript and game logic.
As development progressed, I expanded the game beyond the original tutorial implementation by adding:
- Multiple levels
- Different enemy formations
- Progressive difficulty scaling
- Score tracking
- Improved gameplay balancing
- Pause and restart functionality
These additions transformed the project from a basic clone into a more complete game experience.
Challenges and Setbacks
One of the biggest challenges was the micro integration.
After spending roughly a day researching and experimenting with connections between the micro and the browser, I realised that implementing the controller properly would take significantly more time than expected. Continuing with this feature would likely prevent me from finishing the game itself.
Because of this, I made the decision to remove the micro component from this project and focus entirely on creating the best possible gameplay experience.
Although the controller was not included in the final version of Space Invaders, I was still able to apply my micro knowledge later during our final Urban Interaction Design project, where we used micro as a simulation tool for our interactive wind chime concept.
Another challenge was maintaining focus throughout the semester.
As the minor progressed, my attention shifted towards completing learning outcomes, portfolio work, and final project deliverables. As a result, this project remained untouched for over a week at one point.
Returning to the project afterwards was surprisingly difficult. I found myself procrastinating and struggling to regain momentum.
To overcome this, I reached out to Gijs, my future semester mentor, and asked for a small development task to help me get back into programming. This turned out to be exactly what I needed to rebuild motivation and continue working on the project.
Feedback
Feedback from Gijs
After reviewing the project, Gijs noted that the game was already significantly better than my original first-year version.
His main feedback was that future projects should be developed in Unity rather than HTML, CSS, and JavaScript. Since my goal is to become a game developer, Unity better reflects industry workflows and allows me to learn more relevant development practices.
He also encouraged me to explore:
- State Machines
- Scriptable Objects
- Global Events
- Actions and Unity Events
- Better object-oriented programming practices
Feedback from Teachers
The teachers suggested adding more progression to the game so that players would continue playing after clearing the first enemy wave.
As a result, I implemented multiple levels and a victory condition after level 5, while still allowing the game to continue indefinitely.
I also improved the enemy layouts between levels. Instead of always displaying identical formations, later levels now contain variations in enemy placement and appearance, making progression feel more dynamic.
Final Outcome
Although the project evolved differently than originally planned, I successfully created a complete Space Invaders remake with several improvements compared to my first-year version.
The final game includes:
- Multiple enemy formations
- Difficulty progression
- Shield mechanics
- Score tracking
- Level progression
- Win conditions
- Improved gameplay balancing
More importantly, the project helped me better understand how games are structured and how gameplay systems interact with one another.
It also taught me how to move away from purely tutorial-based learning and become more comfortable solving programming problems independently.
Additional Unity Assignment
To help me improve my development skills, Gijs gave me a separate Unity assignment.
Assignment
Create a small 3D arena where enemies continuously spawn and attack a stationary player.
Requirements included:
- Two enemy types (melee and ranged)
- Scriptable Objects for enemy configuration
- A C# State Machine using interfaces
- State Machine implemented without MonoBehaviour
- Health system using TMPro
- Different enemy attack behaviours
- Random spawning around the arena
My Approach
Before writing any code, I created a development plan and broke the assignment into smaller tasks.
I listed everything that needed to be implemented and continuously updated my notes while working. Features that were completed were crossed off, while unfinished features received additional notes explaining possible solutions.
This structured approach made development much easier and prevented me from becoming overwhelmed by the assignment.
Feedback
The following day, Gijs reviewed my implementation.
Overall, he was positive about the code structure and encouraged me to continue developing the project when I have more time.
During the review, he explained several important concepts used in professional game development, including:
- State Machines
- Scriptable Objects
- Global Events
- Singletons
- Actions
- Structs
- Enums
- Early Returns
This discussion gave me a much better understanding of how professional projects are organised and what skills I should continue developing.
He also advised me to keep creating small portfolio projects because these are often more valuable to employers than large unfinished projects.
Future Plans
My next step is to recreate Space Invaders in Unity while applying everything I learned from both this project and the Unity assignment.
I want to focus on:
- Object-Oriented Programming
- State Machines
- Scriptable Objects
- Better project architecture
- Cleaner code organisation
During the summer break, I also plan to:
- Continue collaborating with Lars to learn more about his workflow and prepare for a potential internship.
- Contribute design work for a mobile game project.
- Work together with my brother and boyfriend on a fully custom-coded portfolio website instead of using WordPress.
These projects will help me continue developing both my technical and design skills.
Reflection
Looking back on this project, I am happy with the final result, but I also recognise several areas where I could have worked more effectively.
The biggest lesson was learning the difference between following tutorials and truly understanding code. Early in the project, I realised that I could recreate features from tutorials but struggled to modify them independently. Once I started researching solutions myself and experimenting with different approaches, I learned much more and gained confidence as a developer.
Another important lesson was scope management. Although the micro controller was an exciting idea, it became clear that it would require significantly more time than expected. Choosing to remove it was difficult, but it allowed me to complete a polished game rather than an unfinished prototype.
I was also confronted with my own tendency to lose focus during long-term projects. Because I spent so much time working on portfolio tasks and learning outcomes, this project was neglected for a period of time. Rebuilding momentum afterwards was challenging and showed me how important consistency is when working on personal projects.
The feedback from Gijs was particularly valuable because it shifted my focus from simply making games towards understanding how professional game systems are built. Concepts such as State Machines and Scriptable Objects showed me that there is much more to game development than making something work.
Overall, this project demonstrated how much I have grown since my first year. At the same time, it also showed me how much there is still to learn. Rather than seeing that as a weakness, I now view it as motivation for future projects and continued development as a game developer.
Learning Outcome
2.1 The student acquires knowledge from other disciplines and masters methods to develop new work.
Through this project and the additional Unity assignment, I expanded my knowledge of programming, game architecture, and professional development practices. Learning about State Machines, Scriptable Objects, Events, and object-oriented design has given me a stronger foundation for future game projects.
2.3 The student formulates personal learning goals, plans activities around those learning goals, and monitors their own development.
Throughout the process, I continuously adjusted the scope, monitored my progress, reflected on setbacks, and actively sought feedback to support my development as a game developer.
