A horror game where the player must run from enemies, and the most the player can do is throw bricks at enemies to temporarily stun them.'s game

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

No:17327

←

Prev Next

→

A horror game where the player must run from enemi..ALL
Developer User7645｜Date and time 23/9/23 5:15:23
Build time 43.243 sec｜Game capacity 5.225KB｜

Script

Sure! Here's an example of a horror game implemented as a single HTML file using JavaScript. The game is designed for smartphone operation and includes pictograms. The goal is for the player to run from enemies and stun them temporarily by throwing bricks.

Please note that this is a simplified example to demonstrate the basic mechanics of the game. To make it more engaging, you can add additional features like scoring, levels, sound effects, and game over screens.

←

Prev　Next

→ 　

Back　

[PR]現在の人気グッズランキング

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

```html
<!DOCTYPE html>
<html>
<head>
    <title>Horror Game</title>
    <style>
        body {
            margin: 0;
            padding: 0;
        }
        canvas {
            background-color: #000;
            display: block;
            margin: 0 auto;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas"></canvas>

// Create player object
        const player = {
            x: playerX,
            y: playerY,
            width: playerSize,
            height: playerSize
        };

// Event listeners for touch controls
        canvas.addEventListener('touchstart', handleTouchStart, false);
        canvas.addEventListener('touchend', handleTouchEnd, false);

function handleTouchStart() {
            isThrowing = true;
        }

function handleTouchEnd() {
            isThrowing = false;
        }

// Generate random enemies
        function generateEnemies() {
            const enemyX = Math.random() * screenWidth;
            const enemyY = Math.random() * screenHeight;
            const dx = enemyX - playerX;
            const dy = enemyY - playerY;
            const distance = Math.sqrt(dx * dx + dy * dy);
            if (distance > playerSize + enemySize) {
                enemies.push({ x: enemyX, y: enemyY });
            }
        }

// Update game state
        function update() {
            ctx.clearRect(0, 0, screenWidth, screenHeight);
            ctx.fillStyle = '#FFF';

// Move and draw enemies
            for (let i = 0; i < enemies.length; i++) {
                const enemy = enemies[i];
                const dx = enemy.x - playerX;
                const dy = enemy.y - playerY;
                const distance = Math.sqrt(dx * dx + dy * dy);
                const speed = enemySpeed / distance;
                enemy.x -= dx * speed;
                enemy.y -= dy * speed;

ctx.fillRect(enemy.x - enemySize / 2, enemy.y - enemySize / 2, enemySize, enemySize);
            }

// Move and draw player
            ctx.fillRect(playerX - playerSize / 2, playerY - playerSize / 2, playerSize, playerSize);

// Move and draw bricks
            for (let i = 0; i < bricks.length; i++) {
                const brick = bricks[i];
                brick.duration -= 16;
                if (brick.duration > 0) {
                    ctx.fillRect(brick.x - brickSize / 2, brick.y - brickSize / 2, brickSize, brickSize);
                } else {
                    bricks.splice(i, 1);
                }
            }

// Handle collision between player and enemies
            for (let i = 0; i < enemies.length; i++) {
                const enemy = enemies[i];
                const dx = enemy.x - playerX;
                const dy = enemy.y - playerY;
                const distance = Math.sqrt(dx * dx + dy * dy);
                if (distance < playerSize + enemySize) {
                    gameOver();
                    break;
                }
            }

if (isThrowing && bricks.length === 0) {
                // Throw brick
                const brick = {
                    x: playerX,
                    y: playerY,
                    duration: brickDuration
                };
                bricks.push(brick);
                isThrowing = false;
            }

// Generate new enemies randomly
            if (Math.random() < 0.02) {
                generateEnemies();
            }

// Move player based on touch controls
            window.addEventListener('touchmove', function (e) {
                const touch = e.touches[0];
                const touchX = touch.clientX;
                const touchY = touch.clientY;
                playerX = touchX;
                playerY = touchY;
            });

requestAnimationFrame(update);
        }

// Game over function
        function gameOver() {
            // Handle game over logic (e.g., show a message or redirect to another page)
            console.log('Game Over');
        }

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