Skip to content
TheChatArchiveThe Chat Archive
grok-3-mini-beta· xAIHugging Face LMArena Human Preference 140K

create a visually stunning playable classic snake game for mobile devices in html code,…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro-preview-03-25’s answer.
  1. User

    create a visually stunning playable classic snake game for mobile devices in html code, that i can paste and run in an online editor

  2. Assistant

    Below is a complete, self-contained HTML file that implements a visually stunning, playable classic Snake game. You can copy and paste this code directly into an online editor like CodePen, JSFiddle, or any HTML file editor (e.g., open it in a browser after saving as an .html file).

    Key Features:

    • Visually Stunning: The game uses a modern design with gradients for the snake (fading colors), a glowing effect for the food, and a subtle grid background. The snake's head is styled differently for emphasis.
    • Mobile-Friendly: It supports touch swipe gestures for controlling the snake (e.g., swipe left/right/up/down). The game is responsive and scales to fit the device's screen.
    • Classic Gameplay: The snake moves automatically, grows when eating food, and the game ends on collisions. Includes a score display and a game over screen with a restart option.
    • Performance: Uses HTML5 Canvas for smooth rendering and requestAnimationFrame for the game loop to ensure it runs well on mobile devices.
    • How to Play: Use arrow keys on desktop or swipe on mobile. Tap or press a key to restart after game over.

    Here's the full code:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Visually Stunning Snake Game</title>
        <style>
            body {
                margin: 0;
                overflow: hidden;
                background-color: #1a1a2e; /* Dark background for a stunning contrast */
                display: flex;
                justify-content: center;
                align-items: center;
                height: 100vh;
                font-family: Arial, sans-serif;
            }
            
            #gameCanvas {
                border: 2px solid #0f3460; /* Subtle border for visual appeal */
                border-radius: 10px; /* Rounded corners for a modern look */
                box-shadow: 0 0 20px rgba(0, 255, 255, 0.5); /* Glowing cyan shadow for stunning effect */
                background-color: #16213e; /* Darker canvas background */
            }
        </style>
    </head>
    <body>
        <canvas id="gameCanvas"></canvas>
        
        <script>
            const canvas = document.getElementById('gameCanvas');
            const ctx = canvas.getContext('2d');
            
            // Set canvas size based on window size for responsiveness
            function resizeCanvas() {
                canvas.width = window.innerWidth * 0.8;  // 80% of screen width
                canvas.height = window.innerHeight * 0.8;  // 80% of screen height
                const size = Math.min(canvas.width, canvas.height);
                canvas.width = size;  // Make it square for better gameplay
                canvas.height = size;
            }
            resizeCanvas();
            window.addEventListener('resize', resizeCanvas);
            
            const rows = 20;  // Grid rows
            const cols = 20;  // Grid columns
            let cellSize = Math.floor(Math.min(canvas.width / cols, canvas.height / rows));  // Dynamic cell size
            
            let snake = [{x: 10, y: 10}];  // Initial snake position
            let direction = 'right';  // Initial direction
            let food = {x: 15, y: 15};  // Initial food position
            let score = 0;
            let gameInterval = 100;  // Snake speed in ms (adjust for difficulty)
            let lastTime = 0;
            let isGameOver = false;
            
            // Touch controls
            let touchStartX = 0;
            let touchStartY = 0;
            
            canvas.addEventListener('touchstart', (e) => {
                touchStartX = e.touches[0].clientX;
                touchStartY = e.touches[0].clientY;
            });
            
            canvas.addEventListener('touchend', (e) => {
                const touchEndX = e.changedTouches[0].clientX;
                const touchEndY = e.changedTouches[0].clientY;
                const dx = touchEndX - touchStartX;
                const dy = touchEndY - touchStartY;
                
                if (Math.abs(dx) > Math.abs(dy)) {  // Horizontal swipe
                    if (dx > 0 && direction !== 'left') direction = 'right';
                    else if (dx < 0 && direction !== 'right') direction = 'left';
                } else {  // Vertical swipe
                    if (dy > 0 && direction !== 'up') direction = 'down';
                    else if (dy < 0 && direction !== 'down') direction = 'up';
                }
            });
            
            // Keyboard controls
            document.addEventListener('keydown', (e) => {
                if (isGameOver && e.key === 'Enter') {  // Restart on Enter
                    resetGame();
                    return;
                }
                if (isGameOver) return;  // Ignore inputs if game over
                
                switch(e.key) {
                    case 'ArrowUp': if (direction !== 'down') direction = 'up'; break;
                    case 'ArrowDown': if (direction !== 'up') direction = 'down'; break;
                    case 'ArrowLeft': if (direction !== 'right') direction = 'left'; break;
                    case 'ArrowRight': if (direction !== 'left') direction = 'right'; break;
                }
            });
            
            function resetGame() {
                snake = [{x: 10, y: 10}];
                direction = 'right';
                score = 0;
                isGameOver = false;
                placeFood();
            }
            
            function placeFood() {
                food.x = Math.floor(Math.random() * cols);
                food.y = Math.floor(Math.random() * rows);
                // Ensure food doesn't spawn on snake
                while (snake.some(segment => segment.x === food.x && segment.y === food.y)) {
                    food.x = Math.floor(Math.random() * cols);
                    food.y = Math.floor(Math.random() * rows);
                }
            }
            
            function update(timestamp) {
                if (isGameOver) return;
                
                if (timestamp - lastTime > gameInterval) {
                    lastTime = timestamp;
                    
                    // Move snake
                    let head = { ...snake[0] };
                    switch(direction) {
                        case 'up': head.y--; break;
                        case 'down': head.y++; break;
                        case 'left': head.x--; break;
                        case 'right': head.x++; break;
                    }
                    
                    // Check collisions
                    if (head.x < 0 || head.x >= cols || head.y < 0 || head.y >= rows || snake.some(segment => segment.x === head.x && segment.y === head.y)) {
                        isGameOver = true;
                        return;
                    }
                    
                    snake.unshift(head);  // Add new head
                    
                    if (head.x === food.x && head.y === food.y) {
                        score++;
                        placeFood();
                    } else {
                        snake.pop();  // Remove tail
                    }
                }
            }
            
            function draw() {
                ctx.clearRect(0, 0, canvas.width, canvas.height);
                
                // Draw grid background for visual appeal
                ctx.strokeStyle = 'rgba(255, 255, 255, 0.1)';  // Subtle white grid
                for (let i = 0; i <= rows; i++) {
                    ctx.beginPath();
                    ctx.moveTo(0, i * cellSize);
                    ctx.lineTo(canvas.width, i * cellSize);
                    ctx.stroke();
                }
                for (let j = 0; j <= cols; j++) {
                    ctx.beginPath();
                    ctx.moveTo(j * cellSize, 0);
                    ctx.lineTo(j * cellSize, canvas.height);
                    ctx.stroke();
                }
                
                // Draw snake with gradient for stunning effect
                for (let i = 0; i < snake.length; i++) {
                    const gradient = ctx.createLinearGradient(snake[i].x * cellSize, snake[i].y * cellSize, (snake[i].x + 1) * cellSize, (snake[i].y + 1) * cellSize);
                    gradient.addColorStop(0, i === 0 ? '#4CAF50' : '#81C784');  // Head: Vibrant green, Body: Lighter green
                    gradient.addColorStop(1, '#2E7D32');
                    ctx.fillStyle = gradient;
                    ctx.fillRect(snake[i].x * cellSize, snake[i].y * cellSize, cellSize, cellSize);
                    ctx.strokeStyle = '#FFFFFF';  // White border for shine
                    ctx.strokeRect(snake[i].x * cellSize, snake[i].y * cellSize, cellSize, cellSize);
                }
                
                // Draw food with glow effect
                const foodGradient = ctx.createRadialGradient((food.x + 0.5) * cellSize, (food.y + 0.5) * cellSize, 0, (food.x + 0.5) * cellSize, (food.y + 0.5) * cellSize, cellSize / 2);
                foodGradient.addColorStop(0, '#FFEB3B');  // Yellow center
                foodGradient.addColorStop(1, '#F57F17');  // Orange glow
                ctx.fillStyle = foodGradient;
                ctx.beginPath();
                ctx.arc((food.x + 0.5) * cellSize, (food.y + 0.5) * cellSize, cellSize / 2, 0, 2 * Math.PI);
                ctx.fill();
                ctx.strokeStyle = '#FFFFFF';
                ctx.stroke();
                
                // Draw score
                ctx.fillStyle = '#FFFFFF';
                ctx.font = '20px Arial';
                ctx.fillText('Score: ' + score, 10, 20);
                
                if (isGameOver) {
                    ctx.fillStyle = 'rgba(0, 0, 0, 0.7)';  // Semi-transparent overlay
                    ctx.fillRect(0, 0, canvas.width, canvas.height);
                    ctx.fillStyle = '#FFEB3B';  // Yellow text
                    ctx.font = '30px Arial';
                    ctx.fillText('Game Over! Score: ' + score, canvas.width / 4, canvas.height / 2);
                    ctx.font = '20px Arial';
                    ctx.fillText('Tap or Press Enter to Restart', canvas.width / 4, canvas.height / 2 + 30);
                }
            }
            
            function gameLoop(timestamp) {
                update(timestamp);
                draw();
                requestAnimationFrame(gameLoop);
            }
            
            placeFood();  // Initial food placement
            requestAnimationFrame(gameLoop);
        </script>
    </body>
    </html>
    

    How to Use:

    1. Copy the entire code and paste it into an online editor like CodePen (set it to "HTML" mode).
    2. Save it as an HTML file on your device and open it in a mobile browser to test touch controls.
    3. On desktop: Use arrow keys to control the snake.
    4. On mobile: Swipe on the canvas to change direction.
    5. After game over, tap the screen or press Enter to restart.

    This code is optimized for both desktop and mobile, with responsive sizing and visual enhancements like gradients and shadows to make it "visually stunning." If you encounter any issues, feel free to ask for tweaks!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.