You are a green cube And you can move around with a joy stick You can chew by tapping the a button When you tap the a button, you see a black box come out, you. They're red cubes that you have to shoot To k○ll them But they can shoot back at you The red cubes only have One bullet to shoot at you But You have infinite Bullets Your goal is the k○ll ten red cubes But if you get shot twice you lose's game

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

No:18632

←

Prev Next

→

You are a green cube And you can move around with ..ALL
Developer User8183｜Date and time 23/9/30 7:58:48
Build time 29.68 sec｜Game capacity 8.543KB｜

Script

To play the game on a smartphone, you can open the HTML file on any web browser on your phone or access it through a web hosting service. Use the virtual joystick by touching and dragging on the joystick area to move the green cube. Tap the "A" button to shoot bullets and eliminate the red cubes. Avoid getting hit by red cube bullets. The goal is to kill ten red cubes before getting shot twice. Good luck!

←

Prev　Next

→ 　

Back　

[PR]現在のフィギュア売れ筋ランキング

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

```html
<!DOCTYPE html>
<html>
<head>
  <title>Green Cube Game</title>
  <style>
    body {
      margin: 0;
      padding: 0;
    }
    
    canvas {
      background-color: #222;
      display: block;
      margin: 0 auto;
    }
  </style>
</head>
<body>
  <canvas id="gameCanvas" width="400" height="400"></canvas>
  
  <script>
    document.addEventListener("DOMContentLoaded", function() {
      const canvas = document.getElementById("gameCanvas");
      const ctx = canvas.getContext("2d");
      
      // Game variables
      const playerSize = 20;
      const playerSpeed = 5;
      const bulletSpeed = 8;
      const enemySpeed = 3;
      const enemyBulletSpeed = 6;
      const bulletSize = 5;
      const enemySize = 25;
      const maxPlayerBullets = 10;
      const maxEnemyBullets = 1;
      const playerShootDelay = 300;
      const enemyShootDelay = 1500;
      const maxPlayerLives = 3;
      const maxEnemies = 10;
      
      let playerX = canvas.width / 2 - playerSize / 2;
      let playerY = canvas.height / 2 - playerSize / 2;
      let playerLives = maxPlayerLives;
      let playerBullets = [];
      let enemyBullets = [];
      let enemies = [];
      let score = 0;
      
      // Joystick variables
      let joystickActive = false;
      let joystickRadius = 60;
      let joystickX = canvas.width / 2;
      let joystickY = canvas.height - joystickRadius - 20;
      
      // Joystick event listeners
      canvas.addEventListener("touchstart", handleTouchStart);
      canvas.addEventListener("touchend", handleTouchEnd);
      canvas.addEventListener("touchmove", handleTouchMove);
      
      function handleTouchStart(event) {
        event.preventDefault();
        const touch = event.touches[0];
        const touchX = touch.pageX - canvas.offsetLeft;
        const touchY = touch.pageY - canvas.offsetTop;
        if (Math.hypot(touchX - joystickX, touchY - joystickY) <= joystickRadius) {
          joystickActive = true;
        }
      }
  
      function handleTouchEnd(event) {
        event.preventDefault();
        if (joystickActive) {
          joystickActive = false;
          resetJoystick();
        }
      }
  
      function handleTouchMove(event) {
        event.preventDefault();
        if (joystickActive) {
          const touch = event.touches[0];
          const touchX = touch.pageX - canvas.offsetLeft;
          const touchY = touch.pageY - canvas.offsetTop;
          calculateJoystickDirection(touchX, touchY);
        }
      }
      
      function calculateJoystickDirection(touchX, touchY) {
        const angle = Math.atan2(touchY - joystickY, touchX - joystickX);
        const distance = Math.hypot(touchX - joystickX, touchY - joystickY);
        if (distance <= joystickRadius) {
          playerX += playerSpeed * Math.cos(angle);
          playerY += playerSpeed * Math.sin(angle);
        } else {
          const ratio = joystickRadius / distance;
          playerX += ratio * playerSpeed * Math.cos(angle);
          playerY += ratio * playerSpeed * Math.sin(angle);
        }
        
        // Keep the player within the canvas
        playerX = Math.min(Math.max(playerX, 0), canvas.width - playerSize);
        playerY = Math.min(Math.max(playerY, 0), canvas.height - playerSize);
      }
      
      function resetJoystick() {
        playerX = canvas.width / 2 - playerSize / 2;
        playerY = canvas.height / 2 - playerSize / 2;
      }
      
      function drawPlayer() {
        ctx.fillStyle = "green";
        ctx.fillRect(playerX, playerY, playerSize, playerSize);
      }
      
      function drawJoystick() {
        ctx.strokeStyle = "white";
        ctx.lineWidth = 2;
        ctx.beginPath();
        ctx.arc(joystickX, joystickY, joystickRadius, 0, Math.PI * 2);
        ctx.stroke();
      }
      
      function drawBullets() {
        ctx.fillStyle = "black";
        for (let i = 0; i < playerBullets.length; i++) {
          ctx.fillRect(playerBullets[i].x, playerBullets[i].y, bulletSize, bulletSize);
        }
        ctx.fillStyle = "red";
        for (let i = 0; i < enemyBullets.length; i++) {
          ctx.fillRect(enemyBullets[i].x, enemyBullets[i].y, bulletSize, bulletSize);
        }
      }
      
      function drawEnemies() {
        ctx.fillStyle = "red";
        for (let i = 0; i < enemies.length; i++) {
          ctx.fillRect(enemies[i].x, enemies[i].y, enemySize, enemySize);
        }
      }
      
      function moveBullets() {
        for (let i = playerBullets.length - 1; i >= 0; i--) {
          playerBullets[i].y -= bulletSpeed;
          if (playerBullets[i].y < 0) {
            playerBullets.splice(i, 1);
          }
        }
        for (let i = enemyBullets.length - 1; i >= 0; i--) {
          enemyBullets[i].y += enemyBulletSpeed;
          if (enemyBullets[i].y > canvas.height) {
            enemyBullets.splice(i, 1);
          }
        }
      }
      
      function moveEnemies() {
        for (let i = 0; i < enemies.length; i++) {
          enemies[i].y += enemySpeed;
          if (enemies[i].y > canvas.height) {
            enemies.splice(i, 1);
          }
        }
      }
      
      function checkCollisions() {
        // Check collision between player bullets and enemies
        for (let i = playerBullets.length - 1; i >= 0; i--) {
          for (let j = enemies.length - 1; j >= 0; j--) {
            if (
              playerBullets[i].x + bulletSize >= enemies[j].x &&
              playerBullets[i].x <= enemies[j].x + enemySize &&
              playerBullets[i].y + bulletSize >= enemies[j].y &&
              playerBullets[i].y <= enemies[j].y + enemySize
            ) {
              playerBullets.splice(i, 1);
              enemies.splice(j, 1);
              score++;
              if (score >= maxEnemies) {
                alert("Congratulations! You won the game!");
                resetGame();
              }
              break;
            }
          }
        }
        
        // Check collision between enemy bullets and player
        for (let i = enemyBullets.length - 1; i >= 0; i--) {
          if (
            enemyBullets[i].x + bulletSize >= playerX && 
            enemyBullets[i].x <= playerX + playerSize &&
            enemyBullets[i].y + bulletSize >= playerY &&
            enemyBullets[i].y <= playerY + playerSize
          ) {
            enemyBullets.splice(i, 1);
            playerLives--;
            if (playerLives <= 0) {
              alert("Game Over! Better luck next time.");
              resetGame();
            }
            break;
          }
        }
      }
      
      function shootPlayerBullet() {
        if (playerBullets.length < maxPlayerBullets) {
          playerBullets.push({
            x: playerX + playerSize / 2 - bulletSize / 2,
            y: playerY
          });
        }
      }
      
      function shootEnemyBullet() {
        if (enemies.length > 0) {
          const enemyIndex = Math.floor(Math.random() * enemies.length);
          enemyBullets.push({
            x: enemies[enemyIndex].x + enemySize / 2 - bulletSize / 2,
            y: enemies[enemyIndex].y + enemySize
          });
        }
      }
      
      function resetGame() {
        playerLives = maxPlayerLives;
        playerBullets = [];
        enemyBullets = [];
        enemies = [];
        score = 0;
        resetJoystick();
      }
      
      function gameLoop() {
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        
        drawPlayer();
        drawJoystick();
        drawBullets();
        drawEnemies();
        
        moveBullets();
        moveEnemies();
        checkCollisions();
        
        if (score < maxEnemies) {
          requestAnimationFrame(gameLoop);
        }
      }
      
      setInterval(shootEnemyBullet, enemyShootDelay);
      setInterval(gameLoop, 10);
      
      document.addEventListener("keydown", function(event) {
        if (event.key === "a" || event.key === "A") {
          shootPlayerBullet();
        }
      });
      
      canvas.addEventListener("click", shootPlayerBullet);  
    });
  </script>
</body>
</html>
```