Skullgun – Top-Down Shooter

Introduction

Skullgun is a Unity-based top-down shooter developed as a demonstration of proficiency in core game development principles, including gameplay programming, system design, and production workflows. The project’s aim was to build a compact but engaging arcade-style experience focused on survival, responsiveness, and flow.

In Skullgun, the player controls a lone character armed with an auto-firing weapon, tasked with surviving as long as possible against continuous waves of enemies. Each wave escalates the difficulty by increasing enemy count and aggression, creating a tight gameplay loop centered on quick decision-making and spatial awareness.

The game was developed independently as a showcase of my ability to design, implement, and polish gameplay systems using Unity’s 2D framework and C#. It also served as an exploration of iterative development and how simple mechanics can deliver replayable, high-tempo action when tuned carefully.

Concept and Design Philosophy

The concept of Skullgun emerged from the desire to explore how minimalist mechanics can produce compelling gameplay through tight controls, reactive feedback, and balanced progression. Instead of emphasizing complex systems or visuals, the focus was on feel, flow, and player clarity.

Design Goals:

• Immediate Playability: Quick sessions with minimal setup — “jump in and play” design.
• Endless Challenge: Progressive difficulty through enemy scaling rather than fixed levels.
• Fluid Controls: Responsive player movement optimized for keyboard input.
• Simple Core Loop: Move, dodge, and survive — creating sustained tension and engagement.
• Polished Feedback: Clear hit effects, readable enemy behavior, and dynamic difficulty pacing.

The game takes inspiration from classic arcade shooters and modern minimalist survival titles like Vampire Survivors and Geometry Wars, but with a personal twist emphasizing control responsiveness and gameplay rhythm.

Development Process

3.1 Project Setup

The development began in Unity using a 2D top-down template. The player, enemies, bullets, and environmental boundaries were implemented using simple sprite-based assets. Initial focus was placed on establishing the core movement and shooting mechanics before expanding into wave management and difficulty progression.

Early prototyping involved testing different camera scales, movement speeds, and bullet fire rates to find a balance between control precision and visual clarity. Once the base mechanics felt satisfying, secondary systems such as scoring, wave management, and UI were layered on top.

3.2 Core Gameplay Systems

1. Player Movement and Controls The player character uses a dual-axis input system for movement, driven by Unity’s Input.GetAxisRaw() method for smooth and responsive directional control. Movement speed and acceleration were fine-tuned to create a sense of fluid motion without inertia, ensuring immediate responsiveness during combat.
2. Auto-Firing Weapon System The shooting system operates automatically at a fixed rate, eliminating manual aiming or firing to maintain constant action. The bullets are instantiated at timed intervals and move forward along the player’s facing direction. Each projectile includes collision detection to destroy enemies upon contact. This design decision simplified input while amplifying focus on positioning and survival, making gameplay more about strategy in movement than precision shooting.
3. Enemy AI and Wave System Enemies spawn in waves around the perimeter of the play area, moving toward the player’s position using simple steering behavior. Each wave incrementally increases: - The number of spawned enemies. - Their movement speed and aggression radius. A central WaveManager script controls the progression logic, automatically triggering new waves after the previous one is cleared. This creates an endless survival loop where tension builds naturally as the player endures longer sessions.
4. Scoring and Progression The scoring system is time- and kill-based. Each defeated enemy contributes to the score, encouraging continuous engagement. There are no level breaks or menus between waves — maintaining uninterrupted momentum.

Technical Implementation

4.1 System Architecture

The project was structured using modular, object-oriented scripts for maintainability:

• PlayerController – Handles player input, movement, and facing direction.
• WeaponSystem – Manages projectile spawning and firing rate.
• EnemyAI – Controls enemy pathfinding and attack behaviors.
• WaveManager – Spawns enemies and tracks game progression.
• GameManager – Oversees scoring, state transitions, and restarts.

Each component interacted through controlled public interfaces, reducing dependency and simplifying debugging.

4.2 Enemy Behavior and Pathfinding

Enemy movement was implemented using a straightforward vector-based approach rather than Unity’s full NavMesh system to maintain performance and simplicity. Enemies continuously calculate a direction vector toward the player and adjust their velocity accordingly.

To avoid clustering and maintain visual clarity, a minor random offset was applied to movement vectors, producing slightly organic movement patterns without introducing full AI complexity.

4.3 Projectile and Collision Logic

