Spaces:

LukasBe
/

dungeon-quest

Running

App Files Files Community

LukasBe commited on Apr 2, 2025

Commit

f82ba54

verified ·

1 Parent(s): e323685

Add 2 files

Browse files

Files changed (2) hide show

README.md +7 -5
index.html +1726 -19

README.md CHANGED Viewed

@@ -1,10 +1,12 @@
 ---
-title: Dungeon Quest
-emoji: 🐨
-colorFrom: green
-colorTo: pink
 sdk: static
 pinned: false
 ---
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

 ---
+title: dungeon-quest
+emoji: 🐳
+colorFrom: gray
+colorTo: red
 sdk: static
 pinned: false
+tags:
+  - deepsite
 ---
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

index.html CHANGED Viewed

@@ -1,19 +1,1726 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Prince of Persia: Forgotten Palace</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Cinzel:wght@400;700&family=MedievalSharp&display=swap');
+        :root {
+            --primary-color: #d4a76a;
+            --secondary-color: #8b4513;
+            --dark-color: #1a1a1a;
+            --light-color: #f5e6c8;
+            --danger-color: #c41e3a;
+        }
+        body {
+            font-family: 'Cinzel', serif;
+            background-color: var(--dark-color);
+            color: var(--light-color);
+            overflow: hidden;
+            touch-action: none;
+            user-select: none;
+        }
+        #game-container {
+            position: relative;
+            width: 100vw;
+            height: 100vh;
+            overflow: hidden;
+        }
+        #game-canvas {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background-color: #222;
+        }
+        #ui-overlay {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+        }
+        .health-bar {
+            position: absolute;
+            top: 20px;
+            left: 20px;
+            width: 200px;
+            height: 30px;
+            background-color: rgba(0, 0, 0, 0.5);
+            border: 2px solid var(--primary-color);
+            border-radius: 5px;
+            overflow: hidden;
+        }
+        .health-fill {
+            height: 100%;
+            width: 100%;
+            background-color: var(--danger-color);
+            transition: width 0.3s ease;
+        }
+        .controls {
+            position: absolute;
+            bottom: 20px;
+            width: 100%;
+            display: flex;
+            justify-content: space-between;
+            padding: 0 20px;
+            pointer-events: auto;
+        }
+        .mobile-control {
+            width: 70px;
+            height: 70px;
+            background-color: rgba(255, 255, 255, 0.2);
+            border-radius: 50%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-size: 24px;
+            color: white;
+            touch-action: manipulation;
+        }
+        #start-screen, #game-over-screen, #victory-screen {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            background-color: rgba(0, 0, 0, 0.8);
+            z-index: 100;
+        }
+        .title {
+            font-size: 4rem;
+            color: var(--primary-color);
+            text-shadow: 0 0 10px rgba(212, 167, 106, 0.5);
+            margin-bottom: 2rem;
+            font-weight: 700;
+            letter-spacing: 3px;
+        }
+        .btn {
+            background-color: var(--primary-color);
+            color: var(--dark-color);
+            padding: 12px 30px;
+            border: none;
+            border-radius: 5px;
+            font-size: 1.2rem;
+            font-weight: bold;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            margin-top: 20px;
+            font-family: 'Cinzel', serif;
+        }
+        .btn:hover {
+            background-color: var(--light-color);
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+        }
+        .story-text {
+            max-width: 600px;
+            text-align: center;
+            margin-bottom: 30px;
+            line-height: 1.6;
+            font-size: 1.1rem;
+        }
+        #touch-controls {
+            display: none;
+        }
+        @media (max-width: 768px) {
+            #touch-controls {
+                display: flex;
+            }
+            .title {
+                font-size: 2.5rem;
+            }
+        }
+        /* Animation for torch flicker */
+        @keyframes torch-flicker {
+            0%, 100% { opacity: 0.8; }
+            25% { opacity: 1; }
+            50% { opacity: 0.7; }
+            75% { opacity: 0.9; }
+        }
+        /* Animation for sword slash */
+        @keyframes sword-slash {
+            0% { transform: rotate(0deg); }
+            50% { transform: rotate(90deg); }
+            100% { transform: rotate(0deg); }
+        }
+        /* Dust particle animation */
+        @keyframes dust-particle {
+            0% { transform: translateY(0) scale(1); opacity: 1; }
+            100% { transform: translateY(-50px) scale(0.5); opacity: 0; }
+        }
+    </style>
+</head>
+<body>
+    <div id="game-container">
+        <canvas id="game-canvas"></canvas>
+        <div id="ui-overlay">
+            <div class="health-bar">
+                <div id="health-fill" class="health-fill" style="width: 100%;"></div>
+            </div>
+            <div id="touch-controls" class="controls">
+                <div id="left-btn" class="mobile-control">←</div>
+                <div id="right-btn" class="mobile-control">→</div>
+                <div id="jump-btn" class="mobile-control">↑</div>
+                <div id="attack-btn" class="mobile-control">⚔️</div>
+            </div>
+        </div>
+        <div id="start-screen">
+            <h1 class="title">PRINCE OF PERSIA</h1>
+            <p class="story-text">The ancient palace holds many secrets... and dangers. You must navigate its treacherous halls, overcome deadly traps, and defeat the guards that stand between you and freedom.</p>
+            <button id="start-btn" class="btn">BEGIN YOUR QUEST</button>
+        </div>
+        <div id="game-over-screen" style="display: none;">
+            <h1 class="title">DEFEATED</h1>
+            <p class="story-text">The palace has claimed another victim. Will you rise to the challenge once more?</p>
+            <button id="restart-btn" class="btn">TRY AGAIN</button>
+        </div>
+        <div id="victory-screen" style="display: none;">
+            <h1 class="title">VICTORY</h1>
+            <p class="story-text">You have escaped the forgotten palace... but your journey is far from over.</p>
+            <button id="next-level-btn" class="btn">CONTINUE</button>
+        </div>
+    </div>
+    <script>
+        // Game Constants
+        const GAME_WIDTH = 1280;
+        const GAME_HEIGHT = 720;
+        const GRAVITY = 0.5;
+        const PLAYER_SPEED = 5;
+        const JUMP_FORCE = -12;
+        const PLAYER_WIDTH = 50;
+        const PLAYER_HEIGHT = 80;
+        const TILE_SIZE = 40;
+        // Game State
+        let gameState = {
+            player: {
+                x: 100,
+                y: GAME_HEIGHT - PLAYER_HEIGHT - 100,
+                width: PLAYER_WIDTH,
+                height: PLAYER_HEIGHT,
+                velocityX: 0,
+                velocityY: 0,
+                isJumping: false,
+                isAttacking: false,
+                isBlocking: false,
+                health: 100,
+                maxHealth: 100,
+                facingRight: true,
+                attackCooldown: 0,
+                invincible: false,
+                invincibleTimer: 0
+            },
+            enemies: [],
+            platforms: [],
+            traps: [],
+            torches: [],
+            particles: [],
+            camera: {
+                x: 0,
+                y: 0,
+                targetX: 0,
+                targetY: 0,
+                zoom: 1
+            },
+            keys: {
+                left: false,
+                right: false,
+                up: false,
+                down: false,
+                attack: false,
+                block: false
+            },
+            gameStarted: false,
+            gameOver: false,
+            victory: false,
+            levelBounds: {
+                left: 0,
+                right: 3000,
+                top: 0,
+                bottom: GAME_HEIGHT
+            },
+            checkpoints: [],
+            currentCheckpoint: 0,
+            lastTime: 0,
+            deltaTime: 0
+        };
+        // DOM Elements
+        const canvas = document.getElementById('game-canvas');
+        const ctx = canvas.getContext('2d');
+        const startScreen = document.getElementById('start-screen');
+        const gameOverScreen = document.getElementById('game-over-screen');
+        const victoryScreen = document.getElementById('victory-screen');
+        const startBtn = document.getElementById('start-btn');
+        const restartBtn = document.getElementById('restart-btn');
+        const nextLevelBtn = document.getElementById('next-level-btn');
+        const healthFill = document.getElementById('health-fill');
+        const leftBtn = document.getElementById('left-btn');
+        const rightBtn = document.getElementById('right-btn');
+        const jumpBtn = document.getElementById('jump-btn');
+        const attackBtn = document.getElementById('attack-btn');
+        // Initialize Game
+        function initGame() {
+            // Set canvas size
+            resizeCanvas();
+            window.addEventListener('resize', resizeCanvas);
+            // Initialize level
+            createLevel();
+            // Event listeners
+            startBtn.addEventListener('click', startGame);
+            restartBtn.addEventListener('click', restartGame);
+            nextLevelBtn.addEventListener('click', nextLevel);
+            // Keyboard controls
+            document.addEventListener('keydown', handleKeyDown);
+            document.addEventListener('keyup', handleKeyUp);
+            // Touch controls
+            leftBtn.addEventListener('touchstart', () => gameState.keys.left = true);
+            leftBtn.addEventListener('touchend', () => gameState.keys.left = false);
+            rightBtn.addEventListener('touchstart', () => gameState.keys.right = true);
+            rightBtn.addEventListener('touchend', () => gameState.keys.right = false);
+            jumpBtn.addEventListener('touchstart', () => gameState.keys.up = true);
+            jumpBtn.addEventListener('touchend', () => gameState.keys.up = false);
+            attackBtn.addEventListener('touchstart', () => gameState.keys.attack = true);
+            attackBtn.addEventListener('touchend', () => gameState.keys.attack = false);
+            // Start game loop
+            requestAnimationFrame(gameLoop);
+        }
+        // Resize canvas to fit window
+        function resizeCanvas() {
+            canvas.width = window.innerWidth;
+            canvas.height = window.innerHeight;
+        }
+        // Create level elements
+        function createLevel() {
+            // Platforms
+            gameState.platforms = [
+                // Ground
+                { x: 0, y: GAME_HEIGHT - 50, width: 3000, height: 50 },
+                // First platform
+                { x: 300, y: GAME_HEIGHT - 150, width: 200, height: 20 },
+                // Second platform (collapsing)
+                { x: 600, y: GAME_HEIGHT - 200, width: 150, height: 20, collapsing: true, collapseTimer: 0 },
+                // Third platform
+                { x: 900, y: GAME_HEIGHT - 250, width: 200, height: 20 },
+                // Final platform before exit
+                { x: 2500, y: GAME_HEIGHT - 300, width: 200, height: 20 }
+            ];
+            // Traps
+            gameState.traps = [
+                // Spike pit
+                { x: 800, y: GAME_HEIGHT - 50, width: 100, height: 50, type: 'spikes' },
+                // Rolling blade
+                { x: 1200, y: GAME_HEIGHT - 300, width: 20, height: 200, type: 'blade', direction: 1, speed: 3 },
+                // Pressure plate
+                { x: 1500, y: GAME_HEIGHT - 30, width: 40, height: 20, type: 'pressurePlate', triggered: false }
+            ];
+            // Torches
+            gameState.torches = [
+                { x: 200, y: GAME_HEIGHT - 150, lit: true, flicker: 0 },
+                { x: 500, y: GAME_HEIGHT - 200, lit: true, flicker: 0 },
+                { x: 850, y: GAME_HEIGHT - 250, lit: true, flicker: 0 },
+                { x: 1200, y: GAME_HEIGHT - 300, lit: true, flicker: 0 }
+            ];
+            // Enemies
+            gameState.enemies = [
+                // First guard
+                {
+                    x: 400,
+                    y: GAME_HEIGHT - 170,
+                    width: 40,
+                    height: 70,
+                    health: 50,
+                    speed: 2,
+                    direction: -1,
+                    isAttacking: false,
+                    attackCooldown: 0,
+                    type: 'guard'
+                },
+                // Second guard
+                {
+                    x: 950,
+                    y: GAME_HEIGHT - 270,
+                    width: 40,
+                    height: 70,
+                    health: 50,
+                    speed: 2,
+                    direction: -1,
+                    isAttacking: false,
+                    attackCooldown: 0,
+                    type: 'guard'
+                },
+                // Elite guard (final enemy)
+                {
+                    x: 2550,
+                    y: GAME_HEIGHT - 320,
+                    width: 50,
+                    height: 80,
+                    health: 100,
+                    speed: 3,
+                    direction: -1,
+                    isAttacking: false,
+                    attackCooldown: 0,
+                    type: 'elite'
+                }
+            ];
+            // Checkpoints
+            gameState.checkpoints = [
+                { x: 100, y: GAME_HEIGHT - PLAYER_HEIGHT - 100 },
+                { x: 700, y: GAME_HEIGHT - 220 },
+                { x: 1600, y: GAME_HEIGHT - 270 }
+            ];
+            gameState.currentCheckpoint = 0;
+        }
+        // Start game
+        function startGame() {
+            gameState.gameStarted = true;
+            startScreen.style.display = 'none';
+            gameState.player.x = gameState.checkpoints[0].x;
+            gameState.player.y = gameState.checkpoints[0].y;
+        }
+        // Restart game
+        function restartGame() {
+            gameState.gameOver = false;
+            gameOverScreen.style.display = 'none';
+            gameState.player.health = gameState.player.maxHealth;
+            gameState.player.x = gameState.checkpoints[gameState.currentCheckpoint].x;
+            gameState.player.y = gameState.checkpoints[gameState.currentCheckpoint].y;
+            gameState.player.velocityX = 0;
+            gameState.player.velocityY = 0;
+            gameState.player.isJumping = false;
+            gameState.player.isAttacking = false;
+            gameState.player.isBlocking = false;
+            gameState.player.invincible = false;
+            // Reset enemies
+            gameState.enemies.forEach(enemy => {
+                enemy.health = enemy.type === 'elite' ? 100 : 50;
+            });
+            // Reset traps
+            gameState.traps.forEach(trap => {
+                if (trap.type === 'pressurePlate') {
+                    trap.triggered = false;
+                }
+            });
+            // Reset collapsing platforms
+            gameState.platforms.forEach(platform => {
+                if (platform.collapsing) {
+                    platform.collapseTimer = 0;
+                }
+            });
+        }
+        // Next level (placeholder)
+        function nextLevel() {
+            victoryScreen.style.display = 'none';
+            gameState.victory = false;
+            // In a full game, this would load the next level
+            alert("This concludes the demo. Thanks for playing!");
+        }
+        // Handle keyboard input
+        function handleKeyDown(e) {
+            switch(e.key) {
+                case 'ArrowLeft':
+                case 'a':
+                    gameState.keys.left = true;
+                    break;
+                case 'ArrowRight':
+                case 'd':
+                    gameState.keys.right = true;
+                    break;
+                case 'ArrowUp':
+                case 'w':
+                case ' ':
+                    gameState.keys.up = true;
+                    break;
+                case 'ArrowDown':
+                case 's':
+                    gameState.keys.down = true;
+                    break;
+                case 'z':
+                    gameState.keys.attack = true;
+                    break;
+                case 'x':
+                    gameState.keys.block = true;
+                    break;
+            }
+        }
+        function handleKeyUp(e) {
+            switch(e.key) {
+                case 'ArrowLeft':
+                case 'a':
+                    gameState.keys.left = false;
+                    break;
+                case 'ArrowRight':
+                case 'd':
+                    gameState.keys.right = false;
+                    break;
+                case 'ArrowUp':
+                case 'w':
+                case ' ':
+                    gameState.keys.up = false;
+                    break;
+                case 'ArrowDown':
+                case 's':
+                    gameState.keys.down = false;
+                    break;
+                case 'z':
+                    gameState.keys.attack = false;
+                    break;
+                case 'x':
+                    gameState.keys.block = false;
+                    break;
+            }
+        }
+        // Game loop
+        function gameLoop(timestamp) {
+            if (!gameState.lastTime) {
+                gameState.lastTime = timestamp;
+            }
+            gameState.deltaTime = (timestamp - gameState.lastTime) / 1000;
+            gameState.lastTime = timestamp;
+            if (gameState.gameStarted && !gameState.gameOver && !gameState.victory) {
+                update();
+            }
+            render();
+            requestAnimationFrame(gameLoop);
+        }
+        // Update game state
+        function update() {
+            const { player, enemies, platforms, traps, torches, particles } = gameState;
+            // Update player
+            updatePlayer();
+            // Update enemies
+            updateEnemies();
+            // Update traps
+            updateTraps();
+            // Update platforms
+            updatePlatforms();
+            // Update torches
+            updateTorches();
+            // Update particles
+            updateParticles();
+            // Update camera
+            updateCamera();
+            // Check for victory condition
+            if (player.x > 2800 && player.y < GAME_HEIGHT - 200) {
+                gameState.victory = true;
+                victoryScreen.style.display = 'flex';
+            }
+            // Check for game over
+            if (player.health <= 0) {
+                gameState.gameOver = true;
+                gameOverScreen.style.display = 'flex';
+            }
+        }
+        // Update player
+        function updatePlayer() {
+            const { player, keys } = gameState;
+            // Horizontal movement
+            if (keys.left) {
+                player.velocityX = -PLAYER_SPEED;
+                player.facingRight = false;
+            } else if (keys.right) {
+                player.velocityX = PLAYER_SPEED;
+                player.facingRight = true;
+            } else {
+                // Apply friction
+                player.velocityX *= 0.7;
+                if (Math.abs(player.velocityX) < 0.5) player.velocityX = 0;
+            }
+            // Jumping
+            if (keys.up && !player.isJumping) {
+                player.velocityY = JUMP_FORCE;
+                player.isJumping = true;
+                createDustParticles(player.x + player.width/2, player.y + player.height, 10);
+            }
+            // Apply gravity
+            player.velocityY += GRAVITY;
+            // Update position
+            player.x += player.velocityX;
+            player.y += player.velocityY;
+            // Check for collisions with platforms
+            checkPlatformCollisions();
+            // Check for collisions with enemies
+            checkEnemyCollisions();
+            // Check for collisions with traps
+            checkTrapCollisions();
+            // Check for ledge grabbing
+            checkLedgeGrab();
+            // Update attack cooldown
+            if (player.attackCooldown > 0) {
+                player.attackCooldown -= gameState.deltaTime;
+            } else if (keys.attack) {
+                player.isAttacking = true;
+                player.attackCooldown = 0.5;
+                // Create sword slash effect
+                createSwordSlash();
+                // Check for enemy hits
+                checkAttackHit();
+                // Reset after animation would complete
+                setTimeout(() => {
+                    player.isAttacking = false;
+                }, 200);
+            }
+            // Update blocking
+            player.isBlocking = keys.block;
+            // Update invincibility timer
+            if (player.invincible) {
+                player.invincibleTimer -= gameState.deltaTime;
+                if (player.invincibleTimer <= 0) {
+                    player.invincible = false;
+                }
+            }
+            // Keep player within bounds
+            if (player.x < 0) player.x = 0;
+            if (player.x > gameState.levelBounds.right - player.width) {
+                player.x = gameState.levelBounds.right - player.width;
+            }
+            if (player.y > gameState.levelBounds.bottom - player.height) {
+                player.y = gameState.levelBounds.bottom - player.height;
+                player.velocityY = 0;
+                player.isJumping = false;
+            }
+            // Update health bar
+            healthFill.style.width = `${(player.health / player.maxHealth) * 100}%`;
+        }
+        // Check for platform collisions
+        function checkPlatformCollisions() {
+            const { player, platforms } = gameState;
+            player.isJumping = true;
+            for (const platform of platforms) {
+                // Skip if platform is collapsing and has collapsed
+                if (platform.collapsing && platform.collapseTimer >= 1) continue;
+                if (player.x < platform.x + platform.width &&
+                    player.x + player.width > platform.x &&
+                    player.y < platform.y + platform.height &&
+                    player.y + player.height > platform.y) {
+                    // Check if player is landing on top of platform
+                    if (player.velocityY > 0 && player.y + player.height - player.velocityY <= platform.y) {
+                        player.y = platform.y - player.height;
+                        player.velocityY = 0;
+                        player.isJumping = false;
+                        // Create dust particles when landing
+                        if (Math.abs(player.velocityY) > 5) {
+                            createDustParticles(player.x + player.width/2, player.y + player.height, 5);
+                        }
+                    }
+                    // Check if player hits platform from below
+                    else if (player.velocityY < 0 && player.y - player.velocityY >= platform.y + platform.height) {
+                        player.y = platform.y + platform.height;
+                        player.velocityY = 0;
+                    }
+                    // Check if player hits platform from the left
+                    else if (player.velocityX > 0 && player.x + player.width - player.velocityX <= platform.x) {
+                        player.x = platform.x - player.width;
+                        player.velocityX = 0;
+                    }
+                    // Check if player hits platform from the right
+                    else if (player.velocityX < 0 && player.x - player.velocityX >= platform.x + platform.width) {
+                        player.x = platform.x + platform.width;
+                        player.velocityX = 0;
+                    }
+                }
+            }
+        }
+        // Check for enemy collisions
+        function checkEnemyCollisions() {
+            const { player, enemies } = gameState;
+            for (const enemy of enemies) {
+                if (enemy.health <= 0) continue;
+                // Check collision with player
+                if (player.x < enemy.x + enemy.width &&
+                    player.x + player.width > enemy.x &&
+                    player.y < enemy.y + enemy.height &&
+                    player.y + player.height > enemy.y) {
+                    // If player is attacking and facing the enemy
+                    if (player.isAttacking &&
+                        ((player.facingRight && player.x < enemy.x) ||
+                         (!player.facingRight && player.x > enemy.x))) {
+                        // Enemy takes damage (handled in attack check)
+                    }
+                    // If player is blocking
+                    else if (player.isBlocking) {
+                        // Create spark effect
+                        createSparkEffect(enemy.x + enemy.width/2, enemy.y + enemy.height/2);
+                        // Small knockback
+                        if (player.x < enemy.x) {
+                            player.velocityX = -5;
+                        } else {
+                            player.velocityX = 5;
+                        }
+                    }
+                    // Otherwise, player takes damage
+                    else if (!player.invincible) {
+                        player.health -= 10;
+                        player.invincible = true;
+                        player.invincibleTimer = 1;
+                        // Knockback
+                        if (player.x < enemy.x) {
+                            player.velocityX = -8;
+                        } else {
+                            player.velocityX = 8;
+                        }
+                        player.velocityY = -5;
+                        // Blood effect
+                        createBloodParticles(player.x + player.width/2, player.y + player.height/2, 10);
+                    }
+                }
+            }
+        }
+        // Check for trap collisions
+        function checkTrapCollisions() {
+            const { player, traps } = gameState;
+            for (const trap of traps) {
+                if (trap.type === 'spikes' || trap.type === 'blade') {
+                    if (player.x < trap.x + trap.width &&
+                        player.x + player.width > trap.x &&
+                        player.y < trap.y + trap.height &&
+                        player.y + player.height > trap.y) {
+                        if (!player.invincible) {
+                            player.health -= 20;
+                            player.invincible = true;
+                            player.invincibleTimer = 1;
+                            // Knockback
+                            player.velocityY = -10;
+                            createBloodParticles(player.x + player.width/2, player.y + player.height/2, 15);
+                        }
+                    }
+                } else if (trap.type === 'pressurePlate' && !trap.triggered) {
+                    if (player.x < trap.x + trap.width &&
+                        player.x + player.width > trap.x &&
+                        player.y < trap.y + trap.height &&
+                        player.y + player.height > trap.y) {
+                        trap.triggered = true;
+                        // In a full game, this would trigger something (like opening a door)
+                        createSparkEffect(trap.x + trap.width/2, trap.y);
+                    }
+                }
+            }
+        }
+        // Check for ledge grab
+        function checkLedgeGrab() {
+            const { player, platforms } = gameState;
+            // Only check for ledge grab if player is falling and near a platform edge
+            if (player.velocityY > 0 && player.isJumping) {
+                for (const platform of platforms) {
+                    // Skip if platform is collapsing and has collapsed
+                    if (platform.collapsing && platform.collapseTimer >= 1) continue;
+                    // Check if player is near the edge of a platform
+                    const ledgeLeft = platform.x - player.width;
+                    const ledgeRight = platform.x + platform.width;
+                    // Check left edge
+                    if (player.x + player.width/2 > ledgeLeft - 10 &&
+                        player.x + player.width/2 < ledgeLeft + 10 &&
+                        player.y + player.height < platform.y - 5 &&
+                        player.y + player.height + player.velocityY >= platform.y - 5) {
+                        // Grab the ledge
+                        if (gameState.keys.down) {
+                            // Player chooses to drop
+                            return;
+                        } else {
+                            player.y = platform.y - player.height;
+                            player.velocityY = 0;
+                            player.isJumping = false;
+                            // If player presses up, climb onto platform
+                            if (gameState.keys.up) {
+                                player.y = platform.y - player.height;
+                            } else {
+                                // Otherwise, hang from the ledge
+                                player.x = ledgeLeft;
+                                player.y = platform.y - player.height + 10;
+                            }
+                            return;
+                        }
+                    }
+                    // Check right edge
+                    if (player.x + player.width/2 > ledgeRight - 10 &&
+                        player.x + player.width/2 < ledgeRight + 10 &&
+                        player.y + player.height < platform.y - 5 &&
+                        player.y + player.height + player.velocityY >= platform.y - 5) {
+                        // Grab the ledge
+                        if (gameState.keys.down) {
+                            // Player chooses to drop
+                            return;
+                        } else {
+                            player.y = platform.y - player.height;
+                            player.velocityY = 0;
+                            player.isJumping = false;
+                            // If player presses up, climb onto platform
+                            if (gameState.keys.up) {
+                                player.y = platform.y - player.height;
+                            } else {
+                                // Otherwise, hang from the ledge
+                                player.x = ledgeRight - player.width;
+                                player.y = platform.y - player.height + 10;
+                            }
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        // Check if player's attack hits an enemy
+        function checkAttackHit() {
+            const { player, enemies } = gameState;
+            for (const enemy of enemies) {
+                if (enemy.health <= 0) continue;
+                // Check if enemy is in front of player and within attack range
+                if ((player.facingRight && enemy.x > player.x && enemy.x < player.x + 100) ||
+                    (!player.facingRight && enemy.x < player.x && enemy.x > player.x - 100)) {
+                    // Check vertical overlap
+                    if (player.y + player.height > enemy.y &&
+                        player.y < enemy.y + enemy.height) {
+                        // Enemy takes damage
+                        enemy.health -= 25;
+                        // Create blood effect
+                        createBloodParticles(enemy.x + enemy.width/2, enemy.y + enemy.height/2, 10);
+                        // Knockback
+                        if (player.facingRight) {
+                            enemy.x += 20;
+                        } else {
+                            enemy.x -= 20;
+                        }
+                        // If enemy is defeated
+                        if (enemy.health <= 0) {
+                            // Create more blood
+                            createBloodParticles(enemy.x + enemy.width/2, enemy.y + enemy.height/2, 20);
+                            // Check if this was the elite guard (final enemy)
+                            if (enemy.type === 'elite') {
+                                // Create victory particles
+                                createVictoryParticles(enemy.x + enemy.width/2, enemy.y + enemy.height/2);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Update enemies
+        function updateEnemies() {
+            const { enemies, player } = gameState;
+            for (const enemy of enemies) {
+                if (enemy.health <= 0) continue;
+                // Simple AI: move toward player if nearby
+                const distanceToPlayer = Math.abs(player.x - enemy.x);
+                if (distanceToPlayer < 300) {
+                    if (player.x < enemy.x) {
+                        enemy.direction = -1;
+                    } else {
+                        enemy.direction = 1;
+                    }
+                    // Move enemy
+                    enemy.x += enemy.speed * enemy.direction;
+                    // Simple platform following
+                    let onPlatform = false;
+                    for (const platform of gameState.platforms) {
+                        // Skip if platform is collapsing and has collapsed
+                        if (platform.collapsing && platform.collapseTimer >= 1) continue;
+                        if (enemy.x >= platform.x &&
+                            enemy.x <= platform.x + platform.width &&
+                            enemy.y + enemy.height >= platform.y - 5 &&
+                            enemy.y + enemy.height <= platform.y + 5) {
+                            onPlatform = true;
+                            enemy.y = platform.y - enemy.height;
+                            // Check if enemy is at edge of platform
+                            if ((enemy.direction === -1 && enemy.x <= platform.x) ||
+                                (enemy.direction === 1 && enemy.x + enemy.width >= platform.x + platform.width)) {
+                                enemy.direction *= -1;
+                            }
+                            break;
+                        }
+                    }
+                    // Apply gravity if not on platform
+                    if (!onPlatform) {
+                        enemy.y += 5;
+                    }
+                    // Attack if close enough
+                    if (distanceToPlayer < 60 && enemy.attackCooldown <= 0) {
+                        enemy.isAttacking = true;
+                        enemy.attackCooldown = 1.5;
+                        // Check if attack hits player
+                        if (Math.abs(player.y - enemy.y) < 30 && !player.invincible) {
+                            player.health -= 10;
+                            player.invincible = true;
+                            player.invincibleTimer = 1;
+                            // Knockback
+                            if (player.x < enemy.x) {
+                                player.velocityX = -8;
+                            } else {
+                                player.velocityX = 8;
+                            }
+                            player.velocityY = -5;
+                            // Blood effect
+                            createBloodParticles(player.x + player.width/2, player.y + player.height/2, 10);
+                        }
+                        setTimeout(() => {
+                            enemy.isAttacking = false;
+                        }, 300);
+                    }
+                }
+                // Update attack cooldown
+                if (enemy.attackCooldown > 0) {
+                    enemy.attackCooldown -= gameState.deltaTime;
+                }
+            }
+        }
+        // Update traps
+        function updateTraps() {
+            const { traps } = gameState;
+            for (const trap of traps) {
+                if (trap.type === 'blade') {
+                    // Move blade back and forth
+                    trap.x += trap.speed * trap.direction;
+                    // Reverse direction at bounds
+                    if (trap.x < 1100 || trap.x > 1300) {
+                        trap.direction *= -1;
+                    }
+                } else if (trap.type === 'pressurePlate' && trap.triggered) {
+                    // In a full game, this would trigger something (like opening a door)
+                }
+            }
+        }
+        // Update platforms
+        function updatePlatforms() {
+            const { platforms } = gameState;
+            for (const platform of platforms) {
+                if (platform.collapsing) {
+                    // Check if player is on the platform
+                    const { player } = gameState;
+                    if (player.x >= platform.x &&
+                        player.x <= platform.x + platform.width &&
+                        player.y + player.height >= platform.y - 5 &&
+                        player.y + player.height <= platform.y + 5) {
+                        // Start collapse timer
+                        platform.collapseTimer += gameState.deltaTime;
+                        // Create shaking effect
+                        if (platform.collapseTimer < 1) {
+                            platform.x += Math.sin(platform.collapseTimer * 30) * 2;
+                        }
+                        // Platform disappears after timer reaches 1
+                        if (platform.collapseTimer >= 1) {
+                            // Create falling debris particles
+                            createDebrisParticles(platform.x + platform.width/2, platform.y + platform.height/2, 20);
+                        }
+                    }
+                }
+            }
+        }
+        // Update torches
+        function updateTorches() {
+            const { torches } = gameState;
+            for (const torch of torches) {
+                torch.flicker = Math.random();
+            }
+        }
+        // Update particles
+        function updateParticles() {
+            const { particles } = gameState;
+            for (let i = particles.length - 1; i >= 0; i--) {
+                const p = particles[i];
+                p.x += p.velocityX;
+                p.y += p.velocityY;
+                p.life -= gameState.deltaTime;
+                if (p.life <= 0) {
+                    particles.splice(i, 1);
+                }
+            }
+        }
+        // Update camera
+        function updateCamera() {
+            const { camera, player } = gameState;
+            // Camera follows player with some delay
+            camera.targetX = player.x - canvas.width / 3;
+            camera.targetY = player.y - canvas.height / 2;
+            // Smooth camera movement
+            camera.x += (camera.targetX - camera.x) * 0.1;
+            camera.y += (camera.targetY - camera.y) * 0.1;
+            // Keep camera within level bounds
+            camera.x = Math.max(0, Math.min(camera.x, gameState.levelBounds.right - canvas.width));
+            camera.y = Math.max(0, Math.min(camera.y, gameState.levelBounds.bottom - canvas.height));
+            // Zoom in slightly when attacking
+            if (player.isAttacking) {
+                camera.zoom = 1.1;
+            } else {
+                camera.zoom = 1;
+            }
+        }
+        // Create dust particles
+        function createDustParticles(x, y, count) {
+            for (let i = 0; i < count; i++) {
+                gameState.particles.push({
+                    x: x,
+                    y: y,
+                    velocityX: (Math.random() - 0.5) * 2,
+                    velocityY: -Math.random() * 2,
+                    size: Math.random() * 3 + 1,
+                    color: '#d4a76a',
+                    life: Math.random() * 0.5 + 0.5,
+                    type: 'dust'
+                });
+            }
+        }
+        // Create blood particles
+        function createBloodParticles(x, y, count) {
+            for (let i = 0; i < count; i++) {
+                gameState.particles.push({
+                    x: x,
+                    y: y,
+                    velocityX: (Math.random() - 0.5) * 10,
+                    velocityY: (Math.random() - 0.5) * 10,
+                    size: Math.random() * 4 + 2,
+                    color: '#c41e3a',
+                    life: Math.random() * 1 + 0.5,
+                    type: 'blood'
+                });
+            }
+        }
+        // Create spark effect
+        function createSparkEffect(x, y) {
+            for (let i = 0; i < 10; i++) {
+                gameState.particles.push({
+                    x: x,
+                    y: y,
+                    velocityX: (Math.random() - 0.5) * 10,
+                    velocityY: (Math.random() - 0.5) * 10,
+                    size: Math.random() * 2 + 1,
+                    color: '#ffffff',
+                    life: Math.random() * 0.3 + 0.2,
+                    type: 'spark'
+                });
+            }
+        }
+        // Create debris particles
+        function createDebrisParticles(x, y, count) {
+            for (let i = 0; i < count; i++) {
+                gameState.particles.push({
+                    x: x,
+                    y: y,
+                    velocityX: (Math.random() - 0.5) * 5,
+                    velocityY: -Math.random() * 5,
+                    size: Math.random() * 6 + 3,
+                    color: '#8b4513',
+                    life: Math.random() * 1 + 0.5,
+                    type: 'debris'
+                });
+            }
+        }
+        // Create victory particles
+        function createVictoryParticles(x, y) {
+            for (let i = 0; i < 30; i++) {
+                gameState.particles.push({
+                    x: x,
+                    y: y,
+                    velocityX: (Math.random() - 0.5) * 10,
+                    velocityY: (Math.random() - 0.5) * 10,
+                    size: Math.random() * 4 + 2,
+                    color: ['#ffd700', '#ffffff', '#d4a76a'][Math.floor(Math.random() * 3)],
+                    life: Math.random() * 1.5 + 0.5,
+                    type: 'victory'
+                });
+            }
+        }
+        // Create sword slash effect
+        function createSwordSlash() {
+            const { player } = gameState;
+            gameState.particles.push({
+                x: player.facingRight ? player.x + player.width : player.x,
+                y: player.y + player.height/2,
+                velocityX: 0,
+                velocityY: 0,
+                size: 30,
+                color: '#ffffff',
+                life: 0.2,
+                type: 'swordSlash',
+                facingRight: player.facingRight
+            });
+        }
+        // Render game
+        function render() {
+            const { camera, player, platforms, enemies, traps, torches, particles } = gameState;
+            // Clear canvas
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            // Save context
+            ctx.save();
+            // Apply camera transform
+            ctx.translate(-camera.x, -camera.y);
+            ctx.scale(camera.zoom, camera.zoom);
+            // Draw background
+            drawBackground();
+            // Draw platforms
+            drawPlatforms();
+            // Draw traps
+            drawTraps();
+            // Draw torches
+            drawTorches();
+            // Draw enemies
+            drawEnemies();
+            // Draw player
+            drawPlayer();
+            // Draw particles
+            drawParticles();
+            // Draw exit door
+            drawExit();
+            // Restore context
+            ctx.restore();
+            // Draw UI elements (not affected by camera)
+            drawUI();
+        }
+        // Draw background
+        function drawBackground() {
+            const { camera } = gameState;
+            // Draw sky gradient
+            const skyGradient = ctx.createLinearGradient(0, 0, 0, GAME_HEIGHT);
+            skyGradient.addColorStop(0, '#1a1a2e');
+            skyGradient.addColorStop(1, '#16213e');
+            ctx.fillStyle = skyGradient;
+            ctx.fillRect(0, 0, gameState.levelBounds.right, GAME_HEIGHT);
+            // Draw distant mountains
+            ctx.fillStyle = '#0f3460';
+            for (let i = 0; i < 5; i++) {
+                const x = i * 600 - (camera.x * 0.2) % 600;
+                const height = 150 + Math.sin(i) * 50;
+                ctx.beginPath();
+                ctx.moveTo(x, GAME_HEIGHT);
+                ctx.lineTo(x + 300, GAME_HEIGHT - height);
+                ctx.lineTo(x + 600, GAME_HEIGHT);
+                ctx.closePath();
+                ctx.fill();
+            }
+            // Draw palace walls (parallax background)
+            ctx.fillStyle = '#3d3d3d';
+            for (let i = 0; i < 10; i++) {
+                const x = i * 400 - (camera.x * 0.5) % 400;
+                ctx.fillRect(x, GAME_HEIGHT - 300, 200, 300);
+                // Draw window details
+                ctx.fillStyle = '#1a1a1a';
+                ctx.fillRect(x + 50, GAME_HEIGHT - 250, 100, 150);
+                ctx.fillStyle = '#3d3d3d';
+                // Draw pillars
+                ctx.fillRect(x + 190, GAME_HEIGHT - 400, 20, 400);
+            }
+        }
+        // Draw platforms
+        function drawPlatforms() {
+            const { platforms } = gameState;
+            for (const platform of platforms) {
+                // Skip if platform is collapsing and has collapsed
+                if (platform.collapsing && platform.collapseTimer >= 1) continue;
+                // Draw platform base
+                ctx.fillStyle = '#8b4513';
+                ctx.fillRect(platform.x, platform.y, platform.width, platform.height);
+                // Draw platform details
+                ctx.fillStyle = '#6b3100';
+                for (let i = 0; i < platform.width; i += 40) {
+                    ctx.fillRect(platform.x + i, platform.y, 40, 5);
+                }
+                // Draw cracks if platform is collapsing
+                if (platform.collapsing && platform.collapseTimer > 0) {
+                    ctx.strokeStyle = '#ffffff';
+                    ctx.lineWidth = 2;
+                    const crackCount = Math.floor(platform.collapseTimer * 5);
+                    for (let i = 0; i < crackCount; i++) {
+                        const startX = platform.x + Math.random() * platform.width;
+                        const startY = platform.y + Math.random() * platform.height;
+                        const length = 10 + Math.random() * 20;
+                        const angle = Math.random() * Math.PI;
+                        ctx.beginPath();
+                        ctx.moveTo(startX, startY);
+                        ctx.lineTo(startX + Math.cos(angle) * length, startY + Math.sin(angle) * length);
+                        ctx.stroke();
+                    }
+                }
+            }
+        }
+        // Draw traps
+        function drawTraps() {
+            const { traps } = gameState;
+            for (const trap of traps) {
+                if (trap.type === 'spikes') {
+                    // Draw spike pit
+                    ctx.fillStyle = '#333333';
+                    ctx.fillRect(trap.x, trap.y, trap.width, trap.height);
+                    // Draw spikes
+                    ctx.fillStyle = '#666666';
+                    const spikeCount = Math.floor(trap.width / 10);
+                    for (let i = 0; i < spikeCount; i++) {
+                        ctx.beginPath();
+                        ctx.moveTo(trap.x + i * 10 + 5, trap.y + trap.height);
+                        ctx.lineTo(trap.x + i * 10, trap.y);
+                        ctx.lineTo(trap.x + i * 10 + 10, trap.y);
+                        ctx.closePath();
+                        ctx.fill();
+                    }
+                } else if (trap.type === 'blade') {
+                    // Draw rolling blade
+                    ctx.fillStyle = '#999999';
+                    ctx.beginPath();
+                    ctx.arc(trap.x + trap.width/2, trap.y + trap.height/2, trap.width/2, 0, Math.PI * 2);
+                    ctx.fill();
+                    // Draw blade edges
+                    ctx.strokeStyle = '#333333';
+                    ctx.lineWidth = 3;
+                    ctx.beginPath();
+                    ctx.arc(trap.x + trap.width/2, trap.y + trap.height/2, trap.width/2 - 5, 0, Math.PI * 2);
+                    ctx.stroke();
+                    // Draw spikes on blade
+                    ctx.fillStyle = '#ff0000';
+                    for (let i = 0; i < 8; i++) {
+                        const angle = (i / 8) * Math.PI * 2;
+                        const spikeX = trap.x + trap.width/2 + Math.cos(angle) * (trap.width/2 - 5);
+                        const spikeY = trap.y + trap.height/2 + Math.sin(angle) * (trap.height/2 - 5);
+                        ctx.beginPath();
+                        ctx.moveTo(spikeX, spikeY);
+                        ctx.lineTo(
+                            spikeX + Math.cos(angle) * 10,
+                            spikeY + Math.sin(angle) * 10
+                        );
+                        ctx.lineWidth = 3;
+                        ctx.stroke();
+                    }
+                } else if (trap.type === 'pressurePlate') {
+                    // Draw pressure plate
+                    ctx.fillStyle = trap.triggered ? '#555555' : '#999999';
+                    ctx.fillRect(trap.x, trap.y, trap.width, trap.height);
+                    // Draw plate details
+                    ctx.strokeStyle = '#333333';
+                    ctx.lineWidth = 2;
+                    ctx.strokeRect(trap.x + 2, trap.y + 2, trap.width - 4, trap.height - 4);
+                }
+            }
+        }
+        // Draw torches
+        function drawTorches() {
+            const { torches } = gameState;
+            for (const torch of torches) {
+                // Draw torch holder
+                ctx.fillStyle = '#8b4513';
+                ctx.fillRect(torch.x - 5, torch.y - 40, 10, 40);
+                // Draw torch base
+                ctx.fillStyle = '#6b3100';
+                ctx.beginPath();
+                ctx.arc(torch.x, torch.y - 10, 10, 0, Math.PI * 2);
+                ctx.fill();
+                // Draw flame
+                if (torch.lit) {
+                    const opacity = 0.6 + torch.flicker * 0.4;
+                    const flameGradient = ctx.createRadialGradient(
+                        torch.x, torch.y - 25, 5,
+                        torch.x, torch.y - 25, 15
+                    );
+                    flameGradient.addColorStop(0, `rgba(255, 200, 0, ${opacity})`);
+                    flameGradient.addColorStop(0.5, `rgba(255, 100, 0, ${opacity * 0.7})`);
+                    flameGradient.addColorStop(1, `rgba(255, 50, 0, 0)`);
+                    ctx.fillStyle = flameGradient;
+                    ctx.beginPath();
+                    ctx.moveTo(torch.x - 10, torch.y - 10);
+                    ctx.quadraticCurveTo(torch.x, torch.y - 50, torch.x + 10, torch.y - 10);
+                    ctx.fill();
+                    // Draw light cast by torch
+                    const lightGradient = ctx.createRadialGradient(
+                        torch.x, torch.y - 15, 0,
+                        torch.x, torch.y - 15, 100
+                    );
+                    lightGradient.addColorStop(0, `rgba(255, 200, 100, ${0.1 + torch.flicker * 0.05})`);
+                    lightGradient.addColorStop(1, `rgba(0, 0, 0, 0)`);
+                    ctx.fillStyle = lightGradient;
+                    ctx.fillRect(torch.x - 100, torch.y - 115, 200, 200);
+                }
+            }
+        }
+        // Draw enemies
+        function drawEnemies() {
+            const { enemies } = gameState;
+            for (const enemy of enemies) {
+                if (enemy.health <= 0) continue;
+                // Draw enemy body
+                ctx.fillStyle = enemy.type === 'elite' ? '#4a4a4a' : '#555555';
+                ctx.fillRect(enemy.x, enemy.y, enemy.width, enemy.height);
+                // Draw enemy head
+                ctx.fillStyle = enemy.type === 'elite' ? '#d4a76a' : '#8b4513';
+                ctx.beginPath();
+                ctx.arc(
+                    enemy.x + enemy.width/2,
+                    enemy.y - 10,
+                    15,
+                    0,
+                    Math.PI * 2
+                );
+                ctx.fill();
+                // Draw enemy eyes
+                ctx.fillStyle = '#ffffff';
+                ctx.beginPath();
+                ctx.arc(
+                    enemy.x + enemy.width/2 - 5,
+                    enemy.y - 15,
+                    3,
+                    0,
+                    Math.PI * 2
+                );
+                ctx.arc(
+                    enemy.x + enemy.width/2 + 5,
+                    enemy.y - 15,
+                    3,
+                    0,
+                    Math.PI * 2
+                );
+                ctx.fill();
+                // Draw enemy weapon
+                ctx.strokeStyle = '#999999';
+                ctx.lineWidth = 3;
+                ctx.beginPath();
+                if (enemy.isAttacking) {
+                    // Draw sword in attack position
+                    ctx.moveTo(
+                        enemy.x + (enemy.direction === 1 ? enemy.width : 0),
+                        enemy.y + 20
+                    );
+                    ctx.lineTo(
+                        enemy.x + (enemy.direction === 1 ? enemy.width + 30 : -30),
+                        enemy.y + 40
+                    );
+                } else {
+                    // Draw sword in ready position
+                    ctx.moveTo(
+                        enemy.x + (enemy.direction === 1 ? enemy.width : 0),
+                        enemy.y + 20
+                    );
+                    ctx.lineTo(
+                        enemy.x + (enemy.direction === 1 ? enemy.width + 10 : -10),
+                        enemy.y + 40
+                    );
+                }
+                ctx.stroke();
+                // Draw enemy health bar if damaged
+                if (enemy.health < (enemy.type === 'elite' ? 100 : 50)) {
+                    const healthWidth = 40;
+                    const healthPercent = enemy.health / (enemy.type === 'elite' ? 100 : 50);
+                    ctx.fillStyle = '#333333';
+                    ctx.fillRect(
+                        enemy.x + enemy.width/2 - healthWidth/2,
+                        enemy.y - 30,
+                        healthWidth,
+                        5
+                    );
+                    ctx.fillStyle = healthPercent > 0.5 ? '#00ff00' : healthPercent > 0.25 ? '#ffff00' : '#ff0000';
+                    ctx.fillRect(
+                        enemy.x + enemy.width/2 - healthWidth/2,
+                        enemy.y - 30,
+                        healthWidth * healthPercent,
+                        5
+                    );
+                }
+            }
+        }
+        // Draw player
+        function drawPlayer() {
+            const { player } = gameState;
+            // Draw player body
+            ctx.fillStyle = player.invincible && Math.floor(Date.now() / 100) % 2 === 0 ?
+                'rgba(212, 167, 106, 0.5)' : '#d4a76a';
+            ctx.fillRect(player.x, player.y, player.width, player.height);
+            // Draw player head
+            ctx.fillStyle = '#8b4513';
+            ctx.beginPath();
+            ctx.arc(
+                player.x + player.width/2,
+                player.y - 10,
+                15,
+                0,
+                Math.PI * 2
+            );
+            ctx.fill();
+            // Draw player eyes
+            ctx.fillStyle = '#ffffff';
+            ctx.beginPath();
+            ctx.arc(
+                player.x + player.width/2 - (player.facingRight ? 5 : 8),
+                player.y - 15,
+                3,
+                0,
+                Math.PI * 2
+            );
+            ctx.arc(
+                player.x + player.width/2 + (player.facingRight ? 8 : 5),
+                player.y - 15,
+                3,
+                0,
+                Math.PI * 2
+            );
+            ctx.fill();
+            // Draw player weapon if attacking
+            if (player.isAttacking) {
+                ctx.strokeStyle = '#ffffff';
+                ctx.lineWidth = 4;
+                ctx.beginPath();
+                ctx.moveTo(
+                    player.x + (player.facingRight ? player.width : 0),
+                    player.y + 20
+                );
+                ctx.lineTo(
+                    player.x + (player.facingRight ? player.width + 40 : -40),
+                    player.y + 30
+                );
+                ctx.stroke();
+            }
+            // Draw player cape
+            ctx.fillStyle = player.invincible && Math.floor(Date.now() / 100) % 2 === 0 ?
+                'rgba(139, 0, 0, 0.5)' : '#8b0000';
+            ctx.beginPath();
+            ctx.moveTo(player.x, player.y + 10);
+            ctx.quadraticCurveTo(
+                player.x - 15,
+                player.y + player.height/2,
+                player.x,
+                player.y + player.height
+            );
+            ctx.quadraticCurveTo(
+                player.x + 10,
+                player.y + player.height/2,
+                player.x,
+                player.y + 10
+            );
+            ctx.fill();
+            // Draw player shadow
+            ctx.fillStyle = 'rgba(0, 0, 0, 0.3)';
+            ctx.beginPath();
+            ctx.ellipse(
+                player.x + player.width/2,
+                player.y + player.height + 5,
+                player.width/2,
+                5,
+                0,
+                0,
+                Math.PI * 2
+            );
+            ctx.fill();
+        }
+        // Draw particles
+        function drawParticles() {
+            const { particles } = gameState;
+            for (const p of particles) {
+                if (p.type === 'dust') {
+                    ctx.fillStyle = p.color;
+                    ctx.beginPath();
+                    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else if (p.type === 'blood') {
+                    ctx.fillStyle = p.color;
+                    ctx.beginPath();
+                    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else if (p.type === 'spark') {
+                    ctx.fillStyle = p.color;
+                    ctx.beginPath();
+                    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else if (p.type === 'debris') {
+                    ctx.fillStyle = p.color;
+                    ctx.fillRect(p.x - p.size/2, p.y - p.size/2, p.size, p.size);
+                } else if (p.type === 'victory') {
+                    ctx.fillStyle = p.color;
+                    ctx.beginPath();
+                    ctx.arc(p.x, p.y, p.size, 0, Math.PI * 2);
+                    ctx.fill();
+                } else if (p.type === 'swordSlash') {
+                    const gradient = ctx.createLinearGradient(
+                        p.x,
+                        p.y - 20,
+                        p.x,
+                        p.y + 20
+                    );
+                    gradient.addColorStop(0, 'rgba(255, 255, 255, 0.8)');
+                    gradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
+                    ctx.fillStyle = gradient;
+                    ctx.beginPath();
+                    if (p.facingRight) {
+                        ctx.moveTo(p.x, p.y - 20);
+                        ctx.lineTo(p.x + 40, p.y);
+                        ctx.lineTo(p.x, p.y + 20);
+                    } else {
+                        ctx.moveTo(p.x, p.y - 20);
+                        ctx.lineTo(p.x - 40, p.y);
+                        ctx.lineTo(p.x, p.y + 20);
+                    }
+                    ctx.closePath();
+                    ctx.fill();
+                }
+            }
+        }
+        // Draw exit door
+        function drawExit() {
+            const { player } = gameState;
+            // Draw exit door
+            ctx.fillStyle = '#6b3100';
+            ctx.fillRect(2800, GAME_HEIGHT - 250, 50, 200);
+            // Draw door details
+            ctx.fillStyle = '#8b4513';
+            ctx.fillRect(2805, GAME_HEIGHT - 245, 40, 190);
+            // Draw door handle
+            ctx.fillStyle = '#d4a76a';
+            ctx.beginPath();
+            ctx.arc(2830, GAME_HEIGHT - 150, 5, 0, Math.PI * 2);
+            ctx.fill();
+            // Draw glowing effect if player is near
+            if (player.x > 2700) {
+                const gradient = ctx.createRadialGradient(
+                    2825, GAME_HEIGHT - 150, 0,
+                    2825, GAME_HEIGHT - 150, 100
+                );
+                gradient.addColorStop(0, 'rgba(255, 255, 255, 0.5)');
+                gradient.addColorStop(1, 'rgba(255, 255, 255, 0)');
+                ctx.fillStyle = gradient;
+                ctx.fillRect(2725, GAME_HEIGHT - 250, 200, 200);
+            }
+        }
+        // Draw UI
+        function drawUI() {
+            // In a full game, this would draw more UI elements
+            // Currently handled by HTML/CSS
+        }
+        // Initialize the game when the page loads
+        window.addEventListener('load', initGame);
+    </script>
+<p style="border-radius: 8px; text-align: center; font-size: 12px; color: #fff; margin-top: 16px;position: fixed; left: 8px; bottom: 8px; z-index: 10; background: rgba(0, 0, 0, 0.8); padding: 4px 8px;">Made with <img src="https://enzostvs-deepsite.hf.space/logo.svg" alt="DeepSite Logo" style="width: 16px; height: 16px; vertical-align: middle;display:inline-block;margin-right:3px;filter:brightness(0) invert(1);"><a href="https://enzostvs-deepsite.hf.space" style="color: #fff;text-decoration: underline;" target="_blank" >DeepSite</a> - <a href="https://enzostvs-deepsite.hf.space?remix=LukasBe/dungeon-quest" style="color: #fff;text-decoration: underline;" target="_blank" >🧬 Remix</a></p></body>
+</html>