# 🗺️ IMPLEMENTATION ROADMAP
**Novafarma - Detailed Feature Implementation Plans**

**Date:** 10.12.2025  
**Status:** Planning Phase

---

## 📋 Priority Matrix

| Priority | Features (Total: 27) | Estimated Time |
|----------|---------------------|----------------|
| 🔴 **High** | 8 features | ~4 weeks |
| 🟡 **Medium** | 12 features | ~8 weeks |
| 🟢 **Low** | 7 features | ~6 weeks |
| **TOTAL** | **27 features** | **~18 weeks** |

---

# 🔴 **HIGH PRIORITY FEATURES**

## 1. 💡 **Light System** - Dynamic Lighting
**Priority:** 🔴 High  
**Complexity:** Medium  
**Time Estimate:** 3-4 days

### Technical Implementation:
```javascript
// src/systems/LightingSystem.js
class LightingSystem {
    constructor(scene) {
        this.scene = scene;
        this.lights = []; // { x, y, radius, intensity, color }
        this.globalLight = 1.0; // 0.0 = night, 1.0 = day
        
        // Light overlay
        this.lightTexture = scene.textures.createCanvas('lightmap', 
            scene.cameras.main.width, 
            scene.cameras.main.height
        );
    }

    update(delta) {
        // Update global light based on time
        const timeSystem = this.scene.weatherSystem;
        if (timeSystem) {
            const hour = timeSystem.currentHour;
            // Dawn: 6-8, Day: 8-18, Dusk: 18-20, Night: 20-6
            if (hour >= 6 && hour < 8) {
                this.globalLight = (hour - 6) / 2; // 0 → 1
            } else if (hour >= 8 && hour < 18) {
                this.globalLight = 1.0; // Full daylight
            } else if (hour >= 18 && hour < 20) {
                this.globalLight = 1.0 - ((hour - 18) / 2); // 1 → 0
            } else {
                this.globalLight = 0.2; // Dark night
            }
        }

        this.renderLightmap();
    }

    addLight(x, y, radius, intensity, color = 0xffaa00) {
        const light = { x, y, radius, intensity, color, active: true };
        this.lights.push(light);
        return light;
    }

    renderLightmap() {
        const ctx = this.lightTexture.context;
        ctx.clearRect(0, 0, this.lightTexture.width, this.lightTexture.height);

        // Global darkness overlay
        const darkness = 1.0 - this.globalLight;
        ctx.fillStyle = `rgba(0, 0, 20, ${darkness * 0.7})`;
        ctx.fillRect(0, 0, this.lightTexture.width, this.lightTexture.height);

        // Render point lights
        this.lights.forEach(light => {
            if (!light.active) return;

            const gradient = ctx.createRadialGradient(
                light.x, light.y, 0,
                light.x, light.y, light.radius
            );

            const r = (light.color >> 16) & 0xff;
            const g = (light.color >> 8) & 0xff;
            const b = light.color & 0xff;

            gradient.addColorStop(0, `rgba(${r}, ${g}, ${b}, ${light.intensity})`);
            gradient.addColorStop(1, 'rgba(0, 0, 0, 0)');

            ctx.globalCompositeOperation = 'lighter';
            ctx.fillStyle = gradient;
            ctx.fillRect(
                light.x - light.radius, 
                light.y - light.radius,
                light.radius * 2, 
                light.radius * 2
            );
        });

        this.lightTexture.refresh();
    }
}
```

### Light Sources:
- **Torches:** 80px radius, orange (0xffaa00), intensity 0.8
- **Campfire:** 120px radius, orange-red (0xff6600), intensity 0.9
- **Player lantern:** 60px radius, yellow (0xffff00), intensity 0.6
- **Moon:** Global soft light, 0.2 intensity during night
- **Lightning:** Flash effect, white, random intensity

### Performance Optimizations:
- Only render lights within camera viewport
- Use pooling for light objects
- Canvas rendering, not WebGL shaders (for compatibility)
- Max 50 active lights at a time

---

## 2. 🌾 **Crop Growth Animations**
**Priority:** 🔴 High  
**Complexity:** Low  
**Time Estimate:** 2 days

