initial commit

resources/js/game/Witch.js

@@ -0,0 +1,265 @@
+import { Zombie } from './Zombie.js';
+import { GameObject } from '../engine/GameObject.js';
+import { Vector2D } from '../engine/Vector2D.js';
+import { WitchProjectile } from './WitchProjectile.js';
+
+export class Witch extends Zombie {
+  constructor(
+    x,
+    y,
+    target,
+    {
+      container,
+      viewport,
+      speed = 85,
+      size = 28,
+      color = [0.55, 0.2, 0.8, 1],
+      health = 5,
+      knockback = 180,
+      scoreValue = 4,
+      preferredDistance = 220,
+      fireInterval = 2.2,
+      projectileSpeed = 220,
+      projectileCount = 1,
+      projectileSpread = 0.08,
+      projectileColor = [0.7, 0.2, 1, 1],
+      emergeTime = 0,
+      spawnProjectile = (p) => {},
+      onDeath = null,
+    } = {},
+  ) {
+    super(x, y, target, {
+      container,
+      viewport,
+      speed,
+      size,
+      color,
+      health,
+      knockback,
+      scoreValue,
+      emergeTime,
+      onDeath,
+    });
+    this.preferredDistance = preferredDistance;
+    this.fireInterval = fireInterval;
+    this.projectileSpeed = projectileSpeed;
+    this.projectileCount = projectileCount;
+    this.projectileSpread = projectileSpread;
+    this.projectileColor = projectileColor;
+    this.spawnProjectile = spawnProjectile;
+    this._fireTimer = 0;
+    this._time = 0;
+    this._cast = 0;
+  }
+
+  update(dt) {
+    this._time += dt;
+    this._cast = Math.max(0, this._cast - dt);
+
+    if (this._updateEmerge(dt)) {
+      return;
+    }
+
+    this._fireTimer -= dt;
+
+    const delta = this.target.pos.subV(this.pos);
+    const distance = delta.length();
+
+    let move = new Vector2D(0, 0);
+    if (distance > 1) {
+      const dir = delta.divS(distance);
+      if (distance < this.preferredDistance) {
+        move = dir.mulS(-this.speed);
+      } else if (distance > this.preferredDistance + 40) {
+        move = dir.mulS(this.speed);
+      }
+    }
+
+    this.velocity = move.addV(this._hitKnockback);
+    GameObject.prototype.update.call(this, dt);
+
+    this._hitKnockback = this._hitKnockback.mulS(Math.max(0, 1 - dt * this.knockbackDamping));
+    this._flash = Math.max(0, this._flash - dt);
+
+    if (this._fireTimer <= 0 && this.target.health > 0 && distance < 480) {
+      this._fireTimer = this.fireInterval * (0.8 + Math.random() * 0.4);
+      this.fire();
+    }
+  }
+
+  _onEmergenceComplete() {
+    this._fireTimer = this.fireInterval * (0.4 + Math.random() * 0.4);
+  }
+
+  fire() {
+    this._cast = 0.22;
+    const aim = this.target.pos.subV(this.pos);
+    const aimAngle = aim.lengthSqrt() > 1
+      ? Math.atan2(aim.y, aim.x)
+      : this._time;
+
+    const offset = ((this.projectileCount - 1) / 2) * this.projectileSpread;
+    for (let i = 0; i < this.projectileCount; i += 1) {
+      const angle = aimAngle - offset + i * this.projectileSpread;
+      const direction = new Vector2D(Math.cos(angle), Math.sin(angle));
+      const projectile = new WitchProjectile(this.pos.x, this.pos.y, direction, {
+        container: this.container,
+        viewport: this.viewport,
+        speed: this.projectileSpeed,
+        color: this.projectileColor,
+      });
+      this.spawnProjectile(projectile);
+    }
+  }
+
+  draw(renderer) {
+    this._drawEmerge(renderer);
+    let s = this.size * this._emergeSize();
+
+    let bodyColor = this.baseColor;
+    if (this._flash > 0) {
+      bodyColor = [1, 1, 1, 1];
+    } else if (this.maxHealth > 1) {
+      const hpRatio = this.health / this.maxHealth;
+      bodyColor = [
+        this.baseColor[0] + (1 - this.baseColor[0]) * (1 - hpRatio),
+        this.baseColor[1] * hpRatio,
+        this.baseColor[2] * hpRatio,
+        1,
+      ];
+    }
+
+    const bob = Math.sin(this._time * 3.4) * s * 0.09;
+    const sway = Math.sin(this._time * 1.7) * 0.09;
+    const castRatio = Math.min(1, this._cast / 0.22);
+    const charge = Math.max(
+      0,
+      Math.min(1, (this.fireInterval - this._fireTimer) / this.fireInterval),
+    );
+    const targetSide = this.target.pos.x < this.pos.x ? -1 : 1;
+    const flightSide = Math.abs(this.velocity.x) > 20
+      ? (this.velocity.x < 0 ? -1 : 1)
+      : targetSide;
+    const facing = flightSide;
+    const lean = facing * s * 0.05;
+
+    const drawLimb = (ax, ay, bx, by, thickness, limbColor) => {
+      const len = Math.hypot(bx - ax, by - ay);
+      if (len < 1) return;
+      renderer.drawTexture(
+        renderer.whiteTexture,
+        (ax + bx) / 2 - len / 2,
+        (ay + by) / 2 - thickness / 2,
+        len,
+        thickness,
+        limbColor,
+        Math.atan2(by - ay, bx - ax),
+      );
+    };
+
+    const robe = s * 0.9;
+    const robeW = robe * (1 + Math.sin(this._time * 3.4) * 0.05);
+    const cy = this.pos.y + bob;
+    renderer.drawTexture(
+      renderer.whiteTexture,
+      this.pos.x + lean - robeW / 2,
+      cy - robe / 2,
+      robeW,
+      robe,
+      bodyColor,
+    );
+
+    const armColor = [bodyColor[0] * 0.72, bodyColor[1] * 0.72, bodyColor[2] * 0.72, 1];
+    const armW = s * 0.16;
+    const armLen = s * (0.3 + castRatio * 0.26);
+    const armSpread = s * (0.36 + castRatio * 0.14);
+    const armY = cy - robe * 0.2 - castRatio * s * 0.14;
+    for (let i = 0; i < 2; i += 1) {
+      const sign = i === 0 ? 1 : -1;
+      const raise = Math.sin(this._time * 6) * castRatio * s * 0.06;
+      renderer.drawTexture(
+        renderer.whiteTexture,
+        this.pos.x + sign * armSpread - armW / 2,
+        armY - armLen / 2 + sign * raise,
+        armW,
+        armLen,
+        armColor,
+      );
+    }
+
+    const hatW = s * 0.7;
+    const hatH = s * 0.9;
+    const hatCx = this.pos.x + lean + sway * s * 0.14;
+    const hatCy = cy - robe / 2 - hatH * 0.55 + bob * 0.4;
+    const hatAngle = sway * 0.8 + castRatio * -0.08;
+    renderer.drawTexture(
+      renderer.whiteTexture,
+      hatCx - hatW / 2,
+      hatCy - hatH / 2,
+      hatW,
+      hatH,
+      [0.15, 0.08, 0.2, 1],
+      hatAngle,
+    );
+
+    const brimW = s * 0.98;
+    const brimH = s * 0.14;
+    renderer.drawTexture(
+      renderer.whiteTexture,
+      hatCx - brimW / 2,
+      hatCy + hatH * 0.1 - brimH / 2,
+      brimW,
+      brimH,
+      [0.15, 0.08, 0.2, 1],
+      hatAngle,
+    );
+
+    const seatY = cy + robe * 0.14 + Math.sin(this._time * 2.3) * s * 0.02;
+    const seatX = this.pos.x + lean;
+    const handleX = seatX + facing * s * 0.5;
+    const bristleX = seatX - facing * s * 0.24;
+    drawLimb(handleX, seatY, bristleX, seatY, s * 0.13, [0.4, 0.3, 0.15, 1]);
+    drawLimb(bristleX, seatY - s * 0.02, bristleX - facing * s * 0.14, seatY - s * 0.09, s * 0.18, [0.62, 0.48, 0.24, 1]);
+
+    if (charge > 0.25) {
+      const eyeFade = (charge - 0.25) / 0.75;
+      const eyeY = hatCy + hatH * 0.32;
+      const eyeSpread = s * 0.13;
+      const eyeS = s * 0.11;
+      const eyeCx = this.pos.x + lean + targetSide * s * 0.06;
+      renderer.setBlendMode('additive');
+      renderer.drawTexture(
+        renderer.glowTexture,
+        eyeCx - eyeSpread - eyeS,
+        eyeY - eyeS,
+        eyeS * 2,
+        eyeS * 2,
+        [0.85, 0.35, 1, 0.75 * eyeFade],
+      );
+      renderer.drawTexture(
+        renderer.glowTexture,
+        eyeCx + eyeSpread - eyeS,
+        eyeY - eyeS,
+        eyeS * 2,
+        eyeS * 2,
+        [0.85, 0.35, 1, 0.75 * eyeFade],
+      );
+      renderer.setBlendMode('normal');
+    }
+
+    if (castRatio > 0) {
+      renderer.setBlendMode('additive');
+      const fx = this.pos.x;
+      const fy = hatCy - hatH * 0.72;
+      renderer.drawTexture(
+        renderer.glowTexture,
+        fx - s * 0.5,
+        fy - s * 0.5,
+        s,
+        s,
+        [0.8, 0.4, 1, 0.9 * castRatio],
+      );
+      renderer.setBlendMode('normal');
+    }
+  }
+}