jakciehan
372 lines
13 KiB
TypeScript
372 lines
13 KiB
TypeScript
import { AttackType, EnemyType, IEnemyConfig, IReinforcementRule } from '../data/Interfaces';
|
|
|
|
/**
|
|
* Enemy AI base class + four concrete subclasses (req 6.1-6.7).
|
|
*
|
|
* Each enemy is modelled as a tiny state machine that ticks on `update(dt)`
|
|
* and emits an `IEnemyAction[]` the level manager then spawns into the world
|
|
* (bullets / smoke bombs / fireballs / sword swings).
|
|
*
|
|
* Enemies outside the camera's culling rect can be frozen by simply skipping
|
|
* `update()` — see `EnemyManager.update()` below (requirement 6.7 / 18.5).
|
|
*/
|
|
|
|
export interface IEnemyAction {
|
|
kind: 'fire_bullet' | 'melee_swing' | 'spawn_item' | 'drop_item';
|
|
attackType?: AttackType;
|
|
/** Origin of the projectile, world coords. */
|
|
originX?: number;
|
|
originY?: number;
|
|
/** Velocity of the projectile. */
|
|
velX?: number;
|
|
velY?: number;
|
|
/** For drop_item only — item id + world coords. */
|
|
itemId?: string;
|
|
}
|
|
|
|
export interface IPlayerSense {
|
|
x: number;
|
|
y: number;
|
|
isGrounded: boolean;
|
|
}
|
|
|
|
export interface IEnemyAABB {
|
|
x: number;
|
|
y: number;
|
|
w: number;
|
|
h: number;
|
|
}
|
|
|
|
export interface IEnemyUpdateCtx {
|
|
dtSec: number;
|
|
nowMs: number;
|
|
player: IPlayerSense;
|
|
}
|
|
|
|
export abstract class EnemyAIBase {
|
|
public readonly type: EnemyType;
|
|
public pos: { x: number; y: number };
|
|
public alive = true;
|
|
public hp: number;
|
|
protected cooldownSec = 0;
|
|
protected readonly cfg: IEnemyConfig;
|
|
|
|
constructor(cfg: IEnemyConfig, spawnX: number, spawnY: number) {
|
|
this.cfg = cfg;
|
|
this.type = cfg.id;
|
|
this.pos = { x: spawnX, y: spawnY };
|
|
this.hp = cfg.hp;
|
|
}
|
|
|
|
public abstract update(ctx: IEnemyUpdateCtx): IEnemyAction[];
|
|
|
|
public get aabb(): IEnemyAABB {
|
|
return { x: this.pos.x, y: this.pos.y, w: this.cfg.size.w, h: this.cfg.size.h };
|
|
}
|
|
|
|
protected decrementCooldown(dtSec: number): boolean {
|
|
this.cooldownSec -= dtSec;
|
|
if (this.cooldownSec > 0) return false;
|
|
this.cooldownSec = this.cfg.attackIntervalSec;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// ---------- Qing Ren (req 6.1) --------------------------------------------
|
|
export class QingRenAI extends EnemyAIBase {
|
|
public update(ctx: IEnemyUpdateCtx): IEnemyAction[] {
|
|
if (!this.decrementCooldown(ctx.dtSec)) return [];
|
|
const dx = ctx.player.x - this.pos.x;
|
|
const horizontalDistance = Math.abs(dx);
|
|
const direction = dx >= 0 ? 1 : -1;
|
|
if (horizontalDistance < 64) {
|
|
return [{ kind: 'melee_swing', attackType: 'sword' }];
|
|
}
|
|
return [
|
|
{
|
|
kind: 'fire_bullet',
|
|
attackType: 'shuriken',
|
|
originX: this.pos.x,
|
|
originY: this.pos.y,
|
|
velX: 240 * direction,
|
|
velY: 0,
|
|
},
|
|
];
|
|
}
|
|
}
|
|
|
|
// ---------- Chi Ren (req 6.2-6.4) -----------------------------------------
|
|
export class ChiRenAI extends EnemyAIBase {
|
|
private interceptCooldown = 0;
|
|
|
|
public update(ctx: IEnemyUpdateCtx): IEnemyAction[] {
|
|
// Patrol horizontally toward the player at 120px/s (req 6.2).
|
|
const dx = ctx.player.x - this.pos.x;
|
|
const direction = dx >= 0 ? 1 : -1;
|
|
this.pos.x += direction * this.cfg.moveSpeed * ctx.dtSec;
|
|
|
|
// Proactive intercept jump when player stands still within vision (req 6.3).
|
|
if (this.interceptCooldown > 0) this.interceptCooldown -= ctx.dtSec;
|
|
const playerIdle = Math.abs(ctx.player.x - this.pos.x) < 200 && ctx.player.isGrounded;
|
|
if (playerIdle && this.interceptCooldown <= 0) {
|
|
this.interceptCooldown = 3;
|
|
// Intercept arc: +X velocity + upward bounce, treated as position warp.
|
|
this.pos.y += 48;
|
|
}
|
|
|
|
if (!this.decrementCooldown(ctx.dtSec)) return [];
|
|
return [
|
|
{
|
|
kind: 'fire_bullet',
|
|
attackType: 'smoke_bomb',
|
|
originX: this.pos.x,
|
|
originY: this.pos.y,
|
|
velX: 140 * direction,
|
|
velY: 0,
|
|
},
|
|
];
|
|
}
|
|
}
|
|
|
|
// ---------- Hei Ren (req 6.5) ---------------------------------------------
|
|
export class HeiRenAI extends EnemyAIBase {
|
|
private hasDroppedMagicFlute = false;
|
|
|
|
public update(ctx: IEnemyUpdateCtx): IEnemyAction[] {
|
|
if (!this.decrementCooldown(ctx.dtSec)) return [];
|
|
const dx = ctx.player.x - this.pos.x;
|
|
const direction = dx >= 0 ? 1 : -1;
|
|
if (Math.abs(dx) < 96) {
|
|
return [{ kind: 'melee_swing', attackType: 'sword' }];
|
|
}
|
|
return [
|
|
{
|
|
kind: 'fire_bullet',
|
|
attackType: 'shuriken',
|
|
originX: this.pos.x,
|
|
originY: this.pos.y,
|
|
velX: 200 * direction,
|
|
velY: 0,
|
|
},
|
|
];
|
|
}
|
|
|
|
/** Called by EnemyManager on death — yields at most one magic flute. */
|
|
public onKilled(): IEnemyAction[] {
|
|
if (this.hasDroppedMagicFlute) return [];
|
|
this.hasDroppedMagicFlute = true;
|
|
return [{ kind: 'drop_item', itemId: 'mo_di', originX: this.pos.x, originY: this.pos.y }];
|
|
}
|
|
}
|
|
|
|
// ---------- Yao Fang (req 6.6) --------------------------------------------
|
|
export class YaoFangAI extends EnemyAIBase {
|
|
public update(ctx: IEnemyUpdateCtx): IEnemyAction[] {
|
|
if (!this.decrementCooldown(ctx.dtSec)) return [];
|
|
const dx = ctx.player.x - this.pos.x;
|
|
const direction = dx >= 0 ? 1 : -1;
|
|
return [
|
|
{
|
|
kind: 'fire_bullet',
|
|
attackType: 'fireball',
|
|
originX: this.pos.x,
|
|
originY: this.pos.y,
|
|
velX: 260 * direction,
|
|
velY: 0,
|
|
},
|
|
];
|
|
}
|
|
}
|
|
|
|
// ---------- Manager with camera-culling (req 6.7) -------------------------
|
|
|
|
export interface ICullingRect {
|
|
leftX: number;
|
|
rightX: number;
|
|
topY: number;
|
|
bottomY: number;
|
|
}
|
|
|
|
export class EnemyManager {
|
|
private readonly enemies: EnemyAIBase[] = [];
|
|
|
|
public spawn(enemy: EnemyAIBase): void {
|
|
this.enemies.push(enemy);
|
|
}
|
|
|
|
public get all(): ReadonlyArray<EnemyAIBase> {
|
|
return this.enemies;
|
|
}
|
|
|
|
/**
|
|
* Update all live enemies that intersect `cull` (with optional margin).
|
|
* Returns the concatenated list of actions emitted so the caller
|
|
* (LevelMgr) can instantiate projectiles, drops, etc.
|
|
*
|
|
* @param cullingMargin Extra pixels beyond `cull` to still activate enemies.
|
|
* Used for reinforcements that spawn just outside the screen.
|
|
*/
|
|
public update(dtSec: number, nowMs: number, player: IPlayerSense, cull: ICullingRect, cullingMargin = 0): IEnemyAction[] {
|
|
const actions: IEnemyAction[] = [];
|
|
for (const e of this.enemies) {
|
|
if (!e.alive) continue;
|
|
if (!this.inside(e, cull, cullingMargin)) continue;
|
|
const ctx: IEnemyUpdateCtx = { dtSec, nowMs, player };
|
|
actions.push(...e.update(ctx));
|
|
}
|
|
return actions;
|
|
}
|
|
|
|
public kill(enemy: EnemyAIBase): IEnemyAction[] {
|
|
enemy.alive = false;
|
|
if (enemy instanceof HeiRenAI) return enemy.onKilled();
|
|
return [];
|
|
}
|
|
|
|
public clear(): void {
|
|
this.enemies.length = 0;
|
|
}
|
|
|
|
private inside(e: EnemyAIBase, cull: ICullingRect, margin = 0): boolean {
|
|
return (
|
|
e.pos.x + e.aabb.w / 2 >= cull.leftX - margin &&
|
|
e.pos.x - e.aabb.w / 2 <= cull.rightX + margin &&
|
|
e.pos.y + e.aabb.h / 2 >= cull.bottomY - margin &&
|
|
e.pos.y - e.aabb.h / 2 <= cull.topY + margin
|
|
);
|
|
}
|
|
}
|
|
|
|
// ---------- Reinforcement Scheduler (dynamic edge spawns) -----------------
|
|
|
|
/** An enemy spawned by the reinforcement scheduler, with a jump-in arc. */
|
|
export interface IReinforcementSpawn {
|
|
enemy: EnemyAIBase;
|
|
/** The edge the enemy is jumping in from. */
|
|
edge: 'left' | 'right';
|
|
}
|
|
|
|
/**
|
|
* Manages periodic reinforcement waves — enemies that jump in from screen
|
|
* edges even when the player is standing still. Each rule specifies an
|
|
* enemy type, interval, count, and which edge(s) they appear from.
|
|
*
|
|
* Usage: call `tick()` every frame. It returns newly-spawned enemies that
|
|
* the caller must register with `EnemyManager.spawn()` and create visual
|
|
* nodes for.
|
|
*/
|
|
export class ReinforcementScheduler {
|
|
private readonly timers = new Map<number, number>();
|
|
private readonly totals = new Map<number, number>();
|
|
|
|
constructor(private readonly rules: IReinforcementRule[]) {}
|
|
|
|
/**
|
|
* Tick the scheduler. Returns enemies that should be spawned this frame.
|
|
* The caller is responsible for:
|
|
* 1. Passing the new enemies to `EnemyManager.spawn()`
|
|
* 2. Creating visual nodes for them
|
|
* 3. Calling `EnemyManager.update()` as usual
|
|
*
|
|
* @param dtSec Frame delta in seconds.
|
|
* @param elapsedSec Total elapsed seconds since level start.
|
|
* @param cull Current camera culling rect (used to determine edge positions).
|
|
* @param groundY Ground Y in physics coords (feet surface).
|
|
* @param enemyCfgFactory A function that returns the IEnemyConfig for a given EnemyType.
|
|
*/
|
|
public tick(
|
|
dtSec: number,
|
|
elapsedSec: number,
|
|
cull: ICullingRect,
|
|
groundY: number,
|
|
enemyCfgFactory: (type: EnemyType) => { moveSpeed: number; attackIntervalSec: number; size: { w: number; h: number } },
|
|
): IReinforcementSpawn[] {
|
|
const spawns: IReinforcementSpawn[] = [];
|
|
|
|
for (let i = 0; i < this.rules.length; i++) {
|
|
const rule = this.rules[i];
|
|
|
|
// Check delay
|
|
if (rule.delaySec && elapsedSec < rule.delaySec) continue;
|
|
|
|
// Check max total
|
|
const total = this.totals.get(i) ?? 0;
|
|
if (rule.maxTotal && rule.maxTotal > 0 && total >= rule.maxTotal) continue;
|
|
|
|
// Accumulate timer
|
|
const timer = this.timers.get(i) ?? 0;
|
|
const newTimer = timer + dtSec;
|
|
this.timers.set(i, newTimer);
|
|
|
|
if (newTimer < rule.intervalSec) continue;
|
|
|
|
// Reset timer (keep remainder for smoother intervals)
|
|
this.timers.set(i, newTimer - rule.intervalSec);
|
|
|
|
// Determine edge(s)
|
|
const edges: Array<'left' | 'right'> = rule.edge === 'both'
|
|
? (Math.random() < 0.5 ? ['left'] : ['right'])
|
|
: [rule.edge];
|
|
|
|
for (const edge of edges) {
|
|
for (let j = 0; j < rule.count; j++) {
|
|
const cfg = enemyCfgFactory(rule.type);
|
|
// Spawn position: just outside the culling rect on the chosen edge.
|
|
// Moving enemies (moveSpeed > 0) start farther out and walk in;
|
|
// stationary enemies (YaoFang) start just inside the visible edge.
|
|
const margin = cfg.moveSpeed > 0 ? 60 : -30; // negative = inside screen
|
|
const spawnX = edge === 'left'
|
|
? cull.leftX - margin - j * 50
|
|
: cull.rightX + margin + j * 50;
|
|
const spawnY = groundY + cfg.size.h / 2;
|
|
|
|
const enemy = createReinforcementEnemy(rule.type, cfg, spawnX, spawnY, edge);
|
|
spawns.push({ enemy, edge });
|
|
this.totals.set(i, (this.totals.get(i) ?? 0) + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return spawns;
|
|
}
|
|
|
|
/** Reset all timers and counters (e.g. on level restart). */
|
|
public reset(): void {
|
|
this.timers.clear();
|
|
this.totals.clear();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an enemy AI instance for a reinforcement spawn.
|
|
* Reuses the same AI classes as static spawns. The enemy spawns at ground
|
|
* level on the chosen edge; moving enemies (ChiRen) will walk into the
|
|
* screen automatically, while stationary enemies (YaoFang) are placed
|
|
* just inside the visible edge so they're immediately active.
|
|
*/
|
|
function createReinforcementEnemy(
|
|
type: EnemyType,
|
|
cfg: { moveSpeed: number; attackIntervalSec: number; size: { w: number; h: number } },
|
|
spawnX: number,
|
|
spawnY: number,
|
|
_edge: 'left' | 'right',
|
|
): EnemyAIBase {
|
|
const fullCfg = {
|
|
id: type,
|
|
displayName: type,
|
|
size: cfg.size,
|
|
moveSpeed: cfg.moveSpeed,
|
|
attackIntervalSec: cfg.attackIntervalSec,
|
|
attacks: [] as never[],
|
|
hp: type === EnemyType.HeiRen ? 2 : 1,
|
|
};
|
|
|
|
switch (type) {
|
|
case EnemyType.ChiRen: return new ChiRenAI(fullCfg, spawnX, spawnY);
|
|
case EnemyType.HeiRen: return new HeiRenAI(fullCfg, spawnX, spawnY);
|
|
case EnemyType.YaoFang: return new YaoFangAI(fullCfg, spawnX, spawnY);
|
|
case EnemyType.QingRen:
|
|
default: return new QingRenAI(fullCfg, spawnX, spawnY);
|
|
}
|
|
}
|