novafarma/src/systems/GrokCharacterSystem.js

/**
 * GrokCharacterSystem.js
 * ======================
 * KRVAVA ŽETEV - Grok Character Update (P13)
 * 
 * Features:
 * - Massive gong (1m diameter!)
 * - Rainbow RGB vape mod
 * - Morning meditation rituals
 * - Combat buffs
 * - Smoke screen abilities
 * 
 * @author NovaFarma Team
 * @date 2025-12-23
 */

export default class GrokCharacterSystem {
    constructor(scene, grokSprite) {
        this.scene = scene;
        this.grok = grokSprite;

        // Grok state
        this.isVaping = true; // Always vaping!
        this.lastGongTime = 0;
        this.gongCooldown = 300000; // 5 minutes
        this.meditationTime = 6; // 6 AM daily

        // Visual elements
        this.gong = null;
        this.vapeDevice = null;
        this.smokeParticles = [];

        // Buffs
        this.activeBuffs = new Map();

        console.log('🧘 GrokCharacterSystem initialized');

        // Setup visuals
        this.setupGrokVisuals();
        this.startVapingAnimation();
    }

    /**
     * 13.1 - Setup Grok's visual elements
     */
    setupGrokVisuals() {
        if (!this.grok) return;

        // Create massive gong (1m diameter = 100 pixels!)
        this.gong = this.scene.add.circle(
            this.grok.x - 50,
            this.grok.y,
            50, // Radius 50px = 100px diameter
            0xDAA520 // Golden color
        );
        this.gong.setStrokeStyle(5, 0x8B4513); // Brown stroke
        this.gong.setDepth(this.grok.depth - 1);

        // Add gong details (concentric circles)
        for (let i = 1; i <= 3; i++) {
            const ring = this.scene.add.circle(
                this.grok.x - 50,
                this.grok.y,
                50 - (i * 10),
                null
            );
            ring.setStrokeStyle(2, 0x8B4513);
            ring.setDepth(this.grok.depth - 1);
        }

        // Create RGB vape mod
        this.vapeDevice = this.scene.add.rectangle(
            this.grok.x + 20,
            this.grok.y + 10,
            15, // Width
            30, // Height
            0xFF1493 // Deep pink
        );
        this.vapeDevice.setDepth(this.grok.depth + 1);

        // Add RGB LED effect
        this.scene.tweens.add({
            targets: this.vapeDevice,
            fillColor: { from: 0xFF1493, to: 0x00CED1 }, // Pink → Cyan
            duration: 2000,
            yoyo: true,
            repeat: -1
        });

        console.log('✅ Grok visuals setup complete');
    }

    /**
     * 13.2 - Morning Meditation Gong
     */
    triggerMorningMeditation() {
        console.log('🧘 *BOOONG!* Morning meditation begins...');

        // Play gong animation
        this.playGongAnimation();

        // Buff all nearby allies
        this.applyMeditationBuff();

        // Show message
        this.showNotification({
            title: 'Morning Meditation',
            text: '🥁 BOOONG! Grok\'s gong brings peace to all.',
            icon: '🧘'
        });
    }

    /**
     * 13.2 - Gong strike (combat buff)
     */
    strikeGong() {
        const now = Date.now();
        if (now - this.lastGongTime < this.gongCooldown) {
            const remaining = Math.ceil((this.gongCooldown - (now - this.lastGongTime)) / 1000);
            console.log(`⏰ Gong on cooldown for ${remaining}s`);
            return false;
        }

        console.log('🥁 *BOOOOONG!!!*');
        this.lastGongTime = now;

        // Visual effect
        this.playGongAnimation();

        // Sound wave radius
        this.createSoundWaveEffect();

        // Combat buffs
        this.applyGongCombatBuff();

        // Stun enemies
        this.stunNearbyEnemies();

        return true;
    }

    /**
     * 13.2 - Gong animation
     */
    playGongAnimation() {
        if (!this.gong) return;

        // Vibrate gong
        this.scene.tweens.add({
            targets: this.gong,
            scaleX: 1.2,
            scaleY: 1.2,
            alpha: 0.5,
            duration: 100,
            yoyo: true,
            repeat: 5
        });

        // Screen shake
        this.scene.cameras.main.shake(500, 0.01);

        // Flash
        this.scene.cameras.main.flash(200, 255, 215, 0); // Gold flash
    }

    /**
     * 13.2 - Sound wave effect
     */
    createSoundWaveEffect() {
        if (!this.gong) return;

        // Create expanding circles (sound waves)
        for (let i = 0; i < 3; i++) {
            setTimeout(() => {
                const wave = this.scene.add.circle(
                    this.gong.x,
                    this.gong.y,
                    10,
                    0xFFD700,
                    0.5
                );

                this.scene.tweens.add({
                    targets: wave,
                    radius: 480, // 10 blocks
                    alpha: 0,
                    duration: 1000,
                    onComplete: () => wave.destroy()
                });
            }, i * 200);
        }
    }

