diff --git a/wbld/orbits.html b/wbld/orbits.html
index 15f6cc3..c30a52a 100644
--- a/wbld/orbits.html
+++ b/wbld/orbits.html
@@ -1,312 +1,289 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
-    <meta charset="UTF-8">
-    <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; }
-        canvas { display: block; }
-        /* Style for the control panel */
-        #controlPanel {
-            position: absolute;
-            bottom: 10px;
-            right: 10px;
-            background-color: rgba(0, 0, 0, 0.7);
-            padding: 10px;
-            border-radius: 5px;
-            font-family: Arial, sans-serif;
-            color: white;
-        }
-        #controlPanel button, #controlPanel select {
-            margin: 5px;
-            padding: 8px;
-            border-radius: 4px;
-            border: 1px solid #ccc;
-            background-color: #eee;
-            color: black;
-            cursor: pointer;
-        }
-         #controlPanel button:hover {
-             background-color: #ddd;
-         }
-         #controlPanel select:hover {
-            background-color: #ddd;
-         }
-    </style>
+  <meta charset="UTF-8">
+  <title>Senthara Orbit, Rotation, Day/Night & Elliptical Orbits</title>
+  <script src="https://cdn.jsdelivr.net/npm/phaser@3.60.0/dist/phaser.js"></script>
+  <style>
+    body { margin: 0; overflow: hidden; }
+    canvas { display: block; }
+    /* Style for the control panel */
+    #controlPanel {
+      position: absolute;
+      bottom: 10px;
+      right: 10px;
+      background-color: rgba(0, 0, 0, 0.7);
+      padding: 10px;
+      border-radius: 5px;
+      font-family: Arial, sans-serif;
+      color: white;
+    }
+    #controlPanel button, #controlPanel select {
+      margin: 5px;
+      padding: 8px;
+      border-radius: 4px;
+      border: 1px solid #ccc;
+      background-color: #eee;
+      color: black;
+      cursor: pointer;
+    }
+    #controlPanel button:hover, #controlPanel select:hover {
+      background-color: #ddd;
+    }
+  </style>
 </head>
 <body>
-    <div id="controlPanel">
-        <button id="playPauseButton">Play</button>
-        <button id="rewindButton">Rewind</button>
-        <select id="speedSelect">
-            <option value="1">x1</option>
-            <option value="2">x2</option>
-            <option value="5" selected>x5</option>
-            <option value="10">x10</option>
-            <option value="100">x100</option>
-            <option value="1000">x1000</option>
-            <option value="1000">x1000</option>
-            <option value="10000">x10000</option>
-            <option value="100000">x100000</option>
-            <option value="1000000">x1000000</option>
-        </select>
-    </div>
+  <div id="controlPanel">
+      <button id="playPauseButton">Play</button>
+      <button id="rewindButton">Rewind</button>
+      <select id="speedSelect">
+          <option value="1">x1</option>
+          <option value="2">x2</option>
+          <option value="5" selected>x5</option>
+          <option value="10">x10</option>
+          <option value="100">x100</option>
+          <option value="1000">x1000</option>
+          <option value="10000">x10000</option>
+          <option value="100000">x100000</option>
+          <option value="1000000">x1000000</option>
+      </select>
+  </div>
+  <script>
+    // Helper: returns {x, y} for an elliptical orbit.
+    // a = semi-major axis, ecc = eccentricity, so semi-minor axis b = a*sqrt(1 - ecc^2).
+    // theta is a linear parameter based on simulation time (not the true anomaly, but sufficient for visualization).
+    function getEllipticalPosition(simTime, period, a, ecc) {
+      const theta = Phaser.Math.DegToRad((360 * (simTime % period)) / period - 90);
+      const b = a * Math.sqrt(1 - ecc * ecc);
+      return { x: a * Math.cos(theta), y: b * Math.sin(theta) };
+    }
 
-    <script>
-        // Function to calculate the current Senthara date from simulationTime (in days)
-        function getSentharaDate(simDays) {
-            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 - seasonIndex * 99;
-            const seasons = ["Summer", "Autumn", "Winter", "Spring"];
-            return `Year ${year} - ${seasons[seasonIndex]} ${dayOfSeason}`;
-        }
+    // Function to calculate the current Senthara date from simulationTime (in days),
+    // with an offset so that simulationTime=0 corresponds to "Autumn 36".
+    function getSentharaDate(simDays) {
+      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 - seasonIndex * 99;
+      const seasons = ["Summer", "Autumn", "Winter", "Spring"];
+      return `Year ${year} - ${seasons[seasonIndex]} ${dayOfSeason}`;
+    }
 
