Files
plan2code/src/web-console/public/activities/ghoul-rockets.js
T

309 lines
13 KiB
JavaScript

// Plan2Code Web Console - Ghoul Rush's Bottle Rocket, the common weapon every stage sells: one use lights THREE rockets, one ahead, one up and one behind.
//
// - AHEAD flies level with his chest at ROCKET_SPEED, straight, until a monster in
// view on its side sits above or below that line (on a shelf, in a pit's mouth):
// then it bends toward the nearest such monster at LEVEL_TURN, never turning back.
// - UP leaves straight up at ROCKET_UP_SPEED for ROCKET_UP_MS, then curves over
// (turning ROCKET_TURN radians a second) and homes on the nearest monster in
// view that is ahead of him or above him: a bat, a flyer, whatever sits on a
// shelf. With nothing to chase it steers for a point far ahead and below, so it
// arcs forward and drops.
// - BEHIND leaves backward at ROCKET_BACK_SPEED, for the horde and the stragglers
// on his heels, bending toward one above or below it the same way.
//
// A rocket explodes on touching a monster, a wall or the floor, a target (an
// organ pipe, a crate), or at ROCKET_LIFE_MS. The blast reaches ROCKET_BLAST_R
// from the rocket, does ROCKET_DMG (a kill for anything ordinary) to every
// monster in it once, and ROCKET_BOSS to a boss in it through armBossDamage (a
// guard shows, a hidden boss is not hit, the share cap holds across all three).
// Its kills leave no drops. Three rockets cost the bag one use. Nothing here
// hurts Planny.
//
// Sparks are only for the eye: they live on the rocket (and, once it has gone off,
// on its burst), never touch a rule, are capped at SPARK_CAP across the field,
// and are drawn from a time-and-serial pattern (`mix`), never a random draw, so a
// round replays the same and a seed does not shift.
//
// No imports: ghoul-arms.js hands the rules its helpers (see `tools`).
const TAU = Math.PI * 2;
export const ROCKET_COUNT = 3;
export const ROCKET_SPEED = 105;
export const ROCKET_BACK_SPEED = 95;
export const ROCKET_UP_SPEED = 80;
export const ROCKET_UP_MS = 220;
export const ROCKET_ARC_SPEED = 80;
export const ROCKET_TURN = 6.5;
// Within HOME_NEAR of its mark it turns HOME_BOOST times as fast, so it closes on a
// target to the side of it instead of circling.
export const HOME_NEAR = 26;
export const HOME_BOOST = 2.8;
// The level rockets (ahead and behind) bend toward a monster whose middle is more than
// LEVEL_OFF above or below them, on their side of the room, inside a cone that rises
// LEVEL_CONE units for every unit of distance (plus LEVEL_SLACK), at LEVEL_TURN.
export const LEVEL_TURN = 3.2;
export const LEVEL_OFF = 1.4;
export const LEVEL_CONE = 1.1;
export const LEVEL_SLACK = 6;
export const ROCKET_LIFE_MS = 2000;
export const ROCKET_BLAST_R = 6;
export const ROCKET_DMG = 40;
export const ROCKET_BOSS = 4;
export const ROCKET_PIPE = 3;
// How far a rocket's nose reaches past a monster's box to count as touching.
export const ROCKET_HIT = 0.9;
// A slice this long at most, so a fast rocket never skips over a monster.
const SLICE_MS = 6;
const CEILING = 56;
// Where the up rocket aims when nothing is there: far ahead and below.
const ARC_DX = 40;
const ARC_DY = -40;
// Sparks: one every SPARK_STEP of travel (6 to 10 a frame at 60 fps), living
// SPARK_LIFE_MS to SPARK_LIFE_MS + SPARK_LIFE_VARY, at most SPARK_CAP on the field
// (the trail stops shedding at SPARK_TRAIL_CAP so a burst always has room), a burst
// of SPARK_BURST flying out of a blast, SPARK_COLORS in turn.
export const SPARK_STEP = 0.2;
export const SPARK_LIFE_MS = 270;
export const SPARK_LIFE_VARY = 110;
export const SPARK_CAP = 480;
export const SPARK_TRAIL_CAP = 410;
export const SPARK_BURST = 44;
export const SPARK_COLORS = Object.freeze(["#ff3b30", "#ff9500", "#ffe14d", "#3ddc5a", "#33e0ff", "#ff4fd8"]);
const SPARK_G = 34;
export const BOOM_MS = 620;
export const MUZZLE_MS = 460;
// The launch sound plays once per volley; the blasts share one, this often at most.
export const BOOM_SOUND_MS = 90;
// A number from 0 to 1 that depends on `n` alone (a hash, not a random draw).
export function mix(n) {
let x = Math.imul(n | 0, 2654435761) >>> 0;
x ^= x >>> 15;
x = Math.imul(x, 2246822519) >>> 0;
x ^= x >>> 13;
x = Math.imul(x, 3266489917) >>> 0;
x ^= x >>> 16;
return (x >>> 0) / 4294967296;
}
const sparkCount = (round) => {
let n = 0;
for (const h of round.hazards) if (h.sparks) n += h.sparks.length;
return n;
};
// A spark at (x, y): `vx`, `vy` its start, color the next of the six.
function spark(round, x, y, vx, vy, life) {
const n = (round.sparkN = (round.sparkN || 0) + 1);
return { x, y, vx, vy, age: 0, life, c: n % SPARK_COLORS.length, s: 0.5 + mix(n * 7 + 3) * 0.5 };
}
function ageSparks(list, ms) {
const dt = ms / 1000;
let n = 0;
for (const p of list) {
p.age += ms;
if (p.age >= p.life) continue;
p.x += p.vx * dt;
p.y += p.vy * dt;
p.vy -= SPARK_G * dt;
list[n++] = p;
}
list.length = n;
}
// The use: three rockets and the flash at his hand.
export function useRockets(round, k) {
const you = round.you;
const face = you.face;
const y = you.y + k.shotY(you);
const make = (dir, x, yy, vx, vy) => ({ kind: "armRocket", dir, face, x, y: yy, vx, vy, t: 0, acc: 0, sparks: [], w: 0.1, h: 0.1, live: 0, cause: "" });
round.hazards.push(make("fwd", you.x + face * 1.8, y, face * ROCKET_SPEED, 0));
round.hazards.push(make("up", you.x + face * 0.4, y + 0.6, 0, ROCKET_UP_SPEED));
round.hazards.push(make("back", you.x - face * 1.8, y, -face * ROCKET_BACK_SPEED, 0));
round.hazards.push({ kind: "armMuzzle", x: you.x + face * 1.8, y, face, life: MUZZLE_MS, max: MUZZLE_MS, w: 0.1, h: 0.1, live: 0, cause: "" });
}
// Turn toward (tx, ty) by at most `turn` radians, at speed `v`.
function steer(h, tx, ty, turn, v) {
const want = Math.atan2(ty - h.y, tx - h.x);
const now = Math.atan2(h.vy, h.vx);
let da = want - now;
while (da > Math.PI) da -= TAU;
while (da < -Math.PI) da += TAU;
const a = now + Math.max(-turn, Math.min(turn, da));
h.vx = Math.cos(a) * v;
h.vy = Math.sin(a) * v;
}
// The up rocket's mark: the nearest monster in view that is ahead of where it was
// fired or above it; else a point far ahead and below, so it arcs and drops.
function markOf(round, h, k, tools) {
const lo = round.camX - 2;
const hi = round.camX + k.FIELD_W + 2;
let best = null;
let d = Infinity;
const consider = (x, y) => {
const dm = Math.hypot(x - h.x, y - h.y);
if (dm < d) {
d = dm;
best = { x, y };
}
};
for (const m of round.monsters) {
if (m.dead || !k.solid(m) || k.stone(m) || k.harmlessNow(m) || m.x < lo || m.x > hi) continue;
const mid = m.y + m.h / 2;
if ((m.x - h.x0) * h.face >= -4 || mid > h.y0 + 3) consider(m.x, mid);
}
const b = tools.bossUp(round);
if (b && !k.guarded(b)) consider(b.x, b.y + b.h / 2);
return best ? { ...best, near: d < HOME_NEAR } : { x: h.x + h.face * ARC_DX, y: h.y + ARC_DY, near: false };
}
// A level rocket's mark: the nearest monster in view on its side of the room whose
// middle is off the rocket's line (more than LEVEL_OFF) and inside the cone. None
// means it flies straight on.
function levelMark(round, h, k, tools) {
const lo = round.camX - 2;
const hi = round.camX + k.FIELD_W + 2;
const way = Math.sign(h.vx) || h.face;
let best = null;
let d = Infinity;
const consider = (x, y) => {
const dx = (x - h.x) * way;
const dy = Math.abs(y - h.y);
if (dx <= 0 || dy <= LEVEL_OFF || dy > LEVEL_CONE * dx + LEVEL_SLACK) return;
const dm = Math.hypot(x - h.x, y - h.y);
if (dm < d) {
d = dm;
best = { x, y, near: dm < HOME_NEAR };
}
};
for (const m of round.monsters) {
if (m.dead || !k.solid(m) || k.stone(m) || k.harmlessNow(m) || m.x < lo || m.x > hi) continue;
consider(m.x, m.y + m.h / 2);
}
const b = tools.bossUp(round);
if (b && !k.guarded(b)) consider(b.x, b.y + b.h / 2);
return best;
}
// Whether a point is inside a box w by h standing at (x, y), `r` to spare.
const inside = (m, px, py, r) => px >= m.x - m.w / 2 - r && px <= m.x + m.w / 2 + r && py >= m.y - r && py <= m.y + m.h + r;
// The distance from (px, py) to the nearest point of a monster's box.
const reach = (m, px, py) => Math.hypot(px - Math.max(m.x - m.w / 2, Math.min(m.x + m.w / 2, px)), py - Math.max(m.y, Math.min(m.y + m.h, py)));
// It goes off at (x, y): the burst, the blast and the sound.
function explode(round, h, k, tools) {
const { x, y } = h;
const sparks = h.sparks;
const room = Math.max(0, SPARK_CAP - sparkCount(round));
const burst = Math.min(SPARK_BURST, room);
for (let i = 0; i < burst; i++) {
const n = (round.sparkN || 0) + 1;
const a = (i / SPARK_BURST) * TAU + mix(n) * 0.5;
const v = 16 + mix(n * 3 + 1) * 34;
const p = spark(round, x, y, Math.cos(a) * v, Math.sin(a) * v + 4, 380 + mix(n * 5 + 2) * 260);
p.s += 0.35;
sparks.push(p);
}
round.hazards.push({ kind: "armRocketBoom", x, y, life: BOOM_MS, max: BOOM_MS, sparks, w: 0.1, h: 0.1, live: 0, cause: "" });
const view = x > round.camX - 4 && x < round.camX + k.FIELD_W + 4;
if (view && !(round.rocketSoundMs > 0)) {
round.rocketSoundMs = BOOM_SOUND_MS;
round.events.push({ type: "armBoom", x, y });
}
const holy = round.effects.holy > 0;
for (const m of round.monsters) {
if (m.dead || !(k.solid(m) || k.stone(m)) || k.harmlessNow(m) || reach(m, x, y) > ROCKET_BLAST_R) continue;
if (k.stone(m)) {
if (holy) k.hurt(round, m, 99, "holy", tools.noDrops);
continue;
}
k.hurt(round, m, ROCKET_DMG, "blast", tools.noDrops);
}
tools.sweepDead(round);
const b = tools.bossUp(round);
if (b && reach(b, x, y) <= ROCKET_BLAST_R) tools.hitBoss(round, Math.max(b.x - b.w / 2, Math.min(b.x + b.w / 2, x)), Math.max(b.y, Math.min(b.y + b.h, y)), ROCKET_BOSS, "blast", k);
for (const p of b?.pipes || []) {
if (p.on && Math.abs(p.x - x) <= ROCKET_BLAST_R && y >= p.y - ROCKET_BLAST_R && y <= p.y + p.h + ROCKET_BLAST_R) k.strike(round, { x: p.x, y: Math.max(p.y, Math.min(p.y + p.h, y)), pipeDmg: ROCKET_PIPE });
}
}
// Whether the rocket is spent now: on a monster, the boss, a target, a wall or
// the floor, out of life, or lost in a pit or the roof.
function spent(round, h, k, tools) {
if (h.t >= ROCKET_LIFE_MS || h.y < k.PIT_Y || h.y > CEILING || k.groundAt(round.spec, h.x) > h.y) return true;
for (const m of round.monsters) if (!m.dead && (k.solid(m) || k.stone(m)) && !k.harmlessNow(m) && inside(m, h.x, h.y, ROCKET_HIT)) return true;
const b = tools.bossUp(round);
if (b && inside(b, h.x, h.y, ROCKET_HIT * 0.5)) return true;
return k.strike(round, { x: h.x, y: h.y, pipeDmg: ROCKET_PIPE, dmg: 1 });
}
// Sparks shed along the way between two slices: one every SPARK_STEP of travel,
// thrown back and to the sides, falling.
function shed(round, h, px, py) {
const d = Math.hypot(h.x - px, h.y - py);
if (!d) return;
h.acc += d;
const speed = Math.hypot(h.vx, h.vy) || 1;
const bx = -h.vx / speed;
const by = -h.vy / speed;
let total = -1;
while (h.acc >= SPARK_STEP) {
h.acc -= SPARK_STEP;
if (total < 0) total = sparkCount(round);
if (total >= SPARK_TRAIL_CAP) continue;
total++;
const f = 1 - h.acc / d;
const n = (round.sparkN || 0) + 1;
const back = 6 + mix(n) * 16;
const side = (mix(n * 3 + 1) - 0.5) * 34;
const p = spark(round, px + (h.x - px) * Math.min(1, Math.max(0, f)) + bx * 1.2, py + (h.y - py) * Math.min(1, Math.max(0, f)) + by * 1.2, bx * back - by * side, by * back + bx * side + 4, SPARK_LIFE_MS + mix(n * 5 + 2) * SPARK_LIFE_VARY);
h.sparks.push(p);
}
}
// One slice of a rocket in flight. `tools` is { bossUp, hitBoss, sweepDead, noDrops } from ghoul-arms.js.
export function stepRocket(round, h, ms, k, tools) {
if (h.t === 0) {
h.x0 = h.x;
h.y0 = h.y;
}
for (let left = ms; left > 0; left -= SLICE_MS) {
const dt = Math.min(SLICE_MS, left);
const s = dt / 1000;
h.t += dt;
ageSparks(h.sparks, dt);
if (h.dir === "up" && h.t > ROCKET_UP_MS) {
const to = markOf(round, h, k, tools);
steer(h, to.x, to.y, ROCKET_TURN * (to.near ? HOME_BOOST : 1) * s, ROCKET_ARC_SPEED);
}
if (h.dir !== "up") {
const to = levelMark(round, h, k, tools);
if (to) steer(h, to.x, to.y, LEVEL_TURN * (to.near ? HOME_BOOST : 1) * s, h.dir === "fwd" ? ROCKET_SPEED : ROCKET_BACK_SPEED);
}
const px = h.x;
const py = h.y;
h.x += h.vx * s;
h.y += h.vy * s;
shed(round, h, px, py);
if (spent(round, h, k, tools)) {
explode(round, h, k, tools);
return false;
}
}
return true;
}
export function stepBoom(round, h, ms) {
ageSparks(h.sparks, ms);
return (h.life -= ms) > 0;
}
export function stepMuzzle(round, h, ms) {
return (h.life -= ms) > 0;
}