### Implementation:
```javascript
// src/systems/FarmingSystem.js - Enhanced
plantCrop(gridX, gridY, cropType) {
    // ... existing code ...
    
    crop.stage = 0; // 0 = seed, 1-3 = growing, 4 = ripe
    crop.stageDuration = [5000, 7000, 7000, 8000]; // ms per stage
    crop.stageTimer = 0;
    
    // Create animated sprite
    const key = `crop_${cropType}_stage_${crop.stage}`;
    crop.sprite = this.scene.add.sprite(x, y, key);
    crop.sprite.setOrigin(0.5, 1);
    
    return crop;
}

updateCrop(crop, delta) {
    if (crop.stage >= 4) return; // Fully grown
    
    crop.stageTimer += delta;
    
    if (crop.stageTimer >= crop.stageDuration[crop.stage]) {
        crop.stageTimer = 0;
        crop.stage += 1;
        
        // Update sprite texture
        const newKey = `crop_${crop.type}_stage_${crop.stage}`;
        crop.sprite.setTexture(newKey);
        
        // Growth animation
        this.scene.tweens.add({
            targets: crop.sprite,
            scaleX: 1.2,
            scaleY: 1.2,
            yoyo: true,
            duration: 200,
            ease: 'Sine.easeInOut'
        });
        
        // Particles
        if (this.scene.particleEffects) {
            this.scene.particleEffects.createGrowthSparkles(
                crop.sprite.x, 
                crop.sprite.y
            );
        }
    }
}
```

### Assets Needed:
```
crops/wheat_stage_0.png  (seed)
crops/wheat_stage_1.png  (sprout)
crops/wheat_stage_2.png  (growing)
crops/wheat_stage_3.png  (mature)
crops/wheat_stage_4.png  (ripe - golden)
```

---

## 3. 🎯 **Skill Tree System**
**Priority:** 🔴 High  
**Complexity:** High  
**Time Estimate:** 5-6 days

