Improve weather system

Author: donutloop

docs/adr/0001-365-day-seasonal-cycle.md

@@ -0,0 +1,24 @@
+# 1. 365-Day Seasonal Cycle
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+The application previously operated on a simple day/night cycle with no concept of long-term progression or seasons. The weather was static unless manually changed. A request was made to simulate a full year.
+
+## Decision
+
+We implemented a `day` (1-365) and `year` counter in the `WeatherSystem`. The year is divided into four distinct seasons based on day ranges:
+*   **Winter**: Days 1-90
+*   **Spring**: Days 91-180
+*   **Summer**: Days 181-270
+*   **Autumn**: Days 271-365
+
+## Consequences
+
+*   **Positive**: Adds depth and variety to the gameplay loop; creates a sense of time progression.
+*   **Negative**: Adds state complexity to the `WeatherSystem`.

docs/adr/0002-automatic-probabilistic-weather-transitions.md

@@ -0,0 +1,24 @@
+# 2. Automatic Probabilistic Weather Transitions
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+Weather needed to change dynamically without user input, but purely random selection (noise) would lack realism (e.g., snow in summer).
+
+## Decision
+
+We implemented a probabilistic approach where the `currentSeason` determines the likelihood of specific weather types. The system checks for a weather change every 2-4 in-game hours.
+
+*   **Winter**: High chance of Snow.
+*   **Summer**: High chance of Sun.
+*   **Spring/Autumn**: Mixed probabilities.
+
+## Consequences
+
+*   **Positive**: Weather feels organic and season-appropriate.
+*   **Negative**: Predictability is reduced; rigorous testing requires time acceleration or mocking.

docs/adr/0003-10-minute-fixed-day-duration.md

@@ -0,0 +1,20 @@
+# 3. 10-Minute Fixed Day Duration
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+The speed of the day/night cycle impacts the pacing of the game.
+
+## Decision
+
+The time scale is fixed such that 1 in-game day equals 10 minutes of real time. This is achieved by setting the time increment `hoursPerSec` to `0.04` (24 hours / 600 seconds).
+
+## Consequences
+
+*   **Positive**: Provides a balanced cycle that is long enough to enjoy but short enough to see transitions during a play session.
+*   **Negative**: Fixed scaling might not suit all players (though this is standard for this genre).

docs/adr/0004-removal-of-manual-weather-controls.md

@@ -0,0 +1,20 @@
+# 4. Removal of Manual Weather Controls
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+With the introduction of the automatic seasonal system, manual overrides (keyboard shortcuts 1, 2, 3) conflicted with the simulation logic (e.g., manually setting Sun during a calculated Snow period would be immediately overwritten or break immersion).
+
+## Decision
+
+We removed the manual keyboard event listeners and the corresponding on-screen UI instructions.
+
+## Consequences
+
+*   **Positive**: Ensures the integrity of the seasonal simulation; cleans up the UI.
+*   **Negative**: Developers and users lose the ability to instantly force weather states for debugging or screenshot purposes. A "Debug Mode" may need to be reintroduced later.

docs/adr/0005-sync-start-date-with-real-world.md

@@ -0,0 +1,20 @@
+# 5. Sync Start Date with Real World
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+Players want the in-game season to initially match the real-world season to enhance immersion. For example, if playing in December, the game should start in Winter.
+
+## Decision
+
+We query the system's current date (`new Date()`) at startup and calculate the day of the year (1-366). We initialize the game's `day` counter with this value.
+
+## Consequences
+
+*   **Positive**: Immediate immersion boost; the game feels "live" and connected to reality.
+*   **Negative**: A new player starting in Winter might face harder weather conditions (snow) immediately compared to starting in Summer.

docs/adr/0006-geometry-merging.md

