AI game creator

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

No:22003

6915

←

Prev Next

→

minesweeper
Developer anonymous｜Date and time 70/1/1 10:54:24
Build time unknown sec｜Game capacity 6.864KB｜

Script

Sure! Here's a simple implementation of Minesweeper as a single HTML file using JavaScript. This game is designed to be played on a smartphone, and it uses pictograms to represent the mines and numbers.

To use this code, please save it as an HTML file (e.g., `minesweeper.html`), and open it in any web browser on your smartphone. The game will start automatically, and you can click on the cells to reveal them. If you click on a mine, the game is over, and all cells will be revealed. Note: This is a simplified version of Minesweeper and does not include features like flagging mines or timers. You can enhance the game by adding those features if desired.

←

Prev　Next

→ 　

Back　

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

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

```html
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <style>
        body {
            font-size: 2rem;
            text-align: center;
        }

.board {
            display: inline-block;
        }

.cell {
            display: inline-block;
            width: 3rem;
            height: 3rem;
            margin: 0.2rem;
            background-color: #ccc;
        }

.hidden {
            background-color: #999;
        }

.mine {
            background-image: url("mine.png");
            background-size: contain;
        }

.number {
            font-weight: bold;
        }

.revealed {
            background-color: #fff;
        }
    </style>
</head>
<body>
    <div id="board" class="board"></div>

// Game State
        let board = [];
        let gameOver = false;

// Create the game board
        function createBoard() {
            const boardElement = document.getElementById('board');

for (let row = 0; row < BOARD_SIZE; row++) {
                const rowElement = document.createElement('div');
                rowElement.classList.add('row');
                board.push([]);

for (let col = 0; col < BOARD_SIZE; col++) {
                    const cellElement = document.createElement('div');
                    cellElement.classList.add('cell', 'hidden');
                    cellElement.dataset.row = row;
                    cellElement.dataset.col = col;
                    cellElement.addEventListener('click', handleCellClick);
                    rowElement.appendChild(cellElement);
                    board[row].push({ mine: false, revealed: false, value: 0 });
                }

boardElement.appendChild(rowElement);
            }
        }

// Handle cell click
        function handleCellClick(event) {
            if (gameOver) return;

const row = parseInt(event.target.dataset.row);
            const col = parseInt(event.target.dataset.col);

// Reveal the cell
            revealCell(row, col);

// Check if game over
            if (board[row][col].mine) {
                gameOver = true;
                revealAllCells();
                alert('Game Over!');
            }
        }

// Reveal cell
        function revealCell(row, col) {
            const cell = board[row][col];
            const cellElement = getCellElement(row, col);

if (cell.revealed) return;

cell.revealed = true;
            cellElement.classList.remove('hidden');
            cellElement.classList.add('revealed');

if (cell.mine) {
                cellElement.classList.add('mine');
            } else if (cell.value > 0) {
                cellElement.textContent = cell.value;
                cellElement.classList.add('number');
            } else {
                // Empty cell, reveal neighboring cells
                const neighbors = getNeighbors(row, col);
                neighbors.forEach(([neighborRow, neighborCol]) => {
                    if (!board[neighborRow][neighborCol].mine) {
                        revealCell(neighborRow, neighborCol);
                    }
                });
            }
        }

// Get neighboring cells
        function getNeighbors(row, col) {
            const neighbors = [];

for (let i = -1; i <= 1; i++) {
                for (let j = -1; j <= 1; j++) {
                    if (i === 0 && j === 0) continue;

const neighborRow = row + i;
                    const neighborCol = col + j;

if (
                        neighborRow >= 0 &&
                        neighborRow < BOARD_SIZE &&
                        neighborCol >= 0 &&
                        neighborCol < BOARD_SIZE
                    ) {
                        neighbors.push([neighborRow, neighborCol]);
                    }
                }
            }

return neighbors;
        }

// Reveal all cells when game over
        function revealAllCells() {
            const cells = document.getElementsByClassName('cell');

for (let i = 0; i < cells.length; i++) {
                const cell = cells[i];
                const row = parseInt(cell.dataset.row);
                const col = parseInt(cell.dataset.col);

cell.classList.remove('hidden');
                cell.classList.add('revealed');

if (board[row][col].mine) {
                    cell.classList.add('mine');
                } else if (board[row][col].value > 0) {
                    cell.textContent = board[row][col].value;
                    cell.classList.add('number');
                }
            }
        }

// Utility function to get cell element
        function getCellElement(row, col) {
            return document.querySelector(`[data-row="${row}"][data-col="${col}"]`);
        }

// Initialize the game
        createBoard();

// Randomly place mines on the board
        let minesToPlace = NUM_MINES;
        while (minesToPlace > 0) {
            const randomRow = Math.floor(Math.random() * BOARD_SIZE);
            const randomCol = Math.floor(Math.random() * BOARD_SIZE);

if (!board[randomRow][randomCol].mine) {
                board[randomRow][randomCol].mine = true;
                minesToPlace--;
            }
        }

// Calculate values for each empty cell
        for (let row = 0; row < BOARD_SIZE; row++) {
            for (let col = 0; col < BOARD_SIZE; col++) {
                if (!board[row][col].mine) {
                    const neighbors = getNeighbors(row, col);
                    let value = 0;

neighbors.forEach(([neighborRow, neighborCol]) => {
                        if (board[neighborRow][neighborCol].mine) {
                            value++;
                        }
                    });

board[row][col].value = value;
                }
            }
        }
    </script>
</body>
</html>
```

Note: This is a simplified version of Minesweeper and does not include features like flagging mines or timers. You can enhance the game by adding those features if desired.