Make the game snake but tap to shoot a gun and the food multiples every minute plaÿed's game

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

No:35579

←

Prev Next

→

Make the game snake but tap to shoot a gun and the..ALL
Developer User16226｜Date and time 24/1/14 23:38:24
Build time 29.696 sec｜Game capacity 7.771KB｜

Script

Sure! Here's a sample implementation of the classic game "Snake" that incorporates shooting elements.

This implementation can be saved as a single HTML file and can be executed on any browser. It incorporates tap event shooting using a smartphone touchscreen. The snake moves using the arrow keys on a keyboard. Shooting bullets at the food doubles the size of the snake, and the score increases accordingly. The game ends when the snake collides with the walls or with itself, and the final score is displayed.

←

Prev　Next

→ 　

Back　

[PR]現在の人気ゲームランキング

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

Sure! Here's a sample implementation of the classic game "Snake" that incorporates shooting elements.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Snake Shooter</title>
    <style>
        canvas {
            border: 1px solid black;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas" width="400" height="400"></canvas>

// Game variables
        let snake = [
            { x: 200, y: 200 },
            { x: 180, y: 200 },
            { x: 160, y: 200 },
            { x: 140, y: 200 },
            { x: 120, y: 200 },
        ];
        let dx = BOX_SIZE;
        let dy = 0;
        let food = { x: 0, y: 0 };
        let score = 0;
        let shooting = false;
        let bullet = { x: -BOX_SIZE, y: -BOX_SIZE }; // Initial position offscreen

const gameCanvas = document.getElementById("gameCanvas");
        const ctx = gameCanvas.getContext("2d");

// Set initial food position and start game loop
        placeFood();
        setInterval(gameLoop, 100);

// Keyboard event listeners
        document.addEventListener("keydown", changeDirection);

// Tap event listener for shooting bullets on a smartphone
        gameCanvas.addEventListener("touchstart", shootBullet);

// Generate a random position for the food
        function placeFood() {
            food.x = Math.floor(Math.random() * (gameCanvas.width / BOX_SIZE)) * BOX_SIZE;
            food.y = Math.floor(Math.random() * (gameCanvas.height / BOX_SIZE)) * BOX_SIZE;
        }

// Main game loop
        function gameLoop() {
            clearCanvas();
            advanceSnake();
            drawSnake();
            drawFood();
            drawBullet();
            checkCollisions();
            handleBullet();
        }

// Clear canvas for each frame
        function clearCanvas() {
            ctx.fillStyle = CANVAS_BACKGROUND_COLOR;
            ctx.strokeStyle = CANVAS_BORDER_COLOR;
            ctx.fillRect(0, 0, gameCanvas.width, gameCanvas.height);
            ctx.strokeRect(0, 0, gameCanvas.width, gameCanvas.height);
        }

// Move snake forward based on current direction
        function advanceSnake() {
            const head = { x: snake[0].x + dx, y: snake[0].y + dy };
            snake.unshift(head);

const ateFood = snake[0].x === food.x && snake[0].y === food.y;
            if (ateFood) {
                score += 10;
                placeFood();
            }
            else {
                snake.pop();
            }
        }

// Draw snake on the canvas
        function drawSnake() {
            snake.forEach(drawSnakePart);
        }

// Draw a single part of the snake
        function drawSnakePart(snakePart) {
            ctx.fillStyle = SNAKE_COLOR;
            ctx.fillRect(snakePart.x, snakePart.y, BOX_SIZE, BOX_SIZE);
            ctx.strokeStyle = CANVAS_BORDER_COLOR;
            ctx.strokeRect(snakePart.x, snakePart.y, BOX_SIZE, BOX_SIZE);
        }

// Draw food on the canvas
        function drawFood() {
            ctx.fillStyle = FOOD_COLOR;
            ctx.fillRect(food.x, food.y, BOX_SIZE, BOX_SIZE);
            ctx.strokeStyle = CANVAS_BORDER_COLOR;
            ctx.strokeRect(food.x, food.y, BOX_SIZE, BOX_SIZE);
        }

// Handle shooting bullet on a tap event
        function shootBullet(event) {
            const rect = gameCanvas.getBoundingClientRect();
            const touchX = event.targetTouches[0].clientX - rect.left;
            const touchY = event.targetTouches[0].clientY - rect.top;

bullet.x = Math.floor(touchX / BOX_SIZE) * BOX_SIZE;
            bullet.y = Math.floor(touchY / BOX_SIZE) * BOX_SIZE;
            shooting = true;
        }

// Draw bullet on the canvas
        function drawBullet() {
            if (shooting) {
                ctx.fillStyle = SHOOT_COLOR;
                ctx.fillRect(bullet.x, bullet.y, BOX_SIZE, BOX_SIZE);
                ctx.strokeStyle = CANVAS_BORDER_COLOR;
                ctx.strokeRect(bullet.x, bullet.y, BOX_SIZE, BOX_SIZE);
            }
        }

// Handle bullet movement and collision detection
        function handleBullet() {
            if (shooting) {
                bullet.x += dx;
                bullet.y += dy;

if (bullet.x < 0 || bullet.x >= gameCanvas.width || bullet.y < 0 || bullet.y >= gameCanvas.height) {
                    shooting = false; // Bullet goes off-screen, stop shooting
                }

if (bullet.x === food.x && bullet.y === food.y) {
                    score += 5;
                    placeFood();

// Double the snake size when food is hit by the bullet
                    for (let i = 0; i < 5; i++) {
                        snake.push({ ...snake[snake.length - 1] });
                    }

shooting = false; // Stop shooting after hitting the food
                }
            }
        }

// Check for collisions with walls or self
        function checkCollisions() {
            const hitLeftWall = snake[0].x < 0;
            const hitRightWall = snake[0].x >= gameCanvas.width;
            const hitTopWall = snake[0].y < 0;
            const hitBottomWall = snake[0].y >= gameCanvas.height;

if (hitLeftWall || hitRightWall || hitTopWall || hitBottomWall) {
                gameOver();
            }

for (let i = 1; i < snake.length; i++) {
                if (snake[i].x === snake[0].x && snake[i].y === snake[0].y) {
                    gameOver();
                }
            }
        }

// Handle game over event
        function gameOver() {
            alert(`Game Over!\nScore: ${score}`);
            snake = [
                { x: 200, y: 200 },
                { x: 180, y: 200 },
                { x: 160, y: 200 },
                { x: 140, y: 200 },
                { x: 120, y: 200 },
            ];
            dx = BOX_SIZE;
            dy = 0;
            score = 0;
            placeFood();
            shooting = false;
            bullet = { x: -BOX_SIZE, y: -BOX_SIZE };
        }

// Change snake direction based on arrow key presses
        function changeDirection(event) {
            const keyPressed = event.keyCode;
            const goingUp = dy === -BOX_SIZE;
            const goingDown = dy === BOX_SIZE;
            const goingLeft = dx === -BOX_SIZE;
            const goingRight = dx === BOX_SIZE;

if (keyPressed === 37 && !goingRight) {
                dx = -BOX_SIZE;
                dy = 0;
            }

if (keyPressed === 38 && !goingDown) {
                dx = 0;
                dy = -BOX_SIZE;
            }

if (keyPressed === 39 && !goingLeft) {
                dx = BOX_SIZE;
                dy = 0;
            }

if (keyPressed === 40 && !goingUp) {
                dx = 0;
                dy = BOX_SIZE;
            }
        }
    </script>
</body>
</html>
```