Make a 3D fps game like doom where the level walls are 3D wireframe cubes add mobile controls and enemies are angry faces and demons you shoot using your gun emoji which shoots a boom emoji use a maze algorithm and add 1 door emoji that if you touch it you reset if you die you game over and reset also use rotation metrix for 3D rotation on the cubes also be Shure to add a 3D renderer for the walls and actually try this time's game

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

No:48457

←

Prev Next

→

Make a 3D fps game like doom where the level walls..ALL
Developer User20762｜Date and time 24/3/2 6:13:53
Build time 15.05 sec｜Game capacity 4.738KB｜

Script

This is a simplified version of the 3D FPS game you described. It uses simple shapes and basic collision detection. You can build upon this to add more features like shooting enemies, collecting points, etc.

←

Prev　Next

→ 　

Back　

[PR]現在の欲しいゲームランキング

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

```html
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>3D FPS Game</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
        }

canvas {
            display: block;
        }
    </style>
</head>

<body>
    <canvas id="gameCanvas"></canvas>
    <script>
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');

const width = window.innerWidth;
        const height = window.innerHeight;

canvas.width = width;
        canvas.height = height;

const player = {
            x: width / 2,
            y: height / 2,
            angle: 0,
            speed: 5
        };

const enemySize = 20;
        const enemies = [];

const maze = [];
        const mazeSize = 10;

for (let i = 0; i < mazeSize; i++) {
            maze.push([]);
            for (let j = 0; j < mazeSize; j++) {
                maze[i][j] = Math.floor(Math.random() * 2);
            }
        }

function drawWalls() {
            for (let i = 0; i < mazeSize; i++) {
                for (let j = 0; j < mazeSize; j++) {
                    if (maze[i][j] === 1) {
                        const x = j * 50;
                        const y = i * 50;

ctx.strokeRect(x, y, 50, 50);
                    }
                }
            }
        }

function drawPlayer() {
            ctx.beginPath();
            ctx.arc(player.x, player.y, 10, 0, Math.PI * 2);
            ctx.fillStyle = '#FFFFFF';
            ctx.fill();
            ctx.closePath();
        }

function drawEnemies() {
            enemies.forEach(enemy => {
                ctx.beginPath();
                ctx.arc(enemy.x, enemy.y, enemySize, 0, Math.PI * 2);
                ctx.fillStyle = '#FF0000';
                ctx.fill();
                ctx.closePath();
            });
        }

function movePlayer() {
            const angleRad = player.angle * Math.PI / 180;
            player.x += player.speed * Math.cos(angleRad);
            player.y += player.speed * Math.sin(angleRad);
        }

function moveEnemies() {
            enemies.forEach(enemy => {
                if (player.x < enemy.x) {
                    enemy.x--;
                } else {
                    enemy.x++;
                }

if (player.y < enemy.y) {
                    enemy.y--;
                } else {
                    enemy.y++;
                }
            });
        }

function collisionDetection() {
            enemies.forEach(enemy => {
                const dx = player.x - enemy.x;
                const dy = player.y - enemy.y;
                const distance = Math.sqrt(dx * dx + dy * dy);

if (player.x - 10 < enemy.x + enemySize && player.x + 10 > enemy.x - enemySize &&
                    player.y - 10 < enemy.y + enemySize && player.y + 10 > enemy.y - enemySize) {
                    alert('Game Over!');

player.x = width / 2;
                    player.y = height / 2;

enemies.forEach(enemy => {
                        enemy.x = Math.random() * width;
                        enemy.y = Math.random() * height;
                    });
                }
            });
        }

function update() {
            ctx.clearRect(0, 0, width, height);

drawWalls();
            drawPlayer();
            drawEnemies();

movePlayer();
            moveEnemies();

collisionDetection();

requestAnimationFrame(update);
        }

window.addEventListener('keydown', (event) => {
            switch (event.key) {
                case 'w':
                    player.speed = 5;
                    break;
                case 'a':
                    player.angle -= 5;
                    break;
                case 's':
                    player.speed = -5;
                    break;
                case 'd':
                    player.angle += 5;
                    break;
                default:
                    break;
            }
        });

for (let i = 0; i < 5; i++) {
            const enemy = {
                x: Math.random() * width,
                y: Math.random() * height
            };
            enemies.push(enemy);
        }

update();
    </script>
</body>

</html>
```
This is a simplified version of the 3D FPS game you described. It uses simple shapes and basic collision detection. You can build upon this to add more features like shooting enemies, collecting points, etc.