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

No:18432

←

Prev Next

→

Merge Game
Developer User8162｜Date and time 23/9/29 10:23:59
Build time 104.503 sec｜Game capacity 9.365KB｜

Script

Sure! Here's an example of a simple Merge Game implemented as a single HTML file using JavaScript:

Merge Game

Score: 0

This Merge Game follows the rules of merging cells with the same value. The objective of the game is to reach the highest possible score by merging cells until there are no more possible moves. To play the game, you can simply open the HTML file in a web browser on your smartphone. Use the arrow keys or swipe gestures (left, right, up, down) to move the cells on the game board. The cells will merge if they have the same value. The game will end when there are no more possible moves available and will display a game over message with your final score. You can then initialize a new game by closing the alert box. Note: This implementation uses keyboard events for convenience, but you can modify it to listen to touch events for better smartphone operation if desired.

←

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 Merge Game implemented as a single HTML file using JavaScript:

```html
<!DOCTYPE html>
<html>
<head>
  <style>
    body {
      font-family: Arial, sans-serif;
      text-align: center;
      margin-top: 50px;
    }

#score {
      font-size: 24px;
      margin-bottom: 20px;
    }

#game-board {
      display: inline-block;
      border: 2px solid #000;
      padding: 20px;
    }

.cell {
      display: inline-block;
      width: 100px;
      height: 100px;
      border: 1px solid #ccc;
      box-sizing: border-box;
    }

.cell span {
      font-size: 36px;
      position: relative;
      top: 50%;
      transform: translateY(-50%);
    }
  </style>
</head>
<body>
  <h1>Merge Game</h1>
  <div id="score">Score: 0</div>
  <div id="game-board"></div>

// Game Variables
    let board = [];
    let score = 0;

// Initialize the game
    function initialize() {
      createBoard();
      drawBoard();
    }

// Create the initial game board
    function createBoard() {
      for (let i = 0; i < BOARD_SIZE; i++) {
        board[i] = [];
        for (let j = 0; j < BOARD_SIZE; j++) {
          board[i][j] = 0;
        }
      }

// Add two random cells with 2 or 4 values
      addRandomCell();
      addRandomCell();
    }

// Draw the game board on the screen
    function drawBoard() {
      const gameBoard = document.getElementById('game-board');
      gameBoard.innerHTML = '';

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          const cellValue = board[i][j];
          const cell = document.createElement('div');
          cell.className = 'cell';
          cell.innerHTML = `<span>${cellValue ? cellValue : ''}</span>`;
          gameBoard.appendChild(cell);
        }
        gameBoard.appendChild(document.createElement('br'));
      }

document.getElementById('score').innerText = `Score: ${score}`;
    }

// Add a random cell with a value of 2 or 4 to the game board
    function addRandomCell() {
      const emptyCells = [];
      for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          if (board[i][j] === 0) {
            emptyCells.push({ row: i, col: j });
          }
        }
      }

if (emptyCells.length > 0) {
        const randomCell = emptyCells[Math.floor(Math.random() * emptyCells.length)];
        board[randomCell.row][randomCell.col] = Math.random() < 0.9 ? 2 : 4;
      }
    }

// Merge cells with the same value
    function mergeCells() {
      for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE - 1; j++) {
          if (board[i][j] === board[i][j + 1] && board[i][j] !== 0) {
            board[i][j] *= 2;
            score += board[i][j];
            board[i].splice(j + 1, 1);
            board[i].push(0);
          }
        }
      }
    }

// Handle key events
    document.addEventListener('keydown', function(event) {
      let moved = false;
      switch (event.key) {
        case 'ArrowUp':
          moved = moveUp();
          break;
        case 'ArrowDown':
          moved = moveDown();
          break;
        case 'ArrowLeft':
          moved = moveLeft();
          break;
        case 'ArrowRight':
          moved = moveRight();
          break;
      }

if (moved) {
        addRandomCell();
        drawBoard();
        checkGameOver();
      }
    });

// Move cells upwards
    function moveUp() {
      let moved = false;

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = 0; i < BOARD_SIZE - 1; i++) {
          if (board[i][j] !== 0) {
            for (let k = i + 1; k < BOARD_SIZE; k++) {
              if (board[k][j] === 0) {
                [board[i][j], board[k][j]] = [board[k][j], board[i][j]];
                moved = true;
              }
            }
          }
        }
      }

mergeCells();

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = 0; i < BOARD_SIZE - 1; i++) {
          if (board[i][j] !== 0 && board[i][j] === board[i + 1][j]) {
            [board[i][j], board[i + 1][j]] = [0, board[i][j] * 2];
            moved = true;
          }
        }
      }

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = 0; i < BOARD_SIZE - 1; i++) {
          if (board[i][j] === 0 && board[i + 1][j] !== 0) {
            [board[i][j], board[i + 1][j]] = [board[i + 1][j], board[i][j]];
          }
        }
      }

return moved;
    }

// Move cells downwards
    function moveDown() {
      let moved = false;

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = BOARD_SIZE - 1; i > 0; i--) {
          if (board[i][j] !== 0) {
            for (let k = i - 1; k >= 0; k--) {
              if (board[k][j] === 0) {
                [board[i][j], board[k][j]] = [board[k][j], board[i][j]];
                moved = true;
              }
            }
          }
        }
      }

mergeCells();

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = BOARD_SIZE - 1; i > 0; i--) {
          if (board[i][j] !== 0 && board[i][j] === board[i - 1][j]) {
            [board[i][j], board[i - 1][j]] = [0, board[i][j] * 2];
            moved = true;
          }
        }
      }

for (let j = 0; j < BOARD_SIZE; j++) {
        for (let i = BOARD_SIZE - 1; i > 0; i--) {
          if (board[i][j] === 0 && board[i - 1][j] !== 0) {
            [board[i][j], board[i - 1][j]] = [board[i - 1][j], board[i][j]];
          }
        }
      }

return moved;
    }

// Move cells to the left
    function moveLeft() {
      let moved = false;

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE - 1; j++) {
          if (board[i][j] !== 0) {
            for (let k = j + 1; k < BOARD_SIZE; k++) {
              if (board[i][k] === 0) {
                [board[i][j], board[i][k]] = [board[i][k], board[i][j]];
                moved = true;
              }
            }
          }
        }
      }

mergeCells();

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE - 1; j++) {
          if (board[i][j] !== 0 && board[i][j] === board[i][j + 1]) {
            [board[i][j], board[i][j + 1]] = [0, board[i][j] * 2];
            moved = true;
          }
        }
      }

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE - 1; j++) {
          if (board[i][j] === 0 && board[i][j + 1] !== 0) {
            [board[i][j], board[i][j + 1]] = [board[i][j + 1], board[i][j]];
          }
        }
      }

return moved;
    }

// Move cells to the right
    function moveRight() {
      let moved = false;

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = BOARD_SIZE - 1; j > 0; j--) {
          if (board[i][j] !== 0) {
            for (let k = j - 1; k >= 0; k--) {
              if (board[i][k] === 0) {
                [board[i][j], board[i][k]] = [board[i][k], board[i][j]];
                moved = true;
              }
            }
          }
        }
      }

mergeCells();

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = BOARD_SIZE - 1; j > 0; j--) {
          if (board[i][j] !== 0 && board[i][j] === board[i][j - 1]) {
            [board[i][j], board[i][j - 1]] = [0, board[i][j] * 2];
            moved = true;
          }
        }
      }

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = BOARD_SIZE - 1; j > 0; j--) {
          if (board[i][j] === 0 && board[i][j - 1] !== 0) {
            [board[i][j], board[i][j - 1]] = [board[i][j - 1], board[i][j]];
          }
        }
      }

return moved;
    }

// Check if the game is over
    function checkGameOver() {
      let gameOver = true;

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          if (board[i][j] === 0) {
            gameOver = false;
            break;
          }
  
          if (i < BOARD_SIZE - 1 && board[i][j] === board[i + 1][j]) {
            gameOver = false;
            break;
          }
  
          if (j < BOARD_SIZE - 1 && board[i][j] === board[i][j + 1]) {
            gameOver = false;
            break;
          }
        }
  
        if (!gameOver) {
          break;
        }
      }

if (gameOver) {
        alert(`Game Over!\nYour Score: ${score}`);
        initialize();
      }
    }

// Start the game
    initialize();
  </script>
</body>
</html>
```

This Merge Game follows the rules of merging cells with the same value. The objective of the game is to reach the highest possible score by merging cells until there are no more possible moves.

To play the game, you can simply open the HTML file in a web browser on your smartphone. Use the arrow keys or swipe gestures (left, right, up, down) to move the cells on the game board. The cells will merge if they have the same value.

The game will end when there are no more possible moves available and will display a game over message with your final score. You can then initialize a new game by closing the alert box.

Note: This implementation uses keyboard events for convenience, but you can modify it to listen to touch events for better smartphone operation if desired.