Update index.html

index.html

@@ -354,6 +354,11 @@
                 this.targetLane = null;
                 this.lanePosition = 0; // -1 to 1 within lane
                 
+                // Road transition tracking
+                this.lastRoadPosition = 0;
+                this.isTransitioningToRoad = false;
+                this.roadTransitionTime = 0;
+                
                 // Convoy and flock behavior
                 this.flockId = -1;
                 this.convoyPosition = -1; // Position in convoy (-1 = not in convoy)
@@ -362,10 +367,19 @@
                 this.followTarget = null;
                 this.role = 'driver'; // driver, leader, parker
                 
-                // Traffic behavior
+                // Enhanced parking system
                 this.isParked = false;
                 this.parkingSpot = null;
                 this.targetParkingLot = null;
+                this.parkingQueue = -1; // Position in parking queue (-1 = not queued)
+                this.isParkingApproach = false;
+                this.isInApproachLane = false;
+                this.isInExitLane = false;
+                this.approachTarget = null;
+                this.exitTarget = null;
+                this.parkingAttempts = 0;
+                this.maxParkingAttempts = 3;
+                this.departureTime = 0;
                 this.turnSignal = 'none'; // left, right, none
                 this.laneDiscipline = 0;
                 this.followingDistance = FOLLOW_DISTANCE;
@@ -510,37 +524,174 @@
                 let nearestRoad = null;
                 let minDistance = Infinity;
                 
-                // Check horizontal roads
-                for (let roadZ = -300; roadZ <= 300; roadZ += ROAD_SPACING) {
-                    const distToRoad = Math.abs(pos.z - roadZ);
-                    if (distToRoad < ROAD_WIDTH / 2 && distToRoad < minDistance) {
-                        minDistance = distToRoad;
-                        const laneCenter = roadZ + (pos.x > 0 ? -LANE_WIDTH/2 : LANE_WIDTH/2);
+                // Check major highways (8 lanes - 48 units wide)
+                const mainHighwayPositions = [0]; // Main cross highways
+                mainHighwayPositions.forEach(roadPos => {
+                    // Horizontal highway
+                    const distToHorizontal = Math.abs(pos.z - roadPos);
+                    if (distToHorizontal < 24 && distToHorizontal < minDistance) {
+                        minDistance = distToHorizontal;
+                        const laneCenter = roadPos + (pos.x > 0 ? -12 : 12); // 4 lanes each direction
                         nearestRoad = {
-                            lane: 'horizontal',
+                            lane: 'highway_horizontal',
                             center: laneCenter,
-                            direction: pos.x > 0 ? Math.PI : 0 // Left side driving
+                            direction: pos.x > 0 ? Math.PI : 0,
+                            width: 48
+                        };
+                    }
+                    
+                    // Vertical highway
+                    const distToVertical = Math.abs(pos.x - roadPos);
+                    if (distToVertical < 24 && distToVertical < minDistance) {
+                        minDistance = distToVertical;
+                        const laneCenter = roadPos + (pos.z > 0 ? -12 : 12);
+                        nearestRoad = {
+                            lane: 'highway_vertical',
+                            center: laneCenter,
+                            direction: pos.z > 0 ? -Math.PI/2 : Math.PI/2,
+                            width: 48
+                        };
+                    }
+                });
+                
+                // Check secondary highways (4 lanes - 24 units wide)
+                for (let roadPos = -300; roadPos <= 300; roadPos += 150) {
+                    if (roadPos === 0) continue; // Skip main highway
+                    
+                    const distToHorizontal = Math.abs(pos.z - roadPos);
+                    if (distToHorizontal < 12 && distToHorizontal < minDistance) {
+                        minDistance = distToHorizontal;
+                        const laneCenter = roadPos + (pos.x > 0 ? -6 : 6);
+                        nearestRoad = {
+                            lane: 'secondary_horizontal',
+                            center: laneCenter,
+                            direction: pos.x > 0 ? Math.PI : 0,
+                            width: 24
+                        };
+                    }
+                    
+                    const distToVertical = Math.abs(pos.x - roadPos);
+                    if (distToVertical < 12 && distToVertical < minDistance) {
+                        minDistance = distToVertical;
+                        const laneCenter = roadPos + (pos.z > 0 ? -6 : 6);
+                        nearestRoad = {
+                            lane: 'secondary_vertical',
+                            center: laneCenter,
+                            direction: pos.z > 0 ? -Math.PI/2 : Math.PI/2,
+                            width: 24
                         };
                     }
                 }
                 
-                // Check vertical roads
-                for (let roadX = -300; roadX <= 300; roadX += ROAD_SPACING) {
-                    const distToRoad = Math.abs(pos.x - roadX);
-                    if (distToRoad < ROAD_WIDTH / 2 && distToRoad < minDistance) {
-                        minDistance = distToRoad;
-                        const laneCenter = roadX + (pos.z > 0 ? -LANE_WIDTH/2 : LANE_WIDTH/2);
+                // Check local roads (2 lanes - 12 units wide)
+                for (let roadPos = -375; roadPos <= 375; roadPos += 75) {
+                    const distToHorizontal = Math.abs(pos.z - roadPos);
+                    if (distToHorizontal < 6 && distToHorizontal < minDistance) {
+                        minDistance = distToHorizontal;
+                        const laneCenter = roadPos + (pos.x > 0 ? -3 : 3);
                         nearestRoad = {
-                            lane: 'vertical',
+                            lane: 'local_horizontal',
+                            center: laneCenter,
+                            direction: pos.x > 0 ? Math.PI : 0,
+                            width: 12
+                        };
+                    }
+                    
+                    const distToVertical = Math.abs(pos.x - roadPos);
+                    if (distToVertical < 6 && distToVertical < minDistance) {
+                        minDistance = distToVertical;
+                        const laneCenter = roadPos + (pos.z > 0 ? -3 : 3);
+                        nearestRoad = {
+                            lane: 'local_vertical',
                             center: laneCenter,
-                            direction: pos.z > 0 ? -Math.PI/2 : Math.PI/2 // Left side driving
+                            direction: pos.z > 0 ? -Math.PI/2 : Math.PI/2,
+                            width: 12
                         };
                     }
                 }
                 
+                // Check building access roads (less precise matching)
+                if (!nearestRoad || minDistance > 8) {
+                    world.buildings.forEach(building => {
+                        const buildingPos = building.mesh.position;
+                        const buildingBox = new THREE.Box3().setFromObject(building.mesh);
+                        const size = buildingBox.getSize(new THREE.Vector3());
+                        
+                        // Check proximity to building access roads
+                        const accessRoadPositions = [
+                            { x: buildingPos.x, z: buildingPos.z + size.z/2 + 10, dir: 'horizontal' },
+                            { x: buildingPos.x, z: buildingPos.z - size.z/2 - 10, dir: 'horizontal' },
+                            { x: buildingPos.x + size.x/2 + 10, z: buildingPos.z, dir: 'vertical' },
+                            { x: buildingPos.x - size.x/2 - 10, z: buildingPos.z, dir: 'vertical' }
+                        ];
+                        
+                        accessRoadPositions.forEach(accessRoad => {
+                            const dist = pos.distanceTo(new THREE.Vector3(accessRoad.x, 0, accessRoad.z));
+                            if (dist < 8 && dist < minDistance) {
+                                minDistance = dist;
+                                nearestRoad = {
+                                    lane: `access_${accessRoad.dir}`,
+                                    center: accessRoad.dir === 'horizontal' ? accessRoad.z : accessRoad.x,
+                                    direction: accessRoad.dir === 'horizontal' ? 
+                                        (pos.x > accessRoad.x ? Math.PI : 0) : 
+                                        (pos.z > accessRoad.z ? -Math.PI/2 : Math.PI/2),
+                                    width: 8
+                                };
+                            }
+                        });
+                    });
+                }
+                
                 return nearestRoad;
             }
             
+            getRoadPosition() {
+                const pos = this.mesh.position;
+                let maxRoadScore = 0;
+                
+                // Check all road types for best road position score
+                
+                // Major highways
+                const mainHighwayDist = Math.abs(pos.z);
+                if (mainHighwayDist <= 24) {
+                    maxRoadScore = Math.max(maxRoadScore, 1 - (mainHighwayDist / 24));
+                }
+                const mainVerticalDist = Math.abs(pos.x);
+                if (mainVerticalDist <= 24) {
+                    maxRoadScore = Math.max(maxRoadScore, 1 - (mainVerticalDist / 24));
+                }
+                
+                // Secondary highways
+                for (let roadPos = -300; roadPos <= 300; roadPos += 150) {
+                    if (roadPos === 0) continue;
+                    
+                    const hDist = Math.abs(pos.z - roadPos);
+                    if (hDist <= 12) {
+                        maxRoadScore = Math.max(maxRoadScore, 1 - (hDist / 12));
+                    }
+                    
+                    const vDist = Math.abs(pos.x - roadPos);
+                    if (vDist <= 12) {
+                        maxRoadScore = Math.max(maxRoadScore, 1 - (vDist / 12));
+                    }
+                }
+                
+                // Local roads
+                for (let roadPos = -375; roadPos <= 375; roadPos += 75) {
+                    const hDist = Math.abs(pos.z - roadPos);
+                    if (hDist <= 6) {
+                        maxRoadScore = Math.max(maxRoadScore, 1 - (hDist / 6));
+                    }
+                    
+                    const vDist = Math.abs(pos.x - roadPos);
+                    if (vDist <= 6) {
+                        maxRoadScore = Math.max(maxRoadScore, 1 - (vDist / 6));
+                    }
+                }
+                
+                return maxRoadScore;
+            }
+            
             updateSensors() {
                 const maxDistance = 10;
                 const raycaster = new THREE.Raycaster();
@@ -746,11 +897,108 @@
                     }
                 });
                 
+                // Calculate flock centroid and check if moving away
+                this.updateFlockCohesion();
+                
                 // Determine role and convoy behavior
                 this.updateRole();
                 this.updateConvoyFormation();
             }
             