### System Design:
```javascript
// src/systems/SkillTreeSystem.js
class SkillTreeSystem {
    constructor(scene) {
        this.scene = scene;
        this.skills = this.defineSkills();
        this.unlockedSkills = [];
        this.skillPoints = 0;
    }

    defineSkills() {
        return {
            // FARMING BRANCH
            farming_1: {
                id: 'farming_1',
                name: 'Green Thumb',
                desc: '+20% crop growth speed',
                cost: 1,
                branch: 'farming',
                tier: 1,
                requires: [],
                effect: { cropGrowthSpeed: 1.2 }
            },
            farming_2: {
                id: 'farming_2',
                name: 'Harvest Master',
                desc: '+1 extra crop yield',
                cost: 2,
                branch: 'farming',
                tier: 2,
                requires: ['farming_1'],
                effect: { harvestBonus: 1 }
            },
            farming_3: {
                id: 'farming_3',
                name: 'Mega Harvest',
                desc: '10% chance for double harvest',
                cost: 3,
                branch: 'farming',
                tier: 3,
                requires: ['farming_2'],
                effect: { doubleHarvestChance: 0.1 }
            },

            // COMBAT BRANCH
            combat_1: {
                id: 'combat_1',
                name: 'Warrior',
                desc: '+10 max HP',
                cost: 1,
                branch: 'combat',
                tier: 1,
                requires: [],
                effect: { maxHpBonus: 10 }
            },
            combat_2: {
                id: 'combat_2',
                name: 'Berserker',
                desc: '+5 attack damage',
                cost: 2,
                branch: 'combat',
                tier: 2,
                requires: ['combat_1'],
                effect: { attackDamageBonus: 5 }
            },
            combat_3: {
                id: 'combat_3',
                name: 'Lifesteal',
                desc: 'Heal 20% of damage dealt',
                cost: 3,
                branch: 'combat',
                tier: 3,
                requires: ['combat_2'],
                effect: { lifesteal: 0.2 }
            },

            // CRAFTING BRANCH
            crafting_1: {
                id: 'crafting_1',
                name: 'Efficient Crafter',
                desc: '-10% material cost',
                cost: 1,
                branch: 'crafting',
                tier: 1,
                requires: [],
                effect: { materialCostReduction: 0.1 }
            },
            crafting_2: {
                id: 'crafting_2',
                name: 'Speed Crafter',
                desc: 'Instant crafting',
                cost: 2,
                branch: 'crafting',
                tier: 2,
                requires: ['crafting_1'],
                effect: { instantCraft: true }
            },
            crafting_3: {
                id: 'crafting_3',
                name: 'Master Craftsman',
                desc: '20% chance for 2x output',
                cost: 3,
                branch: 'crafting',
                tier: 3,
                requires: ['crafting_2'],
                effect: { doubleCraftChance: 0.2 }
            },

            // SURVIVAL BRANCH
            survival_1: {
                id: 'survival_1',
                name: 'Endurance',
                desc: '+50 max energy',
                cost: 1,
                branch: 'survival',
                tier: 1,
                requires: [],
                effect: { maxEnergyBonus: 50 }
            },
            survival_2: {
                id: 'survival_2',
                name: 'Natural Resistance',
                desc: '-50% temperature damage',
                cost: 2,
                branch: 'survival',
                tier: 2,
                requires: ['survival_1'],
                effect: { tempDamageReduction: 0.5 }
            },
            survival_3: {
                id: 'survival_3',
                name: 'Survivor',
                desc: 'Regenerate 1 HP/second',
                cost: 3,
                branch: 'survival',
                tier: 3,
                requires: ['survival_2'],
                effect: { hpRegenPerSecond: 1 }
            }
        };
    }

    unlockSkill(skillId) {
        const skill = this.skills[skillId];
        if (!skill) return false;

        // Check requirements
        if (!this.canUnlock(skillId)) {
            console.log(`Cannot unlock ${skillId}: requirements not met`);
            return false;
        }

        // Check skill points
        if (this.skillPoints < skill.cost) {
            console.log(`Cannot unlock ${skillId}: not enough skill points`);
            return false;
        }

        // Unlock
        this.unlockedSkills.push(skillId);
        this.skillPoints -= skill.cost;

        // Apply effect
        this.applySkillEffect(skill);

        console.log(`✅ Unlocked skill: ${skill.name}`);
        return true;
    }

    canUnlock(skillId) {
        const skill = this.skills[skillId];
        
        // Check if already unlocked
        if (this.unlockedSkills.includes(skillId)) return false;

        // Check prerequisites
        for (const reqId of skill.requires) {
            if (!this.unlockedSkills.includes(reqId)) {
                return false;
            }
        }

        return true;
    }

    applySkillEffect(skill) {
        const player = this.scene.player;
        const effect = skill.effect;

        // Apply bonuses
        if (effect.maxHpBonus) player.maxHp += effect.maxHpBonus;
        if (effect.maxEnergyBonus) player.maxEnergy += effect.maxEnergyBonus;
        if (effect.attackDamageBonus) player.attackDamage += effect.attackDamageBonus;

        // Store multipliers for systems to use
        if (effect.cropGrowthSpeed) {
            if (!this.scene.farmingSystem.growthSpeedMultiplier) {
                this.scene.farmingSystem.growthSpeedMultiplier = 1.0;
            }
            this.scene.farmingSystem.growthSpeedMultiplier *= effect.cropGrowthSpeed;
        }

        // Visual feedback
        if (this.scene.visualEffectsSystem) {
            this.scene.visualEffectsSystem.showFloatingText(
                player.sprite.x,
                player.sprite.y - 60,
                `SKILL UNLOCKED: ${skill.name}!`,
                '#00ff00',
                { fontSize: '24px', duration: 2000 }
            );
        }
    }

    addSkillPoint() {
        this.skillPoints += 1;
        console.log(`🎯 Skill Point earned! Total: ${this.skillPoints}`);
    }
}
```

### UI Implementation:
- Open with **K** key (already exists in UIScene)
- Tree layout: 4 branches radiating from center
- Visual connections between skills
- Locked/unlocked states
- Preview tooltips

---

## 4. 🔨 **Crafting Tiers** - Tool Progression
**Priority:** 🔴 High  
**Complexity:** Medium  
**Time Estimate:** 3 days

