script.js

// =====================================================================================
// 1. GAME STATE & CORE ELEMENTS
// =====================================================================================

const gameOutput = document.getElementById('game-output');
const commandInput = document.getElementById('command-input');
const submitButton = document.getElementById('submit-command');

// Player Data
const player = {
    health: 100,
    maxHealth: 100,
    stamina: 50,     // NEW: For special combat abilities
    maxStamina: 50,  // NEW: For special combat abilities
    inventory: {
        wood: 0,
        stone: 0,
        ironOre: 0,
        leather: 0,
        fish: 0,
        coal: 0,
        healthPotion: 0, // NEW: Added Health Potion for 'use' command
        // Crafted items / Tools
        woodenAxe: 0,
        stonePickaxe: 0,
        ironSword: 0,
        fishingRod: 0
    },
    equippedWeapon: null,
    stats: {
        strength: 1, // Base damage multiplier
        gatheringEfficiency: 1, // Resource gain multiplier
        luck: 1 // Chance for rare drops, etc.
    },
    location: 'forest', // Starting location
    currentEnemy: null, // Holds the enemy object if in combat
    factories: {}, // Stores data for built factories
    isBlocking: false, // NEW: State for 'block' command
    cooldowns: { // NEW: Object to track ability cooldowns in turns (0 means ready)
        strongAttack: 0,
        stun: 0,
        // Add more abilities here
    }
};


// =====================================================================================
// 2. GAME DATA DEFINITIONS (Highly Modular - Add/Modify easily)
// =====================================================================================

// --- Locations ---
// Define locations and what can be done there, and where you can go from there.
const locations = {
    forest: {
        name: "Forest",
        description: "A dense forest. You can 'chop' trees here or 'explore' for secrets.",
        actions: ['chop', 'explore'],
        canGoTo: ['clearing', 'mountain_path']
    },
    clearing: {
        name: "Clearing",
        description: "A peaceful clearing. A good place to 'rest' or 'explore'. You see a river nearby.",
        actions: ['rest', 'explore', 'fish', 'buildBridge'], // NEW: Added buildBridge action
        canGoTo: ['forest', 'river']
        // 'town_center' will be added here dynamically
    },
    mountain_path: {
        name: "Mountain Path",
        description: "A rugged path leading up a mountain. You can 'mine' rocks here.",
        actions: ['mine', 'explore'],
        canGoTo: ['forest', 'mountain_peak']
    },
    mountain_peak: {
        name: "Mountain Peak",
        description: "The windy peak of the mountain. You can 'mine' rare ores here, but it's dangerous.",
        actions: ['mine', 'explore'],
        canGoTo: ['mountain_path']
    },
    river: {
        name: "River",
        description: "A calm river flows here. You might be able to 'fish'.",
        actions: ['fish', 'explore'],
        canGoTo: ['clearing']
    },
    town_center: { // NEW: A locked location
        name: "Town Center",
        description: "A bustling town, full of merchants and opportunities.",
        actions: ['explore', 'rest'],
        canGoTo: ['clearing']
    }
    // Add more locations here!
    // town: { ... }
};

// --- Recipes ---
// Define what items can be crafted, their requirements, and what they give.
const recipes = {
    woodenAxe: {
        name: "Wooden Axe",
        requires: { wood: 5 },
        gives: { woodenAxe: 1 },
        description: "A basic axe for chopping wood more efficiently.",
        type: 'tool'
    },
    stonePickaxe: {
        name: "Stone Pickaxe",
        requires: { wood: 3, stone: 5 },
        gives: { stonePickaxe: 1 },
        description: "A sturdy pickaxe for mining rocks.",
        type: 'tool'
    },
    ironSword: {
        name: "Iron Sword",
        requires: { ironOre: 5, wood: 2 },
        gives: { ironSword: 1 },
        description: "A decent iron sword for combat.",
        type: 'weapon',
        damage: 15 // Base damage for this weapon
    },
    basicFishingRod: {
        name: "Basic Fishing Rod",
        requires: { wood: 4, leather: 1 },
        gives: { fishingRod: 1 },
        description: "A simple rod for catching fish."
    },
    healthPotion: { // NEW: Health Potion recipe
        name: "Health Potion",
        requires: { fish: 1, wood: 1 }, // Simple ingredients for now
        gives: { healthPotion: 1 },
        description: "A simple potion that restores some health.",
        type: 'consumable'
    }
    // Add more recipes here!
};

// --- Enemies ---
// Define enemy types, their stats, and what they drop.
const enemies = {
    goblin: {
        name: "Goblin",
        health: 20,
        damage: 5,
        drops: { wood: 1, stone: 1 },
        description: "A small, mischievous creature.",
        spawnChance: 0.3 // Chance to encounter when exploring
    },
    wolf: {
        name: "Wolf",
        health: 30,
        damage: 8,
        drops: { leather: 2 },
        description: "A hungry, aggressive wolf.",
        spawnChance: 0.2
    },
    rockGolem: {
        name: "Rock Golem",
        health: 50,
        damage: 12,
        drops: { stone: 5, ironOre: 1 },
        description: "A creature made of solid rock. Found in mountains.",
        spawnChance: 0.1,
        canSpawnIn: ['mountain_path', 'mountain_peak'] // Specific spawn location
    }
    // Add more enemies here!
};

// --- Items (for general properties, not just crafting) ---
const items = {
    wood: { name: "Wood", type: "resource" },
    stone: { name: "Stone", type: "resource" },
    ironOre: { name: "Iron Ore", type: "resource" },
    leather: { name: "Leather", type: "resource" },
    fish: { name: "Fish", type: "resource" },
    coal: { name: "Coal", type: "resource" },
    healthPotion: { name: "Health Potion", type: "consumable", heals: 30 }, // NEW: Health Potion item
    woodenAxe: { name: "Wooden Axe", type: "tool", efficiencyBonus: 1.5, toolFor: 'chop' },
    stonePickaxe: { name: "Stone Pickaxe", type: "tool", efficiencyBonus: 1.8, toolFor: 'mine' },
    ironSword: { name: "Iron Sword", type: "weapon", damage: 15 },
    fishingRod: { name: "Fishing Rod", type: "tool", toolFor: 'fish' }
    // Add more item details if needed (e.g., value, healing properties)
};

