226 lines
8.0 KiB
JavaScript
226 lines
8.0 KiB
JavaScript
/**
|
|
* Entscheidungslogik der Gegner (ohne Phaser): Bewegung pro Verhalten,
|
|
* Sprungangriff, Schuss-Salven, Brut. Die Entities rufen diese Funktionen jeden
|
|
* Frame auf und setzen das Ergebnis in Physik und Grafik um.
|
|
*
|
|
* Zustände liegen in kleinen, veränderlichen „Brain“-Objekten pro Gegner. Das ist
|
|
* bewusst kein unveränderlicher Stil: Bei 60 Gegnern und 60 FPS sollen pro Frame
|
|
* keine Objektberge für den Garbage Collector entstehen.
|
|
* @module logic/enemyAi
|
|
*/
|
|
|
|
import { degToRad, distance, normalize, scale, sub } from './math.js';
|
|
import { encirclePoint, flankPoint, keepDistance, seek } from './steering.js';
|
|
|
|
/** @typedef {import('./math.js').Vec2} Vec2 */
|
|
|
|
/**
|
|
* @typedef {Object} Brain
|
|
* @property {number} slotAngle Anflugwinkel im Schwarm (Bogenmaß).
|
|
* @property {1|-1} strafeDirection Richtung beim seitlichen Ausweichen.
|
|
* @property {number} nextStrafeSwitchAt
|
|
* @property {1|-1} flankSide Seite, von der flankiert wird.
|
|
* @property {'chase'|'windup'|'leap'} leapState
|
|
* @property {number} leapStateUntil
|
|
* @property {number} nextLeapAt
|
|
* @property {Vec2} leapDirection
|
|
* @property {AttackState} attack
|
|
* @property {AttackState} mortar
|
|
* @property {number} nextBroodAt
|
|
*/
|
|
|
|
/**
|
|
* @typedef {Object} AttackState
|
|
* @property {number} nextAttackAt
|
|
* @property {number} burstRemaining
|
|
* @property {number} nextShotAt
|
|
*/
|
|
|
|
/**
|
|
* Neuer Angriffszustand. `firstAttackAt` verzögert den ersten Schuss, damit frisch
|
|
* gespawnte Gegner nicht sofort und alle gleichzeitig feuern.
|
|
* @param {number} firstAttackAt
|
|
* @returns {AttackState}
|
|
*/
|
|
export function createAttackState(firstAttackAt = 0) {
|
|
return { nextAttackAt: firstAttackAt, burstRemaining: 0, nextShotAt: 0 };
|
|
}
|
|
|
|
/**
|
|
* Neues Brain mit zufälligen, aber reproduzierbaren Eigenheiten.
|
|
* @param {import('./rng.js').Rng} rng
|
|
* @param {number} now
|
|
* @param {{firstAttackDelayMs?: number}} [options]
|
|
* @returns {Brain}
|
|
*/
|
|
export function createBrain(rng, now, options = {}) {
|
|
const firstAttackAt = now + (options.firstAttackDelayMs ?? 0) * (0.5 + rng());
|
|
return {
|
|
slotAngle: rng() * Math.PI * 2,
|
|
strafeDirection: rng() < 0.5 ? 1 : -1,
|
|
nextStrafeSwitchAt: now,
|
|
flankSide: rng() < 0.5 ? 1 : -1,
|
|
leapState: 'chase',
|
|
leapStateUntil: 0,
|
|
nextLeapAt: now,
|
|
leapDirection: { x: 0, y: 0 },
|
|
attack: createAttackState(firstAttackAt),
|
|
mortar: createAttackState(firstAttackAt + (options.firstAttackDelayMs ?? 0)),
|
|
nextBroodAt: now + (options.firstAttackDelayMs ?? 0),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Wechselt gelegentlich die Ausweichrichtung, damit Fernkämpfer nicht vorhersehbar kreisen.
|
|
* @param {Brain} brain
|
|
* @param {number} now
|
|
* @param {{min: number, max: number}} switchMs
|
|
* @param {import('./rng.js').Rng} rng
|
|
*/
|
|
export function updateStrafe(brain, now, switchMs, rng) {
|
|
if (now >= brain.nextStrafeSwitchAt) {
|
|
brain.strafeDirection = brain.strafeDirection === 1 ? -1 : 1;
|
|
brain.nextStrafeSwitchAt = now + switchMs.min + rng() * (switchMs.max - switchMs.min);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Schwarm: aus der Distanz den eigenen Platz im Umzingelungskreis ansteuern,
|
|
* in Reichweite direkt angreifen. So kommt ein Rudel von mehreren Seiten.
|
|
* @param {Brain} brain
|
|
* @param {Vec2} self
|
|
* @param {Vec2} player
|
|
* @param {number} speed
|
|
* @param {{engageRange: number, encircleRadius: number}} type
|
|
* @returns {Vec2}
|
|
*/
|
|
export function swarmVelocity(brain, self, player, speed, type) {
|
|
if (distance(self, player) <= type.engageRange) {
|
|
return seek(self, player, speed);
|
|
}
|
|
return seek(self, encirclePoint(player, brain.slotAngle, type.encircleRadius), speed);
|
|
}
|
|
|
|
/**
|
|
* Sprungkralle: verfolgen → ansetzen (stillstehen, Vorwarnung) → springen → verfolgen.
|
|
* Die Sprungrichtung wird beim Ansetzen festgelegt: Wer die Vorwarnung sieht, kann
|
|
* ausweichen. Das ist die „Fairness“ des Angriffs.
|
|
* @param {Brain} brain
|
|
* @param {Vec2} self
|
|
* @param {Vec2} player
|
|
* @param {number} now
|
|
* @param {number} speed
|
|
* @param {{triggerRange: number, windupMs: number, speed: number, durationMs: number, cooldownMs: number}} leap
|
|
* @returns {{velocity: Vec2, telegraph: boolean, leaping: boolean}}
|
|
*/
|
|
export function leaperStep(brain, self, player, now, speed, leap) {
|
|
if (brain.leapState === 'windup') {
|
|
if (now < brain.leapStateUntil) {
|
|
return { velocity: { x: 0, y: 0 }, telegraph: true, leaping: false };
|
|
}
|
|
brain.leapState = 'leap';
|
|
brain.leapStateUntil = now + leap.durationMs;
|
|
}
|
|
if (brain.leapState === 'leap') {
|
|
if (now < brain.leapStateUntil) {
|
|
return { velocity: scale(brain.leapDirection, leap.speed), telegraph: false, leaping: true };
|
|
}
|
|
brain.leapState = 'chase';
|
|
brain.nextLeapAt = now + leap.cooldownMs;
|
|
}
|
|
// chase
|
|
if (distance(self, player) <= leap.triggerRange && now >= brain.nextLeapAt) {
|
|
brain.leapState = 'windup';
|
|
brain.leapStateUntil = now + leap.windupMs;
|
|
brain.leapDirection = normalize(sub(player, self));
|
|
return { velocity: { x: 0, y: 0 }, telegraph: true, leaping: false };
|
|
}
|
|
return { velocity: seek(self, player, speed), telegraph: false, leaping: false };
|
|
}
|
|
|
|
/**
|
|
* Fernkämpfer auf Abstand (Nieter-Drohne, Walzmeister).
|
|
* @param {Brain} brain
|
|
* @param {Vec2} self
|
|
* @param {Vec2} player
|
|
* @param {number} speed
|
|
* @param {{min: number, max: number}} range
|
|
* @returns {Vec2}
|
|
*/
|
|
export function kiteVelocity(brain, self, player, speed, range) {
|
|
return keepDistance(self, player, range, speed, brain.strafeDirection);
|
|
}
|
|
|
|
/**
|
|
* Flankierer (Blechsoldat): steuert eine Position seitlich des Spielers an und
|
|
* hält dort Abstand. Nah an der Flankenposition geht er ins Abstandhalten über.
|
|
* @param {Brain} brain
|
|
* @param {Vec2} self
|
|
* @param {Vec2} player
|
|
* @param {number} speed
|
|
* @param {{flankAngleDeg: number, flankDistance: number, range: {min: number, max: number}}} type
|
|
* @returns {Vec2}
|
|
*/
|
|
export function flankVelocity(brain, self, player, speed, type) {
|
|
const target = flankPoint(player, self, degToRad(type.flankAngleDeg) * brain.flankSide, type.flankDistance);
|
|
// Ist die Flanke (fast) erreicht, wie ein Fernkämpfer weiterkämpfen.
|
|
if (distance(self, target) < type.range.min * 0.5) {
|
|
return keepDistance(self, player, type.range, speed, brain.flankSide);
|
|
}
|
|
return seek(self, target, speed);
|
|
}
|
|
|
|
/**
|
|
* Taktgeber für Schüsse und Salven.
|
|
* @param {AttackState} state
|
|
* @param {number} now
|
|
* @param {number} distanceToPlayer
|
|
* @param {{cooldownMs: number, burst?: number, burstIntervalMs?: number, maxDistance: number}} attack
|
|
* @returns {boolean} true, wenn in diesem Frame geschossen werden soll.
|
|
*/
|
|
export function attackStep(state, now, distanceToPlayer, attack) {
|
|
if (state.burstRemaining > 0) {
|
|
if (now >= state.nextShotAt) {
|
|
state.burstRemaining -= 1;
|
|
state.nextShotAt = now + (attack.burstIntervalMs ?? 0);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (now >= state.nextAttackAt && distanceToPlayer <= attack.maxDistance) {
|
|
state.burstRemaining = (attack.burst ?? 1) - 1;
|
|
state.nextShotAt = now + (attack.burstIntervalMs ?? 0);
|
|
state.nextAttackAt = now + attack.cooldownMs;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Winkel aller Projektile einer Salve, gleichmäßig über `spreadDeg` verteilt.
|
|
* @param {number} baseAngle Bogenmaß (Richtung zum Ziel).
|
|
* @param {number} count
|
|
* @param {number} spreadDeg Gesamtbreite des Fächers in Grad.
|
|
* @returns {number[]}
|
|
*/
|
|
export function volleyAngles(baseAngle, count, spreadDeg) {
|
|
if (count <= 1) return [baseAngle];
|
|
const spread = degToRad(spreadDeg);
|
|
const step = spread / (count - 1);
|
|
return Array.from({ length: count }, (_, i) => baseAngle - spread / 2 + i * step);
|
|
}
|
|
|
|
/**
|
|
* Brutmutter: Wie viele Krabbler jetzt schlüpfen sollen.
|
|
* @param {Brain} brain
|
|
* @param {number} now
|
|
* @param {number} aliveChildren Aktuell lebende Nachkommen dieser Brutmutter.
|
|
* @param {{intervalMs: number, spawnCount: number, maxChildren: number}} brood
|
|
* @returns {number}
|
|
*/
|
|
export function broodStep(brain, now, aliveChildren, brood) {
|
|
if (now < brain.nextBroodAt) return 0;
|
|
brain.nextBroodAt = now + brood.intervalMs;
|
|
return Math.max(0, Math.min(brood.spawnCount, brood.maxChildren - aliveChildren));
|
|
}
|