Back to Gem Warden
SOURCE / PINNED RELEASE

Made of little things.

Gem Warden

Release
7c457bfe5427…
Author-recorded commit
fb5453b5fc06…
License
LICENSE
Author’s source reference
nostr://npub1eg5pfnws6tg6rtp33tugpppqtv5u05crmf983qp438cdycwzngys0gxzcs/wss%3A%2F%2Fgit.napplet.soy%2F/n-3929629ef1d

Archive hash verified: 895b8dd430aad9fe…. The source-to-build association is the author’s claim; it has not been independently rebuilt.

src/game.ts
// Pure game state and rules. No DOM access, so the headless balance test can
// drive it from Node with the same code the napplet renders.

export const COLS = 22;
export const ROWS = 14;

export const COLORS = ['red', 'orange', 'yellow', 'green', 'blue', 'purple'] as const;
export type GemColor = (typeof COLORS)[number];

export const COLOR_INFO: Record<GemColor, { name: string; hex: string; special: string; short: string }> = {
  red: { name: 'Ruby', hex: '#ff4a4a', special: 'Splash damage around the target', short: 'Splash' },
  orange: { name: 'Amber', hex: '#ff9a2e', special: 'Leeches mana on every hit', short: 'Mana leech' },
  yellow: { name: 'Topaz', hex: '#ffe14d', special: 'Critical hits', short: 'Crits' },
  green: { name: 'Jade', hex: '#4fe06a', special: 'Poison damage over time', short: 'Poison' },
  blue: { name: 'Sapphire', hex: '#4aa8ff', special: 'Slows monsters', short: 'Slow' },
  purple: { name: 'Amethyst', hex: '#c06bff', special: 'Tears away armor', short: 'Armor tear' },
};

export interface Gem {
  id: number;
  /** Combined worth in grade-1 gems. Grade is floor(log2(mass)) + 1. */
  mass: number;
  comp: Partial<Record<GemColor, number>>;
  kills: number;
}

export type StructKind = 'tower' | 'trap';
export interface Structure {
  id: number;
  kind: StructKind;
  x: number;
  y: number;
  gem: Gem | null;
  cooldown: number;
  aim: number;
}

export type MonsterType = 'crawler' | 'swarm' | 'brute' | 'giant' | 'runner' | 'warded' | 'mender';

/** What each monster is and which gems answer it, for the hover card. */
export const MONSTER_INFO: Record<MonsterType, { name: string; trait: string; counter: string }> = {
  crawler: { name: 'Crawler', trait: 'Plain and steady', counter: 'Anything' },
  swarm: { name: 'Swarm', trait: 'Many small ones, close together', counter: 'Ruby splash' },
  brute: { name: 'Brute', trait: 'Heavy armour blunts every hit', counter: 'Amethyst, jade' },
  giant: { name: 'Giant', trait: 'Huge health, slow', counter: 'Topaz crits, big gems' },
  runner: { name: 'Runner', trait: 'Twice as fast', counter: 'Sapphire slow' },
  warded: { name: 'Warded', trait: 'Each ward charge eats one hit', counter: 'Ruby splash, traps' },
  mender: { name: 'Mender', trait: 'Heals itself unless poisoned', counter: 'Jade poison' },
};
export interface Monster {
  id: number;
  type: MonsterType;
  dist: number;
  hp: number;
  maxHp: number;
  armor: number;
  speed: number;
  slowF: number;
  slowT: number;
  poisonDps: number;
  poisonT: number;
  /** Hits a ward still absorbs completely. */
  ward: number;
  /** Health regained per second while not poisoned. */
  regen: number;
  mana: number;
  wobble: number;
  x: number;
  y: number;
}

export interface Shot {
  from: Structure;
  target: Monster;
  x: number;
  y: number;
  color: string;
}

export interface WaveDef {
  type: MonsterType;
  count: number;
  hp: number;
  armor: number;
  speed: number;
  interval: number;
  ward?: number;
  regen?: number;
}

