733 lines
24 KiB
JavaScript
733 lines
24 KiB
JavaScript
// NPC Entity
|
|
// NPC z random walk AI in isometrično podporo
|
|
class NPC {
|
|
constructor(scene, gridX, gridY, offsetX = 0, offsetY = 0, type = 'zombie') {
|
|
this.scene = scene;
|
|
this.gridX = gridX;
|
|
this.gridY = gridY;
|
|
this.type = type;
|
|
console.log(`🎭 NPC Constructor called - Type: ${type} at (${gridX}, ${gridY})`);
|
|
|
|
// Terrain offset
|
|
this.offsetX = offsetX;
|
|
this.offsetY = offsetY;
|
|
|
|
this.iso = new IsometricUtils(48, 24);
|
|
|
|
// Random walk paramters
|
|
this.moveSpeed = 100; // px/s
|
|
this.gridMoveTime = 300; // ms
|
|
|
|
// Stanje
|
|
this.state = 'WANDER'; // WANDER, TAMED, FOLLOW
|
|
this.isMoving = false;
|
|
this.pauseTime = 0;
|
|
this.maxPauseTime = 2000;
|
|
this.attackCooldownTimer = 0;
|
|
|
|
// Elite Zombie Stats
|
|
if (type === 'elite_zombie') {
|
|
this.hp = 50; // 2.5x več HP
|
|
this.maxHp = 50;
|
|
this.moveSpeed = 150; // 50% hitrejši
|
|
this.gridMoveTime = 200; // Hitrejši premiki
|
|
} else {
|
|
this.hp = 20;
|
|
this.maxHp = 20;
|
|
}
|
|
|
|
// Kreira sprite
|
|
this.createSprite();
|
|
|
|
// Začetna pozicija
|
|
this.updatePosition();
|
|
|
|
// Naključna začetna pavza
|
|
this.pauseTime = Math.random() * this.maxPauseTime;
|
|
|
|
// Register in SpatialGrid
|
|
if (this.scene.spatialGrid) {
|
|
this.scene.spatialGrid.add(this);
|
|
}
|
|
}
|
|
|
|
// Methods moved/consolidated below
|
|
|
|
createSprite() {
|
|
let texKey = `npc_${this.type}`;
|
|
let isAnimated = false;
|
|
|
|
// Check for animated sprites first
|
|
if (this.type === 'zombie' && this.scene.textures.exists('zombie_walk')) {
|
|
texKey = 'zombie_walk';
|
|
isAnimated = true;
|
|
} else if (this.type === 'zombie' && this.scene.textures.exists('zombie_sprite')) {
|
|
texKey = 'zombie_sprite';
|
|
} else if (this.type === 'merchant') {
|
|
// Uporabi generirano sliko, če obstaja
|
|
if (this.scene.textures.exists('merchant_new')) {
|
|
texKey = 'merchant_new';
|
|
} else {
|
|
texKey = 'merchant_texture'; // Fallback na proceduralno
|
|
}
|
|
console.log('🏪 Creating MERCHANT NPC with texture:', texKey);
|
|
} else if (this.type === 'elite_zombie') {
|
|
// Elite Zombie sprite
|
|
if (this.scene.textures.exists('elite_zombie')) {
|
|
texKey = 'elite_zombie';
|
|
} else {
|
|
texKey = 'npc_elite_zombie'; // Fallback na proceduralno
|
|
}
|
|
console.log('👹 Creating ELITE ZOMBIE with texture:', texKey);
|
|
} else if (!this.scene.textures.exists(texKey)) {
|
|
TextureGenerator.createNPCSprite(this.scene, texKey, this.type);
|
|
}
|
|
|
|
// Kreira sprite
|
|
const screenPos = this.iso.toScreen(this.gridX, this.gridY);
|
|
this.sprite = this.scene.add.sprite(
|
|
screenPos.x + this.offsetX,
|
|
screenPos.y + this.offsetY,
|
|
texKey
|
|
);
|
|
this.sprite.setOrigin(0.5, 1);
|
|
|
|
if (isAnimated) {
|
|
this.sprite.setScale(1.5);
|
|
} else {
|
|
// Scale po tipu
|
|
let scale = 0.5; // Default
|
|
if (this.type === 'merchant') scale = 0.2;
|
|
else if (this.type === 'elite_zombie') scale = 0.2; // Elite manjši
|
|
this.sprite.setScale(scale);
|
|
}
|
|
|
|
// HEALTH BAR
|
|
this.healthBarBg = this.scene.add.graphics();
|
|
this.healthBarBg.fillStyle(0x000000, 0.5);
|
|
this.healthBarBg.fillRect(-16, -70, 32, 4);
|
|
this.healthBarBg.setVisible(false);
|
|
|
|
this.healthBar = this.scene.add.graphics();
|
|
this.healthBar.fillStyle(0x00ff00, 1);
|
|
this.healthBar.fillRect(-16, -70, 32, 4);
|
|
this.healthBar.setVisible(false);
|
|
|
|
// Depth sorting
|
|
this.updateDepth();
|
|
}
|
|
|
|
moveToGrid(targetX, targetY) {
|
|
// Determine facing direction before moving
|
|
const dx = targetX - this.gridX;
|
|
const dy = targetY - this.gridY;
|
|
const movingRight = (dx > 0) || (dy > 0);
|
|
this.sprite.setFlipX(!movingRight);
|
|
|
|
this.isMoving = true;
|
|
this.gridX = targetX;
|
|
this.gridY = targetY;
|
|
|
|
const targetScreen = this.iso.toScreen(targetX, targetY);
|
|
|
|
// Animation
|
|
if (this.sprite.texture.key === 'zombie_walk') {
|
|
this.sprite.play('zombie_walk_anim', true);
|
|
}
|
|
|
|
// Tween za smooth gibanje
|
|
this.scene.tweens.add({
|
|
targets: this.sprite,
|
|
x: targetScreen.x + this.offsetX,
|
|
y: targetScreen.y + this.offsetY,
|
|
duration: this.gridMoveTime,
|
|
ease: 'Linear',
|
|
onComplete: () => {
|
|
this.isMoving = false;
|
|
this.updatePosition();
|
|
|
|
// Stop Animation
|
|
if (this.sprite.texture.key === 'zombie_walk') {
|
|
this.sprite.stop();
|
|
this.sprite.setFrame(0);
|
|
}
|
|
}
|
|
});
|
|
|
|
// Posodobi depth
|
|
this.updateDepth();
|
|
}
|
|
|
|
update(delta) {
|
|
// 1. Viewport Culling - če sprite ni viden na kameri, preskoči risanje
|
|
const camera = this.scene.cameras.main;
|
|
if (camera && this.sprite) {
|
|
const worldView = camera.worldView;
|
|
const isVisible = Phaser.Geom.Rectangle.Overlaps(worldView, this.sprite.getBounds());
|
|
|
|
if (!isVisible && this.sprite.visible) {
|
|
this.sprite.setVisible(false);
|
|
if (this.healthBar) {
|
|
this.healthBar.setVisible(false);
|
|
this.healthBarBg.setVisible(false);
|
|
}
|
|
if (this.eyesGroup) this.eyesGroup.setVisible(false);
|
|
return; // Preskoči AI če ni viden
|
|
} else if (isVisible && !this.sprite.visible) {
|
|
this.sprite.setVisible(true);
|
|
if (this.eyesGroup) this.eyesGroup.setVisible(true);
|
|
}
|
|
}
|
|
|
|
// 2. Distance Culling
|
|
if (this.scene.player) {
|
|
const playerPos = this.scene.player.getPosition();
|
|
const dist = Phaser.Math.Distance.Between(this.gridX, this.gridY, playerPos.x, playerPos.y);
|
|
const cullDist = (this.state === 'CHASE' || this.state === 'FOLLOW') ? 50 : 30;
|
|
|
|
if (dist > cullDist) {
|
|
if (this.sprite.visible) {
|
|
this.sprite.setVisible(false);
|
|
if (this.healthBar) {
|
|
this.healthBar.setVisible(false);
|
|
this.healthBarBg.setVisible(false);
|
|
}
|
|
if (this.eyesGroup) this.eyesGroup.setVisible(false);
|
|
}
|
|
return;
|
|
} else {
|
|
if (!this.sprite.visible) {
|
|
this.sprite.setVisible(true);
|
|
if (this.eyesGroup) this.eyesGroup.setVisible(true);
|
|
// Bars stay hidden until damaged usually
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. Optimization: Update depth ONLY if moving
|
|
if (this.isMoving) {
|
|
this.updateDepth();
|
|
this.updatePosition();
|
|
if (this.scene.spatialGrid) this.scene.spatialGrid.updateEntity(this);
|
|
return;
|
|
}
|
|
|
|
// 3. AI Logic
|
|
if (this.type === 'zombie' && this.state !== 'TAMED' && this.state !== 'FOLLOW') {
|
|
this.handleAggressiveAI(delta);
|
|
} else {
|
|
this.handlePassiveAI(delta);
|
|
}
|
|
|
|
this.updatePosition();
|
|
}
|
|
|
|
handlePassiveAI(delta) {
|
|
if (this.state === 'TAMED' || this.state === 'FOLLOW') {
|
|
// Defensive behavior - attack nearby enemy zombies
|
|
this.defendPlayer();
|
|
this.followPlayer();
|
|
return;
|
|
}
|
|
|
|
this.pauseTime += delta;
|
|
if (this.pauseTime >= this.maxPauseTime) {
|
|
this.performRandomWalk();
|
|
this.pauseTime = 0;
|
|
}
|
|
}
|
|
|
|
defendPlayer() {
|
|
if (!this.scene.npcs || this.attackCooldownTimer > 0) return;
|
|
|
|
// Find nearest enemy zombie
|
|
let nearestEnemy = null;
|
|
let minDist = 6; // Defense radius
|
|
|
|
for (const npc of this.scene.npcs) {
|
|
if (npc === this || npc.state === 'TAMED' || npc.state === 'FOLLOW') continue;
|
|
if (npc.type !== 'zombie') continue;
|
|
|
|
const dist = Phaser.Math.Distance.Between(this.gridX, this.gridY, npc.gridX, npc.gridY);
|
|
if (dist < minDist) {
|
|
minDist = dist;
|
|
nearestEnemy = npc;
|
|
}
|
|
}
|
|
|
|
if (nearestEnemy) {
|
|
// Attack if close enough
|
|
if (minDist <= 1.5) {
|
|
this.attackEnemy(nearestEnemy);
|
|
} else {
|
|
// Move towards enemy
|
|
this.moveTowards(nearestEnemy.gridX, nearestEnemy.gridY);
|
|
}
|
|
}
|
|
}
|
|
|
|
attackEnemy(target) {
|
|
if (this.attackCooldownTimer > 0) return;
|
|
this.attackCooldownTimer = 1500;
|
|
|
|
console.log('🧟❤️ Tamed Zombie DEFENDS!');
|
|
|
|
// Attack Animation
|
|
if (this.sprite) {
|
|
this.scene.tweens.add({
|
|
targets: this.sprite,
|
|
y: this.sprite.y - 10,
|
|
yoyo: true, duration: 100, repeat: 1
|
|
});
|
|
}
|
|
|
|
// Deal Damage
|
|
if (target && target.takeDamage) {
|
|
target.takeDamage(15); // Tamed zombies hit harder!
|
|
}
|
|
}
|
|
|
|
handleAggressiveAI(delta) {
|
|
if (!this.scene.player) return;
|
|
|
|
const playerPos = this.scene.player.getPosition();
|
|
const dist = Phaser.Math.Distance.Between(this.gridX, this.gridY, playerPos.x, playerPos.y);
|
|
|
|
if (this.attackCooldownTimer > 0) {
|
|
this.attackCooldownTimer -= delta;
|
|
}
|
|
|
|
if (this.state === 'WANDER') {
|
|
if (dist < 8) {
|
|
this.state = 'CHASE';
|
|
this.showEmote('!');
|
|
} else {
|
|
this.pauseTime += delta;
|
|
if (this.pauseTime >= this.maxPauseTime) {
|
|
this.performRandomWalk();
|
|
this.pauseTime = 0;
|
|
}
|
|
}
|
|
}
|
|
else if (this.state === 'CHASE') {
|
|
if (dist > 15) {
|
|
this.state = 'WANDER';
|
|
return;
|
|
}
|
|
if (dist <= 1.5) {
|
|
this.tryAttack();
|
|
} else {
|
|
this.moveTowards(playerPos.x, playerPos.y);
|
|
}
|
|
}
|
|
}
|
|
|
|
moveTowards(targetX, targetY) {
|
|
// Optimization: if very close, use direct movement (collision checks handled by isValidMove)
|
|
const dist = Phaser.Math.Distance.Between(this.gridX, this.gridY, targetX, targetY);
|
|
|
|
// Use pathfinding for longer distances
|
|
if (dist > 2 && this.scene.pathfinding) {
|
|
|
|
// Check if we need to recalc path (target changed or no path)
|
|
const targetKey = `${targetX},${targetY}`;
|
|
if (!this.currentPath || this.pathTargetKey !== targetKey || this.currentPath.length === 0) {
|
|
|
|
// Recalc path (Async Worker)
|
|
if (!this.isWaitingForPath) {
|
|
this.isWaitingForPath = true;
|
|
this.scene.pathfinding.findPath(this.gridX, this.gridY, targetX, targetY, (path) => {
|
|
this.isWaitingForPath = false;
|
|
this.currentPath = path;
|
|
this.pathTargetKey = targetKey;
|
|
|
|
// Process path once received
|
|
if (this.currentPath && this.currentPath.length > 0) {
|
|
// Remove start node if it's current pos
|
|
if (this.currentPath[0].x === this.gridX && this.currentPath[0].y === this.gridY) {
|
|
this.currentPath.shift();
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
return; // Wait for path
|
|
}
|
|
}
|
|
|
|
// Follow Path
|
|
if (this.currentPath && this.currentPath.length > 0) {
|
|
const step = this.currentPath[0];
|
|
// Move there
|
|
this.moveToGrid(step.x, step.y);
|
|
// Remove step
|
|
this.currentPath.shift();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Fallback: Direct Movement (Dumb AI)
|
|
const dx = Math.sign(targetX - this.gridX);
|
|
const dy = Math.sign(targetY - this.gridY);
|
|
let nextX = this.gridX + dx;
|
|
let nextY = this.gridY + dy;
|
|
|
|
if (this.isValidMove(nextX, nextY)) {
|
|
this.moveToGrid(nextX, nextY);
|
|
} else if (this.isValidMove(this.gridX + dx, this.gridY)) {
|
|
this.moveToGrid(this.gridX + dx, this.gridY);
|
|
} else if (this.isValidMove(this.gridX, this.gridY + dy)) {
|
|
this.moveToGrid(this.gridX, this.gridY + dy);
|
|
}
|
|
}
|
|
|
|
isValidMove(x, y) {
|
|
const terrainSystem = this.scene.terrainSystem;
|
|
if (!terrainSystem) return true;
|
|
if (!this.iso.isInBounds(x, y, terrainSystem.width, terrainSystem.height)) return false;
|
|
if (terrainSystem.tiles[y][x].type.name === 'water') return false;
|
|
|
|
const key = `${x},${y}`;
|
|
if (terrainSystem.decorationsMap.has(key)) {
|
|
const decor = terrainSystem.decorationsMap.get(key);
|
|
const solidTypes = ['tree', 'stone', 'bush', 'wall', 'ruin', 'fence', 'house', 'gravestone'];
|
|
if (solidTypes.includes(decor.type)) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
tryAttack() {
|
|
if (this.attackCooldownTimer > 0) return;
|
|
this.attackCooldownTimer = 1500;
|
|
|
|
// Attack Animation (Jump)
|
|
if (this.sprite) {
|
|
this.scene.tweens.add({
|
|
targets: this.sprite,
|
|
y: this.sprite.y - 10,
|
|
yoyo: true, duration: 100, repeat: 1
|
|
});
|
|
}
|
|
|
|
// Apply Damage to Player
|
|
if (this.scene.player && this.scene.player.takeDamage) {
|
|
console.log('🧟 Zombie ATTACKS Player!');
|
|
this.scene.player.takeDamage(10);
|
|
} else if (this.scene.statsSystem) {
|
|
this.scene.statsSystem.takeDamage(10);
|
|
}
|
|
}
|
|
|
|
performRandomWalk() {
|
|
const dirs = [{ x: 0, y: -1 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 1, y: 0 }];
|
|
const dir = dirs[Math.floor(Math.random() * dirs.length)];
|
|
const nextX = this.gridX + dir.x;
|
|
const nextY = this.gridY + dir.y;
|
|
if (this.isValidMove(nextX, nextY)) {
|
|
this.moveToGrid(nextX, nextY);
|
|
}
|
|
}
|
|
|
|
followPlayer() {
|
|
if (!this.scene.player) return;
|
|
const playerPos = this.scene.player.getPosition();
|
|
const dist = Phaser.Math.Distance.Between(this.gridX, this.gridY, playerPos.x, playerPos.y);
|
|
|
|
if (dist < 2) return;
|
|
this.moveTowards(playerPos.x, playerPos.y);
|
|
}
|
|
|
|
showEmote(text) {
|
|
const emote = this.scene.add.text(this.sprite.x, this.sprite.y - 40, text, { fontSize: '20px', fontStyle: 'bold', color: '#FF0000' });
|
|
emote.setOrigin(0.5);
|
|
emote.setDepth(this.sprite.depth + 100);
|
|
this.scene.tweens.add({ targets: emote, y: emote.y - 20, alpha: 0, duration: 1000, onComplete: () => emote.destroy() });
|
|
}
|
|
|
|
updatePosition() {
|
|
if (!this.sprite) return;
|
|
|
|
const screenPos = this.iso.toScreen(this.gridX, this.gridY);
|
|
|
|
if (!this.isMoving) {
|
|
this.sprite.setPosition(
|
|
screenPos.x + this.offsetX,
|
|
screenPos.y + this.offsetY
|
|
);
|
|
}
|
|
|
|
// BARS
|
|
if (this.healthBar && this.healthBarBg) {
|
|
this.healthBarBg.x = this.sprite.x;
|
|
this.healthBarBg.y = this.sprite.y;
|
|
this.healthBar.x = this.sprite.x;
|
|
this.healthBar.y = this.sprite.y;
|
|
}
|
|
|
|
// EYES
|
|
if (this.eyesGroup) {
|
|
this.eyesGroup.setPosition(this.sprite.x, this.sprite.y);
|
|
}
|
|
|
|
this.updateDepth();
|
|
}
|
|
|
|
updateDepth() {
|
|
if (!this.sprite) return;
|
|
|
|
if (this.lastDepthY === undefined || Math.abs(this.sprite.y - this.lastDepthY) > 0.1) {
|
|
const layerBase = this.iso.LAYER_OBJECTS || 200000;
|
|
const depth = layerBase + this.sprite.y;
|
|
|
|
this.sprite.setDepth(depth);
|
|
this.lastDepthY = this.sprite.y;
|
|
|
|
// Update attached elements depth
|
|
if (this.healthBarBg) {
|
|
this.healthBarBg.setDepth(this.sprite.depth + 100);
|
|
this.healthBar.setDepth(this.sprite.depth + 101);
|
|
}
|
|
if (this.eyesGroup) {
|
|
this.eyesGroup.setDepth(this.sprite.depth + 2);
|
|
}
|
|
}
|
|
}
|
|
|
|
takeDamage(amount) {
|
|
this.hp -= amount;
|
|
|
|
// Hit Sound
|
|
if (this.scene.soundManager) {
|
|
this.scene.soundManager.playHit();
|
|
}
|
|
|
|
// Blood Splash Effect
|
|
if (this.scene.particleEffects) {
|
|
this.scene.particleEffects.bloodSplash(this.sprite.x, this.sprite.y - 20);
|
|
}
|
|
|
|
// Show Health Bar
|
|
if (this.healthBar) {
|
|
this.healthBar.setVisible(true);
|
|
this.healthBarBg.setVisible(true);
|
|
|
|
// Update width
|
|
const percent = Math.max(0, this.hp / this.maxHp);
|
|
this.healthBar.clear();
|
|
this.healthBar.fillStyle(percent < 0.3 ? 0xff0000 : 0x00ff00, 1);
|
|
this.healthBar.fillRect(-16, -70, 32 * percent, 4);
|
|
}
|
|
|
|
// WHITE FLASH Effect
|
|
if (this.sprite) {
|
|
this.sprite.setTint(0xFFFFFF); // White flash
|
|
this.scene.time.delayedCall(50, () => {
|
|
if (this.sprite) {
|
|
this.sprite.setTint(0xFF0000); // Red flash
|
|
this.scene.time.delayedCall(50, () => {
|
|
if (this.sprite) {
|
|
this.sprite.clearTint();
|
|
if (this.state === 'TAMED' || this.state === 'FOLLOW' || this.state === 'STAY') {
|
|
this.sprite.setTint(0xAAFFAA);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// KNOCKBACK Effect
|
|
if (this.sprite && this.scene.player) {
|
|
const knockbackDist = 10;
|
|
const angle = Phaser.Math.Angle.Between(
|
|
this.scene.player.sprite.x,
|
|
this.scene.player.sprite.y,
|
|
this.sprite.x,
|
|
this.sprite.y
|
|
);
|
|
const knockX = Math.cos(angle) * knockbackDist;
|
|
const knockY = Math.sin(angle) * knockbackDist;
|
|
|
|
this.scene.tweens.add({
|
|
targets: this.sprite,
|
|
x: this.sprite.x + knockX,
|
|
y: this.sprite.y + knockY,
|
|
duration: 100,
|
|
yoyo: true,
|
|
ease: 'Quad.easeOut'
|
|
});
|
|
}
|
|
|
|
// FLOATING DAMAGE NUMBERS
|
|
if (this.sprite) {
|
|
const dmgTxt = this.scene.add.text(
|
|
this.sprite.x,
|
|
this.sprite.y - 40,
|
|
`-${amount}`,
|
|
{
|
|
fontSize: '16px',
|
|
fontFamily: 'Courier New',
|
|
color: '#FF0000',
|
|
stroke: '#000',
|
|
strokeThickness: 3,
|
|
fontStyle: 'bold'
|
|
}
|
|
);
|
|
dmgTxt.setOrigin(0.5);
|
|
dmgTxt.setDepth(999999);
|
|
this.scene.tweens.add({
|
|
targets: dmgTxt,
|
|
y: dmgTxt.y - 30,
|
|
alpha: 0,
|
|
duration: 800,
|
|
ease: 'Cubic.easeOut',
|
|
onComplete: () => dmgTxt.destroy()
|
|
});
|
|
}
|
|
|
|
console.log(`Zombie HP: ${this.hp}`);
|
|
|
|
if (this.hp <= 0) {
|
|
this.die();
|
|
}
|
|
}
|
|
|
|
die() {
|
|
console.log('🧟💀 Zombie DEAD');
|
|
|
|
// Death Sound
|
|
if (this.scene.soundManager) {
|
|
this.scene.soundManager.playDeath();
|
|
}
|
|
|
|
// Spawn loot - Elite zombies drop better items!
|
|
if (this.scene.lootSystem) {
|
|
const lootItem = (this.type === 'elite_zombie') ? 'item_scrap' : 'item_bone';
|
|
this.scene.lootSystem.spawnLoot(this.gridX, this.gridY, lootItem);
|
|
|
|
// Elite bonus: 50% chance for extra chip
|
|
if (this.type === 'elite_zombie' && Math.random() < 0.5) {
|
|
this.scene.lootSystem.spawnLoot(this.gridX, this.gridY, 'item_chip');
|
|
}
|
|
} else if (this.scene.interactionSystem && this.scene.interactionSystem.spawnLoot) {
|
|
// Fallback
|
|
const lootItem = (this.type === 'elite_zombie') ? 'item_scrap' : 'item_bone';
|
|
this.scene.interactionSystem.spawnLoot(this.gridX, this.gridY, lootItem);
|
|
}
|
|
|
|
// Quest Tracking (Kill)
|
|
if (this.scene.questSystem) {
|
|
this.scene.questSystem.trackAction(this.type);
|
|
}
|
|
|
|
this.destroy();
|
|
|
|
const idx = this.scene.npcs.indexOf(this);
|
|
if (idx > -1) this.scene.npcs.splice(idx, 1);
|
|
}
|
|
|
|
tame() {
|
|
if (this.state === 'TAMED' || this.type !== 'zombie') return;
|
|
|
|
this.state = 'TAMED';
|
|
console.log('🧟❤️ Zombie TAMED!');
|
|
|
|
// Register to ZombieWorkerSystem
|
|
if (this.scene.zombieSystem) {
|
|
this.scene.zombieSystem.registerWorker(this);
|
|
}
|
|
|
|
// Visual Feedback
|
|
const headX = this.sprite.x;
|
|
const headY = this.sprite.y - 50;
|
|
|
|
const heart = this.scene.add.text(headX, headY, '❤️', { fontSize: '24px' });
|
|
heart.setOrigin(0.5);
|
|
heart.setDepth(this.sprite.depth + 200);
|
|
|
|
this.scene.tweens.add({
|
|
targets: heart,
|
|
y: headY - 40,
|
|
alpha: 0,
|
|
duration: 1500,
|
|
onComplete: () => heart.destroy()
|
|
});
|
|
|
|
// Change color slightly to indicate friend
|
|
this.sprite.setTint(0xAAFFAA);
|
|
|
|
// Hide Health Bar if tamed
|
|
if (this.healthBarBg) {
|
|
this.healthBarBg.setVisible(false);
|
|
this.healthBar.setVisible(false);
|
|
}
|
|
|
|
this.addTamedEyes();
|
|
}
|
|
|
|
interact() {
|
|
console.log('🗣️ Inteacting with NPC:', this.type);
|
|
|
|
// ZOMBIE LOGIC
|
|
if (this.type === 'zombie') {
|
|
if (this.state !== 'TAMED') {
|
|
// Try tame (For now instant)
|
|
this.tame();
|
|
} else {
|
|
// Command: Toggle FOLLOW / STAY
|
|
if (this.state === 'FOLLOW') {
|
|
this.state = 'STAY';
|
|
this.showEmote('🛑'); // Stop
|
|
if (this.workerStats) this.workerStats.task = 'IDLE';
|
|
} else {
|
|
this.state = 'FOLLOW';
|
|
this.showEmote('👣'); // Footprints
|
|
if (this.workerStats) this.workerStats.task = 'FOLLOW';
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// NPC QUEST LOGIC
|
|
if (this.scene.questSystem) {
|
|
const availableQuest = this.scene.questSystem.getAvailableQuest(this.type);
|
|
if (availableQuest) {
|
|
const ui = this.scene.scene.get('UIScene');
|
|
if (ui && ui.showQuestDialog) {
|
|
ui.showQuestDialog(availableQuest, () => {
|
|
this.scene.questSystem.startQuest(availableQuest.id);
|
|
});
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Default behavior (Emote)
|
|
this.showEmote('👋');
|
|
if (this.sprite) {
|
|
this.scene.tweens.add({ targets: this.sprite, y: this.sprite.y - 10, yoyo: true, duration: 100 });
|
|
}
|
|
}
|
|
|
|
addTamedEyes() {
|
|
if (this.eyesGroup) return;
|
|
|
|
this.eyesGroup = this.scene.add.container(this.sprite.x, this.sprite.y);
|
|
this.eyesGroup.setDepth(this.sprite.depth + 1);
|
|
|
|
const eyeL = this.scene.add.rectangle(-4, -54, 4, 4, 0x00FFFF); // Cyan eyes
|
|
const eyeR = this.scene.add.rectangle(4, -54, 4, 4, 0x00FFFF);
|
|
|
|
this.eyesGroup.add([eyeL, eyeR]);
|
|
}
|
|
|
|
destroy() {
|
|
if (this.scene.spatialGrid) {
|
|
this.scene.spatialGrid.remove(this);
|
|
}
|
|
if (this.sprite) this.sprite.destroy();
|
|
if (this.healthBar) this.healthBar.destroy();
|
|
if (this.healthBarBg) this.healthBarBg.destroy();
|
|
if (this.eyesGroup) this.eyesGroup.destroy();
|
|
}
|
|
}
|