A!leys Galerie

// Dynamic NPC Behavior Simulator for RPG Maker MZ
// Features:
// - Simulates 3 different NPC behaviors (Explorer, Trader, Hermit)
// - Visualizes behavior patterns in a simple terminal UI
// - Saves NPC configurations to localStorage
// - Randomizes certain traits while maintaining personality archetypes

import readline from 'readline';

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

class NPCCore {
    constructor(name, behaviorType, traits) {
        this.name = name || `NPC-${Math.floor(Math.random() * 1000)}`;
        this.behaviorType = behaviorType || this.randomBehaviorType();
        this.traits = traits || this.generateTraits(this.behaviorType);
        this.memory = [];
        this.energy = 100;
        this.timeSinceLastAction = 0;
    }

    randomBehaviorType() {
        const types = ['Explorer', 'Trader', 'Hermit'];
        return types[Math.floor(Math.random() * types.length)];
    }

    generateTraits(behaviorType) {
        const baseTraits = {
            curiosity: Math.floor(Math.random() * 41) + 30,  // 30-70
            sociability: Math.floor(Math.random() * 41) + 30,
            routine: Math.floor(Math.random() * 41) + 30,
            greed: Math.floor(Math.random() * 41) + 10,      // 10-50
            knowledge: Math.floor(Math.random() * 41) + 20,  // 20-60
            introversion: Math.floor(Math.random() * 41) + 20 // 20-60
        };

        switch (behaviorType) {
            case 'Explorer':
                return {
                    ...baseTraits,
                    curiosity: Math.min(90, baseTraits.curiosity + 20),
                    knowledge: Math.min(80, baseTraits.knowledge + 10),
                    sociability: Math.max(30, baseTraits.sociability - 10)
                };
            case 'Trader':
                return {
                    ...baseTraits,
                    greed: Math.min(80, baseTraits.greed + 30),
                    sociability: Math.min(80, baseTraits.sociability + 20),
                    routine: Math.max(30, baseTraits.routine - 10)
                };
            case 'Hermit':
                return {
                    ...baseTraits,
                    introversion: Math.min(80, baseTraits.introversion + 20),
                    routine: Math.min(80, baseTraits.routine + 20),
                    sociability: Math.max(20, baseTraits.sociability - 20)
                };
            default:
                return baseTraits;
        }
    }

    update(timePassed) {
        this.timeSinceLastAction += timePassed;
        this.energy -= timePassed * 0.1;

        if (this.energy < 0) this.energy = 0;

        // Behavior-specific updates
        switch (this.behaviorType) {
            case 'Explorer':
                this.explorerBehaviorUpdate(timePassed);
                break;
            case 'Trader':
                this.traderBehaviorUpdate(timePassed);
                break;
            case 'Hermit':
                this.hermitBehaviorUpdate(timePassed);
                break;
        }

        // Random events that might trigger
        if (Math.random() < 0.01 * (1 + this.traits.curiosity / 100)) {
            this.memory.push(`[Discovered ${this.generateDiscovery()}]`);
        }
    }

    explorerBehaviorUpdate(timePassed) {
        // Explorers get energy from discovering new places
        if (Math.random() < 0.02 * (this.traits.curiosity / 100)) {
            this.energy += 5;
            this.memory.push(`[Found interesting artifact near ${this.generateLocation()}]`);
        }

        // They wander more when curious
        if (this.timeSinceLastAction > 10 + (100 - this.traits.curiosity) / 2) {
            this.performAction('Wander to new location');
            this.timeSinceLastAction = 0;
        }
    }

    traderBehaviorUpdate(timePassed) {
        // Traders gain energy from trading
        if (Math.random() < 0.03 * (this.traits.greed / 100) && this.traits.routine > 50) {
            const profit = Math.floor(Math.random() * 11) - 5;
            this.energy += Math.max(3, profit);
            this.memory.push(`[Traded for ${profit >= 0 ? 'profit' : 'loss'} of ${Math.abs(profit)} gold]`);
        }

        // They get restless if routine is low
        if (this.timeSinceLastAction > 8 - (this.traits.routine / 20)) {
            if (Math.random() < 0.3 * (100 - this.traits.sociability) / 100) {
                this.performAction('Seek out other traders');
            } else {
                this.performAction('Restock inventory');
            }
            this.timeSinceLastAction = 0;
        }
    }

