Crea un juego de tetrik niveles infinito Javascript's game

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

No:35142

←

Prev Next

→

Crea un juego de tetrik niveles infinito Javascrip..ALL
Developer User16439｜Date and time 24/1/13 11:40:18
Build time 20.08 sec｜Game capacity 5.967KB｜

Script

Aquí tienes un ejemplo de un juego de Tetris en JavaScript que cumple con las especificaciones que solicitaste:

Este código crea un juego de Tetris con niveles infinitos en un solo archivo HTML. Utiliza pictogramas simples para representar las piezas del Tetris. Puedes abrir el archivo HTML en tu navegador o en un emulador de smartphone para jugar el juego.

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋Kindle本ランキング

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

Aquí tienes un ejemplo de un juego de Tetris en JavaScript que cumple con las especificaciones que solicitaste:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Tetris</title>
    <style>
        #game-board {
            width: 200px;
            height: 400px;
            background-color: #f2f2f2;
            border: 2px solid #333;
            position: relative;
        }
        .cell {
            width: 20px;
            height: 20px;
            position: absolute;
        }
        .shape {
            background-color: #999;
        }
        .active {
            background-color: #333;
        }
    </style>
</head>
<body>
    <div id="game-board"></div>

// Generar una forma de tetromino al azar
        function generateRandomShape() {
            return shapes[Math.floor(Math.random() * shapes.length)];
        }

// Crear la cuadrícula del juego
        const rows = 20;
        const columns = 10;
        const gameBoard = document.getElementById("game-board");
        const grid = [];
        for (let row = 0; row < rows; row++) {
            for (let col = 0; col < columns; col++) {
                const cell = document.createElement("div");
                cell.className = "cell";
                cell.style.top = row * 20 + "px";
                cell.style.left = col * 20 + "px";
                gameBoard.appendChild(cell);
                grid.push(cell);
            }
        }

let currentShape = generateRandomShape();
        let shapeRow = 0;
        let shapeCol = 4;

// Dibujar la forma actual en la cuadrícula
        function drawShape() {
            for (let row = 0; row < currentShape.length; row++) {
                for (let col = 0; col < currentShape[row].length; col++) {
                    if (currentShape[row][col]) {
                        const cellIndex = (shapeRow + row) * columns + (shapeCol + col);
                        grid[cellIndex].className = "cell shape";
                    }
                }
            }
        }

// Borrar la forma actual de la cuadrícula
        function eraseShape() {
            for (let row = 0; row < currentShape.length; row++) {
                for (let col = 0; col < currentShape[row].length; col++) {
                    if (currentShape[row][col]) {
                        const cellIndex = (shapeRow + row) * columns + (shapeCol + col);
                        grid[cellIndex].className = "cell";
                    }
                }
            }
        }

// Mover la forma hacia abajo
        function moveDown() {
            eraseShape();
            shapeRow++;
            if (!canMove()) {
                shapeRow--;
            }
            drawShape();
        }

// Verificar si se puede mover la forma
        function canMove() {
            for (let row = 0; row < currentShape.length; row++) {
                for (let col = 0; col < currentShape[row].length; col++) {
                    if (currentShape[row][col]) {
                        const nextRowIndex = shapeRow + row + 1;
                        const cellIndex = nextRowIndex * columns + (shapeCol + col);
                        if (
                            nextRowIndex === rows ||
                            grid[cellIndex].className === "cell active"
                        ) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Rotar la forma actual
        function rotateShape() {
            const rotatedShape = [];
            for (let col = 0; col < currentShape[0].length; col++) {
                const newRow = [];
                for (let row = currentShape.length - 1; row >= 0; row--) {
                    newRow.push(currentShape[row][col]);
                }
                rotatedShape.push(newRow);
            }
            if (canRotate(rotatedShape)) {
                eraseShape();
                currentShape = rotatedShape;
                drawShape();
            }
        }

// Verificar si se puede rotar la forma
        function canRotate(rotatedShape) {
            const nextShapeCol = shapeCol - Math.floor(rotatedShape[0].length / 2);
            for (let row = 0; row < rotatedShape.length; row++) {
                for (let col = 0; col < rotatedShape[row].length; col++) {
                    if (rotatedShape[row][col]) {
                        const cellIndex = (shapeRow + row) * columns + (nextShapeCol + col);
                        if (
                            nextShapeCol + col < 0 ||
                            nextShapeCol + col >= columns ||
                            shapeRow + row >= rows ||
                            grid[cellIndex].className === "cell active"
                        ) {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

// Iniciar el juego
        function startGame() {
            drawShape();
            setInterval(moveDown, 1000);
        }

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