@@ -0,0 +1,36 @@
+# 6. Geometry Merging for Chunk Performance
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+The game generates an infinite world using chunks. Each chunk contained hundreds of individual meshes for buildings, windows, road markings, and vegetation. This led to a very high number of draw calls (thousands per frame) and significant GPU overhead, preventing the game from maintaining a steady 60 FPS, especially on lower-end devices.
+
+## Decision
+
+We refactored the chunk generation system (`world.js` and `createCityChunk`) to implement **Geometry Merging**.
+
+Instead of creating a `THREE.Mesh` for every single building part:
+1.  We pass a `geoms` accumulator object to all building functions.
+2.  Each function pushes `THREE.BufferGeometry` instances into arrays keyed by material type (e.g., `geoms.concrete`, `geoms.glass`).
+3.  At the end of chunk generation, we use `BufferGeometryUtils.mergeGeometries` to combine all geometries of the same material into a single mesh.
+4.  The final chunk contains only ~10-15 meshes (one per unique material) instead of hundreds.
+
+## Consequences
+
+### Positive
+*   **Drastically Reduced Draw Calls**: From ~500+ per chunk to ~15 per chunk.
+*   **Improved Frame Rate**: Significant CPU and GPU optimization.
+*   **Consistent Visuals**: The visual output remains identical.
+
+### Negative
+*   **Loss of Individual Object Identity**: Individual buildings are no longer separate objects. We cannot easily interact with (e.g., click, move, destroy) a specific building instance anymore without complex raycasting logic on the merged mesh.
+*   **Increased Memory during Generation**: All geometries must be held in memory arrays before merging.
+*   **Slightly Slower Chunk Generation**: The merge operation itself is CPU intensive, but it happens once per chunk load and saves frame time forever after.
+
+## Compliance
+*   Implemented in `src/world.js`.

docs/adr/0007-object-pooling.md

@@ -0,0 +1,34 @@
+# 7. Object Pooling for Traffic
+
+Date: 2025-12-17
+
+## Status
+
+Accepted
+
+## Context
+
+The infinite runner nature of the game requires constant spawning and despawning of traffic cars as new chunks load and old ones unload. Creating new `THREE.Group` hierarchies and geometries for complex cars triggers frequent Garbage Collection (GC) pauses and frame drops (stutter) whenever the player crosses a chunk boundary.
+
+## Decision
+
+We implemented an **Object Pooling** system for the `TrafficSystem`.
+
+1.  A `CarPool` dictionary organizes inactive car objects by type (`sedan`, `taxi`, etc.).
+2.  When a chunk loads, cars are retrieved from the pool (`getCarFromPool`). If empty, a new car is created.
+3.  When a chunk unloads, cars are hidden and returned to the pool (`returnCarToPool`) instead of being disposed.
+4.  The `utils.js` disposal logic is bypassed for pooled objects during normal gameplay.
+
+## Consequences
+
+### Positive
+*   **Reduced Stutter**: Elimination of instantiation lag when generating chunks.
+*   **Reduced GC Pressure**: Memory usage stabilizes as objects are reused rather than constantly allocated and discarded.
+*   **Smoother Gameplay**: Consistent framerate across chunk boundaries.
+
+### Negative
+*   **Memory Overhead**: Unused cars remain in memory (hidden) rather than being fully freed.
+*   **State Management Risk**: If a car is not properly reset (e.g., position, rotation, damage state) when retrieved from the pool, "ghost" behaviors could occur. We explicitly reset visibility and scene presence.
+
+## Compliance
+*   Implemented in `src/traffic.js`.

docs/adr/README.md

@@ -0,0 +1,9 @@
+# Architecture Decision Records
+
+*   [1. 365-Day Seasonal Cycle](0001-365-day-seasonal-cycle.md)
+*   [2. Automatic Probabilistic Weather Transitions](0002-automatic-probabilistic-weather-transitions.md)
+*   [3. 10-Minute Fixed Day Duration](0003-10-minute-fixed-day-duration.md)
+*   [4. Removal of Manual Weather Controls](0004-removal-of-manual-weather-controls.md)
+*   [5. Sync Start Date with Real World](0005-sync-start-date-with-real-world.md)
+*   [6. Geometry Merging](0006-geometry-merging.md)
+*   [7. Object Pooling](0007-object-pooling.md)

src/main.js