    hermitBehaviorUpdate(timePassed) {
        // Hermits gain energy from routine
        if (Math.random() < 0.01 * (this.traits.routine / 100)) {
            this.energy += 2;
            this.memory.push(`[Completed daily routine task]`);
        }

        // They get uncomfortable with too much interaction
        if (this.timeSinceLastAction > 12 + (this.traits.introversion / 3)) {
            if (Math.random() < 0.7 * (this.traits.introversion / 100)) {
                this.performAction('Return to solitary spot');
            } else {
                this.performAction('Observe from a distance');
            }
            this.timeSinceLastAction = 0;
        }
    }

    performAction(action) {
        this.memory.push(`[${this.behaviorType}: ${action}]`);
        this.timeSinceLastAction = 0;
        this.energy += 2; // Small energy boost from activity
    }

    generateDiscovery() {
        const discoveries = [
            'ancient ruins',
            'rare herb',
            'mysterious map fragment',
            'glowing mineral',
            'forgotten text',
            'strange artifact',
            'hidden cave entrance'
        ];
        return discoveries[Math.floor(Math.random() * discoveries.length)];
    }

    generateLocation() {
        const locations = [
            'eastern forest',
            'western valley',
            'northern peaks',
            'southern marshes',
            'abandoned temple',
            'dusty library',
            'old market square'
        ];
        return locations[Math.floor(Math.random() * locations.length)];
    }

    toString() {
        return `[${this.behaviorType}] ${this.name} (Energy: ${Math.round(this.energy)} | ` +
               `Curiosity: ${this.traits.curiosity} | ` +
               `Sociability: ${this.traits.sociability} | ` +
               `Greed: ${this.traits.greed} | ` +
               `Knowledge: ${this.traits.knowledge})`;
    }
}

class SimulationManager {
    constructor() {
        this.npcs = [];
        this.time = 0;
        this.running = false;
        this.loadNPCs();
    }

    loadNPCs() {
        const savedNPCs = localStorage.getItem('rpgNPCBehavior');
        if (savedNPCs) {
            this.npcs = JSON.parse(savedNPCs);
        } else {
            // Create some default NPCs if none saved
            for (let i = 0; i < 3; i++) {
                const behaviorTypes = ['Explorer', 'Trader', 'Hermit'];
                this.npcs.push(new NPCCore(
                    `NPC${i + 1}`,
                    behaviorTypes[i % behaviorTypes.length]
                ));
            }
        }
    }

    saveNPCs() {
        localStorage.setItem('rpgNPCBehavior', JSON.stringify(this.npcs));
    }

    start() {
        this.running = true;
        this.simulate();
    }

    stop() {
        this.running = false;
    }

    simulate() {
        if (!this.running) return;

        // Clear screen (works in most terminals)
        console.log('\x1B[2J\x1B[0;0H');

        // Draw header
        console.log('='.repeat(50));
        console.log('DYNAMIC NPC BEHAVIOR SIMULATOR'.padEnd(50) + 'Time: ' + this.time);
        console.log('='.repeat(50));

        // Draw each NPC
        this.npcs.forEach(npc => {
            console.log('\n' + npc);
            console.log('-'.repeat(40));

            // Draw memory if there are entries
            if (npc.memory.length > 0) {
                console.log('Recent Memory:');
                console.log(npc.memory.slice(-5).join(' | ')); // Show last 5 entries
            }

            // Draw energy bar
            const energyBar = '#'.repeat(Math.floor(npc.energy / 2)) +
                              '-'.repeat(50 - Math.floor(npc.energy / 2));
            console.log(`Energy: [${energyBar}] ${Math.round(npc.energy)}/100`);
        });

        console.log('\n'.repeat(2));

        // Update NPCs
        this.npcs.forEach(npc => {
            npc.update(1); // Time passes at 1 unit per simulation step
        });

        this.time++;
        this.saveNPCs();

        // Continue simulation
        if (this.running) {
            setTimeout(() => this.simulate(), 1000);
        } else {
            console.log('\nSimulation stopped.');
        }
    }

    addNPC(name, behaviorType) {
        this.npcs.push(new NPCCore(name, behaviorType));
        this.saveNPCs();
    }

    removeNPC(index) {
        if (index >= 0 && index < this.npcs.length) {
            this.npcs.splice(index, 1);
            this.saveNPCs();
        }
    }

