Datasets:

webxos
/

BCI-FPS

+<!-- CONTINUATION OF THE PREVIOUS HTML WITH COMPLETE GAME CODE -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>BCI-FPS: Neuralink Brain-Computer Interface Training</title>
+    <style>
+        /* Previous styles remain the same, adding only new styles */
+        /* === VISUAL STIMULI === */
+        .vstim-target {
+            position: absolute;
+            width: 100px;
+            height: 100px;
+            border: 3px solid #0ff;
+            border-radius: 50%;
+            pointer-events: none;
+            z-index: 6;
+            box-shadow: 0 0 50px #0ff;
+            opacity: 0;
+        }
+        .vstim-active {
+            animation: vstimPulse 0.5s infinite alternate;
+        }
+        @keyframes vstimPulse {
+            from { opacity: 0.3; }
+            to { opacity: 1; }
+        }
+        /* === HANDWRITING TRAINING UI === */
+        #handwritingCanvas {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 10, 0, 0.9);
+            border: 2px solid #0f0;
+            border-radius: 10px;
+            z-index: 100;
+            display: none;
+        }
+        .handwriting-prompt {
+            position: fixed;
+            top: 30%;
+            left: 50%;
+            transform: translateX(-50%);
+            color: #0f0;
+            font-size: 24px;
+            text-align: center;
+            z-index: 101;
+            background: rgba(0, 20, 0, 0.9);
+            padding: 20px;
+            border: 2px solid #0f0;
+            border-radius: 10px;
+            display: none;
+        }
+    </style>
+</head>
+<body>
+    <!-- NEURAL NETWORK BACKGROUND -->
+    <div class="neural-background" id="neuralBackground"></div>
+    <!-- MAIN MENU -->
+    <div id="mainMenu">
+        <div class="menu-container">
+            <h1 class="bci-title">BCI-FPS</h1>
+            <p class="bci-subtitle">Neuralink Brain-Computer Interface Training Platform</p>
+            <div class="research-mission">
+                <div class="mission-title">RESEARCH MISSION</div>
+                <p class="mission-text">
+                    *UNDER DEVELOPMENT* by webXOS 2025 // webxos.netlify.pp. Record FPS Game Data for Hugging Face.
+                    This platform generates high-bandwidth neural training data for frontier BCI research.
+                    Through FPS gameplay, we capture simultaneous intent decoding, calibration-free interface training,
+                    and task-optimized neural models. All data supports disability research and Neuralink development.
+                </p>
+            </div>
+            <div class="menu-buttons">
+                <button class="bci-btn" onclick="startBCITraining('motor_imagery')">
+                    <span class="btn-icon">🧠</span> MOTOR IMAGERY TRAINING
+                </button>
+                <button class="bci-btn" onclick="startBCITraining('simultaneous_intent')">
+                    <span class="btn-icon">🎯</span> SIMULTANEOUS INTENT DECODING
+                </button>
+                <button class="bci-btn" onclick="startBCITraining('visual_evoked')">
+                    <span class="btn-icon">👁️</span> VISUAL EVOKED POTENTIALS
+                </button>
+                <button class="bci-btn" onclick="startBCITraining('handwriting_intent')">
+                    <span class="btn-icon">✍️</span> HANDWRITING INTENT
+                </button>
+                <button class="bci-btn" onclick="startBCITraining('full_spectrum')">
+                    <span class="btn-icon">⚡</span> FULL SPECTRUM TRAINING
+                </button>
+            </div>
+            <div class="research-mission" style="margin-top: 30px;">
+                <div class="mission-title">EXPORT OPTIONS</div>
+                <div style="display: flex; gap: 15px; justify-content: center; margin-top: 15px;">
+                    <button class="bci-btn" onclick="exportDataset()" style="width: 200px; padding: 15px 30px;">
+                        <span class="btn-icon">📊</span> EXPORT DATASET
+                    </button>
+                    <button class="bci-btn" onclick="showDataPreview()" style="width: 200px; padding: 15px 30px;">
+                        <span class="btn-icon">👁️</span> PREVIEW DATA
+                    </button>
+                </div>
+            </div>
+        </div>
+    </div>
+    <!-- GAME CONTAINER -->
+    <div id="gameContainer"></div>
+    <!-- UI OVERLAY -->
+    <div id="uiOverlay" style="display: none;">
+        <!-- NEURAL ACTIVITY PANEL -->
+        <div id="neuralPanel" class="hud-panel">
+            <div class="neural-header">NEURAL ACTIVITY</div>
+            <div class="neural-grid" id="neuralChannels">
+                <!-- Neural channels will be populated dynamically -->
+            </div>
+        </div>
+        <!-- BCI INTENT PANEL -->
+        <div id="intentPanel" class="hud-panel">
+            <div class="neural-header">INTENT DECODING</div>
+            <div class="intent-grid" id="intentGrid">
+                <!-- Intent items will be populated dynamically -->
+            </div>
+        </div>
+        <!-- PERFORMANCE PANEL -->
+        <div id="performancePanel" class="hud-panel">
+            <div class="neural-header">PERFORMANCE METRICS</div>
+            <div class="performance-grid">
+                <div class="metric-item">
+                    <div class="metric-label">Bandwidth</div>
+                    <div class="metric-value" id="bandwidthValue">60 Hz</div>
+                </div>
+                <div class="metric-item">
+                    <div class="metric-label">Accuracy</div>
+                    <div class="metric-value" id="accuracyValue">0%</div>
+                </div>
+                <div class="metric-item">
+                    <div class="metric-label">Intent Latency</div>
+                    <div class="metric-value" id="latencyValue">0 ms</div>
+                </div>
+                <div class="metric-item">
+                    <div class="metric-label">Simultaneous Intents</div>
+                    <div class="metric-value" id="intentsValue">0</div>
+                </div>
+            </div>
+        </div>
+        <!-- DATA STREAM PANEL -->
+        <div id="dataStreamPanel" class="hud-panel">
+            <div class="neural-header">DATA STREAM</div>
+            <div class="data-stream">
+                <div class="stream-line" id="dataStream"></div>
+            </div>
+        </div>
+    </div>
+    <!-- CROSSHAIR -->
+    <div id="crosshair" style="display: none;">
+        <div class="crosshair-dot"></div>
+        <div class="crosshair-line horizontal left"></div>
+        <div class="crosshair-line horizontal right"></div>
+        <div class="crosshair-line vertical top"></div>
+        <div class="crosshair-line vertical bottom"></div>
+    </div>
+    <!-- TASK INDICATOR -->
+    <div id="taskIndicator">
+        <div class="task-title" id="taskTitle">MOTOR IMAGERY TRAINING</div>
+        <div class="task-description" id="taskDescription">
+            Imagine moving your cursor to the target. This trains motor cortex decoding.
+        </div>
+        <div class="task-progress">
+            <div class="task-progress-bar" id="taskProgress"></div>
+        </div>
+        <div style="color: #0a0; font-size: 14px;" id="taskStatus">Starting...</div>
+    </div>
+    <!-- EXPERIMENT COMPLETE MODAL -->
+    <div id="experimentComplete">
+        <div class="experiment-content">
+            <div class="experiment-title">TRAINING SESSION COMPLETE</div>
+            <p style="color: #0a0; margin: 20px 0; line-height: 1.6;">
+                High-bandwidth neural training data has been successfully recorded.<br>
+                This dataset can be used for Neuralink research and disability support development.
+            </p>
+            <div class="experiment-results" id="experimentResults">
+                <!-- Results populated dynamically -->
+            </div>
+            <div style="margin: 30px 0;">
+                <button class="bci-btn" onclick="exportDataset()" style="width: 250px; margin: 10px;">
+                    <span class="btn-icon">📊</span> EXPORT TO HUGGING FACE
+                </button>
+                <button class="bci-btn" onclick="restartTraining()" style="width: 250px; margin: 10px;">
+                    <span class="btn-icon">🔄</span> RESTART TRAINING
+                </button>
+                <button class="bci-btn" onclick="returnToMenu()" style="width: 250px; margin: 10px;">
+                    <span class="btn-icon">🏠</span> RETURN TO MENU
+                </button>
+            </div>
+        </div>
+    </div>
+    <!-- BCI CONTROL PANEL -->
+    <div id="bciControlPanel" style="display: none;">
+        <button class="bci-control-btn" onclick="pauseTraining()">⏸ PAUSE</button>
+        <button class="bci-control-btn" onclick="skipTask()">⏭ SKIP</button>
+        <button class="bci-control-btn" onclick="endSession()">⏹ END</button>
+        <button class="bci-control-btn" onclick="toggleVisualStimuli()">💡 STIMULI</button>
+    </div>
+    <!-- HANDWRITING CANVAS -->
+    <canvas id="handwritingCanvas" width="800" height="600"></canvas>
+    <div class="handwriting-prompt" id="handwritingPrompt"></div>
+    <!-- Three.js & JSZip Libraries -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script>
+    <script>
+        // ========== GLOBAL CONFIGURATION ==========
+        const CONFIG = {
+            // BCI Research Parameters
+            SAMPLING_RATE: 1000, // Hz - Neuralink-level sampling
+            BANDWIDTH: 60, // FPS for visual rendering
+            INTENT_DECODING_WINDOW: 100, // ms window for intent analysis
+            // Game Parameters
+            VISUAL_STIMULI_FREQUENCIES: [5, 10, 15, 20, 25], // Hz for c-VEP
+            MOTOR_IMAGERY_TRIALS: 50,
+            SIMULTANEOUS_INTENT_TASKS: 20,
+            HANDWRITING_SAMPLES: 10,
+            // Data Collection
+            MAX_SAMPLES: 1000000,
+            COMPRESSION_ENABLED: true,
+            EXPORT_FORMAT: 'arrow', // 'arrow', 'jsonl', 'parquet'
+            // Neural Simulation
+            NEURAL_CHANNELS: 32,
+            NOISE_LEVEL: 0.1,
+            SIGNAL_STRENGTH: 0.8
+        };
+        // ========== GLOBAL STATE ==========
+        let scene, camera, renderer;
+        let player, controls = {};
+        let targets = [];
+        let neuralData = [];
+        let intentStream = [];
+        let visualStimuli = [];
+        let handwritingSamples = [];
+        let currentMode = null;
+        let currentTask = 0;
+        let totalTasks = 0;
+        let taskStartTime = 0;
+        let sessionStartTime = 0;
+        let mouse = { x: 0, y: 0, dx: 0, dy: 0 };
+        let keyboard = {};
+        let fpsCounter = 0;
+        let lastFpsTime = 0;
+        let currentFps = 60;
+        let neuralBackgroundInterval;
+        let dataStreamInterval;
+        // ========== INITIALIZATION ==========
+        function initNeuralBackground() {
+            const bg = document.getElementById('neuralBackground');
+            bg.innerHTML = '';
+            // Create neural nodes
+            for (let i = 0; i < 50; i++) {
+                const node = document.createElement('div');
+                node.className = 'neural-node';
+                node.style.left = `${Math.random() * 100}%`;
+                node.style.top = `${Math.random() * 100}%`;
+                bg.appendChild(node);
+            }
+            // Create connections
+            const nodes = bg.querySelectorAll('.neural-node');
+            nodes.forEach((node1, i) => {
+                nodes.forEach((node2, j) => {
+                    if (i < j && Math.random() < 0.1) {
+                        const x1 = parseFloat(node1.style.left);
+                        const y1 = parseFloat(node1.style.top);
+                        const x2 = parseFloat(node2.style.left);
+                        const y2 = parseFloat(node2.style.top);
+                        const length = Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
+                        const angle = Math.atan2(y2 - y1, x2 - x1) * 180 / Math.PI;
+                        const connection = document.createElement('div');
+                        connection.className = 'neural-connection';
+                        connection.style.width = `${length}%`;
+                        connection.style.left = `${x1}%`;
+                        connection.style.top = `${y1}%`;
+                        connection.style.transform = `rotate(${angle}deg)`;
+                        bg.appendChild(connection);
+                    }
+                });
+            });
+            // Animate nodes
+            neuralBackgroundInterval = setInterval(() => {
+                nodes.forEach(node => {
+                    node.style.left = `${Math.random() * 100}%`;
+                    node.style.top = `${Math.random() * 100}%`;
+                });
+            }, 3000);
+        }
+        function initThreeJS() {
+            scene = new THREE.Scene();
+            scene.background = new THREE.Color(0x000000);
+            scene.fog = new THREE.Fog(0x000000, 50, 200);
+            camera = new THREE.PerspectiveCamera(90, window.innerWidth / window.innerHeight, 0.1, 1000);
+            camera.position.y = 1.6;
+            renderer = new THREE.WebGLRenderer({ antialias: true });
+            renderer.setSize(window.innerWidth, window.innerHeight);
+            renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+            document.getElementById('gameContainer').appendChild(renderer.domElement);
+            // Add lighting
+            const ambientLight = new THREE.AmbientLight(0x00ff00, 0.1);
+            scene.add(ambientLight);
+            const directionalLight = new THREE.DirectionalLight(0x00ff00, 0.5);
+            directionalLight.position.set(10, 20, 5);
+            scene.add(directionalLight);
+            // Create environment
+            createEnvironment();
+            // Setup controls
+            setupControls();
+            // Start animation loop
+            animate();
+        }
+        function createEnvironment() {
+            // Ground
+            const groundGeometry = new THREE.PlaneGeometry(100, 100, 50, 50);
+            const groundMaterial = new THREE.MeshBasicMaterial({
+                color: 0x003300,
+                wireframe: true,
+                transparent: true,
+                opacity: 0.3
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            scene.add(ground);
+            // Neural training targets
+            for (let i = 0; i < 20; i++) {
+                const geometry = new THREE.SphereGeometry(0.5, 8, 8);
+                const material = new THREE.MeshBasicMaterial({
+                    color: 0x00ff00,
+                    wireframe: true,
+                    transparent: true,
+                    opacity: 0.6
+                });
+                const target = new THREE.Mesh(geometry, material);
+                target.position.set(
+                    (Math.random() - 0.5) * 80,
+                    1 + Math.random() * 5,
+                    (Math.random() - 0.5) * 80
+                );
+                target.userData = {
+                    type: 'neural_target',
+                    active: false,
+                    frequency: CONFIG.VISUAL_STIMULI_FREQUENCIES[Math.floor(Math.random() * CONFIG.VISUAL_STIMULI_FREQUENCIES.length)],
+                    lastFlash: 0
+                };
+                scene.add(target);
+                targets.push(target);
+            }
+            // Create visual stimuli targets in DOM
+            for (let i = 0; i < 5; i++) {
+                const stim = document.createElement('div');
+                stim.className = 'vstim-target';
+                stim.id = `vstim-${i}`;
+                document.body.appendChild(stim);
+            }
+        }
+        function setupControls() {
+            // Mouse control
+            document.addEventListener('mousemove', (e) => {
+                if (document.pointerLockElement === document.body) {
+                    mouse.dx = e.movementX;
+                    mouse.dy = e.movementY;
+                    mouse.x += mouse.dx * 0.002;
+                    mouse.y += mouse.dy * 0.002;
+                    mouse.y = Math.max(-Math.PI/2, Math.min(Math.PI/2, mouse.y));
+                    camera.rotation.order = 'YXZ';
+                    camera.rotation.y = -mouse.x;
+                    camera.rotation.x = -mouse.y;
+                }
+            });
+            // Keyboard controls
+            document.addEventListener('keydown', (e) => {
+                const key = e.key.toLowerCase();
+                keyboard[key] = true;
+                // Record key press as intent
+                if (['w', 'a', 's', 'd', ' '].includes(key)) {
+                    recordIntent({
+                        type: 'key_press',
+                        key: key,
+                        timestamp: Date.now(),
+                        position: camera.position.toArray(),
+                        rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z]
+                    });
+                }
+            });
+            document.addEventListener('keyup', (e) => {
+                const key = e.key.toLowerCase();
+                keyboard[key] = false;
+            });
+            // Mouse click
+            document.addEventListener('mousedown', () => {
+                keyboard['mouse'] = true;
+                recordIntent({
+                    type: 'mouse_click',
+                    button: 'left',
+                    timestamp: Date.now(),
+                    target: getAimedTarget()
+                });
+            });
+            document.addEventListener('mouseup', () => {
+                keyboard['mouse'] = false;
+            });
+            // Pointer lock
+            document.body.addEventListener('click', () => {
+                if (!document.pointerLockElement) {
+                    document.body.requestPointerLock();
+                }
+            });
+            // Window resize
+            window.addEventListener('resize', () => {
+                camera.aspect = window.innerWidth / window.innerHeight;
+                camera.updateProjectionMatrix();
+                renderer.setSize(window.innerWidth, window.innerHeight);
+            });
+        }
+        // ========== BCI TRAINING MODES ==========
+        function startBCITraining(mode) {
+            currentMode = mode;
+            sessionStartTime = Date.now();
+            // Hide menu, show game
+            document.getElementById('mainMenu').style.display = 'none';
+            document.getElementById('gameContainer').style.display = 'block';
+            document.getElementById('uiOverlay').style.display = 'grid';
+            document.getElementById('crosshair').style.display = 'block';
+            document.getElementById('bciControlPanel').style.display = 'flex';
+            // Initialize UI
+            initNeuralUI();
+            initDataStream();
+            // Start specific training mode
+            switch(mode) {
+                case 'motor_imagery':
+                    startMotorImageryTraining();
+                    break;
+                case 'simultaneous_intent':
+                    startSimultaneousIntentTraining();
+                    break;
+                case 'visual_evoked':
+                    startVisualEvokedTraining();
+                    break;
+                case 'handwriting_intent':
+                    startHandwritingIntentTraining();
+                    break;
+                case 'full_spectrum':
+                    startFullSpectrumTraining();
+                    break;
+            }
+            // Start data collection
+            startDataCollection();
+        }
+        function startMotorImageryTraining() {
+            totalTasks = CONFIG.MOTOR_IMAGERY_TRIALS;
+            currentTask = 0;
+            showTaskIndicator(
+                "MOTOR IMAGERY TRAINING",
+                "Imagine moving your cursor to the target. This trains motor cortex decoding for prosthetic control.",
+                "Starting trial..."
+            );
+            setTimeout(() => {
+                nextMotorImageryTask();
+            }, 2000);
+        }
+        function nextMotorImageryTask() {
+            if (currentTask >= totalTasks) {
+                completeTraining();
+                return;
+            }
+            currentTask++;
+            taskStartTime = Date.now();
+            // Activate a random target
+            const target = targets[Math.floor(Math.random() * targets.length)];
+            target.userData.active = true;
+            target.material.color.setHex(0xffff00);
+            updateTaskIndicator(
+                `Trial ${currentTask}/${totalTasks}`,
+                `Imagine moving to the glowing target. Focus on the intent to move.`
+            );
+            // Task completion timer
+            setTimeout(() => {
+                target.userData.active = false;
+                target.material.color.setHex(0x00ff00);
+                // Record completion
+                recordNeuralData({
+                    type: 'motor_imagery_trial',
+                    trial: currentTask,
+                    duration: Date.now() - taskStartTime,
+                    target_position: target.position.toArray(),
+                    accuracy: calculateAccuracy(target)
+                });
+                // Next task
+                setTimeout(() => {
+                    nextMotorImageryTask();
+                }, 1000);
+            }, 3000);
+        }
+        function startSimultaneousIntentTraining() {
+            totalTasks = CONFIG.SIMULTANEOUS_INTENT_TASKS;
+            currentTask = 0;
+            showTaskIndicator(
+                "SIMULTANEOUS INTENT DECODING",
+                "Move (WASD) while aiming at targets. This trains decoding multiple simultaneous intents.",
+                "Starting task..."
+            );
+            setTimeout(() => {
+                nextSimultaneousIntentTask();
+            }, 2000);
+        }
+        function nextSimultaneousIntentTask() {
+            if (currentTask >= totalTasks) {
+                completeTraining();
+                return;
+            }
+            currentTask++;
+            taskStartTime = Date.now();
+            // Activate multiple targets
+            const activeTargets = [];
+            for (let i = 0; i < 3; i++) {
+                const target = targets[Math.floor(Math.random() * targets.length)];
+                target.userData.active = true;
+                target.material.color.setHex(0xff0000);
+                activeTargets.push(target);
+            }
+            updateTaskIndicator(
+                `Task ${currentTask}/${totalTasks}`,
+                `Move while aiming at all red targets. Focus on simultaneous movement and aiming.`
+            );
+            // Task runs for 5 seconds
+            setTimeout(() => {
+                activeTargets.forEach(target => {
+                    target.userData.active = false;
+                    target.material.color.setHex(0x00ff00);
+                });
+                // Record completion
+                recordNeuralData({
+                    type: 'simultaneous_intent_task',
+                    task: currentTask,
+                    duration: Date.now() - taskStartTime,
+                    active_targets: activeTargets.map(t => t.position.toArray()),
+                    simultaneous_actions: countSimultaneousActions()
+                });
+                // Next task
+                setTimeout(() => {
+                    nextSimultaneousIntentTask();
+                }, 1000);
+            }, 5000);
+        }
+        function startVisualEvokedTraining() {
+            showTaskIndicator(
+                "VISUAL EVOKED POTENTIALS",
+                "Focus on the flashing targets. This trains c-VEP decoding for non-verbal communication.",
+                "Starting visual stimulation..."
+            );
+            // Start visual stimuli
+            startVisualStimuli();
+            // Run for 60 seconds
+            setTimeout(() => {
+                stopVisualStimuli();
+                completeTraining();
+            }, 60000);
+        }
+        function startHandwritingIntentTraining() {
+            totalTasks = CONFIG.HANDWRITING_SAMPLES;
+            currentTask = 0;
+            showTaskIndicator(
+                "HANDWRITING INTENT TRAINING",
+                "Trace the letters with precision aiming. This trains fine motor control decoding.",
+                "Starting letter tracing..."
+            );
+            setTimeout(() => {
+                nextHandwritingTask();
+            }, 2000);
+        }
+        function nextHandwritingTask() {
+            if (currentTask >= totalTasks) {
+                completeTraining();
+                return;
+            }
+            currentTask++;
+            const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+            const letter = letters[Math.floor(Math.random() * letters.length)];
+            showHandwritingPrompt(letter);
+            // Record handwriting session
+            const startTime = Date.now();
+            const handwritingSession = {
+                letter: letter,
+                start_time: startTime,
+                samples: []
+            };
+            // Sample mouse movements for 3 seconds
+            const sampleInterval = setInterval(() => {
+                handwritingSession.samples.push({
+                    timestamp: Date.now(),
+                    position: [mouse.x, mouse.y],
+                    velocity: [mouse.dx, mouse.dy],
+                    pressure: Math.random() // Simulated pressure data
+                });
+            }, 16); // ~60Hz sampling
+            setTimeout(() => {
+                clearInterval(sampleInterval);
+                handwritingSession.end_time = Date.now();
+                handwritingSession.duration = Date.now() - startTime;
+                handwritingSamples.push(handwritingSession);
+                hideHandwritingPrompt();
+                // Record completion
+                recordNeuralData({
+                    type: 'handwriting_sample',
+                    sample: currentTask,
+                    letter: letter,
+                    duration: handwritingSession.duration,
+                    samples_count: handwritingSession.samples.length
+                });
+                // Next task
+                setTimeout(() => {
+                    nextHandwritingTask();
+                }, 1000);
+            }, 3000);
+        }
+        function startFullSpectrumTraining() {
+            // Run all training modes sequentially
+            const modes = [
+                { mode: 'motor_imagery', duration: 30000 },
+                { mode: 'simultaneous_intent', duration: 30000 },
+                { mode: 'visual_evoked', duration: 30000 },
+                { mode: 'handwriting_intent', duration: 30000 }
+            ];
+            let currentModeIndex = 0;
+            function runNextMode() {
+                if (currentModeIndex >= modes.length) {
+                    completeTraining();
+                    return;
+                }
+                const mode = modes[currentModeIndex];
+                currentModeIndex++;
+                showTaskIndicator(
+                    `FULL SPECTRUM TRAINING - ${mode.mode.toUpperCase()}`,
+                    `Complete the ${mode.mode.replace('_', ' ')} task.`,
+                    "Starting in 3 seconds..."
+                );
+                setTimeout(() => {
+                    // Run the mode for specified duration
+                    const startTime = Date.now();
+                    // Set up mode-specific tasks
+                    switch(mode.mode) {
+                        case 'motor_imagery':
+                            // Activate random targets
+                            const interval = setInterval(() => {
+                                const target = targets[Math.floor(Math.random() * targets.length)];
+                                target.material.color.setHex(0xffff00);
+                                setTimeout(() => {
+                                    target.material.color.setHex(0x00ff00);
+                                }, 500);
+                            }, 1000);
+                            setTimeout(() => {
+                                clearInterval(interval);
+                                runNextMode();
+                            }, mode.duration);
+                            break;
+                        case 'simultaneous_intent':
+                            // Keep targets active
+                            targets.forEach(t => {
+                                t.material.color.setHex(0xff0000);
+                                t.userData.active = true;
+                            });
+                            setTimeout(() => {
+                                targets.forEach(t => {
+                                    t.material.color.setHex(0x00ff00);
+                                    t.userData.active = false;
+                                });
+                                runNextMode();
+                            }, mode.duration);
+                            break;
+                        case 'visual_evoked':
+                            startVisualStimuli();
+                            setTimeout(() => {
+                                stopVisualStimuli();
+                                runNextMode();
+                            }, mode.duration);
+                            break;
+                        case 'handwriting_intent':
+                            // Show random letters
+                            const letters = 'ABCD';
+                            let letterIndex = 0;
+                            const letterInterval = setInterval(() => {
+                                if (letterIndex >= letters.length) {
+                                    clearInterval(letterInterval);
+                                    runNextMode();
+                                    return;
+                                }
+                                showHandwritingPrompt(letters[letterIndex]);
+                                letterIndex++;
+                                setTimeout(() => {
+                                    hideHandwritingPrompt();
+                                }, 2000);
+                            }, 3000);
+                            break;
+                    }
+                }, 3000);
+            }
+            runNextMode();
+        }
+        // ========== DATA COLLECTION ==========
+        function startDataCollection() {
+            // High-frequency data collection (1000Hz simulated)
+            setInterval(() => {
+                collectNeuralData();
+            }, 1); // 1ms interval ≈ 1000Hz
+            // Intent stream collection (60Hz)
+            setInterval(() => {
+                collectIntentStream();
+            }, 16.67); // 60Hz
+            // Performance metrics (1Hz)
+            setInterval(() => {
+                updatePerformanceMetrics();
+            }, 1000);
+        }
+        function collectNeuralData() {
+            // Simulate neural channel data
+            const neuralSample = {
+                timestamp: Date.now(),
+                session_time: Date.now() - sessionStartTime,
+                channels: {}
+            };
+            for (let i = 0; i < CONFIG.NEURAL_CHANNELS; i++) {
+                // Generate simulated neural signal
+                const baseSignal = Math.sin(Date.now() / 1000 * (i + 1)) * CONFIG.SIGNAL_STRENGTH;
+                const noise = (Math.random() - 0.5) * 2 * CONFIG.NOISE_LEVEL;
+                const intentModulation = calculateIntentModulation(i);
+                neuralSample.channels[`channel_${i}`] = baseSignal + noise + intentModulation;
+            }
+            // Add intent context
+            neuralSample.intent_context = {
+                mouse_movement: [mouse.dx, mouse.dy],
+                keyboard_state: { ...keyboard },
+                camera_rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z],
+                active_targets: targets.filter(t => t.userData.active).length
+            };
+            neuralData.push(neuralSample);
+            // Update UI
+            updateNeuralChannels(neuralSample.channels);
+        }
+        function collectIntentStream() {
+            const intentSample = {
+                timestamp: Date.now(),
+                session_time: Date.now() - sessionStartTime,
+                mouse: {
+                    position: [mouse.x, mouse.y],
+                    delta: [mouse.dx, mouse.dy],
+                    buttons: keyboard['mouse'] ? 1 : 0
+                },
+                keyboard: { ...keyboard },
+                camera: {
+                    position: camera.position.toArray(),
+                    rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z]
+                },
+                environment: {
+                    active_targets: targets.filter(t => t.userData.active).map(t => ({
+                        position: t.position.toArray(),
+                        distance: t.position.distanceTo(camera.position)
+                    })),
+                    fps: currentFps
+                }
+            };
+            intentStream.push(intentSample);
+            // Update data stream display
+            updateDataStream(intentSample);
+        }
+        function recordIntent(intent) {
+            intentStream.push({
+                ...intent,
+                session_time: Date.now() - sessionStartTime,
+                neural_context: getCurrentNeuralContext()
+            });
+        }
+        function recordNeuralData(data) {
+            neuralData.push({
+                ...data,
+                timestamp: Date.now(),
+                session_time: Date.now() - sessionStartTime,
+                intent_context: getCurrentIntentContext(),
+                neural_context: getCurrentNeuralContext()
+            });
+        }
+        // ========== UI FUNCTIONS ==========
+        function initNeuralUI() {
+            // Create neural channels
+            const channelsDiv = document.getElementById('neuralChannels');
+            channelsDiv.innerHTML = '';
+            for (let i = 0; i < 8; i++) { // Show first 8 channels
+                const channel = document.createElement('div');
+                channel.className = 'neural-channel';
+                channel.innerHTML = `
+                    <div class="channel-label">CH ${i}</div>
+                    <div class="channel-value" id="neuralChannel${i}">0.00</div>
+                `;
+                channelsDiv.appendChild(channel);
+            }
+            // Create intent grid
+            const intentGrid = document.getElementById('intentGrid');
+            intentGrid.innerHTML = '';
+            const intents = ['MOVE', 'AIM', 'FIRE', 'JUMP', 'RELOAD', 'CROUCH'];
+            intents.forEach(intent => {
+                const item = document.createElement('div');
+                item.className = 'intent-item';
+                item.id = `intent-${intent.toLowerCase()}`;
+                item.innerHTML = `
+                    <div class="intent-label">${intent}</div>
+                    <div class="intent-value">0%</div>
+                `;
+                intentGrid.appendChild(item);
+            });
+        }
+        function initDataStream() {
+            dataStreamInterval = setInterval(() => {
+                if (intentStream.length > 0) {
+                    const sample = intentStream[intentStream.length - 1];
+                    const line = `[${sample.timestamp}] INTENT: ${JSON.stringify(sample.mouse.delta)}<br>`;
+                    const stream = document.getElementById('dataStream');
+                    stream.innerHTML = line + stream.innerHTML;
+                    if (stream.children.length > 20) {
+                        stream.removeChild(stream.lastChild);
+                    }
+                }
+            }, 100);
+        }
+        function updateNeuralChannels(channels) {
+            for (let i = 0; i < 8; i++) {
+                const value = channels[`channel_${i}`];
+                const element = document.getElementById(`neuralChannel${i}`);
+                if (element && value !== undefined) {
+                    element.textContent = value.toFixed(2);
+                    // Color based on activity
+                    const absValue = Math.abs(value);
+                    if (absValue > 0.5) {
+                        element.style.color = '#ff0';
+                    } else if (absValue > 0.2) {
+                        element.style.color = '#0f0';
+                    } else {
+                        element.style.color = '#0a0';
+                    }
+                }
+            }
+        }
+        function updatePerformanceMetrics() {
+            // Calculate bandwidth (samples per second)
+            const bandwidth = neuralData.filter(d =>
+                Date.now() - d.timestamp < 1000
+            ).length;
+            document.getElementById('bandwidthValue').textContent = `${bandwidth} Hz`;
+            // Calculate accuracy
+            const hits = neuralData.filter(d =>
+                d.type === 'motor_imagery_trial' && d.accuracy > 0.7
+            ).length;
+            const totalTrials = neuralData.filter(d =>
+                d.type === 'motor_imagery_trial'
+            ).length;
+            const accuracy = totalTrials > 0 ? Math.round((hits / totalTrials) * 100) : 0;
+            document.getElementById('accuracyValue').textContent = `${accuracy}%`;
+            // Calculate latency (simulated)
+            const latency = Math.random() * 50 + 50; // 50-100ms
+            document.getElementById('latencyValue').textContent = `${latency.toFixed(1)} ms`;
+            // Count simultaneous intents
+            const simultaneous = keyboard['w'] + keyboard['a'] + keyboard['s'] + keyboard['d'] + keyboard['mouse'];
+            document.getElementById('intentsValue').textContent = simultaneous;
+            // Update intent indicators
+            updateIntentIndicators();
+        }
+        function updateIntentIndicators() {
+            const intents = ['move', 'aim', 'fire', 'jump', 'reload', 'crouch'];
+            intents.forEach(intent => {
+                const element = document.getElementById(`intent-${intent}`);
+                if (element) {
+                    // Simulate intent detection
+                    let value = 0;
+                    switch(intent) {
+                        case 'move':
+                            value = (keyboard['w'] || keyboard['a'] || keyboard['s'] || keyboard['d']) ? 100 : 0;
+                            break;
+                        case 'aim':
+                            value = Math.abs(mouse.dx) > 1 || Math.abs(mouse.dy) > 1 ? 80 : 20;
+                            break;
+                        case 'fire':
+                            value = keyboard['mouse'] ? 100 : 0;
+                            break;
+                        case 'jump':
+                            value = keyboard[' '] ? 100 : 0;
+                            break;
+                    }
+                    element.querySelector('.intent-value').textContent = `${value}%`;
+                    if (value > 50) {
+                        element.classList.add('intent-active');
+                    } else {
+                        element.classList.remove('intent-active');
+                    }
+                }
+            });
+        }
+        function updateDataStream(sample) {
+            const stream = document.getElementById('dataStream');
+            const time = new Date(sample.timestamp).toISOString().substr(11, 12);
+            const line = `[${time}] INTENT: Δ(${sample.mouse.delta[0].toFixed(2)}, ${sample.mouse.delta[1].toFixed(2)})<br>`;
+            stream.innerHTML = line + stream.innerHTML;
+            // Keep only last 20 lines
+            const lines = stream.innerHTML.split('<br>');
+            if (lines.length > 20) {
+                stream.innerHTML = lines.slice(0, 20).join('<br>');
+            }
+        }
+        // ========== VISUAL STIMULI ==========
+        function startVisualStimuli() {
+            // Position stimuli around screen
+            const positions = [
+                { x: '20%', y: '20%' },
+                { x: '80%', y: '20%' },
+                { x: '50%', y: '50%' },
+                { x: '20%', y: '80%' },
+                { x: '80%', y: '80%' }
+            ];
+            CONFIG.VISUAL_STIMULI_FREQUENCIES.forEach((freq, index) => {
+                const stim = document.getElementById(`vstim-${index}`);
+                if (stim) {
+                    stim.style.left = positions[index].x;
+                    stim.style.top = positions[index].y;
+                    stim.classList.add('vstim-active');
+                    // Flash at specified frequency
+                    setInterval(() => {
+                        stim.style.opacity = stim.style.opacity === '1' ? '0.3' : '1';
+                    }, 1000 / freq);
+                    // Record stimulus events
+                    setInterval(() => {
+                        recordNeuralData({
+                            type: 'visual_stimulus',
+                            stimulus_id: index,
+                            frequency: freq,
+                            position: positions[index],
+                            timestamp: Date.now()
+                        });
+                    }, 1000);
+                }
+            });
+        }
+        function stopVisualStimuli() {
+            for (let i = 0; i < 5; i++) {
+                const stim = document.getElementById(`vstim-${i}`);
+                if (stim) {
+                    stim.classList.remove('vstim-active');
+                    stim.style.opacity = '0';
+                }
+            }
+        }
+        function toggleVisualStimuli() {
+            const anyActive = document.querySelector('.vstim-active');
+            if (anyActive) {
+                stopVisualStimuli();
+            } else {
+                startVisualStimuli();
+            }
+        }
+        // ========== HANDWRITING TRAINING ==========
+        function showHandwritingPrompt(letter) {
+            const prompt = document.getElementById('handwritingPrompt');
+            const canvas = document.getElementById('handwritingCanvas');
+            prompt.textContent = `Trace the letter: ${letter}`;
+            prompt.style.display = 'block';
+            canvas.style.display = 'block';
+            // Clear canvas
+            const ctx = canvas.getContext('2d');
+            ctx.clearRect(0, 0, canvas.width, canvas.height);
+            ctx.strokeStyle = '#0f0';
+            ctx.lineWidth = 3;
+            ctx.font = '200px Courier New';
+            ctx.fillStyle = 'rgba(0, 255, 0, 0.1)';
+            ctx.textAlign = 'center';
+            ctx.textBaseline = 'middle';
+            ctx.fillText(letter, canvas.width/2, canvas.height/2);
+            // Start drawing
+            let drawing = false;
+            canvas.onmousedown = () => {
+                drawing = true;
+                ctx.beginPath();
+            };
+            canvas.onmousemove = (e) => {
+                if (!drawing) return;
+                const rect = canvas.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                ctx.lineTo(x, y);
+                ctx.stroke();
+            };
+            canvas.onmouseup = () => {
+                drawing = false;
+            };
+        }
+        function hideHandwritingPrompt() {
+            document.getElementById('handwritingPrompt').style.display = 'none';
+            document.getElementById('handwritingCanvas').style.display = 'none';
+        }
+        // ========== TASK MANAGEMENT ==========
+        function showTaskIndicator(title, description, status) {
+            document.getElementById('taskTitle').textContent = title;
+            document.getElementById('taskDescription').textContent = description;
+            document.getElementById('taskStatus').textContent = status;
+            document.getElementById('taskProgress').style.width = '0%';
+            document.getElementById('taskIndicator').style.display = 'block';
+        }
+        function updateTaskIndicator(status, description) {
+            document.getElementById('taskStatus').textContent = status;
+            if (description) {
+                document.getElementById('taskDescription').textContent = description;
+            }
+            // Update progress
+            const progress = totalTasks > 0 ? (currentTask / totalTasks) * 100 :
+                           (Date.now() - taskStartTime) / 60000 * 100; // For time-based tasks
+            document.getElementById('taskProgress').style.width = `${Math.min(100, progress)}%`;
+        }
+        function hideTaskIndicator() {
+            document.getElementById('taskIndicator').style.display = 'none';
+        }
+        function completeTraining() {
+            hideTaskIndicator();
+            stopVisualStimuli();
+            // Calculate session statistics
+            const sessionDuration = Date.now() - sessionStartTime;
+            const totalSamples = neuralData.length + intentStream.length;
+            const bandwidth = Math.round(totalSamples / (sessionDuration / 1000));
+            // Show results
+            document.getElementById('experimentResults').innerHTML = `
+                <div class="result-item">
+                    <div class="result-label">Training Mode</div>
+                    <div class="result-value">${currentMode.replace('_', ' ').toUpperCase()}</div>
+                </div>
+                <div class="result-item">
+                    <div class="result-label">Duration</div>
+                    <div class="result-value">${Math.round(sessionDuration / 1000)}s</div>
+                </div>
+                <div class="result-item">
+                    <div class="result-label">Samples Collected</div>
+                    <div class="result-value">${totalSamples.toLocaleString()}</div>
+                </div>
+                <div class="result-item">
+                    <div class="result-label">Data Bandwidth</div>
+                    <div class="result-value">${bandwidth} Hz</div>
+                </div>
+                <div class="result-item">
+                    <div class="result-label">Neural Channels</div>
+                    <div class="result-value">${CONFIG.NEURAL_CHANNELS}</div>
+                </div>
+                <div class="result-item">
+                    <div class="result-label">File Size</div>
+                    <div class="result-value">${Math.round((totalSamples * 0.1) / 1024)} KB</div>
+                </div>
+            `;
+            document.getElementById('experimentComplete').style.display = 'flex';
+        }
+        // ========== EXPORT FUNCTIONALITY ==========
+        async function exportDataset() {
+            const sessionId = `bci_fps_${currentMode}_${Date.now()}`;
+            // Create dataset metadata following Hugging Face format
+            const metadata = {
+                dataset_info: {
+                    name: `BCI-FPS_${currentMode.toUpperCase()}_Dataset`,
+                    description: `High-bandwidth neural training data for BCI research. Mode: ${currentMode}`,
+                    version: "1.0.0",
+                    license: "MIT",
+                    citation: `@misc{bci_fps_${currentMode}_2024,\n  title={BCI-FPS ${currentMode} Training Dataset},\n  author={Neuralink Research},\n  year={2024},\n  note={High-frequency intent decoding data for brain-computer interface development}\n}`
+                },
+                session_info: {
+                    session_id: sessionId,
+                    mode: currentMode,
+                    start_time: new Date(sessionStartTime).toISOString(),
+                    duration_ms: Date.now() - sessionStartTime,
+                    sampling_rate_hz: CONFIG.SAMPLING_RATE,
+                    neural_channels: CONFIG.NEURAL_CHANNELS
+                },
+                data_schema: {
+                    neural_data: {
+                        timestamp: "UNIX timestamp in milliseconds",
+                        session_time: "Time since session start in milliseconds",
+                        channels: "Object mapping channel names to neural signal values",
+                        intent_context: "Contextual information about user intent"
+                    },
+                    intent_stream: {
+                        timestamp: "UNIX timestamp in milliseconds",
+                        mouse: "Mouse position and movement data",
+                        keyboard: "Keyboard state",
+                        camera: "Camera position and rotation",
+                        environment: "Game environment state"
+                    },
+                    handwriting_samples: {
+                        letter: "Letter being traced",
+                        samples: "Array of handwriting samples with position and pressure data"
+                    }
+                },
+                research_applications: [
+                    "Motor imagery decoding for prosthetic control",
+                    "Simultaneous intent decoding for fluid BCI interfaces",
+                    "Visual evoked potential (c-VEP) calibration",
+                    "Handwriting intent recognition for text entry",
+                    "Neural network training for brain-computer interfaces"
+                ],
+                huggingface: {
+                    compatible: true,
+                    task_categories: ["brain-computer-interface", "neural-decoding", "human-computer-interaction"],
+                    task_ids: ["motor-imagery", "intent-decoding", "visual-evoked-potentials", "handwriting-recognition"],
+                    language: ["en"],
+                    size_categories: ["10K<n<100K"]
+                }
+            };
+            // Create ZIP archive
+            const zip = new JSZip();
+            // Add data files in Apache Arrow compatible format
+            // For now using JSONL, but could be converted to Parquet
+            zip.file("neural_data.jsonl",
+                neuralData.map(d => JSON.stringify(d)).join('\n'));
+            zip.file("intent_stream.jsonl",
+                intentStream.map(d => JSON.stringify(d)).join('\n'));
+            if (handwritingSamples.length > 0) {
+                zip.file("handwriting_samples.json",
+                    JSON.stringify(handwritingSamples, null, 2));
+            }
+            zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+            // Create Hugging Face dataset card
+            const datasetCard = `---
+language:
+- en
+tags:
+- brain-computer-interface
+- neural-decoding
+- motor-imagery
+- human-computer-interaction
+- neuralink
+task_categories:
+- brain-computer-interface
+task_ids:
+- motor-imagery
+- intent-decoding
+- visual-evoked-potentials
+- handwriting-recognition
+size_categories:
+- 10K<n<100K
+---
+# Dataset Card for BCI-FPS ${currentMode.toUpperCase()} Dataset
+## Dataset Description
+This dataset contains high-bandwidth neural training data collected from BCI-FPS, a specialized training platform for brain-computer interface research.
+### Dataset Summary
+- **Training Mode**: ${currentMode.replace('_', ' ').toUpperCase()}
+- **Session ID**: ${sessionId}
+- **Duration**: ${Math.round((Date.now() - sessionStartTime) / 1000)} seconds
+- **Sampling Rate**: ${CONFIG.SAMPLING_RATE} Hz
+- **Neural Channels**: ${CONFIG.NEURAL_CHANNELS}
+- **Data Points**: ${(neuralData.length + intentStream.length).toLocaleString()}
+### Supported Tasks
+- **${getTaskDescription(currentMode)}**
+- **Neural Decoding**: Training models to decode user intent from neural signals
+- **BCI Calibration**: Providing ground truth data for BCI system calibration
+- **Disability Research**: Supporting development of assistive technologies
+### Languages
+English (interface and documentation)
+## Dataset Structure
+### Data Instances
+\`\`\`json
+${JSON.stringify(neuralData[0] || {}, null, 2)}
+\`\`\`
+### Data Fields
+See \`metadata.json\` for complete schema documentation.
+## Dataset Creation
+### Source Data
+- **Platform**: Web-based BCI-FPS Training Environment
+- **Sampling Rate**: ${CONFIG.SAMPLING_RATE} Hz
+- **Collection Method**: Real-time telemetry during BCI training tasks
+- **Neural Simulation**: Synthetic neural data representing ideal BCI signals
+### Annotations
+- **Annotation process**: Automatic intent labeling during gameplay
+- **Annotation types**: Motor imagery, visual stimuli, handwriting intent
+- **Who annotated**: System automatically labels based on game state
+### Personal and Sensitive Information
+No personal information is collected. All data is synthetic/anonymous.
+## Considerations for Using the Data
+### Social Impact
+This dataset enables research in:
+- Neuralink-style brain-computer interfaces
+- Assistive technologies for disabled individuals
+- Human-AI interaction systems
+- Neural decoding algorithms
+### Discussion of Biases
+Synthetic neural data may not perfectly represent biological signals. Results should be validated with real neural recordings.
+### Other Known Limitations
+- Simulated neural signals
+- Idealized game environment
+- Limited to specific training tasks
+## Additional Information
+### Dataset Curators
+BCI-FPS Research Team
+### Licensing Information
+MIT License
+### Citation Information
+\`\`\`bibtex
+@misc{bci_fps_${currentMode}_2024,
+  title={BCI-FPS ${currentMode} Training Dataset},
+  author={Neuralink Research},
+  year={2024},
+  note={High-frequency intent decoding data for brain-computer interface development}
+}
+\`\`\`
+`;
+            zip.file("README.md", datasetCard);
+            // Generate Python loading script
+            const loadScript = `import json
+import pandas as pd
+from datasets import Dataset, DatasetDict
+def load_bci_fps_dataset(data_dir):
+    """
+    Load BCI-FPS dataset for Hugging Face.
+    Args:
+        data_dir (str): Path to dataset directory
+    Returns:
+        DatasetDict: Hugging Face dataset
+    """
+    # Load neural data
+    neural_data = []
+    with open(f"{data_dir}/neural_data.jsonl", 'r') as f:
+        for line in f:
+            if line.strip():
+                neural_data.append(json.loads(line))
+    # Load intent stream
+    intent_stream = []
+    with open(f"{data_dir}/intent_stream.jsonl", 'r') as f:
+        for line in f:
+            if line.strip():
+                intent_stream.append(json.loads(line))
+    # Create datasets
+    datasets = {
+        "neural_data": Dataset.from_list(neural_data),
+        "intent_stream": Dataset.from_list(intent_stream)
+    }
+    # Load handwriting samples if exists
+    try:
+        with open(f"{data_dir}/handwriting_samples.json", 'r') as f:
+            handwriting = json.load(f)
+        datasets["handwriting"] = Dataset.from_list(handwriting)
+    except:
+        pass
+    # Load metadata
+    with open(f"{data_dir}/metadata.json", 'r') as f:
+        metadata = json.load(f)
+    dataset_dict = DatasetDict(datasets)
+    dataset_dict.info.metadata = metadata
+    return dataset_dict
+# Example usage for Neuralink research
+if __name__ == "__main__":
+    dataset = load_bci_fps_dataset("./bci_data")
+    print(f"Dataset keys: {list(dataset.keys())}")
+    print(f"Neural data samples: {len(dataset['neural_data'])}")
+    print(f"Intent stream samples: {len(dataset['intent_stream'])}")
+    # Example: Extract motor imagery trials
+    motor_trials = [d for d in dataset['neural_data'] if d.get('type') == 'motor_imagery_trial']
+    print(f"Motor imagery trials: {len(motor_trials)}")
+`;
+            zip.file("load_dataset.py", loadScript);
+            // Generate and download ZIP
+            const content = await zip.generateAsync({
+                type: "blob",
+                compression: "DEFLATE",
+                compressionOptions: { level: 6 }
+            });
+            saveAs(content, `${sessionId}.zip`);
+            // Show success message
+            alert(`Dataset exported successfully!\n\nFile: ${sessionId}.zip\nSize: ${(content.size / (1024 * 1024)).toFixed(2)} MB\n\nReady for upload to Hugging Face.`);
+        }
+        function showDataPreview() {
+            const preview = `Dataset Preview:
+Training Mode: ${currentMode}
+Session Duration: ${Math.round((Date.now() - sessionStartTime) / 1000)}s
+Neural Samples: ${neuralData.length}
+Intent Samples: ${intentStream.length}
+Handwriting Samples: ${handwritingSamples.length}
+Total Data Points: ${neuralData.length + intentStream.length}
+Latest Neural Sample:
+${JSON.stringify(neuralData[neuralData.length - 1] || {}, null, 2)}
+Latest Intent Sample:
+${JSON.stringify(intentStream[intentStream.length - 1] || {}, null, 2)}`;
+            alert(preview);
+        }
+        // ========== HELPER FUNCTIONS ==========
+        function getTaskDescription(mode) {
+            switch(mode) {
+                case 'motor_imagery': return 'Motor Imagery Training for prosthetic control';
+                case 'simultaneous_intent': return 'Simultaneous Intent Decoding for fluid BCI interfaces';
+                case 'visual_evoked': return 'Visual Evoked Potentials for non-verbal communication';
+                case 'handwriting_intent': return 'Handwriting Intent Recognition for text entry';
+                case 'full_spectrum': return 'Full Spectrum BCI Training';
+                default: return 'BCI Training';
+            }
+        }
+        function calculateAccuracy(target) {
+            // Calculate aiming accuracy
+            const targetDirection = new THREE.Vector3()
+                .subVectors(target.position, camera.position)
+                .normalize();
+            const aimDirection = new THREE.Vector3(0, 0, -1)
+                .applyQuaternion(camera.quaternion);
+            const dot = targetDirection.dot(aimDirection);
+            return Math.max(0, (dot + 1) / 2); // Convert to 0-1 range
+        }
+        function countSimultaneousActions() {
+            let count = 0;
+            if (keyboard['w'] || keyboard['a'] || keyboard['s'] || keyboard['d']) count++;
+            if (Math.abs(mouse.dx) > 1 || Math.abs(mouse.dy) > 1) count++;
+            if (keyboard['mouse']) count++;
+            if (keyboard[' ']) count++;
+            return count;
+        }
+        function calculateIntentModulation(channel) {
+            // Simulate intent modulation on neural channels
+            let modulation = 0;
+            // Movement intent affects low channels
+            if (channel < 8 && (keyboard['w'] || keyboard['a'] || keyboard['s'] || keyboard['d'])) {
+                modulation += 0.3;
+            }
+            // Visual attention affects mid channels
+            if (channel >= 8 && channel < 16 && targets.some(t => t.userData.active)) {
+                modulation += 0.2;
+            }
+            // Motor intent affects high channels
+            if (channel >= 24 && keyboard['mouse']) {
+                modulation += 0.4;
+            }
+            return modulation;
+        }
+        function getCurrentNeuralContext() {
+            if (neuralData.length === 0) return null;
+            return neuralData[neuralData.length - 1].channels;
+        }
+        function getCurrentIntentContext() {
+            if (intentStream.length === 0) return null;
+            const last = intentStream[intentStream.length - 1];
+            return {
+                mouse: last.mouse,
+                keyboard: last.keyboard,
+                camera: last.camera
+            };
+        }
+        function getAimedTarget() {
+            const raycaster = new THREE.Raycaster();
+            raycaster.setFromCamera(new THREE.Vector2(0, 0), camera);
+            const intersects = raycaster.intersectObjects(targets);
+            if (intersects.length > 0) {
+                return {
+                    id: targets.indexOf(intersects[0].object),
+                    position: intersects[0].object.position.toArray(),
+                    distance: intersects[0].distance
+                };
+            }
+            return null;
+        }
+        // ========== GAME LOOP ==========
+        function animate(time) {
+            requestAnimationFrame(animate);
+            // Update FPS counter
+            fpsCounter++;
+            if (time - lastFpsTime > 1000) {
+                currentFps = fpsCounter;
+                fpsCounter = 0;
+                lastFpsTime = time;
+            }
+            // Handle player movement
+            if (keyboard['w']) camera.translateZ(-0.1);
+            if (keyboard['s']) camera.translateZ(0.1);
+            if (keyboard['a']) camera.translateX(-0.1);
+            if (keyboard['d']) camera.translateX(0.1);
+            if (keyboard[' ']) camera.position.y += 0.1;
+            // Update target visuals
+            targets.forEach(target => {
+                if (target.userData.active) {
+                    target.material.emissiveIntensity = 0.5 + 0.5 * Math.sin(time * 0.005);
+                }
+            });
+            renderer.render(scene, camera);
+        }
+        // ========== CONTROL FUNCTIONS ==========
+        function pauseTraining() {
+            // Toggle pause state
+            // Implementation depends on specific requirements
+        }
+        function skipTask() {
+            // Skip current task
+            // Implementation depends on current mode
+        }
+        function endSession() {
+            completeTraining();
+        }
+        function restartTraining() {
+            location.reload();
+        }
+        function returnToMenu() {
+            document.getElementById('experimentComplete').style.display = 'none';
+            document.getElementById('mainMenu').style.display = 'flex';
+            document.getElementById('gameContainer').style.display = 'none';
+            document.getElementById('uiOverlay').style.display = 'none';
+            document.getElementById('crosshair').style.display = 'none';
+            document.getElementById('bciControlPanel').style.display = 'none';
+            // Clean up intervals
+            clearInterval(neuralBackgroundInterval);
+            clearInterval(dataStreamInterval);
+        }
+        // ========== INITIALIZATION ==========
+        window.onload = function() {
+            initNeuralBackground();
+            initThreeJS();
+        };
+    </script>
+</body>
+</html>