AI game creator

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

No:9435

115

←

Prev Next

→

Pentris
Developer User4358｜Date and time 23/7/24 21:42:49
Build time 50.881 sec｜Game capacity 6.017KB｜

Script

Sure, here's an example of a simple implementation of Pentris, a variant of the classic Tetris game, using JavaScript in a single HTML file:

This implementation of Pentris uses a simple playfield represented as a 2D array and handles the movement, rotation, collision detection, scoring, and game over conditions. The game is played using the arrow keys to control the pieces. The playfield is displayed using HTML `<div>` elements, and each piece is represented as filled-in blocks within the playfield. The game state and piece positions are stored in `localStorage` to allow the game to be resumed even if the page is refreshed. Please note that the above code is just a basic implementation and may not include all the features and complexity of a full-fledged game. You can modify and enhance it according to your specific needs and design preferences.

←

Prev　Next

→ 　

Back　

[PR]現在のゲームギフトランキング

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

Sure, here's an example of a simple implementation of Pentris, a variant of the classic Tetris game, using JavaScript in a single HTML file:

```html
<!DOCTYPE html>
<html>
<head>
  <title>Pentris</title>
  <style>
    #playfield {
      width: 200px;
      height: 400px;
      border: 1px solid black;
      position: relative;
      overflow: hidden;
    }
    #playfield div {
      width: 20px;
      height: 20px;
      border: 1px solid gray;
      position: absolute;
    }
  </style>
</head>
<body>
  <div id="playfield"></div>

const playfield = [];
    let currentPiece = localStorage.getItem("currentPiece") || generatePiece();
    let currentRow = localStorage.getItem("currentRow") || 0;
    let currentCol = localStorage.getItem("currentCol") || 3;

for (let row = 0; row < rows; row++) {
      playfield[row] = [];
      for (let col = 0; col < cols; col++) {
        playfield[row][col] = 0;
      }
    }

function generatePiece() {
      const pieces = [
        [[1, 1], [1, 1]], // square
        [[1, 1, 1, 1]], // line
        [[1, 1, 1], [0, 1, 0]], // T-shape
        [[1, 1, 0], [0, 1, 1]] // Z-shape
      ];

return pieces[Math.floor(Math.random() * pieces.length)];
    }

function draw() {
      const playfieldElement = document.getElementById("playfield");

// Clear previous state
      while (playfieldElement.firstChild) {
        playfieldElement.firstChild.remove();
      }

for (let row = 0; row < rows; row++) {
        for (let col = 0; col < cols; col++) {
          if (playfield[row][col]) {
            const block = document.createElement("div");
            block.style.top = blockSize * row + "px";
            block.style.left = blockSize * col + "px";
            playfieldElement.appendChild(block);
          }
        }
      }

// Draw current piece
      for (let row = 0; row < currentPiece.length; row++) {
        for (let col = 0; col < currentPiece[row].length; col++) {
          if (currentPiece[row][col]) {
            const block = document.createElement("div");
            block.style.top = blockSize * (currentRow + row) + "px";
            block.style.left = blockSize * (currentCol + col) + "px";
            playfieldElement.appendChild(block);
          }
        }
      }
    }

function movePiece(deltaRow, deltaCol) {
      currentRow += deltaRow;
      currentCol += deltaCol;

if (isCollision()) {
        currentRow -= deltaRow;
        currentCol -= deltaCol;

if (deltaRow === 1) {
          placePiece();
        }
      }
    }

function rotatePiece() {
      const rotatedPiece = [];
      for (let col = 0; col < currentPiece[0].length; col++) {
        rotatedPiece[col] = [];
        for (let row = 0; row < currentPiece.length; row++) {
          rotatedPiece[col][row] = currentPiece[currentPiece.length - 1 - row][col];
        }
      }

currentPiece = rotatedPiece;

if (isCollision()) {
        currentPiece = rotatePiece();
      }
    }

return false;
    }

// Check for line clears
      for (let row = rows - 1; row >= 0; row--) {
        if (playfield[row].every((block) => block)) {
          playfield.splice(row, 1);
          playfield.unshift(Array(cols).fill(0));
        }
      }

currentPiece = generatePiece();
      currentRow = 0;
      currentCol = 3;

if (isCollision()) {
        alert("Game over!");
        localStorage.clear();
        location.reload(); // to start a new game
      }
    }

function update() {
      movePiece(1, 0); // move down

localStorage.setItem("currentPiece", JSON.stringify(currentPiece));
      localStorage.setItem("currentRow", currentRow);
      localStorage.setItem("currentCol", currentCol);

draw();
    }

setInterval(update, speed);

// Event listeners for controls
    document.addEventListener("keydown", (event) => {
      switch (event.keyCode) {
        case 37: // left arrow
          movePiece(0, -1);
          break;
        case 39: // right arrow
          movePiece(0, 1);
          break;
        case 40: // down arrow
          movePiece(1, 0);
          break;
        case 38: // up arrow
          rotatePiece();
          break;
      }
    });
  </script>
</body>
</html>
```

Please note that the above code is just a basic implementation and may not include all the features and complexity of a full-fledged game. You can modify and enhance it according to your specific needs and design preferences.