    showMenu() {
        console.log('\nCOMMANDS:');
        console.log('  start - Start/Resume simulation');
        console.log('  stop - Stop simulation');
        console.log('  add [name] [type] - Add new NPC (e.g., "add Gandalf Explorer")');
        console.log('  remove [index] - Remove NPC by index (0-based)');
        console.log('  quit - Exit program');
        console.log('  clear - Clear console (but keeps simulation running)');
        console.log('  help - Show this menu');
    }
}

// Main program
const manager = new SimulationManager();
manager.showMenu();

rl.on('line', (line) => {
    const command = line.trim().toLowerCase();

    if (command === 'start') {
        if (!manager.running) {
            manager.start();
            console.log('Simulation started...');
        } else {
            console.log('Simulation is already running.');
        }
    } else if (command === 'stop') {
        manager.stop();
    } else if (command === 'quit') {
        manager.stop();
        rl.close();
        process.exit();
    } else if (command === 'clear') {
        console.log('\x1B[2J\x1B[0;0H');
    } else if (command === 'help') {
        manager.showMenu();
    } else if (command.startsWith('add ')) {
        const parts = line.split(' ');
        if (parts.length === 3) {
            const name = parts[1];
            const type = parts[2];
            if (['explorer', 'trader', 'hermit'].includes(type.toLowerCase())) {
                manager.addNPC(name, type.charAt(0).toUpperCase() + type.slice(1));
                console.log(`Added ${name} as a ${type} NPC.`);
            } else {
                console.log('Invalid behavior type. Use: Explorer, Trader, Hermit');
            }
        } else {
            console.log('Usage: add [name] [type]');
        }
    } else if (command.startsWith('remove ')) {
        const index = parseInt(line.split(' ')[1]);
        if (!isNaN(index)) {
            manager.removeNPC(index);
            console.log(`Removed NPC at index ${index}.`);
        } else {
            console.log('Please provide a valid index number.');
        }
    } else if (command === '') {
        // Ignore empty lines
        return;
    } else {
        console.log('Unknown command. Type "help" for available commands.');
    }
});

// Handle exit signal
process.on('SIGINT', () => {
    manager.stop();
    rl.close();
    process.exit();
});

extends Camera3D

# Camera Shake & Screen Effects System for Godot 4
# Features:
# - Smooth, interruptible camera shake with customizable curves
# - Multiple screen effect layers (pixelate, scanlines, vignette, distortion)
# - Dynamic transition handling (fade in/out)
# - Runtime toggling via @export variables

# --- @export Variables (Configurable in Inspector) ---

# Camera Shake Settings
@export var shake_intensity: float = 0.5  # Base shake strength (0.0 - 1.0)
@export var shake_duration: float = 1.0  # Duration of the shake in seconds
@export var shake_decay: float = 0.95    # Decay factor (0.0 - 1.0) for smooth falloff
@export var shake_power: float = 0.5     # Power curve (0.0 - 1.0) for non-linear motion
@export var shake_is_active: bool = false  # Toggle shake on/off

# Screen Effect Settings
@export var pixelate_size: int = 0  # 0 to disable (e.g., 8 = 8x8 pixel grid)
@export var scanline_strength: float = 0.0  # 0.0 to 1.0 (0.0 = no scanlines)
@export var vignette_strength: float = 0.3  # 0.0 to 1.0 (darkness at edges)
@export var distortion_amount: float = 0.0  # 0.0 to 1.0 (wave distortion)
@export var distortion_speed: float = 0.1  # Speed of distortion waves

# Transition Settings (for effects like flash/fade)
@export var is_transitioning: bool = false
@export var transition_duration: float = 0.5  # Fade duration in seconds
@export var transition_alpha: float = 0.0  # Current alpha (0.0 = transparent, 1.0 = solid)

# --- Internal State ---

private var _shake_timer: float = 0.0
private var _current_shake_direction: Vector3 = Vector3.ZERO
private var _transition_timer: float = 0.0
private var _is_fading_in: bool = false
private var _original_ projective: ProjectiveCamera

# --- Initialization ---

func _ready() -> void:
    # Store the original projective transform for smooth transitions
    _original_projective = ProjectiveCamera.new()
    _original_projective.data = self.data
    self.data = _original_projective.data

    # Initialize transitions
    _transition_timer = 0.0
    transition_alpha = 1.0  # Start opaque

# --- Camera Shake Core ---

