A game that mixes tetris and tetris's game

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

No:12545

134

←

Prev Next

→

A game that mixes tetris and tetris
Developer User3408｜Date and time 23/8/19 16:15:32
Build time 69.047 sec｜Game capacity 10.45KB｜

Script

Claro, aquí tienes un ejemplo de cómo podrías mezclar los juegos de Tetris y Tetris en un solo juego en un archivo HTML:

Este es un ejemplo básico de cómo podrías mezclar los juegos de Tetris y Tetris. Puedes mejorarlo e implementarlo según tus necesidades y preferencias. ¡Diviértete jugando!

←

Prev　Next

→ 　

Back　

[PR]現在の人気ゲームランキング

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

Claro, aquí tienes un ejemplo de cómo podrías mezclar los juegos de Tetris y Tetris en un solo juego en un archivo HTML:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Tetris Mix</title>
    <style>
        /* Estilos para el área de juego */
        #game-area {
            width: 320px;
            height: 640px;
            border: 1px solid black;
            margin: 0 auto;
            overflow: hidden;
            position: relative;
        }
        
        /* Estilos para los bloques del juego */
        .block {
            width: 30px;
            height: 30px;
            position: absolute;
        }
        
        /* Estilos para los pictogramas */
        .icon {
            font-size: 25px;
        }
    </style>
</head>
<body>
    <div id="game-area"></div>

// Tablero de juego
        var board = [
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        ];

// Función para dibujar el tablero de juego
        function drawGameBoard() {
            gameArea.innerHTML = "";
            
            for (var i = 0; i < 10; i++) {
                for (var j = 0; j < 20; j++) {
                    if (board[j][i] !== 0) {
                        var block = document.createElement("span");
                        block.className = "block icon";
                        block.style.left = i * 30 + "px";
                        block.style.top = j * 30 + "px";
                        block.innerHTML = blockIcons[board[j][i] - 1];
                        gameArea.appendChild(block);
                    }
                }
            }
        }

// Función para generar un nuevo tetromino en la parte superior del tablero
        function generateTetromino() {
            var tetromino = [
                [1, 1],
                [1, 1]
            ];
            return tetromino;
        }

// Función para rotar un tetromino en sentido horario
        function rotateTetromino(tetromino) {
            var rotatedTetromino = [
                [tetromino[1][0], tetromino[0][0]],
                [tetromino[1][1], tetromino[0][1]]
            ];
            return rotatedTetromino;
        }

// Función para guardar el tetromino en el tablero de juego
        function saveTetromino(tetromino, x, y) {
            for (var i = 0; i < tetromino.length; i++) {
                for (var j = 0; j < tetromino[i].length; j++) {
                    if (tetromino[i][j] !== 0) {
                        board[y + i][x + j] = tetromino[i][j];
                    }
                }
            }
        }

