make the full script

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Advanced Adventure Game</title>
    <style>
        body, html {
            margin: 0;
            padding: 0;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            background-color: #222;
            color: #fff;
            font-family: Arial, sans-serif;
            overflow: hidden;
        }
        
        #game-container {
            position: relative;
            width: 800px;
            height: 400px;
            background-color: #333;
            overflow: hidden;
            border: 2px solid #444;
        }

        #game-world {
            position: absolute;
            width: 2400px;
            height: 100%;
            transition: transform 0.1s linear;
        }

        #player {
            position: absolute;
            bottom: 0;
            left: 50px;
            width: 30px;
            height: 30px;
            background-color: #4CAF50;
            animation: idle 1s infinite alternate;
        }

        @keyframes idle {
            from { transform: translateY(0); }
            to { transform: translateY(2px); }
        }

        .character, .boss-door, .power-up, .enemy, .obstacle, .bullet, .burst, .boss, #friend, .coin, .flying-enemy, .charging-enemy, .stealth-enemy, .split-enemy, .sniper-enemy, .regen-enemy, .explosive-enemy, .teleporter-enemy, .mourning-enemy, .velocity-enemy, .sticky-enemy, .reflective-enemy {
            position: absolute;
        }

        .character, .king, .stealth-enemy, .split-enemy, .sniper-enemy, .regen-enemy, .explosive-enemy,
        .teleporter-enemy, .mourning-enemy, .velocity-enemy, .sticky-enemy, .reflective-enemy {
            border-radius: 50%;
        }

        .coin {
            width: 15px;
            height: 15px;
            background-color: #FFD700;
            border-radius: 50%;
            animation: spin 2s linear infinite;
        }

        @keyframes spin {
            from { transform: rotate(0deg); }
            to { transform: rotate(360deg); }
        }

        .flying-enemy {
            width: 30px;
            height: 30px;
            background-color: #0099FF;
            border-radius: 50%;
            opacity: 0.9;
        }

        .charging-enemy {
            width: 40px;
            height: 40px;
            background-color: #FF5500;
            animation: charge 1s linear infinite alternate;
            border-radius: 50%;
        }

        .enemy {
            width: 25px;
            height: 25px;
            background-color: #FF5733;
        }

        .obstacle {
            width: 30px;
            height: 30px;
            background-color: #f44336;
        }

        .power-up {
            width: 20px;
            height: 20px;
        }

        .bullet {
            width: 10px;
            height: 5px;
            background-color: #FFD700;
        }

        .burst {
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background-color: rgba(255, 69, 0, 0.7);
            animation: burst 0.5s ease-out;
        }

        @keyframes burst {
            from { transform: scale(0.5); opacity: 1; }
            to { transform: scale(1.5); opacity: 0; }
        }

        .boss-door {
            width: 30px;
            height: 60px;
            background-color: #FFFF00;
        }

        .boss {
            width: 60px;
            height: 60px;
            background-color: #FF4500;
        }

        #score, #lives, #level, #timer {
            position: absolute;
            top: 10px;
            font-size: 16px;
        }

        #score { left: 10px; }
        #lives { right: 10px; }
        #level { left: 150px; }
        #timer { left: 250px; }

        #instructions, #cutscene, #level-intro, #boss-fight, #boss-hallway, #game-over, #interact-message {
            position: absolute;
            width: 100%;
            height: 100%;
            display: flex;
            justify-content: center;
            align-items: center;
            background-color: rgba(0, 0, 0, 0.8);
            color: #fff;
            flex-direction: column;
            font-size: 18px;
            z-index: 10;
        }

        #instructions button, #cutscene button, #level-intro button, #boss-fight button, #game-over button, #boss-hallway button {
            margin-top: 10px;
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
            background-color: #555;
            color: #fff;
        }

        #cutscene, #level-intro, #boss-fight, #boss-hallway, #game-over, #interact-message {
            display: none;
        }

        #intro {
            position: absolute;
            width: 100%;
            height: 100%;
            display: flex;
            justify-content: space-around;
            align-items: center;
            background-color: rgba(0, 0, 0, 0.8);
            color: #fff;
            flex-direction: row;
            font-size: 18px;
            z-index: 11;
        }

        #boss-health-bar {
            position: absolute;
            top: 10px;
            left: 50%;
            transform: translateX(-50%);
            width: 150px;
            height: 20px;
            background-color: #666;
            border: 1px solid #333;
            display: none;
        }

        #boss-health {
            height: 100%;
            width: 100%;
            background-color: #FF0000;
        }
        
        #friend {
            width: 30px;
            height: 30px;
            background-color: #00FF00;
            display: none;
        }

        #power-up-message {
            position: absolute;
            top: 50px;
            left: 50%;
            transform: translateX(-50%);
            font-size: 24px;
            z-index: 12;
            display: none;
        }

        /* New CSS for cool features */
        @keyframes flash {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }

        .flashing {
            animation: flash 0.5s infinite;
        }

        .glow {
            box-shadow: 0 0 10px rgba(255,255,255,0.5);
        }
    </style>