// --- Factories ---
// Define types of factories, their costs, and what they passively produce
const factories = {
    lumberMill: {
        name: "Lumber Mill",
        description: "Produces wood over time.",
        buildRequires: { wood: 50, stone: 20 },
        produces: { wood: 10 },
        productionTimeMinutes: 1,
        builtInLocation: ['forest', 'clearing']
    },
    stoneQuarry: {
        name: "Stone Quarry",
        description: "Produces stone over time.",
        buildRequires: { wood: 30, stone: 50, ironOre: 5 },
        produces: { stone: 15 },
        productionTimeMinutes: 2,
        builtInLocation: ['mountain_path', 'mountain_peak']
    },
    coalMine: {
        name: "Coal Mine",
        description: "Produces coal passively.",
        buildRequires: { wood: 70, stone: 70, ironOre: 10 },
        produces: { coal: 5 },
        productionTimeMinutes: 3,
        builtInLocation: ['mountain_path', 'mountain_peak']
    }
};

// --- Unlocked Areas Data (NEW) ---
// Define new areas that can be unlocked by giving resources.
const unlockedAreas = {
    town_center: {
        name: "Town Center Path", // Name used in command (e.g., 'buildBridge town_center')
        description: "Building a bridge to unlock the main Town.",
        requires: { wood: 100, stone: 50, ironOre: 10 },
        unlocksLocation: 'town_center',
        unlockingLocation: 'clearing', // Where this can be done
        unlocked: false // Player state, set to true after unlocking
    }
    // Add more unlockable areas here!
    // ancient_temple: { name: "Ancient Temple Entrance", requires: { gold: 20 }, unlocksLocation: 'ancient_temple', unlockingLocation: 'desert', unlocked: false }
};

// --- Combat Abilities (NEW) ---
// Define special combat moves.
const combatAbilities = {
    strongAttack: {
        name: "Strong Attack",
        description: "A powerful blow that deals more damage.",
        staminaCost: 20,
        damageMultiplier: 1.5,
        cooldown: 3, // Cooldown in turns
        effects: [] // Can add status effects here later
    },
    block: {
        name: "Block",
        description: "You brace yourself, heavily reducing incoming damage next turn.",
        staminaCost: 10,
        cooldown: 2 // Cannot block every turn
    },
    stun: {
        name: "Stun",
        description: "Attempt to stun the enemy, making them lose a turn. Low chance.",
        staminaCost: 30,
        cooldown: 5,
        successChance: 0.3 // 30% chance to stun
    },
    focus: { // This one acts as a counter-intuitive healing option
        name: "Focus",
        description: "Regain stamina and reduce cooldowns, but leaves you vulnerable.",
        staminaGain: 20,
        vulnerability: 0.5, // Enemy deals 50% more damage next turn
        cooldown: 4
    }
    // 'sprint' (new flee) does not need an entry here, it's a direct action
};


// =====================================================================================
// 3. UTILITY FUNCTIONS
// =====================================================================================

// Display messages in the game output area
function output(text, type = 'info') {
    const p = document.createElement('p');
    p.classList.add(`text-${type}`);
    p.textContent = `> ${text}`;
    gameOutput.appendChild(p);
    gameOutput.scrollTop = gameOutput.scrollHeight; // Auto-scroll to bottom
}

// Clear the input field after command
function clearInput() {
    commandInput.value = '';
}

// Get player's current weapon damage
function getPlayerDamage() {
    let baseDamage = player.stats.strength * 5; // Base damage from strength
    if (player.equippedWeapon && recipes[player.equippedWeapon] && recipes[player.equippedWeapon].damage) {
        baseDamage += recipes[player.equippedWeapon].damage;
    } else {
        baseDamage += 2; // Bare hands damage
    }
    return baseDamage;
}

// Function to check if player has a required tool for an action
function hasTool(actionType) {
    for (const toolKey in player.inventory) {
        if (player.inventory[toolKey] > 0 && items[toolKey] && items[toolKey].toolFor === actionType) {
            return toolKey; // Return the key of the tool found
        }
    }
    return null; // No suitable tool found
}

// Get tool efficiency bonus
function getToolEfficiency(actionType) {
    const tool = hasTool(actionType);
    if (tool && items[tool] && items[tool].efficiencyBonus) {
        return items[tool].efficiencyBonus;
    }
    return 1; // No bonus if no tool or tool has no efficiencyBonus
}

// Helper to find data key (recipe, item, factory, etc.) by case-insensitive name
function findDataKey(inputName, dataObject) {
    const lowerInput = inputName.toLowerCase();
    for (const key in dataObject) {
        if (key.toLowerCase() === lowerInput || (dataObject[key].name && dataObject[key].name.toLowerCase() === lowerInput)) {
            return key; // Return the actual key (e.g., 'basicFishingRod', 'lumberMill', 'ironSword')
        }
    }
    return null; // Not found
}


// --- Combat Specific Utilities (NEW) ---

// Handles the enemy's turn in combat
function enemyTurn() {
    if (!player.currentEnemy) return; // Should not happen if called correctly

    // Decrement player's active cooldowns
    for (const ability in player.cooldowns) {
        if (player.cooldowns[ability] > 0) {
            player.cooldowns[ability]--;
        }
    }

    // Handle effects like stun
    if (player.currentEnemy.isStunned) {
        output(`The ${player.currentEnemy.name} is stunned and skips its turn!`, 'highlight');
        player.currentEnemy.isStunned = false; // Stun wears off after one turn
        return; // Skip enemy attack
    }

    // Calculate enemy damage
    let enemyDamage = player.currentEnemy.damage;
    if (player.isBlocking) {
        enemyDamage = Math.max(1, enemyDamage - Math.floor(player.maxHealth * 0.2)); // Reduce damage by 20% of max health, minimum 1
        output(`Your block reduces the ${player.currentEnemy.name}'s attack!`, 'info');
        player.isBlocking = false; // Block only lasts for one turn
    }

    if (player.isVulnerable) { // For 'focus' vulnerability
        enemyDamage = Math.floor(enemyDamage * (1 + combatAbilities.focus.vulnerability));
        output(`Your focus leaves you open! The ${player.currentEnemy.name} deals more damage!`, 'warning');
        player.isVulnerable = false; // Vulnerability lasts one turn
    }


    player.health -= enemyDamage;
    output(`The ${player.currentEnemy.name} attacks you for ${enemyDamage} damage! Your health: ${player.health}/${player.maxHealth}.`, 'danger');

    // Check if player died
    if (player.health <= 0) {
        output("You have been defeated...", 'danger');
        output("GAME OVER", 'danger');
        output("Type 'start' to play again.", 'highlight');
        endCombat();
        commandInput.disabled = true;
        submitButton.disabled = true;
        return;
    }
}