export interface FieldDef {
  name: string;
  path: [number, number][];
  waves: number;
  colors: GemColor[];
  rocks: [number, number][];
}

export const FIELDS: FieldDef[] = [
  {
    name: 'Mossy Hollow',
    path: [[0, 2], [6, 2], [6, 11], [14, 11], [14, 4], [19, 4], [19, 9]],
    waves: 10,
    colors: ['red', 'yellow'],
    rocks: [[2, 7], [10, 6], [17, 12], [21, 1], [11, 1]],
  },
  {
    name: 'Ravine of Echoes',
    path: [[0, 7], [4, 7], [4, 1], [10, 1], [10, 12], [16, 12], [16, 6], [20, 6]],
    waves: 12,
    colors: ['red', 'yellow', 'blue'],
    rocks: [[1, 2], [7, 5], [13, 3], [19, 11], [7, 10]],
  },
  {
    name: 'Switchback Pass',
    path: [[0, 1], [18, 1], [18, 4], [3, 4], [3, 8], [18, 8], [18, 12], [10, 12]],
    waves: 14,
    colors: ['red', 'yellow', 'blue', 'green'],
    rocks: [[20, 6], [1, 11], [8, 10], [13, 6], [21, 13]],
  },
  {
    name: 'Coiled Serpent',
    path: [[0, 1], [20, 1], [20, 12], [2, 12], [2, 4], [16, 4], [16, 9], [7, 9]],
    waves: 16,
    colors: ['red', 'yellow', 'green', 'blue', 'purple'],
    rocks: [[10, 6], [12, 7], [5, 7], [18, 7], [21, 13]],
  },
  {
    name: 'Crossroads',
    path: [[0, 6], [15, 6], [15, 1], [8, 1], [8, 12], [19, 12], [19, 3]],
    waves: 18,
    colors: [...COLORS],
    rocks: [[3, 2], [3, 10], [12, 9], [21, 7], [17, 8]],
  },
  {
    name: 'The Gauntlet',
    path: [[0, 10], [9, 10], [9, 3], [17, 3], [17, 8], [20, 8]],
    waves: 22,
    colors: [...COLORS],
    rocks: [[4, 5], [13, 6], [13, 12], [20, 1], [2, 13]],
  },
];

export type GemRef = { kind: 'inv'; index: number } | { kind: 'struct'; id: number };

export type GameEvent =
  | { type: 'hit'; x: number; y: number; color: string; crit: boolean }
  | { type: 'kill'; x: number; y: number; mana: number }
  | { type: 'banish'; x: number; y: number; cost: number; monster: MonsterType }
  | { type: 'build'; x: number; y: number }
  | { type: 'combine'; grade: number }
  | { type: 'wave'; index: number }
  | { type: 'error'; message: string };

export const INVENTORY_SIZE = 12;

export interface Game {
  fieldIndex: number;
  field: FieldDef;
  pathTiles: Set<string>;
  pathPoints: [number, number][];
  pathLength: number;
  orb: [number, number];
  mana: number;
  manaCap: number;
  poolLevel: number;
  manaMult: number;
  structures: Structure[];
  inventory: (Gem | null)[];
  monsters: Monster[];
  shots: Shot[];
  waves: WaveDef[];
  nextWave: number;
  waveTimer: number;
  spawnQueue: { def: WaveDef; left: number; timer: number }[];
  time: number;
  banished: number;
  built: number;
  state: 'playing' | 'won' | 'lost';
  events: GameEvent[];
  nextId: number;
  rng: () => number;
  manaGained: number;
}

export const WAVE_GAP = 24;
export const FIRST_WAVE_DELAY = 40;
const GEM_BASE_COST = 80;

