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

No:19145

Crie um jogo chamado dugem onde na programação ter..ALL
Developer User8225｜Date and time 23/10/1 21:51:06
Build time 21.747 sec｜Game capacity 4.432KB｜

Script

Aqui está um exemplo de um jogo chamado "Dugem" que cria um labirinto de forma aleatória usando uma grade com diferentes tipos de células. O jogador, representado pelo número 5, pode se mover para todas as direções, exceto pelas células que são paredes ou estão fora dos limites do labirinto. Ao tocar na célula de saída (representada pelo número 9), um novo labirinto é gerado.

Dugem - Jogo de Labirinto

Para jogar, você pode abrir esse código-fonte em um navegador da web em seu smartphone e tocar nas células do labirinto para mover o jogador em direções válidas. Quando você alcançar a célula de saída, um novo labirinto será gerado automaticamente.

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋グッズランキング

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

```html
<!DOCTYPE html>
<html>
<head>
  <title>Dugem - Jogo de Labirinto</title>
  <style>
    table {
      border-collapse: collapse;
    }

td {
      width: 40px;
      height: 40px;
      border: 1px solid black;
    }

.cell-0 {
      background-color: white;
    }

.cell-1 {
      background-color: black;
    }

.cell-2 {
      background-color: green;
    }

.cell-3 {
      background-color: red;
    }

.cell-5 {
      background-color: blue;
    }

.cell-9 {
      background-color: yellow;
    }
  </style>
</head>
<body>
  <h1>Dugem - Jogo de Labirinto</h1>
  <table id="grid"></table>

const grid = createGrid();

// Geração de um novo labirinto
    function generateMaze() {
      for (let row = 0; row < numRows; row++) {
        for (let col = 0; col < numCols; col++) {
          if (row === 0 || row === numRows - 1 || col === 0 || col === numCols - 1) {
            grid[row][col] = 1; // Parede
          } else {
            grid[row][col] = Math.random() < 0.2 ? 1 : 0; // 20% de chance de ser parede
          }
        }
      }

const startRow = getRandomNumber(1, numRows - 2);
      const startCol = getRandomNumber(1, numCols - 2);
      const exitRow = getRandomNumber(1, numRows - 2);
      const exitCol = getRandomNumber(1, numCols - 2);
      grid[startRow][startCol] = 5; // Jogador
      grid[exitRow][exitCol] = 9; // Saída

renderGrid();
    }

// Criação da grade inicial
    function createGrid() {
      const grid = [];
      for (let row = 0; row < numRows; row++) {
        grid.push(Array(numCols).fill(0)); // Célula vazia
      }
      return grid;
    }

// Renderizar a grade na página
    function renderGrid() {
      const table = document.getElementById('grid');
      table.innerHTML = '';

grid.forEach((row, rowIndex) => {
        const tr = document.createElement('tr');

row.forEach((cell, colIndex) => {
          const td = document.createElement('td');
          td.classList.add(`cell-${cell}`);
          td.onclick = () => onCellClick(rowIndex, colIndex);
          tr.appendChild(td);
        });

table.appendChild(tr);
      });
    }

// Manipulador de clique na célula
    function onCellClick(row, col) {
      if (grid[row][col] === 1 || grid[row][col] === 9) {
        return; // Ignorar paredes e saída
      }

const playerRow = getPlayerPosition().row;
      const playerCol = getPlayerPosition().col;

if ((row === playerRow + 1 && col === playerCol) ||
        (row === playerRow - 1 && col === playerCol) ||
        (row === playerRow && col === playerCol + 1) ||
        (row === playerRow && col === playerCol - 1)) {
        movePlayer(row, col);
      }
    }

// Obtém a posição atual do jogador
    function getPlayerPosition() {
      for (let row = 0; row < numRows; row++) {
        for (let col = 0; col < numCols; col++) {
          if (grid[row][col] === 5) {
            return { row, col };
          }
        }
      }
    }

// Move o jogador para a nova posição
    function movePlayer(row, col) {
      const playerPosition = getPlayerPosition();
      grid[playerPosition.row][playerPosition.col] = 0; // Remove a posição anterior do jogador
      grid[row][col] = 5; // Define a nova posição do jogador
      renderGrid();

if (grid[row][col] === 9) {
        generateMaze();
      }
    }

// Gera um número aleatório dentro de um intervalo
    function getRandomNumber(min, max) {
      return Math.floor(Math.random() * (max - min + 1)) + min;
    }

// Inicia o jogo gerando o primeiro labirinto
    generateMaze();
  </script>
</body>
</html>
```