// Función que verifica si el tetromino puede moverse hacia abajo
        function canMoveDown(tetromino, x, y) {
            for (var i = 0; i < tetromino.length; i++) {
                for (var j = 0; j < tetromino[i].length; j++) {
                    if (tetromino[i][j] !== 0) {
                        if (y + i >= 19 || board[y + i + 1][x + j] !== 0) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Función que permite mover el tetromino hacia abajo
        function moveDown() {
            if (canMoveDown(currentTetromino, currentTetrominoX, currentTetrominoY)) {
                currentTetrominoY++;
                clearTetromino();
                drawTetromino();
            } else {
                saveTetromino(currentTetromino, currentTetrominoX, currentTetrominoY);
                checkLines();
                generateNewTetromino();
            }
        }
        
        // Función para verificar y eliminar líneas completas
        function checkLines() {
            var linesCleared = 0;
            for (var i = 0; i < 20; i++) {
                var lineFilled = true;
                for (var j = 0; j < 10; j++) {
                    if (board[i][j] === 0) {
                        lineFilled = false;
                        break;
                    }
                }
                if (lineFilled) {
                    linesCleared++;
                    for (var k = i; k > 0; k--) {
                        for (var l = 0; l < 10; l++) {
                            board[k][l] = board[k - 1][l];
                        }
                    }
                }
            }
            if (linesCleared > 0) {
                console.log(linesCleared + " línea(s) eliminada(s)!");
                drawGameBoard();
            }
        }

// Función para borrar el tetromino actual del tablero de juego
        function clearTetromino() {
            for (var i = 0; i < currentTetromino.length; i++) {
                for (var j = 0; j < currentTetromino[i].length; j++) {
                    if (currentTetromino[i][j] !== 0) {
                        board[currentTetrominoY + i][currentTetrominoX + j] = 0;
                    }
                }
            }
        }

// Función para dibujar el tetromino actual en el tablero de juego
        function drawTetromino() {
            for (var i = 0; i < currentTetromino.length; i++) {
                for (var j = 0; j < currentTetromino[i].length; j++) {
                    if (currentTetromino[i][j] !== 0) {
                        var block = document.createElement("span");
                        block.className = "block icon";
                        block.style.left = (currentTetrominoX + j) * 30 + "px";
                        block.style.top = (currentTetrominoY + i) * 30 + "px";
                        block.innerHTML = blockIcons[currentTetromino[i][j] - 1];
                        gameArea.appendChild(block);
                    }
                }
            }
        }

// Función para manejar la entrada del teclado
        function handleKeyPress(event) {
            // Izquierda (37), Derecha (39), Rotar (38), Abajo (40)
            if (event.keyCode === 37) {
                moveLeft();
            } else if (event.keyCode === 39) {
                moveRight();
            } else if (event.keyCode === 38) {
                rotate();
            } else if (event.keyCode === 40) {
                moveDown();
            }
        }

// Función para mover el tetromino hacia la izquierda
        function moveLeft() {
            if (canMoveLeft(currentTetromino, currentTetrominoX, currentTetrominoY)) {
                currentTetrominoX--;
                clearTetromino();
                drawTetromino();
            }
        }

// Función que verifica si el tetromino puede moverse hacia la izquierda
        function canMoveLeft(tetromino, x, y) {
            for (var i = 0; i < tetromino.length; i++) {
                for (var j = 0; j < tetromino[i].length; j++) {
                    if (tetromino[i][j] !== 0) {
                        if (x + j <= 0 || board[y + i][x + j - 1] !== 0) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Función para mover el tetromino hacia la derecha
        function moveRight() {
            if (canMoveRight(currentTetromino, currentTetrominoX, currentTetrominoY)) {
                currentTetrominoX++;
                clearTetromino();
                drawTetromino();
            }
        }

// Función que verifica si el tetromino puede moverse hacia la derecha
        function canMoveRight(tetromino, x, y) {
            for (var i = 0; i < tetromino.length; i++) {
                for (var j = 0; j < tetromino[i].length; j++) {
                    if (tetromino[i][j] !== 0) {
                        if (x + j >= 9 || board[y + i][x + j + 1] !== 0) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Función para rotar el tetromino
        function rotate() {
            var rotatedTetromino = rotateTetromino(currentTetromino);
            if (isValidMove(rotatedTetromino, currentTetrominoX, currentTetrominoY)) {
                clearTetromino();
                currentTetromino = rotatedTetromino;
                drawTetromino();
            }
        }

// Función para verificar si el movimiento es válido
        function isValidMove(tetromino, x, y) {
            for (var i = 0; i < tetromino.length; i++) {
                for (var j = 0; j < tetromino[i].length; j++) {
                    if (tetromino[i][j] !== 0) {
                        if (y + i >= 20 || x + j < 0 || x + j >= 10 || board[y + i][x + j] !== 0) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Función para generar un nuevo tetromino en la parte superior del tablero
        function generateNewTetromino() {
            currentTetromino = generateTetromino();
            currentTetrominoX = 4;
            currentTetrominoY = 0;
            
            if (!isValidMove(currentTetromino, currentTetrominoX, currentTetrominoY)) {
                // Fin del juego
                console.log("Fin del juego!");
            } else {
                drawTetromino();
            }
        }

// Inicia el juego
        function startGame() {
            generateNewTetromino();
            setInterval(moveDown, 1000); // Mueve hacia abajo cada segundo
            document.addEventListener("keydown", handleKeyPress);
        }

startGame();
    </script>
</body>
</html>
```

Este es un ejemplo básico de cómo podrías mezclar los juegos de Tetris y Tetris. Puedes mejorarlo e implementarlo según tus necesidades y preferencias. ¡Diviértete jugando!