435 lines
17 KiB
JavaScript
435 lines
17 KiB
JavaScript
// ---- enemy types, AI, damage & death ----
|
||
|
||
const ENEMY_TYPES = {
|
||
shambler: { hp: 26, spd: 55, dmg: 1, r: 18, drawSize: 64, xp: 1, sprite: 'enemy_shambler' },
|
||
runner: { hp: 12, spd: 236, dmg: 1, r: 15, drawSize: 64, xp: 1, sprite: 'enemy_runner' },
|
||
spitter: { hp: 20, spd: 60, dmg: 1, r: 18, drawSize: 64, xp: 2, sprite: 'enemy_spitter', ranged: true },
|
||
splitter: { hp: 30, spd: 70, dmg: 1, r: 21, drawSize: 64, xp: 1, sprite: 'enemy_splitter', splits: true },
|
||
mini: { hp: 6, spd: 120, dmg: 1, r: 10, drawSize: 32, xp: 1, sprite: 'enemy_mini' },
|
||
exploder: { hp: 14, spd: 110, dmg: 2, r: 16, drawSize: 64, xp: 2, sprite: 'enemy_exploder', explodes: true },
|
||
};
|
||
const MAX_ENEMIES = 72;
|
||
|
||
function makeEnemy(type, x, y, floor, elite) {
|
||
const t = ENEMY_TYPES[type];
|
||
const up = powerScore();
|
||
// floor scaling × player-power scaling (+5% hp / +1% speed per upgrade)
|
||
const fscale = (1 + (floor - 1) * 0.22) * (1 + up * 0.05);
|
||
const sscale = 1 + (floor - 1) * 0.04 + up * 0.01;
|
||
const e = {
|
||
type, x, y, vx: 0, vy: 0,
|
||
r: t.r * (elite ? 1.45 : 1),
|
||
drawSize: t.drawSize * (elite ? 1.5 : 1),
|
||
hp: t.hp * fscale * (elite ? 2.6 : 1) * G.pressure,
|
||
maxHp: t.hp * fscale * (elite ? 2.6 : 1) * G.pressure,
|
||
spd: t.spd * sscale * (elite ? 0.9 : 1) * rand(0.9, 1.1) * G.pressure,
|
||
dmg: t.dmg + (elite ? 1 : 0),
|
||
xp: t.xp * (elite ? 3 : 1),
|
||
sprite: t.sprite,
|
||
elite: !!elite,
|
||
hitT: 0, flash: 0, burnT: 0, burnDps: 0, bleedT: 0, bleedDps: 0,
|
||
slowT: 0, stunT: 0, rootT: 0,
|
||
fireT: rand(1, 2.5), fuse: -1, wob: rand(0, TAU),
|
||
animSeed: rand(0, TAU), animT: rand(0, 1), attackT: 0, actionT: 0,
|
||
spawnT: 0, dead: false,
|
||
boss: false,
|
||
};
|
||
return e;
|
||
}
|
||
|
||
// pick an enemy type for a floor-scaled wave
|
||
function pickEnemyType(floor) {
|
||
const table = [
|
||
['shambler', 40],
|
||
['runner', floor >= 1 ? 25 : 0],
|
||
['spitter', floor >= 2 ? 18 : 0],
|
||
['splitter', floor >= 2 ? 16 : 0],
|
||
['exploder', floor >= 3 ? 14 : 0],
|
||
];
|
||
const total = table.reduce((s, t) => s + t[1], 0);
|
||
let r = Math.random() * total;
|
||
for (const [type, w] of table) { r -= w; if (r <= 0) return type; }
|
||
return 'shambler';
|
||
}
|
||
|
||
// true if (x,y) is within keep-out range of any of the current room's doorways
|
||
function nearAnyDoor(x, y) {
|
||
const r = G.cur;
|
||
if (!r) return false;
|
||
const M = 130; // spawn keep-out radius around doors
|
||
if (r.doors.n && Math.abs(x - W / 2) < DOOR_HALF + 30 && y < WALL + M) return true;
|
||
if (r.doors.s && Math.abs(x - W / 2) < DOOR_HALF + 30 && y > H - WALL - M) return true;
|
||
if (r.doors.e && Math.abs(y - H / 2) < DOOR_HALF + 30 && x > W - WALL - M) return true;
|
||
if (r.doors.w && Math.abs(y - H / 2) < DOOR_HALF + 30 && x < WALL + M) return true;
|
||
return false;
|
||
}
|
||
|
||
function spawnPosAwayFromPlayer() {
|
||
const p = G.player;
|
||
for (let tries = 0; tries < 30; tries++) {
|
||
const x = rand(WALL + 40, W - WALL - 40);
|
||
const y = rand(WALL + 40, H - WALL - 40);
|
||
if (dist(x, y, p.x, p.y) <= 200) continue;
|
||
if (nearAnyDoor(x, y)) continue;
|
||
return { x, y };
|
||
}
|
||
// fallback: center of the room, away from every door
|
||
return { x: rand(W / 2 - 150, W / 2 + 150), y: rand(H / 2 - 120, H / 2 + 120) };
|
||
}
|
||
|
||
function spawnWave(count, floor) {
|
||
for (let i = 0; i < count; i++) {
|
||
if (G.enemies.length >= MAX_ENEMIES) break;
|
||
const pos = spawnPosAwayFromPlayer();
|
||
const elite = chance(Math.min(0.03 + floor * 0.02, 0.2));
|
||
const e = makeEnemy(pickEnemyType(floor), pos.x, pos.y, floor, elite);
|
||
G.enemies.push(e);
|
||
spawnBlood(pos.x, pos.y, rand(0, TAU), 4);
|
||
Sfx.spawn(e);
|
||
}
|
||
}
|
||
|
||
// returns true if the enemy died
|
||
function damageEnemy(e, dmg, ang, knockback, opts) {
|
||
if (e.hp <= 0) return true;
|
||
if (e.phased) return false;
|
||
if (!(dmg > 0)) return false; // NaN / zero / negative damage does nothing
|
||
// crit roll
|
||
const p = G.player;
|
||
const o = opts || {};
|
||
const crit = !!(p && !o.noCrit && chance(p.stats.crit || 0));
|
||
if (crit) dmg *= p.stats.critMul || 2;
|
||
const mitigated = e.dmgTakenMul !== undefined && e.dmgTakenMul < 1;
|
||
dmg *= e.dmgTakenMul === undefined ? 1 : e.dmgTakenMul;
|
||
e.hp -= dmg;
|
||
e.flash = 0.12;
|
||
spawnText(e.x, e.y, Math.max(1, Math.round(dmg)), mitigated ? '#d0b887' : '#ffb0a0');
|
||
if (e.plates > 0) {
|
||
e.plateDmg = (e.plateDmg || 0) + dmg;
|
||
const threshold = e.maxHp * 0.06;
|
||
if (e.plateDmg >= threshold) {
|
||
e.plateDmg -= threshold;
|
||
e.plates--;
|
||
e.rootT = Math.max(e.rootT || 0, 0.45);
|
||
e.flash = 0.2;
|
||
addShake(6);
|
||
spawnGibs(e.x, e.y, 4, true);
|
||
spawnText(e.x, e.y - e.r, 'PLATE BROKEN', '#ffd080');
|
||
Sfx.boss(e, 'plate');
|
||
if (e.plates <= 0) {
|
||
e.dmgTakenMul = 1;
|
||
addToast('ARMOR BREACHED', 'Plate Father is exposed');
|
||
Sfx.boss(e, 'enrage');
|
||
}
|
||
}
|
||
}
|
||
if (knockback && !e.boss && !e.dragged) {
|
||
const kb = p ? p.stats.knockbackMul || 1 : 1;
|
||
e.vx += Math.cos(ang) * 90 * kb; e.vy += Math.sin(ang) * 90 * kb;
|
||
}
|
||
if (p && !o.noProc) procOnHit(e, dmg, ang, o);
|
||
Sfx.hit(e, crit);
|
||
if (e.hp <= 0) { killEnemy(e, ang); return true; }
|
||
return false;
|
||
}
|
||
|
||
// Shared player-hit payload. Every weapon primitive routes through damageEnemy,
|
||
// so items remain useful for bullets, beams, slams, saws, traps and orbitals.
|
||
function procOnHit(e, dmg, ang, opts) {
|
||
const p = G.player, s = p.stats;
|
||
const chanceScale = opts.procScale === undefined ? 1 : opts.procScale;
|
||
const magnitudeScale = opts.procMagnitudeScale === undefined ? 1 : opts.procMagnitudeScale;
|
||
const intervalScale = opts.procIntervalScale === undefined ? 1 : opts.procIntervalScale;
|
||
const procDamage = dmg / Math.max(0.05, intervalScale) * magnitudeScale;
|
||
if (s.splinter > 0 && !(opts.bullet && opts.bullet.shard) && chance(clamp(chanceScale, 0, 1))) {
|
||
const count = Math.min(18, Math.floor(s.splinter));
|
||
for (let i = 0; i < count; i++) {
|
||
const sa = rand(0, TAU);
|
||
G.bullets.push({
|
||
x: e.x, y: e.y, ang: sa,
|
||
vx: Math.cos(sa) * 300 * s.shotSpeedMul, vy: Math.sin(sa) * 300 * s.shotSpeedMul,
|
||
r: 3 * s.sizeMul, dmg: procDamage * 0.4, pierce: 0, bounce: s.bounce,
|
||
life: 0.35 * s.rangeMul, t: 0, behavior: 'bullet', sprite: 'bullet_bone',
|
||
homing: s.homing ? 1.6 + s.homing * 0.7 : 0, shard: true, sizeMul: s.sizeMul,
|
||
});
|
||
}
|
||
spawnSpark(e.x, e.y, ang);
|
||
}
|
||
if (s.bleed > 0) {
|
||
e.bleedT = Math.max(e.bleedT || 0, 2.2);
|
||
e.bleedDps = Math.max(e.bleedDps || 0, procDamage * s.bleed * 0.45);
|
||
}
|
||
if (s.igniteChance > 0 && chance(clamp(s.igniteChance * chanceScale, 0, 0.9))) {
|
||
e.burnT = Math.max(e.burnT || 0, 1.8);
|
||
e.burnDps = Math.max(e.burnDps || 0, 5 * s.dmgMul);
|
||
}
|
||
if (s.slowOnHit > 0 && chance(clamp(s.slowOnHit * chanceScale, 0, 0.9))) e.slowT = Math.max(e.slowT || 0, 1.5);
|
||
if (!e.boss && s.stunOnHit > 0 && chance(clamp(s.stunOnHit * chanceScale, 0, 0.75))) e.stunT = Math.max(e.stunT || 0, 0.35);
|
||
if (s.pullOnHit > 0 && !e.boss && chance(clamp(s.pullOnHit * chanceScale, 0, 0.8))) {
|
||
const toward = angleTo(e.x, e.y, p.x, p.y);
|
||
e.vx += Math.cos(toward) * 170; e.vy += Math.sin(toward) * 170;
|
||
}
|
||
if (s.acidOnHit > 0 && G.hazards.length < 80 && chance(clamp(s.acidOnHit * chanceScale, 0, 0.65))) {
|
||
G.hazards.push({ kind: 'acid', x: e.x, y: e.y, r: 18 * s.sizeMul, life: 2.5, t: 0, dps: 5 * s.dmgMul });
|
||
}
|
||
if (s.chain > 0 && G.enemies.length > 1 && chance(clamp(chanceScale, 0, 1))) {
|
||
const hit = new Set([e]);
|
||
let from = e;
|
||
for (let i = 0; i < Math.min(6, Math.floor(s.chain)); i++) {
|
||
let next = null, best = 180 * 180;
|
||
for (const target of G.enemies) {
|
||
if (target.hp <= 0 || target.phased || hit.has(target)) continue;
|
||
const d2 = dist2(from.x, from.y, target.x, target.y);
|
||
if (d2 < best) { best = d2; next = target; }
|
||
}
|
||
if (!next) break;
|
||
hit.add(next);
|
||
damageEnemy(next, procDamage * 0.35, angleTo(from.x, from.y, next.x, next.y), false, { noProc: true, noCrit: true });
|
||
spawnSpark(next.x, next.y, angleTo(from.x, from.y, next.x, next.y));
|
||
from = next;
|
||
}
|
||
}
|
||
if (s.mortar > 0) {
|
||
p.mortarHits = (p.mortarHits || 0) + chanceScale;
|
||
const every = Math.max(2, 7 - Math.min(5, Math.floor(s.mortar)));
|
||
if (p.mortarHits >= every) {
|
||
p.mortarHits -= every;
|
||
const radius = 42 + s.mortar * 5;
|
||
for (const target of G.enemies) {
|
||
if (target.hp > 0 && target !== e && dist2(e.x, e.y, target.x, target.y) < radius * radius) {
|
||
damageEnemy(target, procDamage * 0.55, angleTo(e.x, e.y, target.x, target.y), true, { noProc: true, noCrit: true });
|
||
}
|
||
}
|
||
spawnExplosionFx(e.x, e.y, radius);
|
||
}
|
||
}
|
||
}
|
||
|
||
function tickEnemyDamage(e, amount) {
|
||
if (!(amount > 0) || e.hp <= 0) return;
|
||
e.hp -= amount * (e.dmgTakenMul === undefined ? 1 : e.dmgTakenMul);
|
||
if (e.hp <= 0) killEnemy(e, rand(0, TAU));
|
||
}
|
||
|
||
function killEnemy(e, ang) {
|
||
if (e.dead) return;
|
||
spawnCorpse(e);
|
||
e.dead = true;
|
||
e.hp = 0;
|
||
const p = G.player;
|
||
if (p.stats.frenzy > 0) p.frenzyT = Math.max(p.frenzyT || 0, 3);
|
||
G.kills++;
|
||
addScore(e.boss ? 500 : (e.elite ? 40 : 10));
|
||
spawnBlood(e.x, e.y, ang || rand(0, TAU), e.boss ? 40 : (e.elite ? 20 : 10), e.boss || e.elite);
|
||
spawnGibs(e.x, e.y, e.boss ? 16 : (e.elite ? 8 : 4), e.boss || e.elite);
|
||
if (e.boss || e.elite) spawnShockwave(e.x, e.y, e.boss ? e.r * 2.4 : e.r * 1.7, '#b82a38', e.boss ? 0.9 : 0.55);
|
||
if (!e.boss) Sfx.enemyDie(e);
|
||
|
||
// Vampire Dentures heal on kills, naturally normalizing slow and rapid weapons.
|
||
const stealChance = clamp((p.stats.lifestealChance || 0) * 3, 0, 0.9);
|
||
if (p.hp < p.stats.maxHp && stealChance && chance(stealChance)) {
|
||
lifestealPlayer(e.boss ? 4 : (e.elite ? 2 : 1));
|
||
}
|
||
|
||
if (e.boss) { onBossDeath(e); return; }
|
||
|
||
// Volatile Bile: kills explode — radius and damage scale with tier
|
||
if (p.stats.explodeOnKill > 0) {
|
||
const rad = 60 + p.stats.explodeOnKill * 15;
|
||
areaDamage(e.x, e.y, rad, (10 + p.stats.explodeOnKill * 8) * p.stats.dmgMul, true);
|
||
spawnExplosionFx(e.x, e.y, rad);
|
||
Sfx.explode({ x: e.x, y: e.y });
|
||
}
|
||
|
||
// drops
|
||
const luck = p.stats.luck;
|
||
let gemVal = e.xp + (p.stats.bloodlust && chance(p.stats.bloodlust) ? e.xp : 0);
|
||
// Bloodrush keeps its XP multiplier and makes the bonus visible as extra crystals.
|
||
const xpBonusChance = clamp((p.stats.xpMul || 1) - 1, 0, 0.9);
|
||
if (xpBonusChance && chance(xpBonusChance)) gemVal += Math.max(1, Math.round(e.xp * 0.5));
|
||
if (e.elite) {
|
||
// special monsters: always bonus XP, mostly ammo, sometimes an item
|
||
gemVal += irand(3, 5);
|
||
spawnGems(e.x, e.y, gemVal);
|
||
if (chance(0.18 + luck * 0.1)) {
|
||
spawnPickup('item', e.x, e.y, { iid: randomItemId() });
|
||
} else if (chance(0.6 + luck * 0.2)) {
|
||
spawnPickup('ammo', e.x, e.y);
|
||
}
|
||
} else {
|
||
spawnGems(e.x, e.y, gemVal);
|
||
if (chance(0.07 + luck * 0.04)) {
|
||
spawnPickup('ammo', e.x, e.y);
|
||
} else if (chance(0.022 + luck * 0.03)) {
|
||
spawnPickup('heart', e.x, e.y);
|
||
}
|
||
}
|
||
|
||
// splitter splits
|
||
if (ENEMY_TYPES[e.type].splits && !e.elite) {
|
||
Sfx.split(e);
|
||
for (let i = 0; i < 2 && G.enemies.length < MAX_ENEMIES; i++) {
|
||
const m = makeEnemy('mini', e.x + rand(-12, 12), e.y + rand(-12, 12), G.floor, false);
|
||
G.enemies.push(m);
|
||
}
|
||
}
|
||
// exploder goes boom
|
||
if (ENEMY_TYPES[e.type].explodes) explodeAt(e.x, e.y, 60, 2, false);
|
||
}
|
||
|
||
function explodeAt(x, y, r, dmg, fromPlayer) {
|
||
spawnExplosionFx(x, y, r);
|
||
Sfx.explode({ x, y });
|
||
if (fromPlayer) {
|
||
areaDamage(x, y, r, dmg, true);
|
||
} else {
|
||
const p = G.player;
|
||
if (dist(x, y, p.x, p.y) < r + p.r) hurtPlayer(dmg, angleTo(x, y, p.x, p.y));
|
||
}
|
||
}
|
||
|
||
function updateEnemies(dt) {
|
||
const p = G.player;
|
||
for (let i = G.enemies.length - 1; i >= 0; i--) {
|
||
const e = G.enemies[i];
|
||
if (e.hp <= 0) { G.enemies.splice(i, 1); continue; }
|
||
e.spawnT = Math.min((e.spawnT || 0) + dt, 1);
|
||
e.animT = (e.animT || 0) + dt;
|
||
if (e.attackT > 0) { e.attackT -= dt; e.actionT += dt; }
|
||
|
||
// status effects
|
||
if (e.flash > 0) e.flash -= dt;
|
||
if (e.orbT > 0) e.orbT -= dt;
|
||
if (e.burnT > 0) {
|
||
e.burnT -= dt;
|
||
tickEnemyDamage(e, e.burnDps * dt);
|
||
if (chance(0.2)) addParticle({ type: 'flame', x: e.x + rand(-6, 6), y: e.y + rand(-6, 6), vx: 0, vy: -40, life: 0.3, t: 0, r: 3 });
|
||
if (e.hp <= 0) { G.enemies.splice(i, 1); continue; }
|
||
}
|
||
if (e.bleedT > 0) {
|
||
e.bleedT -= dt;
|
||
tickEnemyDamage(e, e.bleedDps * dt);
|
||
if (e.hp <= 0) { G.enemies.splice(i, 1); continue; }
|
||
}
|
||
if (e.slowT > 0) e.slowT -= dt;
|
||
if (e.stunT > 0) { e.stunT -= dt; e.vx = 0; e.vy = 0; continue; }
|
||
if (e.rootT > 0) { e.rootT -= dt; e.vx = 0; e.vy = 0; continue; }
|
||
if (e.dragged) { e.vx = 0; e.vy = 0; continue; } // harpooned
|
||
|
||
if (e.boss) { updateBoss(e, dt); }
|
||
else updateEnemyAI(e, dt);
|
||
|
||
// integrate + separation
|
||
e.x += e.vx * dt; e.y += e.vy * dt;
|
||
const drag = Math.pow(0.82, dt * 60);
|
||
e.vx *= drag; e.vy *= drag;
|
||
// Resolve each pair once instead of twice. This halves the hottest
|
||
// enemy-crowd loop while preserving the same mutual separation.
|
||
for (let j = i - 1; j >= 0; j--) {
|
||
const o = G.enemies[j];
|
||
if (o.hp <= 0) continue;
|
||
const d2 = dist2(e.x, e.y, o.x, o.y);
|
||
const min = (e.r + o.r) * 0.9;
|
||
if (d2 < min * min && d2 > 0.01) {
|
||
const d = Math.sqrt(d2), push = (min - d) / d * 30 * dt;
|
||
const px = (e.x - o.x) * push, py = (e.y - o.y) * push;
|
||
e.x += px; e.y += py; o.x -= px; o.y -= py;
|
||
}
|
||
}
|
||
e.x = clamp(e.x, WALL + e.r, W - WALL - e.r);
|
||
e.y = clamp(e.y, WALL + e.r, H - WALL - e.r);
|
||
|
||
// contact damage
|
||
if (e.hitT > 0) e.hitT -= dt;
|
||
if (!e.phased && e.hitT <= 0 && p.hp > 0 && dist2(e.x, e.y, p.x, p.y) < (e.r + p.r) * (e.r + p.r)) {
|
||
e.attackT = 0.3; e.actionT = 0;
|
||
hurtPlayer(e.dmg, angleTo(e.x, e.y, p.x, p.y), e);
|
||
e.hitT = 0.7;
|
||
}
|
||
}
|
||
}
|
||
|
||
function updateEnemyAI(e, dt) {
|
||
const p = G.player;
|
||
const a = angleTo(e.x, e.y, p.x, p.y);
|
||
const d = dist(e.x, e.y, p.x, p.y);
|
||
const spd = e.slowT > 0 ? e.spd * 0.45 : e.spd;
|
||
const t = ENEMY_TYPES[e.type];
|
||
|
||
if (t.ranged) {
|
||
// spitter: hold ~230px range and fire
|
||
if (d > 250) { e.vx += Math.cos(a) * spd * 3 * dt; e.vy += Math.sin(a) * spd * 3 * dt; }
|
||
else if (d < 190) { e.vx -= Math.cos(a) * spd * 3 * dt; e.vy -= Math.sin(a) * spd * 3 * dt; }
|
||
e.fireT -= dt;
|
||
if (e.fireT <= 0 && d < 420) {
|
||
e.fireT = e.elite ? 1.1 : 1.9;
|
||
e.attackT = 0.34; e.actionT = 0;
|
||
const n = e.elite ? 3 : 1;
|
||
for (let k = 0; k < n; k++) {
|
||
const fa = a + (n > 1 ? (k - 1) * 0.25 : 0);
|
||
G.ebullets.push({
|
||
x: e.x, y: e.y, vx: Math.cos(fa) * 220, vy: Math.sin(fa) * 220,
|
||
r: 5, dmg: 1, life: 3, t: 0, sprite: 'bullet_gore',
|
||
});
|
||
}
|
||
Sfx.spit(e);
|
||
}
|
||
} else if (t.explodes) {
|
||
e.vx += Math.cos(a) * spd * 4 * dt; e.vy += Math.sin(a) * spd * 4 * dt;
|
||
if (e.fuse < 0 && d < 56) { e.fuse = 0.5; e.attackT = 0.5; e.actionT = 0; Sfx.fuse(e); }
|
||
if (e.fuse >= 0) {
|
||
e.fuse -= dt;
|
||
e.flash = 0.05;
|
||
if (e.fuse <= 0) { e.hp = 0; explodeAt(e.x, e.y, 70, 2, false); }
|
||
}
|
||
} else {
|
||
// chaser with a little wobble
|
||
e.wob += dt * 3;
|
||
const wa = a + Math.sin(e.wob) * 0.3;
|
||
e.vx += Math.cos(wa) * spd * 4 * dt; e.vy += Math.sin(wa) * spd * 4 * dt;
|
||
}
|
||
}
|
||
|
||
function drawEnemies(ctx) {
|
||
for (const e of G.enemies) {
|
||
if (e.hp <= 0) continue;
|
||
const p = G.player;
|
||
const face = angleTo(e.x, e.y, p.x, p.y);
|
||
const speed = Math.min(Math.hypot(e.vx, e.vy) / Math.max(e.spd, 1), 1);
|
||
let action = speed > 0.12 ? 'move' : 'idle';
|
||
let animTime = e.animT || 0;
|
||
if (e.attackT > 0 || (e.boss && e.state !== 'idle')) {
|
||
action = 'attack';
|
||
animTime = e.attackT > 0 ? e.actionT : (e.animT || 0);
|
||
}
|
||
if (e.flash > 0) { action = 'hit'; animTime = 0.12 - e.flash; }
|
||
let pulse = 1;
|
||
if (e.type === 'exploder' && e.fuse >= 0) pulse = 1 + (0.5 - e.fuse) * 0.13 + Math.sin(G.time * 28) * 0.04;
|
||
const appear = clamp((e.spawnT || 0) / 0.24, 0.12, 1);
|
||
if (e.alpha === undefined || e.alpha > 0.05) Sprites.shadow(ctx, e.x, e.y + e.r * 0.55, e.r * 0.9, e.r * 0.34, (e.boss ? 0.5 : 0.34) * (e.alpha === undefined ? 1 : e.alpha));
|
||
Sprites.actor(ctx, e.sprite, e.x, e.y, face, action, animTime,
|
||
e.drawSize || (e.boss ? 128 : 64), e.alpha === undefined ? 1 : e.alpha, appear * pulse, appear * pulse);
|
||
if (e.plates > 0) {
|
||
ctx.save(); ctx.translate(e.x, e.y); ctx.lineWidth = 4;
|
||
for (let k = 0; k < e.plates; k++) {
|
||
ctx.strokeStyle = k % 2 ? '#8d755d' : '#b79b71';
|
||
ctx.beginPath(); ctx.arc(0, 0, e.r + 7, k * Math.PI / 2 + 0.08, k * Math.PI / 2 + 1.25); ctx.stroke();
|
||
}
|
||
ctx.restore();
|
||
}
|
||
if (e.elite) {
|
||
ctx.strokeStyle = '#ffd060'; ctx.lineWidth = 2; ctx.globalAlpha = 0.7;
|
||
ctx.beginPath(); ctx.arc(e.x, e.y, e.r + 3, 0, TAU); ctx.stroke();
|
||
ctx.globalAlpha = 1;
|
||
}
|
||
// boss & elite hp pip
|
||
if (e.boss || e.elite) {
|
||
const w = e.boss ? 60 : 26;
|
||
ctx.fillStyle = '#400a10';
|
||
ctx.fillRect(e.x - w / 2, e.y - e.r - 10, w, 4);
|
||
ctx.fillStyle = '#d92038';
|
||
ctx.fillRect(e.x - w / 2, e.y - e.r - 10, w * clamp(e.hp / e.maxHp, 0, 1), 4);
|
||
}
|
||
}
|
||
}
|