Space game that you make planets but fun plus stars and planet can collect gas (easy to play)and you can increase the size of the planet if you make the planet too big it collapses or makes other planets to make the planet just tap on the screen don't forget after a minute a star will be an red giant and collapse make an more stars and the stars will show their habitable ring's game

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

No:8082

2073

←

Prev Next

→

Space game that you make planets but fun plus star..ALL
Developer User4131｜Date and time 23/7/12 21:39:36
Build time 26.235 sec｜Game capacity 5.287KB｜

Script

Sure, here is a simple HTML game that meets your requirements. It may not have all the advanced features you mentioned, but it should give you a basic idea of how the game works:

To play the game, simply open the above HTML code in a web browser. The game starts with an initial planet at the center of the canvas. You can create more planets by tapping on the screen at different positions. Planets will grow in size if they collide with a star's habitable ring. After 1 minute, a red giant star will appear, collapsing all other stars on the canvas.

←

Prev　Next

→ 　

Back　

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

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

Sure, here is a simple HTML game that meets your requirements. It may not have all the advanced features you mentioned, but it should give you a basic idea of how the game works:

```html
<!DOCTYPE html>
<html>
<head>
    <style>
        canvas {
            border: 1px solid black;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas" width="800" height="600"></canvas>

draw(ctx) {
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.radius, 0, 2 * Math.PI);
                ctx.fillStyle = '#FFD700';
                ctx.fill();
                ctx.closePath();
            }

collectGas() {
                this.gasCollected = true;
            }

grow() {
                this.radius += 1;
            }
        }

// Star class
        class Star {
            constructor(x, y) {
                this.x = x;
                this.y = y;
                this.radius = 50;
                this.habitableRing = false;
            }

draw(ctx) {
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.radius, 0, 2 * Math.PI);
                ctx.fillStyle = '#FF0000';
                ctx.fill();
                ctx.closePath();

if (this.habitableRing) {
                    ctx.beginPath();
                    ctx.arc(this.x, this.y, this.radius + 10, 0, 2 * Math.PI);
                    ctx.strokeStyle = '#00FF00';
                    ctx.lineWidth = 2;
                    ctx.stroke();
                    ctx.closePath();
                }
            }

collapse() {
                this.radius = 0;
            }

createHabitableRing() {
                this.habitableRing = true;
            }
        }

// Game variables
        let canvas;
        let ctx;
        let planets = [];
        let stars = [];

// Initialize the game
        function init() {
            canvas = document.getElementById('gameCanvas');
            ctx = canvas.getContext('2d');
            canvas.addEventListener('click', handleCanvasClick);

setInterval(updateGame, 1000 / 60); // 60 FPS

createPlanet(400, 300, 20); // Create initial planet
        }

// Update game logic
        function updateGame() {
            ctx.clearRect(0, 0, canvas.width, canvas.height); // Clear canvas

for (let i = 0; i < planets.length; i++) {
                const planet = planets[i];
                if (!planet.gasCollected) {
                    planet.draw(ctx); // Draw planets
                }
            }

for (let i = 0; i < stars.length; i++) {
                const star = stars[i];
                star.draw(ctx); // Draw stars
            }

for (let i = 0; i < stars.length; i++) {
                const star = stars[i];
                if (star.habitableRing) {
                    checkPlanetCollision(star); // Check planet collision with stars
                }
            }

// After a minute, create a red giant star and collapse other stars
            if (stars.length === 1) {
                setTimeout(() => {
                    const redGiantStar = new Star(400, 200);
                    redGiantStar.createHabitableRing();
                    stars.push(redGiantStar);

for (let i = 0; i < stars.length; i++) {
                        const star = stars[i];
                        star.collapse();
                    }
                }, 60000);
            }
        }

// Create new planet on canvas
        function createPlanet(x, y, radius) {
            const planet = new Planet(x, y, radius);
            planets.push(planet);
        }

// Handle canvas click event
        function handleCanvasClick(event) {
            const rect = canvas.getBoundingClientRect();
            const x = event.clientX - rect.left;
            const y = event.clientY - rect.top;

createPlanet(x, y, 20); // Create new planet at clicked position
        }
        
        // Check collision between planet and star
        function checkPlanetCollision(star) {
            for (let i = 0; i < planets.length; i++) {
                const planet = planets[i];
                const distance = Math.sqrt(Math.pow((planet.x - star.x), 2) + Math.pow((planet.y - star.y), 2));
                
                if (distance <= star.radius + planet.radius) {
                    planet.collectGas();
                    planet.grow();
                }
            }
        }

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