High-Performance gamedev techniques

// ── Minimal ECS World ───────────────────────────────
class World {
  constructor() {
    this.nextId     = 0;
    this.components = new Map();  // Map<type, Map<entityId, data>>
    this.systems    = [];
  }

  createEntity() { return this.nextId++; }

  addComponent(entity, type, data) {
    if (!this.components.has(type))
      this.components.set(type, new Map());
    this.components.get(type).set(entity, data);
  }

  query(...types) {
    // Return entity IDs that own ALL requested component types
    const [first, ...rest] = types;
    const candidates = [...(this.components.get(first)?.keys() ?? [])];
    return candidates.filter(id =>
      rest.every(t => this.components.get(t)?.has(id))
    );
  }

  get(entity, type) {
    return this.components.get(type)?.get(entity);
  }

  tick(dt) {
    for (const system of this.systems) system(dt, this);
  }
}

// ── Systems are plain functions ──────────────────────
const MovementSystem = (dt, world) => {
  for (const id of world.query('Position', 'Velocity')) {
    const pos = world.get(id, 'Position');
    const vel = world.get(id, 'Velocity');
    pos.x += vel.x * dt;
    pos.y += vel.y * dt;
  }
};

// ── Scene setup ─────────────────────────────────────
const world = new World();
world.systems.push(MovementSystem);

const player = world.createEntity();
world.addComponent(player, 'Position', { x: 0, y: 0 });
world.addComponent(player, 'Velocity', { x: 120, y: 0 });
world.addComponent(player, 'Sprite',   { sheet: 'player.png' });

class ObjectPool {
  constructor(factory, initialSize = 64) {
    this.factory  = factory;
    this.free     = [];
    this.active   = new Set();

    // Pre-warm the pool
    for (let i = 0; i < initialSize; i++)
      this.free.push(this.factory());
  }

  acquire() {
    const obj = this.free.pop() ?? this.factory(); // grow if empty
    this.active.add(obj);
    return obj;
  }

  release(obj) {
    if (!this.active.has(obj)) return;
    obj.reset();
    this.active.delete(obj);
    this.free.push(obj);
  }

  releaseAll() {
    for (const obj of this.active) this.release(obj);
  }
}

// ── Bullet factory ──────────────────────────────────
const bulletPool = new ObjectPool(() => ({
  x: 0, y: 0, vx: 0, vy: 0,
  damage: 0, active: false,
  reset() {
    this.x = this.y = this.vx = this.vy = 0;
    this.active = false;
  }
}), 256);

// ── Usage inside the game loop ───────────────────────
function fireBullet(x, y, angle, spd) {
  const b  = bulletPool.acquire();
  b.x      = x;
  b.y      = y;
  b.vx     = Math.cos(angle) * spd;
  b.vy     = Math.sin(angle) * spd;
  b.active = true;
  b.damage = 10;
}

function updateBullets(dt) {
  for (const b of bulletPool.active) {
    b.x += b.vx * dt;
    b.y += b.vy * dt;
    if (isOffScreen(b)) bulletPool.release(b);
  }
}

// ── Raw prototypal style (explicit) ────────────────
const gameObjectProto = {
  update(dt) { /* base tick */ },
  destroy()  { this.active = false; }
};

const entityProto = Object.create(gameObjectProto);
entityProto.move = function(dx, dy) {
  this.x += dx; this.y += dy;
};

// ── Factory: no `new`, no class keyword ─────────────
function createPlayer(x, y) {
  const player = Object.create(entityProto);
  player.x      = x;
  player.y      = y;
  player.hp     = 100;
  player.active = true;

  player.jump = function() {
    this.vy = -400;
  };

  return player;
}

// ── Mixin for shared behaviours ──────────────────────
const damageable = {
  takeDamage(amount) {
    this.hp -= amount;
    if (this.hp <= 0) this.destroy();
  }
};

const shieldable = {
  takeDamage(amount) {
    const blocked = Math.min(this.shield, amount);
    this.shield -= blocked;
    damageable.takeDamage.call(this, amount - blocked);
  }
};

// Apply mixin at runtime
Object.assign(entityProto, damageable);

// Upgrade specific instance
const boss = createPlayer(512, 300);
Object.assign(boss, shieldable, { hp: 1000, shield: 250 });

// ── Class syntax (same prototype wiring, cleaner) ───
class Bullet extends GameObject {
  constructor(x, y, vx, vy) {
    super(x, y);
    this.vx = vx; this.vy = vy;
  }

  update(dt) {
    this.x += this.vx * dt;
    this.y += this.vy * dt;
    if (isOffScreen(this)) this.destroy();
  }
}