Game Development · Processing & Java · Procedural VFX
Overview: Spaceone is a 2D space shooter mini game where the player controls a spaceship, dodges enemy movement, fires projectiles, destroys waves of debris, and survives a final alien ship boss attack. Built in Processing with Java, it was my first complete game project that I coded entirely by myself.
Before Spaceone, my game work was mostly focused on art direction, visual effects, and asset creation. This project became the point where I began translating those visual instincts into code. Instead of using PNG sprites or premade art assets, I used simple geometry, motion, collision feedback, timers, and object-oriented programming to create a playable arcade experience with clear visual impact.
This is a compact project rather than a large production game, but it is a meaningful one. It marks my transition from being primarily an artist into someone who could build interactive systems, game feel, and procedural visual effects through code alone.
This browser-playable version recreates my original Processing / Java project as a p5.js web build for portfolio viewing. Visitors can experience the core game feel directly in the browser, including mouse aiming, projectile trails, collision feedback, screen shake, debris explosions, injured-state feedback, and the final boss encounter.
Best experienced on desktop. Click inside the game window before using keyboard controls.
Solo Developer, Gameplay Programmer, Visual Effects Designer
2021
Solo 2D mini game
The main challenge was creating a game that felt fun and visually satisfying without relying on illustrated sprites, textures, or external art assets. Because the game was built almost entirely from basic shapes, every feeling of impact had to come from motion and feedback.
How projectiles travelled, how enemies reacted when hit, how objects exploded, how the player shook when damaged, and how the boss visually stood apart from smaller enemies all had to be solved through code. The goal was not to make the most complex shooter, but to make a simple game feel alive through timing, motion, and interaction.
This was also a personal challenge. Coming from an art and VFX background, I had to translate visual instincts into programming logic: vectors, collision checks, timers, arrays, and object classes. Spaceone was where that translation first clicked.
Spaceone uses a minimal geometric visual language. The player is represented with circular forms and a directional cannon, while enemies are represented with rotating square forms. This contrast created an immediate visual distinction between the player and hostile objects.
The boss was designed to feel heavier and more intimidating through larger layered square shapes, stronger color contrast, and a more dominant screen presence. Even without detailed character art, the boss needed to communicate danger through scale, rhythm, and projectile behavior.
The visual system was built from:
A major focus of Spaceone was using motion to make interactions feel impactful. Projectiles are not just static bullets. They leave short geometric tails behind them, built from repeated shape positions, creating a sense of speed and direction.
When a projectile hits an enemy, it triggers a debris effect where smaller square fragments spread outward, rotate, slow down, and fade over time. Damage feedback was also designed through motion: when the player is hit, the ship briefly shakes and flashes red, making the injured state immediately readable. Enemies also shake when damaged, giving each hit a stronger physical response.
These small feedback systems made the game feel more responsive and satisfying, even though the visuals were created only from simple shapes. Game feel, I learned, comes from the relationship between input, response, timing, and motion, not from art quality alone.
Player control: The player moves using keyboard input and aims toward the mouse position. Movement is driven through acceleration and damping, giving the ship a smoother arcade-like feel instead of instant stop-and-go movement.
Projectile system: The player fires projectiles toward the mouse cursor. Each projectile stores its position, angle, speed, rotation, tail history, collision state, and destruction timer.
Enemy system: Enemies spawn with randomized positions, health values, movement directions, and rotation speeds. They bounce off each other and react to player collisions.
Health and score: The player has limited health, and score increases when enemies are hit. Difficulty rises as the score grows, gradually increasing enemy speed.
Boss phase: After the enemy wave is cleared, the game enters a warning phase before spawning the boss. The boss uses a larger body, a stronger presence, and multiple projectile behaviors, including fast direct shots and slower spreading attacks.
Game states: The project includes a main menu, level gameplay, boss battle, win state, loss state, pause, and restart.
Spaceone was structured using object-oriented programming. Instead of writing every behavior in one place, I separated the game into classes such as Player, Enemy, BossEnemy, Projectile, BossProjectile, Debris, Score, and Crosshair.
This helped me understand how objects can manage their own movement, collision, drawing, health, animation timers, and visual effects. It was one of my first practical experiences with OOP, and it built a stronger foundation for my later Unity and C# game development.
A key part of the implementation was using timers to control visual feedback. Damage flashing, invincibility, projectile destruction, debris fading, death animations, and boss warning effects all rely on countdown-based logic. This let me create layered visual effects without an animation timeline or external assets.
Core classes:
Spaceone taught me how to think like both a designer and a programmer. As a visual designer, I focused on readability, contrast, impact, and rhythm. As a programmer, I had to translate those ideas into systems: vectors, collision checks, timers, arrays, object classes, and state management.
This project helped me understand that game feel is not only about art quality. It comes from the relationship between input, response, timing, motion, and feedback. Even simple shapes can feel exciting when the interaction is clear and the feedback is strong.
Spaceone became an important foundation for my later work in technical art and gameplay development, especially in areas like VFX, procedural animation, collision feedback, and player-facing interaction systems.
Although Spaceone is a small project, it represents an important step in my growth as a game developer. It was my first fully self-coded game, my first deeper experience with Java and object-oriented programming, and one of the first times I created a complete gameplay experience through code alone.
The project demonstrates my ability to create visual impact without relying on premade assets, build interactive systems from scratch, and use motion design to make a simple 2D shooter feel fun, responsive, and satisfying.
More than the game itself, Spaceone marks the moment my art and VFX instincts started becoming code. That transition is the foundation everything in my technical art and gameplay work has been built on since.