@@ -105,24 +105,9 @@ async function init() {
 
         console.log('Game Initialized with Infinite World + Populated Chunks');
 
-        // Weather Controls
-        window.addEventListener('keydown', (e) => {
-            if (weatherSystem) { // Safety check
-                if (e.key === '1') weatherSystem.setSunny();
-                if (e.key === '2') weatherSystem.setRain();
-                if (e.key === '3') weatherSystem.setSnow();
-            }
-        });
 
-        // Instructions for weather
-        const weatherInfo = document.createElement('div');
-        weatherInfo.style.position = 'absolute';
-        weatherInfo.style.top = '20px';
-        weatherInfo.style.right = '20px';
-        weatherInfo.style.color = '#fff';
-        weatherInfo.style.fontFamily = 'monospace';
-        weatherInfo.innerHTML = '[1] Sunny [2] Rain [3] Snow';
-        document.body.appendChild(weatherInfo);
+
+
 
         // Version Display
         const verDiv = document.createElement('div');
@@ -133,7 +118,7 @@ async function init() {
         verDiv.style.background = 'rgba(0,0,0,0.5)';
         verDiv.style.padding = '5px';
         verDiv.style.fontFamily = 'monospace';
-        verDiv.innerHTML = 'v6.1.0: Mega City & Life Update';
+        verDiv.innerHTML = 'v6.2.0: Performance & Weather Update';
         document.body.appendChild(verDiv);
 
         animate(() => {

src/traffic.js

@@ -10,8 +10,16 @@ export class TrafficSystem {
         this.roadWidth = roadWidth;
         this.chunkCars = new Map();
         this.cars = []; // Flat list for easy loop
-        // this.carSpeed = 10; // Removed global speed
-        // No init() call here, wait for ChunkManager
+
+        // Object Pooling
+        this.carPool = {
+            sedan: [],
+            taxi: [],
+            suv: [],
+            truck: [],
+            bus: [],
+            sport: []
+        };
     }
 
     // [NEW] Speed definitions
@@ -27,6 +35,25 @@ export class TrafficSystem {
         }
     }
 
+    getCarFromPool(type) {
+        if (this.carPool[type] && this.carPool[type].length > 0) {
+            const car = this.carPool[type].pop();
+            car.visible = true;
+            return car;
+        }
+        return createCarMesh(type);
+    }
+
+    returnCarToPool(carMesh, type) {
+        if (!carMesh) return;
+        // Reset transform? Not strictly needed as spawnCarInChunk overwrites.
+        carMesh.visible = false;
+        this.scene.remove(carMesh); // Detach from scene logic inside unloadChunk handles this too, but good to ensure.
+
+        if (!this.carPool[type]) this.carPool[type] = [];
+        this.carPool[type].push(carMesh);
+    }
+
     loadChunk(cx, cz, biome = 'city') {
         const chunkCarsList = [];
         const numCars = 3; // Cars per chunk
@@ -43,7 +70,9 @@ export class TrafficSystem {
 
         for (let i = 0; i < numCars; i++) {
             const type = getRandomCarType();
-            const carGroup = createCarMesh(type);
+
+            // USE POOL
+            const carGroup = this.getCarFromPool(type);
 
             // Optimization: Cache local bounding box to avoid per-frame traversal
             // This box is in local space (relative to car origin)
@@ -83,7 +112,13 @@ export class TrafficSystem {
                         cx: cx,
                         cz: cz
                     });
+                } else {
+                    // Spawn failed (invalid spot), return to pool immediately
+                    this.returnCarToPool(carGroup, type);
                 }
+            } else {
+                // Spawn failed (collision?), return to pool
+                this.returnCarToPool(carGroup, type);
             }
         }
         this.chunkCars.set(`${cx},${cz}`, chunkCarsList);
@@ -102,8 +137,10 @@ export class TrafficSystem {
                     // It remains in this.cars so traffic avoids it, which is correct.
                     return;
                 }
-                this.scene.remove(car.mesh);
-                disposeCar(car.mesh); // Dispose resources
+
+                // RETURN TO POOL instead of Dispose
+                this.returnCarToPool(car.mesh, car.type);
+
                 // Remove from flat list
                 const idx = this.cars.indexOf(car);
                 if (idx > -1) this.cars.splice(idx, 1);