From d2dca1da9ba85543f8bc3d16b753f00744a9f93b Mon Sep 17 00:00:00 2001
From: KaiSD <kaisd@noreply.example.org>
Date: Wed, 26 Feb 2025 02:22:42 +0100
Subject: [PATCH] =?UTF-8?q?=D0=98=D0=B7=D0=BC=D0=B5=D0=BD=D0=B8=D1=82?=
 =?UTF-8?q?=D1=8C=20'wbld/orbits.html'?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 wbld/orbits.html | 96 +++++++++++++++++++++++-------------------------
 1 file changed, 45 insertions(+), 51 deletions(-)
diff --git a/wbld/orbits.html b/wbld/orbits.html
index fd2c43a..d5e08ab 100644
--- a/wbld/orbits.html
+++ b/wbld/orbits.html
@@ -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);
