simulation mit zwei Planeten. Gib den Planeten zu Beginn der Simulation eine Geschwindigkeit in eine zufällige Richtung. Die Planeten können miteinander und mit dem Bildschirmrand kollidieren. Sie ziehen sich gegenseitig immer mit einer realistischen schwerkraft an. Jedes mal wenn auf den Bildschirm geklickt wird entsteht an dieser Stelle ein weiterer Planet. Gib keine Erklärungen, nur den Code.'s game

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

No:30735

142

←

Prev Next

→

simulation mit zwei Planeten. Gib den Planeten zu ..ALL
Developer User14077｜Date and time 23/12/24 1:46:43
Build time 23.538 sec｜Game capacity 5.173KB｜

Script

←

Prev　Next

→ 　

Back　

[PR]現在の新着人気ランキング

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

<!DOCTYPE html>
<html>
<head>
    <title>Simple Planet Simulation</title>
    <style>
        canvas {
            border: 1px solid #000;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas" width="800" height="600"></canvas>

// Set the initial variables
        const G = 0.1;  // gravitational constant
        let planets = [];

// Function to generate a random number between min and max
        function getRandom(min, max) {
            return Math.random() * (max - min) + min;
        }

// Function to create a new planet
        function createPlanet(x, y, dx, dy) {
            return {
                x: x,
                y: y,
                dx: dx,
                dy: dy,
                radius: getRandom(10, 20),
                mass: 0,  // mass will be calculated based on radius
                color: '#' + ((1 << 24) * Math.random() | 0).toString(16) // random color
            };
        }

// Function to update the position of each planet
        function updatePositions() {
            for (let i = 0; i < planets.length; i++) {
                const planet = planets[i];

// Update position based on velocity
                planet.x += planet.dx;
                planet.y += planet.dy;

// Check for collisions with the screen edges
                if (planet.x - planet.radius < 0 || planet.x + planet.radius > canvas.width) {
                    planet.dx *= -1;  // reverse direction on collision
                }
                if (planet.y - planet.radius < 0 || planet.y + planet.radius > canvas.height) {
                    planet.dy *= -1;  // reverse direction on collision
                }
            }
        }

// Function to update the velocity of each planet based on gravitational force
        function updateVelocities() {
            for (let i = 0; i < planets.length; i++) {
                const planet1 = planets[i];
                for (let j = i + 1; j < planets.length; j++) {
                    const planet2 = planets[j];

// Calculate distance between two planets
                    const dx = planet2.x - planet1.x;
                    const dy = planet2.y - planet1.y;
                    const distance = Math.sqrt(dx * dx + dy * dy);

// Calculate gravitational force
                    const force = (G * planet1.mass * planet2.mass) / (distance * distance);

// Calculate acceleration based on force
                    const ax = force * (dx / distance);
                    const ay = force * (dy / distance);

// Update velocity based on acceleration
                    planet1.dx += ax / planet1.mass;
                    planet1.dy += ay / planet1.mass;

planet2.dx -= ax / planet2.mass;
                    planet2.dy -= ay / planet2.mass;
                }
            }
        }

// Function to render each planet on the canvas
        function render() {
            // Clear the canvas
            ctx.clearRect(0, 0, canvas.width, canvas.height);

// Render each planet
            for (let i = 0; i < planets.length; i++) {
                const planet = planets[i];

// Draw a circle representing the planet
                ctx.beginPath();
                ctx.arc(planet.x, planet.y, planet.radius, 0, 2 * Math.PI);
                ctx.fillStyle = planet.color;
                ctx.fill();
                ctx.closePath();
            }
        }

// Function to handle the click event on the canvas
        function handleClick(event) {
            const rect = canvas.getBoundingClientRect();
            const x = event.clientX - rect.left;
            const y = event.clientY - rect.top;
            const dx = getRandom(-1, 1);  // random velocity in x direction
            const dy = getRandom(-1, 1);  // random velocity in y direction

// Create a new planet at the clicked position with random velocity
            planets.push(createPlanet(x, y, dx, dy));
        }

// Start the simulation
        function startSimulation() {
            // Generate initial planets with random velocities
            for (let i = 0; i < 2; i++) {
                const x = getRandom(0, canvas.width);
                const y = getRandom(0, canvas.height);
                const dx = getRandom(-1, 1);
                const dy = getRandom(-1, 1);
                planets.push(createPlanet(x, y, dx, dy));
            }

// Bind the click event to the canvas
            canvas.addEventListener("click", handleClick);

// Start the game loop
            setInterval(function() {
                updatePositions();
                updateVelocities();
                render();
            }, 10);  // update every 10 milliseconds
        }

// Call the startSimulation function to begin the game
        startSimulation();
    </script>
</body>
</html>