A game that is a mixture of tetris and tetris and double tetris title.'s game

Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 157

Warning: in_array() expects parameter 2 to be array, bool given in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 476

Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 484
A game that is a mixture of tetris and tetris and double tetris title.'s game | AI game creator

Click here for free DL of the app version that can save data.

No:10456

215

←

Prev Next

→

A game that is a mixture of tetris and tetris and ..ALL
Developer User3408｜Date and time 23/7/31 12:56:29
Build time 51.548 sec｜Game capacity 7.298KB｜

Script

A continuación te presento el código HTML y JavaScript para un juego que combina dos juegos de Tetris en uno, llamado "Doble Tetris":

Para jugar el juego, simplemente copia el código anterior en un archivo HTML y ábrelo en tu navegador. Podrás controlar la pieza actual utilizando las teclas de flecha izquierda, derecha y abajo, y la tecla de flecha hacia arriba para rotarla. El objetivo es completar filas para acumular puntos. El juego terminará cuando no sea posible colocar una nueva pieza en el tablero. ¡Diviértete jugando Doble Tetris!

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋ゲームランキング

Click here for free DL of the app version that can save data.

A continuación te presento el código HTML y JavaScript para un juego que combina dos juegos de Tetris en uno, llamado "Doble Tetris":

```html
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Doble Tetris</title>
    <style>
        body {
            background-color: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
        }

canvas {
            border: 2px solid #FFF;
        }
    </style>
</head>
<body>
    <canvas id="tetrisCanvas" width="240" height="400"></canvas>

// Puntuación y temporizador
        let score = 0;
        let timer = 1000;
        let requestId;

// Piezas
        const PIECES = [
            [[1, 1, 1, 1]], // I
            [[1, 1], [1, 1]], // O
            [[1, 1, 0], [0, 1, 1]], // Z
            [[0, 1, 1], [1, 1, 0]], // S
            [[1, 1, 1], [0, 1, 0]], // T
            [[1, 1, 1], [0, 0, 1]], // L
            [[1, 1, 1], [1, 0, 0]] // J
        ];

// Pieza actual y posición
        let currentPiece, currentRow, currentCol;

// Inicializar el juego
        function init() {
            canvas = document.getElementById('tetrisCanvas');
            ctx = canvas.getContext('2d');

// Inicializar el tablero
            board = [];
            for (let row = 0; row < ROWS; row++) {
                board[row] = Array(COLS).fill(0);
            }

// Agregar una fila vacía extra en la parte superior para detectar el fin del juego
            emptyRow = Array(COLS).fill(0);
            board.push(emptyRow);

// Generar una nueva pieza aleatoria
            generatePiece();

// Iniciar el bucle de juego
            gameLoop();
        }

// Generar una nueva pieza aleatoria
        function generatePiece() {
            const randomPiece = Math.floor(Math.random() * PIECES.length);
            currentPiece = PIECES[randomPiece];
            currentRow = 0;
            currentCol = Math.floor((COLS - currentPiece[0].length) / 2);
        }

// Dibujar el tablero y las piezas
        function draw() {
            // Limpiar el lienzo
            ctx.clearRect(0, 0, canvas.width, canvas.height);

// Dibujar el tablero
            for (let row = 0; row < ROWS; row++) {
                for (let col = 0; col < COLS; col++) {
                    if (board[row][col]) {
                        ctx.fillStyle = "#777";
                        ctx.fillRect(col * BLOCK_SIZE, row * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
                    }
                }
            }

// Dibujar la pieza actual
            for (let row = 0; row < currentPiece.length; row++) {
                for (let col = 0; col < currentPiece[row].length; col++) {
                    if (currentPiece[row][col]) {
                        ctx.fillStyle = "#FFF";
                        ctx.fillRect((currentCol + col) * BLOCK_SIZE, (currentRow + row) * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
                    }
                }
            }
        }

// Control de teclas
        document.addEventListener('keydown', function(event) {
            if (event.keyCode === 37) { // Izquierda
                if (isValidMove(currentPiece, currentRow, currentCol - 1)) {
                    currentCol--;
                }
            } else if (event.keyCode === 39) { // Derecha
                if (isValidMove(currentPiece, currentRow, currentCol + 1)) {
                    currentCol++;
                }
            } else if (event.keyCode === 40) { // Abajo
                if (isValidMove(currentPiece, currentRow + 1, currentCol)) {
                    currentRow++;
                }
            } else if (event.keyCode === 38) { // Rotar
                const rotatedPiece = rotatePiece(currentPiece);
                if (isValidMove(rotatedPiece, currentRow, currentCol)) {
                    currentPiece = rotatedPiece;
                }
            }
        });

// Verificar si un movimiento es válido
        function isValidMove(piece, row, col) {
            for (let r = 0; r < piece.length; r++) {
                for (let c = 0; c < piece[r].length; c++) {
                    // Verificar si la pieza está dentro del tablero
                    if (piece[r][c] && (row + r >= ROWS || col + c < 0 || col + c >= COLS || board[row + r][col + c])) {
                        return false;
                    }
                }
            }
            return true;
        }

// Rotar una pieza
        function rotatePiece(piece) {
            const rotatedPiece = [];
            for (let col = 0; col < piece[0].length; col++) {
                rotatedPiece[col] = [];
                for (let row = piece.length - 1; row >= 0; row--) {
                    rotatedPiece[col][piece.length - 1 - row] = piece[row][col];
                }
            }
            return rotatedPiece;
        }

// Colocar una pieza en el tablero
        function placePiece() {
            for (let row = 0; row < currentPiece.length; row++) {
                for (let col = 0; col < currentPiece[row].length; col++) {
                    if (currentPiece[row][col]) {
                        board[currentRow + row][currentCol + col] = 1;
                    }
                }
            }

// Verificar si se completó una fila
            for (let row = 0; row < ROWS; row++) {
                if (board[row].every(cell => cell === 1)) {
                    score += 10;
                    board.splice(row, 1);
                    board.unshift(emptyRow);
                }
            }

// Generar una nueva pieza aleatoria
            generatePiece();

// Verificar si el juego ha terminado
            if (!isValidMove(currentPiece, currentRow, currentCol)) {
                cancelAnimationFrame(requestId);
                alert("Juego terminado! Puntuación: " + score);
            }
        }

// Actualizar el juego en cada fotograma
        function gameLoop() {
            draw();

// Mover la pieza hacia abajo automáticamente
            if (new Date().getTime() - timer > 500) {
                if (isValidMove(currentPiece, currentRow + 1, currentCol)) {
                    currentRow++;
                } else {
                    placePiece();
                }
                timer = new Date().getTime();
            }

requestId = requestAnimationFrame(gameLoop);
        }

// Iniciar el juego
        init();
    </script>
</body>
</html>
```