Datasets:

webxos
/

datastrike_BCI

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DATASTRIKE v4.0 | by webXOS 2026</title>
+    <!-- Required 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>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            -webkit-tap-highlight-color: transparent;
+        }
+        body {
+            background: #000;
+            color: #0f0;
+            font-family: 'Courier New', monospace;
+            overflow: hidden;
+            cursor: none;
+            height: 100vh;
+            width: 100vw;
+            position: fixed;
+            touch-action: none;
+        }
+        #gameContainer {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 1;
+            image-rendering: pixelated;
+        }
+        canvas {
+            display: block;
+        }
+        /* === MINIMAL UI === */
+        #ui {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 2;
+            padding: 10px;
+            font-size: 12px;
+        }
+        .stat-row {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 4px;
+            padding: 4px 8px;
+            background: rgba(0, 20, 0, 0.7);
+            border: 1px solid #0a0;
+            border-radius: 2px;
+            font-size: 11px;
+        }
+        .stat-label {
+            color: #0a0;
+        }
+        .stat-value {
+            color: #0f0;
+            font-weight: bold;
+        }
+        /* === CROSSHAIR === */
+        #crosshair {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 20px;
+            height: 20px;
+            pointer-events: none;
+            z-index: 3;
+        }
+        .crosshair-dot {
+            position: absolute;
+            width: 4px;
+            height: 4px;
+            background: #0f0;
+            border-radius: 50%;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+        }
+        .crosshair-line {
+            position: absolute;
+            background: #0f0;
+        }
+        .horizontal {
+            width: 8px;
+            height: 1px;
+            top: 50%;
+            transform: translateY(-50%);
+        }
+        .horizontal.left {
+            left: 0;
+        }
+        .horizontal.right {
+            right: 0;
+        }
+        .vertical {
+            width: 1px;
+            height: 8px;
+            left: 50%;
+            transform: translateX(-50%);
+        }
+        .vertical.top {
+            top: 0;
+        }
+        .vertical.bottom {
+            bottom: 0;
+        }
+        /* === BUTTONS === */
+        button {
+            pointer-events: auto;
+            background: rgba(0, 40, 0, 0.9);
+            border: 1px solid #0f0;
+            color: #0f0;
+            padding: 8px 16px;
+            margin: 4px;
+            cursor: pointer;
+            font-family: 'Courier New', monospace;
+            font-size: 11px;
+            border-radius: 3px;
+        }
+        button:hover {
+            background: rgba(0, 60, 0, 0.9);
+        }
+        .button-row {
+            display: flex;
+            justify-content: center;
+            gap: 8px;
+            margin-top: 8px;
+        }
+        /* === LOADING SCREEN === */
+        #loadingOverlay {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: #000;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            z-index: 100;
+        }
+        .loader-text {
+            color: #0f0;
+            font-size: 14px;
+            margin-top: 20px;
+            text-align: center;
+        }
+        /* === TIMELAPSE CAPTURE INDICATOR === */
+        .timelapse-indicator {
+            position: fixed;
+            top: 10px;
+            right: 10px;
+            background: rgba(0, 20, 0, 0.8);
+            border: 1px solid #0f0;
+            border-radius: 4px;
+            padding: 8px;
+            font-size: 10px;
+            z-index: 5;
+            pointer-events: none;
+        }
+        .capture-pulse {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 100px;
+            height: 100px;
+            border: 3px solid #00ffff;
+            border-radius: 50%;
+            pointer-events: none;
+            z-index: 100;
+            opacity: 0;
+            animation: pulse 0.5s ease-out;
+        }
+        @keyframes pulse {
+            0% { transform: translate(-50%, -50%) scale(0.5); opacity: 1; }
+            100% { transform: translate(-50%, -50%) scale(1.5); opacity: 0; }
+        }
+        /* === CAPTURE MODE INDICATOR === */
+        .capture-mode {
+            position: fixed;
+            top: 10px;
+            left: 10px;
+            background: rgba(0, 20, 0, 0.8);
+            border: 1px solid #0f0;
+            border-radius: 4px;
+            padding: 6px 10px;
+            font-size: 10px;
+            z-index: 5;
+            pointer-events: none;
+        }
+        /* === MOBILE CONTROLS === */
+        .mobile-controls {
+            display: none;
+            position: fixed;
+            bottom: 20px;
+            left: 0;
+            width: 100%;
+            z-index: 10;
+            touch-action: none;
+        }
+        .mobile-joystick {
+            position: absolute;
+            bottom: 20px;
+            left: 20px;
+            width: 80px;
+            height: 80px;
+            background: rgba(0, 40, 0, 0.5);
+            border-radius: 50%;
+            border: 1px solid #0f0;
+            touch-action: none;
+        }
+        .mobile-joystick-thumb {
+            position: absolute;
+            width: 30px;
+            height: 30px;
+            background: rgba(0, 255, 0, 0.7);
+            border-radius: 50%;
+            top: 25px;
+            left: 25px;
+            touch-action: none;
+        }
+        .mobile-shoot {
+            position: absolute;
+            bottom: 20px;
+            right: 20px;
+            width: 60px;
+            height: 60px;
+            background: rgba(255, 0, 0, 0.5);
+            border-radius: 50%;
+            border: 1px solid #f00;
+            touch-action: none;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: white;
+            font-size: 11px;
+        }
+        /* === EXPORT PROGRESS === */
+        .export-progress {
+            position: fixed;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.95);
+            border: 2px solid #0f0;
+            padding: 20px;
+            border-radius: 5px;
+            z-index: 1000;
+            display: none;
+            pointer-events: none;
+        }
+        /* === TIMELAPSE PREVIEW === */
+        #timelapsePreview {
+            position: fixed;
+            top: 50px;
+            right: 10px;
+            width: 160px;
+            height: 120px;
+            border: 2px solid #0f0;
+            background: #000;
+            z-index: 100;
+            display: none;
+            pointer-events: none;
+        }
+    </style>
+</head>
+<body>
+    <!-- LOADING SCREEN -->
+    <div id="loadingOverlay">
+        <div class="loader-text" id="loaderText">Initializing BCI Timelapse Capture...</div>
+        <div class="loader-text" id="loaderPercent">0%</div>
+    </div>
+    <!-- GAME CONTAINER -->
+    <div id="gameContainer"></div>
+    <!-- UI LAYER -->
+    <div id="ui">
+        <!-- TOP STATS -->
+        <div class="stat-row">
+            <span class="stat-label">BCI INTENT:</span>
+            <span id="intentStatus" class="stat-value">IDLE</span>
+        </div>
+        <div class="stat-row">
+            <span class="stat-label">FPS:</span>
+            <span id="fps" class="stat-value">60</span>
+        </div>
+        <div class="stat-row">
+            <span class="stat-label">TIMELAPSE:</span>
+            <span id="timelapseCount" class="stat-value">0</span>
+        </div>
+        <div class="stat-row">
+            <span class="stat-label">SEQUENCE:</span>
+            <span id="sequenceCount" class="stat-value">0</span>
+        </div>
+        <div class="stat-row">
+            <span class="stat-label">LEVEL:</span>
+            <span id="level" class="stat-value">1</span>
+        </div>
+        <div class="stat-row">
+            <span class="stat-label">AMMO:</span>
+            <span id="ammo" class="stat-value">30/∞</span>
+        </div>
+        <!-- BOTTOM CONTROLS -->
+        <div style="position: fixed; bottom: 10px; left: 0; width: 100%;">
+            <div class="button-row">
+                <button id="recordBtn" onclick="toggleRecording()">
+                    ⏺ TIMELAPSE REC
+                </button>
+                <button id="modeBtn" onclick="toggleCaptureMode()">
+                    🔄 MANUAL MODE
+                </button>
+                <button id="exportBtn" onclick="exportTimelapseDataset()">
+                    📤 EXPORT SEQUENCE
+                </button>
+                <button onclick="resetSession()">
+                    🔄 RESET
+                </button>
+            </div>
+        </div>
+    </div>
+    <!-- CROSSHAIR -->
+    <div id="crosshair">
+        <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>
+    <!-- CAPTURE MODE INDICATOR -->
+    <div class="capture-mode">
+        <span id="captureModeDisplay">MANUAL</span>
+    </div>
+    <!-- TIMELAPSE INDICATOR -->
+    <div class="timelapse-indicator">
+        <div>📽️ Sequence: <span id="currentSequence">0</span></div>
+        <div>⏱️ Interval: <span id="captureInterval">1000ms</span></div>
+        <div>🎯 Auto-Capture: <span id="autoCaptureStatus">OFF</span></div>
+    </div>
+    <!-- TIMELAPSE PREVIEW -->
+    <canvas id="timelapsePreview"></canvas>
+    <!-- MOBILE CONTROLS -->
+    <div class="mobile-controls">
+        <div class="mobile-joystick" id="joystickArea">
+            <div class="mobile-joystick-thumb" id="joystickThumb"></div>
+        </div>
+        <div class="mobile-shoot" id="shootButton">
+            FIRE
+        </div>
+    </div>
+    <!-- EXPORT PROGRESS -->
+    <div id="exportProgress" class="export-progress">
+        <div id="progressText">Processing timelapse sequence...</div>
+        <div style="width: 300px; height: 10px; background: #111; margin-top: 10px; border-radius: 5px; overflow: hidden;">
+            <div id="progressBar" style="width: 0%; height: 100%; background: #0f0;"></div>
+        </div>
+    </div>
+    <script>
+        // ========== ENHANCED TIMELAPSE CONFIGURATION ==========
+        const CONFIG = {
+            // Performance Settings
+            MAX_TOTAL_OBJECTS: 50,
+            MAX_ACTIVE_OBJECTS: 30,
+            // Game Settings
+            INITIAL_DRONE_COUNT: 2,
+            MAX_DRONES: 6,
+            DRONE_SPAWN_RATE: 4.0,
+            DRONE_SPEED: 0.015,
+            DRONE_HEALTH: 50,
+            // Player Settings
+            PLAYER_SPEED: 0.08,
+            PLAYER_HEIGHT: 1.7,
+            MOUSE_SENSITIVITY: 0.0015,
+            JUMP_FORCE: 0.12,
+            GRAVITY: 0.004,
+            // Weapon Settings
+            WEAPON_DAMAGE: 40,
+            FIRE_RATE: 8,
+            BULLET_SPEED: 1.5,
+            BULLET_LIFETIME: 1.0,
+            MAX_AMMO: 30,
+            RELOAD_TIME: 2.0,
+            // Timelapse Capture Settings
+            CAPTURE_MODES: {
+                MANUAL: 'manual',        // LMB click to capture
+                AUTO: 'auto',            // Automatic at interval
+                SEQUENCE: 'sequence'     // Start/stop sequence recording
+            },
+            // Timelapse Parameters
+            TIMELAPSE: {
+                ENABLED: true,
+                RESOLUTION: { width: 320, height: 240 }, // Higher res for better ML training
+                FORMAT: 'image/jpeg',
+                QUALITY: 0.7,
+                MAX_FRAMES: 1000,
+                AUTO_INTERVAL: 500, // ms between auto captures
+                SEQUENCE_BUFFER: 60 // frames to buffer for smooth sequences
+            },
+            // BCI Intent System
+            BCI_INTENT_TYPES: [
+                'IDLE', 'MOVE_FORWARD', 'MOVE_BACKWARD', 'MOVE_LEFT', 'MOVE_RIGHT',
+                'LOOK_LEFT', 'LOOK_RIGHT', 'LOOK_UP', 'LOOK_DOWN',
+                'FIRE_WEAPON', 'RELOAD', 'JUMP', 'TIMELAPSE_CAPTURE'
+            ],
+            // RLHF Settings for Timelapse
+            RLHF_ENABLED: true,
+            RLHF_EVENTS: ['FIRE_WEAPON', 'DRONE_HIT', 'DRONE_DESTROYED', 'TIMELAPSE_CAPTURE'],
+            RLHF_AUTO_RATINGS: {
+                'FIRE_WEAPON': 0,
+                'DRONE_HIT': 1,
+                'DRONE_DESTROYED': 2,
+                'TIMELAPSE_CAPTURE': 0.5 // Neutral for capture events
+            }
+        };
+        // ========== GAME STATE ==========
+        let scene, camera, renderer;
+        let player;
+        let drones = [];
+        let bullets = [];
+        let lastTime = 0;
+        let gameTime = 0;
+        let deltaTime = 0;
+        let frameCount = 0;
+        let fps = 60;
+        let lastFpsUpdate = 0;
+        let animationFrameId = null;
+        // Object pools
+        let bulletPool = [];
+        // Player stats
+        let level = 1;
+        let exp = 0;
+        let requiredExp = 1000;
+        let kills = 0;
+        let shotsFired = 0;
+        let shotsHit = 0;
+        let accuracy = 0;
+        let totalSamples = 0;
+        // Weapon state
+        let currentAmmo = CONFIG.MAX_AMMO;
+        let isReloading = false;
+        let lastFireTime = 0;
+        // Controls
+        let controls = {
+            w: false, a: false, s: false, d: false,
+            space: false
+        };
+        let mouse = {
+            x: 0,
+            y: 0,
+            dx: 0,
+            dy: 0,
+            sensitivity: CONFIG.MOUSE_SENSITIVITY,
+            locked: false,
+            lmbPressed: false,
+            lmbHoldStart: 0
+        };
+        // Player physics
+        let velocity = new THREE.Vector3();
+        let isGrounded = true;
+        // BCI Intent tracking
+        let currentIntent = 'IDLE';
+        let intentHistory = [];
+        // ========== ENHANCED TIMELAPSE SYSTEM ==========
+        let captureMode = CONFIG.CAPTURE_MODES.MANUAL;
+        let isRecordingTimelapse = false;
+        let timelapseSequence = [];
+        let currentSequence = 0;
+        let captureInterval = null;
+        let timelapseBuffer = [];
+        let frameCounter = 0;
+        // Mobile controls
+        let joystickActive = false;
+        let joystickStart = { x: 0, y: 0 };
+        let joystickVector = { x: 0, y: 0 };
+        // ========== LOADING SYSTEM ==========
+        function updateLoader(progress, text) {
+            const loaderText = document.getElementById('loaderText');
+            const loaderPercent = document.getElementById('loaderPercent');
+            if (loaderText) loaderText.textContent = text;
+            if (loaderPercent) loaderPercent.textContent = `${Math.round(progress)}%`;
+        }
+        async function init() {
+            try {
+                updateLoader(10, "Initializing 3D engine...");
+                // Create scene
+                scene = new THREE.Scene();
+                scene.background = new THREE.Color(0x000000);
+                updateLoader(20, "Creating scene...");
+                // Create camera
+                camera = new THREE.PerspectiveCamera(
+                    CONFIG.FOV,
+                    window.innerWidth / window.innerHeight,
+                    0.1,
+                    CONFIG.RENDER_DISTANCE
+                );
+                camera.position.y = CONFIG.PLAYER_HEIGHT;
+                updateLoader(30, "Setting up camera...");
+                // Create renderer
+                renderer = new THREE.WebGLRenderer({
+                    antialias: false,
+                    alpha: false,
+                    powerPreference: "low-power",
+                    preserveDrawingBuffer: true // Required for canvas.toDataURL()
+                });
+                renderer.setSize(window.innerWidth, window.innerHeight);
+                renderer.setPixelRatio(window.devicePixelRatio || 1);
+                const gameContainer = document.getElementById('gameContainer');
+                if (gameContainer) {
+                    gameContainer.appendChild(renderer.domElement);
+                } else {
+                    document.body.appendChild(renderer.domElement);
+                }
+                updateLoader(40, "Configuring timelapse system...");
+                // Setup lighting
+                const ambientLight = new THREE.AmbientLight(0x00ff00, 0.1);
+                scene.add(ambientLight);
+                const directionalLight = new THREE.DirectionalLight(0x00ff00, 0.3);
+                directionalLight.position.set(10, 20, 5);
+                scene.add(directionalLight);
+                updateLoader(50, "Creating environment...");
+                // Create environment
+                createMinimalEnvironment();
+                updateLoader(60, "Setting up player...");
+                // Setup player
+                player = camera;
+                updateLoader(70, "Setting up controls...");
+                // Setup controls
+                setupControls();
+                updateLoader(80, "Initializing timelapse system...");
+                // Initialize timelapse system
+                initTimelapseSystem();
+                // Initialize object pools
+                initObjectPools();
+                // Create initial drones
+                for (let i = 0; i < CONFIG.INITIAL_DRONE_COUNT; i++) {
+                    setTimeout(() => spawnDrone(), i * 2000);
+                }
+                // Start drone spawner
+                setInterval(() => {
+                    if (drones.length < CONFIG.MAX_DRONES) {
+                        spawnDrone();
+                    }
+                }, 1000 / CONFIG.DRONE_SPAWN_RATE);
+                // Hide loading screen
+                setTimeout(() => {
+                    const loadingOverlay = document.getElementById('loadingOverlay');
+                    if (loadingOverlay) {
+                        loadingOverlay.style.opacity = '0';
+                        setTimeout(() => {
+                            loadingOverlay.style.display = 'none';
+                            showBCIStatus("Timelapse System Ready");
+                            updateCaptureUI();
+                        }, 500);
+                    }
+                }, 300);
+                updateLoader(100, "Starting game loop...");
+                // Start game loop
+                animate();
+                console.log("BCI Timelapse Capture initialized successfully");
+            } catch (error) {
+                console.error("Error initializing:", error);
+                updateLoader(100, `Error: ${error.message}`);
+                alert(`Failed to start: ${error.message}. Check console for details.`);
+            }
+        }
+        function initObjectPools() {
+            // Initialize bullet pool
+            for (let i = 0; i < 15; i++) {
+                const bulletGeometry = new THREE.SphereGeometry(0.08, 4, 4);
+                const bulletMaterial = new THREE.MeshBasicMaterial({
+                    color: 0xffff00
+                });
+                const bullet = new THREE.Mesh(bulletGeometry, bulletMaterial);
+                bullet.visible = false;
+                bullet.userData = { active: false };
+                scene.add(bullet);
+                bulletPool.push(bullet);
+            }
+        }
+        function createMinimalEnvironment() {
+            // Ground
+            const groundGeometry = new THREE.PlaneGeometry(100, 100);
+            const groundMaterial = new THREE.MeshBasicMaterial({
+                color: 0x003300
+            });
+            const ground = new THREE.Mesh(groundGeometry, groundMaterial);
+            ground.rotation.x = -Math.PI / 2;
+            scene.add(ground);
+            // Grid
+            const gridHelper = new THREE.GridHelper(100, 10, 0x00aa00, 0x003300);
+            gridHelper.position.y = 0.01;
+            scene.add(gridHelper);
+            // Simple buildings
+            const buildingGeometry = new THREE.BoxGeometry(1, 1, 1);
+            const buildingMaterial = new THREE.MeshBasicMaterial({
+                color: 0x00aa00,
+                wireframe: true
+            });
+            for (let i = 0; i < 5; i++) {
+                const height = Math.random() * 10 + 5;
+                const building = new THREE.Mesh(buildingGeometry, buildingMaterial);
+                building.scale.set(
+                    Math.random() * 4 + 2,
+                    height,
+                    Math.random() * 4 + 2
+                );
+                building.position.set(
+                    (Math.random() - 0.5) * 80,
+                    height / 2,
+                    (Math.random() - 0.5) * 80
+                );
+                scene.add(building);
+            }
+        }
+        function setupControls() {
+            // Mouse lock
+            document.addEventListener('click', () => {
+                if (!document.pointerLockElement) {
+                    document.body.requestPointerLock();
+                }
+            });
+            // Mouse movement
+            document.addEventListener('mousemove', (e) => {
+                if (document.pointerLockElement === document.body) {
+                    mouse.dx = e.movementX || e.mozMovementX || e.webkitMovementX || 0;
+                    mouse.dy = e.movementY || e.mozMovementY || e.webkitMovementY || 0;
+                    mouse.x += mouse.dx * mouse.sensitivity;
+                    mouse.y += mouse.dy * mouse.sensitivity;
+                    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;
+                    // Record look intent
+                    if (mouse.dx > 0) recordBCIIntent('LOOK_RIGHT');
+                    else if (mouse.dx < 0) recordBCIIntent('LOOK_LEFT');
+                    else if (mouse.dy > 0) recordBCIIntent('LOOK_DOWN');
+                    else if (mouse.dy < 0) recordBCIIntent('LOOK_UP');
+                }
+            });
+            document.addEventListener('pointerlockchange', () => {
+                mouse.locked = document.pointerLockElement === document.body;
+                if (!mouse.locked) {
+                    mouse.dx = mouse.dy = 0;
+                }
+            });
+            // Keyboard controls
+            document.addEventListener('keydown', (e) => {
+                let key = e.key.toLowerCase();
+                if (key === ' ') key = 'space';
+                if (key in controls) {
+                    controls[key] = true;
+                    recordBCIIntent(getIntentFromKey(key, true));
+                }
+                switch(key) {
+                    case 'r':
+                        reloadWeapon();
+                        recordBCIIntent('RELOAD');
+                        break;
+                    case 'c':
+                        toggleCaptureMode();
+                        break;
+                    case 'p':
+                        toggleRecording();
+                        break;
+                    case 'm':
+                        manualCapture();
+                        break;
+                }
+            });
+            document.addEventListener('keyup', (e) => {
+                let key = e.key.toLowerCase();
+                if (key === ' ') key = 'space';
+                if (key in controls) {
+                    controls[key] = false;
+                    recordBCIIntent('IDLE');
+                }
+                if (key === 'space' && isGrounded) {
+                    velocity.y = CONFIG.JUMP_FORCE;
+                    isGrounded = false;
+                    recordBCIIntent('JUMP');
+                }
+            });
+            // Enhanced LMB controls for timelapse capture
+            document.addEventListener('mousedown', (e) => {
+                if (e.button === 0) { // Left mouse button
+                    mouse.lmbPressed = true;
+                    mouse.lmbHoldStart = Date.now();
+                    // Fire weapon AND capture timelapse frame
+                    if (!isReloading && currentAmmo > 0) {
+                        fireWeapon();
+                        // Capture timelapse based on mode
+                        if (captureMode === CONFIG.CAPTURE_MODES.MANUAL) {
+                            captureTimelapseFrame('LMB_MANUAL');
+                        } else if (captureMode === CONFIG.CAPTURE_MODES.SEQUENCE && isRecordingTimelapse) {
+                            captureTimelapseFrame('SEQUENCE_LMB');
+                        }
+                    } else if (currentAmmo === 0) {
+                        reloadWeapon();
+                    }
+                }
+            });
+            document.addEventListener('mouseup', (e) => {
+                if (e.button === 0) {
+                    mouse.lmbPressed = false;
+                    const holdDuration = Date.now() - mouse.lmbHoldStart;
+                    // If LMB was held for > 500ms, trigger burst capture
+                    if (holdDuration > 500 && captureMode === CONFIG.CAPTURE_MODES.MANUAL) {
+                        captureBurstFrames(3);
+                    }
+                }
+            });
+            // Setup mobile controls
+            setupMobileControls();
+            // Window resize
+            window.addEventListener('resize', () => {
+                camera.aspect = window.innerWidth / window.innerHeight;
+                camera.updateProjectionMatrix();
+                renderer.setSize(window.innerWidth, window.innerHeight);
+            });
+        }
+        function setupMobileControls() {
+            const joystickArea = document.getElementById('joystickArea');
+            const joystickThumb = document.getElementById('joystickThumb');
+            const shootButton = document.getElementById('shootButton');
+            if (!joystickArea) return;
+            // Joystick touch
+            joystickArea.addEventListener('touchstart', (e) => {
+                e.preventDefault();
+                joystickActive = true;
+                const touch = e.touches[0];
+                const rect = joystickArea.getBoundingClientRect();
+                joystickStart.x = rect.left + 40;
+                joystickStart.y = rect.top + 40;
+            });
+            document.addEventListener('touchmove', (e) => {
+                if (!joystickActive) return;
+                e.preventDefault();
+                const touch = e.touches[0];
+                let dx = touch.clientX - joystickStart.x;
+                let dy = touch.clientY - joystickStart.y;
+                // Limit to joystick area
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                if (distance > 30) {
+                    dx = (dx / distance) * 30;
+                    dy = (dy / distance) * 30;
+                }
+                joystickVector.x = dx / 30;
+                joystickVector.y = dy / 30;
+                // Update visual
+                joystickThumb.style.transform = `translate(${dx}px, ${dy}px)`;
+                // Simulate keyboard controls
+                controls.w = dy < -10;
+                controls.s = dy > 10;
+                controls.a = dx < -10;
+                controls.d = dx > 10;
+                // Record BCI intent
+                let intent = 'IDLE';
+                if (dy < -10) intent = 'MOVE_FORWARD';
+                if (dy > 10) intent = 'MOVE_BACKWARD';
+                if (dx < -10) intent = 'MOVE_LEFT';
+                if (dx > 10) intent = 'MOVE_RIGHT';
+                recordBCIIntent(intent);
+            });
+            document.addEventListener('touchend', (e) => {
+                if (joystickActive) {
+                    joystickActive = false;
+                    joystickVector.x = 0;
+                    joystickVector.y = 0;
+                    joystickThumb.style.transform = 'translate(0, 0)';
+                    controls.w = controls.s = controls.a = controls.d = false;
+                    recordBCIIntent('IDLE');
+                }
+            });
+            // Shoot button
+            shootButton.addEventListener('touchstart', (e) => {
+                e.preventDefault();
+                if (!isReloading && currentAmmo > 0) {
+                    fireWeapon();
+                    if (captureMode === CONFIG.CAPTURE_MODES.MANUAL) {
+                        captureTimelapseFrame('MOBILE_MANUAL');
+                    }
+                }
+            });
+        }
+        function getIntentFromKey(key, isDown) {
+            if (!isDown) return 'IDLE';
+            switch(key) {
+                case 'w': return 'MOVE_FORWARD';
+                case 's': return 'MOVE_BACKWARD';
+                case 'a': return 'MOVE_LEFT';
+                case 'd': return 'MOVE_RIGHT';
+                case ' ': return 'JUMP';
+                case 'r': return 'RELOAD';
+                case 'm': return 'TIMELAPSE_CAPTURE';
+                default: return 'IDLE';
+            }
+        }
+        function spawnDrone() {
+            if (drones.length >= CONFIG.MAX_DRONES) return;
+            const geometry = new THREE.BoxGeometry(1, 1, 1);
+            const material = new THREE.MeshBasicMaterial({
+                color: 0xff3300,
+                wireframe: true
+            });
+            const drone = new THREE.Mesh(geometry, material);
+            const angle = Math.random() * Math.PI * 2;
+            const distance = 20 + Math.random() * 30;
+            drone.position.set(
+                camera.position.x + Math.cos(angle) * distance,
+                5 + Math.random() * 10,
+                camera.position.z + Math.sin(angle) * distance
+            );
+            drone.userData = {
+                type: 'drone',
+                health: CONFIG.DRONE_HEALTH,
+                speed: CONFIG.DRONE_SPEED,
+                target: camera.position.clone()
+            };
+            scene.add(drone);
+            drones.push(drone);
+        }
+        function fireWeapon() {
+            const now = Date.now();
+            if (now - lastFireTime < 1000 / CONFIG.FIRE_RATE) return;
+            if (isReloading || currentAmmo <= 0) return;
+            lastFireTime = now;
+            currentAmmo--;
+            shotsFired++;
+            // Update UI
+            document.getElementById('ammo').textContent = `${currentAmmo}/∞`;
+            // Get bullet from pool
+            const bullet = getBulletFromPool();
+            if (!bullet) return;
+            // Configure bullet
+            const bulletDirection = new THREE.Vector3(0, 0, -1);
+            bulletDirection.applyQuaternion(camera.quaternion);
+            bullet.position.copy(camera.position);
+            bullet.position.y -= 0.2;
+            bullet.userData = {
+                velocity: bulletDirection.multiplyScalar(CONFIG.BULLET_SPEED),
+                damage: CONFIG.WEAPON_DAMAGE,
+                spawnTime: gameTime,
+                active: true
+            };
+            bullet.visible = true;
+            bullets.push(bullet);
+            // Simple hit detection
+            const raycaster = new THREE.Raycaster();
+            raycaster.set(camera.position, bulletDirection);
+            const intersects = raycaster.intersectObjects(drones);
+            if (intersects.length > 0) {
+                const drone = intersects[0].object;
+                handleDroneHit(drone, bullet.userData.damage);
+            }
+            if (currentAmmo === 0) {
+                reloadWeapon();
+            }
+        }
+        function getBulletFromPool() {
+            for (let i = 0; i < bulletPool.length; i++) {
+                if (!bulletPool[i].visible) {
+                    bulletPool[i].visible = true;
+                    bulletPool[i].userData.active = true;
+                    return bulletPool[i];
+                }
+            }
+            return null;
+        }
+        function recycleBullet(bullet) {
+            bullet.visible = false;
+            bullet.userData.active = false;
+            const index = bullets.indexOf(bullet);
+            if (index > -1) {
+                bullets.splice(index, 1);
+            }
+        }
+        function handleDroneHit(drone, damage) {
+            shotsHit++;
+            accuracy = shotsFired > 0 ? Math.round((shotsHit / shotsFired) * 100) : 0;
+            drone.userData.health -= damage;
+            // Capture timelapse on hit
+            if (captureMode === CONFIG.CAPTURE_MODES.SEQUENCE || captureMode === CONFIG.CAPTURE_MODES.AUTO) {
+                captureTimelapseFrame('DRONE_HIT');
+            }
+            if (drone.userData.health <= 0) {
+                destroyDrone(drone);
+            }
+        }
+        function destroyDrone(drone) {
+            const index = drones.indexOf(drone);
+            if (index > -1) {
+                scene.remove(drone);
+                drones.splice(index, 1);
+            }
+            kills++;
+            exp += 30;
+            checkLevelUp();
+            // Capture timelapse on destroy
+            if (captureMode !== CONFIG.CAPTURE_MODES.MANUAL) {
+                captureTimelapseFrame('DRONE_DESTROYED');
+            }
+            showBCIStatus(`DRONE DESTROYED +30XP`);
+            setTimeout(spawnDrone, 3000);
+        }
+        function reloadWeapon() {
+            if (isReloading || currentAmmo === CONFIG.MAX_AMMO) return;
+            isReloading = true;
+            showBCIStatus("RELOADING...");
+            setTimeout(() => {
+                currentAmmo = CONFIG.MAX_AMMO;
+                isReloading = false;
+                document.getElementById('ammo').textContent = `${currentAmmo}/∞`;
+                showBCIStatus("WEAPON RELOADED");
+            }, CONFIG.RELOAD_TIME * 1000);
+        }
+        function animate(time = 0) {
+            animationFrameId = requestAnimationFrame(animate);
+            const currentTime = performance.now();
+            deltaTime = (currentTime - lastTime) / 1000;
+            lastTime = currentTime;
+            gameTime += deltaTime;
+            frameCount++;
+            // Calculate FPS every second
+            if (currentTime - lastFpsUpdate > 1000) {
+                fps = Math.round((frameCount * 1000) / (currentTime - lastFpsUpdate));
+                frameCount = 0;
+                lastFpsUpdate = currentTime;
+                document.getElementById('fps').textContent = fps;
+            }
+            // Update game systems
+            updatePlayerMovement(deltaTime);
+            updateDrones(deltaTime);
+            updateBullets(deltaTime);
+            updateUI();
+            // Buffer frames for sequence mode
+            if (isRecordingTimelapse && captureMode === CONFIG.CAPTURE_MODES.SEQUENCE) {
+                bufferGameFrame();
+            }
+            // Render scene
+            renderer.render(scene, camera);
+        }
+        function updatePlayerMovement(delta) {
+            if (!player || !mouse.locked) return;
+            const forward = new THREE.Vector3(0, 0, -1);
+            const right = new THREE.Vector3(1, 0, 0);
+            forward.applyQuaternion(camera.quaternion);
+            right.applyQuaternion(camera.quaternion);
+            forward.y = 0;
+            right.y = 0;
+            forward.normalize();
+            right.normalize();
+            velocity.set(0, velocity.y, 0);
+            // Keyboard controls
+            if (controls.w) velocity.add(forward.multiplyScalar(CONFIG.PLAYER_SPEED));
+            if (controls.s) velocity.add(forward.multiplyScalar(-CONFIG.PLAYER_SPEED));
+            if (controls.a) velocity.add(right.multiplyScalar(-CONFIG.PLAYER_SPEED));
+            if (controls.d) velocity.add(right.multiplyScalar(CONFIG.PLAYER_SPEED));
+            // Mobile joystick controls
+            if (joystickActive) {
+                velocity.add(forward.multiplyScalar(joystickVector.y * CONFIG.PLAYER_SPEED));
+                velocity.add(right.multiplyScalar(joystickVector.x * CONFIG.PLAYER_SPEED));
+            }
+            // Gravity
+            if (!isGrounded) {
+                velocity.y -= CONFIG.GRAVITY;
+            }
+            camera.position.add(velocity);
+            // Ground check
+            if (camera.position.y < CONFIG.PLAYER_HEIGHT) {
+                camera.position.y = CONFIG.PLAYER_HEIGHT;
+                velocity.y = 0;
+                isGrounded = true;
+            }
+            // Keep in bounds
+            camera.position.x = Math.max(-40, Math.min(40, camera.position.x));
+            camera.position.z = Math.max(-40, Math.min(40, camera.position.z));
+        }
+        function updateDrones(delta) {
+            for (let i = drones.length - 1; i >= 0; i--) {
+                const drone = drones[i];
+                // Move toward player
+                const direction = new THREE.Vector3().subVectors(
+                    drone.userData.target,
+                    drone.position
+                ).normalize();
+                drone.position.add(direction.multiplyScalar(drone.userData.speed));
+                // Simple rotation
+                drone.rotation.y += 0.01;
+                // Check collision
+                if (drone.position.distanceTo(camera.position) < 2) {
+                    resetSession();
+                    showBCIStatus("MISSION FAILED", "error");
+                }
+            }
+        }
+        function updateBullets(delta) {
+            for (let i = bullets.length - 1; i >= 0; i--) {
+                const bullet = bullets[i];
+                if (!bullet.userData.active) continue;
+                bullet.position.add(bullet.userData.velocity);
+                // Check lifetime
+                if (gameTime - bullet.userData.spawnTime > CONFIG.BULLET_LIFETIME) {
+                    recycleBullet(bullet);
+                    continue;
+                }
+                // Check collisions
+                for (let j = drones.length - 1; j >= 0; j--) {
+                    const drone = drones[j];
+                    if (bullet.position.distanceTo(drone.position) < 1.2) {
+                        handleDroneHit(drone, bullet.userData.damage);
+                        recycleBullet(bullet);
+                        break;
+                    }
+                }
+            }
+        }
+        function updateUI() {
+            document.getElementById('level').textContent = level;
+            document.getElementById('timelapseCount').textContent = timelapseSequence.length;
+            document.getElementById('sequenceCount').textContent = currentSequence;
+            document.getElementById('intentStatus').textContent = currentIntent;
+            // Update ammo color
+            const ammoEl = document.getElementById('ammo');
+            if (currentAmmo === 0) {
+                ammoEl.style.color = '#f00';
+            } else if (currentAmmo <= 10) {
+                ammoEl.style.color = '#ff0';
+            } else {
+                ammoEl.style.color = '#0f0';
+            }
+            if (isReloading) {
+                ammoEl.textContent = "RELOADING";
+            } else {
+                ammoEl.textContent = `${currentAmmo}/∞`;
+            }
+        }
+        function checkLevelUp() {
+            while (exp >= requiredExp && level < 20) {
+                level++;
+                exp -= requiredExp;
+                requiredExp = Math.floor(requiredExp * 1.2);
+                showBCIStatus(`LEVEL UP! Now Level ${level}`);
+            }
+        }
+        function resetSession() {
+            camera.position.set(0, CONFIG.PLAYER_HEIGHT, 0);
+            camera.rotation.set(0, 0, 0);
+            mouse.x = mouse.y = 0;
+            currentAmmo = CONFIG.MAX_AMMO;
+            shotsFired = 0;
+            shotsHit = 0;
+            accuracy = 0;
+            isReloading = false;
+            // Remove all drones
+            drones.forEach(drone => scene.remove(drone));
+            drones = [];
+            // Remove all bullets
+            bullets.forEach(bullet => recycleBullet(bullet));
+            bullets = [];
+            // Reset BCI intent
+            currentIntent = 'IDLE';
+            intentHistory = [];
+            // Reset timelapse data
+            timelapseSequence = [];
+            timelapseBuffer = [];
+            currentSequence = 0;
+            frameCounter = 0;
+            // Update UI
+            document.getElementById('timelapseCount').textContent = '0';
+            document.getElementById('sequenceCount').textContent = '0';
+            // Spawn initial drones
+            for (let i = 0; i < CONFIG.INITIAL_DRONE_COUNT; i++) {
+                setTimeout(() => spawnDrone(), i * 1500);
+            }
+            showBCIStatus("Session Reset");
+        }
+        function showBCIStatus(message, type = "info") {
+            const intentStatus = document.getElementById('intentStatus');
+            if (intentStatus) {
+                intentStatus.textContent = message;
+                if (type === "error") {
+                    intentStatus.style.color = '#f00';
+                    setTimeout(() => {
+                        intentStatus.style.color = '#0f0';
+                    }, 2000);
+                }
+            }
+        }
+        function recordBCIIntent(intent) {
+            if (intent !== currentIntent) {
+                currentIntent = intent;
+                intentHistory.push({
+                    intent: intent,
+                    timestamp: Date.now(),
+                    gameTime: gameTime,
+                    position: camera.position.toArray(),
+                    rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z]
+                });
+                // Keep history limited
+                if (intentHistory.length > 1000) {
+                    intentHistory = intentHistory.slice(-500);
+                }
+            }
+        }
+        // ========== ENHANCED TIMELAPSE CAPTURE SYSTEM ==========
+        function initTimelapseSystem() {
+            console.log("Timelapse capture system initialized");
+            updateCaptureUI();
+        }
+        function toggleCaptureMode() {
+            const modes = Object.values(CONFIG.CAPTURE_MODES);
+            const currentIndex = modes.indexOf(captureMode);
+            captureMode = modes[(currentIndex + 1) % modes.length];
+            // Stop any ongoing auto-capture
+            if (captureInterval) {
+                clearInterval(captureInterval);
+                captureInterval = null;
+            }
+            // Stop sequence recording
+            if (isRecordingTimelapse) {
+                stopTimelapseRecording();
+            }
+            // Start auto-capture if in AUTO mode
+            if (captureMode === CONFIG.CAPTURE_MODES.AUTO) {
+                startAutoCapture();
+            }
+            updateCaptureUI();
+            showBCIStatus(`Capture Mode: ${captureMode.toUpperCase()}`);
+        }
+        function updateCaptureUI() {
+            const modeDisplay = document.getElementById('captureModeDisplay');
+            const intervalDisplay = document.getElementById('captureInterval');
+            const autoCaptureDisplay = document.getElementById('autoCaptureStatus');
+            if (modeDisplay) modeDisplay.textContent = captureMode.toUpperCase();
+            if (captureMode === CONFIG.CAPTURE_MODES.AUTO) {
+                intervalDisplay.textContent = `${CONFIG.TIMELAPSE.AUTO_INTERVAL}ms`;
+                autoCaptureDisplay.textContent = 'ON';
+                autoCaptureDisplay.style.color = '#0f0';
+            } else {
+                intervalDisplay.textContent = 'N/A';
+                autoCaptureDisplay.textContent = 'OFF';
+                autoCaptureDisplay.style.color = '#f00';
+            }
+            // Update button
+            const modeBtn = document.getElementById('modeBtn');
+            modeBtn.textContent = `🔄 ${captureMode.toUpperCase()} MODE`;
+        }
+        function startAutoCapture() {
+            captureInterval = setInterval(() => {
+                if (timelapseSequence.length < CONFIG.TIMELAPSE.MAX_FRAMES) {
+                    captureTimelapseFrame('AUTO_INTERVAL');
+                } else {
+                    clearInterval(captureInterval);
+                }
+            }, CONFIG.TIMELAPSE.AUTO_INTERVAL);
+        }
+        function toggleRecording() {
+            if (captureMode !== CONFIG.CAPTURE_MODES.SEQUENCE) {
+                showBCIStatus("Switch to SEQUENCE mode first", "error");
+                return;
+            }
+            isRecordingTimelapse = !isRecordingTimelapse;
+            const button = document.getElementById('recordBtn');
+            if (isRecordingTimelapse) {
+                button.innerHTML = '⏹️ STOP SEQUENCE';
+                button.style.background = 'rgba(255, 0, 0, 0.7)';
+                showBCIStatus("Sequence Recording Started");
+                timelapseBuffer = []; // Clear buffer
+                currentSequence++;
+                document.getElementById('currentSequence').textContent = currentSequence;
+            } else {
+                button.innerHTML = '⏺️ START SEQUENCE';
+                button.style.background = 'rgba(0, 40, 0, 0.9)';
+                showBCIStatus("Sequence Recording Stopped");
+                // Finalize sequence
+                finalizeSequence();
+            }
+        }
+        function bufferGameFrame() {
+            // Buffer game state for smooth sequence
+            if (timelapseBuffer.length >= CONFIG.TIMELAPSE.SEQUENCE_BUFFER) {
+                timelapseBuffer.shift();
+            }
+            timelapseBuffer.push({
+                frameNumber: frameCounter++,
+                gameTime: gameTime,
+                timestamp: Date.now(),
+                bciIntent: currentIntent,
+                playerState: {
+                    position: camera.position.toArray(),
+                    rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z],
+                    velocity: velocity.toArray()
+                },
+                gameState: {
+                    level: level,
+                    ammo: currentAmmo,
+                    kills: kills,
+                    drones: drones.length
+                }
+            });
+        }
+        function captureTimelapseFrame(triggerType = 'MANUAL') {
+            if (timelapseSequence.length >= CONFIG.TIMELAPSE.MAX_FRAMES) {
+                showBCIStatus("Max frames reached", "error");
+                return null;
+            }
+            try {
+                const timestamp = Date.now();
+                const frameId = `frame_${timestamp}_${timelapseSequence.length}`;
+                // Capture canvas frame
+                const imageData = captureCanvasFrame();
+                if (!imageData) return null;
+                // Get buffered game state
+                const recentState = timelapseBuffer.length > 0 ?
+                    timelapseBuffer[timelapseBuffer.length - 1] :
+                    getCurrentGameState();
+                // Create timelapse frame
+                const frame = {
+                    frame_id: frameId,
+                    sequence_id: currentSequence,
+                    frame_number: timelapseSequence.length,
+                    timestamp: timestamp,
+                    game_time: gameTime,
+                    trigger_type: triggerType,
+                    bci_intent: currentIntent,
+                    // Image data
+                    image_data: imageData,
+                    image_format: CONFIG.TIMELAPSE.FORMAT,
+                    image_resolution: CONFIG.TIMELAPSE.RESOLUTION,
+                    // Game state synchronized with frame
+                    game_state: {
+                        player_position: camera.position.toArray(),
+                        player_rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z],
+                        velocity: velocity.toArray(),
+                        is_grounded: isGrounded,
+                        combat_state: {
+                            ammo: currentAmmo,
+                            is_reloading: isReloading,
+                            shots_fired: shotsFired,
+                            shots_hit: shotsHit,
+                            accuracy: accuracy
+                        },
+                        game_stats: {
+                            level: level,
+                            exp: exp,
+                            required_exp: requiredExp,
+                            kills: kills
+                        },
+                        environment: {
+                            drones_active: drones.length,
+                            bullets_active: bullets.length
+                        }
+                    },
+                    // Input data for RLHF
+                    input_data: {
+                        mouse_position: { x: mouse.x, y: mouse.y },
+                        mouse_movement: { dx: mouse.dx, dy: mouse.dy },
+                        mouse_buttons: {
+                            lmb: mouse.lmbPressed,
+                            lmb_hold_duration: mouse.lmbPressed ? Date.now() - mouse.lmbHoldStart : 0
+                        },
+                        controls: {
+                            forward: controls.w,
+                            backward: controls.s,
+                            left: controls.a,
+                            right: controls.d,
+                            jump: controls.space
+                        },
+                        joystick: {
+                            active: joystickActive,
+                            vector: { x: joystickVector.x, y: joystickVector.y }
+                        }
+                    },
+                    // RLHF data
+                    rlhf_data: {
+                        is_rlhf_event: CONFIG.RLHF_EVENTS.includes(triggerType),
+                        auto_rating: CONFIG.RLHF_AUTO_RATINGS[triggerType] || null,
+                        trigger_type: triggerType
+                    }
+                };
+                timelapseSequence.push(frame);
+                // Show capture indicator
+                showCapturePulse();
+                // Update UI
+                document.getElementById('timelapseCount').textContent = timelapseSequence.length;
+                // Show preview
+                showTimelapsePreview(imageData);
+                // Record intent
+                recordBCIIntent('TIMELAPSE_CAPTURE');
+                console.log(`Timelapse frame captured: ${frameId} (${triggerType})`);
+                return frame;
+            } catch (error) {
+                console.error('Error capturing timelapse frame:', error);
+                return null;
+            }
+        }
+        function captureBurstFrames(count) {
+            if (captureMode !== CONFIG.CAPTURE_MODES.MANUAL) return;
+            showBCIStatus(`Burst capture: ${count} frames`);
+            let captured = 0;
+            const burstInterval = setInterval(() => {
+                if (captured < count && timelapseSequence.length < CONFIG.TIMELAPSE.MAX_FRAMES) {
+                    captureTimelapseFrame('BURST_MANUAL');
+                    captured++;
+                } else {
+                    clearInterval(burstInterval);
+                }
+            }, 100); // 10 FPS burst
+        }
+        function manualCapture() {
+            if (captureMode === CONFIG.CAPTURE_MODES.MANUAL) {
+                captureTimelapseFrame('KEYBOARD_MANUAL');
+            }
+        }
+        function captureCanvasFrame() {
+            try {
+                const canvas = renderer.domElement;
+                // Create off-screen canvas for resizing
+                const offscreen = document.createElement('canvas');
+                offscreen.width = CONFIG.TIMELAPSE.RESOLUTION.width;
+                offscreen.height = CONFIG.TIMELAPSE.RESOLUTION.height;
+                const ctx = offscreen.getContext('2d');
+                // Draw and resize canvas
+                ctx.drawImage(canvas,
+                    0, 0, canvas.width, canvas.height,
+                    0, 0, offscreen.width, offscreen.height);
+                // Convert to Base64
+                return offscreen.toDataURL(CONFIG.TIMELAPSE.FORMAT, CONFIG.TIMELAPSE.QUALITY);
+            } catch (error) {
+                console.error('Error capturing canvas frame:', error);
+                return null;
+            }
+        }
+        function getCurrentGameState() {
+            return {
+                frameNumber: timelapseSequence.length,
+                gameTime: gameTime,
+                timestamp: Date.now(),
+                bciIntent: currentIntent,
+                playerState: {
+                    position: camera.position.toArray(),
+                    rotation: [camera.rotation.x, camera.rotation.y, camera.rotation.z],
+                    velocity: velocity.toArray()
+                },
+                gameState: {
+                    level: level,
+                    ammo: currentAmmo,
+                    kills: kills,
+                    drones: drones.length
+                }
+            };
+        }
+        function showCapturePulse() {
+            const pulse = document.createElement('div');
+            pulse.className = 'capture-pulse';
+            document.body.appendChild(pulse);
+            setTimeout(() => {
+                if (pulse.parentNode) {
+                    pulse.parentNode.removeChild(pulse);
+                }
+            }, 500);
+        }
+        function showTimelapsePreview(imageData) {
+            const preview = document.getElementById('timelapsePreview');
+            if (!preview) return;
+            const img = new Image();
+            img.onload = function() {
+                const ctx = preview.getContext('2d');
+                ctx.clearRect(0, 0, preview.width, preview.height);
+                ctx.drawImage(img, 0, 0, preview.width, preview.height);
+                preview.style.display = 'block';
+                setTimeout(() => {
+                    preview.style.display = 'none';
+                }, 2000);
+            };
+            img.src = imageData;
+        }
+        function finalizeSequence() {
+            if (timelapseBuffer.length === 0) return;
+            // Create sequence summary
+            const sequence = {
+                sequence_id: currentSequence,
+                start_time: timelapseBuffer[0].timestamp,
+                end_time: timelapseBuffer[timelapseBuffer.length - 1].timestamp,
+                duration: timelapseBuffer[timelapseBuffer.length - 1].timestamp - timelapseBuffer[0].timestamp,
+                frame_count: timelapseBuffer.length,
+                frames: [...timelapseBuffer]
+            };
+            console.log(`Sequence ${currentSequence} finalized: ${sequence.frame_count} frames`);
+            showBCIStatus(`Sequence ${currentSequence}: ${sequence.frame_count} frames`);
+        }
+        function stopTimelapseRecording() {
+            if (captureInterval) {
+                clearInterval(captureInterval);
+                captureInterval = null;
+            }
+            isRecordingTimelapse = false;
+        }
+        // ========== EXPORT SYSTEM ==========
+        async function exportTimelapseDataset() {
+            if (timelapseSequence.length < 10) {
+                showBCIStatus("Need at least 10 timelapse frames", "error");
+                return;
+            }
+            try {
+                // Show progress
+                const progressDiv = document.getElementById('exportProgress');
+                const progressBar = document.getElementById('progressBar');
+                const progressText = document.getElementById('progressText');
+                progressDiv.style.display = 'block';
+                progressText.textContent = "Preparing timelapse dataset...";
+                progressBar.style.width = '0%';
+                // Create ZIP
+                const zip = new JSZip();
+                const sessionId = `bci_timelapse_${Date.now()}`;
+                // 1. Export timelapse frames metadata
+                progressText.textContent = "Exporting frame metadata...";
+                progressBar.style.width = '20%';
+                const framesJsonl = timelapseSequence.map(frame => {
+                    const frameCopy = { ...frame };
+                    frameCopy.image_filename = `frames/${frame.frame_id}.jpg`;
+                    delete frameCopy.image_data;
+                    return JSON.stringify(frameCopy);
+                }).join('\n');
+                zip.file("timelapse_frames.jsonl", framesJsonl);
+                // 2. Export sequence data
+                progressText.textContent = "Exporting sequence data...";
+                progressBar.style.width = '35%';
+                const sequences = groupFramesBySequence();
+                const sequencesJson = JSON.stringify(sequences, null, 2);
+                zip.file("sequences.json", sequencesJson);
+                // 3. Export BCI intents
+                progressText.textContent = "Exporting BCI intents...";
+                progressBar.style.width = '45%';
+                const intentsJsonl = intentHistory.map(i => JSON.stringify(i)).join('\n');
+                zip.file("bci_intents.jsonl", intentsJsonl);
+                // 4. Export frames as images
+                progressText.textContent = "Processing frames...";
+                progressBar.style.width = '60%';
+                const framesFolder = zip.folder("frames");
+                let frameCount = 0;
+                const totalFrames = timelapseSequence.length;
+                for (let i = 0; i < timelapseSequence.length; i++) {
+                    const frame = timelapseSequence[i];
+                    if (frame.image_data) {
+                        // Convert Base64 to binary
+                        const base64Data = frame.image_data.split(',')[1];
+                        const binaryData = atob(base64Data);
+                        const array = new Uint8Array(binaryData.length);
+                        for (let j = 0; j < binaryData.length; j++) {
+                            array[j] = binaryData.charCodeAt(j);
+                        }
+                        framesFolder.file(`${frame.frame_id}.jpg`, array);
+                        frameCount++;
+                        // Update progress
+                        if (i % 10 === 0) {
+                            progressBar.style.width = `${60 + (i / totalFrames * 30)}%`;
+                        }
+                    }
+                }
+                // 5. Export metadata
+                progressText.textContent = "Generating metadata...";
+                progressBar.style.width = '90%';
+                const metadata = generateTimelapseMetadata();
+                zip.file("metadata.json", JSON.stringify(metadata, null, 2));
+                // 6. Export README
+                const readme = generateTimelapseREADME();
+                zip.file("README.md", readme);
+                // Generate ZIP
+                progressText.textContent = "Creating ZIP archive...";
+                progressBar.style.width = '95%';
+                const zipBlob = await zip.generateAsync({
+                    type: "blob",
+                    compression: "DEFLATE",
+                    compressionOptions: { level: 5 }
+                });
+                // Download
+                saveAs(zipBlob, `${sessionId}_timelapse_dataset.zip`);
+                // Complete
+                progressText.textContent = "Export complete!";
+                progressBar.style.width = '100%';
+                setTimeout(() => {
+                    progressDiv.style.display = 'none';
+                    showBCIStatus(`Dataset exported (${(zipBlob.size/1024/1024).toFixed(2)}MB)`);
+                }, 1000);
+            } catch (error) {
+                console.error('Export failed:', error);
+                showBCIStatus(`Export failed: ${error.message}`, "error");
+                const progressDiv = document.getElementById('exportProgress');
+                if (progressDiv) {
+                    progressDiv.style.display = 'none';
+                }
+            }
+        }
+        function groupFramesBySequence() {
+            const sequences = {};
+            timelapseSequence.forEach(frame => {
+                const seqId = frame.sequence_id;
+                if (!sequences[seqId]) {
+                    sequences[seqId] = {
+                        sequence_id: seqId,
+                        frames: [],
+                        start_time: frame.timestamp,
+                        end_time: frame.timestamp,
+                        trigger_types: new Set()
+                    };
+                }
+                sequences[seqId].frames.push({
+                    frame_id: frame.frame_id,
+                    frame_number: frame.frame_number,
+                    timestamp: frame.timestamp,
+                    game_time: frame.game_time,
+                    trigger_type: frame.trigger_type,
+                    bci_intent: frame.bci_intent
+                });
+                sequences[seqId].end_time = frame.timestamp;
+                sequences[seqId].trigger_types.add(frame.trigger_type);
+            });
+            // Convert sets to arrays
+            Object.values(sequences).forEach(seq => {
+                seq.trigger_types = Array.from(seq.trigger_types);
+                seq.duration = seq.end_time - seq.start_time;
+                seq.frame_count = seq.frames.length;
+            });
+            return sequences;
+        }
+        function generateTimelapseMetadata() {
+            const sequences = groupFramesBySequence();
+            const rlhfEvents = timelapseSequence.filter(f => f.rlhf_data.is_rlhf_event);
+            return {
+                dataset_info: {
+                    name: "DATASTRIKE_BCI_TIMELAPSE_DATASET",
+                    version: "4.0.0",
+                    description: "Time-synchronized multimodal BCI dataset with frame-by-frame timelapse capture",
+                    license: "MIT",
+                    created_at: new Date().toISOString()
+                },
+                timelapse_info: {
+                    total_frames: timelapseSequence.length,
+                    sequences: Object.keys(sequences).length,
+                    frame_resolution: CONFIG.TIMELAPSE.RESOLUTION,
+                    frame_format: "jpg",
+                    quality: CONFIG.TIMELAPSE.QUALITY,
+                    max_frames: CONFIG.TIMELAPSE.MAX_FRAMES,
+                    capture_modes: Object.values(CONFIG.CAPTURE_MODES),
+                    current_mode: captureMode
+                },
+                rlhf_data: {
+                    total_events: rlhfEvents.length,
+                    event_types: Array.from(new Set(rlhfEvents.map(f => f.trigger_type))),
+                    coverage: (rlhfEvents.length / Math.max(1, timelapseSequence.length)) * 100
+                },
+                bci_data: {
+                    intent_categories: CONFIG.BCI_INTENT_TYPES,
+                    intent_samples: intentHistory.length,
+                    current_intent: currentIntent
+                },
+                game_stats: {
+                    session_duration: formatTime(gameTime),
+                    player_level: level,
+                    total_kills: kills,
+                    accuracy_percentage: accuracy,
+                    shots_fired: shotsFired,
+                    shots_hit: shotsHit
+                },
+                performance: {
+                    average_fps: fps,
+                    frame_counter: frameCounter
+                }
+            };
+        }
+        function generateTimelapseREADME() {
+            const date = new Date().toISOString().split('T')[0];
+            const duration = formatTime(gameTime);
+            const sequences = groupFramesBySequence();
+            return `# DATASTRIKE BCI Timelapse Dataset
+## Description
+Time-synchronized multimodal dataset for BCI intent recognition, collected with frame-by-frame timelapse capture during FPS gameplay.
+## Key Features
+- **Frame-by-Frame Timelapse**: Synchronized image sequences at 320x240 resolution
+- **Multiple Capture Modes**: Manual (LMB), Auto-interval, and Sequence recording
+- **BCI Intent Labels**: 13 intent categories including timelapse capture events
+- **Time-Synced Game State**: Every frame includes synchronized game state data
+- **RLHF Data**: Automated ratings for combat events and capture actions
+- **Sequence Analysis**: Grouped frames into temporal sequences for time-series analysis
+## Dataset Structure
+- \`timelapse_frames.jsonl\`: Frame metadata (one per line)
+- \`frames/\`: JPG images for each frame
+- \`sequences.json\`: Temporal grouping of frames
+- \`bci_intents.jsonl\`: BCI intent transition history
+- \`metadata.json\`: Dataset statistics and configuration
+- \`README.md\`: This documentation
+## Capture Modes
+1. **MANUAL**: LMB click captures single frame (hold for burst)
+2. **AUTO**: Automatic capture at ${CONFIG.TIMELAPSE.AUTO_INTERVAL}ms intervals
+3. **SEQUENCE**: Start/stop recording for continuous frame sequences
+## Dataset Statistics
+- **Total Frames**: ${timelapseSequence.length}
+- **Sequences**: ${Object.keys(sequences).length}
+- **Session Duration**: ${duration}
+- **Player Level**: ${level}
+- **Accuracy**: ${accuracy}%
+- **Total Kills**: ${kills}
+## Frame Data Structure
+Each frame includes:
+- Image data (320x240 JPG)
+- Timestamp and game time
+- BCI intent label
+- Full game state (position, rotation, velocity, ammo, etc.)
+- Input data (mouse movements, keyboard state)
+- RLHF rating (if applicable)
+## Usage for BCI Research
+\`\`\`python
+import json
+import cv2
+import numpy as np
+# Load frame metadata
+frames = []
+with open('timelapse_frames.jsonl', 'r') as f:
+    for line in f:
+        frames.append(json.loads(line))
+# Create time-series dataset
+X_images = []
+X_game_state = []
+y_intents = []
+for frame in frames:
+    # Load image
+    img_path = f"frames/{frame['image_filename'].split('/')[1]}"
+    img = cv2.imread(img_path)
+    X_images.append(img)
+    # Game state features
+    game_state = frame['game_state']
+    features = [
+        game_state['player_position'][0],  # x
+        game_state['player_position'][2],  # z
+        game_state['combat_state']['ammo'],
+        game_state['game_stats']['level']
+    ]
+    X_game_state.append(features)
+    # BCI intent label
+    y_intents.append(frame['bci_intent'])
+# For sequence modeling
+sequences = json.load(open('sequences.json', 'r'))
+for seq_id, sequence in sequences.items():
+    seq_frames = [f for f in frames if f['sequence_id'] == int(seq_id)]
+    # Process as temporal sequence for LSTM/Transformer models
+\`\`\`
+## Citation
+\`\`\`
+@dataset{datastrike_bci_timelapse_2026,
+  title={DATASTRIKE BCI Timelapse Dataset},
+  author={DATASTRIKE Team},
+  year={2026},
+  url={https://github.com/webxos/datastrike-bci},
+  note={Frame-by-frame timelapse capture for BCI intent recognition}
+}
+\`\`\`
+Generated on ${date} by DATASTRIKE BCI Timelapse v4.0
+`;
+        }
+        function formatTime(seconds) {
+            const mins = Math.floor(seconds / 60);
+            const secs = Math.floor(seconds % 60);
+            return `${mins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+        }
+        // ========== INITIALIZATION ==========
+        window.addEventListener('load', () => {
+            let progress = 0;
+            const loadInterval = setInterval(() => {
+                progress += Math.random() * 15;
+                if (progress > 85) {
+                    progress = 85;
+                }
+                updateLoader(progress, "Loading BCI Timelapse Capture...");
+            }, 150);
+            setTimeout(() => {
+                clearInterval(loadInterval);
+                init();
+            }, 1200);
+        });
+        // Mobile detection
+        if ('ontouchstart' in window || navigator.maxTouchPoints) {
+            document.querySelector('.mobile-controls').style.display = 'block';
+        }
+    </script>
+</body>
+</html>