func start_shake(direction: Vector3 = Vector3.RANDOM) -> void:
    if shake_is_active:
        _shake_timer = shake_duration
        _current_shake_direction = direction.normalized()

func stop_shake() -> void:
    _shake_timer = 0.0

func _process(delta: float) -> void:
    # --- Handle Camera Shake ---
    if shake_is_active and _shake_timer > 0.0:
        # Update shake direction slightly for natural variation
        _current_shake_direction = _current_shake_direction.lerp(
            Vector3(Randf_range(-1.0, 1.0), Randf_range(-1.0, 1.0), 0.0),
            0.1 * delta
        )

        # Apply shake using a smooth falloff curve
        _shake_timer -= delta
        var shake_progress = 1.0 - (_shake_timer / shake_duration)
        var shake_strength = shake_intensity * (1.0 - pow(shake_progress, 0.5)) * shake_power

        # Smoothly interpolate shake
        var shake_offset = _current_shake_direction * shake_strength
        self.offset = shake_offset * (1.0 - exp(-delta * 5.0))  # Smooth ramp-up

        # Decay shake naturally
        if _shake_timer <= 0.0:
            self.offset = Vector3.ZERO
        else:
            # Apply decay for smoother falloff
            self.offset *= shake_decay
    else:
        self.offset = Vector3.ZERO

    # --- Handle Screen Effects ---
    if self.data.has("pixelate"):
        self.data.pixelate = pixelate_size > 0
        if pixelate_size > 0:
            self.data.pixelate_size = pixelate_size
    else:
        self.data.pixelate = false

    if self.data.has("scanline"):
        self.data.scanline = scanline_strength > 0.0
        if scanline_strength > 0.0:
            self.data.scanline_strength = scanline_strength
    else:
        self.data.scanline = false

    if self.data.has("vignette"):
        self.data.vignette = vignette_strength > 0.0
        if vignette_strength > 0.0:
            self.data.vignette_strength = vignette_strength
    else:
        self.data.vignette = false

    if self.data.has("distortion"):
        self.data.distortion = distortion_amount > 0.0
        if distortion_amount > 0.0:
            self.data.distortion_amount = distortion_amount
            self.data.distortion_speed = distortion_speed
    else:
        self.data.distortion = false

    # --- Handle Transitions (e.g., flash/fade) ---
    if is_transitioning:
        if _transition_timer <= 0.0:
            is_transitioning = false
            _transition_timer = 0.0
            transition_alpha = 1.0  # Reset to opaque
        else:
            _transition_timer -= delta
            var transition_progress = 1.0 - (_transition_timer / transition_duration)
            if _is_fading_in:
                transition_alpha = transition_progress
            else:
                transition_alpha = 1.0 - transition_progress
    else:
        transition_alpha = 1.0  # Reset if not transitioning

    # Apply transition as a full-screen color (e.g., for flashes)
    if transition_alpha > 0.0:
        var transition_color = Color(1.0, 1.0, 1.0)  # White flash (customizable)
        var transition_override = Projects.gradient_create(transition_color, 0.0, 1.0, 0.0, 1.0)
        var transition_material = StandardMaterial3D.new()
        transition_material.central_color = transition_color
        transition_material.transparency = transition_alpha
        transition_material.energy = 0.1  # Soft glow effect

        # Create a full-screen quad for the transition
        var transition_quad = MeshInstance3D.new()
        transition_quad.mesh = QuadMesh.new()
        transition_quad.material_override = transition_material
        transition_quad.transform.origin = self.global_transform.origin
        transition_quad.transform.basis = self.global_transform.basis
        transition_quad.visible = transition_alpha > 0.0
        add_child(transition_quad)
    else:
        # Clean up transition quad if no longer needed
        for child in get_children():
            if child is MeshInstance3D and child.visible == false:
                child.queue_free()

# --- Helper Functions (for external use) ---

# Start a fade transition (in or out)
func start_transition(fade_in: bool) -> void:
    if is_transitioning:
        return  # Ignore if already transitioning
    is_transitioning = true
    _is_fading_in = fade_in
    _transition_timer = transition_duration
    transition_alpha = fade_in ? 0.0 : 1.0  # Start from opposite end

# Trigger a flash effect (immediate white flash)
func trigger_flash() -> void:
    start_transition(false)  # Fade out
    await get_tree().create_timer(0.1).timeout  # Short delay
    start_transition(true)  # Fade in