    /**
     * 13.2 - Apply gong combat buff
     */
    applyGongCombatBuff() {
        const buffDuration = 30000; // 30 seconds
        const buffData = {
            name: 'Gong Resonance',
            damage: 1.2, // +20% damage
            defense: 1.1, // +10% defense
            expiresAt: Date.now() + buffDuration
        };

        // Apply to player
        if (this.scene.player) {
            this.activeBuffs.set('player', buffData);
            console.log('⚔️ Player buffed: +20% damage, +10% defense (30s)');
        }

        // Apply to nearby allies
        this.buffNearbyAllies(buffData);

        this.showNotification({
            title: 'Gong Resonance!',
            text: '🥁 +20% Damage, +10% Defense for 30s!',
            icon: '⚔️'
        });
    }

    /**
     * 13.2 - Buff nearby allies
     */
    buffNearbyAllies(buffData) {
        // TODO: Get all allies within 10 blocks
        // For now, just log
        console.log('🤝 Allies buffed!');
    }

    /**
     * 13.2 - Apply meditation buff
     */
    applyMeditationBuff() {
        const buffData = {
            name: 'Morning Meditation',
            healthRegen: 5, // +5 HP/sec
            staminaRegen: 10, // +10 stamina/sec
            duration: 60000 // 1 minute
        };

        // TODO: Apply to all players/allies in area
        console.log('🧘 Meditation buff active: +5 HP/sec, +10 stamina/sec');
    }

    /**
     * 13.2 - Stun nearby enemies
     */
    stunNearbyEnemies() {
        const stunRadius = 480; // 10 blocks (48px per tile)

        // TODO: Get all enemies within radius and stun them
        console.log(`💫 Enemies within ${stunRadius}px stunned for 3 seconds!`);
    }

    /**
     * 13.3 - Vaping animation (always active!)
     */
    startVapingAnimation() {
        // Constant vaping
        setInterval(() => {
            this.exhaleVapeSmoke();
        }, 3000); // Every 3 seconds
    }

    /**
     * 13.3 - Exhale vape smoke
     */
    exhaleVapeSmoke() {
        if (!this.vapeDevice) return;

        // Create pink smoke particles
        const smokeCount = 10;
        for (let i = 0; i < smokeCount; i++) {
            setTimeout(() => {
                this.createSmokeParticle();
            }, i * 50);
        }

        // Random smoke trick
        if (Math.random() < 0.2) { // 20% chance
            this.performSmokeTrick();
        }
    }

    /**
     * 13.3 - Create smoke particle
     */
    createSmokeParticle() {
        if (!this.grok) return;

        const smoke = this.scene.add.circle(
            this.grok.x + 20,
            this.grok.y - 10,
            5 + Math.random() * 5,
            0xFF1493, // Deep pink
            0.7
        );

        // Smoke rises and fades
        this.scene.tweens.add({
            targets: smoke,
            y: smoke.y - 50 - Math.random() * 50,
            x: smoke.x + (Math.random() - 0.5) * 30,
            alpha: 0,
            radius: 20,
            duration: 2000 + Math.random() * 1000,
            onComplete: () => smoke.destroy()
        });

        this.smokeParticles.push(smoke);
    }

    /**
     * 13.3 - Smoke tricks
     */
    performSmokeTrick() {
        const tricks = ['rings', 'dragon', 'tornado'];
        const trick = Phaser.Utils.Array.GetRandom(tricks);

        switch (trick) {
            case 'rings':
                this.createSmokeRings();
                break;
            case 'dragon':
                this.createSmokeDragon();
                break;
            case 'tornado':
                this.createSmokeTornado();
                break;
        }

        console.log(`💨 Grok did a ${trick} smoke trick!`);
    }

    /**
     * 13.3 - Create smoke rings
     */
    createSmokeRings() {
        if (!this.grok) return;

        for (let i = 0; i < 3; i++) {
            setTimeout(() => {
                const ring = this.scene.add.circle(
                    this.grok.x + 30,
                    this.grok.y - 20,
                    10,
                    null
                );
                ring.setStrokeStyle(3, 0xFF1493, 0.8);

                this.scene.tweens.add({
                    targets: ring,
                    x: ring.x + 100,
                    radius: 20,
                    alpha: 0,
                    duration: 1500,
                    onComplete: () => ring.destroy()
                });
            }, i * 300);
        }
    }

