feat: enhance terrain generation with varied biomes, improved mountain shapes, and dynamic river systems

README.md

@@ -58,7 +58,7 @@ This project is pre-configured to be deployed as a **Docker Space** on Hugging F
 - **Dynamic Day/Night Cycle**: A slow 7-minute continuous loop transitioning the sky gradient through dawn, noon, vivid sunset, and deep starry night.
 - **Lighting & Shadows**: PCF Soft Shadows enabled. Dynamic shifting hemisphere and directional orbital lighting.
 - **Volumetric Fog**: Deep atmospheric fog that shifts colors based on the time of day.
-- **Low-Poly Art Style**: Flat-shaded terrain, mountains, and forests for a sharp, premium aesthetic.
+- **Low-Poly Art Style**: Stylized terrain with jagged, procedurally generated fractal mountains, snow caps, and forests for a sharp, premium aesthetic.
 - **Reflective Water**: Beautifully refractive lake surfaces mirroring the sun and sky colors.
 
 ### HUD (Heads-Up Display)

src/Aircraft.js

@@ -260,16 +260,14 @@ export class Aircraft {
   }
 
   handleMouseMove(event) {
-    // Only apply mouse controls if pointer is locked (Simulator focused)
+    // Only apply mouse controls if pointer is locked
     if (document.pointerLockElement === document.body) {
-      const mouseSensX = 0.005;
-      const mouseSensY = 0.005;
-
-      // Map mouse Y to Pitch: inverted movementY so mouse Up = plane nose Up
-      this.pitch = THREE.MathUtils.clamp(this.pitch - event.movementY * mouseSensY, -1, 1);
-
-      // Map mouse X to Roll
-      this.roll = THREE.MathUtils.clamp(this.roll + event.movementX * mouseSensX, -1, 1);
+      // Accumulate mouse delta into target inputs (very low sensitivity)
+      this._pitchInput += -event.movementY * 0.002;
+      this._rollInput += event.movementX * 0.002;
+      // Clamp so you can't overload the buffer
+      this._pitchInput = THREE.MathUtils.clamp(this._pitchInput, -1, 1);
+      this._rollInput = THREE.MathUtils.clamp(this._rollInput, -1, 1);
     }
   }
 
@@ -319,10 +317,22 @@ export class Aircraft {
       this.cruiseThrust = THREE.MathUtils.clamp(this.cruiseThrust - 0.4 * deltaTime, 0, 1);
     }
 
+    // Initialize smoothed input buffers
+    if (this._pitchInput === undefined) { this._pitchInput = 0; this._rollInput = 0; }
+
     const speed = Math.max(this.velocity.length(), 0.01);
     const speedRatio = THREE.MathUtils.clamp(speed / 80, 0.35, 1.6);
 
-    // Update rotation using rates
+    // ── Smooth input: lerp actual control values toward buffered inputs ──
+    this.pitch = THREE.MathUtils.lerp(this.pitch, this._pitchInput, deltaTime * 6);
+    this.roll = THREE.MathUtils.lerp(this.roll, this._rollInput, deltaTime * 6);
+
+    // Decay the input buffer back toward zero (spring-return joystick feel)
+    this._pitchInput = THREE.MathUtils.lerp(this._pitchInput, 0, deltaTime * 3);
+    this._rollInput = THREE.MathUtils.lerp(this._rollInput, 0, deltaTime * 3);
+
+    // ── Apply rotation rates using YXZ Euler order ──
+    this.rotation.order = 'YXZ';
     this.rotation.x += this.pitch * this.pitchRate * deltaTime;
     this.rotation.z += this.roll * this.rollRate * deltaTime;
     this.rotation.y += this.yaw * this.yawRate * deltaTime;
@@ -330,22 +340,16 @@ export class Aircraft {
     // Banked turns: roll naturally induces yaw at speed
     this.rotation.y -= this.rotation.z * this.turnAssist * speedRatio * deltaTime;
 
-    // Apply drag to the sticks so they recenter automatically if mouse stops moving
-    if (document.pointerLockElement === document.body) {
-      this.pitch = THREE.MathUtils.lerp(this.pitch, 0, deltaTime * 2.0);
-      this.roll = THREE.MathUtils.lerp(this.roll, 0, deltaTime * 2.0);
-    }
-
-    // Clamp pitch/roll rotation limits and gently stabilize when no input
-    this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -1.1, 1.1);
+    // Clamp pitch to ±60° (well away from ±90° gimbal lock zone)
+    this.rotation.x = THREE.MathUtils.clamp(this.rotation.x, -1.05, 1.05);
     this.rotation.z = THREE.MathUtils.clamp(this.rotation.z, -1.2, 1.2);
 
