Spaces:

awacke1
/

GlasgowDriving

Running

File size: 73,346 Bytes

c136415

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Enhanced AI Flocking Evolution Simulator</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
            font-family: Arial, sans-serif;
            background: #000;
        }
        #ui {
            position: absolute;
            top: 10px;
            left: 10px;
            color: white;
            background-color: rgba(0,0,0,0.9);
            padding: 15px;
            border-radius: 8px;
            z-index: 100;
            font-size: 14px;
            min-width: 200px;
        }
        #controls {
            position: absolute;
            top: 10px;
            right: 10px;
            color: white;
            background-color: rgba(0,0,0,0.9);
            padding: 15px;
            border-radius: 8px;
            z-index: 100;
        }
        button {
            background-color: #4CAF50;
            border: none;
            color: white;
            padding: 8px 16px;
            margin: 5px;
            cursor: pointer;
            border-radius: 4px;
            font-size: 12px;
        }
        button:hover {
            background-color: #45a049;
        }
        #stats {
            position: absolute;
            bottom: 10px;
            left: 10px;
            color: white;
            background-color: rgba(0,0,0,0.9);
            padding: 15px;
            border-radius: 8px;
            z-index: 100;
            font-size: 12px;
            min-width: 200px;
        }
        #flockingStats {
            position: absolute;
            bottom: 10px;
            right: 10px;
            color: white;
            background-color: rgba(0,0,0,0.9);
            padding: 15px;
            border-radius: 8px;
            z-index: 100;
            font-size: 12px;
            min-width: 180px;
        }
        #aiStats {
            position: absolute;
            top: 50%;
            right: 10px;
            transform: translateY(-50%);
            color: white;
            background-color: rgba(0,0,0,0.9);
            padding: 15px;
            border-radius: 8px;
            z-index: 100;
            font-size: 12px;
            min-width: 180px;
        }
        .highlight { color: #ffcc00; font-weight: bold; }
        .success { color: #00ff00; font-weight: bold; }
        .flocking { color: #00aaff; }
        .solo { color: #ff8800; }
        .leader { color: #ff00ff; font-weight: bold; }
        .explorer { color: #00ffff; }
        .follower { color: #88ff88; }
        .species-0 { color: #ff6b6b; }
        .species-1 { color: #4ecdc4; }
        .species-2 { color: #45b7d1; }
        .species-3 { color: #96ceb4; }
        .species-4 { color: #ffd93d; }
        .progress-bar {
            width: 100%;
            height: 10px;
            background-color: #333;
            border-radius: 5px;
            overflow: hidden;
            margin: 5px 0;
        }
        .progress-fill {
            height: 100%;
            background: linear-gradient(90deg, #ff6b6b, #4ecdc4, #45b7d1);
            transition: width 0.3s ease;
        }
    </style>
</head>
<body>
    <div id="ui">
        <div class="highlight">Enhanced AI Evolution Simulator</div>
        <div>Epoch: <span id="epoch">1</span></div>
        <div>Time: <span id="epochTime">60</span>s</div>
        <div class="progress-bar"><div class="progress-fill" id="timeProgress"></div></div>
        <div>Population: <span id="population">100</span></div>
        <div>Species: <span id="speciesCount">1</span></div>
        <div>Best Fitness: <span id="bestFitness">0</span></div>
        <div>Avg IQ: <span id="avgIQ">50</span></div>
        <div>Innovation: <span id="innovationCount">0</span></div>
    </div>

    <div id="controls">
        <button id="pauseBtn">Pause</button>
        <button id="resetBtn">Reset</button>
        <button id="speedBtn">Speed: 1x</button>
        <button id="viewBtn">View: Follow</button>
        <button id="flockBtn">Flocks: ON</button>
        <button id="adaptiveBtn">Adaptive: ON</button>
        <button id="challengeBtn">Challenge: Normal</button>
    </div>

    <div id="stats">
        <div><span class="highlight">Top Performers:</span></div>
        <div id="topPerformers"></div>
        <div style="margin-top: 10px;"><span class="highlight">Generation Stats:</span></div>
        <div>Crashes: <span id="crashCount">0</span></div>
        <div>Total Distance: <span id="totalDistance">0</span></div>
        <div>Exploration: <span id="explorationBonus">0</span></div>
        <div>Cooperation: <span id="cooperationScore">0</span></div>
        <div>Road Mastery: <span id="roadMastery">0</span>%</div>
    </div>

    <div id="flockingStats">
        <div><span class="highlight">Flocking Dynamics:</span></div>
        <div><span class="leader">Leaders:</span> <span id="leaderCount">0</span></div>
        <div><span class="flocking">Followers:</span> <span id="followerCount">0</span></div>
        <div><span class="explorer">Explorers:</span> <span id="explorerCount">0</span></div>
        <div><span class="solo">Solo:</span> <span id="soloCount">0</span></div>
        <div>Largest Flock: <span id="largestFlock">0</span></div>
        <div>Avg Coordination: <span id="avgCoordination">0</span>%</div>
        <div>Group Efficiency: <span id="groupEfficiency">0</span>%</div>
    </div>

    <div id="aiStats">
        <div><span class="highlight">AI Intelligence:</span></div>
        <div>Neural Complexity: <span id="neuralComplexity">100</span></div>
        <div>Decision Quality: <span id="decisionQuality">50</span>%</div>
        <div>Learning Rate: <span id="learningRate">1.0</span></div>
        <div>Memory Usage: <span id="memoryUsage">0</span>%</div>
        <div style="margin-top: 10px;"><span class="highlight">Behaviors:</span></div>
        <div>Predictive: <span id="predictiveBehavior">0</span>%</div>
        <div>Adaptive: <span id="adaptiveBehavior">0</span>%</div>
        <div>Emergent: <span id="emergentBehavior">0</span>%</div>
    </div>

    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
    <script>
        // Global variables
        let scene, camera, renderer, clock;
        let world = {
            roads: [],
            intersections: [],
            buildings: [],
            jumpRamps: [],
            flockLines: [],
            dynamicObstacles: [],
            targets: []
        };
        
        // Enhanced evolution system
        let epoch = 1;
        let epochTime = 60;
        let timeLeft = 60;
        let population = [];
        let species = [];
        let populationSize = 100;
        let bestFitness = 0;
        let totalDistance = 0;
        let groupDistance = 0;
        let crashCount = 0;
        let paused = false;
        let speedMultiplier = 1;
        let cameraMode = 'follow';
        let showFlockLines = true;
        let adaptiveEnvironment = true;
        let challengeLevel = 'normal'; // normal, hard, extreme
        let innovationCounter = 0;
        let globalMemory = new Map();

        // Enhanced AI parameters
        const NEIGHBOR_RADIUS = 30;
        const SEPARATION_RADIUS = 10;
        const LEADERSHIP_RADIUS = 40;
        const MEMORY_SIZE = 10;
        const SPECIES_THRESHOLD = 3.0;
        const TARGET_SPECIES = 5;

        // Dynamic challenge system
        let dynamicChallenges = {
            obstacles: [],
            targets: [],
            weather: 'clear',
            timeOfDay: 'day'
        };

        // Enhanced Neural Network with memory and multiple layers
        class EnhancedNeuralNetwork {
            constructor() {
                this.inputSize = 24; // Expanded sensory inputs
                this.hiddenLayers = [32, 24, 16]; // Multi-layer deep network
                this.outputSize = 8; // More nuanced outputs
                this.memorySize = MEMORY_SIZE;
                
                // Initialize all weight matrices and biases
                this.weights = [];
                this.biases = [];
                this.memory = new Array(this.memorySize).fill(0);
                this.memoryPointer = 0;
                
                // Build network layers
                let prevSize = this.inputSize + this.memorySize;
                for (let i = 0; i < this.hiddenLayers.length; i++) {
                    this.weights.push(this.randomMatrix(prevSize, this.hiddenLayers[i]));
                    this.biases.push(this.randomArray(this.hiddenLayers[i]));
                    prevSize = this.hiddenLayers[i];
                }
                
                // Output layer
                this.weights.push(this.randomMatrix(prevSize, this.outputSize));
                this.biases.push(this.randomArray(this.outputSize));
                
                // Specialized modules
                this.attentionWeights = this.randomArray(this.inputSize);
                this.innovationGenes = this.randomArray(10);
                this.personalityTraits = {
                    leadership: Math.random(),
                    exploration: Math.random(),
                    cooperation: Math.random(),
                    caution: Math.random(),
                    adaptability: Math.random()
                };
            }
            
            randomMatrix(rows, cols) {
                let matrix = [];
                for (let i = 0; i < rows; i++) {
                    matrix[i] = [];
                    for (let j = 0; j < cols; j++) {
                        matrix[i][j] = (Math.random() - 0.5) * 2;
                    }
                }
                return matrix;
            }
            
            randomArray(size) {
                return Array(size).fill().map(() => (Math.random() - 0.5) * 2);
            }
            
            // Advanced activation with attention mechanism
            activate(inputs) {
                // Apply attention mechanism to inputs
                const attentionScores = inputs.map((input, i) => 
                    input * this.sigmoid(this.attentionWeights[i])
                );
                
                // Combine inputs with memory
                let currentInput = [...attentionScores, ...this.memory];
                
                // Forward pass through hidden layers
                for (let layer = 0; layer < this.hiddenLayers.length; layer++) {
                    currentInput = this.forwardLayer(currentInput, this.weights[layer], this.biases[layer]);
                }
                
                // Output layer
                const outputs = this.forwardLayer(currentInput, 
                    this.weights[this.weights.length - 1], 
                    this.biases[this.biases.length - 1]);
                
                // Update memory with current state
                this.updateMemory(inputs, outputs);
                
                return outputs;
            }
            
            forwardLayer(inputs, weights, biases) {
                const outputs = new Array(weights[0].length).fill(0);
                
                for (let i = 0; i < outputs.length; i++) {
                    for (let j = 0; j < inputs.length; j++) {
                        outputs[i] += inputs[j] * weights[j][i];
                    }
                    outputs[i] += biases[i];
                    outputs[i] = this.advancedActivation(outputs[i]);
                }
                
                return outputs;
            }
            
            // Advanced activation function combining sigmoid and tanh
            advancedActivation(x) {
                const clampedX = Math.max(-10, Math.min(10, x));
                return (this.sigmoid(clampedX) + Math.tanh(clampedX)) / 2;
            }
            
            sigmoid(x) {
                return 1 / (1 + Math.exp(-Math.max(-500, Math.min(500, x))));
            }
            
            updateMemory(inputs, outputs) {
                // Store important environmental information
                const importance = Math.max(...inputs.slice(0, 8)); // Obstacle sensor max
                this.memory[this.memoryPointer] = importance;
                this.memoryPointer = (this.memoryPointer + 1) % this.memorySize;
            }
            
            // Advanced mutation with adaptive rates
            mutate(baseRate = 0.1, innovation = false) {
                const adaptiveRate = baseRate * (1 + this.personalityTraits.adaptability);
                
                // Mutate weights
                this.weights.forEach(weightMatrix => {
                    this.mutateMatrix(weightMatrix, adaptiveRate);
                });
                
                // Mutate biases
                this.biases.forEach(biasArray => {
                    this.mutateArray(biasArray, adaptiveRate);
                });
                
                // Mutate attention weights
                this.mutateArray(this.attentionWeights, adaptiveRate * 0.5);
                
                // Mutate personality traits
                Object.keys(this.personalityTraits).forEach(trait => {
                    if (Math.random() < adaptiveRate) {
                        this.personalityTraits[trait] += (Math.random() - 0.5) * 0.2;
                        this.personalityTraits[trait] = Math.max(0, Math.min(1, this.personalityTraits[trait]));
                    }
                });
                
                // Innovation mutations
                if (innovation) {
                    this.mutateArray(this.innovationGenes, adaptiveRate * 2);
                    innovationCounter++;
                }
            }
            
            mutateMatrix(matrix, rate) {
                for (let i = 0; i < matrix.length; i++) {
                    for (let j = 0; j < matrix[i].length; j++) {
                        if (Math.random() < rate) {
                            const mutationStrength = 0.5 * (1 + Math.random());
                            matrix[i][j] += (Math.random() - 0.5) * mutationStrength;
                            matrix[i][j] = Math.max(-5, Math.min(5, matrix[i][j])); // Clamp weights
                        }
                    }
                }
            }
            
            mutateArray(array, rate) {
                for (let i = 0; i < array.length; i++) {
                    if (Math.random() < rate) {
                        const mutationStrength = 0.5 * (1 + Math.random());
                        array[i] += (Math.random() - 0.5) * mutationStrength;
                        array[i] = Math.max(-5, Math.min(5, array[i])); // Clamp values
                    }
                }
            }
            
            // Crossover with compatibility checking
            crossover(other) {
                const child = new EnhancedNeuralNetwork();
                
                // Blend weights and biases
                for (let layer = 0; layer < this.weights.length; layer++) {
                    for (let i = 0; i < this.weights[layer].length; i++) {
                        for (let j = 0; j < this.weights[layer][i].length; j++) {
                            child.weights[layer][i][j] = Math.random() < 0.5 ? 
                                this.weights[layer][i][j] : other.weights[layer][i][j];
                        }
                    }
                    
                    for (let i = 0; i < this.biases[layer].length; i++) {
                        child.biases[layer][i] = Math.random() < 0.5 ? 
                            this.biases[layer][i] : other.biases[layer][i];
                    }
                }
                
                // Blend personality traits
                Object.keys(this.personalityTraits).forEach(trait => {
                    child.personalityTraits[trait] = (this.personalityTraits[trait] + other.personalityTraits[trait]) / 2;
                });
                
                return child;
            }
            
            copy() {
                const newNN = new EnhancedNeuralNetwork();
                
                // Deep copy all components
                newNN.weights = this.weights.map(matrix => 
                    matrix.map(row => [...row])
                );
                newNN.biases = this.biases.map(bias => [...bias]);
                newNN.attentionWeights = [...this.attentionWeights];
                newNN.memory = [...this.memory];
                newNN.memoryPointer = this.memoryPointer;
                newNN.innovationGenes = [...this.innovationGenes];
                newNN.personalityTraits = {...this.personalityTraits};
                
                return newNN;
            }
            
            // Calculate network complexity for visualization
            getComplexity() {
                let totalConnections = 0;
                this.weights.forEach(matrix => {
                    totalConnections += matrix.length * matrix[0].length;
                });
                return totalConnections;
            }
        }

        // Enhanced AI Car with advanced behaviors
        class EnhancedAICar {
            constructor(x = 0, z = 0) {
                this.brain = new EnhancedNeuralNetwork();
                this.mesh = this.createCarMesh();
                this.mesh.position.set(x, 1, z);
                
                // Enhanced movement properties
                this.velocity = new THREE.Vector3(
                    (Math.random() - 0.5) * 10, 0, (Math.random() - 0.5) * 10
                );
                this.acceleration = new THREE.Vector3();
                this.maxSpeed = 25;
                this.minSpeed = 3;
                this.accelerationForce = 0.6;
                this.turnSpeed = 0.1;
                
                // Advanced flocking and behavior
                this.neighbors = [];
                this.role = 'follower'; // leader, follower, explorer, scout
                this.flockId = -1;
                this.speciesId = 0;
                this.leadership = this.brain.personalityTraits.leadership;
                this.exploration = this.brain.personalityTraits.exploration;
                this.cooperation = this.brain.personalityTraits.cooperation;
                
                // Enhanced fitness and metrics
                this.fitness = 0;
                this.rawFitness = 0;
                this.adjustedFitness = 0;
                this.distanceTraveled = 0;
                this.explorationBonus = 0;
                this.cooperationScore = 0;
                this.leadershipScore = 0;
                this.innovationScore = 0;
                this.decisionQuality = 50;
                this.predictiveAccuracy = 0;
                
                // State tracking
                this.timeAlive = 100;
                this.crashed = false;
                this.lastPosition = new THREE.Vector3(x, 1, z);
                this.visitedAreas = new Set();
                this.decisions = [];
                this.predictions = [];
                
                // Enhanced sensors
                this.sensors = Array(12).fill(0); // More sensors
                this.environmentSensors = Array(4).fill(0);
                this.socialSensors = Array(8).fill(0);
                this.sensorRays = [];
                this.flockLines = [];
                
                this.createSensorRays();
                this.createFlockVisualization();
                this.initializeMovement();
            }
            
            createCarMesh() {
                const group = new THREE.Group();
                
                // Enhanced car body with role-based styling
                const bodyGeometry = new THREE.BoxGeometry(1.5, 0.8, 3);
                this.bodyMaterial = new THREE.MeshLambertMaterial({ 
                    color: new THREE.Color().setHSL(Math.random(), 0.8, 0.6) 
                });
                const body = new THREE.Mesh(bodyGeometry, this.bodyMaterial);
                body.position.y = 0.4;
                body.castShadow = true;
                group.add(body);
                
                // Role indicator
                const indicatorGeometry = new THREE.SphereGeometry(0.2, 8, 6);
                this.roleIndicator = new THREE.Mesh(indicatorGeometry, 
                    new THREE.MeshLambertMaterial({ color: 0xffffff }));
                this.roleIndicator.position.set(0, 1.5, 0);
                group.add(this.roleIndicator);
                
                // Intelligence indicator (size based on neural complexity)
                const complexity = this.brain.getComplexity();
                const brainSize = 0.1 + (complexity / 10000) * 0.4;
                const brainGeometry = new THREE.SphereGeometry(brainSize, 6, 4);
                this.brainIndicator = new THREE.Mesh(brainGeometry,
                    new THREE.MeshLambertMaterial({ 
                        color: 0x00ffff,
                        transparent: true,
                        opacity: 0.7
                    }));
                this.brainIndicator.position.set(0, 1.8, 0);
                group.add(this.brainIndicator);
                
                // Enhanced wheels with rotation
                const wheelGeometry = new THREE.CylinderGeometry(0.3, 0.3, 0.2, 8);
                const wheelMaterial = new THREE.MeshLambertMaterial({ color: 0x333333 });
                
                this.wheels = [];
                const wheelPositions = [
                    [-0.8, 0, 1.2], [0.8, 0, 1.2],
                    [-0.8, 0, -1.2], [0.8, 0, -1.2]
                ];
                
                wheelPositions.forEach((pos, i) => {
                    const wheel = new THREE.Mesh(wheelGeometry, wheelMaterial);
                    wheel.position.set(...pos);
                    wheel.rotation.z = Math.PI / 2;
                    this.wheels.push(wheel);
                    group.add(wheel);
                });
                
                return group;
            }
            
            createSensorRays() {
                const sensorMaterial = new THREE.LineBasicMaterial({ 
                    color: 0xff0000, 
                    transparent: true, 
                    opacity: 0.3 
                });
                
                // 12 sensors for comprehensive environment detection
                for (let i = 0; i < 12; i++) {
                    const geometry = new THREE.BufferGeometry().setFromPoints([
                        new THREE.Vector3(0, 0, 0),
                        new THREE.Vector3(0, 0, 8)
                    ]);
                    const ray = new THREE.Line(geometry, sensorMaterial);
                    this.sensorRays.push(ray);
                    this.mesh.add(ray);
                }
            }
            
            createFlockVisualization() {
                const flockMaterial = new THREE.LineBasicMaterial({ 
                    color: 0x00ff00, 
                    transparent: true, 
                    opacity: 0.3 
                });
                
                for (let i = 0; i < 8; i++) {
                    const geometry = new THREE.BufferGeometry().setFromPoints([
                        new THREE.Vector3(0, 2, 0),
                        new THREE.Vector3(0, 2, 0)
                    ]);
                    const line = new THREE.Line(geometry, flockMaterial);
                    this.flockLines.push(line);
                    if (showFlockLines) scene.add(line);
                }
            }
            
            initializeMovement() {
                this.mesh.rotation.y = Math.random() * Math.PI * 2;
                this.velocity.set(
                    Math.sin(this.mesh.rotation.y) * (8 + Math.random() * 7),
                    0,
                    Math.cos(this.mesh.rotation.y) * (8 + Math.random() * 7)
                );
            }
            
            updateEnhancedSensors() {
                const maxDistance = 8;
                const raycaster = new THREE.Raycaster();
                
                // 12-direction sensor array
                const sensorAngles = [];
                for (let i = 0; i < 12; i++) {
                    sensorAngles.push((i * Math.PI * 2) / 12);
                }
                
                sensorAngles.forEach((angle, i) => {
                    const direction = new THREE.Vector3(
                        Math.sin(angle), 0, Math.cos(angle)
                    );
                    direction.applyQuaternion(this.mesh.quaternion);
                    
                    raycaster.set(this.mesh.position, direction);
                    const intersects = raycaster.intersectObjects(this.getObstacles(), true);
                    
                    if (intersects.length > 0 && intersects[0].distance <= maxDistance) {
                        this.sensors[i] = 1 - (intersects[0].distance / maxDistance);
                    } else {
                        this.sensors[i] = 0;
                    }
                    
                    // Update visual ray
                    const endDistance = intersects.length > 0 ? 
                        Math.min(intersects[0].distance, maxDistance) : maxDistance;
                    
                    const rayEnd = direction.clone().multiplyScalar(endDistance);
                    this.sensorRays[i].geometry.setFromPoints([
                        new THREE.Vector3(0, 0, 0), rayEnd
                    ]);
                });
                
                // Environment sensors
                this.updateEnvironmentSensors();
            }
            
            updateEnvironmentSensors() {
                const pos = this.mesh.position;
                
                // Road detection with direction
                this.environmentSensors[0] = this.detectRoadPosition();
                
                // Obstacle density in area
                let nearbyObstacles = 0;
                population.forEach(other => {
                    if (other !== this && !other.crashed) {
                        const dist = pos.distanceTo(other.mesh.position);
                        if (dist < 20) nearbyObstacles++;
                    }
                });
                this.environmentSensors[1] = Math.min(nearbyObstacles / 5, 1);
                
                // Target/goal direction (if any targets exist)
                this.environmentSensors[2] = this.getTargetDirection();
                
                // Exploration potential
                this.environmentSensors[3] = this.getExplorationPotential();
            }
            
            updateAdvancedFlocking() {
                this.neighbors = [];
                this.socialSensors.fill(0);
                
                let separation = new THREE.Vector3();
                let alignment = new THREE.Vector3();
                let cohesion = new THREE.Vector3();
                let leadership = new THREE.Vector3();
                
                let neighborCount = 0;
                let leaderInfluence = 0;
                
                population.forEach(other => {
                    if (other !== this && !other.crashed) {
                        const distance = this.mesh.position.distanceTo(other.mesh.position);
                        
                        if (distance < NEIGHBOR_RADIUS && distance > 0) {
                            this.neighbors.push(other);
                            
                            // Traditional flocking forces
                            cohesion.add(other.mesh.position);
                            alignment.add(other.velocity);
                            
                            // Leadership dynamics
                            if (other.role === 'leader' && distance < LEADERSHIP_RADIUS) {
                                const influence = other.leadership * (1 - distance / LEADERSHIP_RADIUS);
                                leadership.add(other.velocity.clone().multiplyScalar(influence));
                                leaderInfluence += influence;
                            }
                            
                            neighborCount++;
                        }
                        
                        if (distance < SEPARATION_RADIUS && distance > 0) {
                            const diff = this.mesh.position.clone().sub(other.mesh.position);
                            diff.normalize().divideScalar(distance);
                            separation.add(diff);
                        }
                    }
                });
                
                // Finalize flocking forces
                if (neighborCount > 0) {
                    cohesion.divideScalar(neighborCount).sub(this.mesh.position).normalize();
                    alignment.divideScalar(neighborCount).normalize();
                    this.cooperationScore += neighborCount * 0.1;
                }
                
                if (leaderInfluence > 0) {
                    leadership.normalize();
                }
                
                // Update social sensors
                this.socialSensors[0] = Math.min(neighborCount / 10, 1); // Neighbor density
                this.socialSensors[1] = separation.length(); // Separation strength
                this.socialSensors[2] = alignment.length(); // Alignment strength
                this.socialSensors[3] = cohesion.length(); // Cohesion strength
                this.socialSensors[4] = leadership.length(); // Leadership influence
                this.socialSensors[5] = this.leadership; // Own leadership
                this.socialSensors[6] = this.cooperation; // Cooperation tendency
                this.socialSensors[7] = this.role === 'leader' ? 1 : 0; // Role indicator
                
                // Store forces for neural network
                this.flockingForces = { separation, alignment, cohesion, leadership };
                
                // Update role based on behavior
                this.updateRole();
            }
            
            updateRole() {
                const neighborCount = this.neighbors.length;
                
                if (this.leadership > 0.7 && neighborCount > 2) {
                    this.role = 'leader';
                    this.leadershipScore += 1;
                } else if (this.exploration > 0.8 && neighborCount < 2) {
                    this.role = 'explorer';
                    this.explorationBonus += this.velocity.length() * 0.1;
                } else if (neighborCount > 0) {
                    this.role = 'follower';
                } else {
                    this.role = 'scout';
                }
                
                // Update visual indicator
                const colors = {
                    leader: 0xff00ff,
                    explorer: 0x00ffff,
                    follower: 0x88ff88,
                    scout: 0xffff00
                };
                this.roleIndicator.material.color.setHex(colors[this.role]);
            }
            
            getEnhancedInputs() {
                // Comprehensive input vector
                return [
                    ...this.sensors, // 12 obstacle sensors
                    ...this.environmentSensors, // 4 environment sensors
                    ...this.socialSensors, // 8 social sensors
                ];
            }
            
            makeDecision(inputs, outputs) {
                // Enhanced decision making with prediction
                const decision = {
                    timestamp: Date.now(),
                    inputs: [...inputs],
                    outputs: [...outputs],
                    prediction: this.makePrediction(inputs),
                    confidence: this.calculateConfidence(outputs)
                };
                
                this.decisions.push(decision);
                if (this.decisions.length > 20) {
                    this.decisions.shift();
                }
                
                // Update decision quality based on outcomes
                this.updateDecisionQuality();
                
                return outputs;
            }
            
            makePrediction(inputs) {
                // Simple prediction: where will I be in 5 steps?
                const prediction = this.mesh.position.clone().add(
                    this.velocity.clone().multiplyScalar(5)
                );
                
                this.predictions.push({
                    timestamp: Date.now(),
                    predicted: prediction,
                    actual: null // Will be filled later
                });
                
                return prediction;
            }
            
            calculateConfidence(outputs) {
                // Confidence based on output certainty
                const variance = outputs.reduce((sum, val) => sum + Math.pow(val - 0.5, 2), 0);
                return Math.min(variance * 2, 1);
            }
            
            updateDecisionQuality() {
                // Evaluate prediction accuracy
                let accuracy = 0;
                let validPredictions = 0;
                
                this.predictions.forEach(pred => {
                    if (pred.actual) {
                        const error = pred.predicted.distanceTo(pred.actual);
                        accuracy += Math.max(0, 1 - error / 50); // Normalize error
                        validPredictions++;
                    }
                });
                
                if (validPredictions > 0) {
                    this.predictiveAccuracy = accuracy / validPredictions;
                    this.decisionQuality = this.predictiveAccuracy * 100;
                }
            }
            
            detectRoadPosition() {
                const pos = this.mesh.position;
                const roadWidth = 12;
                const roadSpacing = 150;
                
                const nearestHorizontalRoad = Math.round(pos.z / roadSpacing) * roadSpacing;
                const distToHorizontalRoad = Math.abs(pos.z - nearestHorizontalRoad);
                const onHorizontalRoad = distToHorizontalRoad <= roadWidth / 2;
                
                const nearestVerticalRoad = Math.round(pos.x / roadSpacing) * roadSpacing;
                const distToVerticalRoad = Math.abs(pos.x - nearestVerticalRoad);
                const onVerticalRoad = distToVerticalRoad <= roadWidth / 2;
                
                if (onHorizontalRoad || onVerticalRoad) {
                    return Math.max(
                        onHorizontalRoad ? 1 - (distToHorizontalRoad / (roadWidth / 2)) : 0,
                        onVerticalRoad ? 1 - (distToVerticalRoad / (roadWidth / 2)) : 0
                    );
                }
                
                return 0;
            }
            
            getTargetDirection() {
                // Find nearest unexplored area or target
                if (world.targets.length > 0) {
                    const nearest = world.targets.reduce((closest, target) => {
                        const dist = this.mesh.position.distanceTo(target.position);
                        return dist < closest.distance ? { target, distance: dist } : closest;
                    }, { distance: Infinity });
                    
                    if (nearest.distance < 100) {
                        const direction = nearest.target.position.clone()
                            .sub(this.mesh.position).normalize();
                        return (direction.dot(this.velocity.clone().normalize()) + 1) / 2;
                    }
                }
                return 0.5;
            }
            
            getExplorationPotential() {
                // Calculate exploration potential based on visited areas
                const currentArea = `${Math.floor(this.mesh.position.x / 50)},${Math.floor(this.mesh.position.z / 50)}`;
                return this.visitedAreas.has(currentArea) ? 0.2 : 0.8;
            }
            
            update(deltaTime) {
                if (this.crashed) return;
                
                this.timeAlive -= deltaTime;
                if (this.timeAlive <= 0) {
                    this.crashed = true;
                    return;
                }
                
                // Update all sensors and behaviors
                this.updateEnhancedSensors();
                this.updateAdvancedFlocking();
                this.updateVisuals();
                
                // Get comprehensive neural network inputs
                const inputs = this.getEnhancedInputs();
                
                // Get brain decision
                const outputs = this.brain.activate(inputs);
                
                // Process decision with prediction
                const processedOutputs = this.makeDecision(inputs, outputs);
                
                // Apply enhanced movement
                this.applyEnhancedMovement(processedOutputs, deltaTime);
                
                // Update fitness with advanced metrics
                this.updateAdvancedFitness(deltaTime);
                
                // Track exploration
                this.trackExploration();
                
                this.lastPosition.copy(this.mesh.position);
                this.checkCollisions();
                this.keepInBounds();
            }
            
            applyEnhancedMovement(outputs, deltaTime) {
                // Enhanced output interpretation
                const [
                    forwardForce, turnLeft, turnRight, brake,
                    emergencyStop, boost, preciseTurn, formation
                ] = outputs;
                
                // Turning with precision control
                const baseTurn = (turnRight - turnLeft) * this.turnSpeed;
                const precisionTurn = (preciseTurn - 0.5) * this.turnSpeed * 0.5;
                const totalTurn = (baseTurn + precisionTurn) * deltaTime;
                
                this.mesh.rotation.y += totalTurn;
                
                // Advanced acceleration
                const forward = new THREE.Vector3(0, 0, 1);
                forward.applyQuaternion(this.mesh.quaternion);
                
                let acceleration = this.accelerationForce;
                
                // Boost behavior
                if (boost > 0.7) {
                    acceleration *= 1.5;
                    this.maxSpeed = 30;
                } else {
                    this.maxSpeed = 25;
                }
                
                // Emergency stop
                if (emergencyStop > 0.8) {
                    this.velocity.multiplyScalar(0.8);
                } else if (forwardForce > 0.1) {
                    this.acceleration.add(forward.multiplyScalar(acceleration * forwardForce * deltaTime));
                }
                
                // Braking
                if (brake > 0.5) {
                    this.velocity.multiplyScalar(1 - brake * deltaTime * 2);
                }
                
                // Apply flocking forces
                if (this.flockingForces) {
                    const flockingStrength = formation * 0.5;
                    this.acceleration.add(this.flockingForces.separation.multiplyScalar(0.3));
                    this.acceleration.add(this.flockingForces.alignment.multiplyScalar(0.2 * flockingStrength));
                    this.acceleration.add(this.flockingForces.cohesion.multiplyScalar(0.2 * flockingStrength));
                    this.acceleration.add(this.flockingForces.leadership.multiplyScalar(0.4 * (1 - this.leadership)));
                }
                
                // Apply acceleration and velocity
                this.velocity.add(this.acceleration);
                this.acceleration.multiplyScalar(0.1); // Decay acceleration
                
                // Speed limits
                const currentSpeed = this.velocity.length();
                if (currentSpeed > this.maxSpeed) {
                    this.velocity.normalize().multiplyScalar(this.maxSpeed);
                } else if (currentSpeed < this.minSpeed) {
                    this.velocity.normalize().multiplyScalar(this.minSpeed);
                }
                
                // Apply movement
                this.mesh.position.add(this.velocity.clone().multiplyScalar(deltaTime));
                
                // Wheel rotation animation
                this.wheels.forEach(wheel => {
                    wheel.rotation.x += this.velocity.length() * deltaTime * 0.1;
                });
            }
            
            updateAdvancedFitness(deltaTime) {
                const distance = this.mesh.position.distanceTo(this.lastPosition);
                this.distanceTraveled += distance;
                
                // Multi-objective fitness function
                const roadBonus = this.detectRoadPosition() * distance * 3;
                const groupBonus = Math.min(this.neighbors.length, 8) * distance * 2;
                const roleBonus = this.getRoleBonus() * deltaTime;
                const innovationBonus = this.innovationScore * 0.5;
                const efficiencyBonus = this.getEfficiencyBonus();
                
                this.rawFitness = this.distanceTraveled +
                    roadBonus +
                    groupBonus +
                    roleBonus +
                    this.explorationBonus +
                    this.cooperationScore +
                    innovationBonus +
                    efficiencyBonus;
                
                // Update predictions
                this.predictions.forEach(pred => {
                    if (!pred.actual && Date.now() - pred.timestamp > 5000) {
                        pred.actual = this.mesh.position.clone();
                    }
                });
            }
            
            getRoleBonus() {
                switch (this.role) {
                    case 'leader': return this.leadershipScore * 0.5;
                    case 'explorer': return this.explorationBonus * 0.3;
                    case 'follower': return this.cooperationScore * 0.2;
                    case 'scout': return this.distanceTraveled * 0.1;
                    default: return 0;
                }
            }
            
            getEfficiencyBonus() {
                // Reward efficient decision making
                return this.decisionQuality * 0.1 + this.predictiveAccuracy * 50;
            }
            
            trackExploration() {
                const area = `${Math.floor(this.mesh.position.x / 25)},${Math.floor(this.mesh.position.z / 25)}`;
                if (!this.visitedAreas.has(area)) {
                    this.visitedAreas.add(area);
                    this.explorationBonus += 10;
                }
            }
            
            updateVisuals() {
                // Update car color based on role and performance
                this.updateCarColor();
                this.updateFlockVisualization();
                
                // Brain indicator pulsing based on activity
                const brainActivity = this.brain.memory.reduce((sum, val) => sum + Math.abs(val), 0);
                this.brainIndicator.material.opacity = 0.5 + (brainActivity * 0.1);
            }
            
            updateCarColor() {
                const hue = this.speciesId * 0.2;
                let saturation = 0.8;
                let lightness = 0.6;
                
                // Role-based color modifications
                switch (this.role) {
                    case 'leader':
                        saturation = 1.0;
                        lightness = 0.7;
                        break;
                    case 'explorer':
                        saturation = 0.9;
                        lightness = 0.8;
                        break;
                    case 'follower':
                        saturation = 0.7;
                        lightness = 0.5;
                        break;
                }
                
                // Performance-based brightness
                const performanceBonus = Math.min(this.rawFitness / 1000, 0.3);
                lightness += performanceBonus;
                
                this.bodyMaterial.color.setHSL(hue, saturation, lightness);
            }
            
            updateFlockVisualization() {
                if (!showFlockLines) return;
                
                const nearestNeighbors = this.neighbors
                    .sort((a, b) => {
                        const distA = this.mesh.position.distanceTo(a.mesh.position);
                        const distB = this.mesh.position.distanceTo(b.mesh.position);
                        return distA - distB;
                    })
                    .slice(0, 8);
                
                for (let i = 0; i < this.flockLines.length; i++) {
                    if (i < nearestNeighbors.length) {
                        const start = this.mesh.position.clone();
                        start.y = 2;
                        const end = nearestNeighbors[i].mesh.position.clone();
                        end.y = 2;
                        
                        this.flockLines[i].geometry.setFromPoints([start, end]);
                        this.flockLines[i].visible = true;
                        
                        // Color based on relationship
                        if (nearestNeighbors[i].role === 'leader') {
                            this.flockLines[i].material.color.setHex(0xff00ff);
                        } else {
                            this.flockLines[i].material.color.setHex(0x00ff00);
                        }
                    } else {
                        this.flockLines[i].visible = false;
                    }
                }
            }
            
            getObstacles() {
                let obstacles = [];
                population.forEach(car => {
                    if (car !== this && !car.crashed) {
                        obstacles.push(car.mesh);
                    }
                });
                
                world.buildings.forEach(building => {
                    obstacles.push(building.mesh);
                });
                
                world.dynamicObstacles.forEach(obstacle => {
                    obstacles.push(obstacle.mesh);
                });
                
                return obstacles;
            }
            
            checkCollisions() {
                const carBox = new THREE.Box3().setFromObject(this.mesh);
                
                // Enhanced collision detection
                population.forEach(otherCar => {
                    if (otherCar !== this && !otherCar.crashed) {
                        const otherBox = new THREE.Box3().setFromObject(otherCar.mesh);
                        if (carBox.intersectsBox(otherBox)) {
                            // Soft collision - reduce speed instead of crash
                            const collisionForce = new THREE.Vector3()
                                .subVectors(this.mesh.position, otherCar.mesh.position)
                                .normalize()
                                .multiplyScalar(5);
                            
                            this.velocity.add(collisionForce);
                            otherCar.velocity.sub(collisionForce);
                            
                            // Small fitness penalty
                            this.rawFitness -= 10;
                            otherCar.rawFitness -= 10;
                        }
                    }
                });
                
                // Building collisions
                world.buildings.forEach(building => {
                    const buildingBox = new THREE.Box3().setFromObject(building.mesh);
                    if (carBox.intersectsBox(buildingBox)) {
                        this.crashed = true;
                        crashCount++;
                    }
                });
            }
            
            keepInBounds() {
                const bounds = 400;
                if (Math.abs(this.mesh.position.x) > bounds || 
                    Math.abs(this.mesh.position.z) > bounds) {
                    if (Math.abs(this.mesh.position.x) > bounds) {
                        this.mesh.position.x = Math.sign(this.mesh.position.x) * bounds;
                        this.velocity.x *= -0.7;
                    }
                    if (Math.abs(this.mesh.position.z) > bounds) {
                        this.mesh.position.z = Math.sign(this.mesh.position.z) * bounds;
                        this.velocity.z *= -0.7;
                    }
                    this.rawFitness -= 5; // Boundary penalty
                }
            }
            
            destroy() {
                this.flockLines.forEach(line => {
                    if (line.parent) scene.remove(line);
                });
                if (this.mesh.parent) {
                    scene.remove(this.mesh);
                }
            }
        }

        // Enhanced speciation system
        function calculateCompatibility(brain1, brain2) {
            let weightDiff = 0;
            let totalWeights = 0;
            
            // Compare all weight matrices
            for (let layer = 0; layer < brain1.weights.length; layer++) {
                for (let i = 0; i < brain1.weights[layer].length; i++) {
                    for (let j = 0; j < brain1.weights[layer][i].length; j++) {
                        weightDiff += Math.abs(brain1.weights[layer][i][j] - brain2.weights[layer][i][j]);
                        totalWeights++;
                    }
                }
            }
            
            // Compare personality traits
            let traitDiff = 0;
            Object.keys(brain1.personalityTraits).forEach(trait => {
                traitDiff += Math.abs(brain1.personalityTraits[trait] - brain2.personalityTraits[trait]);
            });
            
            return (weightDiff / totalWeights) + (traitDiff / 5);
        }
        
        function speciate() {
            species = [];
            
            population.forEach(individual => {
                let foundSpecies = false;
                
                for (let s of species) {
                    if (s.members.length > 0) {
                        const representative = s.members[0];
                        const compatibility = calculateCompatibility(individual.brain, representative.brain);
                        
                        if (compatibility < SPECIES_THRESHOLD) {
                            s.members.push(individual);
                            individual.speciesId = s.id;
                            foundSpecies = true;
                            break;
                        }
                    }
                }
                
                if (!foundSpecies) {
                    const newSpecies = {
                        id: species.length,
                        members: [individual],
                        avgFitness: 0,
                        staleness: 0,
                        bestFitness: 0
                    };
                    species.push(newSpecies);
                    individual.speciesId = newSpecies.id;
                }
            });
            
            // Calculate species fitness
            species.forEach(s => {
                if (s.members.length > 0) {
                    s.avgFitness = s.members.reduce((sum, ind) => sum + ind.rawFitness, 0) / s.members.length;
                    s.bestFitness = Math.max(...s.members.map(ind => ind.rawFitness));
                    
                    // Adjust individual fitness by species size (fitness sharing)
                    s.members.forEach(ind => {
                        ind.adjustedFitness = ind.rawFitness / s.members.length;
                    });
                }
            });
            
            // Remove empty species
            species = species.filter(s => s.members.length > 0);
        }

        function init() {
            // Enhanced scene setup
            scene = new THREE.Scene();
            scene.background = new THREE.Color(0x87CEEB);
            scene.fog = new THREE.Fog(0x87CEEB, 400, 1200);
            
            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 2000);
            camera.position.set(0, 120, 120);
            camera.lookAt(0, 0, 0);
            
            renderer = new THREE.WebGLRenderer({ antialias: true });
            renderer.setSize(window.innerWidth, window.innerHeight);
            renderer.shadowMap.enabled = true;
            renderer.shadowMap.type = THREE.PCFSoftShadowMap;
            renderer.setClearColor(0x001122);
            document.body.appendChild(renderer.domElement);
            
            // Enhanced lighting
            const ambientLight = new THREE.AmbientLight(0x404040, 0.6);
            scene.add(ambientLight);
            
            const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
            directionalLight.position.set(100, 100, 50);
            directionalLight.castShadow = true;
            directionalLight.shadow.mapSize.width = 2048;
            directionalLight.shadow.mapSize.height = 2048;
            scene.add(directionalLight);
            
            // Create enhanced world
            createEnhancedWorld();
            createInitialPopulation();
            
            clock = new THREE.Clock();
            
            // Event listeners
            window.addEventListener('resize', onWindowResize);
            setupEventListeners();
            
            animate();
        }

        function createEnhancedWorld() {
            // Enhanced ground with texture variation
            const groundGeometry = new THREE.PlaneGeometry(1000, 1000);
            const groundMaterial = new THREE.MeshLambertMaterial({ 
                color: 0x228B22,
                transparent: true,
                opacity: 0.9
            });
            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
            ground.rotation.x = -Math.PI / 2;
            ground.receiveShadow = true;
            scene.add(ground);
            
            createRoadNetwork();
            createObstacles();
            createDynamicEnvironment();
        }

        function createRoadNetwork() {
            const roadMaterial = new THREE.MeshLambertMaterial({ color: 0x444444 });
            
            for (let i = -300; i <= 300; i += 150) {
                // Horizontal roads
                const hRoadGeometry = new THREE.PlaneGeometry(600, 12);
                const hRoad = new THREE.Mesh(hRoadGeometry, roadMaterial);
                hRoad.rotation.x = -Math.PI / 2;
                hRoad.position.set(0, 0.1, i);
                scene.add(hRoad);
                
                // Vertical roads
                const vRoadGeometry = new THREE.PlaneGeometry(12, 600);
                const vRoad = new THREE.Mesh(vRoadGeometry, roadMaterial);
                vRoad.rotation.x = -Math.PI / 2;
                vRoad.position.set(i, 0.1, 0);
                scene.add(vRoad);
            }
        }

        function createObstacles() {
            world.buildings = [];
            const buildingMaterial = new THREE.MeshLambertMaterial({ color: 0x666666 });
            
            for (let i = 0; i < 20; i++) {
                const x = (Math.random() - 0.5) * 700;
                const z = (Math.random() - 0.5) * 700;
                const width = 12 + Math.random() * 25;
                const height = 8 + Math.random() * 35;
                const depth = 12 + Math.random() * 25;
                
                const buildingGeometry = new THREE.BoxGeometry(width, height, depth);
                const building = new THREE.Mesh(buildingGeometry, buildingMaterial);
                building.position.set(x, height / 2, z);
                building.castShadow = true;
                scene.add(building);
                
                world.buildings.push({ mesh: building });
            }
        }

        function createDynamicEnvironment() {
            // Create exploration targets
            world.targets = [];
            for (let i = 0; i < 8; i++) {
                const target = {
                    position: new THREE.Vector3(
                        (Math.random() - 0.5) * 600,
                        5,
                        (Math.random() - 0.5) * 600
                    ),
                    discovered: false
                };
                
                // Visual target
                const targetGeometry = new THREE.SphereGeometry(3, 8, 6);
                const targetMaterial = new THREE.MeshLambertMaterial({ 
                    color: 0x00ff00,
                    transparent: true,
                    opacity: 0.7
                });
                target.mesh = new THREE.Mesh(targetGeometry, targetMaterial);
                target.mesh.position.copy(target.position);
                scene.add(target.mesh);
                
                world.targets.push(target);
            }
        }

        function createInitialPopulation() {
            population = [];
            
            for (let i = 0; i < populationSize; i++) {
                const angle = (i / populationSize) * Math.PI * 2;
                const radius = 40 + Math.random() * 60;
                const x = Math.cos(angle) * radius;
                const z = Math.sin(angle) * radius;
                
                const car = new EnhancedAICar(x, z);
                population.push(car);
                scene.add(car.mesh);
            }
            
            speciate();
        }

        function evolvePopulation() {
            speciate();
            
            // Advanced evolution with speciation
            const totalAdjustedFitness = population.reduce((sum, ind) => sum + ind.adjustedFitness, 0);
            const newPopulation = [];
            
            // Determine offspring allocation per species
            species.forEach(s => {
                if (s.members.length === 0) return;
                
                const speciesFitness = s.members.reduce((sum, ind) => sum + ind.adjustedFitness, 0);
                const offspringCount = Math.floor((speciesFitness / totalAdjustedFitness) * populationSize);
                
                // Sort species members by fitness
                s.members.sort((a, b) => b.adjustedFitness - a.adjustedFitness);
                
                // Elite selection
                const eliteCount = Math.max(1, Math.floor(offspringCount * 0.2));
                for (let i = 0; i < eliteCount && i < s.members.length; i++) {
                    const elite = s.members[i];
                    const angle = Math.random() * Math.PI * 2;
                    const radius = 40 + Math.random() * 60;
                    const newCar = new EnhancedAICar(
                        Math.cos(angle) * radius,
                        Math.sin(angle) * radius
                    );
                    newCar.brain = elite.brain.copy();
                    newCar.speciesId = s.id;
                    newPopulation.push(newCar);
                }
                
                // Crossover and mutation
                while (newPopulation.filter(car => car.speciesId === s.id).length < offspringCount) {
                    const parent1 = tournamentSelection(s.members);
                    const parent2 = tournamentSelection(s.members);
                    
                    const angle = Math.random() * Math.PI * 2;
                    const radius = 40 + Math.random() * 60;
                    const child = new EnhancedAICar(
                        Math.cos(angle) * radius,
                        Math.sin(angle) * radius
                    );
                    
                    if (Math.random() < 0.7) {
                        child.brain = parent1.brain.crossover(parent2.brain);
                    } else {
                        child.brain = parent1.brain.copy();
                    }
                    
                    // Adaptive mutation
                    const mutationRate = 0.05 + (s.staleness * 0.01);
                    child.brain.mutate(mutationRate, Math.random() < 0.1);
                    
                    child.speciesId = s.id;
                    newPopulation.push(child);
                }
            });
            
            // Fill any remaining slots
            while (newPopulation.length < populationSize) {
                const randomSpecies = species[Math.floor(Math.random() * species.length)];
                if (randomSpecies.members.length > 0) {
                    const parent = randomSpecies.members[0];
                    const angle = Math.random() * Math.PI * 2;
                    const radius = 40 + Math.random() * 60;
                    const child = new EnhancedAICar(
                        Math.cos(angle) * radius,
                        Math.sin(angle) * radius
                    );
                    child.brain = parent.brain.copy();
                    child.brain.mutate(0.3, true); // High mutation for diversity
                    child.speciesId = parent.speciesId;
                    newPopulation.push(child);
                }
            }
            
            // Clean up old population
            population.forEach(car => car.destroy());
            
            // Replace population
            population = newPopulation;
            population.forEach(car => scene.add(car.mesh));
            
            // Update epoch
            epoch++;
            timeLeft = epochTime;
            bestFitness = Math.max(bestFitness, ...population.map(car => car.rawFitness));
            crashCount = 0;
            
            console.log(`Epoch ${epoch}: ${species.length} species, best fitness: ${bestFitness.toFixed(1)}`);
        }

        function tournamentSelection(individuals, tournamentSize = 3) {
            let best = null;
            let bestFitness = -1;
            
            for (let i = 0; i < tournamentSize; i++) {
                const candidate = individuals[Math.floor(Math.random() * individuals.length)];
                if (candidate.adjustedFitness > bestFitness) {
                    best = candidate;
                    bestFitness = candidate.adjustedFitness;
                }
            }
            
            return best;
        }

        function animate() {
            requestAnimationFrame(animate);
            
            if (!paused) {
                const deltaTime = Math.min(clock.getDelta() * speedMultiplier, 0.1);
                
                // Update timer
                timeLeft -= deltaTime;
                if (timeLeft <= 0) {
                    evolvePopulation();
                }
                
                // Update population
                updatePopulation(deltaTime);
                updateCamera();
                updateUI();
                updateDynamicEnvironment(deltaTime);
            }
            
            renderer.render(scene, camera);
        }

        function updatePopulation(deltaTime) {
            let stats = {
                alive: 0,
                leaders: 0,
                followers: 0,
                explorers: 0,
                scouts: 0,
                totalVelocity: 0,
                totalCooperation: 0,
                totalExploration: 0,
                totalDecisionQuality: 0,
                totalNeuralComplexity: 0,
                maxGroupSize: 0
            };
            
            population.forEach(car => {
                car.update(deltaTime);
                
                if (!car.crashed) {
                    stats.alive++;
                    stats.totalVelocity += car.velocity.length();
                    stats.totalDecisionQuality += car.decisionQuality;
                    stats.totalNeuralComplexity += car.brain.getComplexity();
                    stats.maxGroupSize = Math.max(stats.maxGroupSize, car.neighbors.length + 1);
                    
                    switch (car.role) {
                        case 'leader': stats.leaders++; break;
                        case 'follower': stats.followers++; break;
                        case 'explorer': stats.explorers++; break;
                        case 'scout': stats.scouts++; break;
                    }
                    
                    stats.totalCooperation += car.cooperationScore;
                    stats.totalExploration += car.explorationBonus;
                }
            });
            
            // Store stats for UI
            window.populationStats = stats;
        }

        function updateCamera() {
            if (cameraMode === 'follow') {
                // Follow the best performing car or largest flock
                let target = population.reduce((best, car) => {
                    if (car.crashed) return best;
                    return !best || car.rawFitness > best.rawFitness ? car : best;
                }, null);
                
                if (target) {
                    const targetPos = target.mesh.position.clone();
                    targetPos.y += 50;
                    targetPos.add(target.velocity.clone().normalize().multiplyScalar(30));
                    
                    camera.position.lerp(targetPos, 0.02);
                    camera.lookAt(target.mesh.position);
                }
            } else {
                camera.position.lerp(new THREE.Vector3(0, 200, 200), 0.02);
                camera.lookAt(0, 0, 0);
            }
        }

        function updateUI() {
            const stats = window.populationStats || {};
            
            // Main UI
            document.getElementById('epoch').textContent = epoch;
            document.getElementById('epochTime').textContent = Math.ceil(timeLeft);
            document.getElementById('population').textContent = stats.alive || 0;
            document.getElementById('speciesCount').textContent = species.length;
            document.getElementById('bestFitness').textContent = Math.round(bestFitness);
            document.getElementById('innovationCount').textContent = innovationCounter;
            
            // Progress bar
            const progress = ((epochTime - timeLeft) / epochTime) * 100;
            document.getElementById('timeProgress').style.width = `${progress}%`;
            
            // AI Stats
            if (stats.alive > 0) {
                document.getElementById('avgIQ').textContent = Math.round(stats.totalDecisionQuality / stats.alive);
                document.getElementById('neuralComplexity').textContent = Math.round(stats.totalNeuralComplexity / stats.alive);
                document.getElementById('decisionQuality').textContent = Math.round(stats.totalDecisionQuality / stats.alive);
                document.getElementById('avgCoordination').textContent = Math.round((stats.totalCooperation / stats.alive) * 10);
            }
            
            // Flocking stats
            document.getElementById('leaderCount').textContent = stats.leaders || 0;
            document.getElementById('followerCount').textContent = stats.followers || 0;
            document.getElementById('explorerCount').textContent = stats.explorers || 0;
            document.getElementById('soloCount').textContent = stats.scouts || 0;
            document.getElementById('largestFlock').textContent = stats.maxGroupSize || 0;
            
            // Generation stats
            const totalDistance = population.reduce((sum, car) => sum + car.distanceTraveled, 0);
            const totalExploration = population.reduce((sum, car) => sum + car.explorationBonus, 0);
            const totalCooperation = population.reduce((sum, car) => sum + car.cooperationScore, 0);
            
            document.getElementById('totalDistance').textContent = Math.round(totalDistance);
            document.getElementById('explorationBonus').textContent = Math.round(totalExploration);
            document.getElementById('cooperationScore').textContent = Math.round(totalCooperation);
            document.getElementById('crashCount').textContent = crashCount;
            
            // Top performers
            updateTopPerformers();
        }

        function updateTopPerformers() {
            const sorted = [...population]
                .filter(car => !car.crashed)
                .sort((a, b) => b.rawFitness - a.rawFitness)
                .slice(0, 5);
            
            const topPerformersDiv = document.getElementById('topPerformers');
            topPerformersDiv.innerHTML = '';
            
            sorted.forEach((car, i) => {
                const div = document.createElement('div');
                const roleIcon = {
                    leader: '👑',
                    explorer: '🔍',
                    follower: '🤝',
                    scout: '👁️'
                }[car.role] || '🚗';
                
                div.innerHTML = `${i + 1}. ${roleIcon} S${car.speciesId} | IQ:${Math.round(car.decisionQuality)} | F:${Math.round(car.rawFitness)}`;
                div.className = `species-${car.speciesId % 5}`;
                topPerformersDiv.appendChild(div);
            });
        }

        function updateDynamicEnvironment(deltaTime) {
            // Update targets
            world.targets.forEach(target => {
                // Pulsing animation
                target.mesh.scale.setScalar(1 + Math.sin(Date.now() * 0.005) * 0.1);
                
                // Check if discovered
                population.forEach(car => {
                    if (!car.crashed && target.mesh.position.distanceTo(car.mesh.position) < 10) {
                        if (!target.discovered) {
                            target.discovered = true;
                            car.explorationBonus += 50;
                            target.mesh.material.color.setHex(0xffff00);
                        }
                    }
                });
            });
        }

        function setupEventListeners() {
            document.getElementById('pauseBtn').addEventListener('click', togglePause);
            document.getElementById('resetBtn').addEventListener('click', resetSimulation);
            document.getElementById('speedBtn').addEventListener('click', toggleSpeed);
            document.getElementById('viewBtn').addEventListener('click', toggleView);
            document.getElementById('flockBtn').addEventListener('click', toggleFlockLines);
            document.getElementById('adaptiveBtn').addEventListener('click', toggleAdaptive);
            document.getElementById('challengeBtn').addEventListener('click', toggleChallenge);
        }

        function togglePause() {
            paused = !paused;
            document.getElementById('pauseBtn').textContent = paused ? 'Resume' : 'Pause';
            if (!paused) clock.start();
        }

        function resetSimulation() {
            epoch = 1;
            timeLeft = epochTime;
            bestFitness = 0;
            crashCount = 0;
            innovationCounter = 0;
            
            population.forEach(car => car.destroy());
            createInitialPopulation();
        }

        function toggleSpeed() {
            speedMultiplier = speedMultiplier === 1 ? 2 : speedMultiplier === 2 ? 5 : 1;
            document.getElementById('speedBtn').textContent = `Speed: ${speedMultiplier}x`;
        }

        function toggleView() {
            cameraMode = cameraMode === 'follow' ? 'overview' : 'follow';
            document.getElementById('viewBtn').textContent = `View: ${cameraMode === 'follow' ? 'Follow' : 'Overview'}`;
        }

        function toggleFlockLines() {
            showFlockLines = !showFlockLines;
            document.getElementById('flockBtn').textContent = `Flocks: ${showFlockLines ? 'ON' : 'OFF'}`;
        }

        function toggleAdaptive() {
            adaptiveEnvironment = !adaptiveEnvironment;
            document.getElementById('adaptiveBtn').textContent = `Adaptive: ${adaptiveEnvironment ? 'ON' : 'OFF'}`;
        }

        function toggleChallenge() {
            const levels = ['normal', 'hard', 'extreme'];
            const currentIndex = levels.indexOf(challengeLevel);
            challengeLevel = levels[(currentIndex + 1) % levels.length];
            document.getElementById('challengeBtn').textContent = `Challenge: ${challengeLevel}`;
        }

        function onWindowResize() {
            camera.aspect = window.innerWidth / window.innerHeight;
            camera.updateProjectionMatrix();
            renderer.setSize(window.innerWidth, window.innerHeight);
        }

        init();
    </script>
</body>
</html>