Game Design Document

Game Design Document (Version 1.0)

1. Executive Summary

Game Title: Echo Kill

Genre: 2D Top-Down Shooter

Target Audience:

  • Fans of fast-paced, high-difficulty action games (e.g., Hotline Miami, My Friend Pedro).

  • Players who enjoy skill-based, tactical shooting mechanics.

Project Scope:

  • A small game with tight combat mechanics and replayability.

  • Focus on player skill, and fast-paced action.

  • Developed in Unity (2D), targeting the VIA Arcade Machine initially.

2. Gameplay

Objectives:

  • The player must eliminate all enemies in a level using a mix of shooting, melee, and movement mechanics. Might add a multiplayer 1vs1.

  • Survive without getting hit (one shot = death).

  • Master bullet bouncing to eliminate enemies in creative ways.

Game Progression:

  • Levels are short but challenging, with increasing difficulty.

  • Each level introduces new enemy types, obstacles, and layouts.

  • Scoring system based on style (how many times the bullet bounce before killing an enemy), and the speed the level is finished.

  • Replayability through ranking, speedruns, and alternate strategies. For the multiplayer, a ranked system would be great.

In-Game GUI:

  • Minimal UI (health is unnecessary due to one-hit kill mechanics).

  • Ammo counter for each weapon.

  • Kill feed & combo meter for style-based scoring.

3. Mechanics

Core Combat System:

  • Twin-stick shooting (move with one stick, aim with the other). That's the main plan, but it still needs to be further discussed due to the VIA Arcade Machine limitations.

  • Bullets bounce up to 3 times (depending on the weapon) before disappearing.

  • Player can die from their own bullets if not careful.

  • Melee attack for close-range combat and deflecting bullets.

  • Dodge roll (invincibility frames) for avoiding bullets.

  • Weapon variety (pistols, shotguns, machine-guns and grenades).

Physics & Interactions:

  • Bullet physics (angles, bouncing behavior, destructible surfaces).

  • Knockback mechanics for certain weapons (like the shotgun).

  • Interactive objects (breakable glass, explosive barrels, doors).

4. Game Elements

World & Setting:

  • The game is set in a modern-era environment, using "realistic" locations such as houses, warehouses, and offices.

Characters:

  • The Player: A skilled assassin trapped in a deadly underground operation.

  • Enemies: Different enemy types with varied behavior (rushing, dodging, sniping, shielding).

Level Design:

  • Short, action-packed levels with strategic cover and bounce opportunities.

  • Encourages creative problem-solving with bullets & positioning.

  • Multiple ways to clear a level (aggressive vs. tactical playstyles).

5. Assets

Visuals:

  • Using a free Kenney asset pack for a top-down shooter. (https://kenney.nl/assets/top-down-shooter)




  • Modern-era setting with clean, readable visuals.

  • Simple but effective character and environment sprites.

Audio:

  • Realistic gunfire and impact sounds to enhance immersion.

  • Tense, action-oriented music (maybe electronic) to match the fast-paced gameplay.

  • Audio feedback for ricocheted bullets to warn the player.

6. Milestones

  1. Core Gameplay Prototype: Basic movement, shooting and ricochet system (Core mechanics basically).

  2. Expanded Mechanics & UI logic: Implementing enemy AI, multiple enemy types and UI.

  3. Level implementation, Polish & Final Testing: Implementing levels, refining mechanics and bugs, balancing difficulty, optimizing performance, and adding final improvements (sounds, animations, etc).

This document will be updated as development progresses.

Comentarios

Publicar un comentario

Entradas populares de este blog

Enemy AIs, UI logic and Adjusting Weapons Architecture

Imagen
NavMesh 2D, Changing Weapon's Architecture, and Implementing first UI For this blog post, I started by cleaning up the weapon system, then gave the enemies some actual AI, and implemented a Pause Menu. A Cleaner Way to Handle Guns At first, the weapons were just hardcoded actions. One script, one gun. But that wouldn’t scale, and it was starting to get messy. I was having some other problems as well, specially when grabbing and dropping the gun, because (for some reason), clones of the GameObject were being created instead of using the original. So I decided to restructure it using an abstract class called "GunBase". Every weapon now inherits from it and implements its own "Shoot()" method and other characteristics a weapon has (ammo, icon, audio, etc). For example, the pistol and machine gun now share the same structure but behave differently (semi-auto vs. full-auto). There’s also built-in logic for ammo, bullet speed, and reloading.  This approach makes i...
Leer más

Core Gameplay Prototype

Imagen
Introduction So far, I’ve been building the foundation of the game by getting the core gameplay running: movement, shooting, and bullet ricochets. These mechanics define the entire feel of the game, so I wanted to make sure I nailed the basics before diving into level design or AI. Movement & Rotation I started by implementing 2D movement using Unity’s new Input System. The player can move using a joystick or keys, and optionally rotate toward the aim direction (in my current setup, that’s the mouse). A key aspect of the experience is that the player always faces where they’re aiming or moving, which makes the action feel more responsive. If you’re holding the "aim" button, the character rotates toward the cursor. Otherwise, the player rotates automatically based on movement direction. Shooting System & Bullet Behavior Next came the shooting system. Once the player picks up a gun, they can shoot in their current facing direction. Bullets are instantiated slightly ahea...
Leer más

Final Game and Conclusion

Imagen
What I Built and How I Did It Throughout the development process, I got to work across nearly every Unity system: Scripting : I wrote dozens of custom scripts using to manage weapons, enemies, player controls, pickups, and more. I also used coroutines for actions like rolling invulnerability or UI transitions, and relied on Unity events to communicate between systems (like triggering win conditions when all enemies are dead).  Input & Vectors : I implemented the new Input System , allowing for both keyboard and arcade stick integration. Movement and aiming are handled using vectors to rotate the player or calculate bullet direction with precision. Physics : All movement and combat use Unity’s 2D physics engine . I configured rigidbodies , colliders , and triggers to manage everything from bullet impacts to object pushing. Careful layer setup and tag filtering helped prevent unwanted collisions (like enemies accidentally killing each other). Graphics & Audi...
Leer más