Update index.html

index.html

@@ -371,7 +371,7 @@
                 
                 // Use the updated getRoadPropertiesAtZ function for consistent elevation
                 const { roadY: elevation_val } = getRoadPropertiesAtZ(worldZ);
-                vertices.setY(i, elevation_val); 
+                vertices.setY(i, elevation_val + 0.1); // Lift road surface slightly above base terrain
             }
             roadGeometry.attributes.position.needsUpdate = true; 
             roadGeometry.computeVertexNormals(); 
@@ -382,6 +382,24 @@
             road.receiveShadow = true;
             scene.add(road);
             
+            // Create thicker road base to prevent water clipping
+            const roadBaseGeometry = new THREE.BoxGeometry(roadWidth, 0.5, roadLength);
+            const roadBaseMaterial = new THREE.MeshStandardMaterial({ color: 0x444444, roughness: 0.9 });
+            const roadBase = new THREE.Mesh(roadBaseGeometry, roadBaseMaterial);
+            
+            // Position road base properly
+            const roadBaseVertices = roadBaseGeometry.attributes.position;
+            for (let i = 0; i < roadBaseVertices.count; i++) {
+                const localZ = roadBaseVertices.getZ(i);
+                const worldZ = localZ + roadLength / 2;
+                const { roadY } = getRoadPropertiesAtZ(worldZ);
+                roadBaseVertices.setY(i, roadBaseVertices.getY(i) + roadY - 0.2); // Position base below road surface
+            }
+            roadBaseGeometry.attributes.position.needsUpdate = true;
+            roadBase.position.z = roadLength / 2;
+            roadBase.receiveShadow = true;
+            scene.add(roadBase);
+            
             const centerLineGeometry = new THREE.PlaneGeometry(0.1, roadLength, 1, 200);
             centerLineGeometry.rotateX(-Math.PI / 2);
             
@@ -392,7 +410,7 @@
                 const curve_val = Math.sin(localZ * 0.005) * 15;
                 lineVertices.setX(i, lineVertices.getX(i) + curve_val);
                 const { roadY: elevation_val } = getRoadPropertiesAtZ(worldZ);
-                lineVertices.setY(i, elevation_val + 0.01); 
+                lineVertices.setY(i, elevation_val + 0.12); 
             }
             centerLineGeometry.attributes.position.needsUpdate = true;
             centerLineGeometry.computeVertexNormals();
@@ -550,8 +568,10 @@
             const car = new THREE.Mesh(new THREE.BoxGeometry(1.8,1,3.8), new THREE.MeshStandardMaterial({color:carColors[Math.floor(Math.random()*carColors.length)]}));
             car.castShadow = true;
             const {roadY,roadCurve} = getRoadPropertiesAtZ(worldZPosition);
+            
+            // Fix lane positioning - oncoming cars should be on player's right side
             const laneXOffset = isOncoming ? (roadWidth/4 + 0.25) : (-roadWidth/4 - 0.25);
-            car.position.set(roadCurve+laneXOffset, 1+roadY, worldZPosition); 
+            car.position.set(roadCurve + laneXOffset, 1+roadY, worldZPosition); 
             car.rotation.y = isOncoming ? Math.PI : 0; 
             scene.add(car);
             const headlightMat = new THREE.MeshBasicMaterial({color:0xFFFFFF});
@@ -855,8 +875,12 @@
             else { if(isGrounded)speed*=0.98; else speed*=0.995; if(Math.abs(speed)<0.05)speed=0; }
             
             if((keys[' ']||keys.j)&&isGrounded&&Math.abs(speed)>10){
-                jumpForce=1.2+Math.abs(speed)*0.06+suspensionCompression*6; // Increased base and scaling
-                velocity.y=jumpForce; isGrounded=false; showMessage("Jumping!",1);
+                // Speed-dependent jump height
+                jumpSpeed = Math.abs(speed); // Store speed when jumping
+                jumpForce = 0.8 + jumpSpeed * 0.04 + suspensionCompression * 6; // Reduced base jump
+                velocity.y = jumpForce; 
+                isGrounded = false; 
+                showMessage("Jumping!", 1);
             }
             
             speed=Math.max(-maxSpeed/2,Math.min(maxSpeed,speed));
@@ -898,7 +922,8 @@
                 if (distToRampZ < ramp.length / 2 && distToRampX < ramp.width / 2 && playerCar.position.y < ramp.mesh.position.y + ramp.height + carEffectiveRadius) {
                     onRamp = true;
                     if (!ramp.used && isGrounded) { // Only trigger jump once and if grounded
-                        velocity.y = ramp.height * 1.5 + Math.abs(speed) * 0.1; // Ramp jump force
+                        jumpSpeed = Math.abs(speed); // Store speed when hitting ramp
+                        velocity.y = ramp.height * 1.2 + jumpSpeed * 0.08; // Speed-dependent ramp jump
                         isGrounded = false;
                         ramp.used = true; // Mark ramp as used for this jump
                         showMessage("Ramp Jump!", 2);
@@ -909,7 +934,6 @@
                 }
             });
 
-
             if (isGrounded && !onRamp) { // Don't apply ground physics if on ramp and about to jump
                 const elevationChange = groundHeightAtCar - lastRoadY; 
                 suspensionCompression = -elevationChange * suspensionStrength; 
@@ -925,11 +949,24 @@
                     playerCar.position.y = groundHeightAtCar + carEffectiveRadius; 
                     isGrounded = true;
                     const impactForce = Math.abs(velocity.y);
-                    velocity.y = 0; airTime = 0;
-                    if (impactForce > 0.5) { // Increased threshold for damage
-                        decreaseHealth(Math.floor(impactForce*8),`Hard landing!`); // Reduced damage multiplier
+                    velocity.y = 0; 
+                    
+                    // Check for successful landing bonuses
+                    checkLandingBonus(impactForce);
+                    
+                    airTime = 0;
+                    // Speed-dependent landing damage
+                    const speedFactor = Math.max(0.3, jumpSpeed / 45); // Reduce damage for slower jumps
+                    const damageThreshold = 0.4 + (jumpSpeed / 45); // Higher threshold for faster jumps
+                    
+                    if (impactForce > damageThreshold) { 
+                        const damage = Math.floor(impactForce * 5 * speedFactor); // Much reduced damage
+                        decreaseHealth(damage, `Hard landing!`); 
                         suspensionCompression = Math.min(impactForce*0.2,0.4); 
-                    } else { suspensionCompression = Math.min(impactForce*0.1,0.1); }
+                    } else { 
+                        suspensionCompression = Math.min(impactForce*0.1,0.1); 
+                    }
+                    jumpSpeed = 0; // Reset jump speed after landing
                 }
             }
             lastRoadY = groundHeightAtCar;