</head>
<body>
    <div id="game-container">
        <div id="game-world">
            <div id="player"></div>
        </div>
        <div id="score">Score: 0</div>
        <div id="lives">Lives: 3</div>
        <div id="level">Level: 1</div>
        <div id="timer">Timer: 0</div>
        <div id="instructions">
            <p>Press Arrow Up to Jump</p>
            <p>Use Arrow Left/Right to Move</p>
            <p>Press Space to Shoot</p>
            <p>Press Z for Power-Up</p>
            <p>Press E to interact</p>
            <button onclick="startGame()">Start Game</button>
            <button onclick="togglePause()">Pause/Resume</button>
        </div>
        <div id="cutscene">
            <p>Get ready for the next level!</p>
            <button onclick="continueGame()">Continue</button>
        </div>
        <div id="level-intro">
            <p id="level-text">Level 1: Get Ready for Adventure!</p>
            <button onclick="startLevel()">Start Level</button>
        </div>
        <div id="boss-fight">
            <p>Defeat the Boss!</p>
        </div>
        <div id="game-over">
            <p>Game Over!</p>
            <button onclick="restartGame()">Restart</button>
        </div>
        <div id="intro">
            <div class="character"></div>
            <div id="dialogue">
                <p>Player: Hey friend! What a nice day for an adventure!</p>
                <button onclick="nextDialogue()">Next</button>
            </div>
            <div class="character"></div>
            <div class="king"></div>
        </div>
        <div id="boss-hallway">
            <p>You have entered the boss hallway! Prepare yourself!</p>
            <button onclick="startBossFight()">Proceed</button>
        </div>
        <div id="boss-health-bar">
            <div id="boss-health"></div>
        </div>
        <div id="power-up-message"></div>
        <div id="interact-message"></div>
        <div id="friend"></div>
    </div>

    <script>
        const gameContainer = document.getElementById('game-container');
        const gameWorld = document.getElementById('game-world');
        const player = document.getElementById('player');
        const scoreDisplay = document.getElementById('score');
        const livesDisplay = document.getElementById('lives');
        const levelDisplay = document.getElementById('level');
        const timerDisplay = document.getElementById('timer');
        const instructions = document.getElementById('instructions');
        const cutscene = document.getElementById('cutscene');
        const levelIntro = document.getElementById('level-intro');
        const levelText = document.getElementById('level-text');
        const bossFightScreen = document.getElementById('boss-fight');
        const gameOverScreen = document.getElementById('game-over');
        const intro = document.getElementById('intro');
        const dialoguePara = document.querySelector('#dialogue p');
        const bossHallway = document.getElementById('boss-hallway');
        const bossHealthBar = document.getElementById('boss-health-bar');
        const bossHealthDisplay = document.getElementById('boss-health');
        const powerUpMessage = document.getElementById('power-up-message');
        const interactMessage = document.getElementById('interact-message');
        const friend = document.getElementById('friend');

        let playerPositionX = 50;
        let playerPositionY = 0;
        let playerVelocityX = 0;
        let playerVelocityY = 0;
        let playerMaxSpeed = 5;
        const playerJumpStrength = 12;
        let jumpCount = 0;
        const maxJumps = 2;
        let isDoubleJumpEnabled = false;
        let isJumping = false;
        let isPaused = false;
        let canShoot = true;
        let gameInterval;
        let obstacles = [];
        let enemies = [];
        let bullets = [];
        let powerUps = [];
        let platforms = [];
        let bossDoors = [];
        let coins = [];
        let score = 0;
        let lives = 3;
        let level = localStorage.getItem('playerLevel') ? parseInt(localStorage.getItem('playerLevel')) : 1;
        const gravity = 0.5;
        const maxLevels = 5;
        let movingLeft = false, movingRight = false;
        let currentDirection = 1;
        let currentPowerUp = null;
        let powerUpTimer = 0;
        let gameScrollPosition = 0;
        const bossScoreThreshold = 500;
        const dialogues = [
            "Player: Hey friend! What a nice day for an adventure!",
            "Friend: Indeed! Maybe we should explore the caves.",
            "Player: What's that over there? Is it the King?",
            "King: Haha, I've found you! You're coming with me!",
            "Friend: Player, help me!"
        ];
        let dialogueIndex = 0;
        let boss = null;
        let bossHealth = 100;
        let bossShielded = true;
        let bossPowerObtained = false;
        let bossFightActive = false;

        const allPowerUpTypes = [
            "super-speed", "invincibility", "teleportation", "time-freeze", 
            "gravity-reversal", "reflective-shield", "double-shot", "extra-life", 
            "score-boost", "mega-jump", "ice", "fire", "levitate", "hypno", "shield", 
            "regeneration", "ghost", "magnet", "invisibility", "freeze", "clone", 
            "shockwave", "energy", "shrink", "grow", "heal", "boss-power-up", 
            "triple-shot", "rapid-fire", "spike", "anti-gravity", "energy-blast",
            "light-speed", "blazing-trail", "sonic-wave", "armor", "telekinetic",
            "camouflage", "dimension-shift", "energy-drain", "mind-control",
            "hologram"
        ];

        window.addEventListener('keydown', handleKeydown);
        window.addEventListener('keyup', handleKeyup);

        function handleKeydown(e) {
            switch (e.key) {
                case 'ArrowLeft':
                    movingLeft = true;
                    currentDirection = -1;
                    break;
                case 'ArrowRight':
                    movingRight = true;
                    currentDirection = 1;
                    break;
                case 'ArrowUp':
                    handleJump();
                    break;
                case ' ':
                    if (canShoot) {
                        shootBullet(currentDirection);
                        canShoot = false;
                        setTimeout(() => canShoot = true, 300);
                    }
                    break;
                case 'z':
                case 'Z':
                    usePowerUp();
                    break;
                case 'e':
                case 'E':
                    interact();
                    break;
                case 'p':
                case 'P':
                    togglePause();
                    break;
            }
        }

        function handleKeyup(e) {
            switch (e.key) {
                case 'ArrowLeft':
                    movingLeft = false;
                    break;
                case 'ArrowRight':
                    movingRight = false;
                    break;
            }
        }

        function handleJump() {
            if (playerPositionY <= 0 || (isDoubleJumpEnabled && jumpCount < maxJumps)) {
                playerVelocityY = playerJumpStrength;
                jumpCount++;
                isJumping = true;
            }
        }

        function nextDialogue() {
            if (dialogueIndex < dialogues.length - 1) {
                dialogueIndex++;
                dialoguePara.textContent = dialogues[dialogueIndex];
            } else {
                intro.style.display = 'none';
                startGame();
            }
        }

        function shootBullet(direction) {
            const bullet = createBullet(direction);
            bullets.push({ element: bullet, direction });
            gameWorld.appendChild(bullet);

            if (currentPowerUp === 'double-shot') {
                const altBullet = createBullet(direction + 1);
                bullets.push({ element: altBullet, direction });
                gameWorld.appendChild(altBullet);
            }

            if (currentPowerUp === 'triple-shot') {
                const sideBullet1 = createBullet(direction + 1);
                const sideBullet2 = createBullet(direction - 1);
                bullets.push({ element: sideBullet1, direction });
                bullets.push({ element: sideBullet2, direction });
                gameWorld.appendChild(sideBullet1);
                gameWorld.appendChild(sideBullet2);
            }
        }

        function createBurst(x, y) {
            const burst = document.createElement('div');
            burst.classList.add('burst');
            burst.style.left = x + 'px';
            burst.style.bottom = y + 'px';
            gameWorld.appendChild(burst);
            setTimeout(() => burst.remove(), 500);
        }

        function moveCamera() {
            gameScrollPosition = Math.max(0, Math.min(gameWorld.offsetWidth - gameContainer.offsetWidth, playerPositionX - 400));
            gameWorld.style.transform = `translateX(${-gameScrollPosition}px)`;
        }

        function moveBullets() {
            bullets.forEach((bulletObj, index) => {
                const bullet = bulletObj.element;
                bullet.style.left = (parseInt(bullet.style.left) + (bulletObj.direction * 5)) + 'px';
                if (parseInt(bullet.style.left) > gameScrollPosition + gameContainer.offsetWidth || parseInt(bullet.style.left) < 0) {
                    bullet.remove();
                    bullets.splice(index, 1);
                } else {
                    enemies.forEach((enemy, enemyIndex) => {
                        if (checkCollision(bullet, enemy)) {
                            handleEnemyHit(enemy, enemyIndex);
                            bullet.remove();
                            bullets.splice(index, 1);
                        }
                    });
                    checkBossHit();
                }
            });
        }

        function handleEnemyHit(enemy, enemyIndex) {
            if (enemy.classList.contains('explosive-enemy')) {
                handleExplosiveEnemyHit(enemy, enemyIndex);
            } else if (enemy.classList.contains('split-enemy') && !enemy.classList.contains('split')) {
                handleSplitterEnemyHit(enemy, enemyIndex);
            } else {
                enemy.remove();
                enemies.splice(enemyIndex, 1);
                score += 10;
                updateDisplay();
            }
        }

        function startGame() {
            gameOverScreen.style.display = 'none';
            instructions.style.display = 'none';
            resetGame();
            levelIntro.style.display = 'flex';
        }

        function startLevel() {
            levelIntro.style.display = 'none';
            gameInterval = setInterval(gameLoop, 1000 / 60);
        }

        function resetGame() {
            lives = 3;
            playerPositionX = 50;
            playerPositionY = 0;
            playerVelocityX = 0;
            playerVelocityY = 0;
            isJumping = false;
            jumpCount = 0;
            isDoubleJumpEnabled = false;
            gameScrollPosition = 0;
            clearAllElements();
            switchLevelBackground();
            level = parseInt(localStorage.getItem('playerLevel') || 1);
            updateDisplay();
        }

        function updateDisplay() {
            scoreDisplay.textContent = `Score: ${score}`;
            livesDisplay.textContent = `Lives: ${lives}`;
            levelDisplay.textContent = `Level: ${level}`;
            timerDisplay.textContent = `Timer: ${powerUpTimer}`;
        }

        function updatePlayerPosition() {
            if (movingLeft) {
                playerVelocityX = -playerMaxSpeed;
            } else if (movingRight) {
                playerVelocityX = playerMaxSpeed;
            } else {
                playerVelocityX = 0;
            }

            playerPositionX += playerVelocityX;
            playerPositionX = Math.max(0, Math.min(gameWorld.offsetWidth - player.offsetWidth, playerPositionX));
            player.style.left = playerPositionX + 'px';

            let onPlatform = false;
            platforms.forEach(platform => {
                if (checkCollision(player, platform) && playerVelocityY < 0) {
                    playerPositionY = parseInt(platform.style.bottom) + platform.offsetHeight;
                    playerVelocityY = 0;
                    isJumping = false;
                    jumpCount = 0;
                    onPlatform = true;
                }
            });

            if (!onPlatform || isJumping || playerPositionY > 0) {
                playerVelocityY -= gravity;
                playerPositionY += playerVelocityY;
                if (playerPositionY <= 0) {
                    playerPositionY = 0;
                    isJumping = false;
                    jumpCount = 0;
                }
            }

            player.style.bottom = playerPositionY + 'px';
            moveCamera();
        }

        function spawnEntities() {
            if (!isPaused && !bossFightActive) {
                if (Math.random() < 0.003) spawnObstacle();
                if (Math.random() < 0.005) spawnEnemy();
                if (Math.random() < 0.002 && !currentPowerUp) spawnPowerUp();
                if (Math.random() < 0.001) spawnPlatform();
                if (Math.random() < 0.003) spawnFlyingEnemy();
                if (Math.random() < 0.002) spawnChargingEnemy();
                if (Math.random() < 0.003) spawnCoin();
                if (Math.random() < 0.002) spawnStealthEnemy();
                if (Math.random() < 0.001) spawnSniperEnemy();
                if (Math.random() < 0.002) spawnRegeneratingEnemy();
                if (Math.random() < 0.001) spawnSplitterEnemy();
                if (bossDoors.length === 0 && score >= level * bossScoreThreshold && enemies.length === 0) spawnBossDoor();
            }
        }

        function moveElements() {
            moveArray(obstacles, 2, 15);
            moveArray(enemies, 1, 30);
            moveArray(coins, 2, 0);
            moveArray(powerUps, 2, 0, true);
            moveArray(platforms, 1, 0);
            moveFlyingEnemies();
            moveChargingEnemies();
            moveStealthEnemies();
            moveBullets();
            moveNewEnemies();
        }

        function spawnObstacle() {
            const obstacle = createElement('obstacle', obstacles, gameScrollPosition + gameContainer.offsetWidth);
            obstacle.style.bottom = '0px';
        }

        function spawnEnemy() {
            const baseEnemy = createElement('enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            baseEnemy.style.bottom = '0px';

            const chance = Math.random();
            if (chance < 0.3) {
                spawnTeleporterEnemy();
            } else if (chance < 0.6) {
                spawnMourningEnemy();
            } else if (chance < 0.7) {
                spawnVelocityEnemy();
            } else if (chance < 0.9) {
                spawnStickyEnemy();
            } else {
                spawnReflectiveEnemy();
            }
        }

        function spawnPowerUp() {
            const powerUpTypes = allPowerUpTypes;
            const type = powerUpTypes[Math.floor(Math.random() * powerUpTypes.length)];
            const powerUp = createElement('power-up', powerUps, gameScrollPosition + gameContainer.offsetWidth);
            powerUp.setAttribute('data-type', type);
            powerUp.style.backgroundColor = getPowerUpColor(type);
            powerUp.style.bottom = Math.floor(Math.random() * 100) + 'px';
        }

        function spawnCoin() {
            const coin = createElement('coin', coins, gameScrollPosition + gameContainer.offsetWidth);
            coin.style.bottom = Math.floor(Math.random() * 50 + 50) + 'px';
        }

        function getPowerUpColor(type) {
            switch (type) {
                case 'super-speed': return 'lime';
                case 'invincibility': return 'gold';
                case 'teleportation': return 'violet';
                case 'time-freeze': return 'cyan';
                case 'gravity-reversal': return 'magenta';
                case 'reflective-shield': return 'aqua';
                case 'double-shot': return 'red';
                case 'extra-life': return 'lightgreen';
                case 'score-boost': return 'coral';
                case 'mega-jump': return 'fuchsia';
                case 'ice': return 'blue';
                case 'fire': return 'red';
                case 'levitate': return 'turquoise';
                case 'hypno': return 'pink';
                case 'shield': return 'silver';
                case 'regeneration': return 'lightgreen';
                case 'ghost': return 'lightgrey';
                case 'magnet': return 'darkgoldenrod';
                case 'invisibility': return 'lightsteelblue';
                case 'freeze': return 'lightblue';
                case 'clone': return 'orchid';
                case 'shockwave': return 'turquoise';
                case 'energy': return 'yellow';
                case 'shrink': return 'aquamarine';
                case 'grow': return 'salmon';
                case 'heal': return 'chartreuse';
                case 'boss-power-up': return 'darkorange';
                default: return 'white';
            }
        }

        function spawnPlatform() {
            const platform = createElement('platform', platforms, gameScrollPosition + gameContainer.offsetWidth);
            platform.style.bottom = Math.floor(Math.random() * 200 + 100) + 'px';
        }

        function spawnBossDoor() {
            const bossDoor = createElement('boss-door', bossDoors, gameScrollPosition + gameContainer.offsetWidth + 200);
            bossDoor.style.bottom = '0px';
        }

        function createElement(className, array, leftPosition, type = '') {
            const element = document.createElement('div');
            element.classList.add(className);
            if (type) element.setAttribute('data-type', type);
            element.style.left = leftPosition + 'px';
            gameWorld.appendChild(element);
            array.push(element);
            return element;
        }

        function moveArray(array, speed, scoreValue, isPowerUp = false) {
            array.forEach((el, index) => {
                el.style.left = (parseInt(el.style.left) - speed) + 'px';
                if (parseInt(el.style.left) < gameScrollPosition - el.offsetWidth) {
                    removeElement(el, array, index, 0);
                } else if (checkCollision(player, el)) {
                    handleCollision(el, array, index, scoreValue, isPowerUp);
                }
            });
        }

        function removeElement(el, array, index, scoreValue) {
            el.remove();
            array.splice(index, 1);
            if (scoreValue) {
                score += scoreValue;
                updateDisplay();
            }
        }

        function handleCollision(el, array, index, scoreValue, isPowerUp = false) {
            if (el.classList.contains('coin')) {
                score += 5;
                updateDisplay();
            } else if (isPowerUp) {
                applyPowerUp(el);
            } else if (el.classList.contains('boss-door') && score >= level * bossScoreThreshold) {
                interactMessage.textContent = "Press 'E' to enter boss door.";
                interactMessage.style.display = checkCollision(player, el) ? 'block' : 'none';
                if (checkCollision(player, el) && playerPositionX >= parseInt(el.style.left)) {
                    openBossHallway();
                }
            } else if (el.classList.contains('enemy') || el.classList.contains('obstacle')) {
                reduceLives();
            }
            removeElement(el, array, index, scoreValue);
        }

        function applyPowerUp(el) {
            if (currentPowerUp) return;

            const type = el.getAttribute('data-type');
            if (type === 'boss-power-up') {
                grantBossPowerUp();
            } else {
                currentPowerUp = type;
                let duration = 10;
                activatePowerUp(type);
                powerUpTimer = duration;

                const powerUpInterval = setInterval(() => {
                    powerUpTimer--;
                    updateDisplay();
                    if (powerUpTimer <= 0) {
                        clearInterval(powerUpInterval);
                        resetPowerUp();
                    }
                }, 1000);
            }

            displayPowerUpMessage(type);
        }

        function activatePowerUp(type) {
            switch (type) {
                case 'super-speed':
                    player.style.backgroundColor = 'lime';
                    playerMaxSpeed = 8;
                    break;
                case 'invincibility':
                    player.style.backgroundColor = 'gold';
                    break;
                case 'teleportation':
                    teleportPlayer();
                    break;
                case 'time-freeze':
                    activateTimeFreeze();
                    break;
                case 'gravity-reversal':
                    toggleGravity();
                    break;
                case 'reflective-shield':
                    activateReflectiveShield();
                    break;
                case 'double-shot':
                    enableDoubleShot();
                    break;
                case 'extra-life':
                    gainExtraLife();
                    break;
                case 'score-boost':
                    boostScore();
                    break;
                case 'mega-jump':
                    activateMegaJump();
                    break;
                case 'energy-blast':
                    activateEnergyBlast();
                    break;
                case 'light-speed':
                    activateLightSpeed();
                    break;
                case 'blazing-trail':
                    activateBlazingTrail();
                    break;
                case 'sonic-wave':
                    activateSonicWave();
                    break;
                case 'armor':
                    activateArmor();
                    break;
                case 'telekinetic':
                    activateTelekinetic();
                    break;
                case 'camouflage':
                    activateCamouflage();
                    break;
                case 'dimension-shift':
                    activateDimensionShift();
                    break;
                case 'energy-drain':
                    activateEnergyDrain();
                    break;
                case 'mind-control':
                    activateMindControl();
                    break;
                case 'hologram':
                    activateHologram();
                    break;
                default:
                    player.style.backgroundColor = getPowerUpColor(type);
                    break;
            }
        }

        function resetPowerUp() {
            currentPowerUp = null;
            player.style.backgroundColor = '#4CAF50';
            playerMaxSpeed = 5;
            player.style.opacity = '1';
            isDoubleJumpEnabled = false;
            clearTimeout(timeSlowTimeout);
            resetGravity();
        }

        function displayPowerUpMessage(type) {
            powerUpMessage.textContent = `You obtained ${type.replace(/-/g, ' ')}!`;
            powerUpMessage.style.display = 'block';
            setTimeout(() => powerUpMessage.style.display = 'none', 2000);
        }

        function grantBossPowerUp() {
            bossPowerObtained = true;
            powerUpMessage.textContent = "Boss Power-Up Obtained!";
            powerUpMessage.style.display = 'block';
            setTimeout(() => powerUpMessage.style.display = 'none', 2000);
        }

        function usePowerUp() {
            if (!currentPowerUp) return;
            switch (currentPowerUp) {
                case 'ice':
                    shootIce();
                    break;
                case 'fire':
                    shootFire();
                    break;
                case 'levitate':
                    useLevitate();
                    break;
                case 'hypno':
                    shootHypno();
                    break;
                case 'double-shot':
                    shootDouble();
                    break;
                default:
                    break;
            }
        }

        function shootIce() {
            const iceBullet = createBullet(currentDirection);
            iceBullet.style.backgroundColor = 'blue';
            gameWorld.appendChild(iceBullet);

            const iceBulletObj = { element: iceBullet, direction: currentDirection };
            animateBullet(iceBulletObj, 5, target => {
                if (target.classList.contains('obstacle')) {
                    target.classList.add('frozen');
                    target.style.backgroundColor = '#00f';
                    target.style.opacity = '0.5';
                }
            });
        }

        function shootFire() {
            const fireBullet = createBullet(currentDirection);
            fireBullet.style.backgroundColor = 'red';
            gameWorld.appendChild(fireBullet);

            const fireBulletObj = { element: fireBullet, direction: currentDirection };
            animateBullet(fireBulletObj, 5, target => {
                if (target.classList.contains('obstacle')) {
                    target.style.transition = 'opacity 0.5s';
                    target.style.opacity = '0';
                    setTimeout(() => target.remove(), 500);
                }
            });
        }

        function useLevitate() {
            player.style.transform = 'translateY(-20px)';
            const levitateUp = setTimeout(() => {
                player.style.transform = 'translateY(0)';
                clearTimeout(levitateUp);
            }, 1000);
        }

        function enableDoubleShot() {
        }

        function createBullet(direction = 1) {
            const bullet = document.createElement('div');
            bullet.classList.add('bullet');
            bullet.style.backgroundColor = '#FFD700';
            bullet.style.left = (playerPositionX + player.offsetWidth / 2 - 5) + 'px';
            bullet.style.bottom = (playerPositionY + player.offsetHeight / 2) + 'px';
            return bullet;
        }

        function shootHypno() {
            const hypnoBullet = createBullet(currentDirection);
            hypnoBullet.style.backgroundColor = 'pink';
            gameWorld.appendChild(hypnoBullet);

            const hypnoBulletObj = { element: hypnoBullet, direction: currentDirection };
            animateBullet(hypnoBulletObj, 5, target => {
                if (target.classList.contains('enemy') && !target.classList.contains('hypnotized')) {
                    target.classList.add('hypnotized');
                    target.style.backgroundColor = 'pink';
                    hypnotizeEnemy(target);
                }
            });
        }

        function shootDouble() {
            const bullet1 = createBullet(currentDirection);
            const bullet2 = createBullet(currentDirection);
            bullets.push({ element: bullet1, direction: currentDirection });
            bullets.push({ element: bullet2, direction: currentDirection });
            gameWorld.appendChild(bullet1);
            gameWorld.appendChild(bullet2);
        }

        function hypnotizeEnemy(enemy) {
            let destroyCount = 0;
            const moveInterval = setInterval(() => {
                let nearestEnemy = findNearestEnemyTo(enemy);
                if (!nearestEnemy) {
                    enemy.remove();
                    clearInterval(moveInterval);
                    return;
                }

                let ex = parseInt(enemy.style.left);
                let ey = parseInt(enemy.style.bottom);
                let nex = parseInt(nearestEnemy.style.left);
                let ney = parseInt(nearestEnemy.style.bottom);

                let dx = nex - ex;
                let dy = ney - ey;
                let distance = Math.sqrt(dx * dx + dy * dy);

                if (distance < 5) {
                    destroyCount++;
                    createBurst(nex, ney);
                    nearestEnemy.remove();
                    enemies = enemies.filter(e => e !== nearestEnemy);

                    if (destroyCount >= 3) {
                        enemy.remove();
                        clearInterval(moveInterval);
                    }
                } else {
                    let angle = Math.atan2(dy, dx);
                    enemy.style.left = (ex + Math.cos(angle) * 2) + 'px';
                    enemy.style.bottom = (ey + Math.sin(angle) * 2) + 'px';
                }
            }, 1000 / 60);
        }

        function findNearestEnemyTo(sourceEnemy) {
            let minDistance = Infinity;
            let closestEnemy = null;

            enemies.forEach(enemy => {
                if (enemy !== sourceEnemy) {
                    let distance = calculateDistance(sourceEnemy, enemy);
                    if (distance < minDistance) {
                        minDistance = distance;
                        closestEnemy = enemy;
                    }
                }
            });

            return closestEnemy;
        }

        function calculateDistance(el1, el2) {
            let el1Rect = el1.getBoundingClientRect();
            let el2Rect = el2.getBoundingClientRect();
            let dx = (el1Rect.left + el1Rect.width / 2) - (el2Rect.left + el2Rect.width / 2);
            let dy = (el1Rect.top + el1Rect.height / 2) - (el2Rect.top + el2Rect.height / 2);
            return Math.sqrt(dx * dx + dy * dy);
        }

        function enableDoubleJump(enable = true) {
            isDoubleJumpEnabled = enable;
        }

        function teleportPlayer() {
            player.style.backgroundColor = 'blueviolet';
            setTimeout(() => {
                playerPositionX += 300 * currentDirection;
                playerPositionX = Math.max(0, Math.min(gameWorld.offsetWidth - player.offsetWidth, playerPositionX));
                player.style.left = playerPositionX + 'px';
            }, 500);
        }

        function toggleGravity() {
            const originalGravity = gravity;
            gravity = -gravity;
            setTimeout(() => {
                gravity = originalGravity;
            }, 5000);
        }

        function resetGravity() {
            gravity = Math.abs(gravity);
        }

        function freezeEnemies() {
            enemies.forEach(enemy => {
                enemy.style.transition = 'opacity 1s';
                enemy.style.opacity = '0.2';
                enemy.classList.add('frozen-enemy');
            });
            setTimeout(() => {
                enemies.forEach(enemy => {
                    enemy.style.opacity = '1';
                    enemy.classList.remove('frozen-enemy');
                });
            }, 5000);
        }

        function createClone() {
            const clone = createElement('player', [], playerPositionX + 50);
            clone.style.bottom = playerPositionY + 'px';
            clone.style.backgroundColor = '#00F';
            clone.style.border = '2px dashed #FFF';
            gameWorld.appendChild(clone);
            setTimeout(() => clone.remove(), 5000);
        }

        function triggerShockwave() {
            const shockwaveRadius = 100;
            enemies.forEach(enemy => {
                const dist = calculateDistance(player, enemy);
                if (dist < shockwaveRadius) {
                    createBurst(parseInt(enemy.style.left), parseInt(enemy.style.bottom));
                    enemy.remove();
                }
            });
        }

        function absorbEnergy() {
            score += 50;
            updateDisplay();
        }

        function shrinkPlayer() {
            player.style.transform = 'scale(0.5)';
            setTimeout(() => player.style.transform = 'scale(1)', 5000);
        }

        function growPlayer() {
            player.style.transform = 'scale(1.5)';
            setTimeout(() => player.style.transform = 'scale(1)', 5000);
        }

        function healPlayer() {
            if (lives < 5) {
                lives++;
                updateDisplay();
            }
        }

        function activateShield() {
            player.style.border = '3px solid purple';
            player.style.opacity = '0.6';
            lives = Math.min(lives + 1, 5);
            updateDisplay();
        }

        function gainExtraLife() {
            lives = Math.min(lives + 1, 5);
            updateDisplay();
        }

        function boostScore() {
            score += 100;
            updateDisplay();
        }

        function activateMegaJump() {
            playerVelocityY = playerJumpStrength * 1.5;
            isJumping = true;
        }

        function activateReflectiveShield() {
            player.style.border = '3px dashed cyan';
            const reflectInterval = setInterval(() => {
                bullets.forEach((bullet, index) => {
                    if (checkCollision(player, bullet.element)) {
                        bullet.direction *= -1;
                    }
                });
            }, 1000 / 60);

            setTimeout(() => {
                player.style.border = '';
                clearInterval(reflectInterval);
            }, 5000);
        }

        function activateRegeneration() {
            const regenerationInterval = setInterval(() => {
                if (lives < 5) lives++;
                updateDisplay();
                if (!currentPowerUp || currentPowerUp !== 'regeneration') {
                    clearInterval(regenerationInterval);
                }
            }, 2000);
        }

        function activateMagnet() {
            const magnetInterval = setInterval(() => {
                coins.forEach(coin => {
                    const coinX = parseInt(coin.style.left);
                    const coinY = parseInt(coin.style.bottom);
                    const dx = playerPositionX - coinX;
                    const dy = playerPositionY - coinY;
                    if (Math.sqrt(dx * dx + dy * dy) < 100) {
                        coin.style.left = (coinX + dx * 0.1) + 'px';
                        coin.style.bottom = (coinY + dy * 0.1) + 'px';
                    }
                });

                if (!currentPowerUp || currentPowerUp !== 'magnet') {
                    clearInterval(magnetInterval);
                }
            }, 1000 / 60);
        }

        let timeSlowTimeout;

        function slowDownTime() {
            const originalTiming = 1000 / 60;
            clearInterval(gameInterval);
            gameInterval = setInterval(gameLoop, originalTiming * 2);
            timeSlowTimeout = setTimeout(() => {
                clearInterval(gameInterval);
                gameInterval = setInterval(gameLoop, originalTiming);
            }, 5000);
        }

        function activateEnergyBlast() {
            const blastRadius = 100;
            let enemiesToRemove = enemies.filter(enemy => calculateDistance(player, enemy) < blastRadius);
            enemiesToRemove.forEach(enemy => {
                createBurst(parseInt(enemy.style.left), parseInt(enemy.style.bottom));
                enemy.remove();
                enemies = enemies.filter(e => e !== enemy);
            });
            updateDisplay();
        }

        function activateLightSpeed() {
            playerMaxSpeed = 20;
            setTimeout(() => playerMaxSpeed = 5, 5000);
        }

        function activateBlazingTrail() {
            const trailInterval = setInterval(() => {
                const trail = document.createElement('div');
                trail.className = 'bullet';
                trail.style.left = (playerPositionX + player.offsetWidth / 2) + 'px';
                trail.style.bottom = (playerPositionY + player.offsetHeight / 2) + 'px';
                trail.style.backgroundColor = 'orange';
                gameWorld.appendChild(trail);
                setTimeout(() => trail.remove(), 500);
            }, 100);

            setTimeout(() => clearInterval(trailInterval), 5000);
        }

        function activateSonicWave() {
            const wave = document.createElement('div');
            wave.className = 'burst';
            wave.style.left = playerPositionX + 'px';
            wave.style.bottom = playerPositionY + 'px';
            wave.style.backgroundColor = 'cyan';
            wave.style.width = '100px';
            wave.style.height = '100px';
            gameWorld.appendChild(wave);
            setTimeout(() => wave.remove(), 500);
            enemies.forEach(enemy => {
                if (calculateDistance(player, enemy) < 50) {
                    createBurst(parseInt(enemy.style.left), parseInt(enemy.style.bottom));
                    enemy.remove();
                }
            });
        }

        function activateArmor() {
            player.style.border = '3px solid steelblue';
            lives = Math.min(lives + 3, 5);
            updateDisplay();
        }

        function activateTelekinetic() {
            const forceInterval = setInterval(() => {
                enemies.forEach(enemy => {
                    const enemyX = parseInt(enemy.style.left);
                    const enemyY = parseInt(enemy.style.bottom);
                    const dx = playerPositionX - enemyX;
                    const dy = playerPositionY - enemyY;
                    if (Math.sqrt(dx * dx + dy * dy) < 100) {
                        enemy.style.left = (enemyX + dx * 0.1) + 'px';
                        enemy.style.bottom = (enemyY + dy * 0.1) + 'px';
                    }
                });
            }, 1000 / 60);

            setTimeout(() => clearInterval(forceInterval), 5000);
        }

        function activateCamouflage() {
            player.style.opacity = '0.2';
            setTimeout(() => player.style.opacity = '1', 5000);
        }

        function activateDimensionShift() {
            gameWorld.style.backgroundColor = 'black';
            setTimeout(() => gameWorld.style.backgroundColor = '', 5000);
        }

        function activateEnergyDrain() {
            const drainInterval = setInterval(() => {
                if (score > 0) {
                    score -= 1;
                    updateDisplay();
                }
            }, 100);

            setTimeout(() => clearInterval(drainInterval), 5000);
        }

        function activateMindControl() {
            enemies.forEach(enemy => {
                if (!enemy.classList.contains('hypnotized')) {
                    enemy.classList.add('hypnotized');
                    enemy.style.backgroundColor = 'violet';
                    hypnotizeEnemy(enemy);
                }
            });
        }

        function activateHologram() {
            const hologram = document.createElement('div');
            hologram.className = 'player';
            hologram.style.left = (playerPositionX - 50) + 'px';
            hologram.style.bottom = playerPositionY + 'px';
            hologram.style.backgroundColor = 'rgba(0, 0, 255, 0.5)';
            gameWorld.appendChild(hologram);
            setTimeout(() => hologram.remove(), 5000);
        }

        function animateBullet(bulletObj, speed, impactCallback = () => {}) {
            const bulletInterval = setInterval(() => {
                const bullet = bulletObj.element;
                bullet.style.left = (parseInt(bullet.style.left) + (bulletObj.direction * speed)) + 'px';
                if (parseInt(bullet.style.left) > gameScrollPosition + gameContainer.offsetWidth || parseInt(bullet.style.left) < 0) {
                    bullet.remove();
                    clearInterval(bulletInterval);
                } else {
                    [...obstacles, ...enemies].forEach(target => {
                        if (checkCollision(bullet, target)) {
                            impactCallback(target);
                            createBurst(parseInt(bullet.style.left), parseInt(bullet.style.bottom));
                            bullet.remove();
                            clearInterval(bulletInterval);
                        }
                    });
                }
            }, 1000 / 60);
        }

        function reduceLives() {
            if (player.style.border) {
                player.style.border = '';
                player.style.opacity = '1';
            } else {
                lives--;
                if (lives <= 0) endGame(false);
            }
            updateDisplay();
        }

        function checkCollision(rect1, rect2) {
            const rect1Bounds = rect1.getBoundingClientRect();
            const rect2Bounds = rect2.getBoundingClientRect();
            return !(rect1Bounds.top > rect2Bounds.bottom || rect1Bounds.bottom < rect2Bounds.top ||
                    rect1Bounds.left > rect2Bounds.right || rect1Bounds.right < rect2Bounds.left);
        }

        function togglePause() {
            if (isPaused) {
                gameInterval = setInterval(gameLoop, 1000 / 60);
                isPaused = false;
            } else {
                clearInterval(gameInterval);
                isPaused = true;
            }
        }

        function clearAllElements() {
            [obstacles, enemies, bullets.map(b => b.element), powerUps, platforms, bossDoors, coins]
                .forEach(arr => {
                    arr.forEach(el => el.remove());
                    arr.length = 0;
                });
        }

        function interact() {
            if (checkCollision(player, friend)) {
                activateFriendDialogue();
            }
            bossDoors.forEach(door => {
                if (checkCollision(player, door)) {
                    openBossHallway();
                }
            });
        }

        function openBossHallway() {
            bossHallway.style.display = 'flex';
            clearAllElements();
            clearInterval(gameInterval);
        }

        function startBossFight() {
            bossHallway.style.display = 'none';
            triggerBossFight();
        }

        function incrementLevel() {
            level++;
            if (level > maxLevels) {
                endGame(true);
            } else {
                localStorage.setItem('playerLevel', level);
                updateDisplay();
                resetGame();
                levelIntro.style.display = 'flex';
                switchLevelBackground();
                levelText.textContent = `Level ${level}: New Challenges Await!`;
            }
        }

        function switchLevelBackground() {
            const backgrounds = ['#333', '#1E90FF', '#228B22', '#E0FFFF', '#B22222'];
            gameContainer.style.backgroundColor = backgrounds[(level - 1) % backgrounds.length];
        }

        function continueGame() {
            levelIntro.style.display = 'none';
            gameInterval = setInterval(gameLoop, 1000 / 60);
        }

        function gameLoop() {
            if (!isPaused) {
                updatePlayerPosition();
                spawnEntities();
                moveElements();
                checkScoreForLevelTransition();
            }
        }

        function endGame(isWin = false) {
            clearInterval(gameInterval);
            gameOverScreen.style.display = 'flex';
            gameOverScreen.innerHTML = `<p>${isWin ? 'Congratulations! You won!' : 'Game Over!'}</p>
            <button onclick="restartGame()">Restart</button>`;
        }

        function restartGame() {
            gameOverScreen.style.display = 'none';
            resetGame();
            startLevel();
        }

        function triggerBossFight() {
            bossFightScreen.style.display = 'flex';
            setTimeout(() => {
                bossFightScreen.style.display = 'none';
                startBossLogic();
            }, 2000);
        }

        function startBossLogic() {
            bossFightActive = true;
            boss = createElement('boss', [], 600);
            boss.style.bottom = '100px';
            gameWorld.appendChild(boss);
            displayBossHealth();

            const bossAttackInterval = setInterval(() => {
                if (boss) {
                    if (!bossShielded) {
                        spawnBossBullets();
                    }
                    boss.style.transform = boss.style.transform === 'scaleX(-1)' ? 'scaleX(1)' : 'scaleX(-1)'; 
                }
            }, 1500);

            const shieldInterval = setInterval(() => {
                bossShielded = !bossShielded;
                boss.style.boxShadow = bossShielded ? "0 0 20px rgba(0, 0, 255, 0.5)" : ""; 

                if (bossShielded) {
                    spawnBossEnemies();
                }
            }, 10000);

            const bossHealthInterval = setInterval(() => {
                if (!bossShielded) {
                    bossHealth -= 1;
                    updateBossHealth();
                }

                if (bossHealth <= 0) {
                    boss.remove();
                    clearInterval(bossAttackInterval);
                    clearInterval(shieldInterval);
                    clearInterval(bossHealthInterval);
                    onBossDefeated();
                }
            }, 1000);
        }

        function displayBossHealth() {
            bossHealthBar.style.display = 'block';
            updateBossHealth();
        }

        function updateBossHealth() {
            bossHealthDisplay.style.width = `${bossHealth}%`;
        }

        function spawnBossEnemies() {
            if (bossShielded) {
                for (let i = 0; i < 2; i++) {
                    const enemy = createElement('enemy', enemies, parseInt(boss.style.left) + (i * 50));
                    enemy.style.bottom = `${Math.random() * 250}px`;
                }
            }
        }

        function spawnBossBullets() {
            const bullet = createBullet();
            bullet.style.left = parseInt(boss.style.left) + 'px';
            bullet.style.bottom = parseInt(boss.style.bottom) + 30 + 'px';
            bullet.style.backgroundColor = 'orange';
            gameWorld.appendChild(bullet);
            bullets.push({ element: bullet, direction: -1 });
        }

        function checkBossHit() {
            if (!boss || bossShielded) return;
            bullets.forEach((bullet, bulletIndex) => {
                if (checkCollision(bullet.element, boss)) {
                    bossHealth -= 2;
                    updateBossHealth();
                    bullet.element.remove();
                    bullets.splice(bulletIndex, 1);
                }
            });
        }

        function onBossDefeated() {
            bossHealthBar.style.display = 'none';
            displayMessage("Noooo");
            setTimeout(() => {
                friend.style.left = '400px';
                friend.style.bottom = '100px';
                friend.style.display = 'block';
                interactMessage.textContent = "Press 'E' to interact with your friend!";
                interactMessage.style.display = 'block';
            }, 2000);
        }

        function activateFriendDialogue() {
            interactMessage.style.display = 'none';
            displayMessage("Thank you for saving me!");
            setTimeout(() => {
                displayMessage("I got a secret power for you.");
                setTimeout(() => {
                    grantBossPowerUp();
                    friend.style.display = 'none';
                }, 3000);
            }, 2000);
        }

        function displayMessage(message) {
            powerUpMessage.textContent = message;
            powerUpMessage.style.display = 'block';
            setTimeout(() => {
                powerUpMessage.style.display = 'none';
            }, 2000);
        }

        function checkScoreForLevelTransition() {
            if (score >= level * 1000) {
                incrementLevel();
            }
        }

        function spawnFlyingEnemy() {
            const flyingEnemy = createElement('flying-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            flyingEnemy.style.bottom = Math.random() * 150 + 50 + 'px';
        }

        function moveFlyingEnemies() {
            enemies.forEach((enemy, index) => {
                if(enemy.classList.contains('flying-enemy')) {
                    if (parseInt(enemy.style.left) < 0) {
                        removeElement(enemy, enemies, index, 30);
                    } else {
                        enemy.style.left = (parseInt(enemy.style.left) - 2) + 'px';
                        if (checkCollision(player, enemy)) {
                            reduceLives();
                            removeElement(enemy, enemies, index, 0);
                        }
                    }
                }
            });
        }

        function spawnChargingEnemy() {
            const chargingEnemy = createElement('charging-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            chargingEnemy.style.bottom = '0px';
            chargingEnemy.setAttribute('data-charge', '0');
        }

        function moveChargingEnemies() {
            enemies.forEach((enemy, index) => {
                if (enemy.classList.contains('charging-enemy')) {
                    const charge = parseInt(enemy.getAttribute('data-charge'));
                    if (charge > 60) {
                        enemy.style.left = (parseInt(enemy.style.left) - 5) + 'px';
                    } else {
                        enemy.setAttribute('data-charge', charge + 1);
                    }

                    if (parseInt(enemy.style.left) < gameScrollPosition - enemy.offsetWidth) {
                        removeElement(enemy, enemies, index, 30);
                    } else if (checkCollision(player, enemy)) {
                        reduceLives();
                        removeElement(enemy, enemies, index, 0);
                    }
                }
            });
        }

        function spawnStealthEnemy() {
            const stealthEnemy = createElement('stealth-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            stealthEnemy.setAttribute('data-stealth', '0');
            stealthEnemy.style.backgroundColor = '#555';
            stealthEnemy.style.opacity = '1';
        }

        function moveStealthEnemies() {
            enemies.forEach(en => {
                if (en.classList.contains('stealth-enemy')) {
                    const stealth = parseInt(en.getAttribute('data-stealth'));
                    if (stealth > 50) {
                        en.style.opacity = en.style.opacity == '0' ? '1' : '0';
                        en.setAttribute('data-stealth', '0');
                    } else {
                        en.setAttribute('data-stealth', stealth + 1);
                    }
                }
            });
        }

        function spawnSplitterEnemy() {
            const splitter = createElement('split-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            splitter.style.bottom = '0px';
            splitter.classList.add('split');
        }

        function handleSplitterEnemyHit(enemy, enemyIndex) {
            if (!enemy.classList.contains('split')) {
                for (let i = 0; i < 3; i++) {
                    const miniEnemy = createElement('split-enemy', enemies, parseInt(enemy.style.left) + i * 30);
                    miniEnemy.style.width = '15px';
                    miniEnemy.style.height = '15px';
                    miniEnemy.classList.remove('split');
                }
            }
            removeElement(enemy, enemies, enemyIndex, 0);
        }

        function handleExplosiveEnemyHit(enemy, enemyIndex) {
            removeElement(enemy, enemies, enemyIndex, 0);
            enemies.forEach((otherEnemy, index) => {
                if (calculateDistance(enemy, otherEnemy) < 50) {
                    removeElement(otherEnemy, enemies, index, 0);
                }
            });
            createBurst(parseInt(enemy.style.left), parseInt(enemy.style.bottom));
            reduceLives();
        }

        function spawnSniperEnemy() {
            const sniper = createElement('sniper-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            sniper.style.bottom = '200px';
            const sniperInterval = setInterval(() => {
                if (Math.random() < 0.05 && calculateDistance(player, sniper) < 300) {
                    const bullet = createBullet();
                    bullet.style.left = parseInt(sniper.style.left) + 'px';
                    bullet.style.bottom = parseInt(sniper.style.bottom) + 'px';
                    bullet.style.backgroundColor = 'red';
                    gameWorld.appendChild(bullet);
                    bullets.push({ element: bullet, direction: -1 });
                }
            }, 1000);

            sniper.setAttribute('data-interval', sniperInterval);
        }

        function spawnRegeneratingEnemy() {
            const regenEnemy = createElement('regen-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            regenEnemy.setAttribute('data-health', '3');
            const regenInterval = setInterval(() => {
                if (parseInt(regenEnemy.getAttribute('data-health')) < 5) {
                    regenEnemy.setAttribute('data-health', parseInt(regenEnemy.getAttribute('data-health')) + 1);
                }
            }, 3000);

            regenEnemy.setAttribute('data-regen-interval', regenInterval);
        }

        function spawnNewInteractiveEnemies() {
            const randomFeature = Math.random();
            if (randomFeature < 0.2) {
                spawnTeleporterEnemy();
            } else if (randomFeature < 0.4) {
                spawnMourningEnemy();
            } else if (randomFeature < 0.6) {
                spawnVelocityEnemy();
            } else if (randomFeature < 0.8) {
                spawnStickyEnemy();
            } else {
                spawnReflectiveEnemy();
            }
        }

        function moveNewEnemies() {
            moveTeleporterEnemies();
            moveMourningEnemies();
            moveVelocityEnemies();
            moveStickyEnemies();
            moveReflectiveEnemies();
        }

        // New enemies with creative features
        function spawnTeleporterEnemy() {
            const teleporterEnemy = createElement('teleporter-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            teleporterEnemy.style.backgroundColor = '#8A2BE2'; 
            teleporterEnemy.style.bottom = '0px';
            teleporterEnemy.setAttribute('data-teleport', '0');
        }

        function moveTeleporterEnemies() {
            enemies.forEach(en => {
                if (en.classList.contains('teleporter-enemy')) {
                    const teleport = parseInt(en.getAttribute('data-teleport'));
                    if (teleport > 100) {
                        en.style.left = Math.random() * (gameWorld.offsetWidth - en.offsetWidth) + 'px';
                        en.setAttribute('data-teleport', '0');
                    } else {
                        en.setAttribute('data-teleport', teleport + 1);
                    }
                }
            });
        }

        function spawnMourningEnemy() {
            const mourningEnemy = createElement('mourning-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            mourningEnemy.style.backgroundColor = '#708090';
            mourningEnemy.style.bottom = '0px';
        }

        function moveMourningEnemies() {
            enemies.forEach(en => {
                if (en.classList.contains('mourning-enemy')) {
                    if (Math.random() < 0.01) {
                        en.style.opacity = en.style.opacity === '0.5' ? '1' : '0.5'; 
                    }

                    if (parseInt(en.style.left) < gameScrollPosition - en.offsetWidth) {
                        removeElement(en, enemies, 0, 30);
                    } else if (checkCollision(player, en)) {
                        reduceLives();
                        removeElement(en, enemies, 0, 0);
                    }
                }
            });
        }

        function spawnVelocityEnemy() {
            const velocityEnemy = createElement('velocity-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            velocityEnemy.style.backgroundColor = '#FF4500'; 
            velocityEnemy.style.bottom = Math.random() * 150 + 'px';
            velocityEnemy.setAttribute('data-speed', '2');
        }

        function moveVelocityEnemies() {
            enemies.forEach(en => {
                if (en.classList.contains('velocity-enemy')) {
                    const speed = parseInt(en.getAttribute('data-speed'));
                    en.style.left = (parseInt(en.style.left) - speed) + 'px';
                    en.style.bottom = (parseInt(en.style.bottom) + (Math.random() - 0.5) * 10) + 'px';
                    if (parseInt(en.style.left) < gameScrollPosition - en.offsetWidth) {
                        removeElement(en, enemies, 0, 30);
                    } else if (checkCollision(player, en)) {
                        reduceLives();
                        removeElement(en, enemies, 0, 0);
                    }
                }
            });
        }

        function spawnStickyEnemy() {
            const stickyEnemy = createElement('sticky-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            stickyEnemy.style.backgroundColor = '#FFD700'; 
            stickyEnemy.style.bottom = '0px';
        }

        function moveStickyEnemies() {
            enemies.forEach(en => {
                if (en.classList.contains('sticky-enemy')) {
                    en.style.left = (parseInt(en.style.left) - 1) + 'px';
                    if (checkCollision(player, en)) {
                        player.style.backgroundColor = '#FFD700';
                        setTimeout(() => player.style.backgroundColor = '#4CAF50', 2000);
                        removeElement(en, enemies, 0, 0);
                    }
                }
            });
        }

        function spawnReflectiveEnemy() {
            const reflectiveEnemy = createElement('reflective-enemy', enemies, gameScrollPosition + gameContainer.offsetWidth);
            reflectiveEnemy.style.backgroundColor = '#20B2AA'; 
            reflectiveEnemy.style.bottom = Math.random() * 150 + 'px';
        }

        function moveReflectiveEnemies() {
            enemies.forEach((en, index) => {
                if (en.classList.contains('reflective-enemy')) {
                    en.style.left = (parseInt(en.style.left) - 1) + 'px';
                    bullets.forEach((bullet, bulletIndex) => {
                        if (checkCollision(bullet.element, en)) {
                            bullet.direction *= -1;
                        }
                    });
                    if (checkCollision(player, en)) {
                        reduceLives();
                        removeElement(en, enemies, index, 0);
                    }
                }
            });
        }
    </script>
</body>
</html>