AI game creator

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

No:15603

109

←

Prev Next

→

Tetris
Developer User6780｜Date and time 23/9/10 3:42:53
Build time 56.33 sec｜Game capacity 7.501KB｜

Script

Score: 0

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋グッズランキング

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

<HTML>
   <head>
      <style>
         body {
         background-color: black;
         }
         #gameBoard {
         display: flex;
         flex-wrap: wrap;
         height: 400px;
         width: 200px;
         border: 1px solid #ffffff;
         }
         .cell {
         flex: 0 0 20%;
         height: 20%;
         background-color: black;
         border: 1px solid #ffffff;
         }
         #score {
         color: white;
         font-size: 20px;
         }
      </style>
   </head>
   <body>
      <div id="gameBoard"></div>
      <p id="score">Score: 0</p>
      <script>
         // Tetris game implementation using JavaScript
         
         // Array to represent the game board
         let gameBoard = [];
         
         // Array to hold the current tetromino
         let tetromino = [];
         
         // Array to hold the current tetromino position
         let tetrominoPosition = { x: 0, y: 0 };
         
         // Variables to keep track of game state
         let score = 0;
         let gameOver = false;
         
         // Function to initialize the game
         function initializeGame() {
           // Create cells for the game board
           for (let i = 0; i < 20; i++) {
             let row = [];
             for (let j = 0; j < 10; j++) {
               row.push(0); // 0 represents an empty cell
             }
             gameBoard.push(row);
           }
         
           // Generate a random tetromino and set initial position
           generateTetromino();
         
           // Start game loop
           gameLoop();
         }
         
         // Function to generate a random tetromino
         function generateTetromino() {
           // Array of available tetrominos (represented as 2D arrays)
           const tetrominos = [
             [
               [1, 1, 1, 1] // I tetromino
             ],
             [
               [1, 1],
               [1, 1] // O tetromino
             ],
             [
               [1, 1, 1],
               [0, 1, 0] // T tetromino
             ],
             [
               [1, 1, 1],
               [0, 0, 1] // L tetromino
             ],
             [
               [1, 1, 1],
               [1, 0, 0] // J tetromino
             ],
             [
               [1, 1, 0],
               [0, 1, 1] // S tetromino
             ],
             [
               [0, 1, 1],
               [1, 1, 0] // Z tetromino
             ]
           ];
         
           // Choose a random tetromino
           const randomIndex = Math.floor(Math.random() * tetrominos.length);
           tetromino = tetrominos[randomIndex];
         
           // Set initial position for the tetromino
           tetrominoPosition.x = Math.floor(10 / 2) - Math.floor(tetromino[0].length / 2);
           tetrominoPosition.y = 0;
         }
         
         // Function to check if a tetromino can be placed at the current position
         function canPlaceTetromino() {
           for (let i = 0; i < tetromino.length; i++) {
             for (let j = 0; j < tetromino[i].length; j++) {
               if (tetromino[i][j] && (tetrominoPosition.y + i >= gameBoard.length || tetrominoPosition.x + j < 0 || tetrominoPosition.x + j >= gameBoard[0].length || gameBoard[tetrominoPosition.y + i][tetrominoPosition.x + j])) {
                 return false;
               }
             }
           }
           return true;
         }
         
         // Function to place the current tetromino on the game board
         function placeTetromino() {
           for (let i = 0; i < tetromino.length; i++) {
             for (let j = 0; j < tetromino[i].length; j++) {
               if (tetromino[i][j]) {
                 gameBoard[tetrominoPosition.y + i][tetrominoPosition.x + j] = 1;
               }
             }
           }
         }
         
         // Function to clear completed rows
         function clearRows() {
           for (let i = gameBoard.length - 1; i >= 0; i--) {
             if (gameBoard[i].every(cell => cell)) {
               gameBoard.splice(i, 1); // Remove row
               score += 10; // Increase score
             }
           }
         
           // Add new rows at the top
           while (gameBoard.length < 20) {
             gameBoard.unshift(Array(10).fill(0));
           }
         }
         
         // Function to move the tetromino down
         function moveDown() {
           tetrominoPosition.y++;
         
           if (!canPlaceTetromino()) {
             tetrominoPosition.y--;
             placeTetromino();
             clearRows();
             generateTetromino();
         
             if (!canPlaceTetromino()) {
               gameOver = true;
             }
           }
         }
         
         // Function to move the tetromino to the left
         function moveLeft() {
           tetrominoPosition.x--;
         
           if (!canPlaceTetromino()) {
             tetrominoPosition.x++;
           }
         }
         
         // Function to move the tetromino to the right
         function moveRight() {
           tetrominoPosition.x++;
         
           if (!canPlaceTetromino()) {
             tetrominoPosition.x--;
           }
         }
         
         // Function to rotate the tetromino
         function rotateTetromino() {
           // Transpose the tetromino matrix
           const tempTetromino = tetromino[0].map((_, i) => tetromino.map(row => row[i]));
         
           // Reverse each row of the transposed matrix
           tetromino = tempTetromino.map(row => row.reverse());
         
           if (!canPlaceTetromino()) {
             // Revert the changes if the rotation is not possible
             tetromino = tempTetromino.map(row => row.reverse());
           }
         }
         
         // Function to handle keyboard input
         function handleInput(event) {
           if (gameOver) {
             return;
           }
         
           if (event.code === 'ArrowUp') {
             rotateTetromino();
           } else if (event.code === 'ArrowDown') {
             moveDown();
           } else if (event.code === 'ArrowLeft') {
             moveLeft();
           } else if (event.code === 'ArrowRight') {
             moveRight();
           }
         }
         
         // Function to update the game state and render the game board
         function updateGame() {
           if (gameOver) {
             alert('Game over!');
             return;
           }
         
           moveDown();
         
           // Clear the game board
           document.getElementById('gameBoard').innerHTML = '';
         
           // Render the game board
           for (let i = 0; i < gameBoard.length; i++) {
             for (let j = 0; j < gameBoard[i].length; j++) {
               const cell = document.createElement('div');
               cell.className = gameBoard[i][j] ? 'cell filled' : 'cell';
               document.getElementById('gameBoard').appendChild(cell);
             }
           }
         
           // Update the score
           document.getElementById('score').textContent = 'Score: ' + score;
         
           // Perform game update recursively
           setTimeout(updateGame, 1000);
         }
         
         // Start the game
         initializeGame();
         
         // Event listener for keyboard input
         document.addEventListener('keydown', handleInput);
      </script>
   </body>
</HTML>