647 lines
21 KiB
TypeScript
647 lines
21 KiB
TypeScript
import * as THREE from 'three';
|
|
import type { Game } from './Game';
|
|
import { Enemy } from './Enemy';
|
|
import { Ghost } from './Ghost';
|
|
import { Slime } from './Slime';
|
|
import { Spider } from './Spider';
|
|
import { Archer } from './Archer';
|
|
import { Shaman } from './Shaman';
|
|
import { Turtle } from './Turtle';
|
|
import { playSound } from './SoundManager';
|
|
|
|
const MAX_HEALTH = 13000;
|
|
const HIT_FLASH_TIME = 0.14;
|
|
const MODEL_SCALE = 1.8;
|
|
const FLOAT_HEIGHT = 1.2;
|
|
const BOB_AMPLITUDE = 0.25;
|
|
const DRIFT_SPEED = 2.5;
|
|
|
|
const TELEPORT_COOLDOWN = 6;
|
|
const TELEPORT_COOLDOWN_2 = 4;
|
|
const TELEPORT_CHARGE = 1.0;
|
|
const TELEPORT_CHARGE_2 = 0.6;
|
|
const TELEPORT_RADIUS = 3.2;
|
|
const TELEPORT_DAMAGE = 15;
|
|
const TELEPORT_RING_PULSE = 6;
|
|
|
|
const VOLLEY_COOLDOWN = 4;
|
|
const VOLLEY_COOLDOWN_2 = 3;
|
|
const VOLLEY_COUNT = 5;
|
|
const VOLLEY_COUNT_2 = 7;
|
|
const VOLLEY_SPREAD = 0.4;
|
|
const BOLT_DAMAGE = 18;
|
|
|
|
const SUMMON_COOLDOWN = 8;
|
|
const SUMMON_COOLDOWN_2 = 6;
|
|
const SUMMON_COUNT = 3;
|
|
const SUMMON_COUNT_2 = 5;
|
|
const SUMMON_TELEGRAPH = 0.8;
|
|
|
|
const ENRAGE_RATIO = 0.4;
|
|
|
|
export class Necromancer extends Enemy {
|
|
private model: THREE.Group;
|
|
private game: Game | null = null;
|
|
private waveTime = 0;
|
|
private enraged = false;
|
|
private hitFlash = 0;
|
|
|
|
private robeMat!: THREE.MeshToonMaterial;
|
|
private darkMat!: THREE.MeshToonMaterial;
|
|
private glowMat!: THREE.MeshBasicMaterial;
|
|
private eyeMat!: THREE.MeshBasicMaterial;
|
|
private shadow!: THREE.Mesh;
|
|
private shadowMat!: THREE.MeshBasicMaterial;
|
|
|
|
private teleportTimer = 3;
|
|
private volleyTimer = 1.5;
|
|
private summonTimer = 5;
|
|
private teleportState: 'idle' | 'charge' = 'idle';
|
|
private teleportCharge = 0;
|
|
private teleportTarget = new THREE.Vector3();
|
|
private teleportRing!: THREE.Group;
|
|
private teleportRingMesh!: THREE.Mesh;
|
|
private teleportRingDisc!: THREE.Mesh;
|
|
private teleportRingMat!: THREE.MeshBasicMaterial;
|
|
private teleportDiscMat!: THREE.MeshBasicMaterial;
|
|
private teleportRingInScene = false;
|
|
|
|
private spawnRings: { group: THREE.Group; timer: number; spawn: () => void }[] = [];
|
|
private arrivalFlashes: { mesh: THREE.Mesh; mat: THREE.MeshBasicMaterial; life: number }[] = [];
|
|
|
|
constructor() {
|
|
super();
|
|
this.health = MAX_HEALTH;
|
|
this.maxHealth = MAX_HEALTH;
|
|
this.isBoss = true;
|
|
this.displayName = 'Erz-Nekromant';
|
|
this.speed = 0;
|
|
this.xp = 320;
|
|
this.contactDps = 15;
|
|
this.contactRadius = 1.8;
|
|
this.guaranteedDrop = true;
|
|
|
|
this.model = new THREE.Group();
|
|
this.model.scale.setScalar(MODEL_SCALE);
|
|
this.fadeOutModel = this.model;
|
|
this.body.add(this.model);
|
|
|
|
this.robeMat = new THREE.MeshToonMaterial({ color: 0x6a3a9a, emissive: 0x1a0a2a });
|
|
this.darkMat = new THREE.MeshToonMaterial({ color: 0x2a1445 });
|
|
this.glowMat = new THREE.MeshBasicMaterial({ color: 0xbb66ff });
|
|
this.eyeMat = new THREE.MeshBasicMaterial({ color: 0xdd88ff });
|
|
const boneMat = new THREE.MeshToonMaterial({ color: 0xf0e6cf });
|
|
const faceMat = new THREE.MeshBasicMaterial({ color: 0x0a0614 });
|
|
let boneFadeRegistered = false;
|
|
const registerBone = (mesh: THREE.Mesh) => {
|
|
// Knochen-Material einmal fürs Fade-Death registrieren (wird geteilt)
|
|
if (!boneFadeRegistered) {
|
|
this.registerFadeMesh(mesh);
|
|
boneFadeRegistered = true;
|
|
}
|
|
};
|
|
|
|
// --- Robe (Blickrichtung +Z, schwebt: unten offen und zerfetzt) ---
|
|
const robeProfile = [
|
|
new THREE.Vector2(0.75, -1.15), // Saum
|
|
new THREE.Vector2(0.62, -0.75),
|
|
new THREE.Vector2(0.45, -0.2),
|
|
new THREE.Vector2(0.38, 0.25),
|
|
new THREE.Vector2(0.5, 0.55), // Schulteransatz
|
|
new THREE.Vector2(0.32, 0.78), // Hals
|
|
];
|
|
const robe = new THREE.Mesh(new THREE.LatheGeometry(robeProfile, 14), this.robeMat);
|
|
robe.castShadow = true;
|
|
this.registerFadeMesh(robe);
|
|
this.model.add(robe);
|
|
|
|
// Innenschatten im Saum (von unten sichtbar)
|
|
const hemInner = new THREE.Mesh(new THREE.CircleGeometry(0.7, 14), this.darkMat);
|
|
hemInner.rotation.x = Math.PI / 2;
|
|
hemInner.position.y = -1.08;
|
|
this.registerFadeMesh(hemInner);
|
|
this.model.add(hemInner);
|
|
|
|
// Zerfetzte Saumfetzen
|
|
for (let i = 0; i < 8; i++) {
|
|
const a = (i / 8) * Math.PI * 2;
|
|
const tatter = new THREE.Mesh(
|
|
new THREE.ConeGeometry(0.08, 0.4, 4),
|
|
i % 2 === 0 ? this.robeMat : this.darkMat
|
|
);
|
|
tatter.rotation.x = Math.PI;
|
|
tatter.position.set(Math.sin(a) * 0.68, -1.28, Math.cos(a) * 0.68);
|
|
this.registerFadeMesh(tatter);
|
|
this.model.add(tatter);
|
|
}
|
|
|
|
// Gürtelkordel + Quaste
|
|
const belt = new THREE.Mesh(new THREE.TorusGeometry(0.42, 0.035, 6, 16), this.darkMat);
|
|
belt.rotation.x = Math.PI / 2;
|
|
belt.position.y = 0.12;
|
|
this.registerFadeMesh(belt);
|
|
this.model.add(belt);
|
|
const tasselCord = new THREE.Mesh(new THREE.CylinderGeometry(0.02, 0.02, 0.28, 5), this.darkMat);
|
|
tasselCord.position.set(-0.3, -0.05, 0.36);
|
|
this.registerFadeMesh(tasselCord);
|
|
this.model.add(tasselCord);
|
|
const tassel = new THREE.Mesh(new THREE.ConeGeometry(0.05, 0.14, 5), boneMat);
|
|
tassel.rotation.x = Math.PI;
|
|
tassel.position.set(-0.3, -0.24, 0.38);
|
|
registerBone(tassel);
|
|
this.model.add(tassel);
|
|
|
|
// Oberkörper
|
|
const body = new THREE.Mesh(new THREE.SphereGeometry(0.55, 16, 12), this.robeMat);
|
|
body.position.y = 0.6;
|
|
body.scale.set(1, 1.2, 1);
|
|
body.castShadow = true;
|
|
this.registerFadeMesh(body);
|
|
this.model.add(body);
|
|
|
|
// Kragen
|
|
const collar = new THREE.Mesh(new THREE.TorusGeometry(0.22, 0.045, 6, 14), this.darkMat);
|
|
collar.rotation.x = Math.PI / 2 - 0.2;
|
|
collar.position.set(0, 0.85, 0.08);
|
|
this.registerFadeMesh(collar);
|
|
this.model.add(collar);
|
|
|
|
// Schulterpanzer mit Spitzen
|
|
for (const side of [-1, 1]) {
|
|
const pauldron = new THREE.Mesh(new THREE.SphereGeometry(0.26, 12, 8), this.darkMat);
|
|
pauldron.scale.set(1.25, 0.65, 1.25);
|
|
pauldron.position.set(side * 0.45, 0.78, 0);
|
|
this.registerFadeMesh(pauldron);
|
|
this.model.add(pauldron);
|
|
const spike = new THREE.Mesh(new THREE.ConeGeometry(0.06, 0.22, 5), this.darkMat);
|
|
spike.position.set(side * 0.55, 0.95, 0);
|
|
spike.rotation.z = side * -0.5;
|
|
this.registerFadeMesh(spike);
|
|
this.model.add(spike);
|
|
}
|
|
|
|
// Kapuze mit Krempe und schwarzem Gesichts-Leerraum
|
|
const hood = new THREE.Mesh(new THREE.ConeGeometry(0.5, 0.95, 12, 1, true), this.darkMat);
|
|
hood.position.set(0, 1.18, 0.02);
|
|
hood.rotation.x = 0.22;
|
|
hood.castShadow = true;
|
|
this.registerFadeMesh(hood);
|
|
this.model.add(hood);
|
|
const hoodRim = new THREE.Mesh(new THREE.TorusGeometry(0.34, 0.05, 8, 16), this.darkMat);
|
|
hoodRim.rotation.x = -0.5;
|
|
hoodRim.position.set(0, 1.05, 0.34);
|
|
this.registerFadeMesh(hoodRim);
|
|
this.model.add(hoodRim);
|
|
const face = new THREE.Mesh(new THREE.SphereGeometry(0.3, 12, 10), faceMat);
|
|
face.scale.set(1, 1.1, 0.8);
|
|
face.position.set(0, 1.04, 0.26);
|
|
this.registerFadeMesh(face);
|
|
this.model.add(face);
|
|
|
|
// Leuchtende Augen in der Kapuze (+Z)
|
|
for (const side of [-1, 1]) {
|
|
const eye = new THREE.Mesh(new THREE.SphereGeometry(0.075, 8, 6), this.eyeMat);
|
|
eye.position.set(side * 0.12, 1.08, 0.48);
|
|
this.model.add(eye);
|
|
}
|
|
|
|
// Amulett + Runen auf der Robe (glühen, färben sich im Enrage)
|
|
const amulet = new THREE.Mesh(new THREE.SphereGeometry(0.08, 8, 6), this.glowMat);
|
|
amulet.position.set(0, 0.6, 0.5);
|
|
this.model.add(amulet);
|
|
const runeSpots: [number, number, number][] = [
|
|
[0, -0.15, 0.5],
|
|
[-0.2, -0.5, 0.5],
|
|
[0.2, -0.5, 0.5],
|
|
];
|
|
for (const [x, y, z] of runeSpots) {
|
|
const rune = new THREE.Mesh(new THREE.OctahedronGeometry(0.06), this.glowMat);
|
|
rune.scale.set(1, 1.7, 0.5);
|
|
rune.position.set(x, y, z);
|
|
this.model.add(rune);
|
|
}
|
|
|
|
// Rechter Arm: Ärmel zum Stab
|
|
const sleeveR = new THREE.Mesh(new THREE.CylinderGeometry(0.09, 0.16, 0.55, 8), this.robeMat);
|
|
sleeveR.position.set(0.65, 0.84, 0.14);
|
|
sleeveR.rotation.z = 1.2;
|
|
this.registerFadeMesh(sleeveR);
|
|
this.model.add(sleeveR);
|
|
const handR = new THREE.Mesh(new THREE.SphereGeometry(0.1, 8, 6), boneMat);
|
|
handR.position.set(0.85, 0.9, 0.23);
|
|
registerBone(handR);
|
|
this.model.add(handR);
|
|
|
|
// Linker Arm: Ärmel nach vorn (Beschwörungs-Geste) + Energiekugel
|
|
const sleeveL = new THREE.Mesh(new THREE.CylinderGeometry(0.09, 0.18, 0.6, 8), this.robeMat);
|
|
sleeveL.position.set(-0.55, 0.75, 0.32);
|
|
sleeveL.rotation.x = -1.25;
|
|
sleeveL.rotation.z = -0.35;
|
|
this.registerFadeMesh(sleeveL);
|
|
this.model.add(sleeveL);
|
|
const handL = new THREE.Mesh(new THREE.SphereGeometry(0.1, 8, 6), boneMat);
|
|
handL.position.set(-0.68, 0.72, 0.62);
|
|
registerBone(handL);
|
|
this.model.add(handL);
|
|
const castOrb = new THREE.Mesh(new THREE.SphereGeometry(0.09, 8, 6), this.glowMat);
|
|
castOrb.position.set(-0.7, 0.92, 0.68);
|
|
this.model.add(castOrb);
|
|
|
|
// Stab mit Manschetten, Totenkopf und schwebendem Orb
|
|
const staff = new THREE.Mesh(new THREE.CylinderGeometry(0.045, 0.045, 2.4, 8), this.darkMat);
|
|
staff.position.set(0.8, 1.2, 0.28);
|
|
staff.rotation.z = 0.18;
|
|
staff.rotation.x = 0.15;
|
|
this.registerFadeMesh(staff);
|
|
this.model.add(staff);
|
|
for (const [x, y, z] of [[0.88, 0.76, 0.21], [0.96, 0.31, 0.15]] as const) {
|
|
const collarM = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.06, 0.07, 8), this.darkMat);
|
|
collarM.position.set(x, y, z);
|
|
this.registerFadeMesh(collarM);
|
|
this.model.add(collarM);
|
|
}
|
|
const skull = new THREE.Mesh(new THREE.SphereGeometry(0.15, 10, 8), boneMat);
|
|
skull.position.set(0.58, 2.42, 0.47);
|
|
registerBone(skull);
|
|
this.model.add(skull);
|
|
for (const side of [-1, 1]) {
|
|
const socket = new THREE.Mesh(new THREE.SphereGeometry(0.03, 6, 4), this.darkMat);
|
|
socket.position.set(0.58 + side * 0.05, 2.44, 0.6);
|
|
this.model.add(socket);
|
|
}
|
|
|
|
const orbMat = new THREE.MeshBasicMaterial({
|
|
color: 0xbb66ff,
|
|
transparent: true,
|
|
opacity: 0.85,
|
|
blending: THREE.AdditiveBlending,
|
|
depthWrite: false,
|
|
});
|
|
const orb = new THREE.Mesh(new THREE.SphereGeometry(0.14, 10, 8), orbMat);
|
|
orb.position.set(0.58, 2.66, 0.47);
|
|
this.model.add(orb);
|
|
this.orbMat = orbMat;
|
|
this.orb = orb;
|
|
|
|
// Boden-Schatten
|
|
this.shadowMat = new THREE.MeshBasicMaterial({
|
|
color: 0x000000,
|
|
transparent: true,
|
|
opacity: 0.3,
|
|
});
|
|
this.shadow = new THREE.Mesh(new THREE.CircleGeometry(0.9, 20), this.shadowMat);
|
|
this.shadow.rotation.x = -Math.PI / 2;
|
|
this.shadow.renderOrder = 998;
|
|
this.body.add(this.shadow);
|
|
|
|
// Teleport-Telegraf: Ring + Scheibe am Zielpunkt
|
|
this.teleportRingMat = new THREE.MeshBasicMaterial({
|
|
color: 0xbb66ff,
|
|
transparent: true,
|
|
opacity: 0,
|
|
side: THREE.DoubleSide,
|
|
depthWrite: false,
|
|
});
|
|
this.teleportDiscMat = new THREE.MeshBasicMaterial({
|
|
color: 0x8833cc,
|
|
transparent: true,
|
|
opacity: 0,
|
|
depthWrite: false,
|
|
});
|
|
const ringMesh = new THREE.Mesh(
|
|
new THREE.RingGeometry(1.6, 2.0, 32),
|
|
this.teleportRingMat
|
|
);
|
|
ringMesh.rotation.x = -Math.PI / 2;
|
|
ringMesh.position.y = 0.05;
|
|
const disc = new THREE.Mesh(new THREE.CircleGeometry(1.8, 32), this.teleportDiscMat);
|
|
disc.rotation.x = -Math.PI / 2;
|
|
disc.position.y = 0.03;
|
|
this.teleportRingMesh = ringMesh;
|
|
this.teleportRingDisc = disc;
|
|
this.teleportRing = new THREE.Group();
|
|
this.teleportRing.add(ringMesh, disc);
|
|
this.teleportRing.visible = false;
|
|
}
|
|
|
|
private orb!: THREE.Mesh;
|
|
private orbMat!: THREE.MeshBasicMaterial;
|
|
|
|
playAnim() {
|
|
// Prozedurale Optik
|
|
}
|
|
|
|
updateAnimation(dt: number) {
|
|
this.updateFadeDeath(dt, { duration: 1.2, sink: 0.5 });
|
|
}
|
|
|
|
update(dt: number, game: Game) {
|
|
this.game = game;
|
|
this.waveTime += dt;
|
|
|
|
// Schweben
|
|
this.body.position.y = FLOAT_HEIGHT + Math.sin(this.waveTime * 2.2) * BOB_AMPLITUDE;
|
|
this.shadow.position.y = 0.06 - this.body.position.y;
|
|
const sway = Math.sin(this.waveTime * 1.5) * 0.06;
|
|
this.model.rotation.z = sway;
|
|
this.model.rotation.x = Math.sin(this.waveTime * 2.2) * 0.04;
|
|
|
|
// Hit-Feedback
|
|
if (this.hitFlash > 0) {
|
|
this.hitFlash -= dt;
|
|
this.robeMat.color.set(0xffffff);
|
|
this.darkMat.color.set(0xffffff);
|
|
this.model.scale.setScalar(MODEL_SCALE * (1 + (this.hitFlash / HIT_FLASH_TIME) * 0.05));
|
|
} else {
|
|
this.robeMat.color.set(this.enraged ? 0x8a2233 : 0x6a3a9a);
|
|
this.darkMat.color.set(this.enraged ? 0x551520 : 0x2a1445);
|
|
this.model.scale.setScalar(MODEL_SCALE);
|
|
}
|
|
|
|
// Orb pulsiert
|
|
const orbPulse = 1 + Math.abs(Math.sin(this.waveTime * 5)) * 0.25;
|
|
this.orb.scale.setScalar(orbPulse);
|
|
this.orbMat.opacity = 0.6 + Math.abs(Math.sin(this.waveTime * 5)) * 0.3;
|
|
|
|
// Enrage unter 40% HP
|
|
if (!this.enraged && this.health < MAX_HEALTH * ENRAGE_RATIO) {
|
|
this.enraged = true;
|
|
this.eyeMat.color.set(0xff4422);
|
|
this.glowMat.color.set(0xff6644);
|
|
playSound('damage', 0.9);
|
|
game.triggerCameraShake(0.35, 0.5);
|
|
}
|
|
|
|
// Zum Spieler driften (langsam)
|
|
const playerPos = game.player.body.position;
|
|
const toPlayer = new THREE.Vector3().subVectors(playerPos, this.body.position);
|
|
toPlayer.y = 0;
|
|
const dist = toPlayer.length();
|
|
if (dist > 0.1) {
|
|
const dir = toPlayer.normalize();
|
|
this.body.lookAt(
|
|
this.body.position.x + dir.x,
|
|
this.body.position.y,
|
|
this.body.position.z + dir.z
|
|
);
|
|
let moveDir = dir.multiplyScalar(DRIFT_SPEED);
|
|
if (this.knockback > 0) {
|
|
moveDir = dir.multiplyScalar(-DRIFT_SPEED);
|
|
this.knockback -= dt;
|
|
}
|
|
this.body.position.x += moveDir.x * dt;
|
|
this.body.position.z += moveDir.z * dt;
|
|
game.clampToArena(this.body.position);
|
|
}
|
|
|
|
// Teleport
|
|
if (this.teleportState === 'idle') {
|
|
this.teleportTimer -= dt;
|
|
if (this.teleportTimer <= 0) {
|
|
this.teleportTimer = this.enraged ? TELEPORT_COOLDOWN_2 : TELEPORT_COOLDOWN;
|
|
this.startTeleport(game);
|
|
}
|
|
} else {
|
|
this.updateTeleportCharge(dt, game);
|
|
}
|
|
|
|
// Salven
|
|
this.volleyTimer -= dt;
|
|
if (this.volleyTimer <= 0) {
|
|
this.volleyTimer = this.enraged ? VOLLEY_COOLDOWN_2 : VOLLEY_COOLDOWN;
|
|
this.fireVolley(game);
|
|
}
|
|
|
|
// Beschwörung
|
|
this.summonTimer -= dt;
|
|
if (this.summonTimer <= 0) {
|
|
this.summonTimer = this.enraged ? SUMMON_COOLDOWN_2 : SUMMON_COOLDOWN;
|
|
this.startSummon(game);
|
|
}
|
|
|
|
// Beschwörungs-Telegraphen
|
|
for (let i = this.spawnRings.length - 1; i >= 0; i--) {
|
|
const r = this.spawnRings[i];
|
|
r.timer -= dt;
|
|
if (r.timer <= 0) {
|
|
r.spawn();
|
|
game.scene.remove(r.group);
|
|
r.group.traverse((obj) => {
|
|
if (obj instanceof THREE.Mesh) {
|
|
obj.geometry.dispose();
|
|
(obj.material as THREE.Material).dispose();
|
|
}
|
|
});
|
|
this.spawnRings.splice(i, 1);
|
|
} else {
|
|
const t = 1 - r.timer / SUMMON_TELEGRAPH;
|
|
r.group.scale.setScalar(0.5 + t * 1.2);
|
|
}
|
|
}
|
|
|
|
// Ankunfts-Blitz-Flächen
|
|
for (let i = this.arrivalFlashes.length - 1; i >= 0; i--) {
|
|
const f = this.arrivalFlashes[i];
|
|
f.life -= dt;
|
|
const t = 1 - Math.max(0, f.life) / 0.3;
|
|
f.mesh.scale.setScalar(0.5 + t * 5);
|
|
f.mat.opacity = 0.7 * (1 - t);
|
|
if (f.life <= 0) {
|
|
game.scene.remove(f.mesh);
|
|
f.mesh.geometry.dispose();
|
|
f.mat.dispose();
|
|
this.arrivalFlashes.splice(i, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- Teleport ---
|
|
|
|
private startTeleport(game: Game) {
|
|
this.teleportState = 'charge';
|
|
this.teleportCharge = this.enraged ? TELEPORT_CHARGE_2 : TELEPORT_CHARGE;
|
|
const playerPos = game.player.body.position;
|
|
// Ziel = aktuelle Spielerposition (leicht zufällig versetzt)
|
|
this.teleportTarget.set(
|
|
playerPos.x + (Math.random() - 0.5) * 2,
|
|
0,
|
|
playerPos.z + (Math.random() - 0.5) * 2
|
|
);
|
|
game.clampToArena(this.teleportTarget);
|
|
if (!this.teleportRingInScene) {
|
|
game.scene.add(this.teleportRing);
|
|
this.teleportRingInScene = true;
|
|
}
|
|
this.teleportRing.position.set(this.teleportTarget.x, 0, this.teleportTarget.z);
|
|
this.teleportRing.visible = true;
|
|
playSound('spawn', 0.7);
|
|
}
|
|
|
|
private updateTeleportCharge(dt: number, game: Game) {
|
|
this.teleportCharge -= dt;
|
|
const pulse = Math.abs(Math.sin(this.waveTime * TELEPORT_RING_PULSE));
|
|
this.teleportRingMat.opacity = 0.3 + 0.5 * pulse;
|
|
this.teleportDiscMat.opacity = 0.1 + 0.08 * pulse;
|
|
|
|
if (this.teleportCharge <= 0) {
|
|
this.teleportState = 'idle';
|
|
this.teleportRing.visible = false;
|
|
this.teleportRingMat.opacity = 0;
|
|
this.teleportDiscMat.opacity = 0;
|
|
|
|
// Blitz
|
|
this.body.position.x = this.teleportTarget.x;
|
|
this.body.position.z = this.teleportTarget.z;
|
|
playSound('teleport', 0.8);
|
|
|
|
// Ankunftsexplosion + Schaden, wenn der Spieler unter dem Zielpunkt steht
|
|
const flashMat = new THREE.MeshBasicMaterial({
|
|
color: 0xbb66ff,
|
|
transparent: true,
|
|
opacity: 0.7,
|
|
side: THREE.DoubleSide,
|
|
depthWrite: false,
|
|
});
|
|
const flash = new THREE.Mesh(new THREE.RingGeometry(0.9, 1.1, 32), flashMat);
|
|
flash.rotation.x = -Math.PI / 2;
|
|
flash.position.set(this.teleportTarget.x, 0.07, this.teleportTarget.z);
|
|
game.scene.add(flash);
|
|
this.arrivalFlashes.push({ mesh: flash, mat: flashMat, life: 0.3 });
|
|
|
|
if (game.player.health > 0 && game.player.body.position.y <= 0.8) {
|
|
const dx = game.player.body.position.x - this.teleportTarget.x;
|
|
const dz = game.player.body.position.z - this.teleportTarget.z;
|
|
if (Math.hypot(dx, dz) < TELEPORT_RADIUS) {
|
|
game.player.damage(TELEPORT_DAMAGE, this.teleportTarget);
|
|
}
|
|
}
|
|
|
|
// Salve vom neuen Standort
|
|
this.fireVolley(game);
|
|
}
|
|
}
|
|
|
|
// --- Projektilsalve ---
|
|
|
|
private fireVolley(game: Game) {
|
|
const from = new THREE.Vector3(this.body.position.x, FLOAT_HEIGHT + 0.6, this.body.position.z);
|
|
const target = game.player.body.position.clone();
|
|
const count = this.enraged ? VOLLEY_COUNT_2 : VOLLEY_COUNT;
|
|
const baseDir = new THREE.Vector3().subVectors(target, from);
|
|
baseDir.y = 0;
|
|
baseDir.normalize();
|
|
const perp = new THREE.Vector3(-baseDir.z, 0, baseDir.x);
|
|
for (let i = 0; i < count; i++) {
|
|
const off = (i / (count - 1) - 0.5) * 2 * VOLLEY_SPREAD;
|
|
const dir = new THREE.Vector3()
|
|
.addScaledVector(baseDir, 1)
|
|
.addScaledVector(perp, off)
|
|
.normalize();
|
|
const t = from.clone().add(dir.multiplyScalar(25));
|
|
t.y = 0.5;
|
|
game.spawnEnemyProjectile(from, t, BOLT_DAMAGE);
|
|
}
|
|
playSound('spawn', 0.5);
|
|
}
|
|
|
|
// --- Beschwörung ---
|
|
|
|
private startSummon(game: Game) {
|
|
const count = this.enraged ? SUMMON_COUNT_2 : SUMMON_COUNT;
|
|
const types = [() => new Ghost(), () => new Slime(), () => new Spider(),
|
|
() => new Archer(), () => new Shaman(), () => new Turtle()];
|
|
for (let i = 0; i < count; i++) {
|
|
const a = Math.random() * Math.PI * 2;
|
|
const r = 5 + Math.random() * 8;
|
|
const [x, z] = this.clampToArena(game,
|
|
this.body.position.x + Math.cos(a) * r,
|
|
this.body.position.z + Math.sin(a) * r
|
|
);
|
|
|
|
// Wachsender Boden-Glow als Telegraf
|
|
const mat = new THREE.MeshBasicMaterial({
|
|
color: 0xbb66ff,
|
|
transparent: true,
|
|
opacity: 0.35,
|
|
depthWrite: false,
|
|
});
|
|
const ring = new THREE.Mesh(new THREE.CircleGeometry(1.6, 24), mat);
|
|
ring.rotation.x = -Math.PI / 2;
|
|
ring.position.set(x, 0.05, z);
|
|
ring.scale.setScalar(0.5);
|
|
const group = new THREE.Group();
|
|
group.add(ring);
|
|
game.scene.add(group);
|
|
|
|
const type = types[Math.floor(Math.random() * types.length)];
|
|
this.spawnRings.push({
|
|
group,
|
|
timer: SUMMON_TELEGRAPH,
|
|
spawn: () => {
|
|
game.spawnEnemyInstance(type(), x, z, 0.1);
|
|
playSound('spawn', 0.5);
|
|
},
|
|
});
|
|
}
|
|
playSound('spawn', 0.6);
|
|
}
|
|
|
|
private clampToArena(game: Game, x: number, z: number): [number, number] {
|
|
const v = new THREE.Vector3(x, 0, z);
|
|
game.clampToArena(v);
|
|
return [v.x, v.z];
|
|
}
|
|
|
|
override takeDamage(
|
|
damage: number,
|
|
game: Game,
|
|
withKnockback = true,
|
|
sourcePos?: THREE.Vector3
|
|
) {
|
|
super.takeDamage(damage, game, withKnockback, sourcePos);
|
|
this.hitFlash = HIT_FLASH_TIME;
|
|
}
|
|
|
|
protected onDeath(_game: Game) {
|
|
this.cleanupEffects();
|
|
this.beginFadeDeath();
|
|
}
|
|
|
|
override dispose() {
|
|
super.dispose();
|
|
this.cleanupEffects();
|
|
}
|
|
|
|
private cleanupEffects() {
|
|
if (this.game) {
|
|
for (const r of this.spawnRings) {
|
|
this.game.scene.remove(r.group);
|
|
r.group.traverse((obj) => {
|
|
if (obj instanceof THREE.Mesh) {
|
|
obj.geometry.dispose();
|
|
(obj.material as THREE.Material).dispose();
|
|
}
|
|
});
|
|
}
|
|
for (const f of this.arrivalFlashes) {
|
|
this.game.scene.remove(f.mesh);
|
|
f.mesh.geometry.dispose();
|
|
f.mat.dispose();
|
|
}
|
|
}
|
|
this.spawnRings = [];
|
|
this.arrivalFlashes = [];
|
|
this.teleportState = 'idle';
|
|
this.teleportRing.visible = false;
|
|
if (this.teleportRingInScene && this.game) {
|
|
this.game.scene.remove(this.teleportRing);
|
|
}
|
|
this.teleportRingInScene = false;
|
|
this.robeMat.color.set(0x6a3a9a);
|
|
this.darkMat.color.set(0x2a1445);
|
|
this.eyeMat.color.set(0xdd88ff);
|
|
this.glowMat.color.set(0xbb66ff);
|
|
this.model.scale.setScalar(MODEL_SCALE);
|
|
}
|
|
}
|