Datasets:

webxos
/

ghosthunter-RL

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>GHOST HUNTER · DATA SET GYM</title>
	<!-- 8-bit font -->
	<link href="https://fonts.googleapis.com/css2?family=Press+Start+2P&display=swap" rel="stylesheet">
	<style>
	body {
	margin: 0;
	overflow: hidden;
	font-family: 'Press Start 2P', 'Courier New', monospace;
	background-color: black;
	image-rendering: pixelated;
	image-rendering: crisp-edges;
	}
	#info {
	position: absolute;
	top: 10px;
	left: 10px;
	color: #8af0ff;
	text-shadow: 2px 2px 0 #004466;
	font-size: 0.7rem;
	z-index: 100;
	background: #001c28;
	padding: 6px 10px;
	border: 2px solid #3ecfcf;
	outline: 2px solid #005f7a;
	letter-spacing: 0.5px;
	pointer-events: none;
	box-shadow: 4px 4px 0 #001018;
	}
	#timer-round {
	position: absolute;
	top: 10px;
	left: 50%;
	transform: translateX(-50%);
	color: #ffffaa;
	font-size: 0.9rem;
	text-shadow: 2px 2px 0 #886600;
	background: #1a2a1a;
	padding: 6px 12px;
	border: 2px solid #aaff55;
	outline: 2px solid #3f9f3f;
	z-index: 100;
	letter-spacing: 0.5px;
	white-space: nowrap;
	box-shadow: 4px 4px 0 #0a1f0a;
	}
	#ghost-count {
	position: absolute;
	top: 10px;
	right: 10px;
	color: #ffaa88;
	font-size: 0.9rem;
	text-shadow: 2px 2px 0 #882200;
	background: #2a1010;
	padding: 6px 12px;
	border: 2px solid #ff8866;
	outline: 2px solid #aa4444;
	z-index: 100;
	letter-spacing: 0.5px;
	box-shadow: 4px 4px 0 #200808;
	}
	#crosshair {
	position: absolute;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	width: 18px;
	height: 18px;
	border: 3px solid #aaf0ff;
	box-shadow: 0 0 0 2px #004466, 2px 2px 0 #003344;
	pointer-events: none;
	z-index: 200;
	opacity: 0.9;
	}
	#crosshair::after {
	content: '';
	position: absolute;
	top: 50%;
	left: 50%;
	width: 5px;
	height: 5px;
	background: #aaf0ff;
	transform: translate(-50%, -50%);
	box-shadow: 1px 1px 0 #004466;
	}
	#instructions {
	position: absolute;
	bottom: 15px;
	left: 50%;
	transform: translateX(-50%);
	color: #b5ffff;
	font-size: 0.55rem;
	text-shadow: 2px 2px 0 #006688;
	background: #0a1c28;
	padding: 8px 14px;
	border: 2px solid #3ecfcf;
	outline: 2px solid #006688;
	z-index: 100;
	letter-spacing: 0.5px;
	white-space: nowrap;
	box-shadow: 4px 4px 0 #021018;
	animation: pulse 2s step-end infinite;
	}
	@keyframes pulse {
	0% { opacity: 1; background: #0a1c28; }
	50% { opacity: 0.9; background: #0e2430; border-color: #5fe0e0; }
	100% { opacity: 1; background: #0a1c28; }
	}
	#victory {
	position: absolute;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	color: #ffffaa;
	font-size: 1.8rem;
	text-shadow: 3px 3px 0 #448800;
	background: #1a3f1a;
	padding: 20px 30px;
	border: 4px solid #aaff55;
	outline: 3px solid #2f9f2f;
	z-index: 300;
	letter-spacing: 2px;
	display: none;
	text-align: center;
	line-height: 1.5;
	box-shadow: 10px 10px 0 #0a2a0a;
	}
	#victory span {
	font-size: 1.0rem;
	display: block;
	margin-top: 15px;
	color: #aaf0ff;
	text-shadow: 2px 2px 0 #004466;
	}
	.scanline {
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: repeating-linear-gradient(0deg, rgba(0,255,255,0.03) 0px, rgba(0,0,0,0.2) 2px, transparent 3px);
	pointer-events: none;
	z-index: 300;
	opacity: 0.3;
	}
	.hit-effect {
	position: absolute;
	width: 20px;
	height: 20px;
	background: radial-gradient(circle, #ffffaa, #ff8800);
	border-radius: 50%;
	pointer-events: none;
	z-index: 400;
	transform: translate(-50%, -50%);
	animation: hitPing 0.2s ease-out forwards;
	}
	@keyframes hitPing {
	0% { opacity: 1; transform: translate(-50%, -50%) scale(0.5); }
	100% { opacity: 0; transform: translate(-50%, -50%) scale(2); }
	}
	/* small flash for hit (kept for screen feedback) */
	.kill-flash {
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	height: 100%;
	background: rgba(255,220,150,0.1);
	pointer-events: none;
	z-index: 500;
	animation: flashFade 0.1s ease-out;
	}
	@keyframes flashFade {
	0% { opacity: 0.4; }
	100% { opacity: 0; }
	}
	#lock-hint {
	position: absolute;
	bottom: 70px;
	left: 50%;
	transform: translateX(-50%);
	color: #b0b0ff;
	font-size: 0.45rem;
	background: #000c1a;
	padding: 4px 8px;
	border: 1px solid #3399ff;
	z-index: 150;
	white-space: nowrap;
	}
	/* Dataset UI */
	#dataset-panel {
	position: absolute;
	bottom: 120px;
	right: 10px;
	background: #0a1a2a;
	border: 2px solid #ffaa55;
	outline: 2px solid #aa5500;
	padding: 8px 12px;
	color: #ffdd99;
	font-size: 0.6rem;
	z-index: 250;
	box-shadow: 4px 4px 0 #031010;
	display: flex;
	flex-direction: column;
	gap: 6px;
	min-width: 160px;
	}
	#dataset-panel button {
	font-family: 'Press Start 2P', monospace;
	background: #2a3f3f;
	border: 2px solid #88aaff;
	color: #ddeeff;
	padding: 6px 8px;
	font-size: 0.55rem;
	cursor: pointer;
	box-shadow: 2px 2px 0 #001122;
	}
	#dataset-panel button:hover {
	background: #3f5f5f;
	}
	#capture-count {
	color: #aaffaa;
	text-align: right;
	}
	#export-status {
	font-size: 0.45rem;
	color: #99ccff;
	word-break: break-all;
	max-width: 180px;
	}
	</style>
	<script type="importmap">
	{
	"imports": {
	"three": "https://unpkg.com/three@0.128.0/build/three.module.js",
	"three/addons/": "https://unpkg.com/three@0.128.0/examples/jsm/",
	"jszip": "https://cdn.skypack.dev/jszip@3.10.1"
	}
	}
	</script>
	</head>
	<body>
	<div id="info">>> GHOST HUNTER // DATASET GYM // by webXOS </div>
	<div id="timer-round">TIME 00:00 ROUND 1/10</div>
	<div id="ghost-count">GHOSTS 0</div>
	<div id="crosshair"></div>
	<div id="instructions">[CLICK TO LOCK] W/A/S/D MOVE \| HOLD LMB AUTO (tight spread) \| KILL = SCREENSHOT</div>
	<div id="lock-hint">↖ CLICK GAME AREA TO LOCK / ESC TO UNLOCK</div>
	<div id="victory">VICTORY<span id="final-time"></span></div>
	<div class="scanline"></div>

	<!-- Dataset capture & export panel -->
	<div id="dataset-panel">
	<div style="display: flex; justify-content: space-between;">
	<span>📸 CAPTURES</span>
	<span id="capture-count">0</span>
	</div>
	<button id="export-dataset">💾 EXPORT DATASET (ZIP)</button>
	<div id="export-status"></div>
	</div>

	<script type="module">
	import * as THREE from 'three';
	import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
	import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
	import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
	import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
	import JSZip from 'jszip';

	// --- SCENE SETUP ---
	const scene = new THREE.Scene();
	scene.background = new THREE.Color(0x050510);
	const camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerHeight, 0.1, 1000);
	camera.position.set(0, 1.8, 0);
	const renderer = new THREE.WebGLRenderer({ antialias: false, powerPreference: "high-performance", preserveDrawingBuffer: true }); // preserveDrawingBuffer for captures
	renderer.setSize(window.innerWidth, window.innerHeight);
	renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1.0));
	renderer.toneMapping = THREE.ReinhardToneMapping;
	document.body.appendChild(renderer.domElement);

	// --- POST PROCESSING ---
	const renderScene = new RenderPass(scene, camera);
	const bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 1.0, 0.3, 0.6);
	bloomPass.threshold = 0.1;
	bloomPass.strength = 1.3;
	bloomPass.radius = 0.7;
	const composer = new EffectComposer(renderer);
	composer.addPass(renderScene);
	composer.addPass(bloomPass);

	// --- CONTROLS ---
	const controls = new PointerLockControls(camera, document.body);
	scene.add(controls.getObject());

	renderer.domElement.addEventListener('click', () => {
	if (gameActive) controls.lock();
	});

	// --- MOVEMENT (A left, D right) ---
	const keyState = { w: false, a: false, s: false, d: false };
	document.addEventListener('keydown', (e) => {
	if (!gameActive) return;
	switch(e.code) {
	case 'KeyW': keyState.w = true; e.preventDefault(); break;
	case 'KeyA': keyState.a = true; e.preventDefault(); break;
	case 'KeyS': keyState.s = true; e.preventDefault(); break;
	case 'KeyD': keyState.d = true; e.preventDefault(); break;
	default: break;
	}
	});
	document.addEventListener('keyup', (e) => {
	switch(e.code) {
	case 'KeyW': keyState.w = false; e.preventDefault(); break;
	case 'KeyA': keyState.a = false; e.preventDefault(); break;
	case 'KeyS': keyState.s = false; e.preventDefault(); break;
	case 'KeyD': keyState.d = false; e.preventDefault(); break;
	default: break;
	}
	});

	const velocity = new THREE.Vector3();
	const moveSpeed = 0.06;
	const damping = 0.92;
	const boundary = 20;

	// --- WORLD POINTS (same as before) ---
	const patterns = [
	[[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1],[1,1,1,1,1]],
	[[0,0,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,0,0]],
	[[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0],[0,0,1,0,0]]
	];
	const cellSize = 1.8;
	const jitter = 0.2;
	const positions = [];
	const colors = [];
	function addPoint(px, py, pz) {
	positions.push(px, py, pz);
	colors.push(0.5+0.3Math.random(), 0.7+0.3Math.random(), 1.0);
	}
	const floorMin = -boundary, floorMax = boundary;
	const cellsX = Math.floor((floorMax - floorMin) / cellSize);
	const cellsZ = cellsX;
	for (let i = 0; i < cellsX; i++) {
	for (let j = 0; j < cellsZ; j++) {
	const wx = floorMin + i * cellSize + cellSize/2;
	const wz = floorMin + j * cellSize + cellSize/2;
	const patIdx = (i + j) % patterns.length;
	const pattern = patterns[patIdx];
	for (let r = 0; r < 5; r++) {
	for (let c = 0; c < 5; c++) {
	if (pattern[r][c] === 1) {
	const offsetX = (c/4-0.5)cellSize0.8 + (Math.random()-0.5)*jitter;
	const offsetZ = (r/4-0.5)cellSize0.8 + (Math.random()-0.5)*jitter;
	const offsetY = (Math.random()-0.5)*0.15;
	addPoint(wx+offsetX, 0+offsetY, wz+offsetZ);
	}
	}
	}
	}
	}
	for (let s = -1; s <= 1; s+=2) {
	for (let z = -boundary; z <= boundary; z+= cellSize*1.5) {
	for (let y = 1; y < 10; y+= cellSize*0.9) {
	addPoint(s*boundary, y, z);
	}
	}
	for (let x = -boundary; x <= boundary; x+= cellSize*1.5) {
	for (let y = 1; y < 10; y+= cellSize*0.9) {
	addPoint(x, y, s*boundary);
	}
	}
	}
	const worldGeometry = new THREE.BufferGeometry();
	worldGeometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
	worldGeometry.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
	const worldMaterial = new THREE.PointsMaterial({
	size: 0.18,
	vertexColors: true,
	blending: THREE.AdditiveBlending,
	depthWrite: false,
	transparent: true,
	opacity: 0.8,
	sizeAttenuation: true
	});
	const worldPoints = new THREE.Points(worldGeometry, worldMaterial);
	scene.add(worldPoints);

	// --- GAME STATE ---
	let gameActive = true;
	let round = 1;
	const maxRounds = 10;
	let ghosts = [];
	let enemyProjectiles = [];
	let explosions = []; // for 3D death effect
	let elapsedSeconds = 0;

	const timerRoundDiv = document.getElementById('timer-round');
	const ghostCountDiv = document.getElementById('ghost-count');
	const victoryDiv = document.getElementById('victory');
	const finalTimeSpan = document.getElementById('final-time');

	// Weapon state: LMB auto-fire only (no RMB)
	let lmbPressed = false;
	let lastLMBShot = 0;
	const LMB_COOLDOWN = 0.12; // auto-fire rate
	const SHOTGUN_PELLETS = 3; // fewer pellets, tighter spread for precision
	const SPREAD_ANGLE = 0.03; // very tight spread (almost precise)

	// --- DATASET CAPTURE ---
	let captures = []; // each: { blob, metadata }
	let captureIndex = 0;
	const captureCountSpan = document.getElementById('capture-count');
	const exportBtn = document.getElementById('export-dataset');
	const exportStatus = document.getElementById('export-status');

	function updateCaptureUI() {
	captureCountSpan.innerText = captures.length;
	}

	// Capture canvas as PNG blob with current metadata
	function captureCurrentFrame(killCount) {
	// Use renderer to get a data URL (preserveDrawingBuffer must be true)
	renderer.render(scene, camera); // ensure latest frame (composer already renders, but we can force)
	// Use toBlob on the canvas element
	renderer.domElement.toBlob((blob) => {
	if (!blob) return;
	const metadata = {
	index: captureIndex++,
	timestamp: performance.now(),
	round: round,
	ghostsRemaining: ghosts.length,
	killsThisShot: killCount \|\| 0,
	playerPos: {
	x: controls.getObject().position.x,
	z: controls.getObject().position.z
	},
	description: `Kill shot at round ${round}, ${ghosts.length} ghosts remain`
	};
	captures.push({ blob, metadata });
	updateCaptureUI();
	}, 'image/png');
	}

	// --- IMPROVED GHOST EXPLOSION (3D particle burst) ---
	function createGhostExplosion(position) {
	const count = 20 + Math.floor(Math.random() * 20);
	const positions = [];
	const colors = [];
	const velocities = [];
	for (let i = 0; i < count; i++) {
	// random direction
	const vel = new THREE.Vector3(
	(Math.random() - 0.5) * 0.5,
	(Math.random() - 0.5) * 0.5,
	(Math.random() - 0.5) * 0.5
	).normalize().multiplyScalar(0.08 + Math.random() * 0.1);
	velocities.push(vel);
	positions.push(0, 0, 0); // relative to center
	colors.push(1.0, 0.8 + Math.random()0.2, 0.3 + Math.random()0.3);
	}
	const geom = new THREE.BufferGeometry();
	geom.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
	geom.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
	const mat = new THREE.PointsMaterial({
	size: 0.25,
	vertexColors: true,
	blending: THREE.AdditiveBlending,
	depthWrite: false,
	transparent: true,
	opacity: 1.0,
	sizeAttenuation: true
	});
	const points = new THREE.Points(geom, mat);
	points.position.copy(position);
	scene.add(points);
	explosions.push({
	mesh: points,
	velocities: velocities,
	life: 1.0, // seconds
	age: 0
	});
	}

	// --- HITSCAN FUNCTION (modified to capture only on kill) ---
	function firePrecisionShot() {
	const origin = camera.position.clone();
	const baseDir = new THREE.Vector3();
	camera.getWorldDirection(baseDir);

	// compute local axes perpendicular to view direction
	const right = new THREE.Vector3().crossVectors(baseDir, camera.up).normalize();
	const up = new THREE.Vector3().crossVectors(right, baseDir).normalize();

	let killedAny = false;
	let killCount = 0;

	for (let i = 0; i < SHOTGUN_PELLETS; i++) {
	// very tight spread
	const spreadX = (Math.random() - 0.5) * SPREAD_ANGLE * 2;
	const spreadY = (Math.random() - 0.5) * SPREAD_ANGLE * 2;

	const dir = baseDir.clone()
	.addScaledVector(right, spreadX)
	.addScaledVector(up, spreadY)
	.normalize();

	let bestHit = null;
	let bestT = Infinity;

	for (let j = 0; j < ghosts.length; j++) {
	const ghost = ghosts[j];
	const toGhost = new THREE.Vector3().subVectors(ghost.position, origin);

	const t = toGhost.dot(dir);
	if (t < 0) continue;
	if (t > 45) continue;

	const toGhostLenSq = toGhost.lengthSq();
	const perpDistSq = Math.max(0, toGhostLenSq - t * t);
	const ghostRadius = ghost.userData.hitRadius \|\| 2.5;

	if (perpDistSq < ghostRadius * ghostRadius) {
	if (t < bestT) {
	bestT = t;
	bestHit = ghost;
	}
	}
	}

	if (bestHit) {
	// Remove ghost
	scene.remove(bestHit);
	const idx = ghosts.indexOf(bestHit);
	if (idx !== -1) ghosts.splice(idx, 1);

	// Create explosion effect at ghost position
	createGhostExplosion(bestHit.position.clone());

	// Show screen hit effect (2D)
	showHitEffect(bestHit.position.clone());

	killedAny = true;
	killCount++;
	}
	}

	// Screen flash for any kill
	if (killedAny) {
	const flash = document.createElement('div');
	flash.className = 'kill-flash';
	document.body.appendChild(flash);
	setTimeout(() => flash.remove(), 100);

	// --- CAPTURE ONLY ON KILL ---
	captureCurrentFrame(killCount);
	}
	}

	// --- VISUAL EFFECTS (2D screen hit marker) ---
	function showHitEffect(worldPos) {
	const ndc = worldPos.clone().project(camera);
	if (Math.abs(ndc.x) <= 1 && Math.abs(ndc.y) <= 1 && ndc.z <= 1) {
	const screenX = (ndc.x * 0.5 + 0.5) * window.innerWidth;
	const screenY = (-ndc.y * 0.5 + 0.5) * window.innerHeight;

	const div = document.createElement('div');
	div.className = 'hit-effect';
	div.style.left = screenX + 'px';
	div.style.top = screenY + 'px';
	document.body.appendChild(div);
	setTimeout(() => div.remove(), 200);
	}
	}

	// --- MOUSE EVENTS: only LMB auto-fire, RMB removed ---
	document.addEventListener('mousedown', (e) => {
	if (!controls.isLocked \|\| !gameActive) return;
	e.preventDefault();
	if (e.button === 0) {
	lmbPressed = true;
	}
	// ignore button 2 (RMB)
	});

	document.addEventListener('mouseup', (e) => {
	if (e.button === 0) {
	lmbPressed = false;
	}
	});

	document.addEventListener('contextmenu', (e) => e.preventDefault());

	// --- GHOST CREATION (same) ---
	function createGhost(pos, roundNum) {
	const pointCount = 60 + Math.floor(Math.random() * 30);
	const positions = [];
	const colors = [];
	const visualRadius = 1.2 + roundNum * 0.2;
	const hitRadius = visualRadius * 2.0;
	for (let i = 0; i < pointCount; i++) {
	const r = visualRadius * Math.pow(Math.random(), 0.7);
	const theta = Math.random() * Math.PI * 2;
	const phi = Math.acos(2 * Math.random() - 1);
	positions.push(
	r * Math.sin(phi) * Math.cos(theta),
	r * Math.sin(phi) * Math.sin(theta),
	r * Math.cos(phi)
	);
	colors.push(0.7+0.3Math.random(), 0.8+0.2Math.random(), 1.0);
	}
	const geom = new THREE.BufferGeometry();
	geom.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
	geom.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
	const mat = new THREE.PointsMaterial({
	size: 0.2,
	vertexColors: true,
	blending: THREE.AdditiveBlending,
	depthWrite: false,
	sizeAttenuation: true,
	transparent: true,
	opacity: 0.95
	});
	const points = new THREE.Points(geom, mat);
	points.position.copy(pos);
	points.userData = {
	visualRadius: visualRadius,
	hitRadius: hitRadius,
	shootInterval: 1.0 + Math.random() * 1.2,
	lastShot: performance.now() / 1000,
	baseY: pos.y,
	timeOffset: Math.random() * 100,
	rotSpeed: 0.002 + Math.random() * 0.004
	};
	scene.add(points);
	return points;
	}

	function spawnRound(roundNum) {
	const count = roundNum * 2;
	for (let i = 0; i < count; i++) {
	let x, z;
	do {
	x = (Math.random() - 0.5) * 30;
	z = (Math.random() - 0.5) * 30;
	} while (Math.sqrt(xx + zz) < 5);
	const y = 2.0 + Math.random() * 6;
	ghosts.push(createGhost(new THREE.Vector3(x, y, z), roundNum));
	}
	updateUI();
	}

	function updateUI() {
	const mins = Math.floor(elapsedSeconds / 60);
	const secs = Math.floor(elapsedSeconds % 60);
	timerRoundDiv.innerText = `TIME ${mins.toString().padStart(2,'0')}:${secs.toString().padStart(2,'0')} ROUND ${round}/${maxRounds}`;
	ghostCountDiv.innerText = `GHOSTS ${ghosts.length}`;
	}

	function nextRound() {
	if (round < maxRounds) {
	round++;
	spawnRound(round);
	} else {
	gameActive = false;
	controls.unlock();
	victoryDiv.style.display = 'block';
	const mins = Math.floor(elapsedSeconds / 60);
	const secs = Math.floor(elapsedSeconds % 60);
	finalTimeSpan.innerText = `TIME: ${mins.toString().padStart(2,'0')}:${secs.toString().padStart(2,'0')}`;
	}
	}

	// --- Enemy projectiles (cosmetic) ---
	function createEnemyProjectile(position, direction) {
	const count = 12;
	const positions = [];
	const colors = [];
	const radius = 0.6;
	for (let i = 0; i < count; i++) {
	const r = radius * (0.7 + 0.3 * Math.random());
	const theta = Math.random() * Math.PI * 2;
	const phi = Math.acos(2 * Math.random() - 1);
	positions.push(
	r * Math.sin(phi) * Math.cos(theta),
	r * Math.sin(phi) * Math.sin(theta),
	r * Math.cos(phi)
	);
	colors.push(1.0, 0.3 + 0.7*Math.random(), 0.0);
	}
	const geom = new THREE.BufferGeometry();
	geom.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
	geom.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
	const mat = new THREE.PointsMaterial({
	size: 0.3,
	vertexColors: true,
	blending: THREE.AdditiveBlending,
	depthWrite: false,
	sizeAttenuation: true
	});
	const points = new THREE.Points(geom, mat);
	points.position.copy(position);
	points.userData = {
	velocity: direction.clone().multiplyScalar(1.5),
	life: 2.5
	};
	scene.add(points);
	return points;
	}

	// --- EXPORT DATASET (ZIP) ---
	async function exportDataset() {
	if (captures.length === 0) {
	exportStatus.innerText = 'No captures yet!';
	setTimeout(() => { exportStatus.innerText = ''; }, 2000);
	return;
	}

	exportStatus.innerText = 'Building ZIP...';
	const zip = new JSZip();

	// Add images and metadata
	const imgFolder = zip.folder('images');
	const metadataList = [];

	for (let i = 0; i < captures.length; i++) {
	const cap = captures[i];
	const filename = `frame_${String(i).padStart(4, '0')}.png`;
	imgFolder.file(filename, cap.blob);
	metadataList.push({
	...cap.metadata,
	filename: filename
	});
	}

	// Add metadata.json
	zip.file('metadata.json', JSON.stringify(metadataList, null, 2));

	// Add README.md for Hugging Face
	const readme = `# Ghost Hunter RLHF Dataset (Precision Auto)

	This dataset contains screenshots captured during gameplay of "Ghost Hunter" (8-bit FPS). Each image corresponds to a moment when the player successfully destroyed a ghost with the precision auto-fire. The dataset is intended for reinforcement learning from human feedback (RLHF) tasks, such as training a preference model to distinguish between "good" and "bad" shots.

	## Dataset Structure

	- \`images/\`: PNG frames captured at the moment of a kill.
	- \`metadata.json\`: JSON array with per-frame metadata including round number, ghosts remaining, player position, kills in that shot, and timestamp.

	## Stats

	- Total captures: ${captures.length}
	- Rounds covered: ${new Set(metadataList.map(m => m.round)).size}
	- Time span: ${elapsedSeconds.toFixed(1)} seconds

	## Usage

	Use this dataset to fine-tune vision-language models or as a reward model input for RLHF. Each image can be paired with the question: "Is this a good aim?" or similar.

	## License

	CC0 (public domain) - feel free to use for any purpose.
	`;
	zip.file('README.md', readme);

	// Generate zip and trigger download
	const content = await zip.generateAsync({ type: 'blob' });
	const url = URL.createObjectURL(content);
	const a = document.createElement('a');
	a.href = url;
	a.download = `ghost_hunter_dataset_${new Date().toISOString().slice(0,10)}.zip`;
	a.click();
	URL.revokeObjectURL(url);

	exportStatus.innerText = `Exported ${captures.length} captures.`;
	setTimeout(() => { exportStatus.innerText = ''; }, 3000);
	}

	exportBtn.addEventListener('click', exportDataset);

	// Initial spawn
	spawnRound(1);

	// --- ANIMATION LOOP ---
	const clock = new THREE.Clock();
	function animate() {
	const delta = Math.min(clock.getDelta(), 0.1);
	const now = performance.now() / 1000;

	if (gameActive) {
	elapsedSeconds += delta;
	updateUI();

	// Movement (A left, D right)
	if (controls.isLocked) {
	const moveDir = new THREE.Vector3();
	if (keyState.w) moveDir.z = 1; // forward
	if (keyState.s) moveDir.z = -1; // backward
	if (keyState.a) moveDir.x = -1; // left
	if (keyState.d) moveDir.x = 1; // right
	if (moveDir.length() > 0) moveDir.normalize();

	const cameraDir = new THREE.Vector3();
	camera.getWorldDirection(cameraDir);
	cameraDir.y = 0;
	cameraDir.normalize();
	const right = new THREE.Vector3().crossVectors(cameraDir, new THREE.Vector3(0,1,0)).normalize();

	const moveWorld = new THREE.Vector3();
	if (keyState.w \|\| keyState.s) moveWorld.addScaledVector(cameraDir, moveDir.z);
	if (keyState.a \|\| keyState.d) moveWorld.addScaledVector(right, moveDir.x);

	velocity.lerp(moveWorld.multiplyScalar(moveSpeed), 0.2);
	const pos = controls.getObject().position;
	pos.x += velocity.x;
	pos.z += velocity.z;
	if (Math.abs(pos.x) > boundary) pos.x = boundary * Math.sign(pos.x);
	if (Math.abs(pos.z) > boundary) pos.z = boundary * Math.sign(pos.z);
	velocity.multiplyScalar(damping);
	}

	// LMB auto-fire
	if (lmbPressed && (now - lastLMBShot) > LMB_COOLDOWN) {
	firePrecisionShot();
	lastLMBShot = now;
	}

	// Ghost shooting (cosmetic)
	ghosts.forEach(ghost => {
	if (now - ghost.userData.lastShot > ghost.userData.shootInterval) {
	ghost.userData.lastShot = now;
	const dir = new THREE.Vector3().subVectors(camera.position, ghost.position).normalize();
	enemyProjectiles.push(createEnemyProjectile(ghost.position.clone(), dir));
	}
	ghost.position.y = ghost.userData.baseY + Math.sin(now * 2 + ghost.userData.timeOffset) * 0.3;
	ghost.rotation.y += ghost.userData.rotSpeed;
	});

	// Projectile movement
	for (let i = enemyProjectiles.length - 1; i >= 0; i--) {
	const proj = enemyProjectiles[i];
	proj.position.addScaledVector(proj.userData.velocity, delta * 20);
	proj.userData.life -= delta;
	if (proj.userData.life <= 0) {
	scene.remove(proj);
	enemyProjectiles.splice(i, 1);
	proj.geometry.dispose();
	proj.material.dispose();
	}
	}

	// Update explosions (death effects)
	for (let i = explosions.length - 1; i >= 0; i--) {
	const exp = explosions[i];
	exp.age += delta;
	if (exp.age >= exp.life) {
	scene.remove(exp.mesh);
	exp.mesh.geometry.dispose();
	exp.mesh.material.dispose();
	explosions.splice(i, 1);
	continue;
	}
	// animate particles outward
	const positions = exp.mesh.geometry.attributes.position.array;
	const vel = exp.velocities;
	for (let j = 0; j < positions.length / 3; j++) {
	positions[j3] += vel[j].x delta * 15; // speed factor
	positions[j3+1] += vel[j].y delta * 15;
	positions[j3+2] += vel[j].z delta * 15;
	}
	exp.mesh.geometry.attributes.position.needsUpdate = true;
	exp.mesh.material.opacity = 1.0 - exp.age / exp.life;
	}

	// Round transition
	if (ghosts.length === 0 && gameActive) {
	nextRound();
	}
	} else {
	ghosts.forEach(g => g.rotation.y += 0.002);
	}

	worldMaterial.size = 0.16 + 0.02 * Math.sin(now * 6);

	composer.render();
	requestAnimationFrame(animate);
	}
	animate();

	window.addEventListener('resize', () => {
	camera.aspect = window.innerWidth / window.innerHeight;
	camera.updateProjectionMatrix();
	renderer.setSize(window.innerWidth, window.innerHeight);
	composer.setSize(window.innerWidth, window.innerHeight);
	});
	</script>
	</body>
	</html>