### Tier System:
```javascript
// src/core/inventory_crafting.js - EXPANDED

export const TOOL_TIERS = {
    WOOD: {
        tier: 1,
        durability: 50,
        efficiency: 1.0,
        damage: 5,
        color: 0x8B4513
    },
    STONE: {
        tier: 2,
        durability: 100,
        efficiency: 1.2,
        damage: 10,
        color: 0x808080
    },
    BRONZE: {
        tier: 3,
        durability: 200,
        efficiency: 1.5,
        damage: 15,
        color: 0xCD7F32
    },
    IRON: {
        tier: 4,
        durability: 400,
        efficiency: 2.0,
        damage: 25,
        color: 0xC0C0C0
    },
    STEEL: {
        tier: 5,
        durability: 800,
        efficiency: 3.0,
        damage: 40,
        color: 0x4682B4
    },
    DIAMOND: {
        tier: 6,
        durability: 1600,
        efficiency: 5.0,
        damage: 60,
        color: 0x00FFFF
    }
};

// Enhanced Recipes
export const CRAFTING_RECIPES = [
    // TIER 1 - WOOD
    { 
        id: 'wood_axe', 
        name: 'Wooden Axe',
        req: { wood: 5 },
        output: 1,
        tier: 'WOOD',
        type: 'tool'
    },

    // TIER 2 - STONE (existing)
    { 
        id: 'stone_axe', 
        name: 'Stone Axe',
        req: { wood: 3, stone: 3 },
        output: 1,
        tier: 'STONE',
        type: 'tool'
    },

    // TIER 3 - BRONZE
    { 
        id: 'bronze_axe', 
        name: 'Bronze Axe',
        req: { wood: 2, bronze_bar: 3 },
        output: 1,
        tier: 'BRONZE',
        type: 'tool',
        desc: '+50% efficiency, 200 durability'
    },
    { 
        id: 'bronze_bar', 
        name: 'Bronze Bar',
        req: { copper_ore: 3, tin_ore: 1 },
        output: 1,
        type: 'material',
        desc: 'Smelt in furnace'
    },

    // TIER 4 - IRON
    { 
        id: 'iron_axe', 
        name: 'Iron Axe',
        req: { wood: 2, iron_bar: 4 },
        output: 1,
        tier: 'IRON',
        type: 'tool',
        desc: '+100% efficiency, 400 durability'
    },

    // TIER 5 - STEEL
    { 
        id: 'steel_axe', 
        name: 'Steel Axe',
        req: { wood: 1, steel_bar: 5 },
        output: 1,
        tier: 'STEEL',
        type: 'tool',
        desc: '+200% efficiency, 800 durability'
    },
    { 
        id: 'steel_bar', 
        name: 'Steel Bar',
        req: { iron_bar: 2, coal: 1 },
        output: 1,
        type: 'material',
        desc: 'High-tier alloy'
    },

    // TIER 6 - DIAMOND
    { 
        id: 'diamond_pickaxe', 
        name: 'Diamond Pickaxe',
        req: { steel_bar: 2, diamond: 3 },
        output: 1,
        tier: 'DIAMOND',
        type: 'tool',
        desc: '+400% efficiency, 1600 durability, mines all ores'
    }
    
    // ... (add similar for pickaxe, hoe, sword, etc.)
];
```

### Durability System:
```javascript
// Each tool has durability
tool.durability = TOOL_TIERS[tool.tier].durability;
tool.currentDurability = tool.durability;

// On use
function useTool(tool) {
    tool.currentDurability -= 1;
    
    if (tool.currentDurability <= 0) {
        // Tool broke!
        console.log(`💥 ${tool.name} broke!`);
        removeFromInventory(inventorySystem, tool.type, 1);
        
        // Visual effect
        playToolBreakAnimation();
    }
    
    // Update UI with durability bar
    updateToolDurabilityUI(tool);
}
```

---

## 5. 🌧️ **Weather Particle Improvements**
**Priority:** 🔴 High  
**Complexity:** Medium  
**Time Estimate:** 2-3 days

