Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 157

Warning: in_array() expects parameter 2 to be array, bool given in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 476

Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 484
Doctor who 2048 game's game | AI game creator

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

No:26868

126

←

Prev Next

→

Doctor who 2048 game
Developer User13293｜Date and time 23/12/2 21:49:16
Build time 168.129 sec｜Game capacity 8.892KB｜

Script

Sure! Here's a sample implementation of a Doctor Who themed 2048 game:

Doctor Who 2048

This implementation uses the standard 2048 game mechanics and adds a Doctor Who theme to it. You can use the arrow keys on your smartphone to make moves, and the goal is to reach the 2048 tile by combining tiles with the same number.

←

Prev　Next

→ 　

Back　

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

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

Sure! Here's a sample implementation of a Doctor Who themed 2048 game:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Doctor Who 2048</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            font-family: Arial, sans-serif;
            text-align: center;
            background-color: #000;
        }
        h1 {
            color: #fff;
            margin: 20px;
        }
        #game-board {
            background-color: #333;
            margin: 20px auto;
            width: 400px;
            height: 400px;
            position: relative;
        }
        .tile {
            position: absolute;
            width: 90px;
            height: 90px;
            text-align: center;
            line-height: 90px;
            font-size: 24px;
            font-weight: bold;
            border-radius: 5px;
            color: #fff;
        }
        .tile-2 { background-color: #73617F; }
        .tile-4 { background-color: #9966CC; }
        .tile-8 { background-color: #FFFF00; }
        .tile-16 { background-color: #FFA500; }
        .tile-32 { background-color: #FF0000; }
        .tile-64 { background-color: #00FF00; }
        .tile-128 { background-color: #800000; }
        .tile-256 { background-color: #FF00FF; }
        .tile-512 { background-color: #008080; }
        .tile-1024 { background-color: #00FFFF; }
        .tile-2048 { background-color: #C0C0C0; }
    </style>
</head>
<body>
    <h1>Doctor Who 2048</h1>
    <div id="game-board"></div>

// Initialize game state
            let grid = Array(gridSize).fill().map(() => Array(gridSize).fill(0));
            
            // Create initial tiles
            addNewTile();
            addNewTile();

// Update the game board UI
            function updateBoard() {
                gameBoard.innerHTML = '';

// Loop through the grid and create tiles
                for (let i = 0; i < gridSize; i++) {
                    for (let j = 0; j < gridSize; j++) {
                        const value = grid[i][j];
                        const tile = document.createElement('div');

tile.className = `tile tile-${value}`;
                        tile.style.top = `${i * 100}px`;
                        tile.style.left = `${j * 100}px`;
                        tile.textContent = value;

gameBoard.appendChild(tile);
                    }
                }
            }

// Add a new tile (2 or 4) in a random empty cell
            function addNewTile() {
                const emptyCells = [];

for (let i = 0; i < gridSize; i++) {
                    for (let j = 0; j < gridSize; j++) {
                        if (grid[i][j] === 0) {
                            emptyCells.push({ row: i, col: j });
                        }
                    }
                }

const randomCell = emptyCells[Math.floor(Math.random() * emptyCells.length)];
                grid[randomCell.row][randomCell.col] = Math.random() < 0.9 ? 2 : 4;

updateBoard();
            }

// Check if the game is over (no empty spaces and no valid moves)
            function isGameOver() {
                for (let i = 0; i < gridSize; i++) {
                    for (let j = 0; j < gridSize; j++) {
                        if (grid[i][j] === 0) {
                            return false;
                        }
                        if (i < gridSize - 1 && grid[i][j] === grid[i + 1][j]) {
                            return false;
                        }
                        if (j < gridSize - 1 && grid[i][j] === grid[i][j + 1]) {
                            return false;
                        }
                    }
                }
                return true;
            }

// Process key press events
            document.addEventListener('keydown', function(event) {
                if (event.key === Key.UP) {
                    moveTilesUp();
                } else if (event.key === Key.DOWN) {
                    moveTilesDown();
                } else if (event.key === Key.LEFT) {
                    moveTilesLeft();
                } else if (event.key === Key.RIGHT) {
                    moveTilesRight();
                }
            });

// Move tiles up
            function moveTilesUp() {
                for (let j = 0; j < gridSize; j++) {
                    for (let i = 1; i < gridSize; i++) {
                        if (grid[i][j] !== 0) {
                            let row = i;
                            while (row > 0 && grid[row - 1][j] === 0) {
                                grid[row - 1][j] = grid[row][j];
                                grid[row][j] = 0;
                                row--;
                            }
                            if (row > 0 && grid[row - 1][j] === grid[row][j]) {
                                grid[row - 1][j] *= 2;
                                grid[row][j] = 0;
                            }
                        }
                    }
                }

addNewTile();
                if (isGameOver()) {
                    alert('Game Over');
                }
            }

// Move tiles down
            function moveTilesDown() {
                for (let j = 0; j < gridSize; j++) {
                    for (let i = gridSize - 2; i >= 0; i--) {
                        if (grid[i][j] !== 0) {
                            let row = i;
                            while (row < gridSize - 1 && grid[row + 1][j] === 0) {
                                grid[row + 1][j] = grid[row][j];
                                grid[row][j] = 0;
                                row++;
                            }
                            if (row < gridSize - 1 && grid[row + 1][j] === grid[row][j]) {
                                grid[row + 1][j] *= 2;
                                grid[row][j] = 0;
                            }
                        }
                    }
                }

addNewTile();
                if (isGameOver()) {
                    alert('Game Over');
                }
            }

// Move tiles left
            function moveTilesLeft() {
                for (let i = 0; i < gridSize; i++) {
                    for (let j = 1; j < gridSize; j++) {
                        if (grid[i][j] !== 0) {
                            let col = j;
                            while (col > 0 && grid[i][col - 1] === 0) {
                                grid[i][col - 1] = grid[i][col];
                                grid[i][col] = 0;
                                col--;
                            }
                            if (col > 0 && grid[i][col - 1] === grid[i][col]) {
                                grid[i][col - 1] *= 2;
                                grid[i][col] = 0;
                            }
                        }
                    }
                }

addNewTile();
                if (isGameOver()) {
                    alert('Game Over');
                }
            }

// Move tiles right
            function moveTilesRight() {
                for (let i = 0; i < gridSize; i++) {
                    for (let j = gridSize - 2; j >= 0; j--) {
                        if (grid[i][j] !== 0) {
                            let col = j;
                            while (col < gridSize - 1 && grid[i][col + 1] === 0) {
                                grid[i][col + 1] = grid[i][col];
                                grid[i][col] = 0;
                                col++;
                            }
                            if (col < gridSize -1 && grid[i][col + 1] === grid[i][col]) {
                                grid[i][col + 1] *= 2;
                                grid[i][col] = 0;
                            }
                        }
                    }
                }

addNewTile();
                if (isGameOver()) {
                    alert('Game Over');
                }
            }

// Initial board setup
            updateBoard();
        });
    </script>
</body>
</html>
```