    /**
     * 13.3 - Create smoke dragon
     */
    createSmokeDragon() {
        if (!this.grok) return;

        // Create flowing smoke path (dragon shape!)
        const points = [];
        for (let i = 0; i < 20; i++) {
            points.push({
                x: this.grok.x + 30 + i * 10,
                y: this.grok.y - 20 + Math.sin(i * 0.5) * 20
            });
        }

        points.forEach((point, index) => {
            setTimeout(() => {
                const smoke = this.scene.add.circle(
                    point.x,
                    point.y,
                    8,
                    0xFF1493,
                    0.6
                );

                this.scene.tweens.add({
                    targets: smoke,
                    alpha: 0,
                    duration: 1000,
                    onComplete: () => smoke.destroy()
                });
            }, index * 50);
        });
    }

    /**
     * 13.3 - Create smoke tornado
     */
    createSmokeTornado() {
        if (!this.grok) return;

        // Spiral smoke upward
        for (let i = 0; i < 30; i++) {
            setTimeout(() => {
                const angle = (i * 20) * Math.PI / 180;
                const radius = 20 + i;
                const smoke = this.scene.add.circle(
                    this.grok.x + 30 + Math.cos(angle) * radius,
                    this.grok.y - 20 - i * 3,
                    5,
                    0xFF1493,
                    0.7
                );

                this.scene.tweens.add({
                    targets: smoke,
                    alpha: 0,
                    duration: 2000,
                    onComplete: () => smoke.destroy()
                });
            }, i * 30);
        }
    }

    /**
     * 13.3 - Combat smoke screen
     */
    deploySmokeScreen() {
        console.log('💨 Deploying combat smoke screen!');

        // Create large pink smoke cloud
        const smokescreenRadius = 240; // 5 blocks

        for (let i = 0; i < 50; i++) {
            setTimeout(() => {
                const angle = Math.random() * Math.PI * 2;
                const distance = Math.random() * smokescreenRadius;

                const smoke = this.scene.add.circle(
                    this.grok.x + Math.cos(angle) * distance,
                    this.grok.y + Math.sin(angle) * distance,
                    10 + Math.random() * 10,
                    0xFF1493,
                    0.8
                );

                this.scene.tweens.add({
                    targets: smoke,
                    alpha: 0,
                    radius: 30,
                    duration: 5000,
                    onComplete: () => smoke.destroy()
                });
            }, i * 50);
        }

        // Confuse enemies
        this.confuseNearbyEnemies();

        this.showNotification({
            title: 'Smoke Screen!',
            text: '💨 Enemies confused! Grok vanishes into pink smoke!',
            icon: '😵'
        });
    }

    /**
     * 13.3 - Confuse enemies
     */
    confuseNearbyEnemies() {
        // TODO: Apply confusion effect to enemies
        console.log('😵 Enemies confused!');
    }

    /**
     * 13.4 - Get Grok dialogue
     */
    getRandomGrokDialogue() {
        const dialogues = [
            "The gong speaks to those who listen... *BOOONG!*",
            "Life is like vape smoke... fleeting and pink. *exhales*",
            "Why fight when you can meditate? *hits vape*",
            "The universe is just a massive gong, friend. *BOOONG!*",
            "*BOOOONG!* Inner peace achieved.",
            "This vape? It's pink because life is beautiful. *exhales rainbow smoke*",
            "My gong has defeated more enemies than any sword. *taps gong*",
            "Violence is temporary. Zen is eternal. *vapes peacefully*",
            "Watch this smoke trick! *creates dragon*",
            "The gong's vibration aligns the chakras. Science!",
            "*BOOONG!* That's me saying hello.",
            "Pink smoke = happy thoughts. Simple. *exhales*"
        ];

        return Phaser.Utils.Array.GetRandom(dialogues);
    }

    /**
     * Update system
     */
    update(time, delta) {
        // Check for morning meditation time
        const currentHour = this.scene.timeSystem?.getCurrentHour() || 0;
        if (currentHour === this.meditationTime) {
            const lastMeditation = localStorage.getItem('grok_last_meditation');
            const today = new Date().toDateString();

            if (lastMeditation !== today) {
                this.triggerMorningMeditation();
                localStorage.setItem('grok_last_meditation', today);
            }
        }

        // Update buff timers
        this.updateBuffs();

        // Clean up old smoke particles
        this.cleanupSmokeParticles();
    }

    /**
     * Update active buffs
     */
    updateBuffs() {
        const now = Date.now();

        this.activeBuffs.forEach((buff, target) => {
            if (buff.expiresAt && buff.expiresAt < now) {
                this.activeBuffs.delete(target);
                console.log(`✨ Buff "${buff.name}" expired for ${target}`);
            }
        });
    }

    /**
     * Cleanup old smoke particles
     */
    cleanupSmokeParticles() {
        this.smokeParticles = this.smokeParticles.filter(smoke => {
            if (!smoke || smoke.alpha <= 0) {
                if (smoke) smoke.destroy();
                return false;
            }
            return true;
        });
    }

    /**
     * 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);
        }
    }

    /**
     * Get active buff for target
     */
    getActiveBuff(target) {
        return this.activeBuffs.get(target);
    }
}