### Enhanced Weather Effects:
```javascript
// src/systems/WeatherSystem.js - Enhanced Particles

createRainParticles() {
    const emitter = this.scene.add.particles(0, 0, 'particle_white', {
        x: { min: -100, max: this.scene.cameras.main.width + 100 },
        y: -50,
        lifespan: 2000,
        speedY: { min: 400, max: 600 },
        speedX: { min: -50, max: 50 },
        scale: { start: 0.3, end: 0.1 },
        alpha: { start: 0.6, end: 0 },
        tint: 0x4488ff,
        frequency: 10, // Spawn every 10ms
        quantity: 3
    });

    emitter.setScrollFactor(0);
    emitter.setDepth(300000); // Above everything
    
    return emitter;
}

createSnowParticles() {
    const emitter = this.scene.add.particles(0, 0, 'particle_white', {
        x: { min: -100, max: this.scene.cameras.main.width + 100 },
        y: -50,
        lifespan: { min: 3000, max: 5000 },
        speedY: { min: 50, max: 100 },
        speedX: { min: -30, max: 30 },
        scale: { start: 0.5, end: 0.2 },
        alpha: { start: 0.8, end: 0.3 },
        rotate: { start: 0, end: 360 },
        tint: 0xffffff,
        frequency: 50,
        quantity: 2,
        gravityY: 20 // Gentle fall
    });

    emitter.setScrollFactor(0);
    emitter.setDepth(300000);
    
    return emitter;
}

createThunderstorm() {
    // Heavy rain + lightning flashes
    this.rainEmitter.setFrequency(5); // Intense rain!
    
    // Lightning timer
    this.lightningTimer = this.scene.time.addEvent({
        delay: Phaser.Math.Between(3000, 8000),
        callback: () => {
            this.flashLightning();
        },
        loop: true
    });
}

flashLightning() {
    // Screen flash
    this.scene.cameras.main.flash(100, 255, 255, 255);
    
    // Sound
    if (this.scene.soundManager) {
        this.scene.soundManager.playThunder();
    }
    
    // Temporary brightness (for lighting system)
    if (this.scene.lightingSystem) {
        this.scene.lightingSystem.globalLight = 1.0;
        this.scene.time.delayedCall(100, () => {
            this.scene.lightingSystem.globalLight = 0.3; // Back to storm darkness
        });
    }
}
```

---

## 6. 🚜 **Farming Automation** - Sprinklers
**Priority:** 🔴 High  
**Complexity:** Medium  
**Time Estimate:** 3 days

### Sprinkler System:
```javascript
// src/systems/AutomationSystem.js
class AutomationSystem {
    constructor(scene) {
        this.scene = scene;
        this.sprinklers = [];
        this.harvesters = [];
    }

    placeSprinkler(gridX, gridY) {
        const sprinkler = {
            gridX,
            gridY,
            range: 3, // 3x3 grid
            waterTimer: 0,
            waterInterval: 5000, // Water every 5 seconds
            active: true
        };

        // Create sprite
        const screenPos = this.scene.player.iso.toScreen(gridX, gridY);
        sprinkler.sprite = this.scene.add.sprite(
            screenPos.x + this.scene.player.offsetX,
            screenPos.y + this.scene.player.offsetY,
            'sprinkler'
        );
        sprinkler.sprite.setOrigin(0.5, 1);

        this.sprinklers.push(sprinkler);
        return sprinkler;
    }

    update(delta) {
        // Update sprinklers
        this.sprinklers.forEach(sprinkler => {
            if (!sprinkler.active) return;

            sprinkler.waterTimer += delta;

            if (sprinkler.waterTimer >= sprinkler.waterInterval) {
                sprinkler.waterTimer = 0;
                this.waterCropsInRange(sprinkler);
            }
        });
    }

    waterCropsInRange(sprinkler) {
        const farmingSystem = this.scene.farmingSystem;
        if (!farmingSystem) return;

        // Water animation
        this.playWaterAnimation(sprinkler);

        // Find crops in range
        for (let dx = -sprinkler.range; dx <= sprinkler.range; dx++) {
            for (let dy = -sprinkler.range; dy <= sprinkler.range; dy++) {
                const cropX = sprinkler.gridX + dx;
                const cropY = sprinkler.gridY + dy;

                const crop = farmingSystem.getCropAt(cropX, cropY);
                if (crop && crop.stage < 4) {
                    // Speed up growth by 20%
                    crop.stageTimer += 1000; // +1 second progress
                }
            }
        }
    }

    playWaterAnimation(sprinkler) {
        // Blue particle spray
        const emitter = this.scene.add.particles(
            sprinkler.sprite.x,
            sprinkler.sprite.y - 20,
            'particle_white',
            {
                lifespan: 500,
                speed: { min: 50, max: 100 },
                angle: { min: -120, max: -60 },
                scale: { start: 0.3, end: 0 },
                tint: 0x44aaff,
                quantity: 10,
                frequency: -1 // One-shot
            }
        );

        emitter.explode();
        
        this.scene.time.delayedCall(500, () => emitter.destroy());
    }
}
```

