Update index.html

index.html

@@ -377,6 +377,8 @@
                 this.isInExitLane = false;
                 this.approachTarget = null;
                 this.exitTarget = null;
+                this.selectedApproachLane = -1;
+                this.selectedExitLane = -1;
                 this.parkingAttempts = 0;
                 this.maxParkingAttempts = 3;
                 this.departureTime = 0;
@@ -1049,37 +1051,69 @@
             }
             
             update(deltaTime) {
-                // Handle parked cars separately
-                if (this.isParked) {
-                    this.handleParkedBehavior(deltaTime);
-                    return;
+                try {
+                    // Handle parked cars separately
+                    if (this.isParked) {
+                        this.handleParkedBehavior(deltaTime);
+                        return;
+                    }
+                    
+                    if (this.crashed) return;
+                    
+                    this.timeAlive -= deltaTime;
+                    if (this.timeAlive <= 0 || this.parkingAttempts >= this.maxParkingAttempts) {
+                        if (!this.isParkingApproach) {
+                            this.attemptParking();
+                        }
+                        return;
+                    }
+                    
+                    this.updateSensors();
+                    this.updateConvoyBehavior();
+                    this.updateVisuals();
+                    
+                    // Get AI decision
+                    const inputs = this.getEnhancedInputs();
+                    const outputs = this.brain.activate(inputs);
+                    
+                    // Apply traffic-aware movement
+                    this.applyTrafficMovement(outputs, deltaTime);
+                    this.updateFitness(deltaTime);
+                    
+                    this.lastPosition.copy(this.mesh.position);
+                    this.checkCollisions();
+                    this.keepInBounds();
+                } catch (error) {
+                    console.warn('Error in car update:', error);
+                    // Try to recover by resetting car state
+                    this.recoverFromError();
                 }
-                
-                if (this.crashed) return;
-                
-                this.timeAlive -= deltaTime;
-                if (this.timeAlive <= 0 || this.parkingAttempts >= this.maxParkingAttempts) {
-                    if (!this.isParkingApproach) {
-                        this.attemptParking();
+            }
+            
+            recoverFromError() {
+                try {
+                    // Reset to basic driving state
+                    this.role = 'driver';
+                    this.isParked = false;
+                    this.isParkingApproach = false;
+                    this.isInApproachLane = false;
+                    this.isInExitLane = false;
+                    this.parkingQueue = -1;
+                    this.convoyPosition = -1;
+                    this.convoyLeader = null;
+                    this.followTarget = null;
+                    
+                    // Set safe velocity
+                    if (this.velocity.length() < 1) {
+                        this.velocity.set(0, 0, 5);
                     }
-                    return;
+                    
+                    // Reset time
+                    this.timeAlive = 30 + Math.random() * 20;
+                } catch (recoveryError) {
+                    console.warn('Error during recovery:', recoveryError);
+                    this.crashed = true;
                 }
-                
-                this.updateSensors();
-                this.updateConvoyBehavior();
-                this.updateVisuals();
-                
-                // Get AI decision
-                const inputs = this.getEnhancedInputs();
-                const outputs = this.brain.activate(inputs);
-                
-                // Apply traffic-aware movement
-                this.applyTrafficMovement(outputs, deltaTime);
-                this.updateFitness(deltaTime);
-                
-                this.lastPosition.copy(this.mesh.position);
-                this.checkCollisions();
-                this.keepInBounds();
             }
             
             applyTrafficMovement(outputs, deltaTime) {
@@ -1285,57 +1319,207 @@
                 
                 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;
+                // Check if there's space in any approach lane
+                let totalApproachCapacity = 0;
+                let currentApproachOccupancy = 0;
                 
-                return queuePosition < 3 && approachLaneOccupancy < this.targetParkingLot.approachLane.length;
+                if (this.targetParkingLot.approachLanes) {
+                    // Multiple lanes system
+                    this.targetParkingLot.approachLanes.forEach(lane => {
+                        totalApproachCapacity += lane.length;
+                    });
+                    
+                    currentApproachOccupancy = population.filter(car => 
+                        car.isInApproachLane && 
+                        car.targetParkingLot === this.targetParkingLot
+                    ).length;
+                } else {
+                    // Single lane fallback
+                    totalApproachCapacity = this.targetParkingLot.approachLane ? 
+                        this.targetParkingLot.approachLane.length : 10;
+                    
+                    currentApproachOccupancy = population.filter(car => 
+                        car.isInApproachLane && 
+                        car.targetParkingLot === this.targetParkingLot
+                    ).length;
+                }
+                
+                return queuePosition < 5 && currentApproachOccupancy < totalApproachCapacity;
             }
             
             enterApproachLane(deltaTime) {
-                // Find first available approach lane position
-                const approachPositions = this.targetParkingLot.approachLane;
+                // Find first available approach lane position from any lane
                 let targetPosition = null;
+                let selectedLane = -1;
                 
-                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 (this.targetParkingLot.approachLanes) {
+                    for (let laneIndex = 0; laneIndex < this.targetParkingLot.approachLanes.length; laneIndex++) {
+                        const lanePositions = this.targetParkingLot.approachLanes[laneIndex];
+                        
+                        for (let posIndex = 0; posIndex < lanePositions.length; posIndex++) {
+                            const pos = lanePositions[posIndex];
+                            const occupied = population.some(car => 
+                                car !== this && 
+                                car.isInApproachLane && 
+                                car.mesh.position.distanceTo(pos) < 4
+                            );
+                            
+                            if (!occupied) {
+                                targetPosition = pos;
+                                selectedLane = laneIndex;
+                                break;
+                            }
+                        }
+                        
+                        if (targetPosition) break;
+                    }
+                } else {
+                    // Fallback to single lane system for compatibility
+                    const approachPositions = this.targetParkingLot.approachLane || [];
+                    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) < 4
+                        );
+                        
+                        if (!occupied) {
+                            targetPosition = pos;
+                            break;
+                        }
                     }
                 }
                 
                 if (targetPosition) {
                     this.isInApproachLane = true;
                     this.approachTarget = targetPosition;
+                    this.selectedApproachLane = selectedLane;
                     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) {
-                    // Wait in approach lane
-                    this.velocity.multiplyScalar(0.95);
-                    return;
+            useExitLane() {
+                let exitTarget = null;
+                let selectedExitLane = -1;
+                
+                // Try multiple exit lanes if available
+                if (this.targetParkingLot.exitLanes) {
+                    for (let laneIndex = 0; laneIndex < this.targetParkingLot.exitLanes.length; laneIndex++) {
+                        const exitPositions = this.targetParkingLot.exitLanes[laneIndex];
+                        
+                        for (let posIndex = 0; posIndex < exitPositions.length; posIndex++) {
+                            const pos = exitPositions[posIndex];
+                            const occupied = population.some(car => 
+                                car !== this && 
+                                car.mesh.position.distanceTo(pos) < 4
+                            );
+                            
+                            if (!occupied) {
+                                exitTarget = pos;
+                                selectedExitLane = laneIndex;
+                                break;
+                            }
+                        }
+                        
+                        if (exitTarget) break;
+                    }
+                } else {
+                    // Fallback to single lane system
+                    const exitPositions = this.targetParkingLot.exitLane || [];
+                    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;
+                        }
+                    }
                 }
                 
-                const spotDistance = this.mesh.position.distanceTo(availableSpot.position);
+                if (exitTarget) {
+                    this.isInExitLane = true;
+                    this.exitTarget = exitTarget;
+                    this.selectedExitLane = selectedExitLane;
+                    this.mesh.position.copy(exitTarget);
+                    
+                    // Set exit velocity toward nearest road or access point
+                    const exitDirection = this.getBestExitDirection();
+                    this.velocity.copy(exitDirection.multiplyScalar(7));
+                    
+                    // Schedule exit lane departure
+                    setTimeout(() => {
+                        if (this.isInExitLane) {
+                            this.isInExitLane = false;
+                            this.role = 'driver';
+                            this.timeAlive = 50 + Math.random() * 30;
+                            this.updateCarColor();
+                        }
+                    }, 2000 + Math.random() * 2000); // 2-4 seconds variation
+                    
+                    return true;
+                }
                 
-                if (spotDistance < 3) {
-                    // Successfully park
-                    this.completeParkingProcess(availableSpot);
-                } else {
-                    // Move toward spot
-                    this.moveToPosition(availableSpot.position, deltaTime, 2);
+                return false;
+            }
+            
+            getBestExitDirection() {
+                // Choose exit direction based on available access points
+                if (this.targetParkingLot.accessPoints && this.targetParkingLot.accessPoints.length > 0) {
+                    const accessPoint = this.targetParkingLot.accessPoints[
+                        Math.floor(Math.random() * this.targetParkingLot.accessPoints.length)
+                    ];
+                    
+                    const direction = accessPoint.pos.clone().sub(this.mesh.position).normalize();
+                    return direction;
+                }
+                
+                // Fallback directions
+                const directions = [
+                    new THREE.Vector3(0, 0, 1),  // South
+                    new THREE.Vector3(0, 0, -1), // North
+                    new THREE.Vector3(1, 0, 0),  // East
+                    new THREE.Vector3(-1, 0, 0)  // West
+                ];
+                
+                return directions[Math.floor(Math.random() * directions.length)];
+            }
+            
+            handleApproachLane(deltaTime) {
+                try {
+                    // Check if we can proceed to actual parking
+                    if (!this.targetParkingLot || !this.targetParkingLot.spots) {
+                        this.isInApproachLane = false;
+                        this.role = 'driver';
+                        return;
+                    }
+                    
+                    const availableSpot = this.targetParkingLot.spots.find(spot => !spot.occupied);
+                    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 spot
+                        this.moveToPosition(availableSpot.position, deltaTime, 2);
+                    }
+                } catch (error) {
+                    console.warn('Error in handleApproachLane:', error);
+                    // Recover by leaving approach lane
+                    this.isInApproachLane = false;
+                    this.role = 'driver';
+                    this.timeAlive = 30;
                 }
             }
             
