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

No:8090

4486

←

Prev Next

→

2048 merge ball numbers
Developer User4131｜Date and time 23/7/12 23:16:41
Build time 46.777 sec｜Game capacity 7.279KB｜

Script

Sure, here's an implementation of the 2048 game using ball numbers:

2048 Merge Ball Numbers

To play the game, you can use the arrow keys on your smartphone or computer keyboard to merge the ball numbers. The objective is to reach the number 2048 by merging adjacent balls with the same number. The game ends when there are no more empty cells or no more valid moves available.

←

Prev　Next

→ 　

Back　

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

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

Sure, here's an implementation of the 2048 game using ball numbers:

```html
<!DOCTYPE html>
<html>
<head>
  <title>2048 Merge Ball Numbers</title>
  <style>
    body {
      font-family: Arial, sans-serif;
      text-align: center;
    }

.ball {
      display: inline-block;
      width: 60px;
      height: 60px;
      margin: 5px;
      border-radius: 50%;
      font-size: 24px;
      line-height: 60px;
      text-align: center;
      background-color: #eee;
    }
  </style>
</head>
<body>
  <h1>2048 Merge Ball Numbers</h1>
  <div id="game"></div>
  <script>
    // Game board size
    const BOARD_SIZE = 4;

// Initialize the game board
    let board = [];
    for (let i = 0; i < BOARD_SIZE; i++) {
      board[i] = [];
      for (let j = 0; j < BOARD_SIZE; j++) {
        board[i][j] = null;
      }
    }

// Generate a new ball (2 or 4) on a random empty cell
    function generateBall() {
      const availableCells = [];
      for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          if (board[i][j] === null) {
            availableCells.push({ x: i, y: j });
          }
        }
      }

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

// Check if the game is over (no more moves possible)
    function isGameOver() {
      for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          if (board[i][j] === null) {
            return false;
          }
          if (i > 0 && board[i][j] === board[i - 1][j]) {
            return false;
          }
          if (i < BOARD_SIZE - 1 && board[i][j] === board[i + 1][j]) {
            return false;
          }
          if (j > 0 && board[i][j] === board[i][j - 1]) {
            return false;
          }
          if (j < BOARD_SIZE - 1 && board[i][j] === board[i][j + 1]) {
            return false;
          }
        }
      }
      return true;
    }

// Render the game board
    function render() {
      const gameDiv = document.getElementById("game");
      gameDiv.innerHTML = "";

for (let i = 0; i < BOARD_SIZE; i++) {
        for (let j = 0; j < BOARD_SIZE; j++) {
          const ball = document.createElement("div");
          ball.className = "ball";
          ball.style.backgroundColor = getBallColor(board[i][j]);
          ball.innerText = board[i][j] ? board[i][j].toString() : "";
          gameDiv.appendChild(ball);
        }
        gameDiv.appendChild(document.createElement("br"));
      }
    }

// Convert the ball number to a CSS color
    function getBallColor(number) {
      switch (number) {
        case 2:
          return "#eec";
        case 4:
          return "#cee";
        case 8:
          return "#9cc";
        case 16:
          return "#6aa";
        case 32:
          return "#488";
        case 64:
          return "#266";
        case 128:
          return "#044";
        case 256:
          return "#822";
        case 512:
          return "#600";
        case 1024:
          return "#e44";
        case 2048:
          return "#c22";
        default:
          return "#000";
      }
    }

// Handle key press events
    document.addEventListener("keydown", function (event) {
      if (isGameOver()) {
        alert("Game Over!");
        return;
      }

let cellsMoved = false;

switch (event.key) {
        case "ArrowUp":
          for (let j = 0; j < BOARD_SIZE; j++) {
            for (let i = 1; i < BOARD_SIZE; i++) {
              if (board[i][j] !== null) {
                let k = i;
                while (k - 1 >= 0 && (board[k - 1][j] === null || board[k - 1][j] === board[i][j])) {
                  if (board[k - 1][j] === null) {
                    board[k - 1][j] = board[k][j];
                    board[k][j] = null;
                    k--;
                    cellsMoved = true;
                  } else if (board[k - 1][j] === board[i][j]) {
                    board[k - 1][j] *= 2;
                    board[i][j] = null;
                    cellsMoved = true;
                    break;
                  }
                }
              }
            }
          }
          break;

case "ArrowDown":
          for (let j = 0; j < BOARD_SIZE; j++) {
            for (let i = BOARD_SIZE - 2; i >= 0; i--) {
              if (board[i][j] !== null) {
                let k = i;
                while (k + 1 < BOARD_SIZE && (board[k + 1][j] === null || board[k + 1][j] === board[i][j])) {
                  if (board[k + 1][j] === null) {
                    board[k + 1][j] = board[k][j];
                    board[k][j] = null;
                    k++;
                    cellsMoved = true;
                  } else if (board[k + 1][j] === board[i][j]) {
                    board[k + 1][j] *= 2;
                    board[i][j] = null;
                    cellsMoved = true;
                    break;
                  }
                }
              }
            }
          }
          break;

case "ArrowLeft":
          for (let i = 0; i < BOARD_SIZE; i++) {
            for (let j = 1; j < BOARD_SIZE; j++) {
              if (board[i][j] !== null) {
                let k = j;
                while (k - 1 >= 0 && (board[i][k - 1] === null || board[i][k - 1] === board[i][j])) {
                  if (board[i][k - 1] === null) {
                    board[i][k - 1] = board[i][k];
                    board[i][k] = null;
                    k--;
                    cellsMoved = true;
                  } else if (board[i][k - 1] === board[i][j]) {
                    board[i][k - 1] *= 2;
                    board[i][j] = null;
                    cellsMoved = true;
                    break;
                  }
                }
              }
            }
          }
          break;

case "ArrowRight":
          for (let i = 0; i < BOARD_SIZE; i++) {
            for (let j = BOARD_SIZE - 2; j >= 0; j--) {
              if (board[i][j] !== null) {
                let k = j;
                while (k + 1 < BOARD_SIZE && (board[i][k + 1] === null || board[i][k + 1] === board[i][j])) {
                  if (board[i][k + 1] === null) {
                    board[i][k + 1] = board[i][k];
                    board[i][k] = null;
                    k++;
                    cellsMoved = true;
                  } else if (board[i][k + 1] === board[i][j]) {
                    board[i][k + 1] *= 2;
                    board[i][j] = null;
                    cellsMoved = true;
                    break;
                  }
                }
              }
            }
          }
          break;
      }

if (cellsMoved) {
        generateBall();
        render();
      }
    });

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