### Sprinkler Recipe:
```javascript
{ 
    id: 'sprinkler', 
    name: 'Sprinkler',
    req: { iron_bar: 5, pipe: 3, water_tank: 1 },
    output: 1,
    type: 'automation',
    desc: 'Automatically waters 3x3 crops every 5 seconds'
}
```

---

## 7. 🎣 **Fishing System**
**Priority:** 🔴 High  
**Complexity:** Medium  
**Time Estimate:** 3-4 days

### Implementation:
```javascript
// src/systems/FishingSystem.js
class FishingSystem {
    constructor(scene) {
        this.scene = scene;
        this.isFishing = false;
        this.fishingMinigameActive = false;
        this.currentFish = null;

        // Fish types
        this.fishTypes = [
            { id: 'bass', name: 'Bass', rarity: 0.4, value: 10, difficulty: 1 },
            { id: 'salmon', name: 'Salmon', rarity: 0.3, value: 25, difficulty: 2 },
            { id: 'tuna', name: 'Tuna', rarity: 0.15, value: 50, difficulty: 3 },
            { id: 'goldfish', name: 'Goldfish', rarity: 0.1, value: 100, difficulty: 4 },
            { id: 'legendary_fish', name: 'Legendary Fish', rarity: 0.05, value: 500, difficulty: 5 }
        ];
    }

    startFishing(gridX, gridY) {
        // Check if near water
        const tile = this.scene.terrainSystem.tiles[gridY][gridX];
        if (tile.type !== 'water') {
            console.log('⚠️ Not near water!');
            return false;
        }

        // Check if has fishing rod
        if (!this.scene.inventorySystem.hasItem('fishing_rod', 1)) {
            console.log('⚠️ Need fishing rod!');
            return false;
        }

        this.isFishing = true;
        this.castLine(gridX, gridY);
        
        return true;
    }

    castLine(gridX, gridY) {
        console.log('🎣 Casting line...');

        // Visual: throw line
        const screenPos = this.scene.player.iso.toScreen(gridX, gridY);
        const bobber = this.scene.add.sprite(
            screenPos.x + this.scene.player.offsetX,
            screenPos.y + this.scene.player.offsetY,
            'fishing_bobber'
        );
        
        // Animate line cast
        const playerPos = this.scene.player.getScreenPosition();
        bobber.setPosition(playerPos.x, playerPos.y);
        
        this.scene.tweens.add({
            targets: bobber,
            x: screenPos.x + this.scene.player.offsetX,
            y: screenPos.y + this.scene.player.offsetY - 10,
            duration: 500,
            ease: 'Quad.easeOut',
            onComplete: () => {
                // Wait for bite
                this.waitForBite(bobber);
            }
        });

        this.bobber = bobber;
    }

    waitForBite(bobber) {
        // Random wait time (2-8 seconds)
        const waitTime = 2000 + Math.random() * 6000;

        this.biteTimer = this.scene.time.delayedCall(waitTime, () => {
            // Fish bit!
            this.onFishBite(bobber);
        });
    }

    onFishBite(bobber) {
        console.log('🐟 Fish bite!');

        // Visual: bobber shake
        this.scene.tweens.add({
            targets: bobber,
            y: bobber.y - 20,
            yoyo: true,
            duration: 100,
            repeat: 3
        });

        // Sound
        if (this.scene.soundManager && this.scene.soundManager.playFishBite) {
            this.scene.soundManager.playFishBite();
        }

        // UI prompt: "Press SPACE to reel!"
        const uiScene = this.scene.scene.get('UIScene');
        if (uiScene && uiScene.showFishingPrompt) {
            uiScene.showFishingPrompt(() => this.startMinigame());
        }

        // Auto-start minigame after 2 seconds if no input
        this.scene.time.delayedCall(2000, () => {
            if (this.isFishing) {
                this.startMinigame();
            }
        });
    }

    startMinigame() {
        // Select random fish (weighted by rarity)
        this.currentFish = this.selectFish();
        
        console.log(`🎣 Fishing minigame started! Fish: ${this.currentFish.name}`);

        // Simple QTE (Quick Time Event)
        // Show moving bar, player must press SPACE when bar is in green zone
        
        const uiScene = this.scene.scene.get('UIScene');
        if (uiScene && uiScene.showFishingMinigame) {
            uiScene.showFishingMinigame(this.currentFish, (success) => {
                if (success) {
                    this.catchFish(this.currentFish);
                } else {
                    this.fishEscaped();
                }
                this.endFishing();
            });
        }
    }

    selectFish() {
        // Weighted random selection
        const roll = Math.random();
        let cumulative = 0;

        for (const fish of this.fishTypes) {
            cumulative += fish.rarity;
            if (roll < cumulative) {
                return fish;
            }
        }

        return this.fishTypes[0]; // Fallback
    }

    catchFish(fish) {
        console.log(`✅ Caught ${fish.name}!`);

        // Add to inventory
        this.scene.inventorySystem.addItem(fish.id, 1);

        // XP
        if (this.scene.player && this.scene.player.addExperience) {
            this.scene.player.addExperience(fish.value);
        }

        // Visual effect
        if (this.scene.visualEffectsSystem) {
            this.scene.visualEffectsSystem.showFloatingText(
                this.bobber.x,
                this.bobber.y,
                `Caught ${fish.name}! +${fish.value} XP`,
                '#00ff00'
            );
        }
    }

    fishEscaped() {
        console.log('❌ Fish escaped!');

        if (this.scene.visualEffectsSystem) {
            this.scene.visualEffectsSystem.showFloatingText(
                this.bobber.x,
                this.bobber.y,
                'Fish Escaped!',
                '#ff0000'
            );
        }
    }

    endFishing() {
        this.isFishing = false;
        
        if (this.bobber) {
            this.bobber.destroy();
            this.bobber = null;
        }

        if (this.biteTimer) {
            this.biteTimer.remove();
        }
    }
}
```

