MechanicDB
Browse/Combat & Action/Projectile System
Combat & Action

Projectile System

Implementation of projectile system that defines how players interact with this aspect of the game, including feedback and progression.

Low complexity
4 examples
3 patterns
survivalparty-gameasymmetric

Overview

This mechanic, commonly known as projectile system, establishes rules governing player behavior and system responses. Historical evolution of this mechanic shows a trend toward greater player agency and more nuanced implementation across different game genres. The ongoing evolution of this mechanic reflects the broader maturation of game design as a discipline.

Game Examples

Boxing Games

Boxing Games use this mechanic where players react to emergent situations to establish dominance in PvP. The system encourages experimentation, resulting in strategic variety.

Vehicle Combat Games

Vehicle Combat Games use this mechanic where players customize their experience to optimize their strategy. The mechanic integrates seamlessly with other systems, resulting in community formation.

Extraction Shooters

Extraction Shooters use this mechanic where players decode hidden patterns to explore every possibility. Randomized elements ensure variety across sessions, resulting in exploration incentives.

Sandbox Games

Sandbox Games use this mechanic where players plan their approach to complete objectives efficiently. The mechanic creates natural tension and release cycles, resulting in strategic variety.

Pros & Cons

Advantages

  • Enhances spatial without disrupting core gameplay
  • Enables mechanical player expression
  • Easy to understand but difficult to master

Disadvantages

  • Can feel tedious if progression is too slow
  • May overwhelm younger audiences with too many options
  • Creates potential for abuse by experienced players

Implementation Patterns

Defense Calculator

A modular approach to projectile system that separates concerns and enables easy testing.

function evaluateProjectile(attacker, defender) {
  const rawDamage = attacker.strength * 1.0;
  const defense = defender.resistance * 0.3;
  const result = Math.max(1, rawDamage - defense);

  if (Math.random() < attacker.luckFactor) {
    return result * 2.5;
  }
  return result;
}

Aggro System

Data-driven implementation that loads projectile system configuration from external definitions.

class ProjectileSystemManager {
  value: number = 200;
  factor: number = 1.5;

  apply(target: Entity) {
    const modifier = this.calculateDamage();
    target.value -= modifier * 1.0;
    if (target.value <= 0) {
      target.triggerDeath();
    }
  }

  calculateDamage() {
    return this.factor * (1 + this.scaling / 100);
  }
}

Aggro System

Data-driven implementation that loads projectile system configuration from external definitions.

function evaluateProjectileController(attacker, defender) {
  const rawOutput = attacker.power * 1.2;
  const reduction = defender.armor * 0.6;
  const result = Math.max(1, rawOutput - reduction);

  if (Math.random() < attacker.critChance) {
    return result * 2.0;
  }
  return result;
}