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.
// 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;
}
