AI game creator

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

No:26581

←

Prev Next

→

Merge Game
Developer User13198｜Date and time 23/12/1 21:38:18
Build time 184.761 sec｜Game capacity 7.654KB｜

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">
    <title>Merge Game</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
        }
        
        .container {
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
        }
        
        .game-board {
            width: 300px;
        }
        
        .cell {
            border: 1px solid black;
            width: 50px;
            height: 50px;
            display: flex;
            justify-content: center;
            align-items: center;
            font-size: 24px;
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="game-board"></div>
    </div>

// Function to generate a random number between min and max (inclusive)
        function getRandomNumber(min, max) {
            return Math.floor(Math.random() * (max - min + 1) + min);
        }

// Function to initialize the game board
        function initializeBoard() {
            const gameBoard = [];
            for (let i = 0; i < boardSize; i++) {
                const row = [];
                for (let j = 0; j < boardSize; j++) {
                    row.push(0);
                }
                gameBoard.push(row);
            }
            addRandomTile(gameBoard);
            addRandomTile(gameBoard);
            return gameBoard;
        }

// Function to add a random tile (2 or 4) to the game board
        function addRandomTile(gameBoard) {
            const emptyCells = [];
            for (let i = 0; i < boardSize; i++) {
                for (let j = 0; j < boardSize; j++) {
                    if (gameBoard[i][j] === 0) {
                        emptyCells.push({ row: i, col: j });
                    }
                }
            }
            if (emptyCells.length > 0) {
                const randomIndex = getRandomNumber(0, emptyCells.length - 1);
                const randomCell = emptyCells[randomIndex];
                gameBoard[randomCell.row][randomCell.col] = getRandomNumber(1, 2) * 2;
            }
        }

// Function to merge tiles in a given direction
        function mergeTiles(gameBoard, direction) {
            const reverse = direction === 'right' || direction === 'down';
            const transpose = direction === 'up' || direction === 'down';

for (let i = 0; i < boardSize; i++) {
                gameBoard[i] = mergeLine(gameBoard[i], reverse);
            }

if (transpose) {
                gameBoard = transposeBoard(gameBoard);
                for (let i = 0; i < boardSize; i++) {
                    gameBoard[i] = mergeLine(gameBoard[i], reverse);
                }
                gameBoard = transposeBoard(gameBoard);
            }

return gameBoard;
        }

// Helper function to merge a single line of tiles
        function mergeLine(line, reverse) {
            let mergingIndex;
            if (reverse) {
                line.reverse();
                mergingIndex = boardSize - 2;
            } else {
                mergingIndex = 1;
            }
            for (let i = mergingIndex; reverse ? i >= 0 : i < boardSize; reverse ? i-- : i++) {
                if (line[i - 1] === line[i]) {
                    line[i] *= 2;
                    line[i - 1] = 0;
                }
            }
            if (reverse) {
                line.reverse();
            }
            return line;
        }

// Helper function to transpose the game board
        function transposeBoard(gameBoard) {
            const transposedBoard = [];
            for (let i = 0; i < boardSize; i++) {
                const row = [];
                for (let j = 0; j < boardSize; j++) {
                    row.push(gameBoard[j][i]);
                }
                transposedBoard.push(row);
            }
            return transposedBoard;
        }

// Function to check if there are any valid moves left
        function hasValidMoves(gameBoard) {
            for (let i = 0; i < boardSize; i++) {
                for (let j = 0; j < boardSize; j++) {
                    if (gameBoard[i][j] === 0) {
                        return true;
                    }
                    if (i < boardSize - 1 && gameBoard[i][j] === gameBoard[i + 1][j]) {
                        return true;
                    }
                    if (j < boardSize - 1 && gameBoard[i][j] === gameBoard[i][j + 1]) {
                        return true;
                    }
                }
            }
            return false;
        }

// Function to update the game board UI
        function updateGameBoardUI(gameBoard) {
            const gameBoardElement = document.querySelector('.game-board');
            gameBoardElement.innerHTML = '';

for (let i = 0; i < boardSize; i++) {
                for (let j = 0; j < boardSize; j++) {
                    const cellValue = gameBoard[i][j];
                    const cell = document.createElement('div');
                    cell.className = 'cell';
                    cell.innerText = cellValue > 0 ? getPictogram(cellValue) : '';
                    gameBoardElement.appendChild(cell);
                }
            }
        }

// Function to get the pictogram for a given tile value
        function getPictogram(value) {
            // Return the appropriate pictogram based on the value of the tile
            // You can define your own set of pictograms using emojis or icons

switch (value) {
                case 2:
                    return '🔵';
                case 4:
                    return '🔴';
                case 8:
                    return '🟠';
                case 16:
                    return '🟡';
                case 32:
                    return '🟢';
                case 64:
                    return '🔷';
                case 128:
                    return '🔶';
                case 256:
                    return '🔺';
                case 512:
                    return '🔹';
                case 1024:
                    return '🔸';
                case 2048:
                    return '🔳';
                default:
                    return '';
            }
        }

// Function to handle keypress events
        function handleKeyPress(event) {
            let direction;

switch (event.key) {
                case 'ArrowUp':
                    direction = 'up';
                    break;
                case 'ArrowDown':
                    direction = 'down';
                    break;
                case 'ArrowLeft':
                    direction = 'left';
                    break;
                case 'ArrowRight':
                    direction = 'right';
                    break;
                default:
                    return;
            }

gameBoard = mergeTiles(gameBoard, direction);
            addRandomTile(gameBoard);
            updateGameBoardUI(gameBoard);

if (!hasValidMoves(gameBoard)) {
                alert('Game Over!');
                document.removeEventListener('keydown', handleKeyPress);
            }
        }

// Initial game board setup
        let gameBoard = initializeBoard();
        updateGameBoardUI(gameBoard);

// Event listener for keypress events
        document.addEventListener('keydown', handleKeyPress);
    </script>
</body>
</html>