630 lines
19 KiB
JavaScript
630 lines
19 KiB
JavaScript
/**
|
|
* HybridAbilitySystem.js
|
|
*
|
|
* Phase 36: Hybrid Skill - Alfa Abilities
|
|
* Player's unique Alfa powers to control and support zombies
|
|
*
|
|
* Abilities:
|
|
* - Q: Heal Zombies (regenerate HP)
|
|
* - E: Boost Zombies (temp strength/speed)
|
|
* - R: Calm Wild Zombies (easier taming)
|
|
* - F: Sense Danger (detect enemies)
|
|
*
|
|
* Energy System: Uses Alfa Energy (regenerates over time)
|
|
*/
|
|
|
|
class HybridAbilitySystem {
|
|
constructor(scene) {
|
|
this.scene = scene;
|
|
|
|
// Alfa Energy (similar to mana, but for Alfa abilities)
|
|
this.maxEnergy = 100;
|
|
this.energy = 100;
|
|
this.energyRegen = 5; // per second
|
|
|
|
// Ability Definitions
|
|
this.abilities = {
|
|
// Q: Heal Zombies
|
|
healZombies: {
|
|
id: 'healZombies',
|
|
name: 'Heal Zombies',
|
|
key: 'Q',
|
|
energyCost: 25,
|
|
cooldown: 8000, // 8 seconds
|
|
range: 150, // pixels
|
|
healAmount: 30,
|
|
description: 'Regenerate HP for all zombies in range',
|
|
visualEffect: 'green_glow',
|
|
soundEffect: 'heal_pulse'
|
|
},
|
|
|
|
// E: Boost Zombies
|
|
boostZombies: {
|
|
id: 'boostZombies',
|
|
name: 'Boost Zombies',
|
|
key: 'E',
|
|
energyCost: 30,
|
|
cooldown: 15000, // 15 seconds
|
|
range: 200,
|
|
duration: 10000, // 10s buff
|
|
speedBoost: 1.5, // +50% speed
|
|
damageBoost: 1.3, // +30% damage
|
|
efficiencyBoost: 1.5, // +50% work speed
|
|
description: 'Temporarily boost zombie speed, damage, and work efficiency',
|
|
visualEffect: 'yellow_aura',
|
|
soundEffect: 'power_up'
|
|
},
|
|
|
|
// R: Calm Wild Zombies
|
|
calmWildZombies: {
|
|
id: 'calmWildZombies',
|
|
name: 'Calm Wild Zombies',
|
|
key: 'R',
|
|
energyCost: 20,
|
|
cooldown: 12000, // 12 seconds
|
|
range: 250,
|
|
duration: 15000, // 15s peaceful state
|
|
tamingBonus: 0.5, // +50% taming success chance
|
|
description: 'Make wild zombies peaceful and easier to tame',
|
|
visualEffect: 'blue_ripple',
|
|
soundEffect: 'calm_wave'
|
|
},
|
|
|
|
// F: Sense Danger
|
|
senseDanger: {
|
|
id: 'senseDanger',
|
|
name: 'Sense Danger',
|
|
key: 'F',
|
|
energyCost: 15,
|
|
cooldown: 20000, // 20 seconds
|
|
range: 400, // large detection radius
|
|
duration: 8000, // 8s reveal
|
|
description: 'Detect all enemies in a large radius',
|
|
visualEffect: 'red_pulse',
|
|
soundEffect: 'danger_ping'
|
|
}
|
|
};
|
|
|
|
// Cooldown tracking
|
|
this.cooldowns = new Map();
|
|
|
|
// Active buffs (zombie IDs with their buff data)
|
|
this.activeBuffs = new Map();
|
|
|
|
// Revealed enemies (for Sense Danger)
|
|
this.revealedEnemies = new Set();
|
|
|
|
// Visual effects
|
|
this.visualEffects = [];
|
|
|
|
// UI references
|
|
this.energyBar = null;
|
|
this.abilityIcons = new Map();
|
|
|
|
// Player level & unlocks
|
|
this.playerLevel = 1; // Tracks Hybrid Skill level (1-10)
|
|
this.unlockedAbilities = new Set(['healZombies']); // Start with heal
|
|
|
|
this.init();
|
|
}
|
|
|
|
init() {
|
|
this.createUI();
|
|
this.setupInput();
|
|
this.setupEventListeners();
|
|
|
|
// Start energy regen
|
|
this.scene.time.addEvent({
|
|
delay: 1000,
|
|
callback: this.regenerateEnergy,
|
|
callbackScope: this,
|
|
loop: true
|
|
});
|
|
|
|
console.log('[HybridAbilitySystem] Initialized - Alfa powers ready');
|
|
}
|
|
|
|
// ==================== INPUT HANDLING ====================
|
|
|
|
setupInput() {
|
|
// Ability hotkeys
|
|
this.scene.input.keyboard.on('keydown-Q', () => this.useAbility('healZombies'));
|
|
this.scene.input.keyboard.on('keydown-E', () => this.useAbility('boostZombies'));
|
|
this.scene.input.keyboard.on('keydown-R', () => this.useAbility('calmWildZombies'));
|
|
this.scene.input.keyboard.on('keydown-F', () => this.useAbility('senseDanger'));
|
|
}
|
|
|
|
setupEventListeners() {
|
|
// Listen for zombie level up to award player XP
|
|
this.scene.events.on('zombieLevelUp', (zombieId, newLevel) => {
|
|
this.addPlayerXP(5); // 5 XP per zombie level
|
|
});
|
|
|
|
// Listen for zombie death (inheritance)
|
|
this.scene.events.on('zombieDeath', (zombieId, finalLevel) => {
|
|
this.addPlayerXP(finalLevel * 2); // 2 XP per zombie's final level
|
|
});
|
|
}
|
|
|
|
// ==================== ABILITY USAGE ====================
|
|
|
|
useAbility(abilityId) {
|
|
const ability = this.abilities[abilityId];
|
|
|
|
if (!ability) {
|
|
console.warn(`[HybridAbilitySystem] Unknown ability: ${abilityId}`);
|
|
return false;
|
|
}
|
|
|
|
// Check if unlocked
|
|
if (!this.unlockedAbilities.has(abilityId)) {
|
|
this.scene.uiSystem?.showMessage(`Ability locked! Unlock at Hybrid Skill level ${this.getUnlockLevel(abilityId)}`);
|
|
return false;
|
|
}
|
|
|
|
// Check cooldown
|
|
if (this.isOnCooldown(abilityId)) {
|
|
const remaining = this.getCooldownRemaining(abilityId);
|
|
this.scene.uiSystem?.showMessage(`${ability.name} on cooldown: ${(remaining / 1000).toFixed(1)}s`);
|
|
return false;
|
|
}
|
|
|
|
// Check energy cost
|
|
if (this.energy < ability.energyCost) {
|
|
this.scene.uiSystem?.showMessage(`Not enough Alfa Energy! (${this.energy}/${ability.energyCost})`);
|
|
return false;
|
|
}
|
|
|
|
// Execute ability
|
|
console.log(`[HybridAbilitySystem] Using ${ability.name}`);
|
|
this.consumeEnergy(ability.energyCost);
|
|
this.startCooldown(abilityId, ability.cooldown);
|
|
|
|
// Play sound
|
|
if (ability.soundEffect) {
|
|
this.scene.sound.play(ability.soundEffect, { volume: 0.5 });
|
|
}
|
|
|
|
// Execute specific ability logic
|
|
switch (abilityId) {
|
|
case 'healZombies':
|
|
this.executeHeal(ability);
|
|
break;
|
|
case 'boostZombies':
|
|
this.executeBoost(ability);
|
|
break;
|
|
case 'calmWildZombies':
|
|
this.executeCalm(ability);
|
|
break;
|
|
case 'senseDanger':
|
|
this.executeSense(ability);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ==================== ABILITY EXECUTIONS ====================
|
|
|
|
executeHeal(ability) {
|
|
const player = this.scene.player;
|
|
const zombieSystem = this.scene.zombieSystem;
|
|
|
|
if (!zombieSystem) return;
|
|
|
|
let healed = 0;
|
|
|
|
// Find all zombies in range
|
|
zombieSystem.zombies.forEach((zombie, zombieId) => {
|
|
const dist = Phaser.Math.Distance.Between(
|
|
player.x, player.y,
|
|
zombie.sprite.x, zombie.sprite.y
|
|
);
|
|
|
|
if (dist <= ability.range && zombie.state !== 'dead') {
|
|
// Heal zombie
|
|
const oldHp = zombie.hp;
|
|
zombie.hp = Math.min(zombie.hp + ability.healAmount, zombie.maxHp);
|
|
healed++;
|
|
|
|
// Visual: Green heal particles
|
|
this.createHealEffect(zombie.sprite.x, zombie.sprite.y);
|
|
|
|
// Show floating text
|
|
this.showFloatingText(zombie.sprite.x, zombie.sprite.y,
|
|
`+${zombie.hp - oldHp} HP`, 0x00ff00);
|
|
|
|
console.log(`[HybridAbilitySystem] Healed zombie ${zombieId}: ${oldHp} → ${zombie.hp}`);
|
|
}
|
|
});
|
|
|
|
// Player feedback
|
|
this.createPlayerEffect(ability.visualEffect);
|
|
this.scene.uiSystem?.showMessage(`Healed ${healed} zombie(s)!`, 0x00ff00);
|
|
}
|
|
|
|
executeBoost(ability) {
|
|
const player = this.scene.player;
|
|
const zombieSystem = this.scene.zombieSystem;
|
|
|
|
if (!zombieSystem) return;
|
|
|
|
let boosted = 0;
|
|
|
|
zombieSystem.zombies.forEach((zombie, zombieId) => {
|
|
const dist = Phaser.Math.Distance.Between(
|
|
player.x, player.y,
|
|
zombie.sprite.x, zombie.sprite.y
|
|
);
|
|
|
|
if (dist <= ability.range && zombie.state !== 'dead') {
|
|
// Apply buff
|
|
this.applyBoostBuff(zombieId, zombie, ability);
|
|
boosted++;
|
|
|
|
// Visual: Yellow aura
|
|
this.createBoostEffect(zombie.sprite);
|
|
|
|
console.log(`[HybridAbilitySystem] Boosted zombie ${zombieId} for ${ability.duration}ms`);
|
|
}
|
|
});
|
|
|
|
this.createPlayerEffect(ability.visualEffect);
|
|
this.scene.uiSystem?.showMessage(`Boosted ${boosted} zombie(s)!`, 0xffff00);
|
|
}
|
|
|
|
executeCalm(ability) {
|
|
const player = this.scene.player;
|
|
const zombieSystem = this.scene.zombieSystem;
|
|
|
|
if (!zombieSystem) return;
|
|
|
|
let calmed = 0;
|
|
|
|
zombieSystem.zombies.forEach((zombie, zombieId) => {
|
|
const dist = Phaser.Math.Distance.Between(
|
|
player.x, player.y,
|
|
zombie.sprite.x, zombie.sprite.y
|
|
);
|
|
|
|
if (dist <= ability.range && zombie.state === 'wild') {
|
|
// Apply calm buff
|
|
this.applyCalmBuff(zombieId, zombie, ability);
|
|
calmed++;
|
|
|
|
// Visual: Blue ripple
|
|
this.createCalmEffect(zombie.sprite.x, zombie.sprite.y);
|
|
|
|
// Make zombie peaceful
|
|
zombie.aggression = Math.max(0, zombie.aggression - 50);
|
|
zombie.sprite.setTint(0x88ccff); // Blue tint
|
|
|
|
console.log(`[HybridAbilitySystem] Calmed wild zombie ${zombieId}`);
|
|
}
|
|
});
|
|
|
|
this.createPlayerEffect(ability.visualEffect);
|
|
this.scene.uiSystem?.showMessage(`Calmed ${calmed} wild zombie(s)!`, 0x00aaff);
|
|
}
|
|
|
|
executeSense(ability) {
|
|
const player = this.scene.player;
|
|
|
|
// Clear previous reveals
|
|
this.revealedEnemies.clear();
|
|
|
|
// Find all enemies in range
|
|
let detected = 0;
|
|
|
|
// Check enemy groups (you'd have an enemySystem or similar)
|
|
// For now, placeholder detection logic
|
|
if (this.scene.enemies) {
|
|
this.scene.enemies.forEach((enemy) => {
|
|
const dist = Phaser.Math.Distance.Between(
|
|
player.x, player.y,
|
|
enemy.x, enemy.y
|
|
);
|
|
|
|
if (dist <= ability.range) {
|
|
this.revealedEnemies.add(enemy);
|
|
detected++;
|
|
|
|
// Visual: Red outline on enemy
|
|
enemy.setTint(0xff0000);
|
|
|
|
// Auto-remove tint after duration
|
|
this.scene.time.delayedCall(ability.duration, () => {
|
|
enemy.clearTint();
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// Player visual: Red pulse
|
|
this.createSenseEffect(player.x, player.y, ability.range);
|
|
|
|
if (detected > 0) {
|
|
this.scene.uiSystem?.showMessage(`⚠️ ${detected} enemies detected!`, 0xff0000);
|
|
} else {
|
|
this.scene.uiSystem?.showMessage(`No enemies nearby`, 0x00ff00);
|
|
}
|
|
|
|
console.log(`[HybridAbilitySystem] Sense Danger: ${detected} enemies revealed`);
|
|
}
|
|
|
|
// ==================== BUFF MANAGEMENT ====================
|
|
|
|
applyBoostBuff(zombieId, zombie, ability) {
|
|
const buffData = {
|
|
zombieId,
|
|
type: 'boost',
|
|
speedMultiplier: ability.speedBoost,
|
|
damageMultiplier: ability.damageBoost,
|
|
efficiencyMultiplier: ability.efficiencyBoost,
|
|
startTime: Date.now(),
|
|
duration: ability.duration
|
|
};
|
|
|
|
this.activeBuffs.set(zombieId, buffData);
|
|
|
|
// Auto-remove after duration
|
|
this.scene.time.delayedCall(ability.duration, () => {
|
|
this.removeBoostBuff(zombieId);
|
|
});
|
|
}
|
|
|
|
removeBoostBuff(zombieId) {
|
|
if (this.activeBuffs.has(zombieId)) {
|
|
this.activeBuffs.delete(zombieId);
|
|
console.log(`[HybridAbilitySystem] Boost buff expired for zombie ${zombieId}`);
|
|
}
|
|
}
|
|
|
|
applyCalmBuff(zombieId, zombie, ability) {
|
|
const buffData = {
|
|
zombieId,
|
|
type: 'calm',
|
|
tamingBonus: ability.tamingBonus,
|
|
startTime: Date.now(),
|
|
duration: ability.duration
|
|
};
|
|
|
|
this.activeBuffs.set(zombieId, buffData);
|
|
|
|
// Auto-remove
|
|
this.scene.time.delayedCall(ability.duration, () => {
|
|
this.removeCalmBuff(zombieId, zombie);
|
|
});
|
|
}
|
|
|
|
removeCalmBuff(zombieId, zombie) {
|
|
if (this.activeBuffs.has(zombieId)) {
|
|
this.activeBuffs.delete(zombieId);
|
|
|
|
// Remove blue tint
|
|
if (zombie && zombie.sprite) {
|
|
zombie.sprite.clearTint();
|
|
}
|
|
|
|
console.log(`[HybridAbilitySystem] Calm buff expired for zombie ${zombieId}`);
|
|
}
|
|
}
|
|
|
|
// Get active buff for zombie (for ZombieSystem to query)
|
|
getZombieBuff(zombieId) {
|
|
return this.activeBuffs.get(zombieId);
|
|
}
|
|
|
|
// ==================== ENERGY MANAGEMENT ====================
|
|
|
|
consumeEnergy(amount) {
|
|
this.energy = Math.max(0, this.energy - amount);
|
|
this.updateEnergyBar();
|
|
}
|
|
|
|
regenerateEnergy() {
|
|
if (this.energy < this.maxEnergy) {
|
|
this.energy = Math.min(this.maxEnergy, this.energy + this.energyRegen);
|
|
this.updateEnergyBar();
|
|
}
|
|
}
|
|
|
|
// ==================== COOLDOWN MANAGEMENT ====================
|
|
|
|
startCooldown(abilityId, duration) {
|
|
this.cooldowns.set(abilityId, Date.now() + duration);
|
|
}
|
|
|
|
isOnCooldown(abilityId) {
|
|
if (!this.cooldowns.has(abilityId)) return false;
|
|
return Date.now() < this.cooldowns.get(abilityId);
|
|
}
|
|
|
|
getCooldownRemaining(abilityId) {
|
|
if (!this.isOnCooldown(abilityId)) return 0;
|
|
return this.cooldowns.get(abilityId) - Date.now();
|
|
}
|
|
|
|
// ==================== PLAYER PROGRESSION ====================
|
|
|
|
addPlayerXP(amount) {
|
|
// TODO: Implement full XP/level system
|
|
// For now, just log
|
|
console.log(`[HybridAbilitySystem] Player gained ${amount} Hybrid XP`);
|
|
|
|
// Check for level ups (placeholder)
|
|
// this.checkLevelUp();
|
|
}
|
|
|
|
getUnlockLevel(abilityId) {
|
|
const unlockLevels = {
|
|
healZombies: 1, // Start ability
|
|
calmWildZombies: 3,
|
|
boostZombies: 5,
|
|
senseDanger: 7
|
|
};
|
|
return unlockLevels[abilityId] || 10;
|
|
}
|
|
|
|
unlockAbility(abilityId) {
|
|
this.unlockedAbilities.add(abilityId);
|
|
this.scene.uiSystem?.showMessage(`Unlocked: ${this.abilities[abilityId].name}!`, 0xffaa00);
|
|
console.log(`[HybridAbilitySystem] Unlocked ability: ${abilityId}`);
|
|
}
|
|
|
|
// ==================== VISUAL EFFECTS ====================
|
|
|
|
createHealEffect(x, y) {
|
|
// Green particles rising
|
|
const particles = this.scene.add.particles(x, y, 'particle', {
|
|
speed: { min: -50, max: -100 },
|
|
scale: { start: 0.5, end: 0 },
|
|
tint: 0x00ff00,
|
|
lifespan: 1000,
|
|
quantity: 10
|
|
});
|
|
|
|
this.scene.time.delayedCall(1000, () => particles.destroy());
|
|
}
|
|
|
|
createBoostEffect(sprite) {
|
|
// Yellow aura around zombie
|
|
const aura = this.scene.add.circle(sprite.x, sprite.y, 30, 0xffff00, 0.3);
|
|
aura.setDepth(sprite.depth - 1);
|
|
|
|
// Pulse animation
|
|
this.scene.tweens.add({
|
|
targets: aura,
|
|
scale: { from: 1, to: 1.2 },
|
|
alpha: { from: 0.3, to: 0.1 },
|
|
duration: 500,
|
|
yoyo: true,
|
|
repeat: -1
|
|
});
|
|
|
|
// Remove after 10s
|
|
this.scene.time.delayedCall(10000, () => aura.destroy());
|
|
}
|
|
|
|
createCalmEffect(x, y) {
|
|
// Blue ripple expanding
|
|
const ripple = this.scene.add.circle(x, y, 10, 0x88ccff, 0.5);
|
|
|
|
this.scene.tweens.add({
|
|
targets: ripple,
|
|
radius: 100,
|
|
alpha: 0,
|
|
duration: 1000,
|
|
onComplete: () => ripple.destroy()
|
|
});
|
|
}
|
|
|
|
createSenseEffect(x, y, range) {
|
|
// Red pulse expanding to range
|
|
const pulse = this.scene.add.circle(x, y, 10, 0xff0000, 0.3);
|
|
|
|
this.scene.tweens.add({
|
|
targets: pulse,
|
|
radius: range,
|
|
alpha: 0,
|
|
duration: 800,
|
|
onComplete: () => pulse.destroy()
|
|
});
|
|
}
|
|
|
|
createPlayerEffect(effectType) {
|
|
const player = this.scene.player;
|
|
|
|
// Brief flash around player
|
|
const flash = this.scene.add.circle(player.x, player.y, 50,
|
|
effectType === 'green_glow' ? 0x00ff00 :
|
|
effectType === 'yellow_aura' ? 0xffff00 :
|
|
effectType === 'blue_ripple' ? 0x88ccff :
|
|
0xff0000, 0.4);
|
|
|
|
this.scene.tweens.add({
|
|
targets: flash,
|
|
alpha: 0,
|
|
scale: 1.5,
|
|
duration: 500,
|
|
onComplete: () => flash.destroy()
|
|
});
|
|
}
|
|
|
|
showFloatingText(x, y, text, color) {
|
|
const floatText = this.scene.add.text(x, y - 20, text, {
|
|
fontSize: '16px',
|
|
color: `#${color.toString(16).padStart(6, '0')}`,
|
|
stroke: '#000',
|
|
strokeThickness: 3
|
|
}).setOrigin(0.5);
|
|
|
|
this.scene.tweens.add({
|
|
targets: floatText,
|
|
y: y - 60,
|
|
alpha: 0,
|
|
duration: 1500,
|
|
onComplete: () => floatText.destroy()
|
|
});
|
|
}
|
|
|
|
// ==================== UI ====================
|
|
|
|
createUI() {
|
|
// Energy bar (top-left, below HP/Stamina)
|
|
this.energyBar = this.scene.add.graphics();
|
|
this.energyBar.setScrollFactor(0);
|
|
this.energyBar.setDepth(1000);
|
|
this.updateEnergyBar();
|
|
|
|
// Ability icons (bottom of screen)
|
|
const abilities = ['healZombies', 'calmWildZombies', 'boostZombies', 'senseDanger'];
|
|
abilities.forEach((abilityId, index) => {
|
|
// TODO: Create actual icons
|
|
// For now just placeholders
|
|
});
|
|
}
|
|
|
|
updateEnergyBar() {
|
|
if (!this.energyBar) return;
|
|
|
|
this.energyBar.clear();
|
|
|
|
// Background
|
|
this.energyBar.fillStyle(0x222222, 0.8);
|
|
this.energyBar.fillRect(10, 70, 200, 20);
|
|
|
|
// Energy fill (purple/pink for Alfa)
|
|
const energyWidth = (this.energy / this.maxEnergy) * 196;
|
|
this.energyBar.fillStyle(0xff00ff, 1);
|
|
this.energyBar.fillRect(12, 72, energyWidth, 16);
|
|
|
|
// Border
|
|
this.energyBar.lineStyle(2, 0xffffff, 1);
|
|
this.energyBar.strokeRect(10, 70, 200, 20);
|
|
}
|
|
|
|
// ==================== UPDATE ====================
|
|
|
|
update(time, delta) {
|
|
// Update cooldown visuals
|
|
// Update buff timers
|
|
// (placeholder for now)
|
|
}
|
|
|
|
// ==================== CLEANUP ====================
|
|
|
|
destroy() {
|
|
if (this.energyBar) this.energyBar.destroy();
|
|
this.visualEffects.forEach(effect => effect.destroy());
|
|
this.activeBuffs.clear();
|
|
this.cooldowns.clear();
|
|
console.log('[HybridAbilitySystem] Destroyed');
|
|
}
|
|
}
|
|
|
|
// Export for use in GameScene
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = HybridAbilitySystem;
|
|
}
|