Un juego que sea un tetris divido en dos juegos's game

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

No:12647

126

←

Prev Next

→

Un juego que sea un tetris divido en dos juegos
Developer User3408｜Date and time 23/8/21 9:59:47
Build time 24.147 sec｜Game capacity 8.563KB｜

Script

←

Prev　Next

→ 　

Back　

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

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

<!DOCTYPE html>
<html>
<head>
    <title>Tetris Dividido</title>
    <style>
        /* CSS styles for the game */
        #game-container {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
        }
        
        #game-board {
            width: 400px;
            height: 600px;
            border: 2px solid #000;
            background-color: #f0f0f0;
        }
        
        .row {
            display: flex;
            flex-direction: row;
        }
        
        .cell {
            width: 20px;
            height: 20px;
            border: 1px solid #ccc;
            background-color: #fff;
        }
        
        .cell.active {
            background-color: #ff0;
        }
        
        .cell.taken {
            background-color: #00f;
        }
    </style>
</head>
<body>
    <div id="game-container">
        <div id="game-board"></div>
    </div>

// Function to create the game board
            function createGameBoard() {
                for (let row = 0; row < rows; row++) {
                    const gameRow = document.createElement('div');
                    gameRow.classList.add('row');
                    
                    const gameCellRow = [];

for (let col = 0; col < cols; col++) {
                        const gameCell = document.createElement('div');
                        gameCell.classList.add('cell');
                        gameRow.appendChild(gameCell);
                        gameCellRow.push(emptyCell);
                    }

gameBoard.appendChild(gameRow);
                    gameCells.push(gameCellRow);
                }
            }
            
            // Function to create a Tetris piece
            function createPiece() {
                const pieces = [
                    [[1, 1, 1, 1]],
                    [[1, 1], [1, 1]],
                    [[1, 1, 0], [0, 1, 1]],
                    [[0, 1, 1], [1, 1, 0]],
                    [[1, 1, 1], [0, 1, 0]],
                    [[1, 0, 0], [1, 1, 1]],
                    [[0, 0, 1], [1, 1, 1]]
                ];

const piece = pieces[Math.floor(Math.random() * pieces.length)];
                const rotation = Math.floor(Math.random() * 4);
                const startX = Math.floor((cols - piece[0].length) / 2);
                const startY = -1 * piece.length;

currentPiece = piece;
                currentRotation = rotation;
                currentX = startX;
                currentY = startY;
            }

// Function to draw the game board with the current pieces
            function drawGameBoard() {
                for (let row = 0; row < rows; row++) {
                    for (let col = 0; col < cols; col++) {
                        const gameCell = gameCells[row][col];
                        const cellDiv = gameBoard.childNodes[row].childNodes[col];

cellDiv.classList.remove('active', 'taken');

if (gameCell === activeCell) {
                            cellDiv.classList.add('active');
                        } else if (gameCell === takenCell) {
                            cellDiv.classList.add('taken');
                        }
                    }
                }
            }

// Function to check if a move is valid
            function isValidMove(piece, rotation, x, y) {
                for (let row = 0; row < piece.length; row++) {
                    for (let col = 0; col < piece[row].length; col++) {
                        if (
                            piece[row][col] &&
                            (y + row >= rows || x + col < 0 || x + col >= cols || gameCells[y + row][x + col] === takenCell)
                        ) {
                            return false;
                        }
                    }
                }

return true;
            }

// Function to merge the current piece into the game board
            function mergePiece() {
                for (let row = 0; row < currentPiece.length; row++) {
                    for (let col = 0; col < currentPiece[row].length; col++) {
                        if (currentPiece[row][col]) {
                            gameCells[currentY + row][currentX + col] = takenCell;
                        }
                    }
                }
            }

// Function to clear full rows and update the score
            function clearRows() {
                let filledRowCount = 0;

for (let row = 0; row < rows; row++) {
                    if (gameCells[row].every(cell => cell === takenCell)) {
                        gameCells.splice(row, 1);
                        gameCells.unshift(Array(cols).fill(emptyCell));
                        filledRowCount++;
                    }
                }

score += 10 * Math.pow(2, filledRowCount);
            }

// Function to move the current piece down
            function moveDown() {
                if (isValidMove(currentPiece, currentRotation, currentX, currentY + 1)) {
                    currentY++;
                } else {
                    mergePiece();
                    clearRows();
                    createPiece();

if (!isValidMove(currentPiece, currentRotation, currentX, currentY)) {
                        gameOver = true;
                    }
                }
            }

// Function to move the current piece left
            function moveLeft() {
                if (isValidMove(currentPiece, currentRotation, currentX - 1, currentY)) {
                    currentX--;
                }
            }

// Function to move the current piece right
            function moveRight() {
                if (isValidMove(currentPiece, currentRotation, currentX + 1, currentY)) {
                    currentX++;
                }
            }

// Function to rotate the current piece
            function rotatePiece() {
                const newRotation = (currentRotation + 1) % 4;

if (isValidMove(currentPiece, newRotation, currentX, currentY)) {
                    currentRotation = newRotation;
                }
            }

// Function to handle keyboard controls
            function handleKeyDown(event) {
                if (!gameOver) {
                    if (event.key === 'ArrowDown') {
                        moveDown();
                    } else if (event.key === 'ArrowLeft') {
                        moveLeft();
                    } else if (event.key === 'ArrowRight') {
                        moveRight();
                    } else if (event.key === 'ArrowUp') {
                        rotatePiece();
                    }
                }
            }

// Function to update the game state and redraw the board
            function updateGame() {
                if (!gameOver) {
                    moveDown();
                    drawGameBoard();
                    updateScore();
                } else {
                    clearInterval(gameInterval);
                    alert('Fin del juego \n Puntuación: ' + score);
                }
            }

// Function to update the score display
            function updateScore() {
                const scoreDisplay = document.getElementById('score');
                scoreDisplay.innerText = 'Puntuación: ' + score;
            }

// Function to start the game
            function startGame() {
                createGameBoard();
                createPiece();

document.addEventListener('keydown', handleKeyDown);
                
                gameInterval = setInterval(updateGame, 500);
            }

// Start the game
            startGame();
        });
    </script>
</body>
</html>