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

No:37260

Make a Game like Freefire
Developer User17049｜Date and time 24/1/20 23:53:08
Build time 21.91 sec｜Game capacity 5.906KB｜

Script

Sure! Here's an example of a simple game similar to Freefire, implemented as a single HTML file using JavaScript. Please keep in mind that this is a basic implementation and not a full-fledged game. You can further improve and enhance it as per your requirements.

Freefire-like Game

Score: 0

Game Over

Please note that this is a stripped-down version for demonstration purposes only. You can enhance and modify this code to add more features, levels, sound effects, etc., to create a fully functional Freefire-like game.

←

Prev　Next

→ 　

Back　

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

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

```html
<!DOCTYPE html>
<html>
<head>
  <title>Freefire-like Game</title>
  <style>
    body {
      display: flex;
      justify-content: center;
      align-items: center;
      height: 100vh;
      background-color: #222;
      font-family: Arial, sans-serif;
    }

#game-container {
      width: 400px;
      height: 400px;
      border: 2px solid #fff;
      display: flex;
      justify-content: center;
      align-items: center;
      position: relative;
    }

#player {
      position: absolute;
      width: 50px;
      height: 50px;
      background-color: #f00;
    }

.enemy {
      position: absolute;
      width: 30px;
      height: 30px;
      background-color: #ff0;
      display: none;
    }

#score {
      color: #fff;
      font-size: 20px;
      margin-bottom: 10px;
    }

#game-over {
      color: #fff;
      font-size: 30px;
      display: none;
    }
  </style>
</head>
<body>
  <h1>Freefire-like Game</h1>
  <div id="game-container">
    <div id="player"></div>
    <div id="score">Score: 0</div>
    <div id="game-over">Game Over</div>
  </div>

// Variables
    let playerX = (GAME_WIDTH - PLAYER_WIDTH) / 2;
    let playerY = (GAME_HEIGHT - PLAYER_HEIGHT) / 2;
    let score = 0;
    let gameInterval;
    let enemies = [];

// Get DOM elements
    const gameContainer = document.getElementById('game-container');
    const player = document.getElementById('player');
    const scoreElement = document.getElementById('score');
    const gameOverElement = document.getElementById('game-over');

// Move player with touch/mouse movement
    gameContainer.addEventListener('mousemove', (event) => {
      const x = event.clientX - gameContainer.offsetLeft;
      const y = event.clientY - gameContainer.offsetTop;
      player.style.transform = `translate(${x - PLAYER_WIDTH / 2}px, ${y - PLAYER_HEIGHT / 2}px)`;
      playerX = x - PLAYER_WIDTH / 2;
      playerY = y - PLAYER_HEIGHT / 2;
    });

// Game loop
    function gameLoop() {
      update();
      draw();
      if (isGameOver()) {
        stopGame();
        showGameOver();
      }
    }

// Update logic
    function update() {
      moveEnemies();
      checkCollision();
    }

// Draw logic
    function draw() {
      updateEnemiesDisplay();
      scoreElement.innerText = `Score: ${score}`;
    }

// Generate random position for an enemy
    function generateRandomPosition() {
      const x = Math.floor(Math.random() * (GAME_WIDTH - ENEMY_WIDTH));
      const y = Math.floor(Math.random() * (GAME_HEIGHT - ENEMY_HEIGHT));
      return { x, y };
    }

// Create a new enemy
    function createEnemy() {
      const position = generateRandomPosition();
      const enemy = document.createElement('div');
      enemy.className = 'enemy';
      enemy.style.left = `${position.x}px`;
      enemy.style.top = `${position.y}px`;
      gameContainer.appendChild(enemy);
      enemies.push({
        element: enemy,
        x: position.x,
        y: position.y,
      });
    }

// Move enemies towards the player
    function moveEnemies() {
      for (let i = 0; i < enemies.length; i++) {
        const enemy = enemies[i];
        const dx = playerX + PLAYER_WIDTH / 2 - (enemy.x + ENEMY_WIDTH / 2);
        const dy = playerY + PLAYER_HEIGHT / 2 - (enemy.y + ENEMY_HEIGHT / 2);
        const distance = Math.sqrt(dx * dx + dy * dy);
        const vx = (ENEMY_SPEED * dx) / distance;
        const vy = (ENEMY_SPEED * dy) / distance;
        enemy.x += vx;
        enemy.y += vy;
        enemy.element.style.transform = `translate(${enemy.x}px, ${enemy.y}px)`;
      }
    }

// Check collision between enemies and player
    function checkCollision() {
      for (let i = 0; i < enemies.length; i++) {
        const enemy = enemies[i];
        if (
          enemy.x < playerX + PLAYER_WIDTH &&
          enemy.x + ENEMY_WIDTH > playerX &&
          enemy.y < playerY + PLAYER_HEIGHT &&
          enemy.y + ENEMY_HEIGHT > playerY
        ) {
          gameOver();
          return;
        }
      }
    }

// Update the display of enemies
    function updateEnemiesDisplay() {
      for (let i = 0; i < enemies.length; i++) {
        const enemy = enemies[i];
        enemy.element.style.display = 'block';
      }
    }

// Start the game
    function startGame() {
      gameInterval = setInterval(gameLoop, 16);
      createEnemy();
    }

// Stop the game
    function stopGame() {
      clearInterval(gameInterval);
    }

// Show game over message
    function showGameOver() {
      gameOverElement.style.display = 'block';
    }

// Check if the game is over
    function isGameOver() {
      return enemies.some((enemy) => {
        if (
          enemy.x < playerX + PLAYER_WIDTH &&
          enemy.x + ENEMY_WIDTH > playerX &&
          enemy.y < playerY + PLAYER_HEIGHT &&
          enemy.y + ENEMY_HEIGHT > playerY
        ) {
          return true;
        }
        return false;
      });
    }

// Game over logic
    function gameOver() {
      stopGame();
      showGameOver();
    }

// Start the game
    startGame();
  </script>
</body>
</html>
```