-        // Phaser configuration
-        const config = {
-            type: Phaser.AUTO,
-            width: window.innerWidth,
-            height: window.innerHeight,
-            backgroundColor: "#000000",
-            scene: {
-                preload: preload,
-                create: create,
-                update: update
-            },
-            scale: {
-                mode: Phaser.Scale.RESIZE
-            }
-        };
+    // Phaser configuration (responsive)
+    const config = {
+      type: Phaser.AUTO,
+      width: window.innerWidth,
+      height: window.innerHeight,
+      backgroundColor: "#000000",
+      scene: {
+        preload: preload,
+        create: create,
+        update: update
+      },
+      scale: {
+        mode: Phaser.Scale.RESIZE
+      }
+    };
 
-        const game = new Phaser.Game(config);
+    const game = new Phaser.Game(config);
 
-        let globalGraphics;
-        let dateText;
-        let simulationTime = 0;
-        let simulationSpeed = 5;
-        let isPlaying = false;
-        let isRewinding = false;
+    let globalGraphics;
+    let dateText;
+    let simulationTime = 0; // in days (simulation time)
+    let simulationSpeed = 5; // speed multiplier
+    let isPlaying = false;   // Start paused
+    let isRewinding = false; // Control forward/backward
 
-        // Orbital parameters (in days and relative units)
-        const planetPeriod = 396;
-        const planetRotationPeriod = 1;
-        const kerielPeriod = 27;
-        const arkaenPeriod = 82;
-        const minianPeriod = 98;
+    // Orbital periods (in days)
+    const planetPeriod = 396;  // Senthara's orbital year around its star
+    const planetRotationPeriod = 1; // Planet rotates fully in 1 day
+    const kerielPeriod = 27;
+    const arkaenPeriod = 82;
+    const minianPeriod = 98;
 
-        // Orbital radii and eccentricities
-        let planetOrbitRadius, kerielOrbitRadius, arkaenOrbitRadius, minianOrbitRadius;
-        const planetEccentricity = 0.2;  // Example eccentricity for Senthara
-        const kerielEccentricity = 0.1;
-        const arkaenEccentricity = 0.15;
-        const minianEccentricity = 0.05;
+    // Eccentricity parameters (0 = circle; higher values = more elliptical)
+    const planetEcc = 0.2;     // Planet's orbit eccentricity
+    const kerielEcc = 0.05;    // Moons tend to have near-circular orbits due to tidal locking
+    const arkaenEcc = 0.05;
+    const minianEcc = 0.05;
 
-       // Angle offsets
-        let planetAngleOffset;
-        let kerielAngleOffset;
-        let arkaenAngleOffset;
-        let minianAngleOffset;
+    // Orbital radii (semi-major axes) (computed relative to window size)
+    let planetOrbitRadius, kerielOrbitRadius, arkaenOrbitRadius, minianOrbitRadius;
 
-        // Containers
-        let planetContainer;
-        let kerielContainer, arkaenContainer, minianContainer;
+    // Containers for the planet and the moons.
+    let planetContainer;
+    let kerielContainer, arkaenContainer, minianContainer;
 