export function makeRng(seed: number): () => number {
  let s = seed >>> 0;
  return () => {
    s = (s + 0x6d2b79f5) >>> 0;
    let t = s;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

export function key(x: number, y: number): string {
  return `${x},${y}`;
}

function buildPath(points: [number, number][]): { tiles: Set<string>; length: number } {
  const tiles = new Set<string>();
  let length = 0;
  for (let i = 0; i < points.length - 1; i++) {
    const [ax, ay] = points[i];
    const [bx, by] = points[i + 1];
    const dx = Math.sign(bx - ax);
    const dy = Math.sign(by - ay);
    let x = ax;
    let y = ay;
    tiles.add(key(x, y));
    while (x !== bx || y !== by) {
      x += dx;
      y += dy;
      tiles.add(key(x, y));
    }
    length += Math.abs(bx - ax) + Math.abs(by - ay);
  }
  return { tiles, length };
}

/** Position (tile units, centre of tile = +0.5) at a distance along the path. */
export function pathPos(g: Game, dist: number): [number, number] {
  let d = Math.max(0, dist);
  const pts = g.pathPoints;
  for (let i = 0; i < pts.length - 1; i++) {
    const [ax, ay] = pts[i];
    const [bx, by] = pts[i + 1];
    const seg = Math.abs(bx - ax) + Math.abs(by - ay);
    if (d <= seg) {
      const t = seg === 0 ? 0 : d / seg;
      return [ax + (bx - ax) * t + 0.5, ay + (by - ay) * t + 0.5];
    }
    d -= seg;
  }
  const last = pts[pts.length - 1];
  return [last[0] + 0.5, last[1] + 0.5];
}

/** Long winding paths give towers more shots, so they get tougher monsters. */
const FIELD_HP = [1, 0.7, 1, 1.5, 1.6, 0.8];

/** One wave of a monster type, as it would come at wave w of a field. */
export function waveDef(type: MonsterType, w: number, fieldIndex: number): WaveDef {
  const level = w + fieldIndex * 2.5;
  const baseHp = 9 * Math.pow(1.185, level) * FIELD_HP[fieldIndex];
  // Armour keeps pace with health once monsters get big, so late hits never shrug it off.
  const armor = Math.floor(w * 0.3 + fieldIndex * 0.8 + Math.max(0, baseHp * 0.03 - 4));
  // Brutes get serious once jade (field 3) and amethyst (field 4) can answer them.
  const bruteArmor = baseHp * (fieldIndex >= 2 ? 0.08 : 0.04);
  switch (type) {
    case 'swarm':
      return { type, count: 18 + Math.floor(w * 0.8), hp: baseHp * 0.38, armor: Math.floor(armor * 0.5), speed: 1.45, interval: 0.28 };
    case 'brute':
      return { type, count: 7 + Math.floor(w / 4), hp: baseHp * 1.2, armor: Math.floor(armor + 2 + bruteArmor), speed: 0.8, interval: 0.9 };
    case 'giant':
      return { type, count: 2 + Math.floor((w + fieldIndex) / 6), hp: baseHp * 6.5, armor: Math.floor(armor * 1.5) + 1, speed: 0.55, interval: 2.2 };
    case 'runner':
      return { type, count: 10 + Math.floor(w / 3), hp: baseHp * 0.8, armor: Math.floor(armor * 0.5), speed: 2.1, interval: 0.55 };
    case 'warded':
      return { type, count: 7 + Math.floor(w / 4), hp: baseHp * 0.8, armor, speed: 0.9, interval: 0.8, ward: 2 + Math.floor(level / 4) };
    case 'mender':
      return { type, count: 8 + Math.floor(w / 4), hp: baseHp * 1.3, armor, speed: 0.9, interval: 0.8, regen: 0.04 };
    default:
      return { type, count: 10 + Math.floor(w / 3), hp: baseHp, armor, speed: 1, interval: 0.6 };
  }
}

export function makeWaves(fieldIndex: number, count: number): WaveDef[] {
  const rng = makeRng(1000 + fieldIndex * 77);
  const waves: WaveDef[] = [];
  // Each field adds monsters that one kind of gem answers best.
  const pool: MonsterType[] = ['swarm', 'brute'];
  if (fieldIndex >= 1) pool.push('runner', 'warded');
  if (fieldIndex >= 2) pool.push('mender');
  if (fieldIndex >= 3) pool.push('brute', 'warded');
  let last: MonsterType = 'crawler';
  for (let w = 0; w < count; w++) {
    let type: MonsterType = 'crawler';
    if (w > 0 && (w + 1) % 5 === 0) type = 'giant';
    else if (w >= 2) {
      const avail = pool.filter((t) => t !== last && (t !== 'brute' || fieldIndex > 0 || w >= 5));
      // Field 1 offers only swarms before wave 6, so after a swarm nothing is left to pick.
      type = rng() < 0.2 ? 'crawler' : avail[Math.floor(rng() * avail.length)] ?? 'crawler';
    }
    last = type;
    waves.push(waveDef(type, w, fieldIndex));
  }
  return waves;
}

export function newGame(fieldIndex: number): Game {
  const field = FIELDS[fieldIndex];
  const { tiles, length } = buildPath(field.path);
  const orb = field.path[field.path.length - 1];
  const g: Game = {
    fieldIndex,
    field,
    pathTiles: tiles,
    pathPoints: field.path,
    pathLength: length,
    orb,
    mana: 560 + fieldIndex * 320,
    manaCap: 900 + fieldIndex * 400,
    poolLevel: 0,
    manaMult: 1,
    structures: [],
    inventory: new Array(INVENTORY_SIZE).fill(null),
    monsters: [],
    shots: [],
    waves: makeWaves(fieldIndex, field.waves),
    nextWave: 0,
    waveTimer: FIRST_WAVE_DELAY,
    spawnQueue: [],
    time: 0,
    banished: 0,
    built: 0,
    state: 'playing',
    events: [],
    nextId: 1,
    rng: makeRng(4242 + fieldIndex),
    manaGained: 0,
  };
  return g;
}

// ---------------------------------------------------------------- gems

export function gemGrade(gem: Gem): number {
  return Math.floor(Math.log2(gem.mass) + 1e-9) + 1;
}

/** Continuous grade used for stats; equals the grade for pure combines. */
/** Share of the way from the current grade to the next, 0 for an exact combine. */
export function gradeProgress(gem: Gem): number {
  return gem.mass / Math.pow(2, gemGrade(gem) - 1) - 1;
}

export function gemPower(gem: Gem): number {
  return Math.log2(gem.mass) + 1;
}

/** Combining is free, so a grade costs exactly its 2^(g-1) grade-1 gems. */
export function gemCost(grade: number): number {
  return GEM_BASE_COST * Math.pow(2, grade - 1);
}

export function gemValue(gem: Gem): number {
  return Math.round(GEM_BASE_COST * gem.mass * 0.7);
}

export function towerCost(g: Game): number {
  const n = g.structures.filter((s) => s.kind === 'tower').length;
  return 90 + 30 * n;
}

export function trapCost(g: Game): number {
  const n = g.structures.filter((s) => s.kind === 'trap').length;
  return 70 + 25 * n;
}

export function poolCost(g: Game): number {
  return Math.round(g.manaCap * 0.6);
}

export function gemColorHex(gem: Gem): string {
  let r = 0;
  let gg = 0;
  let b = 0;
  let total = 0;
  for (const c of COLORS) {
    const f = gem.comp[c] ?? 0;
    if (!f) continue;
    const hex = COLOR_INFO[c].hex;
    r += parseInt(hex.slice(1, 3), 16) * f;
    gg += parseInt(hex.slice(3, 5), 16) * f;
    b += parseInt(hex.slice(5, 7), 16) * f;
    total += f;
  }
  const to = (v: number) => Math.round(v / total).toString(16).padStart(2, '0');
  return `#${to(r)}${to(gg)}${to(b)}`;
}

export function dominantColor(gem: Gem): GemColor {
  let best: GemColor = 'red';
  let bf = -1;
  for (const c of COLORS) {
    const f = gem.comp[c] ?? 0;
    if (f > bf) {
      bf = f;
      best = c;
    }
  }
  return best;
}

export interface GemStats {
  damage: number;
  range: number;
  rate: number;
  splash: number;
  leech: number;
  crit: number;
  critMult: number;
  poison: number;
  slow: number;
  tear: number;
}

/** 1 for a single-colour gem, 0.5 for an even two-colour mix, 1/6 for all six. */
export function gemPurity(gem: Gem): number {
  let p = 0;
  for (const c of COLORS) p += (gem.comp[c] ?? 0) ** 2;
  return p;
}

export function gemStats(gem: Gem, kind: StructKind): GemStats {
  const e = gemPower(gem);
  // Mixing costs: an even two-colour gem keeps 75% of each special and 90% of its damage.
  const purity = gemPurity(gem);
  const pm = 0.5 + 0.5 * purity;
  const f = (c: GemColor) => (gem.comp[c] ?? 0) * pm;
  const trap = kind === 'trap';
  const sm = trap ? 2.5 : 1;
  const base = 4 * Math.pow(1.85, e - 1);
  const damage = base * (trap ? 0.45 : 1) * (0.8 + 0.2 * purity);
  return {
    damage,
    range: trap ? 0.85 : Math.min(5.2, 2.7 + 0.16 * e),
    rate: (1 + 0.07 * e) * (trap ? 1.4 : 1),
    splash: Math.min(0.9, f('red') * (0.35 + 0.04 * e) * sm),
    leech: f('orange') * (0.6 + 0.55 * e) * sm,
    crit: Math.min(0.6, f('yellow') * (0.12 + 0.015 * e) * sm),
    critMult: 2 + 0.12 * e,
    poison: base * f('green') * (0.18 + 0.03 * e) * (trap ? 1.3 : 1),
    slow: Math.min(0.75, f('blue') * (0.25 + 0.025 * e) * sm),
    tear: base * f('purple') * 0.3 * sm,
  };
}

function takeId(g: Game): number {
  return g.nextId++;
}

function spend(g: Game, cost: number, what: string): boolean {
  if (g.mana < cost) {
    g.events.push({ type: 'error', message: `Not enough mana for ${what}` });
    return false;
  }
  g.mana -= cost;
  return true;
}

export function gainMana(g: Game, amount: number): void {
  const add = amount * g.manaMult;
  g.manaGained += add;
  g.mana = Math.min(g.manaCap, g.mana + add);
}

export function freeSlot(g: Game): number {
  return g.inventory.findIndex((s) => s === null);
}

export function createGem(g: Game, color: GemColor, grade: number): number {
  if (!g.field.colors.includes(color)) return -1;
  const slot = freeSlot(g);
  if (slot < 0) {
    g.events.push({ type: 'error', message: 'Inventory is full' });
    return -1;
  }
  if (!spend(g, gemCost(grade), 'that gem')) return -1;
  g.inventory[slot] = { id: takeId(g), mass: Math.pow(2, grade - 1), comp: { [color]: 1 }, kills: 0 };
  return slot;
}

export const RANDOM_BATCH = 3;

/** A random batch: RANDOM_BATCH gems of random field colours for the price of 2.5.
 *  Each gem still costs more than it sells for, so batches cannot be resold for profit. */
export function randomBatchCost(grade: number): number {
  return gemCost(grade) * 2.5;
}

/** Forges a random batch; returns the slots filled, or [] if it could not. */
export function createRandomGems(g: Game, grade: number): number[] {
  if (g.inventory.filter((s) => s === null).length < RANDOM_BATCH) {
    g.events.push({ type: 'error', message: `Random batch needs ${RANDOM_BATCH} free slots` });
    return [];
  }
  if (!spend(g, randomBatchCost(grade), 'a random batch')) return [];
  const slots: number[] = [];
  for (let i = 0; i < RANDOM_BATCH; i++) {
    const color = g.field.colors[Math.floor(g.rng() * g.field.colors.length)];
    const slot = freeSlot(g);
    g.inventory[slot] = { id: takeId(g), mass: Math.pow(2, grade - 1), comp: { [color]: 1 }, kills: 0 };
    slots.push(slot);
  }
  return slots;
}

export function canBuild(g: Game, kind: StructKind, x: number, y: number): boolean {
  if (x < 0 || y < 0 || x >= COLS || y >= ROWS) return false;
  if (g.structures.some((s) => s.x === x && s.y === y)) return false;
  if (x === g.orb[0] && y === g.orb[1]) return false;
  const [sx, sy] = g.pathPoints[0];
  if (x === sx && y === sy) return false;
  if (g.field.rocks.some(([rx, ry]) => rx === x && ry === y)) return false;
  const onPath = g.pathTiles.has(key(x, y));
  return kind === 'trap' ? onPath : !onPath;
}

export function build(g: Game, kind: StructKind, x: number, y: number): Structure | null {
  if (!canBuild(g, kind, x, y)) return null;
  const cost = kind === 'tower' ? towerCost(g) : trapCost(g);
  if (!spend(g, cost, `a ${kind}`)) return null;
  const s: Structure = { id: takeId(g), kind, x, y, gem: null, cooldown: 0, aim: -Math.PI / 2 };
  g.structures.push(s);
  g.built++;
  g.events.push({ type: 'build', x: x + 0.5, y: y + 0.5 });
  return s;
}

export function expandPool(g: Game): boolean {
  if (!spend(g, poolCost(g), 'expanding the pool')) return false;
  g.poolLevel++;
  g.manaCap = Math.round(g.manaCap * 1.6);
  g.manaMult = 1 + 0.15 * g.poolLevel;
  return true;
}

export function gemAt(g: Game, ref: GemRef): Gem | null {
  if (ref.kind === 'inv') return g.inventory[ref.index] ?? null;
  return g.structures.find((s) => s.id === ref.id)?.gem ?? null;
}

function setGem(g: Game, ref: GemRef, gem: Gem | null): void {
  if (ref.kind === 'inv') g.inventory[ref.index] = gem;
  else {
    const s = g.structures.find((st) => st.id === ref.id);
    if (s) {
      s.gem = gem;
      s.cooldown = Math.max(s.cooldown, 0.4);
    }
  }
}

export function sameRef(a: GemRef, b: GemRef): boolean {
  return a.kind === b.kind && (a.kind === 'inv' ? a.index === (b as { index: number }).index : a.id === (b as { id: number }).id);
}

export function combine(a: Gem, b: Gem, id: number): Gem {
  const mass = a.mass + b.mass;
  const comp: Partial<Record<GemColor, number>> = {};
  for (const c of COLORS) {
    const v = ((a.comp[c] ?? 0) * a.mass + (b.comp[c] ?? 0) * b.mass) / mass;
    if (v > 0.001) comp[c] = v;
  }
  return { id, mass, comp, kills: a.kills + b.kills };
}

/** Move src onto dst: into an empty spot, or combine with the gem already there. */
export function moveGem(g: Game, src: GemRef, dst: GemRef): boolean {
  if (sameRef(src, dst)) return false;
  const a = gemAt(g, src);
  if (!a) return false;
  if (dst.kind === 'struct' && !g.structures.some((s) => s.id === dst.id)) return false;
  const b = gemAt(g, dst);
  if (!b) {
    setGem(g, src, null);
    setGem(g, dst, a);
    return true;
  }
  const merged = combine(a, b, takeId(g));
  setGem(g, src, null);
  setGem(g, dst, merged);
  g.events.push({ type: 'combine', grade: gemGrade(merged) });
  return true;
}

export function sellGem(g: Game, ref: GemRef): boolean {
  const gem = gemAt(g, ref);
  if (!gem) return false;
  setGem(g, ref, null);
  g.mana = Math.min(g.manaCap, g.mana + gemValue(gem));
  return true;
}

export function callWaveEarly(g: Game): number {
  if (g.nextWave >= g.waves.length || g.state !== 'playing') return 0;
  const bonus = Math.round(g.waveTimer * (1.5 + g.nextWave * 0.6 + g.fieldIndex));
  gainMana(g, bonus);
  launchWave(g);
  return bonus;
}

function launchWave(g: Game): void {
  const def = g.waves[g.nextWave];
  g.spawnQueue.push({ def, left: def.count, timer: 0 });
  g.events.push({ type: 'wave', index: g.nextWave });
  g.nextWave++;
  g.waveTimer = WAVE_GAP;
}

function spawn(g: Game, def: WaveDef): void {
  const hp = def.hp * (0.92 + g.rng() * 0.16);
  const [x, y] = pathPos(g, 0);
  g.monsters.push({
    id: takeId(g),
    type: def.type,
    dist: 0,
    hp,
    maxHp: hp,
    armor: def.armor,
    speed: def.speed * (0.95 + g.rng() * 0.1),
    slowF: 0,
    slowT: 0,
    poisonDps: 0,
    poisonT: 0,
    ward: def.ward ?? 0,
    regen: (def.regen ?? 0) * hp,
    mana: 4 + hp * 0.3 + def.armor * 0.1 + (def.ward ?? 0) * 2,
    wobble: g.rng() * Math.PI * 2,
    x,
    y,
  });
}

function damageMonster(g: Game, m: Monster, raw: number, src: Structure | null): void {
  if (m.hp <= 0) return;
  if (m.ward > 0) {
    m.ward--;
    return;
  }
  const dealt = Math.max(raw * 0.15, raw - m.armor);
  m.hp -= dealt;
  if (m.hp <= 0) {
    gainMana(g, m.mana);
    if (src?.gem) src.gem.kills++;
    g.events.push({ type: 'kill', x: m.x, y: m.y, mana: m.mana * g.manaMult });
  }
}

function hit(g: Game, s: Structure, m: Monster): void {
  const gem = s.gem;
  if (!gem || m.hp <= 0) return;
  const st = gemStats(gem, s.kind);
  // A ward swallows the whole hit, specials included.
  if (m.ward > 0) {
    m.ward--;
    g.events.push({ type: 'hit', x: m.x, y: m.y, color: '#cfd8ff', crit: false });
    return;
  }
  let dmg = st.damage * (0.8 + g.rng() * 0.4);
  const crit = g.rng() < st.crit;
  if (crit) dmg *= st.critMult;
  if (st.tear > 0) m.armor = Math.max(0, m.armor - st.tear);
  if (st.slow > 0) {
    m.slowF = Math.max(m.slowF, st.slow);
    // Trap effects linger, so a trap ahead of the towers helps them too.
    m.slowT = s.kind === 'trap' ? 5 : 2.5;
  }
  if (st.poison > 0) {
    m.poisonDps = Math.max(m.poisonDps, st.poison);
    m.poisonT = s.kind === 'trap' ? 6 : 4;
  }
  if (st.leech > 0) gainMana(g, st.leech);
  damageMonster(g, m, dmg, s);
  if (st.splash > 0) {
    for (const o of g.monsters) {
      if (o === m || o.hp <= 0) continue;
      const d = Math.hypot(o.x - m.x, o.y - m.y);
      if (d < 1.15) damageMonster(g, o, dmg * st.splash, s);
    }
  }
  g.events.push({ type: 'hit', x: m.x, y: m.y, color: gemColorHex(gem), crit });
}

export function step(g: Game, dt: number): void {
  if (g.state !== 'playing') return;
  g.time += dt;

  // Waves.
  if (g.nextWave < g.waves.length) {
    g.waveTimer -= dt;
    if (g.waveTimer <= 0) launchWave(g);
  }
  for (const q of g.spawnQueue) {
    q.timer -= dt;
    while (q.left > 0 && q.timer <= 0) {
      spawn(g, q.def);
      q.left--;
      q.timer += q.def.interval;
    }
  }
  g.spawnQueue = g.spawnQueue.filter((q) => q.left > 0);

  // Passive mana trickle.
  gainMana(g, dt * (1 + g.fieldIndex * 0.4));

  // Monsters move, take poison and may reach the orb.
  for (const m of g.monsters) {
    if (m.hp <= 0) continue;
    if (m.poisonT > 0) {
      m.poisonT -= dt;
      m.hp -= m.poisonDps * dt;
      if (m.poisonT <= 0) m.poisonDps = 0;
      if (m.hp <= 0) {
        gainMana(g, m.mana);
        g.events.push({ type: 'kill', x: m.x, y: m.y, mana: m.mana * g.manaMult });
        continue;
      }
    } else if (m.regen > 0) m.hp = Math.min(m.maxHp, m.hp + m.regen * dt);
    if (m.slowT > 0) {
      m.slowT -= dt;
      if (m.slowT <= 0) m.slowF = 0;
    }
    m.dist += m.speed * (1 - m.slowF) * dt;
    if (m.dist >= g.pathLength) {
      const cost = Math.round(m.maxHp * 0.6 + 10 + g.banished * 2);
      g.mana -= cost;
      g.banished++;
      g.events.push({ type: 'banish', x: m.x, y: m.y, cost, monster: m.type });
      if (g.mana < 0) {
        g.mana = 0;
        g.state = 'lost';
        return;
      }
      m.dist = 0;
    }
    [m.x, m.y] = pathPos(g, m.dist);
  }
  g.monsters = g.monsters.filter((m) => m.hp > 0);

  // Structures fire.
  for (const s of g.structures) {
    if (!s.gem) continue;
    s.cooldown -= dt;
    if (s.cooldown > 0) continue;
    const st = gemStats(s.gem, s.kind);
    const cx = s.x + 0.5;
    const cy = s.y + 0.5;
    let best: Monster | null = null;
    for (const m of g.monsters) {
      if (m.hp <= 0) continue;
      if (Math.hypot(m.x - cx, m.y - cy) > st.range) continue;
      if (!best || m.dist > best.dist) best = m;
    }
    if (!best) continue;
    s.cooldown = 1 / st.rate;
    s.aim = Math.atan2(best.y - cy, best.x - cx);
    // A trap strikes everything on and beside it, so its special reaches the whole crowd.
    if (s.kind === 'trap') {
      for (const m of g.monsters) if (m.hp > 0 && Math.hypot(m.x - cx, m.y - cy) <= st.range) hit(g, s, m);
    } else g.shots.push({ from: s, target: best, x: cx, y: cy, color: gemColorHex(s.gem) });
  }

  // Projectiles home in.
  const speed = 14;
  g.shots = g.shots.filter((p) => {
    if (p.target.hp <= 0 || !g.monsters.includes(p.target)) return false;
    const dx = p.target.x - p.x;
    const dy = p.target.y - p.y;
    const d = Math.hypot(dx, dy);
    if (d < speed * dt) {
      hit(g, p.from, p.target);
      return false;
    }
    p.x += (dx / d) * speed * dt;
    p.y += (dy / d) * speed * dt;
    return true;
  });
  g.monsters = g.monsters.filter((m) => m.hp > 0);

  if (g.nextWave >= g.waves.length && g.spawnQueue.length === 0 && g.monsters.length === 0) {
    g.state = 'won';
  }
}

export function stars(g: Game): number {
  if (g.state !== 'won') return 0;
  let s = 1;
  if (g.banished === 0) s++;
  if (g.built <= 5) s++;
  return s;
}