// Ends the current combat encounter
function endCombat() {
    if (player.currentEnemy) {
        output(`Combat with ${player.currentEnemy.name} has ended.`, 'highlight');
        player.currentEnemy = null; // Clear enemy
    }
    player.isBlocking = false; // Clear any combat-related flags
    player.isVulnerable = false;
    // Keep cooldowns, they are based on turns and persist
}

// Central function to be called after a player combat action (like attack, block, etc.)
function startCombatTurn() {
    // Check if enemy died from player's action
    if (player.currentEnemy.health <= 0) {
        output(`You defeated the ${player.currentEnemy.name}!`, 'success');
        output("--- Loot ---", 'highlight');
        let droppedAny = false;
        for (const dropItem in player.currentEnemy.drops) {
            const amount = player.currentEnemy.drops[dropItem];
            player.inventory[dropItem] = (player.inventory[dropItem] || 0) + amount;
            output(`You gained ${amount} ${items[dropItem]?.name || dropItem}.`, 'info');
            droppedAny = true;
        }
        if (!droppedAny) {
            output("The enemy dropped nothing.", 'info');
        }
        endCombat();
        return; // Combat over, no enemy turn
    }

    // If enemy is not defeated, it's their turn
    enemyTurn();
}


// =====================================================================================
// 4. GAME ACTIONS (Highly Modular - Add new commands here)
// =====================================================================================