-        function preload() {
-            // No external assets are needed.
-        }
-        function create() {
-            globalGraphics = this.add.graphics();
-            dateText = this.add.text(10, game.scale.height - 30, "", { font: "20px Arial", fill: "#ffffff" });
+    function preload() {
+      // No external assets are needed.
+    }
 
-            recalcOrbitRadii();
-            setRandomAngleOffsets();
+    function create() {
+      globalGraphics = this.add.graphics();
 
-            planetContainer = this.add.container(0, 0);
-            let planetBody = this.add.graphics();
-            planetBody.fillStyle(0x00FF00, 1);
-            planetBody.fillCircle(0, 0, 12);
-            planetBody.lineStyle(2, 0x000000, 1);
-            planetBody.beginPath();
-            planetBody.moveTo(0, 0);
-            planetBody.lineTo(12, 0);
-            planetBody.strokePath();
-            planetContainer.add(planetBody);
+      dateText = this.add.text(10, game.scale.height - 30, "", {
+        font: "20px Arial",
+        fill: "#ffffff"
+      });
 
-            let nightOverlay = this.add.graphics();
-            nightOverlay.fillStyle(0x000000, 0.5);
-            nightOverlay.slice(0, 0, 12, 0, Math.PI, false);
-            nightOverlay.fillPath();
-            planetContainer.nightOverlay = nightOverlay;
-            planetContainer.add(nightOverlay);
+      recalcOrbitRadii();
 
-            kerielContainer = createMoonContainer(this, 6, 0xFF0000);
-            arkaenContainer = createMoonContainer(this, 5, 0x0000FF);
-            minianContainer = createMoonContainer(this, 5, 0xFFFFFF);
+      // Create container for Senthara (the planet)
+      planetContainer = this.add.container(0, 0);
+      // Planet body (green circle) with a marker line.
+      let planetBody = this.add.graphics();
+      planetBody.fillStyle(0x00FF00, 1);
+      planetBody.fillCircle(0, 0, 12);
+      planetBody.lineStyle(2, 0x000000, 1);
+      planetBody.beginPath();
+      planetBody.moveTo(0, 0);
+      planetBody.lineTo(12, 0);
+      planetBody.strokePath();
+      planetContainer.add(planetBody);
 
-            this.scale.on('resize', (gameSize) => {
-                recalcOrbitRadii();
-                dateText.setPosition(10, gameSize.height - 30);
-            });
+      // Night overlay for day/night cycle (semi-transparent half-circle)
+      let nightOverlay = this.add.graphics();
+      nightOverlay.fillStyle(0x000000, 0.5);
+      nightOverlay.slice(0, 0, 12, 0, Math.PI, false);
+      nightOverlay.fillPath();
+      planetContainer.nightOverlay = nightOverlay;
+      planetContainer.add(nightOverlay);
 
-            const playPauseButton = document.getElementById("playPauseButton");
-            const rewindButton = document.getElementById("rewindButton");
-            const speedSelect = document.getElementById("speedSelect");
+      // Create containers for each moon.
+      kerielContainer = createMoonContainer(this, 6, 0xFF0000); // Keriel: red
+      arkaenContainer = createMoonContainer(this, 5, 0x0000FF); // Arkaen: blue
+      minianContainer = createMoonContainer(this, 5, 0xFFFFFF);  // Minian: white
 
-            playPauseButton.addEventListener("click", () => {
-                isPlaying = !isPlaying;
-                playPauseButton.textContent = isPlaying ? "Pause" : "Play";
-                if (isPlaying) isRewinding = false;
-            });
+      // UI Control Handlers
+      const playPauseButton = document.getElementById("playPauseButton");
+      const rewindButton = document.getElementById("rewindButton");
+      const speedSelect = document.getElementById("speedSelect");
 
-            rewindButton.addEventListener("click", () => {
-                isRewinding = !isRewinding;
-                rewindButton.textContent = isRewinding ? "Forward" : "Rewind";
-                if (isRewinding) isPlaying = false;
-                playPauseButton.textContent = "Play";
-            });
+      playPauseButton.addEventListener("click", () => {
+          isPlaying = !isPlaying;
+          playPauseButton.textContent = isPlaying ? "Pause" : "Play";
+          if (isPlaying) isRewinding = false;
+      });
 
-            speedSelect.addEventListener("change", () => {
-                simulationSpeed = parseFloat(speedSelect.value);
-            });
-        }
-        function createMoonContainer(scene, radius, color) {
-            let moonContainer = scene.add.container(0, 0);
-            let moonBody = scene.add.graphics();
-            moonBody.fillStyle(color, 1);
-            moonBody.fillCircle(0, 0, radius);
-            moonBody.lineStyle(2, 0x000000, 1);
-            moonBody.beginPath();
-            moonBody.moveTo(0, 0);
-            moonBody.lineTo(radius, 0);
-            moonBody.strokePath();
-            moonContainer.add(moonBody);
-            return moonContainer;
-        }
+      rewindButton.addEventListener("click", () => {
+          isRewinding = !isRewinding;
+          rewindButton.textContent = isRewinding ? "Forward" : "Rewind";
+          if(isRewinding) isPlaying = false;
+          playPauseButton.textContent = "Play";
+      });
 
-        // Recalculate orbital radii based on the current window size.
-        function recalcOrbitRadii() {
-            const minDim = Math.min(window.innerWidth, window.innerHeight);
-            planetOrbitRadius = minDim * 0.3;
-            kerielOrbitRadius = planetOrbitRadius * 0.25;
-            arkaenOrbitRadius = planetOrbitRadius * 0.35;
-            minianOrbitRadius = planetOrbitRadius * 0.45;
-        }
-        // Sets random angle offsets.
-        function setRandomAngleOffsets() {
-            planetAngleOffset = Phaser.Math.RND.between(0, 360);
-            kerielAngleOffset = Phaser.Math.RND.between(0, 360);
-            arkaenAngleOffset = Phaser.Math.RND.between(0, 360);
-            minianAngleOffset = Phaser.Math.RND.between(0, 360);
-        }
+      speedSelect.addEventListener("change", () => {
+          simulationSpeed = parseFloat(speedSelect.value);
+      });
 
-        // Calculates position on an ellipse.
-        function calculateEllipsePosition(centerX, centerY, semiMajorAxis, eccentricity, period, time, angleOffset) {
-            const meanAnomaly = (2 * Math.PI * (time % period)) / period;
-            // Approximate eccentric anomaly using Newton-Raphson method
-            let eccentricAnomaly = approximateEccentricAnomaly(meanAnomaly, eccentricity);
+      this.scale.on('resize', (gameSize) => {
+          recalcOrbitRadii();
+          dateText.setPosition(10, gameSize.height - 30);
+      });
+    }
 
-            // Calculate the true anomaly
-            const trueAnomaly = 2 * Math.atan2(
-                Math.sqrt(1 + eccentricity) * Math.sin(eccentricAnomaly / 2),
-                Math.sqrt(1 - eccentricity) * Math.cos(eccentricAnomaly / 2)
-            );
+    // Helper function to create a moon container with a circular body and a marker.
+    function createMoonContainer(scene, radius, color) {
+      let moonContainer = scene.add.container(0, 0);
+      let moonBody = scene.add.graphics();
+      moonBody.fillStyle(color, 1);
+      moonBody.fillCircle(0, 0, radius);
+      moonBody.lineStyle(2, 0x000000, 1);
+      moonBody.beginPath();
+      moonBody.moveTo(0, 0);
+      moonBody.lineTo(radius, 0);
+      moonBody.strokePath();
+      moonContainer.add(moonBody);
+      return moonContainer;
+    }
 
-            // Calculate distance from the center
-            const distance = semiMajorAxis * (1 - eccentricity * Math.cos(eccentricAnomaly));
+    // Recalculate orbital radii based on window size.
+    function recalcOrbitRadii() {
+      const minDim = Math.min(window.innerWidth, window.innerHeight);
+      planetOrbitRadius = minDim * 0.3;  // semi-major axis for planet orbit
+      kerielOrbitRadius = planetOrbitRadius * 0.25;
+      arkaenOrbitRadius = planetOrbitRadius * 0.35;
+      minianOrbitRadius = planetOrbitRadius * 0.45;
+    }
 
-            // Calculate x and y coordinates, with angle offset
-            const x = centerX + distance * Math.cos(trueAnomaly + Phaser.Math.DegToRad(angleOffset));
-            const y = centerY + distance * Math.sin(trueAnomaly + Phaser.Math.DegToRad(angleOffset));
+    function update(time, delta) {
+      // Advance or rewind simulation time.
+      if (isPlaying) {
+          simulationTime += (delta * simulationSpeed) / 1000;
+      } else if (isRewinding) {
+          simulationTime -= (delta * simulationSpeed) / 1000;
+      }
 
-            return { x, y };
-        }
-        // Approximates the eccentric anomaly using the Newton-Raphson method.
-        function approximateEccentricAnomaly(meanAnomaly, eccentricity) {
-            let E = meanAnomaly; // Initial guess
-            let delta = 1;
+      const centerX = game.scale.width / 2;
+      const centerY = game.scale.height / 2;
 
-            // Iterate until the change is small enough (e.g., less than 0.0001)
-            while (delta > 0.0001) {
-                let nextE = E - (E - eccentricity * Math.sin(E) - meanAnomaly) / (1 - eccentricity * Math.cos(E));
-                delta = Math.abs(nextE - E);
-                E = nextE;
-            }
-            return E;
-        }
+      globalGraphics.clear();
 
-        function update(time, delta) {
-            if (isPlaying) {
-                simulationTime += (delta * simulationSpeed) / 1000;
-            } else if (isRewinding) {
-                simulationTime -= (delta * simulationSpeed) / 1000;
-            }
+      // Draw the central star.
+      globalGraphics.fillStyle(0xFFFF00, 1);
+      globalGraphics.fillCircle(centerX, centerY, 20);
 
-            const centerX = game.scale.width / 2;
-            const centerY = game.scale.height / 2;
+      // Draw the planet's elliptical orbital path around the star.
+      const bPlanet = planetOrbitRadius * Math.sqrt(1 - planetEcc * planetEcc);
+      globalGraphics.lineStyle(1, 0x555555, 1);
+      globalGraphics.strokeEllipse(centerX, centerY, 2 * planetOrbitRadius, 2 * bPlanet);
 
-            globalGraphics.clear();
-            globalGraphics.fillStyle(0xFFFF00, 1);
-            globalGraphics.fillCircle(centerX, centerY, 20);
+      // Get planet's position on its elliptical orbit.
+      const planetPos = getEllipticalPosition(simulationTime, planetPeriod, planetOrbitRadius, planetEcc);
+      const planetX = centerX + planetPos.x;
+      const planetY = centerY + planetPos.y;
 
-            // Calculate and draw Senthara's elliptical orbit
-           const planetPos = calculateEllipsePosition(centerX, centerY, planetOrbitRadius, planetEccentricity, planetPeriod, simulationTime, planetAngleOffset);
-            planetContainer.x = planetPos.x;
-            planetContainer.y = planetPos.y;
+      // Update planet container position.
+      planetContainer.x = planetX;
+      planetContainer.y = planetY;
+      // Planet rotates about its own axis with a 1-day period.
+      const planetRotationAngle = Phaser.Math.DegToRad((360 * (simulationTime % planetRotationPeriod)) / planetRotationPeriod);
+      planetContainer.rotation = planetRotationAngle;
 
-            const planetRotationAngle = Phaser.Math.DegToRad((360 * (simulationTime % planetRotationPeriod)) / planetRotationPeriod);
-            planetContainer.rotation = planetRotationAngle;
+      // Update night overlay so that the dark half covers the hemisphere away from the star.
+      const subsolarAngle = Phaser.Math.Angle.Between(planetX, planetY, centerX, centerY);
+      planetContainer.nightOverlay.rotation = subsolarAngle + Math.PI / 2 - planetContainer.rotation;
 
-            const subsolarAngle = Phaser.Math.Angle.Between(planetPos.x, planetPos.y, centerX, centerY);
-            planetContainer.nightOverlay.rotation = subsolarAngle + Math.PI / 2 - planetContainer.rotation;
+      // Draw moon orbital paths (elliptical) around Senthara.
+      // For each moon, compute semi-minor axis: b = a * sqrt(1 - ecc^2).
+      const bKeriel = kerielOrbitRadius * Math.sqrt(1 - kerielEcc * kerielEcc);
+      const bArkaen = arkaenOrbitRadius * Math.sqrt(1 - arkaenEcc * arkaenEcc);
+      const bMinian = minianOrbitRadius * Math.sqrt(1 - minianEcc * minianEcc);
+      globalGraphics.lineStyle(1, 0x888888, 1);
+      globalGraphics.strokeEllipse(planetX, planetY, 2 * kerielOrbitRadius, 2 * bKeriel);
+      globalGraphics.strokeEllipse(planetX, planetY, 2 * arkaenOrbitRadius, 2 * bArkaen);
+      globalGraphics.strokeEllipse(planetX, planetY, 2 * minianOrbitRadius, 2 * bMinian);
 
-            // Calculate and update moon positions (relative to Senthara, using elliptical orbits)
-            const kerielPos = calculateEllipsePosition(planetPos.x, planetPos.y, kerielOrbitRadius, kerielEccentricity, kerielPeriod, simulationTime, kerielAngleOffset);
-            kerielContainer.x = kerielPos.x;
-            kerielContainer.y = kerielPos.y;
-            kerielContainer.rotation = Phaser.Math.Angle.Between(kerielPos.x, kerielPos.y, planetPos.x, planetPos.y);
+      // Calculate and update moon positions relative to Senthara.
+      // Keriel:
+      const kerielPos = getEllipticalPosition(simulationTime, kerielPeriod, kerielOrbitRadius, kerielEcc);
+      const kerielX = planetX + kerielPos.x;
+      const kerielY = planetY + kerielPos.y;
+      kerielContainer.x = kerielX;
+      kerielContainer.y = kerielY;
+      kerielContainer.rotation = Phaser.Math.Angle.Between(kerielX, kerielY, planetX, planetY);
 
-            const arkaenPos = calculateEllipsePosition(planetPos.x, planetPos.y, arkaenOrbitRadius, arkaenEccentricity, arkaenPeriod, simulationTime, arkaenAngleOffset);
-            arkaenContainer.x = arkaenPos.x;
-            arkaenContainer.y = arkaenPos.y;
-            arkaenContainer.rotation = Phaser.Math.Angle.Between(arkaenPos.x, arkaenPos.y, planetPos.x, planetPos.y);
+      // Arkaen:
+      const arkaenPos = getEllipticalPosition(simulationTime, arkaenPeriod, arkaenOrbitRadius, arkaenEcc);
+      const arkaenX = planetX + arkaenPos.x;
+      const arkaenY = planetY + arkaenPos.y;
+      arkaenContainer.x = arkaenX;
+      arkaenContainer.y = arkaenY;
+      arkaenContainer.rotation = Phaser.Math.Angle.Between(arkaenX, arkaenY, planetX, planetY);
 
-            const minianPos = calculateEllipsePosition(planetPos.x, planetPos.y, minianOrbitRadius, minianEccentricity, minianPeriod, simulationTime, minianAngleOffset);
-            minianContainer.x = minianPos.x;
-            minianContainer.y = minianPos.y;
-            minianContainer.rotation = Phaser.Math.Angle.Between(minianPos.x, minianPos.y, planetPos.x, planetPos.y);
+      // Minian:
+      const minianPos = getEllipticalPosition(simulationTime, minianPeriod, minianOrbitRadius, minianEcc);
+      const minianX = planetX + minianPos.x;
+      const minianY = planetY + minianPos.y;
+      minianContainer.x = minianX;
+      minianContainer.y = minianY;
+      minianContainer.rotation = Phaser.Math.Angle.Between(minianX, minianY, planetX, planetY);
 
-            // Draw elliptical orbits (optional, for visualization)
-            drawEllipticalOrbit(globalGraphics, centerX, centerY, planetOrbitRadius, planetEccentricity, planetAngleOffset);
-            drawEllipticalOrbit(globalGraphics, planetPos.x, planetPos.y, kerielOrbitRadius, kerielEccentricity, kerielAngleOffset);
-            drawEllipticalOrbit(globalGraphics, planetPos.x, planetPos.y, arkaenOrbitRadius, arkaenEccentricity, arkaenAngleOffset);
-            drawEllipticalOrbit(globalGraphics, planetPos.x, planetPos.y, minianOrbitRadius, minianEccentricity, minianAngleOffset);
-
-            dateText.setText(getSentharaDate(simulationTime));
-        }
-		// Helper function to draw an elliptical orbit using Phaser graphics.
-        function drawEllipticalOrbit(graphics, centerX, centerY, semiMajorAxis, eccentricity, angleOffset) {
-            const points = [];
-            const steps = 100; // Number of points to create a smooth curve
-            for (let i = 0; i <= steps; i++) {
-                const meanAnomaly = (2 * Math.PI * i) / steps;
-                const eccentricAnomaly = approximateEccentricAnomaly(meanAnomaly, eccentricity);
-                const trueAnomaly = 2 * Math.atan2(
-                    Math.sqrt(1 + eccentricity) * Math.sin(eccentricAnomaly / 2),
-                    Math.sqrt(1 - eccentricity) * Math.cos(eccentricAnomaly / 2)
-                );
-                const distance = semiMajorAxis * (1 - eccentricity * Math.cos(eccentricAnomaly));
-                const x = centerX + distance * Math.cos(trueAnomaly + Phaser.Math.DegToRad(angleOffset));
-                const y = centerY + distance * Math.sin(trueAnomaly + Phaser.Math.DegToRad(angleOffset));
-                points.push(new Phaser.Math.Vector2(x, y));
-            }
-
-            graphics.lineStyle(1, 0x888888, 1); // Set orbit line style
-            graphics.strokePoints(points, true); // Draw the ellipse
-        }
-    </script>
+      // Update the Senthara calendar date text.
+      dateText.setText(getSentharaDate(simulationTime));
+    }
+  </script>
 </body>
-</html>
\ No newline at end of file
+</html>
