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

No:13717

116

←

Prev Next

→

マージゲーム
Developer User6006｜Date and time 23/8/29 16:54:17
Build time 51.847 sec｜Game capacity 9.263KB｜

Script

了解です。マージゲームを実装します。以下が実装例です。

Merge Game

以上が実際のマージゲームの実装例です。このコードをHTMLファイルとして保存し、スマートフォンで開くことで遊ぶことができます。ゲームボード上の数字はスワイプ操作によってマージされる仕組みとなっています。

←

Prev　Next

→ 　

Back　

[PR]現在の欲しいゲームランキング

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

了解です。マージゲームを実装します。以下が実装例です。

```html
<!DOCTYPE html>
<html>
<head>
    <title>Merge Game</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            text-align: center;
        }
        
        #game-board {
            margin-top: 50px;
        }
        
        .tile {
            display: inline-block;
            width: 80px;
            height: 80px;
            border: 2px solid black;
            font-size: 24px;
            line-height: 80px;
            vertical-align: middle;
            margin: 5px;
        }
    </style>
</head>
<body>
    <h1>Merge Game</h1>
    <div id="game-board"></div>
    
    <script>
        // ゲームボードのサイズ
        const BOARD_SIZE = 4;
        
        // ゲームボードの初期化
        let gameBoard = new Array(BOARD_SIZE);
        for (let i = 0; i < BOARD_SIZE; i++) {
            gameBoard[i] = new Array(BOARD_SIZE);
        }
        
        // ゲームボードにランダムに数字を追加
        function addRandomNumber() {
            let emptyTiles = [];
            
            // 空のタイルの位置を取得
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    if (gameBoard[i][j] === undefined) {
                        emptyTiles.push({ row: i, col: j });
                    }
                }
            }
            
            // ランダムに数字を追加
            if (emptyTiles.length > 0) {
                let randomTile = emptyTiles[Math.floor(Math.random() * emptyTiles.length)];
                gameBoard[randomTile.row][randomTile.col] = Math.random() < 0.8 ? 2 : 4;
            }
        }
        
        // ゲームボードを描画
        function drawGameBoard() {
            let boardElement = document.getElementById('game-board');
            boardElement.innerHTML = '';
            
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    let tileValue = gameBoard[i][j] === undefined ? '' : gameBoard[i][j];
                    let tileElement = document.createElement('div');
                    tileElement.className = 'tile';
                    tileElement.innerText = tileValue;
                    boardElement.appendChild(tileElement);
                }
                
                let lineBreak = document.createElement('br');
                boardElement.appendChild(lineBreak);
            }
        }
        
        // ゲームの初期化
        function initializeGame() {
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    gameBoard[i][j] = undefined;
                }
            }
            
            addRandomNumber();
            addRandomNumber();
            drawGameBoard();
        }
        
        // ゲームの初期化
        initializeGame();
        
        // スワイプ操作の処理
        document.addEventListener('touchstart', handleTouchStart, false);        
        document.addEventListener('touchmove', handleTouchMove, false);
        
        let xDown = null;
        let yDown = null;
        
        function handleTouchStart(event) {
            xDown = event.touches[0].clientX;
            yDown = event.touches[0].clientY;
        }
        
        function handleTouchMove(event) {
            if (!xDown || !yDown) {
                return;
            }
            
            let xUp = event.touches[0].clientX;
            let yUp = event.touches[0].clientY;
            
            let xDiff = xDown - xUp;
            let yDiff = yDown - yUp;
            
            if (Math.abs(xDiff) > Math.abs(yDiff)) {
                if (xDiff > 0) {
                    mergeLeft();
                } else {
                    mergeRight();
                }
            } else {
                if (yDiff > 0) {
                    mergeUp();
                } else {
                    mergeDown();
                }
            }
            
            xDown = null;
            yDown = null;
        }
        
        // 左にマージする処理
        function mergeLeft() {
            let merged = false;
            
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = 1; j < BOARD_SIZE; j++) {
                    if (gameBoard[i][j] !== undefined) {
                        let k = j - 1;
                        
                        while (k >= 0 && gameBoard[i][k] === undefined) {
                            k--;
                        }
                        
                        if (k >= 0 && gameBoard[i][k] === gameBoard[i][j]) {
                            gameBoard[i][k] *= 2;
                            gameBoard[i][j] = undefined;
                            merged = true;
                        } else if (k + 1 !== j) {
                            gameBoard[i][k + 1] = gameBoard[i][j];
                            gameBoard[i][j] = undefined;
                            merged = true;
                        }
                    }
                }
            }
            
            if (merged) {
                addRandomNumber();
                drawGameBoard();
            }
        }
        
        // 右にマージする処理
        function mergeRight() {
            let merged = false;
            
            for (let i = 0; i < BOARD_SIZE; i++) {
                for (let j = BOARD_SIZE - 2; j >= 0; j--) {
                    if (gameBoard[i][j] !== undefined) {
                        let k = j + 1;
                        
                        while (k < BOARD_SIZE && gameBoard[i][k] === undefined) {
                            k++;
                        }
                        
                        if (k < BOARD_SIZE && gameBoard[i][k] === gameBoard[i][j]) {
                            gameBoard[i][k] *= 2;
                            gameBoard[i][j] = undefined;
                            merged = true;
                        } else if (k - 1 !== j) {
                            gameBoard[i][k - 1] = gameBoard[i][j];
                            gameBoard[i][j] = undefined;
                            merged = true;
                        }
                    }
                }
            }
            
            if (merged) {
                addRandomNumber();
                drawGameBoard();
            }
        }
        
        // 上にマージする処理
        function mergeUp() {
            let merged = false;
            
            for (let i = 1; i < BOARD_SIZE; i++) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    if (gameBoard[i][j] !== undefined) {
                        let k = i - 1;
                        
                        while (k >= 0 && gameBoard[k][j] === undefined) {
                            k--;
                        }
                        
                        if (k >= 0 && gameBoard[k][j] === gameBoard[i][j]) {
                            gameBoard[k][j] *= 2;
                            gameBoard[i][j] = undefined;
                            merged = true;
                        } else if (k + 1 !== i) {
                            gameBoard[k + 1][j] = gameBoard[i][j];
                            gameBoard[i][j] = undefined;
                            merged = true;
                        }
                    }
                }
            }
            
            if (merged) {
                addRandomNumber();
                drawGameBoard();
            }
        }
        
        // 下にマージする処理
        function mergeDown() {
            let merged = false;
            
            for (let i = BOARD_SIZE - 2; i >= 0; i--) {
                for (let j = 0; j < BOARD_SIZE; j++) {
                    if (gameBoard[i][j] !== undefined) {
                        let k = i + 1;
                        
                        while (k < BOARD_SIZE && gameBoard[k][j] === undefined) {
                            k++;
                        }
                        
                        if (k < BOARD_SIZE && gameBoard[k][j] === gameBoard[i][j]) {
                            gameBoard[k][j] *= 2;
                            gameBoard[i][j] = undefined;
                            merged = true;
                        } else if (k - 1 !== i) {
                            gameBoard[k - 1][j] = gameBoard[i][j];
                            gameBoard[i][j] = undefined;
                            merged = true;
                        }
                    }
                }
            }
            
            if (merged) {
                addRandomNumber();
                drawGameBoard();
            }
        }
    </script>
</body>
</html>
```