+            updateFlockCohesion() {
+                if (this.neighbors.length === 0) return;
+                
+                // Calculate flock centroid
+                const centroid = new THREE.Vector3();
+                this.neighbors.forEach(neighbor => {
+                    centroid.add(neighbor.mesh.position);
+                });
+                centroid.divideScalar(this.neighbors.length);
+                
+                // Check if moving away from centroid
+                const currentPos = this.mesh.position.clone();
+                const futurePos = currentPos.clone().add(this.velocity.clone().normalize().multiplyScalar(5));
+                
+                const currentDistToCentroid = currentPos.distanceTo(centroid);
+                const futureDistToCentroid = futurePos.distanceTo(centroid);
+                
+                // If moving away from flock, apply gentle correction
+                if (futureDistToCentroid > currentDistToCentroid && currentDistToCentroid > 15) {
+                    const returnForce = centroid.clone().sub(currentPos).normalize().multiplyScalar(0.3);
+                    this.velocity.add(returnForce);
+                    
+                    // Gentle turning toward centroid
+                    const targetDirection = Math.atan2(returnForce.x, returnForce.z);
+                    const currentDirection = Math.atan2(this.velocity.x, this.velocity.z);
+                    let angleDiff = targetDirection - currentDirection;
+                    
+                    while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
+                    while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
+                    
+                    // Apply gentle turning
+                    this.mesh.rotation.y += angleDiff * 0.02;
+                    
+                    // Slow down for turning
+                    this.velocity.multiplyScalar(0.98);
+                }
+                
+                // Move flock centroid toward roads
+                this.guideFlockToRoads(centroid);
+            }
+            
+            guideFlockToRoads(centroid) {
+                if (this.role !== 'leader') return;
+                
+                // Find nearest road from centroid
+                const nearestRoadInfo = this.findNearestRoadFromPosition(centroid);
+                if (!nearestRoadInfo) return;
+                
+                const roadDistance = nearestRoadInfo.distance;
+                if (roadDistance > 5) {
+                    // Guide flock toward road
+                    const roadDirection = nearestRoadInfo.direction;
+                    const roadForce = roadDirection.clone().multiplyScalar(0.2);
+                    this.velocity.add(roadForce);
+                }
+            }
+            
+            findNearestRoadFromPosition(position) {
+                let nearestRoad = null;
+                let minDistance = Infinity;
+                
+                // Check horizontal roads
+                for (let roadZ = -300; roadZ <= 300; roadZ += ROAD_SPACING) {
+                    const distToRoad = Math.abs(position.z - roadZ);
+                    if (distToRoad < minDistance) {
+                        minDistance = distToRoad;
+                        const direction = new THREE.Vector3(0, 0, roadZ - position.z).normalize();
+                        nearestRoad = {
+                            distance: distToRoad,
+                            direction: direction,
+                            lane: 'horizontal',
+                            center: roadZ
+                        };
+                    }
+                }
+                
+                // Check vertical roads
+                for (let roadX = -300; roadX <= 300; roadX += ROAD_SPACING) {
+                    const distToRoad = Math.abs(position.x - roadX);
+                    if (distToRoad < minDistance) {
+                        minDistance = distToRoad;
+                        const direction = new THREE.Vector3(roadX - position.x, 0, 0).normalize();
+                        nearestRoad = {
+                            distance: distToRoad,
+                            direction: direction,
+                            lane: 'vertical',
+                            center: roadX
+                        };
+                    }
+                }
+                
+                return nearestRoad;
+            }
+            
             updateRole() {
                 const roadPos = this.getRoadPosition();
                 
@@ -801,11 +1049,19 @@
             }
             
             update(deltaTime) {
-                if (this.crashed || this.isParked) return;
+                // Handle parked cars separately
+                if (this.isParked) {
+                    this.handleParkedBehavior(deltaTime);
+                    return;
+                }
+                
+                if (this.crashed) return;
                 
                 this.timeAlive -= deltaTime;
-                if (this.timeAlive <= 0) {
-                    this.attemptParking();
+                if (this.timeAlive <= 0 || this.parkingAttempts >= this.maxParkingAttempts) {
+                    if (!this.isParkingApproach) {
+                        this.attemptParking();
+                    }
                     return;
                 }
                 
@@ -897,17 +1153,38 @@
             
             followRoad(deltaTime) {
                 const roadInfo = this.findNearestRoad();
+                const currentRoadPos = this.getRoadPosition();
+                
+                // Check if transitioning from grass to road
+                if (currentRoadPos > 0.3 && this.lastRoadPosition <= 0.3) {
+                    // Just touched road after being on grass - slow down
+                    this.velocity.multiplyScalar(0.7);
+                    this.isTransitioningToRoad = true;
+                    this.roadTransitionTime = 2.0; // 2 seconds to stabilize
+                }
+                
+                if (this.roadTransitionTime > 0) {
+                    this.roadTransitionTime -= deltaTime;
+                    // Maintain slower speed during transition
+                    const currentSpeed = this.velocity.length();
+                    if (currentSpeed > this.maxSpeed * 0.6) {
+                        this.velocity.normalize().multiplyScalar(this.maxSpeed * 0.6);
+                    }
+                }
+                
+                this.lastRoadPosition = currentRoadPos;
+                
                 if (!roadInfo) return;
                 
-                // Lane-keeping force
+                // Enhanced lane-keeping force
                 const laneKeepingForce = this.brain.trafficTraits.laneKeeping;
                 let targetDirection = roadInfo.direction;
                 
-                // Adjust for lane position
+                // Adjust for lane position with stronger correction
                 if (roadInfo.lane === 'horizontal') {
                     const laneOffset = this.mesh.position.z - roadInfo.center;
                     if (Math.abs(laneOffset) > LANE_WIDTH / 4) {
-                        const correction = -laneOffset * 0.02 * laneKeepingForce;
+                        const correction = -laneOffset * 0.05 * laneKeepingForce;
                         this.velocity.z += correction;
                         if (Math.abs(laneOffset) > LANE_WIDTH / 2) {
                             this.trafficViolations++;
@@ -917,7 +1194,7 @@
                 } else {
                     const laneOffset = this.mesh.position.x - roadInfo.center;
                     if (Math.abs(laneOffset) > LANE_WIDTH / 4) {
-                        const correction = -laneOffset * 0.02 * laneKeepingForce;
+                        const correction = -laneOffset * 0.05 * laneKeepingForce;
                         this.velocity.x += correction;
                         if (Math.abs(laneOffset) > LANE_WIDTH / 2) {
                             this.trafficViolations++;
@@ -926,14 +1203,14 @@
                     }
                 }
                 
-                // Direction alignment
+                // Stronger direction alignment for road following
                 const currentDirection = Math.atan2(this.velocity.x, this.velocity.z);
                 let angleDiff = targetDirection - currentDirection;
                 while (angleDiff > Math.PI) angleDiff -= 2 * Math.PI;
                 while (angleDiff < -Math.PI) angleDiff += 2 * Math.PI;
                 
                 if (Math.abs(angleDiff) > 0.1) {
-                    this.mesh.rotation.y += angleDiff * 0.05 * laneKeepingForce;
+                    this.mesh.rotation.y += angleDiff * 0.08 * laneKeepingForce;
                 }
                 
                 this.roadTime += deltaTime;
@@ -971,48 +1248,204 @@
             }
             
             executeParking(deltaTime) {
+                if (!this.targetParkingLot) {
+                    this.findNearestParkingLot();
+                    return;
+                }
+                
+                // Enhanced parking state machine
+                if (this.parkingQueue === -1) {
+                    this.joinParkingQueue();
+                }
+                
+                if (this.isInApproachLane) {
+                    this.handleApproachLane(deltaTime);
+                } else if (this.canProceedToApproach()) {
+                    this.enterApproachLane(deltaTime);
+                } else {
+                    this.waitForApproachAccess(deltaTime);
+                }
+            }
+            
+            joinParkingQueue() {
                 if (!this.targetParkingLot) return;
                 
-                // Find available parking spot
+                if (!this.targetParkingLot.queue) {
+                    this.targetParkingLot.queue = [];
+                }
+                
+                if (!this.targetParkingLot.queue.includes(this)) {
+                    this.targetParkingLot.queue.push(this);
+                    this.parkingQueue = this.targetParkingLot.queue.length - 1;
+                }
+            }
+            
+            canProceedToApproach() {
+                if (!this.targetParkingLot || !this.targetParkingLot.queue) return false;
+                
+                const queuePosition = this.targetParkingLot.queue.indexOf(this);
+                
+                // Check if there's space in approach lane
+                const approachLaneOccupancy = population.filter(car => 
+                    car.isInApproachLane && car.targetParkingLot === this.targetParkingLot
+                ).length;
+                
+                return queuePosition < 3 && approachLaneOccupancy < this.targetParkingLot.approachLane.length;
+            }
+            
+            enterApproachLane(deltaTime) {
+                // Find first available approach lane position
+                const approachPositions = this.targetParkingLot.approachLane;
+                let targetPosition = null;
+                
+                for (let i = 0; i < approachPositions.length; i++) {
+                    const pos = approachPositions[i];
+                    const occupied = population.some(car => 
+                        car !== this && 
+                        car.isInApproachLane && 
+                        car.mesh.position.distanceTo(pos) < 3
+                    );
+                    
+                    if (!occupied) {
+                        targetPosition = pos;
+                        break;
+                    }
+                }
+                
+                if (targetPosition) {
+                    this.isInApproachLane = true;
+                    this.approachTarget = targetPosition;
+                    this.moveToPosition(targetPosition, deltaTime, 4); // Slow approach
+                }
+            }
+            
+            handleApproachLane(deltaTime) {
+                // Check if we can proceed to actual parking
                 const availableSpot = this.targetParkingLot.spots.find(spot => !spot.occupied);
-                if (!availableSpot) return;
-                
-                const spotPos = availableSpot.position;
-                const distance = this.mesh.position.distanceTo(spotPos);
-                
-                if (distance < 2) {
-                    // Park successfully
-                    this.isParked = true;
-                    this.parkingSpot = availableSpot;
-                    availableSpot.occupied = true;
-                    availableSpot.car = this;
-                    this.mesh.position.copy(spotPos);
-                    this.velocity.set(0, 0, 0);
-                    this.parkingScore += 100;
-                    parkingEvents++;
-                    this.updateCarColor();
+                if (!availableSpot) {
+                    // Wait in approach lane
+                    this.velocity.multiplyScalar(0.95);
+                    return;
+                }
+                
+                const spotDistance = this.mesh.position.distanceTo(availableSpot.position);
+                
+                if (spotDistance < 3) {
+                    // Successfully park
+                    this.completeParkingProcess(availableSpot);
                 } else {
-                    // Move toward parking spot
-                    const direction = spotPos.clone().sub(this.mesh.position).normalize();
-                    this.velocity.copy(direction.multiplyScalar(5));
+                    // Move toward spot
+                    this.moveToPosition(availableSpot.position, deltaTime, 2);
+                }
+            }
+            
+            completeParkingProcess(spot) {
+                this.isParked = true;
+                this.parkingSpot = spot;
+                spot.occupied = true;
+                spot.car = this;
+                this.mesh.position.copy(spot.position);
+                this.velocity.set(0, 0, 0);
+                this.parkingScore += 100;
+                this.leaveParkingQueue();
+                this.isInApproachLane = false;
+                
+                parkingEvents++;
+                
+                this.departureTime = 15 + Math.random() * 25;
+                this.updateCarColor();
+            }
+            
+            waitForApproachAccess(deltaTime) {
+                // Line up end-to-end near parking lot
+                const queuePosition = Math.min(this.parkingQueue, 5);
+                const queueTarget = this.targetParkingLot.center.clone();
+                queueTarget.add(new THREE.Vector3(-50, 0, -15 + queuePosition * 5)); // 5m spacing
+                
+                this.moveToPosition(queueTarget, deltaTime, 3);
+            }
+            
+            moveToPosition(targetPos, deltaTime, speed) {
+                const direction = targetPos.clone().sub(this.mesh.position);
+                const distance = direction.length();
+                
+                if (distance > 1) {
+                    direction.normalize();
+                    this.velocity.copy(direction.multiplyScalar(speed));
                     this.mesh.position.add(this.velocity.clone().multiplyScalar(deltaTime));
                     
-                    // Align with parking spot
+                    // Align rotation with movement
                     const targetAngle = Math.atan2(direction.x, direction.z);
                     this.mesh.rotation.y = targetAngle;
+                } else {
+                    this.velocity.multiplyScalar(0.9);
+                }
+            }
+            
+            leaveParking() {
+                if (!this.isParked || !this.parkingSpot) return;
+                
+                // Free the parking spot
+                this.parkingSpot.occupied = false;
+                this.parkingSpot.car = null;
+                this.parkingSpot = null;
+                this.isParked = false;
+                this.isInApproachLane = false;
+                
+                // Use exit lane for organized departure
+                this.useExitLane();
+            }
+            
+            useExitLane() {
+                // Find exit lane position
+                const exitPositions = this.targetParkingLot.exitLane;
+                let exitTarget = null;
+                
+                for (let i = 0; i < exitPositions.length; i++) {
+                    const pos = exitPositions[i];
+                    const occupied = population.some(car => 
+                        car !== this && 
+                        car.mesh.position.distanceTo(pos) < 4
+                    );
+                    
+                    if (!occupied) {
+                        exitTarget = pos;
+                        break;
+                    }
+                }
+                
+                if (exitTarget) {
+                    this.isInExitLane = true;
+                    this.exitTarget = exitTarget;
+                    this.mesh.position.copy(exitTarget);
+                    
+                    // Set exit velocity
+                    const exitDirection = new THREE.Vector3(0, 0, 1); // Move south to exit
+                    this.velocity.copy(exitDirection.multiplyScalar(6));
+                    
+                    // Schedule exit lane departure
+                    setTimeout(() => {
+                        this.isInExitLane = false;
+                        this.role = 'driver';
+                        this.timeAlive = 50 + Math.random() * 30;
+                        this.updateCarColor();
+                    }, 2000);
                 }
             }
             
             attemptParking() {
+                this.role = 'parker';
+                this.findNearestParkingLot();
+                
                 if (!this.targetParkingLot) {
-                    this.crashed = true;
+                    // No parking available, become a wanderer
+                    this.timeAlive = 20;
+                    this.role = 'driver';
                     return;
                 }
                 
-                this.executeParking(0.016); // Try one more time
-                if (!this.isParked) {
-                    this.crashed = true;
-                }
+                // Start parking process
+                this.isParkingApproach = true;
             }
             
             updateFitness(deltaTime) {
@@ -1144,27 +1577,47 @@
             checkCollisions() {
                 const carBox = new THREE.Box3().setFromObject(this.mesh);
                 
+                // Modified collision behavior for parking areas
+                const isParkingMode = this.isInApproachLane || this.isInExitLane || 
+                                     this.isParkingApproach || this.role === 'parker';
+                
                 // Soft collision with other cars
                 population.forEach(otherCar => {
                     if (otherCar !== this && !otherCar.crashed && !otherCar.isParked) {
                         const otherBox = new THREE.Box3().setFromObject(otherCar.mesh);
-                        if (carBox.intersectsBox(otherBox)) {
+                        const distance = this.mesh.position.distanceTo(otherCar.mesh.position);
+                        
+                        // Relaxed collision detection for parking behavior
+                        const minDistance = isParkingMode || otherCar.isInApproachLane ? 2.5 : 4.0;
+                        const bothInParkingMode = isParkingMode && 
+                            (otherCar.isInApproachLane || otherCar.isParkingApproach || otherCar.role === 'parker');
+                        
+                        if (carBox.intersectsBox(otherBox) || (distance < minDistance && !bothInParkingMode)) {
+                            // Gentle separation instead of hard collision
                             const separation = new THREE.Vector3()
                                 .subVectors(this.mesh.position, otherCar.mesh.position)
-                                .normalize()
-                                .multiplyScalar(3);
-                            
-                            this.velocity.add(separation.multiplyScalar(0.3));
-                            otherCar.velocity.sub(separation.multiplyScalar(0.3));
+                                .normalize();
                             
-                            this.fitness -= 20;
-                            otherCar.fitness -= 20;
-                            this.trafficViolations++;
+                            if (isParkingMode) {
+                                // Very gentle separation for parking
+                                separation.multiplyScalar(1.5);
+                                this.velocity.add(separation.multiplyScalar(0.1));
+                                this.velocity.multiplyScalar(0.95); // Slow down
+                            } else {
+                                // Normal separation
+                                separation.multiplyScalar(3);
+                                this.velocity.add(separation.multiplyScalar(0.3));
+                                otherCar.velocity.sub(separation.multiplyScalar(0.3));
+                                
+                                this.fitness -= 10;
+                                otherCar.fitness -= 10;
+                                this.trafficViolations++;
+                            }
                         }
                     }
                 });
                 
-                // Building collisions
+                // Building collisions (unchanged)
                 world.buildings.forEach(building => {
                     const buildingBox = new THREE.Box3().setFromObject(building.mesh);
                     if (carBox.intersectsBox(buildingBox)) {
@@ -1191,11 +1644,16 @@
             }
             
             destroy() {
+                // Clean up parking spot
                 if (this.parkingSpot) {
                     this.parkingSpot.occupied = false;
                     this.parkingSpot.car = null;
                 }
                 
+                // Remove from parking queue
+                this.leaveParkingQueue();
+                
+                // Clean up visual elements
                 this.flockLines.forEach(line => {
                     if (line.parent) scene.remove(line);
                 });
@@ -1246,52 +1704,300 @@
         }
 
         function createTrafficWorld() {
-            // Ground
-            const groundGeometry = new THREE.PlaneGeometry(1000, 1000);
+            // Enhanced ground with road texture hints
+            const groundGeometry = new THREE.PlaneGeometry(1200, 1200);
             const groundMaterial = new THREE.MeshLambertMaterial({ color: 0x228B22 });
             const ground = new THREE.Mesh(groundGeometry, groundMaterial);
             ground.rotation.x = -Math.PI / 2;
             ground.receiveShadow = true;
             scene.add(ground);
             
+            // Create comprehensive road network first
             createRoadNetwork();
+            
+            // Then create buildings with parking lots
             createBuildingsWithParkingLots();
         }
 
         function createRoadNetwork() {
             const roadMaterial = new THREE.MeshLambertMaterial({ color: 0x444444 });
+            const highwayMaterial = new THREE.MeshLambertMaterial({ color: 0x333333 });
             const lineMaterial = new THREE.MeshLambertMaterial({ color: 0xffffff });
+            const yellowLineMaterial = new THREE.MeshLambertMaterial({ color: 0xffff00 });
+            
+            // Create comprehensive road network
+            
+            // 1. MAJOR HIGHWAYS (8 lanes) - Cross patterns
+            createHighway(-400, 400, 0, 'horizontal', 48, highwayMaterial, yellowLineMaterial); // North highway
+            createHighway(-400, 400, 0, 'vertical', 48, highwayMaterial, yellowLineMaterial);   // Main highway
+            
+            // 2. SECONDARY HIGHWAYS (4 lanes) - Grid system
+            for (let i = -300; i <= 300; i += 150) {
+                if (i !== 0) { // Don't overlap main highway
+                    createHighway(-400, 400, i, 'horizontal', 24, roadMaterial, yellowLineMaterial);
+                    createHighway(-400, 400, i, 'vertical', 24, roadMaterial, yellowLineMaterial);
+                }
+            }
             
-            // Create road grid
-            for (let i = -300; i <= 300; i += ROAD_SPACING) {
-                // Horizontal roads
-                const hRoadGeometry = new THREE.PlaneGeometry(600, ROAD_WIDTH);
-                const hRoad = new THREE.Mesh(hRoadGeometry, roadMaterial);
-                hRoad.rotation.x = -Math.PI / 2;
-                hRoad.position.set(0, 0.1, i);
-                scene.add(hRoad);
-                
-                // Lane dividers for horizontal roads
-                const hLineGeometry = new THREE.PlaneGeometry(600, 0.3);
-                const hLine = new THREE.Mesh(hLineGeometry, lineMaterial);
-                hLine.rotation.x = -Math.PI / 2;
-                hLine.position.set(0, 0.15, i);
-                scene.add(hLine);
-                
-                // Vertical roads
-                const vRoadGeometry = new THREE.PlaneGeometry(ROAD_WIDTH, 600);
-                const vRoad = new THREE.Mesh(vRoadGeometry, roadMaterial);
-                vRoad.rotation.x = -Math.PI / 2;
-                vRoad.position.set(i, 0.1, 0);
-                scene.add(vRoad);
-                
-                // Lane dividers for vertical roads
-                const vLineGeometry = new THREE.PlaneGeometry(0.3, 600);
-                const vLine = new THREE.Mesh(vLineGeometry, lineMaterial);
-                vLine.rotation.x = -Math.PI / 2;
-                vLine.position.set(i, 0.15, 0);
-                scene.add(vLine);
+            // 3. LOCAL ROADS (2 lanes) - Connecting roads
+            for (let i = -375; i <= 375; i += 75) {
+                createLocalRoad(-400, 400, i, 'horizontal', 12, roadMaterial, lineMaterial);
+                createLocalRoad(-400, 400, i, 'vertical', 12, roadMaterial, lineMaterial);
             }
+            
+            // 4. BUILDING ACCESS ROADS - Around all buildings
+            createBuildingAccessRoads();
+        }
+
+        function createHighway(start, end, position, direction, width, material, linemat) {
+            if (direction === 'horizontal') {
+                // Main road surface
+                const roadGeometry = new THREE.PlaneGeometry(end - start, width);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set((start + end) / 2, 0.1, position);
+                scene.add(road);
+                
+                // Lane dividers
+                const laneCount = width / 6; // 6 units per lane
+                for (let lane = 1; lane < laneCount; lane++) {
+                    const lineY = position - width/2 + (lane * 6);
+                    
+                    // Center divider (yellow)
+                    if (lane === Math.floor(laneCount / 2)) {
+                        createDashedLine(start, end, lineY, 'horizontal', linemat, true);
+                    } else {
+                        // Regular lane dividers (white)
+                        createDashedLine(start, end, lineY, 'horizontal', linemat, false);
+                    }
+                }
+            } else {
+                // Vertical highway
+                const roadGeometry = new THREE.PlaneGeometry(width, end - start);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set(position, 0.1, (start + end) / 2);
+                scene.add(road);
+                
+                // Lane dividers
+                const laneCount = width / 6; 
+                for (let lane = 1; lane < laneCount; lane++) {
+                    const lineX = position - width/2 + (lane * 6);
+                    
+                    if (lane === Math.floor(laneCount / 2)) {
+                        createDashedLine(start, end, lineX, 'vertical', linemat, true);
+                    } else {
+                        createDashedLine(start, end, lineX, 'vertical', linemat, false);
+                    }
+                }
+            }
+        }
+
+        function createLocalRoad(start, end, position, direction, width, material, linemat) {
+            if (direction === 'horizontal') {
+                const roadGeometry = new THREE.PlaneGeometry(end - start, width);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set((start + end) / 2, 0.1, position);
+                scene.add(road);
+                
+                // Center line
+                createDashedLine(start, end, position, 'horizontal', linemat, false);
+            } else {
+                const roadGeometry = new THREE.PlaneGeometry(width, end - start);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set(position, 0.1, (start + end) / 2);
+                scene.add(road);
+                
+                // Center line
+                createDashedLine(start, end, position, 'vertical', linemat, false);
+            }
+        }
+
+        function createDashedLine(start, end, position, direction, material, isDouble) {
+            const dashLength = 8;
+            const gapLength = 4;
+            const totalLength = end - start;
+            const segments = Math.floor(totalLength / (dashLength + gapLength));
+            
+            for (let i = 0; i < segments; i++) {
+                const segmentStart = start + i * (dashLength + gapLength);
+                
+                if (direction === 'horizontal') {
+                    const lineGeometry = new THREE.PlaneGeometry(dashLength, 0.3);
+                    const line = new THREE.Mesh(lineGeometry, material);
+                    line.rotation.x = -Math.PI / 2;
+                    line.position.set(segmentStart + dashLength/2, 0.12, position);
+                    scene.add(line);
+                    
+                    // Double line for highway center
+                    if (isDouble) {
+                        const line2 = new THREE.Mesh(lineGeometry, material);
+                        line2.rotation.x = -Math.PI / 2;
+                        line2.position.set(segmentStart + dashLength/2, 0.12, position + 1);
+                        scene.add(line2);
+                    }
+                } else {
+                    const lineGeometry = new THREE.PlaneGeometry(0.3, dashLength);
+                    const line = new THREE.Mesh(lineGeometry, material);
+                    line.rotation.x = -Math.PI / 2;
+                    line.position.set(position, 0.12, segmentStart + dashLength/2);
+                    scene.add(line);
+                    
+                    if (isDouble) {
+                        const line2 = new THREE.Mesh(lineGeometry, material);
+                        line2.rotation.x = -Math.PI / 2;
+                        line2.position.set(position + 1, 0.12, segmentStart + dashLength/2);
+                        scene.add(line2);
+                    }
+                }
+            }
+        }
+
+        function createBuildingAccessRoads() {
+            const accessRoadMaterial = new THREE.MeshLambertMaterial({ color: 0x555555 });
+            const lineMaterial = new THREE.MeshLambertMaterial({ color: 0xffffff });
+            
+            world.buildings.forEach((building, index) => {
+                const pos = building.mesh.position;
+                const buildingBox = new THREE.Box3().setFromObject(building.mesh);
+                const size = buildingBox.getSize(new THREE.Vector3());
+                
+                // Create access roads around each building (rectangular loop)
+                const roadWidth = 8;
+                const buffer = 5; // Distance from building
+                
+                // North road
+                createBuildingRoad(
+                    pos.x - size.x/2 - buffer - 10, 
+                    pos.x + size.x/2 + buffer + 10,
+                    pos.z + size.z/2 + buffer + roadWidth/2,
+                    'horizontal', roadWidth, accessRoadMaterial, lineMaterial
+                );
+                
+                // South road  
+                createBuildingRoad(
+                    pos.x - size.x/2 - buffer - 10,
+                    pos.x + size.x/2 + buffer + 10,
+                    pos.z - size.z/2 - buffer - roadWidth/2,
+                    'horizontal', roadWidth, accessRoadMaterial, lineMaterial
+                );
+                
+                // East road
+                createBuildingRoad(
+                    pos.x + size.x/2 + buffer + roadWidth/2,
+                    pos.z - size.z/2 - buffer - 10,
+                    pos.z + size.z/2 + buffer + 10,
+                    'vertical', roadWidth, accessRoadMaterial, lineMaterial
+                );
+                
+                // West road
+                createBuildingRoad(
+                    pos.x - size.x/2 - buffer - roadWidth/2,
+                    pos.z - size.z/2 - buffer - 10,
+                    pos.z + size.z/2 + buffer + 10,
+                    'vertical', roadWidth, accessRoadMaterial, lineMaterial
+                );
+                
+                // Connecting roads to main network
+                createConnectorRoads(pos, size, roadWidth, accessRoadMaterial);
+            });
+        }
+
+        function createBuildingRoad(startOrX, endOrStartZ, positionOrEndZ, direction, width, material, linemat) {
+            if (direction === 'horizontal') {
+                const roadGeometry = new THREE.PlaneGeometry(endOrStartZ - startOrX, width);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set((startOrX + endOrStartZ) / 2, 0.08, positionOrEndZ);
+                scene.add(road);
+                
+                // Center line
+                const lineGeometry = new THREE.PlaneGeometry(endOrStartZ - startOrX, 0.2);
+                const line = new THREE.Mesh(lineGeometry, linemat);
+                line.rotation.x = -Math.PI / 2;
+                line.position.set((startOrX + endOrStartZ) / 2, 0.1, positionOrEndZ);
+                scene.add(line);
+            } else {
+                const roadGeometry = new THREE.PlaneGeometry(width, positionOrEndZ - endOrStartZ);
+                const road = new THREE.Mesh(roadGeometry, material);
+                road.rotation.x = -Math.PI / 2;
+                road.position.set(startOrX, 0.08, (endOrStartZ + positionOrEndZ) / 2);
+                scene.add(road);
+                
+                // Center line
+                const lineGeometry = new THREE.PlaneGeometry(0.2, positionOrEndZ - endOrStartZ);
+                const line = new THREE.Mesh(lineGeometry, linemat);
+                line.rotation.x = -Math.PI / 2;
+                line.position.set(startOrX, 0.1, (endOrStartZ + positionOrEndZ) / 2);
+                scene.add(line);
+            }
+        }
+
+        function createConnectorRoads(buildingPos, buildingSize, roadWidth, material) {
+            // Connect building access roads to nearest main roads
+            const nearestMainRoads = findNearestMainRoads(buildingPos);
+            
+            nearestMainRoads.forEach(mainRoad => {
+                // Create connector from building to main road
+                const startPos = buildingPos.clone();
+                const endPos = mainRoad.position.clone();
+                
+                // Create straight connector road
+                const distance = startPos.distanceTo(endPos);
+                const direction = endPos.clone().sub(startPos).normalize();
+                
+                const connectorGeometry = new THREE.PlaneGeometry(roadWidth, distance);
+                const connector = new THREE.Mesh(connectorGeometry, material);
+                connector.rotation.x = -Math.PI / 2;
+                connector.rotation.z = Math.atan2(direction.x, direction.z);
+                connector.position.copy(startPos.clone().add(endPos).multiplyScalar(0.5));
+                connector.position.y = 0.08;
+                scene.add(connector);
+            });
+        }
+
+        function findNearestMainRoads(position) {
+            const mainRoads = [];
+            
+            // Find nearest horizontal main road
+            let nearestHorizontalDist = Infinity;
+            let nearestHorizontalZ = 0;
+            for (let z = -300; z <= 300; z += 150) {
+                const dist = Math.abs(position.z - z);
+                if (dist < nearestHorizontalDist) {
+                    nearestHorizontalDist = dist;
+                    nearestHorizontalZ = z;
+                }
+            }
+            
+            if (nearestHorizontalDist < 100) {
+                mainRoads.push({
+                    position: new THREE.Vector3(position.x, 0, nearestHorizontalZ),
+                    type: 'horizontal'
+                });
+            }
+            
+            // Find nearest vertical main road
+            let nearestVerticalDist = Infinity;
+            let nearestVerticalX = 0;
+            for (let x = -300; x <= 300; x += 150) {
+                const dist = Math.abs(position.x - x);
+                if (dist < nearestVerticalDist) {
+                    nearestVerticalDist = dist;
+                    nearestVerticalX = x;
+                }
+            }
+            
+            if (nearestVerticalDist < 100) {
+                mainRoads.push({
+                    position: new THREE.Vector3(nearestVerticalX, 0, position.z),
+                    type: 'vertical'
+                });
+            }
+            
+            return mainRoads.slice(0, 2); // Maximum 2 connections per building
         }
 
         function createBuildingsWithParkingLots() {
@@ -1301,22 +2007,24 @@
             const buildingMaterial = new THREE.MeshLambertMaterial({ color: 0x666666 });
             const parkingMaterial = new THREE.MeshLambertMaterial({ color: 0x333333 });
             const spotMaterial = new THREE.MeshLambertMaterial({ color: 0xffffff });
+            const queueMaterial = new THREE.MeshLambertMaterial({ color: 0x222222 });
             
-            // Create buildings at strategic locations
+            // Create buildings at strategic locations with better spacing
             const buildingLocations = [
-                { x: -75, z: -75 }, { x: 75, z: -75 },
-                { x: -75, z: 75 }, { x: 75, z: 75 },
-                { x: -225, z: -225 }, { x: 225, z: -225 },
-                { x: -225, z: 225 }, { x: 225, z: 225 },
-                { x: 0, z: -150 }, { x: 0, z: 150 },
-                { x: -150, z: 0 }, { x: 150, z: 0 }
+                { x: -200, z: -200 }, { x: 0, z: -200 }, { x: 200, z: -200 },
+                { x: -200, z: 0 }, { x: 200, z: 0 },
+                { x: -200, z: 200 }, { x: 0, z: 200 }, { x: 200, z: 200 },
+                { x: -100, z: -100 }, { x: 100, z: -100 },
+                { x: -100, z: 100 }, { x: 100, z: 100 },
+                { x: -300, z: -300 }, { x: 300, z: -300 },
+                { x: -300, z: 300 }, { x: 300, z: 300 }
             ];
             
-            buildingLocations.forEach(loc => {
+            buildingLocations.forEach((loc, index) => {
                 // Create building
-                const width = 25 + Math.random() * 15;
-                const height = 15 + Math.random() * 25;
-                const depth = 25 + Math.random() * 15;
+                const width = 20 + Math.random() * 10;
+                const height = 12 + Math.random() * 20;
+                const depth = 20 + Math.random() * 10;
                 
                 const buildingGeometry = new THREE.BoxGeometry(width, height, depth);
                 const building = new THREE.Mesh(buildingGeometry, buildingMaterial);
@@ -1326,24 +2034,61 @@
                 
                 world.buildings.push({ mesh: building });
                 
-                // Create large parking lot next to building
+                // Create enhanced parking lot with approach lanes
                 const parkingLot = {
-                    center: new THREE.Vector3(loc.x + width/2 + 20, 0.1, loc.z),
-                    spots: []
+                    center: new THREE.Vector3(loc.x + width/2 + 25, 0.1, loc.z),
+                    spots: [],
+                    queue: [],
+                    approachLane: [],
+                    exitLane: []
                 };
                 
-                // Parking lot ground
-                const lotGeometry = new THREE.PlaneGeometry(40, 30);
+                // Main parking lot surface (larger)
+                const lotGeometry = new THREE.PlaneGeometry(50, 40);
                 const lot = new THREE.Mesh(lotGeometry, parkingMaterial);
                 lot.rotation.x = -Math.PI / 2;
                 lot.position.copy(parkingLot.center);
                 scene.add(lot);
                 
-                // Create parking spots (4x6 grid = 24 spots)
-                for (let row = 0; row < 4; row++) {
-                    for (let col = 0; col < 6; col++) {
-                        const spotX = parkingLot.center.x + (col - 2.5) * 6;
-                        const spotZ = parkingLot.center.z + (row - 1.5) * 7;
+                // Approach lane (single file entry)
+                const approachGeometry = new THREE.PlaneGeometry(6, 60);
+                const approachLane = new THREE.Mesh(approachGeometry, queueMaterial);
+                approachLane.rotation.x = -Math.PI / 2;
+                approachLane.position.set(parkingLot.center.x - 30, 0.08, parkingLot.center.z);
+                scene.add(approachLane);
+                
+                // Exit lane (single file exit)
+                const exitGeometry = new THREE.PlaneGeometry(6, 60);
+                const exitLane = new THREE.Mesh(exitGeometry, queueMaterial);
+                exitLane.rotation.x = -Math.PI / 2;
+                exitLane.position.set(parkingLot.center.x + 30, 0.08, parkingLot.center.z);
+                scene.add(exitLane);
+                
+                // Create approach queue positions
+                for (let q = 0; q < 12; q++) {
+                    const queuePos = new THREE.Vector3(
+                        parkingLot.center.x - 30,
+                        1,
+                        parkingLot.center.z - 25 + (q * 4.5) // 4.5m spacing for tight queuing
+                    );
+                    parkingLot.approachLane.push(queuePos);
+                }
+                
+                // Create exit queue positions
+                for (let q = 0; q < 8; q++) {
+                    const exitPos = new THREE.Vector3(
+                        parkingLot.center.x + 30,
+                        1,
+                        parkingLot.center.z - 15 + (q * 4) // Tighter exit spacing
+                    );
+                    parkingLot.exitLane.push(exitPos);
+                }
+                
+                // Create parking spots (5x8 grid = 40 spots)
+                for (let row = 0; row < 5; row++) {
+                    for (let col = 0; col < 8; col++) {
+                        const spotX = parkingLot.center.x + (col - 3.5) * 6;
+                        const spotZ = parkingLot.center.z + (row - 2) * 7;
                         
                         // Spot marking
                         const spotGeometry = new THREE.PlaneGeometry(PARKING_SPOT_SIZE.width, PARKING_SPOT_SIZE.length);
@@ -1505,7 +2250,8 @@
                 totalParkingScore: 0,
                 totalViolations: 0,
                 totalFollowingDistance: 0,
-                followingCount: 0
+                followingCount: 0,
+                approaching: 0 // Cars approaching parking
             };
             
             population.forEach(car => {
@@ -1520,6 +2266,8 @@
                     
                     if (car.isParked) {
                         stats.parked++;
+                    } else if (car.isParkingApproach) {
+                        stats.approaching++;
                     } else if (car.role === 'leader') {
                         stats.leaders++;
                         stats.maxConvoySize = Math.max(stats.maxConvoySize, car.convoyFollowers.length + 1);
@@ -1677,12 +2425,15 @@
             parkingEvents = 0;
             laneViolations = 0;
             
-            // Reset parking lots
+            // Reset parking lots and queues
             world.parkingLots.forEach(lot => {
                 lot.spots.forEach(spot => {
                     spot.occupied = false;
                     spot.car = null;
                 });
+                lot.queue = []; // Clear parking queues
+                lot.approachLane = lot.approachLane || [];
+                lot.exitLane = lot.exitLane || [];
             });
             
             population.forEach(car => car.destroy());