AI game creator

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

No:31833

←

Prev Next

→

Merge Game
Developer User15247｜Date and time 23/12/28 15:27:05
Build time 84.098 sec｜Game capacity 10.772KB｜

Script

Sure! Here's a simple text-based game called "Merge Game" implemented as a single HTML file with JavaScript enclosed in script tags:

Merge Game

Join the numbers and get to the 2048 tile!

This game is an implementation of the popular mobile game "2048" using JavaScript and HTML. The game consists of a 4x4 grid filled with numbers, with the objective being to merge matching numbers by moving them in different directions (up, down, left, or right). The goal is to reach the number 2048. You can play the game using the arrow keys on your smartphone. Simply swipe in the desired direction (up, down, left, or right) to merge the numbers accordingly. The game will automatically add new random numbers and update the score. The game will end when there are no more valid moves available and display your final score. The game interface is designed using simple CSS styles and displays the numbers using text within the grid cells.

←

Prev　Next

→ 　

Back　

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

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

Sure! Here's a simple text-based game called "Merge Game" implemented as a single HTML file with JavaScript enclosed in script tags:

```html
<!DOCTYPE html>
<html>

<head>
    <title>Merge Game</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
            margin-top: 100px;
        }

.container {
            display: flex;
            justify-content: center;
            align-items: center;
            flex-wrap: wrap;
        }

.item {
            width: 50px;
            height: 50px;
            background-color: #ddd;
            border: 1px solid #aaa;
            margin: 5px;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 20px;
        }

.highlight {
            background-color: #FFC107;
            border-color: #FFA000;
        }

.game-over {
            font-size: 24px;
            color: red;
            margin-top: 20px;
        }
    </style>
</head>

<body>
    <h2>Merge Game</h2>
    <p>Join the numbers and get to the 2048 tile!</p>

// Render the game board
        function renderBoard() {
            const container = document.querySelector('.container');
            container.innerHTML = '';

board.forEach(row => {
                row.forEach(value => {
                    const item = document.createElement('div');
                    item.classList.add('item');
                    item.textContent = value > 0 ? value : '';
                    container.appendChild(item);
                });
            });
        }

// Add initial numbers to the board
        function addInitialNumbers() {
            for (let i = 0; i < 2; i++) {
                addRandomNumber();
            }
        }

// Add a random number (2 or 4) at an empty position on the board
        function addRandomNumber() {
            const emptyCells = [];
            for (let i = 0; i < 4; i++) {
                for (let j = 0; j < 4; j++) {
                    if (board[i][j] === 0) {
                        emptyCells.push({ row: i, col: j });
                    }
                }
            }

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

// Merge the board in the specified direction (up, down, left, or right)
        function mergeBoard(direction) {
            let moved = false;

switch (direction) {
                case 'up':
                    for (let col = 0; col < 4; col++) {
                        for (let row = 1; row < 4; row++) {
                            if (board[row][col] !== 0) {
                                let currentRow = row;
                                while (currentRow > 0 && board[currentRow - 1][col] === 0) {
                                    board[currentRow - 1][col] = board[currentRow][col];
                                    board[currentRow][col] = 0;
                                    currentRow--;
                                    moved = true;
                                }

if (currentRow > 0 && board[currentRow - 1][col] === board[currentRow][col]) {
                                    board[currentRow - 1][col] *= 2;
                                    score += board[currentRow - 1][col];
                                    board[currentRow][col] = 0;
                                    moved = true;
                                }
                            }
                        }
                    }
                    break;

case 'down':
                    for (let col = 0; col < 4; col++) {
                        for (let row = 2; row >= 0; row--) {
                            if (board[row][col] !== 0) {
                                let currentRow = row;
                                while (currentRow < 3 && board[currentRow + 1][col] === 0) {
                                    board[currentRow + 1][col] = board[currentRow][col];
                                    board[currentRow][col] = 0;
                                    currentRow++;
                                    moved = true;
                                }

if (currentRow < 3 && board[currentRow + 1][col] === board[currentRow][col]) {
                                    board[currentRow + 1][col] *= 2;
                                    score += board[currentRow + 1][col];
                                    board[currentRow][col] = 0;
                                    moved = true;
                                }
                            }
                        }
                    }
                    break;

case 'left':
                    for (let row = 0; row < 4; row++) {
                        for (let col = 1; col < 4; col++) {
                            if (board[row][col] !== 0) {
                                let currentCol = col;
                                while (currentCol > 0 && board[row][currentCol - 1] === 0) {
                                    board[row][currentCol - 1] = board[row][currentCol];
                                    board[row][currentCol] = 0;
                                    currentCol--;
                                    moved = true;
                                }

if (currentCol > 0 && board[row][currentCol - 1] === board[row][currentCol]) {
                                    board[row][currentCol - 1] *= 2;
                                    score += board[row][currentCol - 1];
                                    board[row][currentCol] = 0;
                                    moved = true;
                                }
                            }
                        }
                    }
                    break;

case 'right':
                    for (let row = 0; row < 4; row++) {
                        for (let col = 2; col >= 0; col--) {
                            if (board[row][col] !== 0) {
                                let currentCol = col;
                                while (currentCol < 3 && board[row][currentCol + 1] === 0) {
                                    board[row][currentCol + 1] = board[row][currentCol];
                                    board[row][currentCol] = 0;
                                    currentCol++;
                                    moved = true;
                                }

if (currentCol < 3 && board[row][currentCol + 1] === board[row][currentCol]) {
                                    board[row][currentCol + 1] *= 2;
                                    score += board[row][currentCol + 1];
                                    board[row][currentCol] = 0;
                                    moved = true;
                                }
                            }
                        }
                    }
                    break;
            }

if (moved) {
                addRandomNumber();
                renderBoard();
                checkGameOver();
            }
        }

// Check if the game is over (no more valid moves)
        function checkGameOver() {
            const directions = ['up', 'down', 'left', 'right'];
            let validMoveAvailable = false;

for (let direction of directions) {
                let testBoard = JSON.parse(JSON.stringify(board)); // Create a deep copy
                mergeBoardInDirection(testBoard, direction);
                
                if (!arraysEqual(board, testBoard)) {
                    validMoveAvailable = true;
                    break;
                }
            }

gameOver = !validMoveAvailable;

if (gameOver) {
                const gameoverText = document.createElement('div');
                gameoverText.classList.add('game-over');
                gameoverText.textContent = 'Game Over! Your Score: ' + score;
                document.body.appendChild(gameoverText);
            }
        }

// Helper function to check if two arrays are equal
        function arraysEqual(arr1, arr2) {
            if (arr1.length !== arr2.length) return false;
            for (let i = 0; i < arr1.length; i++) {
                if (arr1[i].length !== arr2[i].length) return false;
                for (let j = 0; j < arr1[i].length; j++) {
                    if (arr1[i][j] !== arr2[i][j]) return false;
                }
            }
            return true;
        }

// Handle key events for arrow keys
        function handleArrowKeys(event) {
            if (gameOver) return;

event.preventDefault();

switch (event.keyCode) {
                case 37: // Left arrow
                    mergeBoard('left');
                    break;
                case 38: // Up arrow
                    mergeBoard('up');
                    break;
                case 39: // Right arrow
                    mergeBoard('right');
                    break;
                case 40: // Down arrow
                    mergeBoard('down');
                    break;
            }
        }

// Initialize the game
        function initializeGame() {
            addInitialNumbers();
            renderBoard();
            document.addEventListener('keydown', handleArrowKeys);
        }

initializeGame();
    </script>
</body>

</html>
```

You can play the game using the arrow keys on your smartphone. Simply swipe in the desired direction (up, down, left, or right) to merge the numbers accordingly. The game will automatically add new random numbers and update the score. The game will end when there are no more valid moves available and display your final score.

The game interface is designed using simple CSS styles and displays the numbers using text within the grid cells.