251 lines
8.6 KiB
JavaScript
251 lines
8.6 KiB
JavaScript
/**
|
||
* Gegner beider Fraktionen. Das Verhalten kommt aus `config.ENEMY_TYPES[type].behavior`,
|
||
* die Entscheidungen trifft die Phaser-freie Logik in `logic/enemyAi.js`. Diese
|
||
* Klasse setzt sie nur in Physik, Drehung und Grafik um.
|
||
* @module entities/Enemy
|
||
*/
|
||
|
||
import { AI, ENEMY_TYPES, GAME, PLAYER } from '../config.js';
|
||
import {
|
||
attackStep,
|
||
broodStep,
|
||
createBrain,
|
||
flankVelocity,
|
||
kiteVelocity,
|
||
leaperStep,
|
||
swarmVelocity,
|
||
updateStrafe,
|
||
volleyAngles,
|
||
} from '../logic/enemyAi.js';
|
||
import { angleTo, degToRad, distance, scale } from '../logic/math.js';
|
||
import { combine, seek, separation, steerTowards } from '../logic/steering.js';
|
||
import { TEXTURE_KEYS } from '../systems/Placeholders.js';
|
||
|
||
/** Frisch gespawnte Gegner schießen nicht sofort (Fairness). */
|
||
const FIRST_ATTACK_DELAY_MS = 1100;
|
||
/** Unter dieser Geschwindigkeit bleibt die Blickrichtung stehen (verhindert Zittern). */
|
||
const MIN_TURN_SPEED = 12;
|
||
/** Farbe der Vorwarnung vor dem Sprungangriff. */
|
||
const TELEGRAPH_TINT = 0xff5040;
|
||
/** Verhalten, die im Nahkampf angreifen. */
|
||
const MELEE_BEHAVIORS = new Set(['swarm', 'leaper', 'brood']);
|
||
/** Stärke der Leerlauf-Animationen (Anteil der Größe). */
|
||
const ANIMATION = Object.freeze({ periodMs: 90, swarmWobble: 0.09, broodPulse: 0.04, hoverBob: 0.04 });
|
||
|
||
/**
|
||
* @typedef {Object} EnemyContext
|
||
* @property {{x: number, y: number}} player
|
||
* @property {Phaser.GameObjects.GameObject[]} neighbors
|
||
* @property {() => number} rng
|
||
* @property {(x: number, y: number, angle: number, speed: number, damage: number) => void} fireBullet
|
||
* @property {(enemy: Enemy, count: number) => void} spawnChildren
|
||
* @property {(x: number, y: number, mortar: object) => void} scheduleMortar
|
||
*/
|
||
|
||
let nextEnemyId = 1;
|
||
|
||
export class Enemy extends Phaser.Physics.Arcade.Sprite {
|
||
/**
|
||
* @param {Phaser.Scene} scene
|
||
* @param {number} x
|
||
* @param {number} y
|
||
* @param {string} typeId Schlüssel aus ENEMY_TYPES.
|
||
* @param {{now: number, rng: () => number, hpMultiplier?: number, speedMultiplier?: number, parent?: Enemy|null}} options
|
||
*/
|
||
constructor(scene, x, y, typeId, options) {
|
||
super(scene, x, y, TEXTURE_KEYS.enemy(typeId));
|
||
this.id = nextEnemyId;
|
||
nextEnemyId += 1;
|
||
this.type = ENEMY_TYPES[typeId];
|
||
/** Wellen-Multiplikatoren; ausgebrütete Krabbler erben sie von der Brutmutter. */
|
||
this.multipliers = { hp: options.hpMultiplier ?? 1, speed: options.speedMultiplier ?? 1 };
|
||
this.maxHp = Math.round(this.type.hp * this.multipliers.hp);
|
||
this.hp = this.maxHp;
|
||
this.speed = this.type.speed * this.multipliers.speed;
|
||
this.brain = createBrain(options.rng, options.now, { firstAttackDelayMs: FIRST_ATTACK_DELAY_MS });
|
||
this.alive = true;
|
||
this.lastContactAt = -Infinity;
|
||
this.leaping = false;
|
||
this.telegraphing = false;
|
||
/** @type {Enemy|null} Brutmutter, von der dieser Krabbler stammt. */
|
||
this.parentEnemy = options.parent ?? null;
|
||
this.childCount = 0;
|
||
|
||
scene.add.existing(this);
|
||
scene.physics.add.existing(this);
|
||
this.setDepth(GAME.depth.enemies);
|
||
}
|
||
|
||
/** Physik-Körper einrichten – erst nach dem Einfügen in die Physik-Gruppe aufrufen. */
|
||
initBody() {
|
||
const r = this.type.radius;
|
||
this.body.setCircle(r, this.width / 2 - r, this.height / 2 - r);
|
||
this.setCollideWorldBounds(true);
|
||
}
|
||
|
||
/** @returns {boolean} */
|
||
get isElite() {
|
||
return this.type.tier === 'elite';
|
||
}
|
||
|
||
/**
|
||
* Ein KI-Schritt: Wunschgeschwindigkeit bestimmen, Angriffe auslösen.
|
||
* @param {number} now Spielzeit in ms.
|
||
* @param {EnemyContext} ctx
|
||
*/
|
||
step(now, ctx) {
|
||
if (!this.alive) return;
|
||
const { player } = ctx;
|
||
const type = this.type;
|
||
let desired;
|
||
let responsiveness = AI.steeringResponsiveness;
|
||
let faceTarget = false;
|
||
|
||
switch (type.behavior) {
|
||
case 'swarm':
|
||
desired = swarmVelocity(this.brain, this, player, this.speed, type);
|
||
break;
|
||
case 'leaper': {
|
||
const result = leaperStep(this.brain, this, player, now, this.speed, type.leap);
|
||
desired = result.velocity;
|
||
this.leaping = result.leaping;
|
||
if (result.leaping || result.telegraph) responsiveness = 1;
|
||
this.setTelegraph(result.telegraph);
|
||
break;
|
||
}
|
||
case 'brood': {
|
||
desired = seek(this, player, this.speed);
|
||
const hatch = broodStep(this.brain, now, this.childCount, type.brood);
|
||
if (hatch > 0) ctx.spawnChildren(this, hatch);
|
||
break;
|
||
}
|
||
case 'kite':
|
||
updateStrafe(this.brain, now, AI.strafeSwitchMs, ctx.rng);
|
||
desired = kiteVelocity(this.brain, this, player, this.speed, type.range);
|
||
faceTarget = true;
|
||
this.tryAttack(now, ctx);
|
||
break;
|
||
case 'flank':
|
||
desired = flankVelocity(this.brain, this, player, this.speed, type);
|
||
faceTarget = true;
|
||
this.tryAttack(now, ctx);
|
||
break;
|
||
case 'siege':
|
||
updateStrafe(this.brain, now, AI.strafeSwitchMs, ctx.rng);
|
||
desired = kiteVelocity(this.brain, this, player, this.speed, type.range);
|
||
faceTarget = true;
|
||
this.tryAttack(now, ctx);
|
||
this.tryMortar(now, ctx);
|
||
break;
|
||
default:
|
||
desired = seek(this, player, this.speed);
|
||
}
|
||
|
||
// Nahkämpfer bleiben am Präsidenten „kleben“, statt sich auf seinen Mittelpunkt zu
|
||
// drängen – sonst stapeln sie sich unlesbar übereinander.
|
||
if (MELEE_BEHAVIORS.has(type.behavior) && !this.leaping) {
|
||
if (distance(this, player) < PLAYER.radius + type.radius) desired = { x: 0, y: 0 };
|
||
}
|
||
|
||
// Abstand zu Nachbarn – außer im Sprung, der soll geradlinig bleiben.
|
||
if (!this.leaping) {
|
||
const push = separation(this, ctx.neighbors, AI.separationRadius + type.radius);
|
||
desired = combine(
|
||
[
|
||
{ vector: desired, weight: 1 },
|
||
{ vector: scale(push, this.speed), weight: AI.separationWeight },
|
||
],
|
||
this.speed,
|
||
);
|
||
}
|
||
|
||
const velocity = steerTowards(this.body.velocity, desired, responsiveness);
|
||
this.setVelocity(velocity.x, velocity.y);
|
||
|
||
if (faceTarget) {
|
||
this.setRotation(angleTo(this, player));
|
||
} else if (Math.hypot(velocity.x, velocity.y) > MIN_TURN_SPEED) {
|
||
this.setRotation(Math.atan2(velocity.y, velocity.x));
|
||
}
|
||
this.animate(now);
|
||
}
|
||
|
||
/**
|
||
* Kleine Lebenszeichen ohne Spritesheet: Insekten wackeln beim Laufen, die Brutmutter
|
||
* pulsiert, Drohnen schweben. Die ID verschiebt die Phase, damit nicht alle im Takt wippen.
|
||
* @param {number} now
|
||
*/
|
||
animate(now) {
|
||
if (this.telegraphing) return;
|
||
const phase = now / ANIMATION.periodMs + this.id;
|
||
if (this.type.behavior === 'brood') {
|
||
this.setScale(1 + ANIMATION.broodPulse * Math.sin(phase * 0.35));
|
||
} else if (this.type.faction === 'swarm') {
|
||
const moving = Math.hypot(this.body.velocity.x, this.body.velocity.y) > MIN_TURN_SPEED;
|
||
this.setScale(1, moving ? 1 + ANIMATION.swarmWobble * Math.sin(phase * 2.2) : 1);
|
||
} else if (this.type.behavior === 'kite') {
|
||
this.setScale(1 + ANIMATION.hoverBob * Math.sin(phase));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Schießt gemäß Takt des Gegnertyps.
|
||
* @param {number} now
|
||
* @param {EnemyContext} ctx
|
||
*/
|
||
tryAttack(now, ctx) {
|
||
const attack = this.type.attack;
|
||
if (!attackStep(this.brain.attack, now, distance(this, ctx.player), attack)) return;
|
||
let base = angleTo(this, ctx.player);
|
||
// Einzelschüsse streuen leicht, Fächersalven sind bereits breit.
|
||
if (attack.count === 1 && attack.spreadDeg > 0) {
|
||
base += (ctx.rng() - 0.5) * degToRad(attack.spreadDeg);
|
||
}
|
||
const reach = this.type.radius + 6;
|
||
for (const angle of volleyAngles(base, attack.count, attack.spreadDeg)) {
|
||
ctx.fireBullet(this.x + Math.cos(angle) * reach, this.y + Math.sin(angle) * reach, angle, attack.speed, attack.damage);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Walzmeister: Mörser auf die aktuelle Spielerposition (mit Bodenmarkierung).
|
||
* @param {number} now
|
||
* @param {EnemyContext} ctx
|
||
*/
|
||
tryMortar(now, ctx) {
|
||
const mortar = this.type.mortar;
|
||
if (!mortar) return;
|
||
if (attackStep(this.brain.mortar, now, distance(this, ctx.player), mortar)) {
|
||
ctx.scheduleMortar(ctx.player.x, ctx.player.y, mortar);
|
||
}
|
||
}
|
||
|
||
/** @param {boolean} active */
|
||
setTelegraph(active) {
|
||
if (active === this.telegraphing) return;
|
||
this.telegraphing = active;
|
||
if (active) {
|
||
this.setTint(TELEGRAPH_TINT);
|
||
this.setScale(1.15);
|
||
} else {
|
||
this.clearTint();
|
||
this.setScale(1);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @param {number} amount
|
||
* @returns {boolean} true, wenn der Gegner dadurch stirbt.
|
||
*/
|
||
takeDamage(amount) {
|
||
if (!this.alive) return false;
|
||
this.hp -= amount;
|
||
if (this.hp <= 0) {
|
||
this.hp = 0;
|
||
this.alive = false;
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
}
|