412 lines
11 KiB
JavaScript
412 lines
11 KiB
JavaScript
/**
|
|
* MesojedkeSystem.js
|
|
* ==================
|
|
* KRVAVA ŽETEV - Carnivorous Plants System (Phase 39)
|
|
*
|
|
* Features:
|
|
* - Mario-style carnivorous plants
|
|
* - 5 growth stages
|
|
* - Meat feeding system
|
|
* - Auto-attack defense
|
|
* - Rare material harvest
|
|
*
|
|
* @author NovaFarma Team
|
|
* @date 2025-12-23
|
|
*/
|
|
|
|
export default class MesojedkeSystem {
|
|
constructor(scene) {
|
|
this.scene = scene;
|
|
|
|
// Plant registry
|
|
this.plants = new Map();
|
|
this.nextPlantId = 1;
|
|
|
|
// Growth stages
|
|
this.growthStages = [
|
|
{ stage: 1, name: 'Seed', size: 0.2, damage: 0, range: 0, icon: '🌱' },
|
|
{ stage: 2, name: 'Sprout', size: 0.4, damage: 0, range: 0, icon: '🌿' },
|
|
{ stage: 3, name: 'Young Plant', size: 0.6, damage: 10, range: 100, icon: '🪴' },
|
|
{ stage: 4, name: 'Adult Plant', size: 0.8, damage: 25, range: 150, icon: '🌺' },
|
|
{ stage: 5, name: 'Giant Carnivorous Flower', size: 1.5, damage: 50, range: 200, icon: '🌸' }
|
|
];
|
|
|
|
// Meat types for feeding
|
|
this.meatTypes = {
|
|
zombie_flesh: { nutrition: 10, growthBoost: 1.0, quality: 'common' },
|
|
mutant_meat: { nutrition: 25, growthBoost: 1.5, quality: 'uncommon' },
|
|
boss_meat: { nutrition: 50, growthBoost: 2.0, quality: 'rare' },
|
|
legendary_meat: { nutrition: 100, growthBoost: 3.0, quality: 'legendary' }
|
|
};
|
|
|
|
console.log('🌺 MesojedkeSystem initialized');
|
|
}
|
|
|
|
/**
|
|
* Plant mesojedka seed
|
|
*/
|
|
plantSeed(x, y) {
|
|
const plantId = `mesojedka_${this.nextPlantId++}`;
|
|
|
|
const plant = {
|
|
id: plantId,
|
|
x: x,
|
|
y: y,
|
|
stage: 1,
|
|
growth: 0, // 0-100% per stage
|
|
hunger: 100, // Needs meat to grow
|
|
lastFed: Date.now(),
|
|
lastAttack: 0,
|
|
attackCooldown: 2000, // 2 seconds
|
|
kills: 0,
|
|
totalDamage: 0,
|
|
sprite: null
|
|
};
|
|
|
|
this.plants.set(plantId, plant);
|
|
|
|
// TODO: Create actual sprite
|
|
console.log(`🌱 Planted mesojedka at (${x}, ${y})`);
|
|
|
|
this.showNotification({
|
|
title: 'Mesojedka Planted!',
|
|
text: '🌱 Feed it meat to make it grow!',
|
|
icon: '🌺'
|
|
});
|
|
|
|
return plantId;
|
|
}
|
|
|
|
/**
|
|
* Feed plant with meat
|
|
*/
|
|
feedPlant(plantId, meatType) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) {
|
|
console.error(`Plant ${plantId} not found!`);
|
|
return false;
|
|
}
|
|
|
|
const meat = this.meatTypes[meatType];
|
|
if (!meat) {
|
|
console.error(`Meat type ${meatType} not found!`);
|
|
return false;
|
|
}
|
|
|
|
// Restore hunger
|
|
plant.hunger = Math.min(100, plant.hunger + meat.nutrition);
|
|
plant.lastFed = Date.now();
|
|
|
|
// Boost growth
|
|
const growthGain = 10 * meat.growthBoost;
|
|
plant.growth += growthGain;
|
|
|
|
console.log(`🍖 Fed ${plantId} with ${meatType} (+${growthGain}% growth)`);
|
|
|
|
// Check for stage up
|
|
if (plant.growth >= 100) {
|
|
this.growPlant(plantId);
|
|
}
|
|
|
|
this.showNotification({
|
|
title: 'Plant Fed!',
|
|
text: `🍖 ${meat.quality} meat! +${Math.floor(growthGain)}% growth!`,
|
|
icon: '🌺'
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Grow plant to next stage
|
|
*/
|
|
growPlant(plantId) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) return false;
|
|
|
|
if (plant.stage >= 5) {
|
|
console.log(`🌸 ${plantId} already at max stage!`);
|
|
return false;
|
|
}
|
|
|
|
// Level up
|
|
plant.stage++;
|
|
plant.growth = 0;
|
|
|
|
const stageData = this.growthStages[plant.stage - 1];
|
|
|
|
console.log(`🌺 ${plantId} grew to stage ${plant.stage}: ${stageData.name}!`);
|
|
|
|
// Update sprite size
|
|
if (plant.sprite) {
|
|
plant.sprite.setScale(stageData.size);
|
|
}
|
|
|
|
this.showNotification({
|
|
title: 'Plant Evolved!',
|
|
text: `${stageData.icon} Stage ${plant.stage}: ${stageData.name}!`,
|
|
icon: '✨'
|
|
});
|
|
|
|
// Unlock attack at stage 3
|
|
if (plant.stage === 3) {
|
|
this.showNotification({
|
|
title: 'Defense Unlocked!',
|
|
text: '⚔️ Mesojedka can now attack enemies!',
|
|
icon: '🌺'
|
|
});
|
|
}
|
|
|
|
// Giant flower achievement
|
|
if (plant.stage === 5) {
|
|
this.showNotification({
|
|
title: 'GIANT CARNIVOROUS FLOWER!',
|
|
text: '🌸 Maximum power achieved! 50 damage, 200 range!',
|
|
icon: '👑'
|
|
});
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Auto-attack enemies
|
|
*/
|
|
attackNearbyEnemies(plantId) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) return;
|
|
|
|
const stageData = this.growthStages[plant.stage - 1];
|
|
|
|
// Can't attack if too young
|
|
if (plant.stage < 3) return;
|
|
|
|
// Check cooldown
|
|
const now = Date.now();
|
|
if (now - plant.lastAttack < plant.attackCooldown) return;
|
|
|
|
// TODO: Get enemies within range
|
|
const enemies = this.getEnemiesInRange(plant.x, plant.y, stageData.range);
|
|
|
|
if (enemies.length === 0) return;
|
|
|
|
// Attack nearest enemy
|
|
const target = enemies[0];
|
|
const damage = stageData.damage;
|
|
|
|
console.log(`🌺 ${plantId} attacks! ${damage} damage!`);
|
|
|
|
// Deal damage
|
|
// TODO: Integrate with enemy system
|
|
plant.totalDamage += damage;
|
|
|
|
// Check for kill
|
|
// if (target.health <= damage) {
|
|
// plant.kills++;
|
|
// }
|
|
|
|
plant.lastAttack = now;
|
|
|
|
// Visual attack effect
|
|
this.playAttackAnimation(plant, target);
|
|
}
|
|
|
|
/**
|
|
* Get enemies in range
|
|
*/
|
|
getEnemiesInRange(x, y, range) {
|
|
// TODO: Get actual enemies from enemy system
|
|
// For now, return empty array
|
|
return [];
|
|
}
|
|
|
|
/**
|
|
* Play attack animation
|
|
*/
|
|
playAttackAnimation(plant, target) {
|
|
// TODO: Create bite animation
|
|
console.log(`💥 CHOMP! Attack animation`);
|
|
|
|
// Screen shake for giant plants
|
|
if (plant.stage === 5) {
|
|
this.scene.cameras.main.shake(100, 0.005);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Harvest plant
|
|
*/
|
|
harvestPlant(plantId) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) {
|
|
console.error(`Plant ${plantId} not found!`);
|
|
return null;
|
|
}
|
|
|
|
if (plant.stage < 4) {
|
|
this.showNotification({
|
|
title: 'Too Young!',
|
|
text: 'Plant must reach stage 4 to harvest!',
|
|
icon: '🌺'
|
|
});
|
|
return null;
|
|
}
|
|
|
|
// Calculate harvest based on stage
|
|
const harvest = this.calculateHarvest(plant);
|
|
|
|
// Remove plant
|
|
this.plants.delete(plantId);
|
|
|
|
// TODO: Remove sprite
|
|
|
|
console.log(`✂️ Harvested ${plantId}:`, harvest);
|
|
|
|
this.showNotification({
|
|
title: 'Harvest Complete!',
|
|
text: `Collected: ${harvest.petals} Petals, ${harvest.seeds} Seeds!`,
|
|
icon: '🌸'
|
|
});
|
|
|
|
return harvest;
|
|
}
|
|
|
|
/**
|
|
* Calculate harvest rewards
|
|
*/
|
|
calculateHarvest(plant) {
|
|
const harvest = {
|
|
petals: 0,
|
|
seeds: 0,
|
|
special: []
|
|
};
|
|
|
|
// Base rewards by stage
|
|
switch (plant.stage) {
|
|
case 4:
|
|
harvest.petals = 5 + Math.floor(Math.random() * 5);
|
|
harvest.seeds = 1;
|
|
break;
|
|
case 5:
|
|
harvest.petals = 15 + Math.floor(Math.random() * 10);
|
|
harvest.seeds = 2 + Math.floor(Math.random() * 2);
|
|
|
|
// Chance for legendary drops
|
|
if (Math.random() < 0.1) { // 10%
|
|
harvest.special.push('legendary_nectar');
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Bonus from kills
|
|
harvest.petals += plant.kills;
|
|
|
|
return harvest;
|
|
}
|
|
|
|
/**
|
|
* Update all plants
|
|
*/
|
|
update(delta) {
|
|
const now = Date.now();
|
|
|
|
this.plants.forEach((plant, plantId) => {
|
|
// Decrease hunger over time
|
|
const hoursSinceLastFed = (now - plant.lastFed) / (1000 * 60 * 60);
|
|
if (hoursSinceLastFed >= 1) {
|
|
plant.hunger = Math.max(0, plant.hunger - 5);
|
|
plant.lastFed = now;
|
|
}
|
|
|
|
// Die if starved
|
|
if (plant.hunger <= 0) {
|
|
this.killPlant(plantId);
|
|
return;
|
|
}
|
|
|
|
// Auto-attack if enemies nearby
|
|
this.attackNearbyEnemies(plantId);
|
|
|
|
// Passive growth (very slow)
|
|
if (plant.hunger > 50) {
|
|
plant.growth += 0.001 * (delta / 1000); // 0.1% per second
|
|
|
|
if (plant.growth >= 100) {
|
|
this.growPlant(plantId);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Kill plant (starvation)
|
|
*/
|
|
killPlant(plantId) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) return;
|
|
|
|
console.log(`💀 ${plantId} died from starvation!`);
|
|
|
|
this.plants.delete(plantId);
|
|
|
|
// TODO: Remove sprite
|
|
|
|
this.showNotification({
|
|
title: 'Plant Died!',
|
|
text: '💀 Your mesojedka starved! Feed them meat regularly!',
|
|
icon: '⚠️'
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Get plant info
|
|
*/
|
|
getPlantInfo(plantId) {
|
|
const plant = this.plants.get(plantId);
|
|
if (!plant) return null;
|
|
|
|
const stageData = this.growthStages[plant.stage - 1];
|
|
|
|
return {
|
|
...plant,
|
|
stageData: stageData,
|
|
canAttack: plant.stage >= 3,
|
|
canHarvest: plant.stage >= 4
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get all plants
|
|
*/
|
|
getAllPlants() {
|
|
return Array.from(this.plants.values());
|
|
}
|
|
|
|
/**
|
|
* Get plant count by stage
|
|
*/
|
|
getPlantCountByStage(stage) {
|
|
return Array.from(this.plants.values()).filter(p => p.stage === stage).length;
|
|
}
|
|
|
|
/**
|
|
* Get total defense damage
|
|
*/
|
|
getTotalDefenseDamage() {
|
|
return Array.from(this.plants.values())
|
|
.reduce((total, plant) => total + plant.totalDamage, 0);
|
|
}
|
|
|
|
/**
|
|
* Helper: Show notification
|
|
*/
|
|
showNotification(notification) {
|
|
console.log(`📢 ${notification.icon} ${notification.title}: ${notification.text}`);
|
|
|
|
const ui = this.scene.scene.get('UIScene');
|
|
if (ui && ui.showNotification) {
|
|
ui.showNotification(notification);
|
|
}
|
|
}
|
|
}
|