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 | AI game creator

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

No:30734

173

simulation mit zwei Planeten. Gib den Planeten zu ..ALL
Developer User14077｜Date and time 23/12/24 1:44:37
Build time 28.327 sec｜Game capacity 5.656KB｜

→ 　

0　

0　

[PR]現在の欲しいものランキング

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

(C)2023 HisashiApp

<!DOCTYPE html>
<html>
<head>
    <title>Planets Simulation</title>
</head>
<body>

<script>
    var canvas = document.createElement("canvas");
    document.body.appendChild(canvas);
    var ctx = canvas.getContext("2d");
    
    // Set canvas size to window size
    canvas.width = window.innerWidth;
    canvas.height = window.innerHeight;
    
    // Planet class
    function Planet(x, y, radius, color, mass, dx, dy) {
        this.x = x;
        this.y = y;
        this.radius = radius;
        this.color = color;
        this.mass = mass;
        this.dx = dx;
        this.dy = dy;
    }
    
    // Generate random color
    function getRandomColor() {
        var letters = '0123456789ABCDEF';
        var color = '#';
        for (var i = 0; i < 6; i++) {
            color += letters[Math.floor(Math.random() * 16)];
        }
        return color;
    }
    
    // Generate random direction and speed
    function getRandomDirection() {
        var radian = Math.random() * Math.PI * 2;
        var speed = Math.random() * 5 + 1; // Range: 1-6
        var dx = Math.cos(radian) * speed;
        var dy = Math.sin(radian) * speed;
        return {
            dx: dx,
            dy: dy
        };
    }
    
    // Calculate gravitational force between two planets
    function calculateGravity(planet1, planet2) {
        var distanceX = planet2.x - planet1.x;
        var distanceY = planet2.y - planet1.y;
        var distance = Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));
        var force = (planet1.mass * planet2.mass) / Math.pow(distance, 2);
        return force;
    }
    
    // Update planet's position based on its velocity
    function updatePosition(planet) {
        planet.x += planet.dx;
        planet.y += planet.dy;
    }
    
    // Detect collisions with other planets and screen edge
    function detectCollisions(planet, planets) {
        // Detect collisions with other planets
        for (var i = 0; i < planets.length; i++) {
            if (planet !== planets[i]) {
                var distanceX = planet.x - planets[i].x;
                var distanceY = planet.y - planets[i].y;
                var distance = Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2));
                if (distance <= planet.radius + planets[i].radius) {
                    // Update velocity based on momentum conservation
                    var newDX = ((planet.mass - planets[i].mass) * planet.dx + 2 * planets[i].mass * planets[i].dx) / (planet.mass + planets[i].mass);
                    var newDY = ((planet.mass - planets[i].mass) * planet.dy + 2 * planets[i].mass * planets[i].dy) / (planet.mass + planets[i].mass);
                    planet.dx = newDX;
                    planet.dy = newDY;
                }
            }
        }
        
        // Detect collisions with screen edge
        if (planet.x - planet.radius <= 0 || planet.x + planet.radius >= canvas.width) {
            planet.dx *= -1;
        }
        if (planet.y - planet.radius <= 0 || planet.y + planet.radius >= canvas.height) {
            planet.dy *= -1;
        }
    }
    
    // Render planets on the canvas
    function renderPlanets(planets) {
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        for (var i = 0; i < planets.length; i++) {
            var planet = planets[i];
            ctx.beginPath();
            ctx.arc(planet.x, planet.y, planet.radius, 0, Math.PI * 2);
            ctx.fillStyle = planet.color;
            ctx.fill();
            ctx.closePath();
        }
    }
    
    // Create planets with random properties
    var planets = [];
    for (var i = 0; i < 2; i++) {
        var radius = Math.random() * 50 + 10; // Range: 10-60
        var x = Math.random() * (canvas.width - radius * 2) + radius;
        var y = Math.random() * (canvas.height - radius * 2) + radius;
        var color = getRandomColor();
        var mass = Math.PI * Math.pow(radius, 2);
        var direction = getRandomDirection();
        planets.push(new Planet(x, y, radius, color, mass, direction.dx, direction.dy));
    }
    
    // Add event listener for creating planets on click
    canvas.addEventListener("click", function(event) {
        var radius = Math.random() * 50 + 10; // Range: 10-60
        var x = event.clientX;
        var y = event.clientY;
        var color = getRandomColor();
        var mass = Math.PI * Math.pow(radius, 2);
        var direction = getRandomDirection();
        planets.push(new Planet(x, y, radius, color, mass, direction.dx, direction.dy));
    });
    
    // Update and render planets in an animation loop
    function animate() {
        for (var i = 0; i < planets.length; i++) {
            var planet = planets[i];
            for (var j = 0; j < planets.length; j++) {
                if (i !== j) {
                    var force = calculateGravity(planet, planets[j]);
                    var distanceX = planets[j].x - planet.x;
                    var distanceY = planets[j].y - planet.y;
                    var accelerationX = force * (distanceX / Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2)));
                    var accelerationY = force * (distanceY / Math.sqrt(Math.pow(distanceX, 2) + Math.pow(distanceY, 2)));
                    planet.dx += accelerationX / planet.mass;
                    planet.dy += accelerationY / planet.mass;
                }
            }
            updatePosition(planet);
            detectCollisions(planet, planets);
        }
        renderPlanets(planets);
        requestAnimationFrame(animate);
    }
    
    // Start the simulation
    animate();
</script>

</body>
</html>