Datasets:

webxos
/

space_zombies_RL

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <title>SPACE ZOMBIES RL - Mouse Behavior Dataset Gym</title>
+    <style>
+        body {
+            margin: 0;
+            overflow: hidden;
+            background: #000;
+            font-family: 'Courier New', monospace;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: 100vh;
+            color: #00ff00;
+            image-rendering: pixelated;
+            touch-action: none;
+        }
+        #gameContainer {
+            position: relative;
+            width: 800px;
+            height: 450px;
+            border: 2px solid #00ff00;
+            box-shadow: 0 0 20px #00ff00;
+            max-width: 100%;
+            max-height: 70vh;
+        }
+        canvas {
+            display: block;
+            width: 100%;
+            height: 100%;
+        }
+        #ui {
+            position: absolute;
+            top: 10px;
+            left: 10px;
+            z-index: 10;
+            background: rgba(0, 0, 0, 0.7);
+            padding: 10px;
+            border: 1px solid #00ff00;
+            font-size: 14px;
+        }
+        #healthBar {
+            width: 200px;
+            height: 20px;
+            background: #333;
+            border: 1px solid #00ff00;
+            margin-bottom: 10px;
+            position: relative;
+        }
+        #healthFill {
+            width: 100%;
+            height: 100%;
+            background: #00ff00;
+            transition: width 0.3s;
+        }
+        #healthText {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            text-align: center;
+            line-height: 20px;
+            font-weight: bold;
+        }
+        #datasetBar {
+            width: 200px;
+            height: 20px;
+            background: #333;
+            border: 1px solid #00aaff;
+            margin-top: 10px;
+            position: relative;
+        }
+        #datasetFill {
+            width: 0%;
+            height: 100%;
+            background: #00aaff;
+            transition: width 0.3s;
+        }
+        #datasetText {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            text-align: center;
+            line-height: 20px;
+            font-weight: bold;
+            color: #fff;
+        }
+        #bombCooldown {
+            width: 200px;
+            height: 10px;
+            background: #333;
+            border: 1px solid #00ff00;
+            margin-top: 5px;
+        }
+        #bombFill {
+            width: 0%;
+            height: 100%;
+            background: #ff5500;
+            transition: width 0.1s;
+        }
+        #gameOver {
+            display: none;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.9);
+            padding: 30px;
+            border: 3px solid #00ff00;
+            text-align: center;
+            z-index: 20;
+            width: 300px;
+        }
+        #menu {
+            display: none;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.95);
+            padding: 20px;
+            border: 3px solid #00ff00;
+            z-index: 20;
+            width: 500px;
+            max-height: 80vh;
+            overflow-y: auto;
+        }
+        .menu-section {
+            margin-bottom: 20px;
+            border-bottom: 1px solid #00ff00;
+            padding-bottom: 10px;
+        }
+        .stat-row {
+            display: flex;
+            justify-content: space-between;
+            margin: 5px 0;
+        }
+        button {
+            background: #00ff00;
+            color: #000;
+            border: none;
+            padding: 10px 20px;
+            margin-top: 10px;
+            cursor: pointer;
+            font-weight: bold;
+            font-family: 'Courier New', monospace;
+        }
+        button:hover {
+            background: #22ff22;
+        }
+        button:disabled {
+            background: #555;
+            cursor: not-allowed;
+        }
+        #instructions {
+            margin-top: 20px;
+            text-align: center;
+            max-width: 800px;
+            line-height: 1.5;
+            font-size: 14px;
+            color: #00aaff;
+        }
+        .crosshair {
+            position: absolute;
+            width: 20px;
+            height: 20px;
+            pointer-events: none;
+            z-index: 15;
+            transform: translate(-50%, -50%);
+            color: #00ff00;
+            font-size: 20px;
+            text-align: center;
+            line-height: 20px;
+        }
+        #movementIndicator {
+            position: absolute;
+            width: 20px;
+            height: 20px;
+            border-radius: 50%;
+            background: rgba(0, 255, 255, 0.5);
+            border: 2px solid #00ffff;
+            pointer-events: none;
+            z-index: 5;
+            display: none;
+            transform: translate(-50%, -50%);
+        }
+        #exportPanel {
+            display: none;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.95);
+            padding: 30px;
+            border: 3px solid #00aaff;
+            z-index: 25;
+            width: 400px;
+            text-align: center;
+        }
+        .data-point {
+            position: absolute;
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            z-index: 3;
+            pointer-events: none;
+        }
+        .lmb-point {
+            background: rgba(255, 0, 0, 0.7);
+            box-shadow: 0 0 8px rgba(255, 0, 0, 0.9);
+        }
+        .rmb-point {
+            background: rgba(255, 165, 0, 0.7);
+            box-shadow: 0 0 8px rgba(255, 165, 0, 0.9);
+        }
+        .move-point {
+            background: rgba(0, 255, 255, 0.5);
+            box-shadow: 0 0 5px rgba(0, 255, 255, 0.7);
+        }
+        #dataStats {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            z-index: 10;
+            background: rgba(0, 0, 0, 0.7);
+            padding: 10px;
+            border: 1px solid #00aaff;
+            font-size: 12px;
+            max-width: 200px;
+        }
+        #waveAlert {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            font-size: 24px;
+            font-weight: bold;
+            text-shadow: 0 0 10px #00ff00;
+            z-index: 15;
+            display: none;
+        }
+        #completionMessage {
+            display: none;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: rgba(0, 0, 0, 0.9);
+            padding: 30px;
+            border: 3px solid #00ff00;
+            text-align: center;
+            z-index: 20;
+            width: 400px;
+        }
+        @media (max-width: 768px) {
+            #gameContainer {
+                width: 100%;
+                height: 60vh;
+            }
+            #ui {
+                font-size: 12px;
+                padding: 5px;
+            }
+            #healthBar, #datasetBar, #bombCooldown {
+                width: 150px;
+            }
+            #dataStats {
+                font-size: 10px;
+                padding: 5px;
+                max-width: 150px;
+            }
+        }
+    </style>
+    <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>
+</head>
+<body>
+    <h1>SPACE ZOMBIES RL GYM by webXOS 2026</h1>
+    <div id="gameContainer">
+        <div id="ui">
+            <div class="stat-row">
+                <div>Wave: <span id="waveNumber">1</span>/10</div>
+                <div>Dataset Level: <span id="datasetLevel">1</span></div>
+            </div>
+            <div class="stat-row">
+                <div>Zombies: <span id="zombieCountValue">0</span></div>
+                <div>Data Points: <span id="dataPoints">0</span>/<span id="dataNeeded">100</span></div>
+            </div>
+            <div>HEALTH</div>
+            <div id="healthBar">
+                <div id="healthFill"></div>
+                <div id="healthText">100%</div>
+            </div>
+            <div class="stat-row">
+                <div>Bomb Ready</div>
+                <div id="bombTimer">10s</div>
+            </div>
+            <div id="bombCooldown">
+                <div id="bombFill"></div>
+            </div>
+            <div>DATASET PROGRESS</div>
+            <div id="datasetBar">
+                <div id="datasetFill"></div>
+                <div id="datasetText">0%</div>
+            </div>
+        </div>
+        <div id="dataStats">
+            <div>Mouse Data Collection</div>
+            <div>LMB Clicks: <span id="lmbCount">0</span></div>
+            <div>RMB Clicks: <span id="rmbCount">0</span></div>
+            <div>Movement: <span id="moveCount">0</span></div>
+            <div>Session Time: <span id="sessionTime">0</span>s</div>
+        </div>
+        <div id="waveAlert">Wave <span id="waveAlertNumber">1</span></div>
+        <div id="gameOver">
+            <h2>MISSION TERMINATED</h2>
+            <p>You survived <span id="finalWave">0</span> waves</p>
+            <p>Dataset Level: <span id="finalDatasetLevel">1</span></p>
+            <p>Total Data Points: <span id="finalDataPoints">0</span></p>
+            <button id="exportButton">EXPORT DATASET</button>
+            <button id="restartButton">NEW SESSION</button>
+        </div>
+        <div id="completionMessage">
+            <h2>DATASET COMPLETE!</h2>
+            <p>You cleared all 10 waves and collected valuable RL data!</p>
+            <p>Final Dataset Level: <span id="completionDatasetLevel">1</span></p>
+            <p>Total Samples: <span id="completionSamples">0</span></p>
+            <button id="completionExport">EXPORT TO HUGGING FACE</button>
+            <button id="completionRestart">NEW COLLECTION</button>
+        </div>
+        <div id="menu">
+            <h2>RL DATASET COLLECTOR</h2>
+            <div class="menu-section">
+                <h3>DATASET STATS</h3>
+                <div class="stat-row">
+                    <div>Dataset Level:</div>
+                    <div id="menuDatasetLevel">1</div>
+                </div>
+                <div class="stat-row">
+                    <div>Data Points:</div>
+                    <div id="menuDataPoints">0/100</div>
+                </div>
+                <div class="stat-row">
+                    <div>Mouse Clicks (LMB):</div>
+                    <div id="menuLMB">0</div>
+                </div>
+                <div class="stat-row">
+                    <div>Bomb Clicks (RMB):</div>
+                    <div id="menuRMB">0</div>
+                </div>
+                <div class="stat-row">
+                    <div>Movement Samples:</div>
+                    <div id="menuMovement">0</div>
+                </div>
+                <div class="stat-row">
+                    <div>Session Duration:</div>
+                    <div id="menuSessionTime">0s</div>
+                </div>
+            </div>
+            <div class="menu-section">
+                <h3>RL RESEARCH PARAMETERS</h3>
+                <div class="stat-row">
+                    <div>Sampling Rate:</div>
+                    <div>50ms</div>
+                </div>
+                <div class="stat-row">
+                    <div>Features Collected:</div>
+                    <div>18</div>
+                </div>
+                <div class="stat-row">
+                    <div>Export Format:</div>
+                    <div>JSON + CSV</div>
+                </div>
+                <div class="stat-row">
+                    <div>HF Compatible:</div>
+                    <div style="color: #00ff00">✓</div>
+                </div>
+            </div>
+            <button id="resumeButton">RESUME COLLECTION</button>
+            <button id="manualExport" style="background: #00aaff; margin-left: 10px;">EXPORT NOW</button>
+        </div>
+        <div id="exportPanel">
+            <h2>DATASET EXPORT</h2>
+            <p>Your mouse behavior data is ready for Hugging Face!</p>
+            <div id="exportStats" style="text-align: left; margin: 15px 0; padding: 10px; background: rgba(0,0,0,0.5);">
+                <!-- Filled by JavaScript -->
+            </div>
+            <p>Files included in export:</p>
+            <ul style="text-align: left; font-size: 14px;">
+                <li>mouse_behavior.json (raw data)</li>
+                <li>rl_transitions.csv (state-action pairs)</li>
+                <li>metadata.yaml (HF dataset card)</li>
+                <li>README.md (usage instructions)</li>
+            </ul>
+            <button id="downloadButton">DOWNLOAD ZIP</button>
+            <button id="closeExport" style="background: #555; margin-left: 10px;">CLOSE</button>
+        </div>
+        <div class="crosshair">+</div>
+        <div id="movementIndicator"></div>
+        <canvas id="gameCanvas"></canvas>
+    </div>
+    <div id="instructions">
+        <p><strong>RL RESEARCH MODE:</strong> CLICK to move | AUTO-AIM at nearest zombie | RIGHT CLICK or BOMB button (10s cooldown) | ESC for menu</p>
+        <p>Every mouse action collects data for RL training. Survive waves to level up your dataset. Export to Hugging Face for research!</p>
+    </div>
+    <script>
+        // Game variables
+        let scene, camera, renderer;
+        let player, playerModel, zombies = [];
+        let walls = [];
+        let doors = [];
+        let projectiles = [];
+        let explosions = [];
+        let itemDrops = [];
+        let playerHealth = 100;
+        let playerMaxHealth = 100;
+        let datasetLevel = 1;
+        let datasetPoints = 0;
+        let pointsToNextLevel = 100;
+        let playerSpeed = 0.1;
+        let playerDamage = 10;
+        let currentWave = 1;
+        let maxWaves = 10;
+        let zombiesInWave = 0;
+        let zombiesRemaining = 0;
+        let zombiesKilled = 0;
+        let gameOver = false;
+        let gameCompleted = false;
+        let lastSpawnTime = 0;
+        let lastWaveTime = 0;
+        let lastShotTime = 0;
+        let bombCooldown = 0;
+        let bombMaxCooldown = 10;
+        let mouse = { x: 0, y: 0, leftDown: false, rightDown: false };
+        let playerTarget = { x: 0, y: 0, z: 0 };
+        let isMenuOpen = false;
+        let raycaster = new THREE.Raycaster();
+        // RL Dataset variables
+        let mouseDataset = [];
+        let sessionStartTime = Date.now();
+        let lmbCount = 0;
+        let rmbCount = 0;
+        let movementSamples = 0;
+        let lastMouseMoveTime = 0;
+        let lastMousePosition = { x: 0, y: 0 };
+        let mouseMoveThreshold = 5;
+        let samplingInterval = 50;
+        // Movement system - FIXED to match original
+        let moveToTarget = null;
+        let isMoving = false;
+        // Shooting system - AUTO SHOOT like original
+        let autoShoot = true;
+        // Initialize the game
+        function init() {
+            // Create scene
+            scene = new THREE.Scene();
+            scene.background = new THREE.Color(0x000011);
+            // Create starfield background
+            createStarfield();
+            // Create camera (orthographic for isometric view)
+            const frustumSize = 50;
+            const aspect = 800 / 450;
+            camera = new THREE.OrthographicCamera(
+                frustumSize * aspect / -2,
+                frustumSize * aspect / 2,
+                frustumSize / 2,
+                frustumSize / -2,
+                0.1,
+                1000
+            );
+            camera.position.set(35, 35, 35);
+            camera.lookAt(0, 0, 0);
+            // Create renderer
+            renderer = new THREE.WebGLRenderer({
+                canvas: document.getElementById('gameCanvas'),
+                antialias: false
+            });
+            renderer.setSize(800, 450);
+            renderer.setPixelRatio(1);
+            // Lighting
+            const ambientLight = new THREE.AmbientLight(0x404040, 1);
+            scene.add(ambientLight);
+            const pointLight = new THREE.PointLight(0xffffff, 1, 50);
+            pointLight.position.set(0, 0, 10);
+            scene.add(pointLight);
+            // Create environment
+            createEnvironment();
+            // Create player
+            createPlayer();
+            // Start game loop
+            animate();
+            // Event listeners - FIXED to match original controls
+            window.addEventListener('keydown', (e) => {
+                if (e.code === 'Escape') {
+                    toggleMenu();
+                    e.preventDefault();
+                }
+            });
+            document.getElementById('restartButton').addEventListener('click', restartGame);
+            document.getElementById('completionRestart').addEventListener('click', restartGame);
+            document.getElementById('completionExport').addEventListener('click', showExportPanel);
+            document.getElementById('exportButton').addEventListener('click', showExportPanel);
+            document.getElementById('resumeButton').addEventListener('click', toggleMenu);
+            document.getElementById('manualExport').addEventListener('click', showExportPanel);
+            document.getElementById('closeExport').addEventListener('click', () => {
+                document.getElementById('exportPanel').style.display = 'none';
+            });
+            document.getElementById('downloadButton').addEventListener('click', exportDataset);
+            const gameContainer = document.getElementById('gameContainer');
+            // Mouse move tracking - UPDATED to work like original
+            gameContainer.addEventListener('mousemove', (e) => {
+                if (isMenuOpen || gameOver || gameCompleted) return;
+                const rect = gameContainer.getBoundingClientRect();
+                const x = e.clientX - rect.left;
+                const y = e.clientY - rect.top;
+                mouse.x = (x / rect.width) * 2 - 1;
+                mouse.y = -(y / rect.height) * 2 + 1;
+                // Update crosshair position
+                const crosshair = document.querySelector('.crosshair');
+                crosshair.style.left = x + 'px';
+                crosshair.style.top = y + 'px';
+                // Record mouse movement for RL dataset
+                recordMouseMovement(x, y, rect.width, rect.height);
+            });
+            // Click to move - FIXED: Like original, click moves player
+            gameContainer.addEventListener('mousedown', (e) => {
+                if (isMenuOpen || gameOver || gameCompleted) return;
+                const rect = gameContainer.getBoundingClientRect();
+                const clientX = e.clientX;
+                const clientY = e.clientY;
+                // Right click for bomb (like original)
+                if (e.button === 2) {
+                    e.preventDefault();
+                    useBomb();
+                    recordMouseAction('rmb', clientX - rect.left, clientY - rect.top);
+                    return;
+                }
+                // Left click for movement ONLY (like original)
+                if (e.button === 0) {
+                    // Record movement click
+                    recordMouseAction('move_click', clientX - rect.left, clientY - rect.top);
+                    // Handle movement (exactly like original)
+                    handleMoveInput(e);
+                }
+            });
+            // Prevent context menu - FIXED: Right click for bomb
+            gameContainer.addEventListener('contextmenu', (e) => {
+                e.preventDefault();
+                if (!isMenuOpen && !gameOver && !gameCompleted) {
+                    useBomb();
+                    const rect = gameContainer.getBoundingClientRect();
+                    recordMouseAction('rmb', e.clientX - rect.left, e.clientY - rect.top);
+                }
+            });
+            // Update session timer every second
+            setInterval(updateSessionTimer, 1000);
+            // Start first wave
+            startWave();
+        }
+        // Record mouse movement for RL dataset
+        function recordMouseMovement(x, y, containerWidth, containerHeight) {
+            const now = Date.now();
+            const gameRect = document.getElementById('gameContainer').getBoundingClientRect();
+            // Only record if enough time has passed
+            if (now - lastMouseMoveTime > samplingInterval) {
+                // Calculate normalized position (0-1)
+                const normalizedX = x / containerWidth;
+                const normalizedY = y / containerHeight;
+                // Calculate velocity
+                let velocityX = 0, velocityY = 0;
+                if (lastMousePosition.x !== 0 || lastMousePosition.y !== 0) {
+                    velocityX = (x - lastMousePosition.x) / ((now - lastMouseMoveTime) || 1);
+                    velocityY = (y - lastMousePosition.y) / ((now - lastMouseMoveTime) || 1);
+                }
+                // Create data point
+                const dataPoint = {
+                    timestamp: now,
+                    type: 'move',
+                    position: { x: normalizedX, y: normalizedY },
+                    velocity: { x: velocityX, y: velocityY },
+                    gameState: {
+                        playerHealth: playerHealth,
+                        playerPosition: { x: player.position.x, z: player.position.z },
+                        zombiesCount: zombies.length,
+                        wave: currentWave,
+                        datasetLevel: datasetLevel
+                    },
+                    action: 'mouse_move'
+                };
+                mouseDataset.push(dataPoint);
+                movementSamples++;
+                // Add visual indicator (faint)
+                const point = document.createElement('div');
+                point.className = 'data-point move-point';
+                point.style.left = (x + gameRect.left) + 'px';
+                point.style.top = (y + gameRect.top) + 'px';
+                document.body.appendChild(point);
+                // Remove after animation
+                setTimeout(() => {
+                    if (point.parentNode) {
+                        point.parentNode.removeChild(point);
+                    }
+                }, 1000);
+                // Add dataset points
+                addDatasetPoints(1);
+                // Update last position and time
+                lastMousePosition = { x: x, y: y };
+                lastMouseMoveTime = now;
+                // Update UI
+                document.getElementById('moveCount').textContent = movementSamples;
+            }
+        }
+        // Record mouse action
+        function recordMouseAction(type, x, y) {
+            const now = Date.now();
+            const gameRect = document.getElementById('gameContainer').getBoundingClientRect();
+            const containerWidth = gameRect.width;
+            const containerHeight = gameRect.height;
+            // Calculate normalized position
+            const normalizedX = x / containerWidth;
+            const normalizedY = y / containerHeight;
+            // Create data point
+            const dataPoint = {
+                timestamp: now,
+                type: type,
+                position: { x: normalizedX, y: normalizedY },
+                gameState: {
+                    playerHealth: playerHealth,
+                    playerPosition: { x: player.position.x, z: player.position.z },
+                    zombiesCount: zombies.length,
+                    wave: currentWave,
+                    datasetLevel: datasetLevel
+                },
+                action: type === 'rmb' ? 'bomb' : 'move'
+            };
+            mouseDataset.push(dataPoint);
+            // Update counts
+            if (type === 'move_click') {
+                lmbCount++;
+                document.getElementById('lmbCount').textContent = lmbCount;
+            } else if (type === 'rmb') {
+                rmbCount++;
+                document.getElementById('rmbCount').textContent = rmbCount;
+            }
+            // Add visual indicator
+            const point = document.createElement('div');
+            point.className = `data-point ${type === 'move_click' ? 'lmb-point' : 'rmb-point'}`;
+            point.style.left = (x + gameRect.left) + 'px';
+            point.style.top = (y + gameRect.top) + 'px';
+            document.body.appendChild(point);
+            // Remove after animation
+            setTimeout(() => {
+                if (point.parentNode) {
+                    point.parentNode.removeChild(point);
+                }
+            }, 1500);
+            // Add dataset points for actions
+            addDatasetPoints(type === 'move_click' ? 3 : 10);
+        }
+        // Add points to dataset and level up if needed
+        function addDatasetPoints(points) {
+            datasetPoints += points;
+            // Check for level up
+            if (datasetPoints >= pointsToNextLevel) {
+                datasetLevel++;
+                datasetPoints = datasetPoints - pointsToNextLevel;
+                pointsToNextLevel = Math.floor(pointsToNextLevel * 1.5);
+                // Level up benefits
+                playerMaxHealth += 10;
+                playerHealth = Math.min(playerMaxHealth, playerHealth + 20);
+                playerDamage += 2;
+                // Show level up notification
+                showNotification(`Dataset Level ${datasetLevel}!`, '#00aaff');
+            }
+            updateDatasetUI();
+        }
+        // Update dataset UI
+        function updateDatasetUI() {
+            const datasetPercent = (datasetPoints / pointsToNextLevel) * 100;
+            document.getElementById('datasetFill').style.width = datasetPercent + '%';
+            document.getElementById('datasetText').textContent = Math.floor(datasetPercent) + '%';
+            document.getElementById('datasetLevel').textContent = datasetLevel;
+            document.getElementById('dataPoints').textContent = datasetPoints;
+            document.getElementById('dataNeeded').textContent = pointsToNextLevel;
+            // Update menu if open
+            if (isMenuOpen) {
+                updateMenu();
+            }
+        }
+        // Show notification
+        function showNotification(message, color) {
+            const notification = document.createElement('div');
+            notification.textContent = message;
+            notification.style.position = 'absolute';
+            notification.style.top = '50%';
+            notification.style.left = '50%';
+            notification.style.transform = 'translate(-50%, -50%)';
+            notification.style.background = 'rgba(0,0,0,0.8)';
+            notification.style.color = color || '#00ff00';
+            notification.style.padding = '10px 20px';
+            notification.style.border = `2px solid ${color || '#00ff00'}`;
+            notification.style.zIndex = '100';
+            notification.style.fontWeight = 'bold';
+            notification.style.fontSize = '18px';
+            document.getElementById('gameContainer').appendChild(notification);
+            setTimeout(() => {
+                if (notification.parentNode) {
+                    notification.parentNode.removeChild(notification);
+                }
+            }, 2000);
+        }
+        // Update session timer
+        function updateSessionTimer() {
+            if (gameOver || gameCompleted) return;
+            const sessionTime = Math.floor((Date.now() - sessionStartTime) / 1000);
+            document.getElementById('sessionTime').textContent = sessionTime;
+        }
+        // Create starfield background
+        function createStarfield() {
+            const starGeometry = new THREE.BufferGeometry();
+            const starCount = 2000;
+            const positions = new Float32Array(starCount * 3);
+            for (let i = 0; i < starCount * 3; i += 3) {
+                positions[i] = (Math.random() - 0.5) * 3000;
+                positions[i + 1] = (Math.random() - 0.5) * 3000;
+                positions[i + 2] = (Math.random() - 0.5) * 3000;
+            }
+            starGeometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+            const starMaterial = new THREE.PointsMaterial({
+                color: 0xFFFFFF,
+                size: 2,
+                sizeAttenuation: false
+            });
+            const starField = new THREE.Points(starGeometry, starMaterial);
+            scene.add(starField);
+        }
+        // Handle move input (click or tap) - FIXED: Exactly like original
+        function handleMoveInput(e) {
+            if (isMenuOpen || gameOver || gameCompleted) return;
+            e.preventDefault();
+            const rect = e.currentTarget.getBoundingClientRect();
+            let clientX, clientY;
+            if (e.type === 'touchstart') {
+                clientX = e.touches[0].clientX;
+                clientY = e.touches[0].clientY;
+            } else {
+                clientX = e.clientX;
+                clientY = e.clientY;
+                // Right click is for bomb, handled separately
+                if (e.button === 2) return;
+            }
+            const x = ((clientX - rect.left) / rect.width) * 2 - 1;
+            const y = -((clientY - rect.top) / rect.height) * 2 + 1;
+            // Calculate target position in 3D space using raycaster
+            raycaster.setFromCamera(new THREE.Vector2(x, y), camera);
+            const plane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);
+            const targetPoint = new THREE.Vector3();
+            raycaster.ray.intersectPlane(plane, targetPoint);
+            // Set move target
+            moveToTarget = {
+                x: Math.max(-24, Math.min(24, targetPoint.x)),
+                z: Math.max(-24, Math.min(24, targetPoint.z))
+            };
+            isMoving = true;
+            // Show movement indicator
+            const indicator = document.getElementById('movementIndicator');
+            indicator.style.display = 'block';
+            indicator.style.left = (clientX - rect.left) + 'px';
+            indicator.style.top = (clientY - rect.top) + 'px';
+            // Hide indicator after a moment
+            setTimeout(() => {
+                indicator.style.display = 'none';
+            }, 500);
+        }
+        // Create the space station environment
+        function createEnvironment() {
+            // Create central platform
+            const platformGeometry = new THREE.CylinderGeometry(30, 30, 0.5, 32);
+            const platformMaterial = new THREE.MeshPhongMaterial({
+                color: 0x111111,
+                shininess: 30,
+                emissive: 0x001100
+            });
+            const platform = new THREE.Mesh(platformGeometry, platformMaterial);
+            platform.position.y = -0.25;
+            scene.add(platform);
+            // Create perimeter walls
+            const wallHeight = 3;
+            const wallThickness = 0.5;
+            // Create circular wall around platform
+            const wallSegments = 32;
+            for (let i = 0; i < wallSegments; i++) {
+                const angle = (i / wallSegments) * Math.PI * 2;
+                const x = Math.cos(angle) * 29;
+                const z = Math.sin(angle) * 29;
+                const wallSegment = new THREE.Mesh(
+                    new THREE.BoxGeometry(wallThickness, wallHeight, 5),
+                    new THREE.MeshPhongMaterial({
+                        color: 0x002200,
+                        emissive: 0x00ff00,
+                        shininess: 100
+                    })
+                );
+                wallSegment.position.set(x, wallHeight/2, z);
+                wallSegment.rotation.y = -angle;
+                scene.add(wallSegment);
+                walls.push(wallSegment);
+            }
+            // Create interior structures
+            createInteriorStructures();
+            // Create doors
+            const doorPositions = [
+                { x: 0, z: 29, rotation: 0 },
+                { x: 29, z: 0, rotation: Math.PI/2 },
+                { x: 0, z: -29, rotation: Math.PI },
+                { x: -29, z: 0, rotation: -Math.PI/2 }
+            ];
+            doorPositions.forEach(pos => {
+                const door = createDoor(pos.x, 1.5, pos.z, pos.rotation);
+                scene.add(door);
+                doors.push(door);
+            });
+        }
+        // Create interior structures
+        function createInteriorStructures() {
+            const obstaclePositions = [
+                { x: 10, z: 10, rotation: 0 },
+                { x: -10, z: 10, rotation: Math.PI/4 },
+                { x: 10, z: -10, rotation: Math.PI/2 },
+                { x: -10, z: -10, rotation: Math.PI }
+            ];
+            obstaclePositions.forEach(pos => {
+                const obstacle = createCyberObstacle(pos.x, 1, pos.z, pos.rotation);
+                scene.add(obstacle);
+                walls.push(obstacle);
+            });
+        }
+        // Create a cyber-themed obstacle
+        function createCyberObstacle(x, y, z, rotation) {
+            const obstacleGroup = new THREE.Group();
+            const baseGeometry = new THREE.BoxGeometry(3, 2, 3);
+            const baseMaterial = new THREE.MeshPhongMaterial({
+                color: 0x002200,
+                emissive: 0x004400
+            });
+            const base = new THREE.Mesh(baseGeometry, baseMaterial);
+            base.position.y = 1;
+            obstacleGroup.add(base);
+            const detailGeometry = new THREE.BoxGeometry(2.8, 0.2, 0.2);
+            const detailMaterial = new THREE.MeshPhongMaterial({
+                color: 0x00ff00,
+                emissive: 0x00aa00
+            });
+            for (let i = 0; i < 3; i++) {
+                const detail = new THREE.Mesh(detailGeometry, detailMaterial);
+                detail.position.set(0, 0.5 + i * 0.7, 1.4);
+                base.add(detail);
+            }
+            const lightGeometry = new THREE.CylinderGeometry(0.5, 0.5, 0.3, 8);
+            const lightMaterial = new THREE.MeshPhongMaterial({
+                color: 0x00ff00,
+                emissive: 0x00ff00
+            });
+            const light = new THREE.Mesh(lightGeometry, lightMaterial);
+            light.position.set(0, 2.1, 0);
+            obstacleGroup.add(light);
+            obstacleGroup.position.set(x, y, z);
+            obstacleGroup.rotation.y = rotation;
+            return obstacleGroup;
+        }
+        // Create a door
+        function createDoor(x, y, z, rotation) {
+            const doorGeometry = new THREE.BoxGeometry(4, 3, 0.2);
+            const doorMaterial = new THREE.MeshPhongMaterial({
+                color: 0x00ff00,
+                emissive: 0x004400
+            });
+            const door = new THREE.Mesh(doorGeometry, doorMaterial);
+            door.position.set(x, y, z);
+            door.rotation.y = rotation;
+            return door;
+        }
+        // Create the player character
+        function createPlayer() {
+            playerModel = new THREE.Group();
+            // Body
+            const bodyGeometry = new THREE.CylinderGeometry(0.5, 0.5, 1.2, 8);
+            const bodyMaterial = new THREE.MeshPhongMaterial({
+                color: 0xffffff,
+                shininess: 100
+            });
+            const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
+            body.position.y = 0.6;
+            playerModel.add(body);
+            // Helmet
+            const helmetGeometry = new THREE.SphereGeometry(0.4, 12, 12);
+            const helmetMaterial = new THREE.MeshPhongMaterial({
+                color: 0xffffff,
+                shininess: 100,
+                transparent: true,
+                opacity: 0.7
+            });
+            const helmet = new THREE.Mesh(helmetGeometry, helmetMaterial);
+            helmet.position.y = 1.5;
+            playerModel.add(helmet);
+            // Visor
+            const visorGeometry = new THREE.BoxGeometry(0.3, 0.15, 0.05);
+            const visorMaterial = new THREE.MeshPhongMaterial({
+                color: 0x00aaff,
+                emissive: 0x002244
+            });
+            const visor = new THREE.Mesh(visorGeometry, visorMaterial);
+            visor.position.set(0, 1.5, 0.35);
+            playerModel.add(visor);
+            player = new THREE.Group();
+            player.add(playerModel);
+            player.position.set(0, 0, 0);
+            scene.add(player);
+        }
+        // Create a zombie
+        function createZombie(type, spawnPoint) {
+            const baseHealth = 50 + (currentWave * 15);
+            const baseSpeed = 0.05 + (currentWave * 0.005);
+            const baseDamage = 5 + (currentWave * 1);
+            const zombieModel = new THREE.Group();
+            // Body
+            const bodyGeometry = new THREE.CylinderGeometry(0.5, 0.5, 1.2, 8);
+            const bodyMaterial = new THREE.MeshPhongMaterial({
+                color: 0xff0000,
+                shininess: 50
+            });
+            const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
+            body.position.y = 0.6;
+            body.rotation.x = Math.PI / 8;
+            zombieModel.add(body);
+            // Head
+            const headGeometry = new THREE.SphereGeometry(0.4, 12, 12);
+            const headMaterial = new THREE.MeshPhongMaterial({
+                color: 0xff0000,
+                shininess: 50
+            });
+            const head = new THREE.Mesh(headGeometry, headMaterial);
+            head.position.y = 1.5;
+            zombieModel.add(head);
+            const zombie = new THREE.Group();
+            zombie.add(zombieModel);
+            // Position at one of the doors
+            const door = doors[spawnPoint];
+            zombie.position.copy(door.position);
+            zombie.position.y = 0;
+            zombie.type = type;
+            zombie.speed = baseSpeed;
+            zombie.health = baseHealth;
+            zombie.maxHealth = baseHealth;
+            zombie.damage = baseDamage;
+            zombie.lastDirectionChange = 0;
+            zombie.wobbleOffset = Math.random() * Math.PI * 2;
+            scene.add(zombie);
+            zombies.push(zombie);
+            return zombie;
+        }
+        // Create a projectile
+        function createProjectile(startX, startZ, targetX, targetZ) {
+            const geometry = new THREE.SphereGeometry(0.1, 6, 6);
+            const material = new THREE.MeshBasicMaterial({
+                color: 0x00ffff,
+                emissive: 0x004444
+            });
+            const projectile = new THREE.Mesh(geometry, material);
+            projectile.position.set(startX, 0.5, startZ);
+            // Calculate direction
+            const dx = targetX - startX;
+            const dz = targetZ - startZ;
+            const distance = Math.sqrt(dx * dx + dz * dz);
+            projectile.direction = {
+                x: dx / distance,
+                z: dz / distance
+            };
+            projectile.speed = 0.5;
+            projectile.damage = playerDamage;
+            scene.add(projectile);
+            projectiles.push(projectile);
+            return projectile;
+        }
+        // Create an explosion effect
+        function createExplosion(x, z, radius, damage) {
+            const explosion = {
+                x: x,
+                z: z,
+                radius: radius * 3,
+                damage: damage,
+                time: 0,
+                maxTime: 0.5
+            };
+            const geometry = new THREE.SphereGeometry(explosion.radius, 16, 16);
+            const material = new THREE.MeshBasicMaterial({
+                color: 0xff5500,
+                transparent: true,
+                opacity: 0.7
+            });
+            const explosionMesh = new THREE.Mesh(geometry, material);
+            explosionMesh.position.set(x, 0.1, z);
+            scene.add(explosionMesh);
+            explosion.mesh = explosionMesh;
+            explosions.push(explosion);
+            return explosion;
+        }
+        // Create an item drop
+        function createItemDrop(x, z, type) {
+            const drop = {
+                x: x,
+                z: z,
+                type: type,
+                mesh: null,
+                time: 0
+            };
+            if (type === 'exp') {
+                // XP orb
+                const geometry = new THREE.OctahedronGeometry(0.3, 0);
+                const material = new THREE.MeshPhongMaterial({
+                    color: 0x00ff00,
+                    emissive: 0x004400,
+                    shininess: 100
+                });
+                const dropMesh = new THREE.Mesh(geometry, material);
+                dropMesh.position.set(x, 0.5, z);
+                scene.add(dropMesh);
+                drop.mesh = dropMesh;
+            } else {
+                // Health pack
+                const crossGroup = new THREE.Group();
+                const verticalGeometry = new THREE.BoxGeometry(0.2, 0.6, 0.1);
+                const horizontalGeometry = new THREE.BoxGeometry(0.6, 0.2, 0.1);
+                const crossMaterial = new THREE.MeshPhongMaterial({
+                    color: 0xff0000,
+                    emissive: 0x440000,
+                    shininess: 100
+                });
+                const vertical = new THREE.Mesh(verticalGeometry, crossMaterial);
+                const horizontal = new THREE.Mesh(horizontalGeometry, crossMaterial);
+                crossGroup.add(vertical);
+                crossGroup.add(horizontal);
+                crossGroup.position.set(x, 0.5, z);
+                scene.add(crossGroup);
+                drop.mesh = crossGroup;
+            }
+            itemDrops.push(drop);
+            return drop;
+        }
+        // Start a new wave
+        function startWave() {
+            if (currentWave > maxWaves) {
+                gameCompleted = true;
+                document.getElementById('completionMessage').style.display = 'block';
+                document.getElementById('completionDatasetLevel').textContent = datasetLevel;
+                document.getElementById('completionSamples').textContent = mouseDataset.length;
+                return;
+            }
+            // Calculate zombies for this wave
+            zombiesInWave = 2 + (currentWave - 1) * 2;
+            zombiesRemaining = zombiesInWave;
+            // Show wave alert
+            const waveAlert = document.getElementById('waveAlert');
+            const waveAlertNumber = document.getElementById('waveAlertNumber');
+            waveAlertNumber.textContent = currentWave;
+            waveAlert.style.display = 'block';
+            setTimeout(() => {
+                waveAlert.style.display = 'none';
+            }, 2000);
+            // Update UI
+            document.getElementById('waveNumber').textContent = currentWave;
+            document.getElementById('zombieCountValue').textContent = zombiesRemaining;
+            lastWaveTime = Date.now();
+        }
+        // Spawn a zombie
+        function spawnZombie() {
+            if (zombiesRemaining <= 0) return;
+            const zombieTypes = ['engineer', 'security', 'cargo', 'scientist'];
+            const type = zombieTypes[Math.floor(Math.random() * zombieTypes.length)];
+            const spawnPoint = Math.floor(Math.random() * doors.length);
+            createZombie(type, spawnPoint);
+            zombiesRemaining--;
+            document.getElementById('zombieCountValue').textContent = zombiesRemaining;
+        }
+        // Player shooting - AUTO SHOOT like original
+        function shoot() {
+            const now = Date.now();
+            if (now - lastShotTime < 100) return; // Rate of fire limit
+            // Find nearest zombie to shoot at
+            let nearestZombie = null;
+            let minDistance = Infinity;
+            zombies.forEach(zombie => {
+                const dx = zombie.position.x - player.position.x;
+                const dz = zombie.position.z - player.position.z;
+                const distance = Math.sqrt(dx * dx + dz * dz);
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    nearestZombie = zombie;
+                }
+            });
+            if (nearestZombie) {
+                createProjectile(
+                    player.position.x,
+                    player.position.z,
+                    nearestZombie.position.x,
+                    nearestZombie.position.z
+                );
+                // Record auto-shoot for dataset
+                recordAutoShoot(nearestZombie);
+                lastShotTime = now;
+            }
+        }
+        // Record auto-shoot for dataset
+        function recordAutoShoot(targetZombie) {
+            const now = Date.now();
+            const gameRect = document.getElementById('gameContainer').getBoundingClientRect();
+            // Get crosshair position
+            const crosshair = document.querySelector('.crosshair');
+            const x = parseFloat(crosshair.style.left) || gameRect.width / 2;
+            const y = parseFloat(crosshair.style.top) || gameRect.height / 2;
+            const normalizedX = x / gameRect.width;
+            const normalizedY = y / gameRect.height;
+            const dataPoint = {
+                timestamp: now,
+                type: 'auto_shoot',
+                position: { x: normalizedX, y: normalizedY },
+                gameState: {
+                    playerHealth: playerHealth,
+                    playerPosition: { x: player.position.x, z: player.position.z },
+                    zombiesCount: zombies.length,
+                    wave: currentWave,
+                    datasetLevel: datasetLevel
+                },
+                action: 'auto_shoot',
+                target: {
+                    x: targetZombie.position.x,
+                    z: targetZombie.position.z,
+                    health: targetZombie.health
+                }
+            };
+            mouseDataset.push(dataPoint);
+            addDatasetPoints(2); // Less points for auto-shoot
+        }
+        // Use bomb (right click)
+        function useBomb() {
+            if (bombCooldown > 0) return;
+            // Create explosion at player's position
+            createExplosion(player.position.x, player.position.z, 3, 50);
+            // Set cooldown
+            bombCooldown = bombMaxCooldown;
+            document.getElementById('bombFill').style.width = '0%';
+            document.getElementById('bombTimer').textContent = bombCooldown.toFixed(1) + 's';
+        }
+        // Toggle menu
+        function toggleMenu() {
+            isMenuOpen = !isMenuOpen;
+            document.getElementById('menu').style.display = isMenuOpen ? 'block' : 'none';
+            if (isMenuOpen) {
+                updateMenu();
+            }
+        }
+        // Update menu with current stats
+        function updateMenu() {
+            document.getElementById('menuDatasetLevel').textContent = datasetLevel;
+            document.getElementById('menuDataPoints').textContent = datasetPoints + '/' + pointsToNextLevel;
+            document.getElementById('menuLMB').textContent = lmbCount;
+            document.getElementById('menuRMB').textContent = rmbCount;
+            document.getElementById('menuMovement').textContent = movementSamples;
+            const sessionTime = Math.floor((Date.now() - sessionStartTime) / 1000);
+            document.getElementById('menuSessionTime').textContent = sessionTime + 's';
+        }
+        // Show export panel
+        function showExportPanel() {
+            // Update export stats
+            const exportStats = document.getElementById('exportStats');
+            exportStats.innerHTML = `
+                <div class="stat-row"><div>Total Samples:</div><div>${mouseDataset.length}</div></div>
+                <div class="stat-row"><div>Movement Clicks (LMB):</div><div>${lmbCount}</div></div>
+                <div class="stat-row"><div>Bomb Clicks (RMB):</div><div>${rmbCount}</div></div>
+                <div class="stat-row"><div>Movement Samples:</div><div>${movementSamples}</div></div>
+                <div class="stat-row"><div>Auto-Shots:</div><div>${mouseDataset.filter(d => d.type === 'auto_shoot').length}</div></div>
+                <div class="stat-row"><div>Dataset Level:</div><div>${datasetLevel}</div></div>
+                <div class="stat-row"><div>Session Duration:</div><div>${Math.floor((Date.now() - sessionStartTime) / 1000)}s</div></div>
+                <div class="stat-row"><div>Waves Completed:</div><div>${currentWave - 1}</div></div>
+            `;
+            document.getElementById('exportPanel').style.display = 'block';
+            if (isMenuOpen) toggleMenu();
+            if (gameOver) document.getElementById('gameOver').style.display = 'none';
+            if (gameCompleted) document.getElementById('completionMessage').style.display = 'none';
+        }
+        // Export dataset to Hugging Face compatible format
+        function exportDataset() {
+            if (mouseDataset.length === 0) {
+                alert('No data collected yet! Play the game to collect mouse behavior data.');
+                return;
+            }
+            // Create RL transitions from mouse data
+            const rlTransitions = mouseDataset.map((point, index) => {
+                const nextPoint = mouseDataset[index + 1] || point;
+                return {
+                    state: point.gameState,
+                    action: point.action,
+                    reward: calculateReward(point),
+                    next_state: nextPoint.gameState,
+                    done: index === mouseDataset.length - 1,
+                    timestamp: point.timestamp
+                };
+            });
+            // Create metadata YAML for Hugging Face
+            const metadataYaml = `---
+license: mit
+task_categories:
+  - reinforcement-learning
+  - human-computer-interaction
+task_ids:
+  - mouse-behavior-modeling
+  - rl-from-demonstration
+language:
+  - en
+size_categories:
+  - ${mouseDataset.length < 1000 ? 'n<1K' : mouseDataset.length < 10000 ? '1K<n<10K' : '10K<n<100K'}
+tags:
+  - mouse-input
+  - human-in-the-loop
+  - reinforcement-learning
+  - webxos-2026
+  - space-zombies-rl
+pretty_name: "Space Zombies RL Mouse Behavior Dataset"
+dataset_info:
+  features:
+    - name: state
+      dtype:
+        playerHealth: float32
+        playerPosition:
+          x: float32
+          z: float32
+        zombiesCount: int32
+        wave: int32
+        datasetLevel: int32
+    - name: action
+      dtype: string
+    - name: reward
+      dtype: float32
+    - name: next_state
+      dtype:
+        playerHealth: float32
+        playerPosition:
+          x: float32
+          z: float32
+        zombiesCount: int32
+        wave: int32
+        datasetLevel: int32
+    - name: done
+      dtype: bool
+    - name: timestamp
+      dtype: int64
+  splits:
+    train:
+      num_examples: ${Math.floor(mouseDataset.length * 0.8)}
+    test:
+      num_examples: ${Math.floor(mouseDataset.length * 0.2)}
+---
+# Space Zombies RL Mouse Behavior Dataset
+This dataset contains mouse interaction data collected from the "Space Zombies RL" game, designed for reinforcement learning research on human input patterns.
+## Dataset Description
+- **Total Samples**: ${mouseDataset.length}
+- **Collection Date**: ${new Date().toISOString().split('T')[0]}
+- **Game Version**: Space Zombies RL v1.0 by webXOS 2026
+- **Purpose**: RL training from human demonstrations, mouse behavior modeling, adaptive interface research
+## Usage
+\`\`\`python
+from datasets import load_dataset
+dataset = load_dataset("your-username/space-zombies-rl")
+\`\`\`
+## Citation
+If you use this dataset in your research, please cite:
+\`\`\`
+@dataset{space_zombies_rl_2026,
+  title={Space Zombies RL Mouse Behavior Dataset},
+  author={webXOS Research},
+  year={2026},
+  publisher={Hugging Face}
+}
+\`\`\`
+`;
+            // Create README
+            const readmeText = `# Space Zombies RL Dataset
+## Overview
+Mouse behavior dataset collected from the Space Zombies RL game. Contains ${mouseDataset.length} samples of mouse movements, clicks, and game state transitions.
+## Files
+- \`mouse_behavior.json\`: Raw mouse interaction data
+- \`rl_transitions.csv\`: State-action-reward-next_state tuples for RL training
+- \`metadata.yaml\`: Hugging Face dataset card
+- \`README.md\`: This file
+## Collection Parameters
+- Sampling Rate: ${samplingInterval}ms for movement
+- Game: Space Zombies RL (webXOS 2026)
+- Controls: Click to move, auto-aim shooting, right-click for bomb
+- Waves Completed: ${currentWave - 1}
+- Dataset Level: ${datasetLevel}
+## Research Applications
+- Reinforcement Learning from Human Demonstrations
+- Mouse Behavior Modeling
+- Adaptive Interface Design
+- Human-in-the-loop RL
+- Neurorehabilitation Research
+## License
+MIT License - See metadata.yaml for details
+## Contact
+webXOS Research 2026
+`;
+            // Create CSV for transitions
+            let csvContent = "timestamp,playerHealth,playerX,playerZ,zombiesCount,wave,datasetLevel,action,reward,nextHealth,nextX,nextZ,nextZombiesCount,nextWave,nextDatasetLevel,done\n";
+            rlTransitions.forEach(transition => {
+                const state = transition.state;
+                const nextState = transition.next_state;
+                csvContent += `${transition.timestamp},${state.playerHealth},${state.playerPosition.x},${state.playerPosition.z},${state.zombiesCount},${state.wave},${state.datasetLevel},${transition.action},${transition.reward},${nextState.playerHealth},${nextState.playerPosition.x},${nextState.playerPosition.z},${nextState.zombiesCount},${nextState.wave},${nextState.datasetLevel},${transition.done}\n`;
+            });
+            // Create ZIP file
+            const zip = new JSZip();
+            zip.file("mouse_behavior.json", JSON.stringify(mouseDataset, null, 2));
+            zip.file("rl_transitions.csv", csvContent);
+            zip.file("metadata.yaml", metadataYaml);
+            zip.file("README.md", readmeText);
+            // Generate and download ZIP
+            zip.generateAsync({type: "blob", compression: "DEFLATE"})
+                .then(function(blob) {
+                    // Create download link
+                    const a = document.createElement('a');
+                    const url = URL.createObjectURL(blob);
+                    a.href = url;
+                    a.download = `space_zombies_rl_dataset_${Date.now()}.zip`;
+                    document.body.appendChild(a);
+                    a.click();
+                    // Clean up
+                    setTimeout(() => {
+                        document.body.removeChild(a);
+                        URL.revokeObjectURL(url);
+                        showNotification('Dataset exported successfully!', '#00ff00');
+                    }, 100);
+                })
+                .catch(error => {
+                    console.error('Error creating ZIP:', error);
+                    showNotification('Export failed!', '#ff0000');
+                });
+        }
+        // Calculate reward for RL transition
+        function calculateReward(dataPoint) {
+            let reward = 0;
+            // Positive rewards for actions
+            if (dataPoint.type === 'move_click') reward += 0.05; // Movement
+            if (dataPoint.type === 'rmb') reward += 0.1; // Bomb
+            if (dataPoint.type === 'auto_shoot') reward += 0.02; // Auto-shoot
+            // Negative rewards for low health
+            if (dataPoint.gameState.playerHealth < 30) reward -= 0.03;
+            // Reward for progress
+            reward += dataPoint.gameState.datasetLevel * 0.01;
+            return parseFloat(reward.toFixed(3));
+        }
+        // Check for collisions
+        function checkCollisions() {
+            // Projectile vs Zombie collisions
+            for (let i = projectiles.length - 1; i >= 0; i--) {
+                const projectile = projectiles[i];
+                for (let j = zombies.length - 1; j >= 0; j--) {
+                    const zombie = zombies[j];
+                    const dx = projectile.position.x - zombie.position.x;
+                    const dz = projectile.position.z - zombie.position.z;
+                    const distance = Math.sqrt(dx * dx + dz * dz);
+                    if (distance < 0.5) {
+                        // Damage zombie
+                        zombie.health -= projectile.damage;
+                        // Remove projectile
+                        scene.remove(projectile);
+                        projectiles.splice(i, 1);
+                        // Check if zombie is dead
+                        if (zombie.health <= 0) {
+                            // Create item drops
+                            const dropType = Math.random() < 0.5 ? 'exp' : 'health';
+                            createItemDrop(zombie.position.x, zombie.position.z, dropType);
+                            // Add dataset points for killing zombie
+                            addDatasetPoints(15);
+                            // Remove zombie
+                            scene.remove(zombie);
+                            zombies.splice(j, 1);
+                            zombiesKilled++;
+                            // Check if wave is complete
+                            if (zombies.length === 0 && zombiesRemaining === 0) {
+                                currentWave++;
+                                if (currentWave <= maxWaves) {
+                                    setTimeout(() => startWave(), 2000);
+                                }
+                            }
+                        }
+                        break;
+                    }
+                }
+                // Remove projectiles that go too far
+                if (Math.abs(projectile.position.x) > 30 || Math.abs(projectile.position.z) > 30) {
+                    scene.remove(projectile);
+                    projectiles.splice(i, 1);
+                }
+            }
+            // Explosion vs Zombie collisions
+            for (let i = explosions.length - 1; i >= 0; i--) {
+                const explosion = explosions[i];
+                for (let j = zombies.length - 1; j >= 0; j--) {
+                    const zombie = zombies[j];
+                    const dx = explosion.x - zombie.position.x;
+                    const dz = explosion.z - zombie.position.z;
+                    const distance = Math.sqrt(dx * dx + dz * dz);
+                    if (distance < explosion.radius) {
+                        // Damage zombie
+                        zombie.health -= explosion.damage;
+                        // Check if zombie is dead
+                        if (zombie.health <= 0) {
+                            // Create item drops
+                            const dropType = Math.random() < 0.5 ? 'exp' : 'health';
+                            createItemDrop(zombie.position.x, zombie.position.z, dropType);
+                            // Add dataset points for killing zombie with bomb
+                            addDatasetPoints(25);
+                            // Remove zombie
+                            scene.remove(zombie);
+                            zombies.splice(j, 1);
+                            zombiesKilled++;
+                            // Check if wave is complete
+                            if (zombies.length === 0 && zombiesRemaining === 0) {
+                                currentWave++;
+                                if (currentWave <= maxWaves) {
+                                    setTimeout(() => startWave(), 2000);
+                                }
+                            }
+                        }
+                    }
+                }
+                // Update explosion
+                explosion.time += 0.016;
+                if (explosion.mesh) {
+                    explosion.mesh.material.opacity = 0.7 * (1 - explosion.time / explosion.maxTime);
+                }
+                // Remove expired explosions
+                if (explosion.time >= explosion.maxTime) {
+                    if (explosion.mesh) {
+                        scene.remove(explosion.mesh);
+                    }
+                    explosions.splice(i, 1);
+                }
+            }
+            // Player vs Item collisions
+            for (let i = itemDrops.length - 1; i >= 0; i--) {
+                const drop = itemDrops[i];
+                const dx = player.position.x - drop.x;
+                const dz = player.position.z - drop.z;
+                const distance = Math.sqrt(dx * dx + dz * dz);
+                if (distance < 0.8) {
+                    if (drop.type === 'exp') {
+                        addDatasetPoints(20); // XP orbs give dataset points
+                    } else if (drop.type === 'health') {
+                        playerHealth = Math.min(playerMaxHealth, playerHealth + 30);
+                    }
+                    // Remove drop
+                    scene.remove(drop.mesh);
+                    itemDrops.splice(i, 1);
+                    // Update UI
+                    updateUI();
+                }
+                // Animate item drops
+                if (drop.mesh) {
+                    drop.time += 0.05;
+                    drop.mesh.position.y = 0.5 + Math.sin(drop.time) * 0.2;
+                    if (drop.mesh.rotation) {
+                        drop.mesh.rotation.y += 0.02;
+                    }
+                }
+            }
+            // Zombie vs Player collisions
+            for (let i = zombies.length - 1; i >= 0; i--) {
+                const zombie = zombies[i];
+                const dx = player.position.x - zombie.position.x;
+                const dz = player.position.z - zombie.position.z;
+                const distance = Math.sqrt(dx * dx + dz * dz);
+                if (distance < 0.8) {
+                    playerHealth -= zombie.damage;
+                    if (playerHealth <= 0) {
+                        gameOver = true;
+                        document.getElementById('gameOver').style.display = 'block';
+                        document.getElementById('finalWave').textContent = currentWave;
+                        document.getElementById('finalDatasetLevel').textContent = datasetLevel;
+                        document.getElementById('finalDataPoints').textContent = mouseDataset.length;
+                    }
+                    updateUI();
+                }
+            }
+        }
+        // Update UI elements
+        function updateUI() {
+            const healthPercent = (playerHealth / playerMaxHealth) * 100;
+            document.getElementById('healthFill').style.width = healthPercent + '%';
+            document.getElementById('healthText').textContent = Math.floor(healthPercent) + '%';
+            // Update bomb cooldown
+            if (bombCooldown > 0) {
+                const cooldownPercent = (bombCooldown / bombMaxCooldown) * 100;
+                document.getElementById('bombFill').style.width = (100 - cooldownPercent) + '%';
+                document.getElementById('bombTimer').textContent = bombCooldown.toFixed(1) + 's';
+            } else {
+                document.getElementById('bombFill').style.width = '100%';
+                document.getElementById('bombTimer').textContent = 'READY';
+            }
+        }
+        // Restart the game
+        function restartGame() {
+            // Reset game state
+            playerHealth = 100;
+            playerMaxHealth = 100;
+            datasetLevel = 1;
+            datasetPoints = 0;
+            pointsToNextLevel = 100;
+            playerSpeed = 0.1;
+            playerDamage = 10;
+            currentWave = 1;
+            zombiesInWave = 0;
+            zombiesRemaining = 0;
+            zombiesKilled = 0;
+            gameOver = false;
+            gameCompleted = false;
+            bombCooldown = 0;
+            moveToTarget = null;
+            isMoving = false;
+            autoShoot = true;
+            // Reset dataset collection
+            mouseDataset = [];
+            sessionStartTime = Date.now();
+            lmbCount = 0;
+            rmbCount = 0;
+            movementSamples = 0;
+            lastMouseMoveTime = 0;
+            lastMousePosition = { x: 0, y: 0 };
+            // Clear all game objects
+            while (zombies.length > 0) {
+                const zombie = zombies.pop();
+                scene.remove(zombie);
+            }
+            while (projectiles.length > 0) {
+                const projectile = projectiles.pop();
+                scene.remove(projectile);
+            }
+            while (itemDrops.length > 0) {
+                const drop = itemDrops.pop();
+                if (drop.mesh) scene.remove(drop.mesh);
+            }
+            while (explosions.length > 0) {
+                const explosion = explosions.pop();
+                if (explosion.mesh) scene.remove(explosion.mesh);
+            }
+            // Reset player position
+            player.position.set(0, 0, 0);
+            // Update UI
+            updateUI();
+            updateDatasetUI();
+            // Update data stats
+            document.getElementById('lmbCount').textContent = lmbCount;
+            document.getElementById('rmbCount').textContent = rmbCount;
+            document.getElementById('moveCount').textContent = movementSamples;
+            document.getElementById('sessionTime').textContent = 0;
+            // Hide game over/completion messages
+            document.getElementById('gameOver').style.display = 'none';
+            document.getElementById('completionMessage').style.display = 'none';
+            document.getElementById('menu').style.display = 'none';
+            document.getElementById('exportPanel').style.display = 'none';
+            isMenuOpen = false;
+            // Start first wave
+            startWave();
+        }
+        // Game loop
+        function animate() {
+            if (gameOver || gameCompleted) {
+                requestAnimationFrame(animate);
+                return;
+            }
+            const now = Date.now();
+            const deltaTime = (now - lastSpawnTime) / 1000;
+            // Handle player movement
+            if (isMoving && moveToTarget) {
+                const dx = moveToTarget.x - player.position.x;
+                const dz = moveToTarget.z - player.position.z;
+                const distance = Math.sqrt(dx * dx + dz * dz);
+                if (distance > 0.2) {
+                    // Move towards target
+                    player.position.x += (dx / distance) * playerSpeed;
+                    player.position.z += (dz / distance) * playerSpeed;
+                    // Rotate player to face movement direction
+                    const angle = Math.atan2(dx, dz);
+                    player.rotation.y = angle;
+                } else {
+                    // Reached target
+                    isMoving = false;
+                    moveToTarget = null;
+                }
+            }
+            // Keep player within bounds
+            player.position.x = Math.max(-24, Math.min(24, player.position.x));
+            player.position.z = Math.max(-24, Math.min(24, player.position.z));
+            // Handle shooting (always auto-shoot like original)
+            shoot();
+            // Update bomb cooldown
+            if (bombCooldown > 0) {
+                bombCooldown -= deltaTime;
+                if (bombCooldown < 0) bombCooldown = 0;
+            }
+            // Spawn zombies
+            if (zombiesRemaining > 0 && now - lastSpawnTime > 1000) {
+                spawnZombie();
+                lastSpawnTime = now;
+            }
+            // Update zombies with enhanced AI and movement
+            zombies.forEach(zombie => {
+                // Move towards player with occasional direction changes
+                const dx = player.position.x - zombie.position.x;
+                const dz = player.position.z - zombie.position.z;
+                const distance = Math.sqrt(dx * dx + dz * dz);
+                if (distance > 0.5) {
+                    const currentTime = Date.now();
+                    if (currentTime - zombie.lastDirectionChange > 1000) {
+                        zombie.lastDirectionChange = currentTime;
+                    }
+                    // Wobble effect for realistic zombie movement
+                    const wobble = Math.sin(currentTime * 0.01 + zombie.wobbleOffset) * 0.1;
+                    const angle = Math.atan2(dx, dz) + wobble;
+                    zombie.position.x += Math.sin(angle) * zombie.speed;
+                    zombie.position.z += Math.cos(angle) * zombie.speed;
+                    // Rotate to face movement direction
+                    zombie.rotation.y = angle;
+                }
+            });
+            // Update projectiles
+            projectiles.forEach(projectile => {
+                projectile.position.x += projectile.direction.x * projectile.speed;
+                projectile.position.z += projectile.direction.z * projectile.speed;
+            });
+            // Auto-aim at nearest zombie if not moving (like original)
+            if (!isMoving) {
+                let nearestZombie = null;
+                let minDistance = Infinity;
+                zombies.forEach(zombie => {
+                    const dx = zombie.position.x - player.position.x;
+                    const dz = zombie.position.z - player.position.z;
+                    const distance = Math.sqrt(dx * dx + dz * dz);
+                    if (distance < minDistance) {
+                        minDistance = distance;
+                        nearestZombie = zombie;
+                    }
+                });
+                if (nearestZombie) {
+                    const dx = nearestZombie.position.x - player.position.x;
+                    const dz = nearestZombie.position.z - player.position.z;
+                    const angle = Math.atan2(dx, dz);
+                    player.rotation.y = angle;
+                }
+            }
+            // Check collisions
+            checkCollisions();
+            // Update UI
+            updateUI();
+            // Render
+            renderer.render(scene, camera);
+            requestAnimationFrame(animate);
+        }
+        // Start the game
+        init();
+    </script>
+</body>
+</html>