AI game creator

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

No:13261

105

←

Prev Next

→

particle
Developer User5831｜Date and time 23/8/27 16:36:45
Build time 23.16 sec｜Game capacity 4.683KB｜

Script

Sure! I can help you create a simple game using JavaScript and pictograms. Below is an example of a game where you have to avoid colliding with particles on your smartphone.

In this game, the objective is to avoid colliding with the red particles falling from the top of the screen. You control the blue square (player) using the left and right arrow keys to move it horizontally. If a particle collides with the player, the game ends, and an alert is displayed. The game canvas is automatically sized to fit the smartphone screen.

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋グッズランキング

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

Sure! I can help you create a simple game using JavaScript and pictograms. Below is an example of a game where you have to avoid colliding with particles on your smartphone.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Particle Game</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            overflow: hidden;
        }

canvas {
            background-color: #222;
            display: block;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas"></canvas>

// Particle class
        class Particle {
            constructor(x, y, speed) {
                this.x = x;
                this.y = y;
                this.speed = speed;
            }

update() {
                this.y += this.speed;
                if (this.y > GAME_HEIGHT + PARTICLE_SIZE) {
                    this.reset();
                }
            }

reset() {
                this.y = -PARTICLE_SIZE;
                this.x = Math.random() * (GAME_WIDTH - PARTICLE_SIZE);
            }

draw(ctx) {
                ctx.fillStyle = 'red';
                ctx.fillRect(this.x, this.y, PARTICLE_SIZE, PARTICLE_SIZE);
            }
        }

// Player class
        class Player {
            constructor(x, y) {
                this.x = x;
                this.y = y;
            }

moveLeft() {
                this.x -= PLAYER_SPEED;
                if (this.x < 0) {
                    this.x = 0;
                }
            }

moveRight() {
                this.x += PLAYER_SPEED;
                if (this.x > GAME_WIDTH - PLAYER_SIZE) {
                    this.x = GAME_WIDTH - PLAYER_SIZE;
                }
            }

draw(ctx) {
                ctx.fillStyle = 'blue';
                ctx.fillRect(this.x, this.y, PLAYER_SIZE, PLAYER_SIZE);
            }
        }

// Game variables
        let canvas, ctx, player, particles, gameOver;

function init() {
            canvas = document.getElementById('gameCanvas');
            ctx = canvas.getContext('2d');
            canvas.width = GAME_WIDTH;
            canvas.height = GAME_HEIGHT;

player = new Player((GAME_WIDTH - PLAYER_SIZE) / 2, GAME_HEIGHT - PLAYER_SIZE);
            particles = [];
            gameOver = false;

setInterval(spawnParticle, PARTICLE_FREQ);
            document.addEventListener('keydown', handleKeydown);
        }

function spawnParticle() {
            const particle = new Particle(Math.random() * (GAME_WIDTH - PARTICLE_SIZE), -PARTICLE_SIZE, PARTICLE_SPEED);
            particles.push(particle);
        }

function handleKeydown(event) {
            if (event.key === 'ArrowLeft') {
                player.moveLeft();
            } else if (event.key === 'ArrowRight') {
                player.moveRight();
            }
        }

function update() {
            if (!gameOver) {
                particles.forEach(particle => {
                    particle.update();

if (isCollision(particle, player)) {
                        gameOver = true;
                        alert('Game Over!');
                    }
                });
            }
        }

function isCollision(particle, player) {
            return (
                particle.x < player.x + PLAYER_SIZE &&
                particle.x + PARTICLE_SIZE > player.x &&
                particle.y < player.y + PLAYER_SIZE &&
                particle.y + PARTICLE_SIZE > player.y
            );
        }

function draw() {
            ctx.clearRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
            player.draw(ctx);
            particles.forEach(particle => particle.draw(ctx));
        }

function animate() {
            update();
            draw();
            requestAnimationFrame(animate);
        }

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