@@ -1644,22 +1828,53 @@
             }
             
             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);
-                });
-                
-                if (this.mesh.parent) {
-                    scene.remove(this.mesh);
+                try {
+                    // Clean up parking spot
+                    if (this.parkingSpot) {
+                        this.parkingSpot.occupied = false;
+                        this.parkingSpot.car = null;
+                    }
+                    
+                    // Remove from parking queue
+                    this.leaveParkingQueue();
+                    
+                    // Clean up convoy relationships
+                    if (this.convoyFollowers && this.convoyFollowers.length > 0) {
+                        this.convoyFollowers.forEach(follower => {
+                            if (follower) {
+                                follower.convoyLeader = null;
+                                follower.followTarget = null;
+                                follower.convoyPosition = -1;
+                            }
+                        });
+                    }
+                    
+                    if (this.convoyLeader) {
+                        const index = this.convoyLeader.convoyFollowers.indexOf(this);
+                        if (index !== -1) {
+                            this.convoyLeader.convoyFollowers.splice(index, 1);
+                        }
+                    }
+                    
+                    // Clean up visual elements
+                    if (this.flockLines) {
+                        this.flockLines.forEach(line => {
+                            try {
+                                if (line && line.parent) {
+                                    scene.remove(line);
+                                }
+                            } catch (error) {
+                                console.warn('Error removing flock line:', error);
+                            }
+                        });
+                    }
+                    
+                    // Remove mesh from scene
+                    if (this.mesh && this.mesh.parent) {
+                        scene.remove(this.mesh);
+                    }
+                } catch (error) {
+                    console.warn('Error in car destroy method:', error);
                 }
             }
         }
