543 lines
19 KiB
JavaScript
543 lines
19 KiB
JavaScript
import { Player } from '../entities/Player.js';
|
|
import { WaveManager } from '../systems/WaveManager.js';
|
|
import { XPSystem } from '../systems/XPSystem.js';
|
|
import { SkillTree } from '../systems/SkillTree.js';
|
|
import { HUD } from '../ui/HUD.js';
|
|
import { SkillTreeUI } from '../ui/SkillTreeUI.js';
|
|
import { Reticle } from '../ui/Reticle.js';
|
|
import { BarrierManager } from '../systems/BarrierManager.js';
|
|
|
|
const ZONE_PALETTE = [
|
|
null, // index 0 unused
|
|
{ bg: 0x111118, grid: 0x222233, gridAlpha: 0.50, border: 0x334466, shimmer: null }, // zone 1 — dark blue-grey (unchanged)
|
|
{ bg: 0x080d28, grid: 0x1a3488, gridAlpha: 0.70, border: 0x2255dd, shimmer: 0x00eeff }, // zone 2 — deep navy
|
|
{ bg: 0x0e0828, grid: 0x2a1888, gridAlpha: 0.70, border: 0x6633cc, shimmer: 0x8833ff }, // zone 3 — indigo
|
|
{ bg: 0x160828, grid: 0x420aaa, gridAlpha: 0.70, border: 0x9922dd, shimmer: 0xff00ff }, // zone 4 — deep violet
|
|
{ bg: 0x1e0820, grid: 0x5a0e55, gridAlpha: 0.70, border: 0xcc22aa, shimmer: 0xff2266 }, // zone 5 — dark magenta
|
|
{ bg: 0x1e0e06, grid: 0x552208, gridAlpha: 0.70, border: 0xdd5511, shimmer: 0xff7700 }, // zone 6 — burnt amber
|
|
];
|
|
|
|
export class GameScene extends Phaser.Scene {
|
|
constructor() {
|
|
super({ key: 'GameScene' });
|
|
}
|
|
|
|
preload() {
|
|
this.load.json('zones', './js/data/zones.json');
|
|
this.load.json('skillTree', './js/data/skillTree.json');
|
|
this.load.spritesheet('player', './assets/sprites/player.png', { frameWidth: 48, frameHeight: 48 });
|
|
this.load.spritesheet('enemies', './assets/sprites/enemies.png', { frameWidth: 48, frameHeight: 48 });
|
|
this.load.audio('music-game', './assets/music/gameBackground.mp3');
|
|
this.load.audio('sfx-edge-remove', './assets/fx/EdgeRemove.mp3');
|
|
this.load.audio('sfx-arrow-ping', './assets/fx/ArrowPing.mp3');
|
|
this.load.audio('sfx-sprayer-shoot', './assets/fx/SprayerShoot.mp3');
|
|
this.load.audio('sfx-death', './assets/fx/Death.mp3');
|
|
this.load.audio('sfx-new-life', './assets/fx/NewLife.mp3');
|
|
this.load.audio('sfx-shoot', './assets/fx/Shoot.mp3');
|
|
this.load.audio('sfx-take-damage', './assets/fx/TakeDamage.mp3');
|
|
this.load.audio('sfx-shooter-shoot', './assets/fx/ShooterShoot.mp3');
|
|
this.load.audio('sfx-enemy-wave', './assets/fx/EnemyWave.mp3');
|
|
this.load.audio('sfx-death-chaser', './assets/fx/EnemyChaseDeath.mp3');
|
|
this.load.audio('sfx-death-swarmer', './assets/fx/EnemySwarmerDeath.mp3');
|
|
this.load.audio('sfx-death-shooter', './assets/fx/EnemyShooterDeath.mp3');
|
|
this.load.audio('sfx-death-sprayer', './assets/fx/EnemySprayerDeath.mp3');
|
|
this.load.audio('sfx-death-bomber', './assets/fx/EnemyBomberDeath.mp3');
|
|
}
|
|
|
|
create() {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
|
|
this._drawArena(W, H);
|
|
|
|
this.physics.world.setBounds(0, 0, W, H);
|
|
|
|
// Core systems — data already loaded by preload()
|
|
this.skillTree = new SkillTree();
|
|
this.skillTree.load(this.cache.json.get('skillTree'));
|
|
|
|
this.player = new Player(this, W / 2, H / 2);
|
|
|
|
this.xpSystem = new XPSystem(this);
|
|
|
|
this.waveManager = new WaveManager(this, this.player);
|
|
this.waveManager.load(this.cache.json.get('zones'));
|
|
|
|
this.hud = new HUD(this, this.player, this.xpSystem);
|
|
|
|
// Enemy projectile group for collision
|
|
this._enemyProjectiles = [];
|
|
|
|
// Event wiring
|
|
this.events.on('enemy-killed', ({ xp }) => this.xpSystem.addXP(xp));
|
|
this.events.on('enemy-projectile-spawned', proj => this._enemyProjectiles.push(proj));
|
|
this.events.on('level-up', level => this._showLevelUp(level));
|
|
this.events.on('game-over', () => this._onGameOver());
|
|
this.events.on('victory', () => this._onVictory());
|
|
|
|
this._levelUpPending = false;
|
|
this._frozen = false;
|
|
this._waitingForExit = false;
|
|
this._pulseEffects = [];
|
|
this._shimmers = [];
|
|
this._shimmerTimer = 0;
|
|
this._shimmerSpawnMs = 1500;
|
|
|
|
this.events.on('wave-start', () => this.sound.play('sfx-enemy-wave', { volume: 0.5 }));
|
|
this.events.on('zone-waves-complete', () => this._startZoneExit());
|
|
this.events.on('player-died', () => this._onPlayerDied());
|
|
this.events.on('player-respawned', () => { this.waveManager.enemiesFrozen = false; });
|
|
|
|
this.reticle = new Reticle(this);
|
|
|
|
this._setupBarriers();
|
|
|
|
this._bgMusic = this.sound.add('music-game', { loop: true, volume: 0.8 });
|
|
this._bgMusic.play();
|
|
|
|
this.waveManager.start();
|
|
}
|
|
|
|
_setupBarriers() {
|
|
// Remove old colliders before destroying the groups they reference
|
|
if (this._barrierColliders) {
|
|
this._barrierColliders.forEach(c => c.destroy());
|
|
}
|
|
this.barrierManager?.destroy();
|
|
|
|
const zoneData = this.waveManager.currentZone ?? this.waveManager.zones[0];
|
|
const interiorCount = zoneData?.interiorBarriers ?? 0;
|
|
this.barrierManager = new BarrierManager(this, interiorCount);
|
|
|
|
// Player blocked by all barriers; enemies only blocked by interior ones
|
|
this._barrierColliders = [
|
|
this.physics.add.collider(this.player.sprite, this.barrierManager.staticGroup),
|
|
this.physics.add.collider(this.waveManager.spriteGroup, this.barrierManager.interiorStaticGroup),
|
|
];
|
|
|
|
this.barrierManager.activateEdgeBarriers(() => {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
if (this.barrierManager.isInsideEdgeBarrier(this.player.x, this.player.y)) {
|
|
this.player.sprite.body.reset(W / 2, H / 2);
|
|
this.player.takeDamage(this.player.hp); // lose a life, respawn at center
|
|
}
|
|
});
|
|
}
|
|
|
|
_drawArena(W, H) {
|
|
this._arenaBg = this.add.rectangle(W / 2, H / 2, W, H, 0x111118);
|
|
this._arenaGrid = this.add.graphics();
|
|
const z1 = ZONE_PALETTE[1];
|
|
this._drawArenaGrid(z1.grid, z1.gridAlpha, z1.border);
|
|
}
|
|
|
|
_drawArenaGrid(gridColor, gridAlpha, borderColor) {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
this._arenaGrid.clear();
|
|
this._arenaGrid.lineStyle(1, gridColor, gridAlpha);
|
|
for (let x = 0; x <= W; x += 80) { this._arenaGrid.lineBetween(x, 0, x, H); }
|
|
for (let y = 0; y <= H; y += 80) { this._arenaGrid.lineBetween(0, y, W, y); }
|
|
this._arenaGrid.lineStyle(3, borderColor, 1);
|
|
this._arenaGrid.strokeRect(2, 2, W - 4, H - 4);
|
|
}
|
|
|
|
_updateArenaColors(zoneNum) {
|
|
const palette = ZONE_PALETTE[zoneNum] ?? ZONE_PALETTE[ZONE_PALETTE.length - 1];
|
|
this._arenaBg.setFillStyle(palette.bg);
|
|
this._drawArenaGrid(palette.grid, palette.gridAlpha, palette.border);
|
|
}
|
|
|
|
_spawnShimmer() {
|
|
const zoneNum = this.waveManager.zoneNum;
|
|
if (zoneNum < 2) return;
|
|
if (this._shimmers.length >= 2) return;
|
|
const palette = ZONE_PALETTE[Math.min(zoneNum, ZONE_PALETTE.length - 1)];
|
|
if (!palette?.shimmer) return;
|
|
|
|
const COLS = Math.floor(this.scale.width / 80);
|
|
const ROWS = Math.floor(this.scale.height / 80);
|
|
const col = Phaser.Math.Between(0, COLS - 1);
|
|
const row = Phaser.Math.Between(0, ROWS - 1);
|
|
|
|
const rect = this.add.rectangle(
|
|
col * 80 + 40, row * 80 + 40, 80, 80, palette.shimmer, 0
|
|
).setDepth(1);
|
|
|
|
this._shimmers.push({
|
|
rect, col, row,
|
|
stepTimer: 0,
|
|
stepMs: Phaser.Math.Between(250, 400),
|
|
stepsLeft: Phaser.Math.Between(5, 9),
|
|
phase: 'fadein',
|
|
phaseTimer: 0,
|
|
});
|
|
}
|
|
|
|
_updateShimmers(delta) {
|
|
if (this.waveManager.zoneNum < 2) return;
|
|
|
|
this._shimmerTimer += delta;
|
|
if (this._shimmerTimer >= this._shimmerSpawnMs) {
|
|
this._shimmerTimer = 0;
|
|
this._shimmerSpawnMs = Phaser.Math.Between(3000, 6000);
|
|
this._spawnShimmer();
|
|
}
|
|
|
|
const COLS = Math.floor(this.scale.width / 80);
|
|
const ROWS = Math.floor(this.scale.height / 80);
|
|
const TARGET_ALPHA = 0.22;
|
|
const FADE_IN_MS = 150;
|
|
const FADE_OUT_MS = 350;
|
|
|
|
this._shimmers = this._shimmers.filter(s => {
|
|
s.phaseTimer += delta;
|
|
|
|
if (s.phase === 'fadein') {
|
|
s.rect.fillAlpha = Math.min(1, s.phaseTimer / FADE_IN_MS) * TARGET_ALPHA;
|
|
if (s.phaseTimer >= FADE_IN_MS) {
|
|
s.phase = 'walk';
|
|
s.phaseTimer = 0;
|
|
s.stepTimer = 0;
|
|
}
|
|
} else if (s.phase === 'walk') {
|
|
s.stepTimer += delta;
|
|
if (s.stepTimer >= s.stepMs) {
|
|
s.stepTimer = 0;
|
|
s.stepsLeft--;
|
|
if (s.stepsLeft <= 0) {
|
|
s.phase = 'fadeout';
|
|
s.phaseTimer = 0;
|
|
} else {
|
|
const dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]];
|
|
const [dc, dr] = dirs[Phaser.Math.Between(0, 3)];
|
|
s.col = Phaser.Math.Clamp(s.col + dc, 0, COLS - 1);
|
|
s.row = Phaser.Math.Clamp(s.row + dr, 0, ROWS - 1);
|
|
s.rect.setPosition(s.col * 80 + 40, s.row * 80 + 40);
|
|
s.stepMs = Phaser.Math.Between(250, 400);
|
|
}
|
|
}
|
|
} else if (s.phase === 'fadeout') {
|
|
s.rect.fillAlpha = Math.max(0, (1 - s.phaseTimer / FADE_OUT_MS)) * TARGET_ALPHA;
|
|
if (s.phaseTimer >= FADE_OUT_MS) {
|
|
s.rect.destroy();
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
update(time, delta) {
|
|
this.reticle?.update(delta);
|
|
|
|
if (!this.player || this._frozen) return;
|
|
|
|
this.player.update(delta);
|
|
this.waveManager.update(delta);
|
|
this.hud.update();
|
|
|
|
this._checkBulletHits();
|
|
this._checkEnemyProjectileHits();
|
|
this._pruneEnemyProjectiles();
|
|
this._updatePulseEffects(delta);
|
|
this._updateShimmers(delta);
|
|
|
|
if (this._waitingForExit) this._checkPlayerExit();
|
|
}
|
|
|
|
_updatePulseEffects(delta) {
|
|
this._pulseEffects = this._pulseEffects.filter(effect => {
|
|
effect.elapsed += delta;
|
|
|
|
if (!effect.adjSpawned && effect.elapsed >= effect.ADJ_MS) {
|
|
effect.adjSpawned = true;
|
|
effect.adjacents.forEach(t => { if (t?.active) t.setVisible(true); });
|
|
}
|
|
|
|
if (effect.elapsed >= effect.FADE_MS) {
|
|
const progress = Math.min(1, (effect.elapsed - effect.FADE_MS) / (effect.END_MS - effect.FADE_MS));
|
|
if (effect.center?.active) effect.center.alpha = Math.max(0, 0.55 * (1 - progress));
|
|
effect.adjacents.forEach(t => { if (t?.active) t.alpha = Math.max(0, 0.38 * (1 - progress)); });
|
|
}
|
|
|
|
if (effect.elapsed >= effect.END_MS) {
|
|
if (effect.center?.active) effect.center.destroy();
|
|
effect.adjacents.forEach(t => { if (t?.active) t.destroy(); });
|
|
return false; // remove from array
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
_onPlayerDied() {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
const cx = W / 2;
|
|
const cy = H / 2;
|
|
|
|
// Destroy all enemy projectiles
|
|
this._enemyProjectiles.forEach(p => { if (p?.active) p.destroy(); });
|
|
this._enemyProjectiles = [];
|
|
|
|
// Destroy enemies within 150px of screen centre
|
|
this.waveManager.enemies.forEach(e => {
|
|
if (e.active && Phaser.Math.Distance.Between(e.x, e.y, cx, cy) < 150) {
|
|
e.takeDamage(99999);
|
|
}
|
|
});
|
|
|
|
// Freeze remaining enemies for the duration of invincibility
|
|
this.waveManager.enemiesFrozen = true;
|
|
}
|
|
|
|
_checkBulletHits() {
|
|
const bullets = this.player.bullets.getChildren();
|
|
const enemies = this.waveManager.enemies;
|
|
|
|
for (const bullet of bullets) {
|
|
if (!bullet.active) continue;
|
|
|
|
// Destroy bullet if it hits a barrier
|
|
if (this.barrierManager.isPointBlocked(bullet.x, bullet.y)) {
|
|
bullet.destroy();
|
|
continue;
|
|
}
|
|
|
|
for (const enemy of enemies) {
|
|
if (!enemy.active) continue;
|
|
const dist = Phaser.Math.Distance.Between(bullet.x, bullet.y, enemy.x, enemy.y);
|
|
if (dist < enemy.radius + 5) {
|
|
enemy.takeDamage(bullet.damage);
|
|
bullet.destroy();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
_checkEnemyProjectileHits() {
|
|
this._enemyProjectiles = this._enemyProjectiles.filter(p => p?.active);
|
|
this._enemyProjectiles.forEach(proj => {
|
|
if (!proj.active) return;
|
|
const dist = Phaser.Math.Distance.Between(proj.x, proj.y, this.player.x, this.player.y);
|
|
if (dist < 16 + 6) {
|
|
this.player.takeDamage(proj.damage);
|
|
proj.destroy();
|
|
}
|
|
});
|
|
}
|
|
|
|
_pruneEnemyProjectiles() {
|
|
this._enemyProjectiles = this._enemyProjectiles.filter(p => p?.active);
|
|
}
|
|
|
|
// ── Zone exit (Smash TV style) ─────────────────────────────────────────────
|
|
|
|
_startZoneExit() {
|
|
this.sound.play('sfx-edge-remove', { volume: 0.6 });
|
|
// Explode edge barriers first, then allow exit
|
|
this.barrierManager.explodeEdgeBarriers(() => {
|
|
this._waitingForExit = true;
|
|
this.player.sprite.body.setCollideWorldBounds(false);
|
|
this._showExitArrows();
|
|
});
|
|
}
|
|
|
|
_showExitArrows() {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
|
|
const g = this.add.graphics();
|
|
g.setDepth(15);
|
|
this._exitArrowsGfx = g;
|
|
|
|
const ARROW_W = 30; // triangle base half-width
|
|
const ARROW_D = 28; // triangle depth (pointing direction)
|
|
const MARGIN = 18; // gap from screen edge to arrow tip
|
|
|
|
const drawUp = (cx, tipY) => g.fillTriangle(cx - ARROW_W, tipY + ARROW_D, cx + ARROW_W, tipY + ARROW_D, cx, tipY);
|
|
const drawDown = (cx, tipY) => g.fillTriangle(cx - ARROW_W, tipY - ARROW_D, cx + ARROW_W, tipY - ARROW_D, cx, tipY);
|
|
const drawLeft = (tipX, cy) => g.fillTriangle(tipX + ARROW_D, cy - ARROW_W, tipX + ARROW_D, cy + ARROW_W, tipX, cy);
|
|
const drawRight = (tipX, cy) => g.fillTriangle(tipX - ARROW_D, cy - ARROW_W, tipX - ARROW_D, cy + ARROW_W, tipX, cy);
|
|
|
|
// Three arrows per edge
|
|
const xPositions = [W * 0.25, W * 0.5, W * 0.75];
|
|
const yPositions = [H * 0.25, H * 0.5, H * 0.75];
|
|
|
|
g.fillStyle(0xffffff, 1);
|
|
xPositions.forEach(cx => {
|
|
drawUp(cx, MARGIN);
|
|
drawDown(cx, H - MARGIN);
|
|
});
|
|
yPositions.forEach(cy => {
|
|
drawLeft(MARGIN, cy);
|
|
drawRight(W - MARGIN, cy);
|
|
});
|
|
|
|
this._arrowPing = this.sound.add('sfx-arrow-ping', { loop: true, volume: 0.4 });
|
|
this._arrowPing.play();
|
|
|
|
// Blink the arrows
|
|
this._exitArrowsTween = this.tweens.add({
|
|
targets: g,
|
|
alpha: 0.1,
|
|
duration: 350,
|
|
yoyo: true,
|
|
repeat: -1,
|
|
ease: 'Sine.easeInOut',
|
|
});
|
|
|
|
// "Zone cleared" prompt
|
|
this._exitText = this.add.text(W / 2, 60, 'ZONE CLEARED — EXIT THROUGH ANY DOOR', {
|
|
fontSize: '20px',
|
|
fill: '#ffdd44',
|
|
fontStyle: 'bold',
|
|
stroke: '#000000',
|
|
strokeThickness: 4,
|
|
}).setOrigin(0.5).setDepth(15);
|
|
|
|
this.tweens.add({
|
|
targets: this._exitText,
|
|
alpha: 0,
|
|
duration: 400,
|
|
yoyo: true,
|
|
repeat: -1,
|
|
});
|
|
}
|
|
|
|
_hideExitArrows() {
|
|
this._exitArrowsTween?.stop();
|
|
this._exitArrowsGfx?.destroy();
|
|
this._exitText?.destroy();
|
|
this._arrowPing?.stop();
|
|
this._arrowPing = null;
|
|
this._exitArrowsGfx = null;
|
|
this._exitText = null;
|
|
}
|
|
|
|
_checkPlayerExit() {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
const px = this.player.x;
|
|
const py = this.player.y;
|
|
|
|
if (px < -24) this._doZoneTransition('left');
|
|
else if (px > W + 24) this._doZoneTransition('right');
|
|
else if (py < -24) this._doZoneTransition('top');
|
|
else if (py > H + 24) this._doZoneTransition('bottom');
|
|
}
|
|
|
|
_doZoneTransition(direction) {
|
|
this._waitingForExit = false;
|
|
this._hideExitArrows();
|
|
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
|
|
// Respawn player on the opposite edge, same lateral position
|
|
const px = Phaser.Math.Clamp(this.player.x, 48, W - 48);
|
|
const py = Phaser.Math.Clamp(this.player.y, 48, H - 48);
|
|
const spawnX = direction === 'left' ? W - 48 : direction === 'right' ? 48 : px;
|
|
const spawnY = direction === 'top' ? H - 48 : direction === 'bottom' ? 48 : py;
|
|
|
|
// White flash
|
|
const flash = this.add.rectangle(W / 2, H / 2, W, H, 0xffffff).setDepth(50);
|
|
this.tweens.add({
|
|
targets: flash,
|
|
alpha: 0,
|
|
duration: 300,
|
|
onComplete: () => flash.destroy(),
|
|
});
|
|
|
|
this.player.sprite.setPosition(spawnX, spawnY);
|
|
this.player.sprite.body.setCollideWorldBounds(true);
|
|
this.waveManager.startNextZone();
|
|
// Set up barriers AFTER zone index is incremented so we read the new zone's config
|
|
if (this.waveManager.currentZone) this._setupBarriers();
|
|
this._updateArenaColors(this.waveManager.zoneNum);
|
|
this._shimmers.forEach(s => s.rect?.destroy());
|
|
this._shimmers = [];
|
|
this._shimmerTimer = 0;
|
|
this._shimmerSpawnMs = 1500;
|
|
}
|
|
|
|
// ── Level up ───────────────────────────────────────────────────────────────
|
|
|
|
_showLevelUp(level) {
|
|
if (this._levelUpPending) return;
|
|
this._levelUpPending = true;
|
|
|
|
// Only show if there are skills available
|
|
const available = this.skillTree.getAvailable();
|
|
if (available.length === 0) {
|
|
this._levelUpPending = false;
|
|
return;
|
|
}
|
|
|
|
this._frozen = true;
|
|
this.physics.world.pause();
|
|
|
|
new SkillTreeUI(this, this.skillTree, this.player, () => {
|
|
this._levelUpPending = false;
|
|
this._frozen = false;
|
|
this.physics.world.resume();
|
|
});
|
|
}
|
|
|
|
_onGameOver() {
|
|
this._bgMusic?.stop();
|
|
this.scene.launch('GameOverScene');
|
|
this.scene.pause();
|
|
}
|
|
|
|
_onVictory() {
|
|
const W = this.scale.width;
|
|
const H = this.scale.height;
|
|
|
|
this.add.rectangle(W / 2, H / 2, W, H, 0x000000, 0.7).setDepth(30);
|
|
this.add.text(W / 2, H / 2 - 40, 'VICTORY!', {
|
|
fontFamily: 'FutureImperfect',
|
|
fontSize: '72px', fill: '#ffdd00',
|
|
}).setOrigin(0.5).setDepth(31);
|
|
|
|
const prompt = this.add.text(W / 2, H / 2 + 60, 'Press R to return to menu', {
|
|
fontSize: '22px', fill: '#ffffff'
|
|
}).setOrigin(0.5).setDepth(31);
|
|
this.tweens.add({ targets: prompt, alpha: 0, duration: 700, yoyo: true, repeat: -1 });
|
|
|
|
this.input.keyboard.once('keydown-R', () => {
|
|
this.scene.start('IntroScene');
|
|
});
|
|
}
|
|
|
|
shutdown() {
|
|
// Remove only our custom listeners — removeAllListeners() would also strip
|
|
// Phaser's internal scene lifecycle listeners and corrupt the next create().
|
|
this.events.off('enemy-killed');
|
|
this.events.off('enemy-projectile-spawned');
|
|
this.events.off('level-up');
|
|
this.events.off('game-over');
|
|
this.events.off('victory');
|
|
this.events.off('wave-start');
|
|
this.events.off('zone-waves-complete');
|
|
this.events.off('player-died');
|
|
this.events.off('player-respawned');
|
|
this._barrierColliders?.forEach(c => c.destroy());
|
|
this.reticle?.destroy();
|
|
this.barrierManager?.destroy();
|
|
this._hideExitArrows();
|
|
this._waitingForExit = false;
|
|
this.player?.destroy();
|
|
this.waveManager?.reset();
|
|
this.hud?.destroy();
|
|
this._bgMusic?.stop();
|
|
this._bgMusic = null;
|
|
this._enemyProjectiles = [];
|
|
this._pulseEffects = [];
|
|
this._shimmers?.forEach(s => s.rect?.destroy());
|
|
this._shimmers = [];
|
|
}
|
|
}
|