A game that is a mixture of tetris and tetris or double tetris.'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 or double tetris.'s game | AI game creator

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

No:10449

214

←

Prev Next

→

A game that is a mixture of tetris and tetris or d..ALL
Developer User3408｜Date and time 23/7/31 12:44:05
Build time 88.852 sec｜Game capacity 11.323KB｜

Script

←

Prev　Next

→ 　

Back　

[PR]現在のプレゼントランキング

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

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Doble Tetris</title>
    <style>
      #board1 {
        position: relative;
        float: left;
        width: 200px;
        height: 400px;
        margin-right: 10px;
      }

#board2 {
        position: relative;
        float: left;
        width: 200px;
        height: 400px;
      }

.block {
        position: absolute;
        width: 20px;
        height: 20px;
      }
    </style>
  </head>
  <body>
    <canvas id="board1"></canvas>
    <canvas id="board2"></canvas>

const canvas2 = document.getElementById('board2');
      const ctx2 = canvas2.getContext('2d');
      canvas2.width = 200;
      canvas2.height = 400;

const BLOCK_SIZE = 20;
      const BOARD_ROWS = canvas1.height / BLOCK_SIZE;
      const BOARD_COLS = canvas1.width / BLOCK_SIZE;

function drawSquare(ctx, x, y, color) {
        ctx.fillStyle = color;
        ctx.fillRect(x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
        ctx.strokeStyle = 'black';
        ctx.strokeRect(x * BLOCK_SIZE, y * BLOCK_SIZE, BLOCK_SIZE, BLOCK_SIZE);
      }

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

let board1 = [];
      let currentShape1;
      let currentX1;
      let currentY1;
      let score1 = 0;

function validMove1() {
        for (let row = 0; row < currentShape1.length; row++) {
          for (let col = 0; col < currentShape1[row].length; col++) {
            if (currentShape1[row][col]) {
              const newX = currentX1 + col;
              const newY = currentY1 + row;

if (
                newX < 0 ||
                newX >= BOARD_COLS ||
                newY >= BOARD_ROWS ||
                board1[newY][newX] !== 'white'
              ) {
                return false;
              }
            }
          }
        }
        return true;
      }

function mergeCurrentShapeWithBoard1() {
        for (let row = 0; row < currentShape1.length; row++) {
          for (let col = 0; col < currentShape1[row].length; col++) {
            if (currentShape1[row][col]) {
              const newX = currentX1 + col;
              const newY = currentY1 + row;

board1[newY][newX] = 'orange';
            }
          }
        }
      }

function rotateShape1() {
        const temp = currentShape1;
        currentShape1 = currentShape1[0].map((_, i) => currentShape1.map(row => row[i])).reverse();
        if (!validMove1()) {
          currentShape1 = temp;
        }
      }

function moveShapeLeft1() {
        currentX1--;
        if (!validMove1()) {
          currentX1++;
        }
      }

function moveShapeRight1() {
        currentX1++;
        if (!validMove1()) {
          currentX1--;
        }
      }

for (let row of fullRows) {
          for (let r = row; r > 0; r--) {
            board1[r] = [...board1[r - 1]];
          }
          board1[0] = Array(BOARD_COLS).fill('white');
          score1 += 10;
        }
      }

function isGameOver1() {
        for (let col = 0; col < BOARD_COLS; col++) {
          if (board1[0][col] !== 'white') {
            return true;
          }
        }
        return false;
      }

function spawnNextShape1() {
        const randomIdx = Math.floor(Math.random() * tetrisShapes.length);
        currentShape1 = [...tetrisShapes[randomIdx]];
        currentX1 = Math.floor(BOARD_COLS / 2) - Math.floor(currentShape1[0].length / 2);
        currentY1 = 0;

if (!validMove1()) {
          gameOver1();
        }
      }

function gameOver1() {
        ctx1.fillStyle = 'black';
        ctx1.fillRect(0, 0, canvas1.width, canvas1.height);
        ctx1.fillStyle = 'red';
        ctx1.font = '40px Arial';
        ctx1.fillText('GAME OVER', 25, canvas1.height / 2);
      }
      
      let board2 = [];
      let currentShape2;
      let currentX2;
      let currentY2;
      let score2 = 0;

function validMove2() {
        for (let row = 0; row < currentShape2.length; row++) {
          for (let col = 0; col < currentShape2[row].length; col++) {
            if (currentShape2[row][col]) {
              const newX = currentX2 + col;
              const newY = currentY2 + row;

if (
                newX < 0 ||
                newX >= BOARD_COLS ||
                newY >= BOARD_ROWS ||
                board2[newY][newX] !== 'white'
              ) {
                return false;
              }
            }
          }
        }
        return true;
      }

function mergeCurrentShapeWithBoard2() {
        for (let row = 0; row < currentShape2.length; row++) {
          for (let col = 0; col < currentShape2[row].length; col++) {
            if (currentShape2[row][col]) {
              const newX = currentX2 + col;
              const newY = currentY2 + row;

board2[newY][newX] = 'green';
            }
          }
        }
      }

function rotateShape2() {
        const temp = currentShape2;
        currentShape2 = currentShape2[0].map((_, i) => currentShape2.map(row => row[i])).reverse();
        if (!validMove2()) {
          currentShape2 = temp;
        }
      }

function moveShapeLeft2() {
        currentX2--;
        if (!validMove2()) {
          currentX2++;
        }
      }

function moveShapeRight2() {
        currentX2++;
        if (!validMove2()) {
          currentX2--;
        }
      }

for (let row of fullRows) {
          for (let r = row; r > 0; r--) {
            board2[r] = [...board2[r - 1]];
          }
          board2[0] = Array(BOARD_COLS).fill('white');
          score2 += 10;
        }
      }
      
      function isGameOver2() {
        for (let col = 0; col < BOARD_COLS; col++) {
          if (board2[0][col] !== 'white') {
            return true;
          }
        }
        return false;
      }

function spawnNextShape2() {
        const randomIdx = Math.floor(Math.random() * tetrisShapes.length);
        currentShape2 = [...tetrisShapes[randomIdx]];
        currentX2 = Math.floor(BOARD_COLS / 2) - Math.floor(currentShape2[0].length / 2);
        currentY2 = 0;

if (!validMove2()) {
          gameOver2();
        }
      }

function gameOver2() {
        ctx2.fillStyle = 'black';
        ctx2.fillRect(0, 0, canvas1.width, canvas1.height);
        ctx2.fillStyle = 'red';
        ctx2.font = '40px Arial';
        ctx2.fillText('GAME OVER', 25, canvas2.height / 2);
      }

function gameLoop() {
        ctx1.clearRect(0, 0, canvas1.width, canvas1.height);
        drawBoard1();
        drawScore1();
        drawCurrentShape1();

ctx2.clearRect(0, 0, canvas2.width, canvas2.height);
        drawBoard2();
        drawScore2();
        drawCurrentShape2();
        
        moveShapeDown1();
        moveShapeDown2();
      }

createBoard1();
      spawnNextShape1();
      createBoard2();
      spawnNextShape2();

setInterval(gameLoop, 1000 / 2);