Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-v3-0324· DeepSeekHugging Face LMArena Human Preference 140K

Create Tetris game in cyberpunk style

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

    Create Tetris game in cyberpunk style

  2. DeepSeek Assistant

    Cyberpunk Tetris Game Concept

    Here's a concept for a Tetris game with a cyberpunk aesthetic. I'll outline the key elements and provide a basic implementation approach.

    Visual Design Elements

    1. Neon Grid: Glowing grid with electric blue/purple/pink colors
    2. HUD Elements: Digital readouts for score, level, next piece
    3. Matrix Effects: Falling binary code in the background
    4. Cyber Blocks: Tetrominoes with circuit board textures and glow effects
    5. Neon Cityscape: Skyline silhouette in the background

    Sound Design

    • Synthwave/electronic soundtrack
    • Digital sound effects for rotations and line clears
    • Voice samples ("Line clear", "Level up" in robotic voice)

    Basic JavaScript Implementation

    Here's a simplified starting point using HTML5 Canvas:

    <!DOCTYPE html>
    <html>
    <head>
        <title>Cyberpunk Tetris</title>
        <style>
            body {
                margin: 0;
                background: #0a0a1a;
                color: #0ff;
                font-family: 'Courier New', monospace;
                overflow: hidden;
            }
            canvas {
                display: block;
                margin: 0 auto;
                border: 2px solid #4f0fff;
                box-shadow: 0 0 20px #4f0fff;
            }
            .game-container {
                position: relative;
                width: 100vw;
                height: 100vh;
                display: flex;
                justify-content: center;
                align-items: center;
            }
            .hud {
                position: absolute;
                top: 20px;
                left: 20px;
                font-size: 24px;
                text-shadow: 0 0 5px #0ff;
            }
        </style>
    </head>
    <body>
        <div class="game-container">
            <canvas id="tetris" width="300" height="600"></canvas>
            <div class="hud">
                <div>SCORE: <span id="score">0</span></div>
                <div>LEVEL: <span id="level">1</span></div>
                <div>LINES: <span id="lines">0</span></div>
            </div>
        </div>
    
        <script>
            const canvas = document.getElementById('tetris');
            const context = canvas.getContext('2d');
            const scoreElement = document.getElementById('score');
            const levelElement = document.getElementById('level');
            const linesElement = document.getElementById('lines');
    
            // Scale up the canvas
            context.scale(20, 20);
    
            // Matrix background effect
            function drawMatrixEffect() {
                context.fillStyle = 'rgba(10, 10, 30, 0.05)';
                context.fillRect(0, 0, canvas.width, canvas.height);
                
                context.fillStyle = '#0f0';
                context.font = '10px monospace';
                for (let i = 0; i < 30; i++) {
                    const x = Math.random() * canvas.width;
                    const y = Math.random() * canvas.height;
                    const char = Math.random() > 0.5 ? '0' : '1';
                    context.fillText(char, x, y);
                }
            }
    
            // Game state
            const arena = createMatrix(12, 20);
            const player = {
                pos: {x: 0, y: 0},
                matrix: null,
                score: 0,
                level: 1,
                lines: 0
            };
    
            // Colors with cyberpunk neon palette
            const colors = [
                null,
                '#FF2A6D', // Pink
                '#05D9E8', // Cyan
                '#D300C5', // Purple
                '#FFEE00', // Yellow
                '#00FF85', // Green
                '#FF7F11', // Orange
                '#4F0FFF'  // Blue
            ];
    
            // Create matrix
            function createMatrix(w, h) {
                const matrix = [];
                while (h--) {
                    matrix.push(new Array(w).fill(0));
                }
                return matrix;
            }
    
            // Create piece
            function createPiece(type) {
                if (type === 'T') {
                    return [
                        [0, 0, 0],
                        [1, 1, 1],
                        [0, 1, 0],
                    ];
                } else if (type === 'O') {
                    return [
                        [2, 2],
                        [2, 2],
                    ];
                } else if (type === 'L') {
                    return [
                        [0, 3, 0],
                        [0, 3, 0],
                        [0, 3, 3],
                    ];
                } else if (type === 'J') {
                    return [
                        [0, 4, 0],
                        [0, 4, 0],
                        [4, 4, 0],
                    ];
                } else if (type === 'I') {
                    return [
                        [0, 5, 0, 0],
                        [0, 5, 0, 0],
                        [0, 5, 0, 0],
                        [0, 5, 0, 0],
                    ];
                } else if (type === 'S') {
                    return [
                        [0, 6, 6],
                        [6, 6, 0],
                        [0, 0, 0],
                    ];
                } else if (type === 'Z') {
                    return [
                        [7, 7, 0],
                        [0, 7, 7],
                        [0, 0, 0],
                    ];
                }
            }
    
            // Draw matrix
            function drawMatrix(matrix, offset) {
                matrix.forEach((row, y) => {
                    row.forEach((value, x) => {
                        if (value !== 0) {
                            // Draw block with glow effect
                            context.fillStyle = colors[value];
                            context.fillRect(x + offset.x, y + offset.y, 1, 1);
                            
                            // Inner glow
                            context.fillStyle = 'white';
                            context.globalAlpha = 0.3;
                            context.fillRect(x + offset.x + 0.1, y + offset.y + 0.1, 0.8, 0.8);
                            context.globalAlpha = 1.0;
                            
                            // Border
                            context.strokeStyle = 'rgba(255, 255, 255, 0.5)';
                            context.lineWidth = 0.05;
                            context.strokeRect(x + offset.x, y + offset.y, 1, 1);
                        }
                    });
                });
            }
    
            // Merge arena and player
            function merge(arena, player) {
                player.matrix.forEach((row, y) => {
                    row.forEach((value, x) => {
                        if (value !== 0) {
                            arena[y + player.pos.y][x + player.pos.x] = value;
                        }
                    });
                });
            }
    
            // Rotate matrix
            function rotate(matrix, dir) {
                for (let y = 0; y < matrix.length; ++y) {
                    for (let x = 0; x < y; ++x) {
                        [matrix[x][y], matrix[y][x]] = [matrix[y][x], matrix[x][y]];
                    }
                }
                if (dir > 0) {
                    matrix.forEach(row => row.reverse());
                } else {
                    matrix.reverse();
                }
            }
    
            // Collision detection
            function collide(arena, player) {
                const [m, o] = [player.matrix, player.pos];
                for (let y = 0; y < m.length; ++y) {
                    for (let x = 0; x < m[y].length; ++x) {
                        if (m[y][x] !== 0 &&
                            (arena[y + o.y] &&
                            arena[y + o.y][x + o.x]) !== 0) {
                            return true;
                        }
                    }
                }
                return false;
            }
    
            // Reset player position
            function playerReset() {
                const pieces = 'ILJOTSZ';
                player.matrix = createPiece(pieces[pieces.length * Math.random() | 0]);
                player.pos.y = 0;
                player.pos.x = (arena[0].length / 2 | 0) - (player.matrix[0].length / 2 | 0);
                
                if (collide(arena, player)) {
                    arena.forEach(row => row.fill(0));
                    player.score = 0;
                    player.level = 1;
                    player.lines = 0;
                    updateScore();
                }
            }
    
            // Arena sweep
            function arenaSweep() {
                let lineCount = 0;
                outer: for (let y = arena.length - 1; y > 0; --y) {
                    for (let x = 0; x < arena[y].length; ++x) {
                        if (arena[y][x] === 0) {
                            continue outer;
                        }
                    }
                    
                    const row = arena.splice(y, 1)[0].fill(0);
                    arena.unshift(row);
                    ++y;
                    lineCount++;
                }
                
                if (lineCount > 0) {
                    player.score += lineCount * 100 * player
    

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