@@ -2034,13 +2249,14 @@
                 
                 world.buildings.push({ mesh: building });
                 
-                // Create enhanced parking lot with approach lanes
+                // Create enhanced parking lot with multiple access points
                 const parkingLot = {
                     center: new THREE.Vector3(loc.x + width/2 + 25, 0.1, loc.z),
                     spots: [],
                     queue: [],
-                    approachLane: [],
-                    exitLane: []
+                    approachLanes: [], // Multiple approach lanes
+                    exitLanes: [],    // Multiple exit lanes
+                    accessPoints: []  // Multiple access points
                 };
                 
                 // Main parking lot surface (larger)
@@ -2050,40 +2266,64 @@
                 lot.position.copy(parkingLot.center);
                 scene.add(lot);
                 
-                // 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 multiple approach lanes (3 lanes)
+                for (let laneNum = 0; laneNum < 3; laneNum++) {
+                    const laneOffset = (laneNum - 1) * 10; // -10, 0, 10 offset
+                    
+                    // Approach lane
+                    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 - 35, 0.08, parkingLot.center.z + laneOffset);
+                    scene.add(approachLane);
+                    
+                    // Create approach queue positions for this lane
+                    const lanePositions = [];
+                    for (let q = 0; q < 10; q++) {
+                        const queuePos = new THREE.Vector3(
+                            parkingLot.center.x - 35,
+                            1,
+                            parkingLot.center.z + laneOffset - 25 + (q * 5) // 5m spacing
+                        );
+                        lanePositions.push(queuePos);
+                    }
+                    parkingLot.approachLanes.push(lanePositions);
                 }
                 
