A game where you have a gun and walk around and shoot zombies for coins.'s game

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

No:35074

←

Prev Next

→

A game where you have a gun and walk around and sh..ALL
Developer User16428｜Date and time 24/1/13 8:05:55
Build time 17.667 sec｜Game capacity 6.005KB｜

Script

Sure, here's an example of a simple game where you can play as a character with a gun, walking around and shooting zombies to collect coins. The game is implemented as a single HTML file, enclosed in script tags, and uses JavaScript for the logic. It assumes smartphone operation and uses pictograms for visuals.

To play the game: 1. Save the above code into a file with an `.html` extension (e.g., `zombie_shooter.html`). 2. Open the file in a web browser, preferably on a smartphone. 3. Use touch gestures to move the player character around and shoot the zombies. 4. Collect coins by colliding with them. 5. Survive as long as possible and try to collect as many coins as you can. Please note that this is a basic implementation for demonstration purposes. You can modify and enhance it based on your specific requirements and preferences.

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋ゲームランキング

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

```html
<!DOCTYPE html>
<html>
<head>
    <title>Zombie Shooter</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
        }

canvas {
            border: 1px solid #000;
            display: block;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas"></canvas>

// Player properties
        const player = {
            x: width / 2,
            y: height / 2,
            radius: 20,
            angle: 0
        };

// Zombie properties
        let zombies = [];
        const zombieRadius = 15;

// Coin properties
        let coins = [];
        const coinRadius = 10;

// Collectible coins
        let totalCoins = 0;

// Game loop
        function gameLoop() {
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }

function update() {
            // Detecting player movement using touch events
            canvas.addEventListener('touchstart', handleTouchStart);
            canvas.addEventListener('touchmove', handleTouchMove);

// Creating new zombies randomly
            if (Math.random() < 0.01) {
                const zombieX = Math.random() < 0.5 ? Math.random() * width : 0;
                const zombieY = Math.random() < 0.5 ? Math.random() * height : 0;
                const zombie = { x: zombieX, y: zombieY };
                zombies.push(zombie);
            }

// Moving zombies towards the player
            zombies.forEach(zombie => {
                const angle = Math.atan2(player.y - zombie.y, player.x - zombie.x);
                zombie.x += Math.cos(angle);
                zombie.y += Math.sin(angle);
            });

// Checking collision of player with zombies
            zombies.forEach((zombie, index) => {
                const dx = player.x - zombie.x;
                const dy = player.y - zombie.y;
                const distance = Math.sqrt(dx * dx + dy * dy);
                if (distance < player.radius + zombieRadius) {
                    zombies.splice(index, 1);
                    totalCoins -= 10;
                }
            });

// Checking collision of player with coins
            coins.forEach((coin, index) => {
                const dx = player.x - coin.x;
                const dy = player.y - coin.y;
                const distance = Math.sqrt(dx * dx + dy * dy);
                if (distance < player.radius + coinRadius) {
                    coins.splice(index, 1);
                    totalCoins++;
                }
            });
        }

function draw() {
            // Clearing canvas
            context.clearRect(0, 0, width, height);

// Drawing player
            context.beginPath();
            context.arc(player.x, player.y, player.radius, 0, Math.PI * 2);
            context.fillStyle = 'blue';
            context.fill();

// Drawing zombies
            zombies.forEach(zombie => {
                context.beginPath();
                context.arc(zombie.x, zombie.y, zombieRadius, 0, Math.PI * 2);
                context.fillStyle = 'red';
                context.fill();
            });

// Drawing coins
            coins.forEach(coin => {
                context.beginPath();
                context.arc(coin.x, coin.y, coinRadius, 0, Math.PI * 2);
                context.fillStyle = 'yellow';
                context.fill();
            });

// Displaying collected coins count
            context.font = '20px Arial';
            context.fillStyle = 'white';
            context.fillText('Coins: ' + totalCoins, 10, 30);
        }

// Handling player movement using touch events
        let touchStartX = 0;
        let touchStartY = 0;

function handleTouchStart(event) {
            touchStartX = event.touches[0].clientX;
            touchStartY = event.touches[0].clientY;
        }

function handleTouchMove(event) {
            const touchX = event.touches[0].clientX;
            const touchY = event.touches[0].clientY;

const dx = touchX - touchStartX;
            const dy = touchY - touchStartY;

player.x += dx;
            player.y += dy;

touchStartX = touchX;
            touchStartY = touchY;
        }

// Spawning coins randomly
        setInterval(() => {
            const coinX = Math.random() * width;
            const coinY = Math.random() * height;
            const coin = { x: coinX, y: coinY };
            coins.push(coin);
        }, 2000);

// Starting the game loop
        gameLoop();
    </script>
</body>
</html>
```

Please note that this is a basic implementation for demonstration purposes. You can modify and enhance it based on your specific requirements and preferences.