KaiSD/Test-rep
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Изменить 'wbld/orbits.html'

Browse Source
This commit is contained in:
KaiSD
2025-02-26 02:22:42 +01:00
parent fd41d7a991
commit d2dca1da9b
1 changed files with 45 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
wbld/orbits.html
View File

@@ -2,7 +2,7 @@
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Senthara Orbit and Rotation Visualization</title>
<title>Senthara Orbit, Rotation & Day/Night Visualization</title>
<script src="https://cdn.jsdelivr.net/npm/phaser@3.60.0/dist/phaser.js"></script>
<style>
body { margin: 0; overflow: hidden; }
@@ -12,13 +12,16 @@
<body>
<script>
// Function to calculate the current Senthara date from simulationTime (in days)
// We add an offset so that simulationTime = 0 corresponds to "Autumn 36"
// With a 396-day year divided evenly into 4 seasons, an offset of 134 ensures:
// floor(134) mod 99 = 35 so that dayOfSeason becomes 35+1 = 36 and seasonIndex = 1 (Autumn).
function getSentharaDate(simDays) {
// Total days per year is 396
const year = Math.floor(simDays / 396) + 1;
const dayOfYear = (Math.floor(simDays) % 396) + 1;
// Each season is 99 days.
const offset = 134;
const X = Math.floor(simDays + offset);
const year = Math.floor(X / 396) + 1;
const dayOfYear = (X % 396) + 1;
const seasonIndex = Math.floor((dayOfYear - 1) / 99);
const dayOfSeason = ((dayOfYear - 1) % 99) + 1;
const dayOfSeason = dayOfYear - seasonIndex * 99;
const seasons = ["Summer", "Autumn", "Winter", "Spring"];
return `Year ${year} - ${seasons[seasonIndex]} ${dayOfSeason}`;
}
@@ -44,24 +47,24 @@
let globalGraphics;
let dateText;
let simulationTime = 0; // in days (simulation time)
const simulationSpeed = 10; // Speed multiplier
const simulationSpeed = 0.05; // speed multiplier
// Orbital periods (in days)
const planetPeriod = 396; // Senthara's orbit (year)
const planetPeriod = 396; // Senthara's orbital year
const planetRotationPeriod = 1; // Planet rotates fully in 1 day
const kerielPeriod = 27;
const arkaenPeriod = 82;
const minianPeriod = 98;
// Orbital radii (will be computed relative to window size)
// Orbital radii (computed relative to window size)
let planetOrbitRadius, kerielOrbitRadius, arkaenOrbitRadius, minianOrbitRadius;
// Containers for planet and moons
// Containers for the planet and the moons
let planetContainer;
let kerielContainer, arkaenContainer, minianContainer;
function preload() {
// No external assets are loaded.
// No external assets are needed.
}
function create() {
@@ -72,43 +75,37 @@
fill: "#ffffff"
});
// Calculate orbital radii based on window size.
recalcOrbitRadii();
// Create planet container.
// Create a container for Senthara (the planet)
planetContainer = this.add.container(0, 0);
// Create a Graphics object for the planet body.
// Draw the planet body (green circle) with a marker for rotation.
let planetBody = this.add.graphics();
planetBody.fillStyle(0x00FF00, 1);
planetBody.fillCircle(0, 0, 12);
// Add a marker line (pointing to the right, 0 deg) to indicate surface rotation.
// Marker line (points to the right)
planetBody.lineStyle(2, 0x000000, 1);
planetBody.beginPath();
planetBody.moveTo(0, 0);
planetBody.lineTo(12, 0);
planetBody.closePath();
planetBody.strokePath();
// Add the planet body to the container.
planetContainer.add(planetBody);
// Create a night overlay that will cover the "dark" half of the planet.
// Draw a half-circle (180° arc) from 0 to PI.
// Create a night overlay (semi-transparent dark half-circle)
let nightOverlay = this.add.graphics();
nightOverlay.fillStyle(0x000000, 0.5);
// Draw the half circle with radius 12.
// Draw a half-circle (180° arc) with radius 12
nightOverlay.slice(0, 0, 12, 0, Math.PI, false);
nightOverlay.fillPath();
// Store it as a property for updating later.
// Save as a property for updating its rotation later.
planetContainer.nightOverlay = nightOverlay;
// Add the overlay on top of the planet.
planetContainer.add(nightOverlay);
// Create containers for each moon.
kerielContainer = createMoonContainer(this, 6, 0xFF0000); // Keriel: radius 6, red
arkaenContainer = createMoonContainer(this, 5, 0x0000FF); // Arkaen: radius 5, blue
minianContainer = createMoonContainer(this, 5, 0xFFFFFF); // Minian: radius 5, white
kerielContainer = createMoonContainer(this, 6, 0xFF0000); // Keriel: red
arkaenContainer = createMoonContainer(this, 5, 0x0000FF); // Arkaen: blue
minianContainer = createMoonContainer(this, 5, 0xFFFFFF); // Minian: white
// Listen for window resize events.
this.scale.on('resize', (gameSize) => {
@@ -123,21 +120,20 @@
let moonBody = scene.add.graphics();
moonBody.fillStyle(color, 1);
moonBody.fillCircle(0, 0, radius);
// Draw a marker (line) indicating the "front" of the moon.
// Marker line indicating the "front" of the moon.
moonBody.lineStyle(2, 0x000000, 1);
moonBody.beginPath();
moonBody.moveTo(0, 0);
moonBody.lineTo(radius, 0);
moonBody.closePath();
moonBody.strokePath();
moonContainer.add(moonBody);
return moonContainer;
}
// Recalculate orbital radii based on the window size.
// Recalculate orbital radii based on the current window size.
function recalcOrbitRadii() {
const minDim = Math.min(window.innerWidth, window.innerHeight);
planetOrbitRadius = minDim * 0.3; // 30% of smaller dimension
planetOrbitRadius = minDim * 0.3; // 30% of the smaller dimension
kerielOrbitRadius = planetOrbitRadius * 0.25;
arkaenOrbitRadius = planetOrbitRadius * 0.35;
minianOrbitRadius = planetOrbitRadius * 0.45;
@@ -147,51 +143,49 @@
// Advance simulation time.
simulationTime += (delta * simulationSpeed) / 1000;
// Clear global graphics and redraw orbit paths.
globalGraphics.clear();
// Center of the star (sun) at center of screen.
// Get center of the screen (position of the star).
const centerX = game.scale.width / 2;
const centerY = game.scale.height / 2;
// Draw the star.
// Clear global graphics.
globalGraphics.clear();
// Draw the central star.
globalGraphics.fillStyle(0xFFFF00, 1);
globalGraphics.fillCircle(centerX, centerY, 20);
// Draw Senthara's orbital path around the star.
// Draw Senthara's orbital path (around the star).
globalGraphics.lineStyle(1, 0x555555, 1);
globalGraphics.strokeCircle(centerX, centerY, planetOrbitRadius);
// Calculate Senthara's (planet's) orbital position.
// Calculate Senthara's (the planet's) position along its orbit.
const planetOrbitAngle = Phaser.Math.DegToRad((360 * (simulationTime % planetPeriod)) / planetPeriod - 90);
const planetX = centerX + planetOrbitRadius * Math.cos(planetOrbitAngle);
const planetY = centerY + planetOrbitRadius * Math.sin(planetOrbitAngle);
// Update planet container position.
// Update the planet container's position.
planetContainer.x = planetX;
planetContainer.y = planetY;
// Planet rotation (self-rotation) on a period of 1 day.
// Set the planet's self-rotation (day/night cycle) with a 1-day period.
const planetRotationAngle = Phaser.Math.DegToRad((360 * (simulationTime % planetRotationPeriod)) / planetRotationPeriod);
planetContainer.rotation = planetRotationAngle;
// Determine the subsolar angle (direction from planet to star).
// Update the night overlay so that the dark half covers the side away from the star.
const subsolarAngle = Phaser.Math.Angle.Between(planetX, planetY, centerX, centerY);
// The terminator line on the planet should be perpendicular to the sun direction.
// Update the night overlay's rotation so that its dark half covers the night side.
// Because the nightOverlay is a child of planetContainer, subtract the planet's rotation.
planetContainer.nightOverlay.rotation = subsolarAngle + Math.PI/2 - planetContainer.rotation;
// The night overlay's rotation is adjusted relative to the planet's rotation.
planetContainer.nightOverlay.rotation = subsolarAngle + Math.PI / 2 - planetContainer.rotation;
// Calculate positions for each moon relative to Senthara.
// Keriel
// Calculate and update moon positions (relative to Senthara).
// Keriel:
const kerielOrbitAngle = Phaser.Math.DegToRad((360 * (simulationTime % kerielPeriod)) / kerielPeriod - 90);
const kerielX = planetX + kerielOrbitRadius * Math.cos(kerielOrbitAngle);
const kerielY = planetY + kerielOrbitRadius * Math.sin(kerielOrbitAngle);
kerielContainer.x = kerielX;
kerielContainer.y = kerielY;
// Tidal locking: set moon's rotation so that its marker points toward Senthara.
// Ensure tidal locking: set Keriel's rotation so its marker points toward Senthara.
kerielContainer.rotation = Phaser.Math.Angle.Between(kerielX, kerielY, planetX, planetY);
// Arkaen
// Arkaen:
const arkaenOrbitAngle = Phaser.Math.DegToRad((360 * (simulationTime % arkaenPeriod)) / arkaenPeriod - 90);
const arkaenX = planetX + arkaenOrbitRadius * Math.cos(arkaenOrbitAngle);
const arkaenY = planetY + arkaenOrbitRadius * Math.sin(arkaenOrbitAngle);
@@ -199,7 +193,7 @@
arkaenContainer.y = arkaenY;
arkaenContainer.rotation = Phaser.Math.Angle.Between(arkaenX, arkaenY, planetX, planetY);
// Minian
// Minian:
const minianOrbitAngle = Phaser.Math.DegToRad((360 * (simulationTime % minianPeriod)) / minianPeriod - 90);
const minianX = planetX + minianOrbitRadius * Math.cos(minianOrbitAngle);
const minianY = planetY + minianOrbitRadius * Math.sin(minianOrbitAngle);
@@ -207,7 +201,7 @@
minianContainer.y = minianY;
minianContainer.rotation = Phaser.Math.Angle.Between(minianX, minianY, planetX, planetY);
// Optionally, redraw the orbits of the moons (around Senthara).
// Optionally, redraw the moons' orbital paths (around Senthara).
globalGraphics.lineStyle(1, 0x888888, 1);
globalGraphics.strokeCircle(planetX, planetY, kerielOrbitRadius);
globalGraphics.strokeCircle(planetX, planetY, arkaenOrbitRadius);