-                // 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 multiple exit lanes (2 lanes)
+                for (let exitNum = 0; exitNum < 2; exitNum++) {
+                    const exitOffset = (exitNum - 0.5) * 15; // -7.5, 7.5 offset
+                    
+                    // Exit lane
+                    const exitGeometry = new THREE.PlaneGeometry(6, 50);
+                    const exitLane = new THREE.Mesh(exitGeometry, queueMaterial);
+                    exitLane.rotation.x = -Math.PI / 2;
+                    exitLane.position.set(parkingLot.center.x + 35, 0.08, parkingLot.center.z + exitOffset);
+                    scene.add(exitLane);
+                    
+                    // Create exit positions for this lane
+                    const exitPositions = [];
+                    for (let q = 0; q < 8; q++) {
+                        const exitPos = new THREE.Vector3(
+                            parkingLot.center.x + 35,
+                            1,
+                            parkingLot.center.z + exitOffset - 20 + (q * 5)
+                        );
+                        exitPositions.push(exitPos);
+                    }
+                    parkingLot.exitLanes.push(exitPositions);
                 }
                 
+                // Create multiple access points with road connections
+                const accessPoints = [
+                    { pos: new THREE.Vector3(loc.x + width/2 + 10, 1, loc.z + depth/2 + 15), name: 'north' },
+                    { pos: new THREE.Vector3(loc.x + width/2 + 10, 1, loc.z - depth/2 - 15), name: 'south' },
+                    { pos: new THREE.Vector3(loc.x + width + 15, 1, loc.z), name: 'east' },
+                    { pos: new THREE.Vector3(loc.x - 15, 1, loc.z), name: 'west' }
+                ];
+                
+                parkingLot.accessPoints = accessPoints;
+                
                 // Create parking spots (5x8 grid = 40 spots)
                 for (let row = 0; row < 5; row++) {
                     for (let col = 0; col < 8; col++) {
@@ -2136,86 +2376,135 @@
         }
 
         function evolvePopulation() {
-            // Sort by fitness
-            population.sort((a, b) => b.fitness - a.fitness);
-            
-            // Advanced selection
-            const eliteCount = Math.floor(populationSize * 0.15);
-            const tournamentCount = Math.floor(populationSize * 0.25);
-            const mutatedCount = populationSize - eliteCount - tournamentCount;
-            
-            const survivors = population.slice(0, eliteCount);
-            
-            // Tournament selection
-            for (let i = 0; i < tournamentCount; i++) {
-                const tournamentSize = 5;
-                let best = null;
-                let bestFitness = -Infinity;
+            try {
+                // Sort by fitness with error handling
+                population.sort((a, b) => {
+                    const fitnessA = a.fitness || 0;
+                    const fitnessB = b.fitness || 0;
+                    return fitnessB - fitnessA;
+                });
+                
+                // Advanced selection
+                const eliteCount = Math.floor(populationSize * 0.15);
+                const tournamentCount = Math.floor(populationSize * 0.25);
                 
-                for (let j = 0; j < tournamentSize; j++) {
-                    const candidate = population[Math.floor(Math.random() * Math.min(population.length, populationSize * 0.5))];
-                    if (candidate.fitness > bestFitness) {
-                        best = candidate;
-                        bestFitness = candidate.fitness;
+                const survivors = population.slice(0, eliteCount);
+                
+                // Tournament selection with error handling
+                for (let i = 0; i < tournamentCount; i++) {
+                    try {
+                        const tournamentSize = 5;
+                        let best = null;
+                        let bestFitness = -Infinity;
+                        
+                        for (let j = 0; j < tournamentSize; j++) {
+                            const candidateIndex = Math.floor(Math.random() * Math.min(population.length, populationSize * 0.5));
+                            const candidate = population[candidateIndex];
+                            if (candidate && (candidate.fitness || 0) > bestFitness) {
+                                best = candidate;
+                                bestFitness = candidate.fitness || 0;
+                            }
+                        }
+                        if (best) survivors.push(best);
+                    } catch (error) {
+                        console.warn('Error in tournament selection:', error);
                     }
                 }
-                if (best) survivors.push(best);
-            }
-            
-            // Clean up old population
-            population.forEach(car => car.destroy());
-            
-            // Create new population
-            const newPopulation = [];
-            const roadPositions = [
-                { x: -280, z: 0 }, { x: 280, z: 0 },
-                { x: 0, z: -280 }, { x: 0, z: 280 },
-                { x: -130, z: 0 }, { x: 130, z: 0 },
-                { x: 0, z: -130 }, { x: 0, z: 130 }
-            ];
-            
-            // Elite reproduction
-            survivors.forEach((parent, index) => {
-                const startPos = roadPositions[index % roadPositions.length];
-                const newCar = new TrafficCar(
-                    startPos.x + (Math.random() - 0.5) * 10,
-                    startPos.z + (Math.random() - 0.5) * 10
-                );
-                newCar.brain = parent.brain.copy();
-                newPopulation.push(newCar);
-                scene.add(newCar.mesh);
-            });
-            
-            // Mutated offspring
-            while (newPopulation.length < populationSize) {
-                const parentIndex = Math.floor(Math.random() * Math.min(survivors.length, eliteCount * 2));
-                const parent = survivors[parentIndex];
-                const startPos = roadPositions[newPopulation.length % roadPositions.length];
                 
-                const child = new TrafficCar(
-                    startPos.x + (Math.random() - 0.5) * 10,
-                    startPos.z + (Math.random() - 0.5) * 10
-                );
-                child.brain = parent.brain.copy();
+                // Clean up old population
+                population.forEach(car => {
+                    try {
+                        car.destroy();
+                    } catch (error) {
+                        console.warn('Error destroying car during evolution:', error);
+                    }
+                });
+                
+                // Create new population
+                const newPopulation = [];
+                const roadPositions = [
+                    { x: -280, z: 0 }, { x: 280, z: 0 },
+                    { x: 0, z: -280 }, { x: 0, z: 280 },
+                    { x: -130, z: 0 }, { x: 130, z: 0 },
+                    { x: 0, z: -130 }, { x: 0, z: 130 }
+                ];
+                
+                // Elite reproduction
+                survivors.forEach((parent, index) => {
+                    try {
+                        const startPos = roadPositions[index % roadPositions.length];
+                        const newCar = new TrafficCar(
+                            startPos.x + (Math.random() - 0.5) * 10,
+                            startPos.z + (Math.random() - 0.5) * 10
+                        );
+                        if (parent.brain) {
+                            newCar.brain = parent.brain.copy();
+                        }
+                        newPopulation.push(newCar);
+                        scene.add(newCar.mesh);
+                    } catch (error) {
+                        console.warn('Error creating elite offspring:', error);
+                    }
+                });
+                
+                // Mutated offspring
+                while (newPopulation.length < populationSize) {
+                    try {
+                        const parentIndex = Math.floor(Math.random() * Math.min(survivors.length, eliteCount * 2));
+                        const parent = survivors[parentIndex];
+                        const startPos = roadPositions[newPopulation.length % roadPositions.length];
+                        
+                        const child = new TrafficCar(
+                            startPos.x + (Math.random() - 0.5) * 10,
+                            startPos.z + (Math.random() - 0.5) * 10
+                        );
+                        
+                        if (parent && parent.brain) {
+                            child.brain = parent.brain.copy();
+                            const mutationRate = (parent.fitness || 0) > bestFitness * 0.8 ? 0.05 : 0.15;
+                            child.brain.mutate(mutationRate);
+                        }
+                        
+                        newPopulation.push(child);
+                        scene.add(child.mesh);
+                    } catch (error) {
+                        console.warn('Error creating mutated offspring:', error);
+                        // Create a basic car as fallback
+                        try {
+                            const startPos = roadPositions[newPopulation.length % roadPositions.length];
+                            const basicCar = new TrafficCar(
+                                startPos.x + (Math.random() - 0.5) * 10,
+                                startPos.z + (Math.random() - 0.5) * 10
+                            );
+                            newPopulation.push(basicCar);
+                            scene.add(basicCar.mesh);
+                        } catch (fallbackError) {
+                            console.error('Error creating fallback car:', fallbackError);
+                        }
+                    }
+                }
+                
+                population = newPopulation;
+                
+                // Update epoch
+                epoch++;
+                timeLeft = epochTime;
+                bestFitness = Math.max(bestFitness, survivors[0]?.fitness || 0);
+                crashCount = 0;
+                parkingEvents = 0;
+                laneViolations = 0;
                 
-                const mutationRate = parent.fitness > bestFitness * 0.8 ? 0.05 : 0.15;
-                child.brain.mutate(mutationRate);
+                console.log(`Epoch ${epoch}: Best fitness: ${bestFitness.toFixed(1)}, Population: ${population.length}`);
                 
-                newPopulation.push(child);
-                scene.add(child.mesh);
+            } catch (error) {
+                console.error('Critical error during evolution:', error);
+                // Try to recover by creating a new basic population
+                try {
+                    createInitialPopulation();
+                } catch (recoveryError) {
+                    console.error('Failed to recover from evolution error:', recoveryError);
+                }
             }
-            
-            population = newPopulation;
-            
-            // Update epoch
-            epoch++;
-            timeLeft = epochTime;
-            bestFitness = Math.max(bestFitness, survivors[0]?.fitness || 0);
-            crashCount = 0;
-            parkingEvents = 0;
-            laneViolations = 0;
-            
-            console.log(`Epoch ${epoch}: Best fitness: ${bestFitness.toFixed(1)}, Parking events: ${parkingEvents}`);
         }
 
         function animate() {
@@ -2254,32 +2543,40 @@
                 approaching: 0 // Cars approaching parking
             };
             
-            population.forEach(car => {
-                car.update(deltaTime);
-                
-                if (!car.crashed) {
-                    stats.alive++;
-                    stats.totalRoadTime += car.roadTime;
-                    stats.totalConvoyTime += car.convoyTime;
-                    stats.totalParkingScore += car.parkingScore;
-                    stats.totalViolations += car.trafficViolations;
+            // Update each car with error handling
+            population.forEach((car, index) => {
+                try {
+                    car.update(deltaTime);
                     
-                    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);
-                    } else if (car.convoyPosition >= 0) {
-                        stats.convoy++;
-                        if (car.followingDistance > 0) {
-                            stats.totalFollowingDistance += car.followingDistance;
-                            stats.followingCount++;
+                    if (!car.crashed) {
+                        stats.alive++;
+                        stats.totalRoadTime += car.roadTime || 0;
+                        stats.totalConvoyTime += car.convoyTime || 0;
+                        stats.totalParkingScore += car.parkingScore || 0;
+                        stats.totalViolations += car.trafficViolations || 0;
+                        
+                        if (car.isParked) {
+                            stats.parked++;
+                        } else if (car.isParkingApproach) {
+                            stats.approaching++;
+                        } else if (car.role === 'leader') {
+                            stats.leaders++;
+                            const followerCount = car.convoyFollowers ? car.convoyFollowers.length : 0;
+                            stats.maxConvoySize = Math.max(stats.maxConvoySize, followerCount + 1);
+                        } else if (car.convoyPosition >= 0) {
+                            stats.convoy++;
+                            if (car.followingDistance > 0) {
+                                stats.totalFollowingDistance += car.followingDistance;
+                                stats.followingCount++;
+                            }
+                        } else {
+                            stats.solo++;
                         }
-                    } else {
-                        stats.solo++;
                     }
+                } catch (error) {
+                    console.warn(`Error updating car ${index}:`, error);
+                    // Mark problematic car as crashed to prevent further errors
+                    car.crashed = true;
                 }
             });
             
@@ -2287,39 +2584,66 @@
         }
 
         function updateCamera() {
-            if (cameraMode === 'follow_best') {
-                // Follow best performing car
-                let bestCar = population.reduce((best, car) => {
-                    if (car.crashed || car.isParked) return best;
-                    return !best || car.fitness > best.fitness ? car : best;
-                }, null);
-                
-                if (bestCar) {
-                    const targetPos = bestCar.mesh.position.clone();
-                    targetPos.y += 40;
-                    targetPos.add(bestCar.velocity.clone().normalize().multiplyScalar(25));
+            try {
+                if (cameraMode === 'follow_best') {
+                    // Follow best performing car
+                    let bestCar = null;
+                    let bestFitness = -1;
                     
-                    camera.position.lerp(targetPos, 0.03);
-                    camera.lookAt(bestCar.mesh.position);
-                }
-            } else if (cameraMode === 'follow_convoy') {
-                // Follow largest convoy
-                let largestConvoy = population.find(car => 
-                    car.role === 'leader' && car.convoyFollowers.length > 0
-                );
-                
-                if (largestConvoy) {
-                    const targetPos = largestConvoy.mesh.position.clone();
-                    targetPos.y += 50;
-                    targetPos.add(largestConvoy.velocity.clone().normalize().multiplyScalar(30));
+                    population.forEach(car => {
+                        if (car && !car.crashed && !car.isParked && car.fitness > bestFitness) {
+                            bestCar = car;
+                            bestFitness = car.fitness;
+                        }
+                    });
+                    
+                    if (bestCar && bestCar.mesh) {
+                        const targetPos = bestCar.mesh.position.clone();
+                        targetPos.y += 40;
+                        if (bestCar.velocity && bestCar.velocity.length() > 0.1) {
+                            targetPos.add(bestCar.velocity.clone().normalize().multiplyScalar(25));
+                        }
+                        
+                        camera.position.lerp(targetPos, 0.03);
+                        camera.lookAt(bestCar.mesh.position);
+                    }
+                } else if (cameraMode === 'follow_convoy') {
+                    // Follow largest convoy
+                    let largestConvoy = null;
+                    let maxFollowers = 0;
                     
-                    camera.position.lerp(targetPos, 0.03);
-                    camera.lookAt(largestConvoy.mesh.position);
+                    population.forEach(car => {
+                        if (car && car.role === 'leader' && 
+                            car.convoyFollowers && car.convoyFollowers.length > maxFollowers) {
+                            largestConvoy = car;
+                            maxFollowers = car.convoyFollowers.length;
+                        }
+                    });
+                    
+                    if (largestConvoy && largestConvoy.mesh) {
+                        const targetPos = largestConvoy.mesh.position.clone();
+                        targetPos.y += 50;
+                        if (largestConvoy.velocity && largestConvoy.velocity.length() > 0.1) {
+                            targetPos.add(largestConvoy.velocity.clone().normalize().multiplyScalar(30));
+                        }
+                        
+                        camera.position.lerp(targetPos, 0.03);
+                        camera.lookAt(largestConvoy.mesh.position);
+                    }
+                } else {
+                    // Overview mode
+                    camera.position.lerp(new THREE.Vector3(0, 180, 180), 0.02);
+                    camera.lookAt(0, 0, 0);
+                }
+            } catch (error) {
+                console.warn('Error updating camera:', error);
+                // Fallback to overview mode
+                try {
+                    camera.position.lerp(new THREE.Vector3(0, 180, 180), 0.02);
+                    camera.lookAt(0, 0, 0);
+                } catch (fallbackError) {
+                    console.error('Critical camera error:', fallbackError);
                 }
-            } else {
-                // Overview mode
-                camera.position.lerp(new THREE.Vector3(0, 180, 180), 0.02);
-                camera.lookAt(0, 0, 0);
             }
         }
 
@@ -2425,18 +2749,58 @@
             parkingEvents = 0;
             laneViolations = 0;
             
-            // Reset parking lots and queues
+            // Reset parking lots and queues with error handling
             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 || [];
+                try {
+                    lot.spots.forEach(spot => {
+                        spot.occupied = false;
+                        spot.car = null;
+                    });
+                    lot.queue = []; // Clear parking queues
+                    
+                    // Initialize multiple lanes if they don't exist
+                    if (!lot.approachLanes) {
+                        lot.approachLanes = [lot.approachLane || []];
+                    }
+                    if (!lot.exitLanes) {
+                        lot.exitLanes = [lot.exitLane || []];
+                    }
+                    if (!lot.accessPoints) {
+                        lot.accessPoints = [];
+                    }
+                } catch (error) {
+                    console.warn('Error resetting parking lot:', error);
+                }
             });
             
-            population.forEach(car => car.destroy());
+            // Clean up population with error handling
+            population.forEach(car => {
+                try {
+                    car.destroy();
+                } catch (error) {
+                    console.warn('Error destroying car:', error);
+                }
+            });
+            
+            // Clear any remaining visual elements
+            try {
+                const linesToRemove = [];
+                scene.traverse(child => {
+                    if (child.isLine && child.material && child.material.color) {
+                        // Check if it's a flock line (green color)
+                        if (child.material.color.g > 0.8) {
+                            linesToRemove.push(child);
+                        }
+                    }
+                });
+                
+                linesToRemove.forEach(line => {
+                    scene.remove(line);
+                });
+            } catch (error) {
+                console.warn('Error cleaning up visual elements:', error);
+            }
+            
             createInitialPopulation();
         }