### Fishing Rod Recipe:
```javascript
{ 
    id: 'fishing_rod', 
    name: 'Fishing Rod',
    req: { wood: 3, string: 2 },
    output: 1,
    type: 'tool',
    desc: 'Catch fish from water tiles'
}
```

---

## 8. 👤 **Shadow System**
**Priority:** 🔴 High  
**Complexity:** Low  
**Time Estimate:** 1-2 days

### Implementation:
```javascript
// src/systems/ShadowSystem.js
class ShadowSystem {
    constructor(scene) {
        this.scene = scene;
        this.shadows = new Map(); // entity → shadow sprite
    }

    createShadow(entity) {
        // Create ellipse shadow
        const shadow = this.scene.add.ellipse(
            entity.sprite.x,
            entity.sprite.y,
            entity.sprite.width * 0.8, // width
            entity.sprite.width * 0.4,  // height (oval)
            0x000000,
            0.3 // alpha
        );

        shadow.setOrigin(0.5, 0.5);
        shadow.setDepth(entity.sprite.depth - 1); // Below entity

        this.shadows.set(entity, shadow);
        return shadow;
    }

    update() {
        this.shadows.forEach((shadow, entity) => {
            if (!entity.sprite || !entity.sprite.active) {
                shadow.destroy();
                this.shadows.delete(entity);
                return;
            }

            // Update position
            shadow.setPosition(
                entity.sprite.x,
                entity.sprite.y + 5 // Slight offset below feet
            );

            // Update depth
            shadow.setDepth(entity.sprite.depth - 1);

            // Dynamic shadow based on time of day
            if (this.scene.lightingSystem) {
                const sunIntensity = this.scene.lightingSystem.globalLight;
                shadow.setAlpha(sunIntensity * 0.4); // Darker shadows during day
            }
        });
    }

    removeShadow(entity) {
        const shadow = this.shadows.get(entity);
        if (shadow) {
            shadow.destroy();
            this.shadows.delete(entity);
        }
    }
}
```