-    // Auto-leveling logic
-    if (Math.abs(this.roll) < 0.05) {
-      this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, 0, deltaTime * 0.8);
+    // Auto-leveling: gently stabilise when input is near zero
+    if (Math.abs(this.pitch) < 0.03 && Math.abs(this._pitchInput) < 0.03) {
+      this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, 0, deltaTime * 0.4);
     }
-    if (Math.abs(this.pitch) < 0.05) {
-      this.rotation.x = THREE.MathUtils.lerp(this.rotation.x, 0, deltaTime * 0.3);
+    if (Math.abs(this.roll) < 0.03 && Math.abs(this._rollInput) < 0.03) {
+      this.rotation.z = THREE.MathUtils.lerp(this.rotation.z, 0, deltaTime * 1.0);
     }
 
     // Calculate body axes

src/main.js

@@ -388,17 +388,23 @@ class FlightSimulator {
   }
 
   createTerrain() {
-    const size = 2800;
-    const segments = 260;
+    const size = 3200;
+    const segments = 300;
     const geometry = new THREE.PlaneGeometry(size, size, segments, segments);
 
     const position = geometry.attributes.position;
     const colors = [];
-    const lowlandColor = new THREE.Color(0x1a2e1d);
-    const grassColor = new THREE.Color(0x264d28);
-    const highlandColor = new THREE.Color(0x384a2f);
-    const alpineColor = new THREE.Color(0x6a6a60);
-    const waterEdgeColor = new THREE.Color(0x152820);
+    // Richer, more varied biome colors
+    const deepWaterColor = new THREE.Color(0x0a1a24);
+    const shallowWaterColor = new THREE.Color(0x1a3a3a);
+    const sandColor = new THREE.Color(0x8a7a5a);
+    const lowlandColor = new THREE.Color(0x1a3520);
+    const grassColor = new THREE.Color(0x2d5a2d);
+    const forestColor = new THREE.Color(0x1f4228);
+    const highlandColor = new THREE.Color(0x4a5a40);
+    const rockyColor = new THREE.Color(0x5a5850);
+    const alpineColor = new THREE.Color(0x7a7870);
+    const snowColor = new THREE.Color(0xd8dee8);
     const color = new THREE.Color();
     const blend = new THREE.Color();
 
@@ -412,31 +418,48 @@ class FlightSimulator {
       height = THREE.MathUtils.lerp(height, 1.4, runwayProximity * 0.76);
       position.setZ(i, height);
 
-      const sampleStep = 5;
+      // Calculate slope for rock faces
+      const sampleStep = 6;
       const slopeX = this.getTerrainHeight(x + sampleStep, y) - this.getTerrainHeight(x - sampleStep, y);
       const slopeY = this.getTerrainHeight(x, y + sampleStep) - this.getTerrainHeight(x, y - sampleStep);
       const slope = Math.abs(slopeX) + Math.abs(slopeY);
-      const slopeFactor = THREE.MathUtils.clamp(slope / 28, 0, 1);
-      const ridgeNoise =
-        Math.sin(x * 0.022 + y * 0.009) +
-        Math.cos(y * 0.018) +
-        Math.sin((x - y) * 0.013);
-      const variation = ridgeNoise * 0.016;
-
-      if (height < -4) {
-        color.copy(waterEdgeColor);
-      } else if (height < 4) {
-        blend.lerpColors(lowlandColor, grassColor, THREE.MathUtils.clamp((height + 4) / 8, 0, 1));
+      const slopeFactor = THREE.MathUtils.clamp(slope / 35, 0, 1);
+
+      // Add subtle color variation
+      const noiseVar = Math.sin(x * 0.018 + y * 0.012) * 0.5 + Math.cos(y * 0.024 + x * 0.016) * 0.5;
+      const variation = noiseVar * 0.025;
+
+      // Height-based biomes with smooth transitions
+      if (height < -8) {
+        color.copy(deepWaterColor);
+      } else if (height < -2) {
+        blend.lerpColors(deepWaterColor, shallowWaterColor, THREE.MathUtils.clamp((height + 8) / 6, 0, 1));
+        color.copy(blend);
+      } else if (height < 2) {
+        blend.lerpColors(shallowWaterColor, sandColor, THREE.MathUtils.clamp((height + 2) / 4, 0, 1));
+        color.copy(blend);
+      } else if (height < 8) {
+        blend.lerpColors(sandColor, grassColor, THREE.MathUtils.clamp((height - 2) / 6, 0, 1));
+        color.copy(blend);
+      } else if (height < 20) {
+        blend.lerpColors(grassColor, forestColor, THREE.MathUtils.clamp((height - 8) / 12, 0, 1));
         color.copy(blend);
-      } else if (height < 18) {
-        blend.lerpColors(grassColor, highlandColor, THREE.MathUtils.clamp((height - 4) / 14, 0, 1));
+      } else if (height < 40) {
+        blend.lerpColors(forestColor, highlandColor, THREE.MathUtils.clamp((height - 20) / 20, 0, 1));
+        color.copy(blend);
+      } else if (height < 70) {
+        blend.lerpColors(highlandColor, rockyColor, THREE.MathUtils.clamp((height - 40) / 30, 0, 1));
+        color.copy(blend);
+      } else if (height < 100) {
+        blend.lerpColors(rockyColor, alpineColor, THREE.MathUtils.clamp((height - 70) / 30, 0, 1));
         color.copy(blend);
       } else {
-        blend.lerpColors(highlandColor, alpineColor, THREE.MathUtils.clamp((height - 18) / 28, 0, 1));
+        blend.lerpColors(alpineColor, snowColor, THREE.MathUtils.clamp((height - 100) / 40, 0, 1));
         color.copy(blend);
       }
 
-      color.lerp(alpineColor, slopeFactor * 0.42);
+      // Blend in rock color on steep slopes
+      color.lerp(rockyColor, slopeFactor * 0.6);
       color.offsetHSL(0, 0, variation);
       colors.push(color.r, color.g, color.b);
     }
@@ -509,16 +532,35 @@ class FlightSimulator {
   }
 
   getTerrainHeight(x, y) {
+    // Large continental features - mountain ranges
     const continental =
-      Math.sin(x * 0.0016) * 15 +
-      Math.cos(y * 0.00145) * 13;
+      Math.sin(x * 0.0008) * 35 +
+      Math.cos(y * 0.00065) * 28 +
+      Math.sin((x * 0.0005 + y * 0.0004)) * 22;
+
+    // Medium ridgelines - create spine-like formations
     const ridges =
-      Math.sin((x + y) * 0.0038) * 9 +
-      Math.cos((x - y) * 0.0027) * 7;
+      Math.sin((x + y) * 0.0022) * 18 +
+      Math.cos((x - y) * 0.0018) * 14 +
+      Math.sin(x * 0.0035) * Math.cos(y * 0.0028) * 12;
+
+    // Smaller hills and valleys
+    const hills =
+      Math.sin(x * 0.008) * Math.cos(y * 0.006) * 8 +
+      Math.cos(y * 0.009) * Math.sin(x * 0.007) * 6;
+
+    // Fine detail and texture
     const details =
-      Math.sin(x * 0.013) * Math.cos(y * 0.011) * 3 +
-      Math.sin((x + y) * 0.023) * 1.4;
-    return continental + ridges + details;
+      Math.sin(x * 0.025) * Math.cos(y * 0.022) * 3 +
+      Math.sin((x + y) * 0.038) * 1.8 +
+      Math.cos(x * 0.042) * Math.sin(y * 0.035) * 1.2;
+
+    // Create valley near runway (smoothed area)
+    const distToRunway = Math.sqrt(x * x + y * y);
+    const valleyFactor = Math.max(0, 1 - distToRunway / 400);
+    const valleySmoothing = valleyFactor * valleyFactor * 30;
+
+    return continental + ridges + hills + details - valleySmoothing;
   }
 
   createSky() {
@@ -716,152 +758,329 @@ class FlightSimulator {
 
   createDistantMountains() {
     const mountainGroup = new THREE.Group();
-    const rockMaterial = new THREE.MeshStandardMaterial({
-      color: 0x5a5b50,
-      roughness: 0.95,
+
+    // Varied rock materials for different mountain types
+    const darkRockMaterial = new THREE.MeshStandardMaterial({
+      color: 0x3a3540,
+      roughness: 0.92,
+      metalness: 0.03,
+      flatShading: true
+    });
+    const mediumRockMaterial = new THREE.MeshStandardMaterial({
+      color: 0x5a5560,
+      roughness: 0.88,
+      metalness: 0.04,
+      flatShading: true
+    });
+    const lightRockMaterial = new THREE.MeshStandardMaterial({
+      color: 0x7a7580,
+      roughness: 0.85,
+      metalness: 0.05,
+      flatShading: true
+    });
+    // Snow materials for different conditions
+    const freshSnowMaterial = new THREE.MeshStandardMaterial({
+      color: 0xf0f5fa,
+      roughness: 0.7,
       metalness: 0.05,
       flatShading: true
     });
+    const oldSnowMaterial = new THREE.MeshStandardMaterial({
+      color: 0xd0d8e0,
+      roughness: 0.8,
+      metalness: 0.03,
+      flatShading: true
+    });
     const foothillMaterial = new THREE.MeshStandardMaterial({
-      color: 0x4a5d3f,
-      roughness: 0.96,
+      color: 0x3d4f3b,
+      roughness: 0.95,
+      metalness: 0.02,
+      flatShading: true
+    });
+    const screeMaterial = new THREE.MeshStandardMaterial({
+      color: 0x6a6860,
+      roughness: 0.98,
       metalness: 0.01,
       flatShading: true
     });
 
-    for (let i = 0; i < 42; i++) {
+    // Helper to create jagged mountain geometry
+    const perturbGeometry = (geometry, intensity, preserveBase = true) => {
+      const posAttribute = geometry.attributes.position;
+      const vertex = new THREE.Vector3();
+      for (let i = 0; i < posAttribute.count; i++) {
+        vertex.fromBufferAttribute(posAttribute, i);
+        if (!preserveBase || vertex.y > -0.3 * geometry.parameters.height) {
+          vertex.x += (Math.random() - 0.5) * intensity;
+          vertex.z += (Math.random() - 0.5) * intensity;
+          vertex.y += (Math.random() - 0.5) * intensity * 0.4;
+        }
+        posAttribute.setXYZ(i, vertex.x, vertex.y, vertex.z);
+      }
+      geometry.computeVertexNormals();
+      return geometry;
+    };
+
+    // Major mountain peaks - dramatic and varied
+    for (let i = 0; i < 55; i++) {
       const angle = this.randomRange(0, Math.PI * 2);
-      const radius = this.randomRange(900, 1500);
+      const radius = this.randomRange(1000, 1800);
       const x = Math.cos(angle) * radius;
       const z = Math.sin(angle) * radius;
       const ground = this.getTerrainHeight(x, z);
-      const peakHeight = this.randomRange(95, 250);
-      const baseRadius = this.randomRange(34, 92);
 
-      const mountain = new THREE.Mesh(
-        new THREE.ConeGeometry(baseRadius, peakHeight, 8),
-        rockMaterial
-      );
-      mountain.position.set(x, ground + peakHeight * 0.46, z);
+      // Varied peak heights - some very tall, some medium
+      const peakHeight = this.randomRange(180, 520);
+      const baseRadius = peakHeight * this.randomRange(0.5, 0.95);
+
+      // Choose random rock material
+      const rockMats = [darkRockMaterial, mediumRockMaterial, lightRockMaterial];
+      const rockMat = rockMats[Math.floor(Math.random() * rockMats.length)];
+
+      // Create varied mountain shapes
+      let geom;
+      const shapeType = Math.random();
+      if (shapeType < 0.3) {
+        // Sharp spire
+        geom = new THREE.CylinderGeometry(0, baseRadius * 0.7, peakHeight, 6, 4);
+        geom = perturbGeometry(geom, baseRadius * 0.3);
+      } else if (shapeType < 0.6) {
+        // Classic cone
+        geom = new THREE.CylinderGeometry(0, baseRadius, peakHeight, 8, 5);
+        geom = perturbGeometry(geom, baseRadius * 0.22);
+      } else {
+        // Broad dome with jagged top
+        geom = new THREE.CylinderGeometry(baseRadius * 0.15, baseRadius * 1.2, peakHeight, 10, 6);
+        geom = perturbGeometry(geom, baseRadius * 0.35);
+      }
+
+      const mountain = new THREE.Mesh(geom, rockMat);
+      mountain.position.set(x, ground + peakHeight * 0.5, z);
       mountain.rotation.y = this.randomRange(0, Math.PI * 2);
       mountain.castShadow = true;
       mountain.receiveShadow = true;
       mountainGroup.add(mountain);
+
+      // Add snow cap for tall peaks
+      if (peakHeight > 300) {
+        const snowHeight = peakHeight * this.randomRange(0.25, 0.4);
+        const snowBase = baseRadius * this.randomRange(0.25, 0.4);
+        const snowMat = Math.random() > 0.5 ? freshSnowMaterial : oldSnowMaterial;
+
+        let capGeom;
+        if (Math.random() > 0.5) {
+          capGeom = new THREE.CylinderGeometry(0, snowBase, snowHeight, 7, 3);
+        } else {
+          capGeom = new THREE.SphereGeometry(snowBase, 8, 6, 0, Math.PI * 2, 0, Math.PI * 0.6);
+        }
+        capGeom = perturbGeometry(capGeom, snowBase * 0.15, false);
+
+        const cap = new THREE.Mesh(capGeom, snowMat);
+        cap.position.set(0, peakHeight * 0.5 - snowHeight * 0.4, 0);
+        cap.rotation.y = this.randomRange(0, Math.PI * 2);
+        mountain.add(cap);
+      }
+
+      // Add rocky outcrops on some mountains
+      if (Math.random() > 0.6) {
+        const outcropCount = Math.floor(this.randomRange(1, 4));
+        for (let j = 0; j < outcropCount; j++) {
+          const outcropGeom = new THREE.ConeGeometry(
+            baseRadius * this.randomRange(0.1, 0.25),
+            peakHeight * this.randomRange(0.15, 0.35),
+            5
+          );
+          perturbGeometry(outcropGeom, baseRadius * 0.1, false);
+          const outcrop = new THREE.Mesh(outcropGeom, darkRockMaterial);
+          outcrop.position.set(
+            this.randomRange(-baseRadius * 0.5, baseRadius * 0.5),
+            peakHeight * this.randomRange(0.1, 0.4),
+            this.randomRange(-baseRadius * 0.5, baseRadius * 0.5)
+          );
+          mountain.add(outcrop);
+        }
+      }
     }
 
-    for (let i = 0; i < 70; i++) {
+    // Rocky foothills - varied shapes
+    for (let i = 0; i < 100; i++) {
       const angle = this.randomRange(0, Math.PI * 2);
-      const radius = this.randomRange(620, 1300);
+      const radius = this.randomRange(600, 1400);
       const x = Math.cos(angle) * radius;
       const z = Math.sin(angle) * radius;
       const ground = this.getTerrainHeight(x, z);
-      const hillHeight = this.randomRange(24, 72);
-      const hillRadius = this.randomRange(20, 55);
 
-      const hill = new THREE.Mesh(
-        new THREE.ConeGeometry(hillRadius, hillHeight, 7),
-        foothillMaterial
-      );
-      hill.position.set(x, ground + hillHeight * 0.44, z);
+      const hillHeight = this.randomRange(50, 160);
+      const hillRadius = hillHeight * this.randomRange(1.0, 2.2);
+
+      let geom;
+      const hillType = Math.random();
+      if (hillType < 0.4) {
+        geom = new THREE.CylinderGeometry(0, hillRadius, hillHeight, 7, 3);
+      } else if (hillType < 0.7) {
+        geom = new THREE.DodecahedronGeometry(hillRadius * 0.6, 1);
+        geom.scale(1, hillHeight / (hillRadius * 0.6), 1);
+      } else {
+        geom = new THREE.ConeGeometry(hillRadius * 0.8, hillHeight, 6);
+      }
+      geom = perturbGeometry(geom, hillRadius * 0.12);
+
+      const hill = new THREE.Mesh(geom, Math.random() > 0.5 ? foothillMaterial : screeMaterial);
+      hill.position.set(x, ground + hillHeight * 0.4, z);
       hill.rotation.y = this.randomRange(0, Math.PI * 2);
       hill.castShadow = true;
       hill.receiveShadow = true;
       mountainGroup.add(hill);
     }
 
+    // Small rocky outcrops scattered around
+    for (let i = 0; i < 80; i++) {
+      const angle = this.randomRange(0, Math.PI * 2);
+      const radius = this.randomRange(400, 1200);
+      const x = Math.cos(angle) * radius;
+      const z = Math.sin(angle) * radius;
+      const ground = this.getTerrainHeight(x, z);
+
+      if (ground < 5) continue; // Skip water areas
+
+      const rockSize = this.randomRange(8, 25);
+      const geom = new THREE.DodecahedronGeometry(rockSize, 0);
+      perturbGeometry(geom, rockSize * 0.2, false);
+
+      const rock = new THREE.Mesh(geom, darkRockMaterial);
+      rock.position.set(x, ground + rockSize * 0.3, z);
+      rock.rotation.set(
+        this.randomRange(-0.3, 0.3),
+        this.randomRange(0, Math.PI * 2),
+        this.randomRange(-0.3, 0.3)
+      );
+      rock.scale.y = this.randomRange(0.5, 1.2);
+      rock.castShadow = true;
+      rock.receiveShadow = true;
+      mountainGroup.add(rock);
+    }
+
     this.scene.add(mountainGroup);
   }
 
   createForest() {
-    const maxTrees = 360;
-    const trunkGeometry = new THREE.CylinderGeometry(0.15, 0.28, 2.4, 6);
-    const canopyGeometry = new THREE.ConeGeometry(1.25, 4.8, 8);
+    const maxTrees = 500;
+    const trunkGeometry = new THREE.CylinderGeometry(0.12, 0.26, 2.2, 6);
+    const canopyGeometry = new THREE.ConeGeometry(1.15, 4.2, 8);
+    const broadCanopyGeometry = new THREE.SphereGeometry(2.2, 8, 6);
+
     const trunkMaterial = new THREE.MeshStandardMaterial({
       color: 0x3d2719,
       roughness: 0.98,
       metalness: 0,
       flatShading: true
     });
-    const canopyMaterial = new THREE.MeshStandardMaterial({
-      color: 0x1f4225,
-      roughness: 0.93,
-      metalness: 0.01,
-      flatShading: true
-    });
+    // Varied canopy colors
+    const canopyMaterials = [
+      new THREE.MeshStandardMaterial({ color: 0x1a4520, roughness: 0.93, metalness: 0.01, flatShading: true }),
+      new THREE.MeshStandardMaterial({ color: 0x2d5530, roughness: 0.93, metalness: 0.01, flatShading: true }),
+      new THREE.MeshStandardMaterial({ color: 0x1f3825, roughness: 0.93, metalness: 0.01, flatShading: true }),
+      new THREE.MeshStandardMaterial({ color: 0x3a6035, roughness: 0.93, metalness: 0.01, flatShading: true }),
+    ];
 
     const trunks = new THREE.InstancedMesh(trunkGeometry, trunkMaterial, maxTrees);
-    const canopies = new THREE.InstancedMesh(canopyGeometry, canopyMaterial, maxTrees);
+    const canopies = new THREE.InstancedMesh(canopyGeometry, canopyMaterials[0], maxTrees);
+    const broadCanopies = new THREE.InstancedMesh(broadCanopyGeometry, canopyMaterials[1], maxTrees);
     trunks.castShadow = true;
     trunks.receiveShadow = true;
     canopies.castShadow = true;
     canopies.receiveShadow = true;
+    broadCanopies.castShadow = true;
+    broadCanopies.receiveShadow = true;
 
     const dummy = new THREE.Object3D();
 
-    let placed = 0;
+    let placedConifers = 0;
+    let placedBroad = 0;
     let attempts = 0;
-    while (placed < maxTrees && attempts < maxTrees * 12) {
+    while (placedConifers + placedBroad < maxTrees && attempts < maxTrees * 15) {
       attempts += 1;
-      const x = this.randomRange(-1180, 1180);
-      const z = this.randomRange(-1180, 1180);
-      if (Math.sqrt(x * x + z * z) < 230) continue;
+      const x = this.randomRange(-1300, 1300);
+      const z = this.randomRange(-1300, 1300);
+      if (Math.sqrt(x * x + z * z) < 250) continue;
 
       const height = this.getTerrainHeight(x, z);
-      if (height < 2 || height > 34) continue;
-      if (Math.random() < 0.3 && height > 22) continue;
-
-      const scale = this.randomRange(0.75, 1.75);
-      dummy.position.set(x, height + (2.4 * scale) / 2, z);
-      dummy.rotation.set(0, this.randomRange(0, Math.PI * 2), 0);
-      dummy.scale.set(scale, scale, scale);
-      dummy.updateMatrix();
-      trunks.setMatrixAt(placed, dummy.matrix);
-
-      dummy.position.set(x, height + 2.8 * scale, z);
-      dummy.rotation.set(0, this.randomRange(0, Math.PI * 2), 0);
-      dummy.scale.set(scale * 1.18, scale * 1.24, scale * 1.18);
-      dummy.updateMatrix();
-      canopies.setMatrixAt(placed, dummy.matrix);
-      placed += 1;
+      if (height < 2 || height > 60) continue;
+
+      // Conifers prefer higher elevations, broadleaf prefer lower
+      const isConifer = height > 25 || Math.random() > 0.4;
+      const scale = this.randomRange(0.6, 1.8) * (isConifer ? 1.1 : 0.9);
+
+      if (isConifer) {
+        // Conifer tree
+        dummy.position.set(x, height + (2.2 * scale) / 2, z);
+        dummy.rotation.set(0, this.randomRange(0, Math.PI * 2), 0);
+        dummy.scale.set(scale, scale, scale);
+        dummy.updateMatrix();
+        trunks.setMatrixAt(placedConifers, dummy.matrix);
+
+        dummy.position.set(x, height + 2.6 * scale, z);
+        dummy.scale.set(scale * 1.1, scale * 1.2, scale * 1.1);
+        dummy.updateMatrix();
+        canopies.setMatrixAt(placedConifers, dummy.matrix);
+        placedConifers++;
+      } else {
+        // Broadleaf tree
+        dummy.position.set(x, height + (2.2 * scale) / 2, z);
+        dummy.rotation.set(0, this.randomRange(0, Math.PI * 2), 0);
+        dummy.scale.set(scale * 0.8, scale, scale * 0.8);
+        dummy.updateMatrix();
+        trunks.setMatrixAt(maxTrees - 1 - placedBroad, dummy.matrix);
+
+        dummy.position.set(x, height + 2.8 * scale, z);
+        dummy.scale.set(scale * 0.9, scale * 0.7, scale * 0.9);
+        dummy.updateMatrix();
+        broadCanopies.setMatrixAt(placedBroad, dummy.matrix);
+        placedBroad++;
+      }
     }
 
-    trunks.count = placed;
-    canopies.count = placed;
+    trunks.count = placedConifers + placedBroad;
+    canopies.count = placedConifers;
+    broadCanopies.count = placedBroad;
     trunks.instanceMatrix.needsUpdate = true;
     canopies.instanceMatrix.needsUpdate = true;
+    broadCanopies.instanceMatrix.needsUpdate = true;
     this.scene.add(trunks);
     this.scene.add(canopies);
+    this.scene.add(broadCanopies);
   }
 
   createLake() {
-    let lowestSpot = { x: 360, z: -420, h: this.getTerrainHeight(360, -420) };
-    for (let i = 0; i < 260; i++) {
-      const x = this.randomRange(-900, 900);
-      const z = this.randomRange(-900, 900);
-      if (Math.sqrt(x * x + z * z) < 260) continue;
+    // Find the lowest spot for the lake
+    let lowestSpot = { x: 400, z: -450, h: this.getTerrainHeight(400, -450) };
+    for (let i = 0; i < 300; i++) {
+      const x = this.randomRange(-1000, 1000);
+      const z = this.randomRange(-1000, 1000);
+      if (Math.sqrt(x * x + z * z) < 280) continue;
       const h = this.getTerrainHeight(x, z);
       if (h < lowestSpot.h) {
         lowestSpot = { x, z, h };
       }
     }
 
-    const lakeRadius = 160;
-    const waterLevel = lowestSpot.h + 0.55;
+    const lakeRadius = 180;
+    const waterLevel = lowestSpot.h + 1.2;
 
-    // Highly reflective premium water material matching sunset
+    // Main lake water with reflective material
     const lakeMaterial = new THREE.MeshStandardMaterial({
-      color: 0xff7766,
-      emissive: 0x5a1835,
-      emissiveIntensity: 0.2,
-      roughness: 0.05,
-      metalness: 0.95,
+      color: 0x4a8090,
+      emissive: 0x1a3040,
+      emissiveIntensity: 0.15,
+      roughness: 0.08,
+      metalness: 0.9,
       transparent: true,
-      opacity: 0.85,
+      opacity: 0.88,
       flatShading: true
     });
 
     const lake = new THREE.Mesh(
-      new THREE.CircleGeometry(lakeRadius, 72),
+      new THREE.CircleGeometry(lakeRadius, 64),
       lakeMaterial
     );
     lake.rotation.x = -Math.PI / 2;
@@ -869,19 +1088,74 @@ class FlightSimulator {
     lake.receiveShadow = true;
     this.scene.add(lake);
 
+    // Lake shore with beach
     const shore = new THREE.Mesh(
-      new THREE.RingGeometry(lakeRadius, lakeRadius + 12, 72),
+      new THREE.RingGeometry(lakeRadius, lakeRadius + 18, 64),
       new THREE.MeshStandardMaterial({
-        color: 0x4a5d3f,
-        roughness: 0.95,
+        color: 0x6a7a5a,
+        roughness: 0.92,
         metalness: 0,
         flatShading: true
       })
     );
     shore.rotation.x = -Math.PI / 2;
-    shore.position.set(lowestSpot.x, waterLevel - 0.01, lowestSpot.z);
+    shore.position.set(lowestSpot.x, waterLevel - 0.02, lowestSpot.z);
     shore.receiveShadow = true;
     this.scene.add(shore);
+
+    // Create rivers flowing into the lake from higher elevations
+    const riverCount = 3;
+    const riverMaterial = new THREE.MeshStandardMaterial({
+      color: 0x3a7080,
+      roughness: 0.15,
+      metalness: 0.7,
+      transparent: true,
+      opacity: 0.85,
+      flatShading: true
+    });
+
+    for (let r = 0; r < riverCount; r++) {
+      // Start river from a random high point
+      const startAngle = (r / riverCount) * Math.PI * 2 + this.randomRange(-0.5, 0.5);
+      const startRadius = this.randomRange(600, 900);
+      let currentX = Math.cos(startAngle) * startRadius;
+      let currentZ = Math.sin(startAngle) * startRadius;
+
+      // Flow towards lake
+      const riverPoints = [];
+      const maxPoints = 60;
+      for (let i = 0; i < maxPoints; i++) {
+        const height = this.getTerrainHeight(currentX, currentZ);
+        riverPoints.push(new THREE.Vector3(currentX, height + 0.3, currentZ));
+
+        // Move towards lake with some wandering
+        const toLakeX = lowestSpot.x - currentX;
+        const toLakeZ = lowestSpot.z - currentZ;
+        const distToLake = Math.sqrt(toLakeX * toLakeX + toLakeZ * toLakeZ);
+
+        if (distToLake < lakeRadius + 20) break;
+
+        // Flow downhill with some meandering
+        const wander = this.randomRange(-0.4, 0.4);
+        currentX += (toLakeX / distToLake) * 25 + wander * 15;
+        currentZ += (toLakeZ / distToLake) * 25 + wander * 15;
+      }
+
+      // Create river as a tube
+      if (riverPoints.length >= 2) {
+        const curve = new THREE.CatmullRomCurve3(riverPoints);
+        const riverWidth = this.randomRange(8, 14);
+        const tubeGeom = new THREE.TubeGeometry(curve, riverPoints.length * 2, riverWidth, 6, false);
+        const river = new THREE.Mesh(tubeGeom, riverMaterial);
+        river.receiveShadow = true;
+        this.scene.add(river);
+      }
+    }
+
+    // Store lake info for other systems
+    this.lakePosition = lowestSpot;
+    this.lakeRadius = lakeRadius;
+    this.lakeWaterLevel = waterLevel;
   }
 
   randomRange(min, max) {