const gameActions = {
    // --- BASIC COMMANDS ---
    help: (args) => {
        output("Available commands:", 'highlight');
        output("  'help' - Shows this list.", 'info');
        output("  'status' - Check your health, stamina, and location.", 'info');
        output("  'inventory' or 'inv' - Check your resources and items.", 'info');
        output("  'go <location_name>' - Travel to a new location (e.g., 'go clearing').", 'info');
        output("  'look' - Get a description of your current location.", 'info');
        output("  'clear' - Clear the game log.", 'info');
        output("  'craft <recipe_name>' - Create an item (e.g., 'craft woodenAxe').", 'info');
        output("  'recipes' - See all craftable recipes.", 'info');
        output("  'equip <weapon_name>' - Equip a weapon from your inventory (e.g., 'equip ironSword').", 'info');
        output("  'unequip' - Unequip your current weapon.", 'info');
        output("  'use <item_name>' - Use a consumable item (e.g., 'use healthPotion').", 'info');
        output("  'build <factory_name>' - Build a passive resource factory.", 'info');
        output("  'factories' - See your built factories and their production status.", 'info');
        output("  'collect <factory_name>' - Collect resources from a built factory.", 'info');

        const currentLoc = locations[player.location];
        if (currentLoc && currentLoc.actions) {
            output(`\nActions available in ${currentLoc.name}:`, 'highlight');
            currentLoc.actions.forEach(action => {
                let description = '';
                if (action === 'chop') description = 'chop trees';
                else if (action === 'mine') description = 'mine rocks';
                else if (action === 'explore') description = 'explore area';
                else if (action === 'rest') description = 'recover health and stamina';
                else if (action === 'fish') description = 'try to catch fish';
                else if (action === 'buildBridge') description = 'try to build a bridge to a new area'; // NEW help for unlock

                if (description) {
                    output(`  '${action}' - ${description}.`, 'info');
                } else {
                    output(`  '${action}' - Perform this action.`, 'info'); // Fallback for undefined actions
                }
            });
        }

        if (player.currentEnemy) {
            output("\nCombat commands (only available in combat):", 'highlight');
            output("  'attack' - Attack the current enemy.", 'info');
            output("  'block' - Reduce incoming damage this turn (costs stamina, has cooldown).", 'info'); // NEW
            output("  'strongattack' - A powerful attack (costs stamina, has cooldown).", 'info'); // NEW
            output("  'stun' - Attempt to stun the enemy (costs stamina, has cooldown, low chance).", 'info'); // NEW
            output("  'inspect' - Get more info about the enemy (no turn cost).", 'info'); // NEW
            output("  'focus' - Regain stamina, but take more damage next turn (has cooldown).", 'info'); // NEW
            output("  'sprint' - Escape from combat (guaranteed flee, takes a turn, no cooldown).", 'info'); // NEW
        }
    },

    status: (args) => {
        output("--- Your Status ---", 'highlight');
        output(`Health: ${player.health}/${player.maxHealth}`, player.health < player.maxHealth / 4 ? 'danger' : 'info');
        output(`Stamina: ${player.stamina}/${player.maxStamina}`, player.stamina < player.maxStamina / 4 ? 'warning' : 'info'); // NEW
        output(`Location: ${locations[player.location]?.name || 'Unknown'}`, 'info');
        output(`Equipped: ${player.equippedWeapon ? items[player.equippedWeapon]?.name || player.equippedWeapon : 'None'}`, 'info');
        output(`Strength: ${player.stats.strength}`, 'info');
        output(`Gathering Efficiency: ${player.stats.gatheringEfficiency}`, 'info');
        output(`Luck: ${player.stats.luck}`, 'info');

        let cooldownInfo = '';
        for (const ability in player.cooldowns) {
            if (player.cooldowns[ability] > 0) {
                if (cooldownInfo) cooldownInfo += ', ';
                cooldownInfo += `${combatAbilities[ability]?.name || ability}: ${player.cooldowns[ability]} turns`;
            }
        }
        if (cooldownInfo) {
            output(`Cooldowns: ${cooldownInfo}`, 'info');
        }
        output("-------------------", 'highlight');
    },

    inventory: (args) => {
        output("--- Your Inventory ---", 'highlight');
        let empty = true;
        for (const item in player.inventory) {
            if (player.inventory[item] > 0) {
                output(`${items[item]?.name || item}: ${player.inventory[item]}`, 'info');
                empty = false;
            }
        }
        if (empty) {
            output("Your inventory is empty.", 'info');
        }
        output("--------------------", 'highlight');
    },
    inv: (args) => gameActions.inventory(args), // Alias for inventory

    look: (args) => {
        const currentLoc = locations[player.location];
        if (currentLoc) {
            output(`You are in the ${currentLoc.name}.`, 'highlight');
            output(currentLoc.description, 'info');
            const exits = currentLoc.canGoTo.map(loc => locations[loc]?.name || loc).join(', ');
            output(`From here, you can go to: ${exits}.`, 'info');
        } else {
            output("You are in an unknown place.", 'danger');
        }
    },

    clear: (args) => {
        gameOutput.innerHTML = ''; // Clears the output log
        output("Game log cleared.", 'info');
    },

    // --- MOVEMENT COMMANDS ---
    go: (args) => {
        if (player.currentEnemy) {
            output("You can't move while in combat! 'sprint' to flee or 'attack'.", 'warning');
            return;
        }
        const targetLocationKey = args[0]; // Already lowercased from processCommand
        if (!targetLocationKey) {
            output("Go where? (e.g., 'go forest')", 'warning');
            return;
        }

        const currentLoc = locations[player.location];
        if (!currentLoc) {
            output("Your current location is unknown.", 'danger');
            return;
        }

        if (currentLoc.canGoTo.includes(targetLocationKey) && locations[targetLocationKey]) {
            player.location = targetLocationKey;
            output(`You travel to the ${locations[targetLocationKey].name}.`, 'success');
            gameActions.look(); // Show description of new location
        } else {
            output(`You cannot go to '${targetLocationKey}' from here.`, 'warning');
        }
    },

    // --- GATHERING COMMANDS ---
    chop: (args) => {
        if (player.currentEnemy) { output("You can't gather while in combat!", 'warning'); return; }
        const currentLoc = locations[player.location];
        if (!currentLoc || !currentLoc.actions.includes('chop')) {
            output("You can't chop trees here.", 'warning');
            return;
        }

        const tool = hasTool('chop');
        if (!tool) {
            output("You need an axe to chop trees effectively! Craft one with 'craft woodenAxe'.", 'warning');
            return;
        }

        const amount = Math.floor(5 * player.stats.gatheringEfficiency * getToolEfficiency('chop'));
        player.inventory.wood += amount;
        output(`You chop some trees and gain ${amount} wood. You now have ${player.inventory.wood} wood.`, 'success');
    },

    mine: (args) => {
        if (player.currentEnemy) { output("You can't gather while in combat!", 'warning'); return; }
        const currentLoc = locations[player.location];
        if (!currentLoc || !currentLoc.actions.includes('mine')) {
            output("You can't mine rocks here.", 'warning');
            return;
        }

        const tool = hasTool('mine');
        if (!tool) {
            output("You need a pickaxe to mine rocks effectively! Craft one with 'craft stonePickaxe'.", 'warning');
            return;
        }

        const amount = Math.floor(3 * player.stats.gatheringEfficiency * getToolEfficiency('mine'));
        player.inventory.stone += amount;
        output(`You mine some rocks and gain ${amount} stone. You now have ${player.inventory.stone} stone.`, 'success');

        if (player.location.includes('mountain')) {
            if (Math.random() < 0.2 * player.stats.luck) {
                const ironAmount = Math.floor(1 * player.stats.gatheringEfficiency * getToolEfficiency('mine'));
                player.inventory.ironOre += ironAmount;
                output(`You found ${ironAmount} Iron Ore while mining!`, 'highlight');
            }
        }
    },

    fish: (args) => {
        if (player.currentEnemy) { output("You can't gather while in combat!", 'warning'); return; }
        const currentLoc = locations[player.location];
        if (!currentLoc || !currentLoc.actions.includes('fish')) {
            output("There's no water to fish in here.", 'warning');
            return;
        }

        const tool = hasTool('fish');
        if (!tool) {
            output("You need a fishing rod to fish! Craft one with 'craft basicFishingRod'.", 'warning');
            return;
        }

        if (Math.random() < 0.7) {
            const fishAmount = Math.floor(1 + Math.random() * player.stats.gatheringEfficiency);
            player.inventory.fish += fishAmount;
            output(`You cast your line and catch ${fishAmount} fish! You now have ${player.inventory.fish} fish.`, 'success');
        } else {
            output("You waited patiently, but nothing bit this time.", 'info');
        }
    },

    rest: (args) => {
        if (player.currentEnemy) { output("You can't rest while in combat!", 'warning'); return; }
        const currentLoc = locations[player.location];
        if (!currentLoc || !currentLoc.actions.includes('rest')) {
            output("You can't rest here.", 'warning');
            return;
        }

        const healthRecovered = Math.min(player.maxHealth - player.health, 20);
        player.health += healthRecovered;
        const staminaRecovered = Math.min(player.maxStamina - player.stamina, 20); // NEW: Recover stamina
        player.stamina += staminaRecovered;


        if (healthRecovered > 0 || staminaRecovered > 0) {
            output(`You rest for a while and recover ${healthRecovered} health and ${staminaRecovered} stamina.`, 'success');
            output(`Your health: ${player.health}/${player.maxHealth}. Your stamina: ${player.stamina}/${player.maxStamina}.`, 'info');
        } else {
            output("You are already at full health and stamina.", 'info');
        }

        // Clear all cooldowns for resting
        for (const ability in player.cooldowns) {
            player.cooldowns[ability] = 0;
        }
        if (healthRecovered > 0 || staminaRecovered > 0) {
            output("All combat cooldowns are reset after resting.", 'highlight');
        }
    },

    // --- CRAFTING & EQUIPMENT COMMANDS ---
    recipes: (args) => {
        output("--- Available Recipes ---", 'highlight');
        let anyRecipes = false;
        for (const recipeKey in recipes) {
            anyRecipes = true;
            const recipe = recipes[recipeKey];
            output(`\n** ${recipe.name} **`, 'special');
            output(`  ${recipe.description}`, 'info');

            let requiresText = "  Requires: ";
            const requiredItems = [];
            for (const reqItemKey in recipe.requires) {
                const requiredAmount = recipe.requires[reqItemKey];
                const itemName = items[reqItemKey]?.name || reqItemKey;
                requiredItems.push(`${requiredAmount} ${itemName} (you have ${player.inventory[reqItemKey] || 0})`);
            }
            output(requiresText + (requiredItems.length > 0 ? requiredItems.join(', ') : 'None'), 'info');

            let givesText = "  Gives: ";
            const givesItems = [];
            for (const giveItemKey in recipe.gives) {
                const givenAmount = recipe.gives[giveItemKey];
                const itemName = items[giveItemKey]?.name || giveItemKey;
                givesItems.push(`${givenAmount} ${itemName}`);
            }
            output(givesText + givesItems.join(', '), 'info');
        }

        if (!anyRecipes) {
            output("No recipes are defined.", 'warning');
        }
        output("\n--------------------", 'highlight');
        output("Use 'craft <recipe_name>' (e.g., 'craft woodenAxe').", 'info');
    },

    craft: (args) => {
        if (player.currentEnemy) { output("You can't craft while in combat!", 'warning'); return; }
        const inputRecipeName = args[0];
        if (!inputRecipeName) {
            output("What do you want to craft? (e.g., 'craft woodenAxe')", 'warning');
            output("Type 'recipes' to see all available recipes.", 'info');
            return;
        }

        const recipeKey = findDataKey(inputRecipeName, recipes);
        if (!recipeKey) {
            output(`Unknown recipe: '${inputRecipeName}'. Type 'recipes' to see options.`, 'danger');
            return;
        }
        const recipe = recipes[recipeKey];

        output(`Attempting to craft ${recipe.name}...`, 'info');
        let canCraft = true;
        for (const resource in recipe.requires) {
            if ((player.inventory[resource] || 0) < recipe.requires[resource]) {
                output(`You need ${recipe.requires[resource]} ${items[resource]?.name || resource}, but you only have ${player.inventory[resource] || 0}.`, 'danger');
                canCraft = false;
            }
        }

        if (canCraft) {
            for (const resource in recipe.requires) {
                player.inventory[resource] -= recipe.requires[resource];
            }
            for (const item in recipe.gives) {
                player.inventory[item] = (player.inventory[item] || 0) + recipe.gives[item];
                output(`You successfully crafted a ${recipe.name}!`, 'success');
            }
        } else {
            output(`Failed to craft ${recipe.name}. Missing resources.`, 'warning');
        }
    },

    equip: (args) => {
        if (player.currentEnemy) { output("You can't equip while in combat!", 'warning'); return; }
        const itemName = args[0];
        if (!itemName) {
            output("What do you want to equip? (e.g., 'equip ironSword')", 'warning');
            return;
        }

        const itemToEquipKey = findDataKey(itemName, items);
        if (!itemToEquipKey) {
            output(`Unknown item: '${itemName}'.`, 'danger');
            return;
        }

        const itemToEquip = items[itemToEquipKey];
        if (itemToEquip.type !== 'weapon') {
            output(`You can't equip '${itemToEquip.name}' or it's not a weapon.`, 'warning');
            return;
        }
        if (player.inventory[itemToEquipKey] === 0) {
            output(`You don't have a '${itemToEquip.name}' in your inventory.`, 'warning');
            return;
        }

        player.equippedWeapon = itemToEquipKey;
        output(`You equipped the ${itemToEquip.name}.`, 'success');
    },

    unequip: (args) => {
        if (player.currentEnemy) { output("You can't unequip while in combat!", 'warning'); return; }
        if (!player.equippedWeapon) {
            output("You don't have anything equipped.", 'info');
            return;
        }
        output(`You unequipped your ${items[player.equippedWeapon]?.name || player.equippedWeapon}.`, 'success');
        player.equippedWeapon = null;
    },

    use: (args) => {
        const itemName = args[0];
        if (!itemName) {
            output("What do you want to use? (e.g., 'use healthPotion')", 'warning');
            return;
        }

        const itemToUseKey = findDataKey(itemName, items);
        if (!itemToUseKey) {
            output(`Unknown item: '${itemName}'.`, 'danger');
            return;
        }

        const itemToUse = items[itemToUseKey];

        if (player.inventory[itemToUseKey] === 0) {
            output(`You don't have any '${itemToUse.name}'.`, 'warning');
            return;
        }

        // --- Handle consumable type items ---
        if (itemToUse.type === 'consumable') {
            if (itemToUse.heals) {
                const amountHealed = Math.min(itemToUse.heals, player.maxHealth - player.health);
                if (amountHealed <= 0) {
                    output("You are already at full health.", 'info');
                    return;
                }
                player.health += amountHealed;
                player.inventory[itemToUseKey]--;
                output(`You used a ${itemToUse.name} and recovered ${amountHealed} health! Your health is now ${player.health}/${player.maxHealth}.`, 'success');

                // If in combat, this consumes a turn
                if (player.currentEnemy) {
                    output(`(Using the ${itemToUse.name} takes your turn)`, 'info');
                    startCombatTurn();
                }
            } else {
                output(`You can't 'use' the '${itemToUse.name}' in that way.`, 'warning');
            }
        } else {
            output(`You can't 'use' the '${itemToUse.name}'. It's not a consumable item.`, 'warning');
        }
    },


    // --- FACTORY COMMANDS ---
    build: (args) => {
        if (player.currentEnemy) { output("You can't build while in combat!", 'warning'); return; }
        const inputFactoryName = args[0];
        if (!inputFactoryName) {
            output("What do you want to build? (e.g., 'build lumberMill')", 'warning');

            output("\n--- Buildable Factories ---", 'highlight');
            let anyFactories = false;
            for (const factoryKey in factories) {
                anyFactories = true;
                const factory = factories[factoryKey];
                let requiresText = "Requires: ";
                const requiredItems = [];
                for (const reqItemKey in factory.buildRequires) {
                    const requiredAmount = factory.buildRequires[reqItemKey];
                    const itemName = items[reqItemKey]?.name || reqItemKey;
                    requiredItems.push(`${requiredAmount} ${itemName} (you have ${player.inventory[reqItemKey] || 0})`);
                }
                output(`\n** ${factory.name} ** (${factory.description})`, 'special');
                output(`  ${requiresText} ${requiredItems.join(', ')}`, 'info');
                output(`  Can be built in: ${factory.builtInLocation.map(loc => locations[loc]?.name || loc).join(', ')}`, 'info');
                output(`  Produces: ${factory.produces ? Object.keys(factory.produces).map(res => `${factory.produces[res]} ${items[res]?.name || res}`).join(', ') : 'Nothing'} every ${factory.productionTimeMinutes} min.`, 'info');
            }
            if (!anyFactories) {
                output("No factories are defined to build.", 'warning');
            }
            output("--------------------------", 'highlight');
            return;
        }

        const factoryKey = findDataKey(inputFactoryName, factories);
        if (!factoryKey) {
            output(`Unknown factory type: '${inputFactoryName}'.`, 'danger');
            return;
        }

        const factoryToBuild = factories[factoryKey];

        if (player.factories[factoryKey]) {
            output(`You already have a ${factoryToBuild.name}! You can only build one of each type.`, 'warning');
            return;
        }

        if (!factoryToBuild.builtInLocation.includes(player.location)) {
            output(`You cannot build a ${factoryToBuild.name} in the ${locations[player.location]?.name || 'current location'}. It can only be built in: ${factoryToBuild.builtInLocation.map(loc => locations[loc]?.name || loc).join(', ')}.`, 'warning');
            return;
        }

        output(`Attempting to build a ${factoryToBuild.name}...`, 'info');
        let canBuild = true;
        for (const resource in factoryToBuild.buildRequires) {
            if ((player.inventory[resource] || 0) < factoryToBuild.buildRequires[resource]) {
                output(`You need ${factoryToBuild.buildRequires[resource]} ${items[resource]?.name || resource}, but you only have ${player.inventory[resource] || 0}.`, 'danger');
                canBuild = false;
            }
        }

        if (canBuild) {
            for (const resource in factoryToBuild.buildRequires) {
                player.inventory[resource] -= factoryToBuild.buildRequires[resource];
            }
            player.factories[factoryKey] = {
                builtTime: Date.now(),
                lastCollectedTime: Date.now() // Start collection timer now
            };
            output(`You successfully built a ${factoryToBuild.name}! It has begun passive production.`, 'success');
        } else {
            output(`Failed to build ${factoryToBuild.name}. Missing resources.`, 'warning');
        }
    },

    factories: (args) => {
        output("--- Your Factories ---", 'highlight');
        let empty = true;
        for (const factoryKey in player.factories) {
            empty = false;
            const factoryStatus = player.factories[factoryKey];
            const factoryDef = factories[factoryKey];
            if (!factoryDef) continue; // Should not happen if data is consistent

            output(`\n** ${factoryDef.name} **`, 'special');

            const now = Date.now();
            const elapsedTimeMillis = now - factoryStatus.lastCollectedTime;
            const cycleMillis = factoryDef.productionTimeMinutes * 60 * 1000;
            const cyclesCompleted = Math.floor(elapsedTimeMillis / cycleMillis);

            let producedInfo = [];
            if (cyclesCompleted > 0) {
                for (const prodItem in factoryDef.produces) {
                    const totalProduced = factoryDef.produces[prodItem] * cyclesCompleted;
                    producedInfo.push(`${totalProduced} ${items[prodItem]?.name || prodItem}`);
                }
                output(`  Ready to collect: ${producedInfo.join(', ')}`, 'highlight');
            } else {
                const millisUntilNext = cycleMillis - (elapsedTimeMillis % cycleMillis);
                const secondsUntilNext = Math.ceil(millisUntilNext / 1000);
                output(`  Next collection ready in: ${Math.floor(secondsUntilNext / 60)} min ${secondsUntilNext % 60} sec.`, 'info');
                output(`  (Collects: ${Object.keys(factoryDef.produces).map(res => `${factoryDef.produces[res]} ${items[res]?.name || res}`).join(', ')})`, 'info');
            }
            output(`  Last Collected: ${new Date(factoryStatus.lastCollectedTime).toLocaleString()}`, 'info');
        }
        if (empty) {
            output("You have not built any factories yet.", 'info');
            output("Use 'build' to see available options.", 'info');
        }
        output("\n--------------------", 'highlight');
    },

    collect: (args) => {
        if (player.currentEnemy) { output("You can't collect while in combat!", 'warning'); return; }
        const inputFactoryName = args[0];
        if (!inputFactoryName) {
            output("Collect from which factory? (e.g., 'collect lumberMill')", 'warning');
            output("Use 'factories' to see your built factories.", 'info');
            return;
        }

        const factoryKey = findDataKey(inputFactoryName, factories);
        if (!factoryKey) {
            output(`Unknown factory: '${inputFactoryName}'.`, 'danger');
            return;
        }

        const factoryDef = factories[factoryKey];
        const factoryStatus = player.factories[factoryKey];

        if (!factoryStatus) {
            output(`You don't own a ${factoryDef.name}. Build it first with 'build ${factoryKey}'.`, 'warning');
            return;
        }

        const now = Date.now();
        const elapsedTimeMillis = now - factoryStatus.lastCollectedTime;
        const cycleMillis = factoryDef.productionTimeMinutes * 60 * 1000;
        const cyclesCompleted = Math.floor(elapsedTimeMillis / cycleMillis);

        if (cyclesCompleted === 0) {
            const millisUntilNext = cycleMillis - (elapsedTimeMillis % cycleMillis);
            const secondsUntilNext = Math.ceil(millisUntilNext / 1000);
            output(`Your ${factoryDef.name} is not ready for collection yet. Next ready in ${Math.floor(secondsUntilNext / 60)} min ${secondsUntilNext % 60} sec.`, 'info');
            return;
        }

        output(`Collecting from your ${factoryDef.name}...`, 'info');
        let collectedAny = false;
        for (const prodItem in factoryDef.produces) {
            const totalProduced = factoryDef.produces[prodItem] * cyclesCompleted;
            player.inventory[prodItem] = (player.inventory[prodItem] || 0) + totalProduced;
            output(`You collected ${totalProduced} ${items[prodItem]?.name || prodItem}.`, 'success');
            collectedAny = true;
        }

        if (collectedAny) {
            player.factories[factoryKey].lastCollectedTime = factoryStatus.lastCollectedTime + (cyclesCompleted * cycleMillis);
            output(`${cyclesCompleted} production cycles collected!`, 'success');
        } else {
            output(`Your ${factoryDef.name} produced nothing this time.`, 'info');
        }
    },

    // --- AREA UNLOCKING COMMANDS (NEW) ---
    buildBridge: (args) => {
        if (player.currentEnemy) { output("You can't do that while in combat!", 'warning'); return; }
        if (player.location !== unlockedAreas.town_center.unlockingLocation) {
            output(`You need to be in the ${locations[unlockedAreas.town_center.unlockingLocation].name} to do this.`, 'warning');
            return;
        }

        const areaToUnlock = unlockedAreas.town_center; // Only one unlockable for now
        if (areaToUnlock.unlocked) {
            output(`The path to ${locations[areaToUnlock.unlocksLocation].name} is already clear!`, 'info');
            return;
        }

        output(`You consider building a bridge to the ${locations[areaToUnlock.unlocksLocation].name}.`, 'info');
        let requiresText = "This requires: ";
        const requiredItems = [];
        let canPay = true;
        for (const reqItemKey in areaToUnlock.requires) {
            const requiredAmount = areaToUnlock.requires[reqItemKey];
            const itemName = items[reqItemKey]?.name || reqItemKey;
            requiredItems.push(`${requiredAmount} ${itemName} (you have ${player.inventory[reqItemKey] || 0})`);
            if ((player.inventory[reqItemKey] || 0) < requiredAmount) {
                canPay = false;
            }
        }
        output(requiresText + requiredItems.join(', '), 'highlight');

        if (!canPay) {
            output("You don't have enough resources to build the bridge yet.", 'danger');
            return;
        }

        output("Are you sure you want to spend these resources to build the bridge? (Type 'yes' to confirm)", 'warning');
        commandInput.value = ''; // Clear for user confirmation
        commandInput.removeEventListener('keyup', commandListener); // Temporarily remove main listener
        submitButton.removeEventListener('click', buttonListener); // Temporarily remove main listener

        const confirmAction = (e) => {
            if (e.type === 'click' || e.key === 'Enter') {
                const confirmation = commandInput.value.toLowerCase().trim();
                clearInput();

                commandInput.removeEventListener('keyup', confirmAction);
                submitButton.removeEventListener('click', confirmAction);

                // Restore original listeners
                commandInput.addEventListener('keyup', commandListener);
                submitButton.addEventListener('click', buttonListener);

                if (confirmation === 'yes') {
                    for (const reqItemKey in areaToUnlock.requires) {
                        player.inventory[reqItemKey] -= areaToUnlock.requires[reqItemKey];
                    }
                    areaToUnlock.unlocked = true;
                    // Dynamically add to the source location's canGoTo
                    locations[areaToUnlock.unlockingLocation].canGoTo.push(areaToUnlock.unlocksLocation);
                    output(`You have successfully built the bridge! The path to the ${locations[areaToUnlock.unlocksLocation].name} is now open!`, 'success');
                    output(`You can now 'go ${areaToUnlock.unlocksLocation}'.`, 'info');
                } else {
                    output("Bridge building cancelled.", 'info');
                }
            }
        };

        commandInput.addEventListener('keyup', confirmAction);
        submitButton.addEventListener('click', confirmAction);
    },

    // --- COMBAT COMMANDS ---
    explore: (args) => {
        if (player.currentEnemy) {
            output("You are already in combat! 'attack' or 'sprint' to flee.", 'warning');
            return;
        }
        const currentLoc = locations[player.location];
        if (!currentLoc || !currentLoc.actions.includes('explore')) {
            output("You can't explore here.", 'warning');
            return;
        }

        output("You begin to explore the area...", 'info');

        let totalSpawnChance = 0;
        const potentialEnemies = [];
        for (const enemyKey in enemies) {
            const enemy = enemies[enemyKey];
            if (enemy.canSpawnIn && !enemy.canSpawnIn.includes(player.location)) {
                continue;
            }
            if (enemy.spawnChance) {
                potentialEnemies.push({ enemyKey, chance: enemy.spawnChance });
                totalSpawnChance += enemy.spawnChance;
            }
        }

        const rand = Math.random();
        let encounteredEnemy = null;
        let cumulativeChance = 0;

        for (const entry of potentialEnemies) {
            cumulativeChance += entry.chance / totalSpawnChance;
            if (rand < cumulativeChance) {
                encounteredEnemy = enemies[entry.enemyKey];
                break;
            }
        }

        if (encounteredEnemy) {
            player.currentEnemy = { ...encounteredEnemy, health: encounteredEnemy.health, isStunned: false }; // Ensure fresh combat instance + stun status
            output(`A wild ${player.currentEnemy.name} appears! (${player.currentEnemy.health} HP)`, 'danger');
            output(player.currentEnemy.description, 'danger');
            output("Type 'attack' to fight or 'sprint' to try to escape.", 'warning');
        } else {
            output("You explored the area but found nothing of interest.", 'info');
            if (Math.random() < 0.2) {
                const healthRecovered = Math.min(player.maxHealth - player.health, 5);
                if (healthRecovered > 0) {
                    player.health += healthRecovered;
                    output(`You found a quiet spot and rested for a moment, recovering ${healthRecovered} health.`, 'info');
                }
            }
        }
    },

    attack: (args) => {
        if (!player.currentEnemy) {
            output("There's no enemy to attack.", 'warning');
            return;
        }

        const playerDamage = getPlayerDamage();
        player.currentEnemy.health -= playerDamage;
        output(`You attack the ${player.currentEnemy.name} for ${playerDamage} damage!`, 'success');
        startCombatTurn();
    },

    // NEW COMBAT COMMANDS
    block: (args) => {
        if (!player.currentEnemy) { output("You are not in combat.", 'warning'); return; }
        const ability = combatAbilities.block;

        if (player.cooldowns.block > 0) {
            output(`Block is on cooldown! (${player.cooldowns.block} turns remaining)`, 'warning');
            return;
        }
        if (player.stamina < ability.staminaCost) {
            output(`Not enough stamina for ${ability.name}! (${ability.staminaCost} needed, you have ${player.stamina})`, 'warning');
            return;
        }

        player.stamina -= ability.staminaCost;
        player.isBlocking = true;
        player.cooldowns.block = ability.cooldown;
        output(`You prepare to block the next attack. Your stamina is now ${player.stamina}/${player.maxStamina}.`, 'info');
        startCombatTurn();
    },

    strongattack: (args) => {
        if (!player.currentEnemy) { output("You are not in combat.", 'warning'); return; }
        const ability = combatAbilities.strongAttack;

        if (player.cooldowns.strongAttack > 0) {
            output(`Strong Attack is on cooldown! (${player.cooldowns.strongAttack} turns remaining)`, 'warning');
            return;
        }
        if (player.stamina < ability.staminaCost) {
            output(`Not enough stamina for ${ability.name}! (${ability.staminaCost} needed, you have ${player.stamina})`, 'warning');
            return;
        }

        player.stamina -= ability.staminaCost;
        const playerDamage = getPlayerDamage() * ability.damageMultiplier;
        player.currentEnemy.health -= playerDamage;
        player.cooldowns.strongAttack = ability.cooldown;

        output(`You unleash a powerful blow on the ${player.currentEnemy.name} for ${playerDamage} damage!`, 'success');
        output(`Your stamina is now ${player.stamina}/${player.maxStamina}.`, 'info');
        startCombatTurn();
    },

    stun: (args) => {
        if (!player.currentEnemy) { output("You are not in combat.", 'warning'); return; }
        const ability = combatAbilities.stun;

        if (player.cooldowns.stun > 0) {
            output(`Stun is on cooldown! (${player.cooldowns.stun} turns remaining)`, 'warning');
            return;
        }
        if (player.stamina < ability.staminaCost) {
            output(`Not enough stamina for ${ability.name}! (${ability.staminaCost} needed, you have ${player.stamina})`, 'warning');
            return;
        }

        player.stamina -= ability.staminaCost;
        player.cooldowns.stun = ability.cooldown;

        if (Math.random() < ability.successChance) {
            player.currentEnemy.isStunned = true;
            output(`You successfully stunned the ${player.currentEnemy.name}! They will miss their next turn!`, 'success');
        } else {
            output(`You tried to stun the ${player.currentEnemy.name}, but failed!`, 'warning');
        }
        output(`Your stamina is now ${player.stamina}/${player.maxStamina}.`, 'info');
        startCombatTurn();
    },

    inspect: (args) => {
        if (!player.currentEnemy) { output("There's no enemy to inspect.", 'warning'); return; }
        output("--- Enemy Intel ---", 'highlight');
        output(`Name: ${player.currentEnemy.name}`, 'info');
        output(`Health: ${player.currentEnemy.health}/${enemies[findDataKey(player.currentEnemy.name, enemies)]?.health || '??'}`, 'info'); // Show original max HP too
        output(`Damage: ${player.currentEnemy.damage}`, 'info');
        output(`Description: ${player.currentEnemy.description}`, 'info');
        output("-------------------", 'highlight');
        // This action does NOT consume a turn, as per design
    },

    focus: (args) => {
        if (!player.currentEnemy) { output("You can only focus during combat.", 'warning'); return; }
        const ability = combatAbilities.focus;

        if (player.cooldowns.focus > 0) {
            output(`Focus is on cooldown! (${player.cooldowns.focus} turns remaining)`, 'warning');
            return;
        }

        player.stamina = Math.min(player.maxStamina, player.stamina + ability.staminaGain);
        player.isVulnerable = true; // Set vulnerability
        player.cooldowns.focus = ability.cooldown;

        output(`You clear your mind, regaining ${ability.staminaGain} stamina.`, 'success');
        output(`Your stamina is now ${player.stamina}/${player.maxStamina}.`, 'info');
        output("However, you feel vulnerable to the next attack!", 'warning');

        // Clear all *other* cooldowns immediately, but only in combat (not resting)
        for (const cd in player.cooldowns) {
            if (cd !== 'focus') player.cooldowns[cd] = 0; // Don't reset Focus itself
        }
        output("Other combat abilities instantly become ready!", 'highlight');
        startCombatTurn();
    },

    sprint: (args) => { // Replaces the original 'flee'
        if (!player.currentEnemy) {
            output("You are not in combat.", 'warning');
            return;
        }

        // A guaranteed flee, but consumes a turn (enemy still attacks)
        output(`You attempt to sprint away from the ${player.currentEnemy.name}!`, 'success');
        endCombat(); // Immediately end combat from player's perspective

        // After this, an immediate enemy turn happens before leaving "combat".
        // It's a bit of a trick for UI feedback.
        // For a more robust solution, 'sprint' could return true to indicate flee and bypass enemyTurn()
        // but for simplicity, let the enemy attack you one last time while you escape.
        enemyTurn(); // Enemy gets a final attack.
        if (player.health > 0) { // If player survived the last attack during flee
            output("You successfully escaped!", 'success');
        }
    },


    // --- GAME CONTROL ---
    start: (args) => {
        // Reset player state to initial values
        player.health = 100;
        player.maxHealth = 100;
        player.stamina = 50; // Reset stamina
        player.maxStamina = 50; // Reset max stamina
        player.inventory = {
            wood: 0,
            stone: 0,
            ironOre: 0,
            leather: 0,
            fish: 0,
            coal: 0,
            healthPotion: 0, // Reset health potions
            woodenAxe: 0,
            stonePickaxe: 0,
            ironSword: 0,
            fishingRod: 0
        };
        player.equippedWeapon = null;
        player.stats = {
            strength: 1,
            gatheringEfficiency: 1,
            luck: 1
        };
        player.location = 'forest';
        player.currentEnemy = null;
        player.factories = {}; // Reset factories
        player.isBlocking = false; // Reset combat flags
        player.isVulnerable = false; // Reset combat flags
        player.cooldowns = { // Reset all cooldowns
            strongAttack: 0,
            stun: 0,
            block: 0,
            focus: 0,
        };

        // Reset unlockable areas to their default state (unlocked: false)
        for (const key in unlockedAreas) {
            unlockedAreas[key].unlocked = false;
        }
        // IMPORTANT: Reset canGoTo for locations that change (e.g., clearing to town)
        locations.clearing.canGoTo = ['forest', 'river']; // Set back to initial exits


        gameOutput.innerHTML = ''; // Clear previous game log
        commandInput.disabled = false; // Re-enable input
        submitButton.disabled = false;

        output("--- Welcome to the Text Adventure RPG! ---", 'highlight');
        output("Your journey begins in a mysterious forest.", 'info');
        output("Type 'help' for a list of commands.", 'info');
        gameActions.look(); // Show starting location
    }
};


// =====================================================================================
// 5. COMMAND PROCESSING
// =====================================================================================

function processCommand(command) {
    if (!command) return;

    output(`> ${command}`, 'text-info'); // Echo command

    const parts = command.toLowerCase().trim().split(' ');
    const mainCommand = parts[0];
    const args = parts.slice(1); // Arguments will be lowercase here

    if (gameActions[mainCommand]) {
        gameActions[mainCommand](args);
    } else {
        output(`Unknown command: '${command}'. Type 'help' for a list of commands.`, 'danger');
    }

    clearInput();
}


// =====================================================================================
// 6. EVENT LISTENERS & INITIALIZATION
// =====================================================================================

// Event listeners need to be defined once to be toggled
const commandListener = (event) => {
    if (event.key === 'Enter') {
        processCommand(commandInput.value);
    }
};

const buttonListener = () => {
    processCommand(commandInput.value);
};

submitButton.addEventListener('click', buttonListener);
commandInput.addEventListener('keyup', commandListener);

// Initial game start when the page loads
gameActions.start();