---

# 🟡 **MEDIUM PRIORITY FEATURES**

## 9. 🍳 **Cooking System**
**Priority:** 🟡 Medium  
**Complexity:** Medium  
**Time Estimate:** 3-4 days

### Recipes:
```javascript
// Cooking recipes
{ id: 'bread', req: { wheat: 3 }, result: 'bread', hp: +20 },
{ id: 'stew', req: { potato: 2, carrot: 2, beef: 1 }, result: 'stew', hp: +50 },
{ id: 'fish_soup', req: { bass: 2, salt: 1 }, result: 'fish_soup', hp: +30 },
{ id: 'cake', req: { wheat: 3, milk: 2, egg: 1, sugar: 2 }, result: 'cake', hp: +60 }
```

### Cooking Station:
```javascript
{ 
    id: 'cooking_pot', 
    name: 'Cooking Pot',
    req: { iron_bar: 5 },
    output: 1,
    type: 'building',
    desc: 'Cook food for HP restoration'
}
```

---

## 10. 🐮 **Animal Breeding**
**Priority:** 🟡 Medium  
**Complexity:** High  
**Time Estimate:** 5-6 days

_See DLC_ROADMAP.md for full breeding system design_

---

## 11. ⛏️ **Mining Dungeons**
**Priority:** 🟡 Medium  
**Complexity:** High  
**Time Estimate:** 6-8 days

### Procedural Cave Generation:
```javascript
// Use Perlin Noise for cave systems
// - Vertical descent
// - Ores, gems, enemies
// - Boss rooms
// - Loot chests
```

---

## 12. 🌫️ **Fog of War**
**Priority:** 🟡 Medium  
**Complexity:** Medium  
**Time Estimate:** 3 days

### Implementation:
```javascript
// src/systems/FogOfWarSystem.js
// - Track explored tiles
// - Render darkness overlay on unexplored areas
// - Gradually reveal as player moves
```

---

## 13-20: **Additional Medium Priority**
- Weather transitions
- Boss raids
- Icon polish (higher res)
- UI transitions
- Build animations
- Controller support improvements
- Performance profiler
- Debug console

---

# 🟢 **LOW PRIORITY FEATURES**

## 21-27: **Future Enhancements**
- Co-op mode
- Trading post
- Leaderboards
- Mod support
- Replay system
- Platform ports (Linux, Mac)
- Auto-update system

---

# 📅 **SUGGESTED TIMELINE**

### **Month 1: Visual Polish** (Weeks 1-4)
- Week 1: Light System + Shadow System
- Week 2: Crop Animations + Weather Particles
- Week 3: UI Transitions + Icon Polish
- Week 4: Building Animations + Testing

### **Month 2: Core Gameplay** (Weeks 5-8)
- Week 5: Skill Tree System
- Week 6: Crafting Tiers
- Week 7: Farming Automation (Sprinklers)
- Week 8: Fishing System

### **Month 3: Advanced Features** (Weeks 9-12)
- Week 9: Cooking System
- Week 10: Fog of War
- Week 11: Animal Breeding
- Week 12: Polish + Bug Fixes

### **Month 4+: Expansion** (Weeks 13+)
- Mining Dungeons
- Boss Raids
- Multiplayer
- Platform Ports

---

**Total Estimated Development Time:** ~18 weeks (4.5 months)

**Status:** ✅ ROADMAP COMPLETE - Ready for phased implementation