Projectiles used Rigidbody2D components with OnTriggerEnter2D() detection to handle hits. Upon collision with an enemy, the bullet is destroyed, and the enemy’s health is reduced or removed. To prevent overdraw and memory buildup, a simple object pooling system was introduced, reusing inactive bullet instances rather than instantiating new ones each time.

This approach significantly improved runtime efficiency and reduced garbage collection spikes — particularly noticeable during higher enemy counts.

4.4 Game Loop and Difficulty Scaling

The game operates under a simple yet robust loop:

• Spawn new enemies according to the current wave number.
• Allow the player to fight until all enemies are destroyed.
• Increase wave number and repeat.

Difficulty progression is controlled through a linear scaling curve, modifying spawn count and movement speed based on wave index. These adjustments were carefully tuned to create a gradual increase in tension without sudden difficulty spikes.

4.5 UI and Feedback Systems

The user interface displays the current wave, player score, and survival time. Hit feedback is conveyed through:

• Flash effects on enemy damage.
• Brief screen shake upon player hit.
• Subtle particle bursts on enemy death.

These feedback layers were implemented to enhance player immersion and reward moment-to-moment actions without cluttering the visual field.

Challenges and Problem-Solving

5.1 Balancing Difficulty Curves

Initial testing revealed inconsistent pacing — early waves were too slow, while later waves became nearly impossible. By introducing incremental scaling functions and fine-tuning enemy spawn intervals, the game achieved a smoother difficulty progression that maintained engagement without overwhelming the player.

5.2 Performance Optimization

During prolonged sessions, performance dropped due to excessive object instantiation. Implementing object pooling for bullets and enemies reduced frame stutter and ensured stability even in late-game waves.

5.3 Maintaining Gameplay Readability

As enemy counts increased, visual clutter risked obscuring the player. Adjustments to color contrast, sprite scaling, and hit effects improved readability, helping players navigate chaos without confusion.

Iteration and Testing

Testing was iterative and feedback-driven. Each new build focused on a specific refinement goal — for instance:

• Build 1: Core movement and shooting feedback.
• Build 2: Wave system and scaling.
• Build 3: Visual feedback, effects, and optimization.

Playtesting emphasized feel — how satisfying movement, shooting, and survival felt over short sessions. Observations guided incremental changes to firing rate, enemy spawn frequency, and camera boundaries.

This iterative workflow mirrored real-world production methodology: small, testable improvements layered over a solid foundation.

Final Outcome

The finished version of Skullgun delivers an engaging, fast-paced survival shooter experience characterized by:

• Smooth and responsive movement.
• Endless wave progression and adaptive challenge.
• Visually clear and rewarding combat feedback.
• Stable performance across sessions.

Though minimalist by design, Skullgun achieves depth through pacing, control precision, and iteration-driven refinement — proving that simplicity, when executed thoughtfully, can yield compelling gameplay.

Insights and Lessons Learned

Developing Skullgun reinforced several important lessons about designing and implementing action-based gameplay:

• Player Feel Is Paramount: Technical correctness matters less than how the game feels. Responsiveness and feedback define player satisfaction.
• Small Systems, Strong Core: A simple, solid gameplay loop offers far more longevity than numerous underdeveloped features.
• Iterative Development Works: Frequent testing and small adjustments yield higher-quality results than large, infrequent overhauls.
• Optimization Early Saves Time: Object pooling and minimal physics complexity ensured scalability and smooth performance from the start.

These takeaways extend beyond this project, influencing how I approach system design, testing, and player experience in future games.

Future Improvements

Potential directions for future development include:

• Power-Up System: Introducing collectible upgrades (e.g., speed boosts, spread shots).
• Enemy Variety: Adding ranged enemies or mini-bosses to diversify combat flow.
• Procedural Arenas: Randomized environments to enhance replay value.
• Audio and Sound Design: Integrating adaptive music and dynamic sound cues to reinforce intensity.
• Leaderboards: Tracking high scores to encourage competition.

These enhancements would expand gameplay depth while maintaining the project’s minimalist identity.

Conclusion

Skullgun – Top-Down Shooter exemplifies the effectiveness of focused design and disciplined iteration in game development. Built in Unity using straightforward systems, it demonstrates strong technical execution, clean architectural thinking, and a refined understanding of player experience.

The project not only achieved its objective as a proof of proficiency in game programming and design but also deepened my appreciation for balancing simplicity with depth. Through its creation, I honed my ability to design scalable systems, optimize gameplay flow, and approach creative challenges through structured, iterative problem-solving.

Ultimately, Skullgun stands as a testament to how minimalism, responsiveness, and thoughtful iteration can combine to produce engaging, replayable gameplay experiences.