Datasets:

webxos
/

drone_fsd_dataset

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>webXOS MIRROR IDE</title>
	<meta name="theme-color" content="#000">
	<link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;500;700&family=Press+Start+2P&display=swap" rel="stylesheet">
	<script src="https://cdn.jsdelivr.net/npm/three@0.158.0/build/three.min.js"></script>
	<script src="https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js"></script>
	<script src="https://cdn.jsdelivr.net/npm/pako@2.1.0/dist/pako.min.js"></script>
	<style>
	* {
	margin: 0;
	padding: 0;
	box-sizing: border-box;
	font-family: 'Orbitron', monospace;
	image-rendering: pixelated;
	}

	body {
	background: #000;
	color: #0f0;
	overflow: hidden;
	height: 100vh;
	user-select: none;
	}

	/* CRT EFFECT */
	#crt {
	position: fixed;
	inset: 0;
	pointer-events: none;
	z-index: 9999;
	background: repeating-linear-gradient(
	0deg,
	rgba(0, 40, 0, 0.03) 0px,
	rgba(0, 40, 0, 0.03) 1px,
	transparent 1px,
	transparent 2px
	);
	animation: scan 8s linear infinite;
	}

	@keyframes scan {
	0% { background-position: 0 0; }
	100% { background-position: 0 100%; }
	}

	/* GLITCH BANNER */
	#banner {
	position: absolute;
	top: 0;
	left: 0;
	width: 100%;
	height: 30px;
	background: linear-gradient(90deg, rgba(255,0,255,0.9) 0%, rgba(0,255,255,0.9) 100%);
	color: #000;
	display: flex;
	align-items: center;
	justify-content: center;
	font-size: 11px;
	letter-spacing: 1px;
	border-bottom: 2px solid #0ff;
	z-index: 1000;
	animation: glitch 4s infinite;
	font-family: 'Press Start 2P', cursive;
	}

	@keyframes glitch {
	0%, 100% { transform: translateX(0); }
	4% { transform: translateX(-1.5px); }
	8% { transform: translateX(1.5px); }
	95% { transform: translateX(0); }
	}

	/* MAIN CONTAINER */
	#container {
	position: relative;
	width: 100vw;
	height: 100vh;
	overflow: hidden;
	}

	/* THREE.JS VIEW */
	#threeContainer {
	position: absolute;
	top: 40px;
	left: 0;
	width: 100%;
	height: calc(100% - 120px);
	z-index: 1;
	}

	canvas {
	display: block;
	}

	/* HEADER */
	#header {
	position: absolute;
	top: 30px;
	left: 0;
	width: 100%;
	height: 40px;
	background: linear-gradient(90deg, #000 0%, #0a0a0a 50%, #000 100%);
	border-bottom: 1px solid #0f0;
	display: flex;
	align-items: center;
	justify-content: space-between;
	padding: 0 20px;
	z-index: 100;
	box-shadow: 0 0 20px rgba(0, 255, 0, 0.1);
	}

	.logo {
	font-size: 14px;
	font-weight: 700;
	letter-spacing: 1px;
	color: #0f0;
	text-shadow: 0 0 10px #0f0;
	font-family: 'Press Start 2P', cursive;
	}

	.status-indicator {
	display: flex;
	align-items: center;
	gap: 10px;
	}

	.status-dot {
	width: 8px;
	height: 8px;
	border-radius: 50%;
	background: #f00;
	animation: pulse 2s infinite;
	}

	.status-dot.active {
	background: #0f0;
	}

	@keyframes pulse {
	0%, 100% { opacity: 1; }
	50% { opacity: 0.5; }
	}

	.status-text {
	font-size: 12px;
	color: #0f0;
	}

	/* CONTROL PANEL */
	#controlPanel {
	position: absolute;
	bottom: 0;
	left: 0;
	width: 100%;
	height: 80px;
	background: rgba(0, 10, 0, 0.95);
	border-top: 2px solid #0f0;
	display: flex;
	align-items: center;
	padding: 0 20px;
	gap: 15px;
	z-index: 100;
	backdrop-filter: blur(5px);
	}

	/* BUTTONS */
	.mirror-btn {
	width: 52px;
	height: 52px;
	background: #000;
	border: 2px solid #0f0;
	color: #0f0;
	font-size: 7px;
	display: flex;
	align-items: center;
	justify-content: center;
	cursor: pointer;
	box-shadow: 2px 2px 0 #000;
	transform: skew(-2deg);
	transition: all 0.1s;
	text-align: center;
	line-height: 1.1;
	flex-direction: column;
	padding: 4px;
	font-family: 'Press Start 2P', cursive;
	}

	.mirror-btn:hover {
	background: #0f0;
	color: #000;
	}

	.mirror-btn.active {
	background: #0f0;
	color: #000;
	}

	.mirror-btn.danger {
	border-color: #f00;
	color: #f00;
	}

	.mirror-btn.danger:hover {
	background: #f00;
	color: #fff;
	}

	.btn-icon {
	font-size: 16px;
	margin-bottom: 2px;
	}

	/* DATA PANELS */
	.data-panel {
	position: absolute;
	background: rgba(0, 10, 0, 0.9);
	border: 1px solid #0f0;
	padding: 10px;
	border-radius: 6px;
	z-index: 10;
	backdrop-filter: blur(5px);
	}

	#telemetryPanel {
	top: 80px;
	right: 10px;
	width: 250px;
	}

	#progressPanel {
	top: 80px;
	left: 10px;
	width: 220px;
	}

	#patternPanel {
	top: 220px;
	left: 10px;
	width: 220px;
	border-color: #0ff;
	}

	#fsdPanel {
	top: 220px;
	right: 10px;
	width: 250px;
	border-color: #ff00ff;
	}

	#rewardPanel {
	top: 360px;
	right: 10px;
	width: 250px;
	border-color: #ffaa00;
	}

	.panel-title {
	font-size: 11px;
	color: #0f0;
	margin-bottom: 8px;
	text-align: center;
	font-family: 'Press Start 2P', cursive;
	}

	.pattern-title {
	color: #0ff;
	}

	.fsd-title {
	color: #ff00ff;
	}

	.reward-title {
	color: #ffaa00;
	}

	.data-row {
	display: flex;
	justify-content: space-between;
	margin: 4px 0;
	font-size: 10px;
	}

	.data-label {
	color: #0a0;
	}

	.data-value {
	color: #0f0;
	font-family: 'Courier New', monospace;
	font-size: 10px;
	}

	.pattern-value {
	color: #0ff;
	}

	.fsd-value {
	color: #ff00ff;
	}

	.reward-value {
	color: #ffaa00;
	}

	/* PROGRESS BAR */
	.progress-bar-container {
	width: 100%;
	height: 6px;
	background: #050;
	border-radius: 3px;
	margin: 8px 0;
	overflow: hidden;
	}

	.progress-bar {
	height: 100%;
	background: #0f0;
	width: 0%;
	transition: width 0.3s;
	}

	/* WAVE VISUALIZER */
	#waveVisualizer {
	position: absolute;
	bottom: 90px;
	right: 10px;
	width: 250px;
	height: 80px;
	background: rgba(0, 10, 0, 0.8);
	border: 1px solid #0f0;
	border-radius: 6px;
	overflow: hidden;
	z-index: 10;
	backdrop-filter: blur(5px);
	}

	/* PATH VISUALIZER */
	#pathVisualizer {
	position: absolute;
	bottom: 180px;
	right: 10px;
	width: 250px;
	height: 150px;
	background: rgba(0, 10, 0, 0.8);
	border: 1px solid #0ff;
	border-radius: 6px;
	overflow: hidden;
	z-index: 10;
	backdrop-filter: blur(5px);
	}

	/* BUTTONS */
	.toggle-btn {
	position: absolute;
	top: 10px;
	z-index: 10;
	width: 52px;
	height: 52px;
	}

	#viewToggle {
	right: 150px;
	top: 40px;
	}

	#fullscreenBtn {
	right: 210px;
	top: 40px;
	}

	#emergencyStop {
	right: 10px;
	top: 40px;
	}

	/* MESSAGE OVERLAY */
	#messageOverlay {
	position: fixed;
	top: 50%;
	left: 50%;
	transform: translate(-50%, -50%);
	background: rgba(0, 0, 0, 0.9);
	border: 3px solid #0ff;
	padding: 20px;
	text-align: center;
	display: none;
	z-index: 2000;
	pointer-events: none;
	}

	.message-text {
	color: #0ff;
	font-size: 16px;
	margin-bottom: 10px;
	}

	.message-detail {
	color: #0aa;
	font-size: 12px;
	}

	/* NEURAL NETWORK VISUALIZATION */
	#nnVisualizer {
	position: absolute;
	top: 360px;
	left: 10px;
	width: 220px;
	height: 200px;
	background: rgba(0, 10, 0, 0.8);
	border: 1px solid #ff00ff;
	border-radius: 6px;
	overflow: hidden;
	z-index: 10;
	backdrop-filter: blur(5px);
	}

	/* RESPONSIVE */
	@media (max-width: 768px) {
	#controlPanel {
	gap: 8px;
	padding: 0 10px;
	}

	.mirror-btn {
	width: 45px;
	height: 45px;
	font-size: 6px;
	}

	.data-panel {
	transform: scale(0.9);
	}
	}
	</style>
	</head>
	<body>
	<!-- GLITCH BANNER -->
	<div id="banner">webXOS MIRROR IDE • DRONE DATASETS</div>

	<!-- CRT EFFECT -->
	<div id="crt"></div>

	<!-- MESSAGE OVERLAY -->
	<div id="messageOverlay">
	<div class="message-text" id="messageTitle">FSD TRAINING INITIALIZED</div>
	<div class="message-detail" id="messageDetail">Neural Network: 256-128-64-32 • Learning Rate: 0.001</div>
	</div>

	<div id="container">
	<!-- THREE.JS VIEW -->
	<div id="threeContainer"></div>

	<!-- HEADER -->
	<div id="header">
	<div class="logo">FSD TRAINER v3.0</div>
	<div class="status-indicator">
	<div class="status-dot" id="statusDot"></div>
	<div class="status-text" id="statusText">INITIALIZING ENHANCED FSD...</div>
	</div>
	</div>

	<!-- DATA PANELS -->
	<div id="telemetryPanel" class="data-panel">
	<div class="panel-title">DRONE TELEMETRY</div>
	<div class="data-row">
	<span class="data-label">ALTITUDE:</span>
	<span class="data-value" id="altitude">0.0m</span>
	</div>
	<div class="data-row">
	<span class="data-label">SPEED:</span>
	<span class="data-value" id="speed">0.0m/s</span>
	</div>
	<div class="data-row">
	<span class="data-label">VEL X/Y/Z:</span>
	<span class="data-value" id="velocity">0.0/0.0/0.0</span>
	</div>
	<div class="data-row">
	<span class="data-label">DIST TO TARGET:</span>
	<span class="data-value" id="distanceToTarget">0.0m</span>
	</div>
	<div class="data-row">
	<span class="data-label">NEXT PORTAL:</span>
	<span class="data-value" id="nextPortal">NW</span>
	</div>
	<div class="data-row">
	<span class="data-label">PATTERN STEP:</span>
	<span class="data-value" id="patternStep">1/5</span>
	</div>
	<div class="data-row">
	<span class="data-label">COLLISIONS:</span>
	<span class="data-value" id="collisionCount">0</span>
	</div>
	<div class="data-row">
	<span class="data-label">PATH LENGTH:</span>
	<span class="data-value" id="pathLength">0.0m</span>
	</div>
	<div class="data-row">
	<span class="data-label">EFFICIENCY:</span>
	<span class="data-value" id="efficiency">0%</span>
	</div>
	</div>

	<!-- PROGRESS PANEL -->
	<div id="progressPanel" class="data-panel">
	<div class="panel-title">FSD TRAINING PROGRESS</div>
	<div class="data-row">
	<span class="data-label">EPOCH:</span>
	<span class="data-value" id="epochNumber">1</span>
	</div>
	<div class="data-row">
	<span class="data-label">ITERATION:</span>
	<span class="data-value" id="iterationNumber">1</span>
	</div>
	<div class="data-row">
	<span class="data-label">TRAINING STEP:</span>
	<span class="data-value" id="trainingStep">0</span>
	</div>
	<div class="progress-bar-container">
	<div class="progress-bar" id="patternProgressBar"></div>
	</div>
	<div class="data-row">
	<span class="data-label">EPOCH TIME:</span>
	<span class="data-value" id="patternTime">0.0s</span>
	</div>
	<div class="data-row">
	<span class="data-label">BEST TIME:</span>
	<span class="data-value" id="bestTime">∞</span>
	</div>
	<div class="data-row">
	<span class="data-label">EPOCH SCORE:</span>
	<span class="data-value" id="epochScore">0.00</span>
	</div>
	</div>

	<!-- PATTERN PANEL -->
	<div id="patternPanel" class="data-panel">
	<div class="panel-title pattern-title">CRISS-CROSS PATTERN</div>
	<div class="data-row">
	<span class="data-label">PATTERN:</span>
	<span class="data-value pattern-value" id="patternSequence">NW→SE→NE→SW→CENTER</span>
	</div>
	<div class="data-row">
	<span class="data-label">CROSSINGS:</span>
	<span class="data-value pattern-value" id="crossingCount">0</span>
	</div>
	<div class="data-row">
	<span class="data-label">OBSTACLE AVOID:</span>
	<span class="data-value pattern-value" id="avoidanceScore">0.0</span>
	</div>
	<div class="data-row">
	<span class="data-label">SUCCESS RATE:</span>
	<span class="data-value pattern-value" id="successRate">0%</span>
	</div>
	<div class="data-row">
	<span class="data-label">ENV DIFFICULTY:</span>
	<span class="data-value pattern-value" id="difficultyLevel">1.0</span>
	</div>
	</div>

	<!-- FSD PANEL -->
	<div id="fsdPanel" class="data-panel">
	<div class="panel-title fsd-title">ENHANCED NEURAL NETWORK</div>
	<div class="data-row">
	<span class="data-label">NETWORK:</span>
	<span class="data-value fsd-value" id="networkArch">256-128-64-32</span>
	</div>
	<div class="data-row">
	<span class="data-label">LEARNING RATE:</span>
	<span class="data-value fsd-value" id="learningRate">0.001</span>
	</div>
	<div class="data-row">
	<span class="data-label">EXPLORATION:</span>
	<span class="data-value fsd-value" id="explorationRate">0.9</span>
	</div>
	<div class="data-row">
	<span class="data-label">Q-VALUE:</span>
	<span class="data-value fsd-value" id="qValue">0.00</span>
	</div>
	<div class="data-row">
	<span class="data-label">TD-ERROR:</span>
	<span class="data-value fsd-value" id="tdError">0.00</span>
	</div>
	<div class="data-row">
	<span class="data-label">MEMORY SIZE:</span>
	<span class="data-value fsd-value" id="memorySize">0</span>
	</div>
	<div class="data-row">
	<span class="data-label">BATCH SIZE:</span>
	<span class="data-value fsd-value" id="batchSize">32</span>
	</div>
	</div>

	<!-- REWARD PANEL -->
	<div id="rewardPanel" class="data-panel">
	<div class="panel-title reward-title">REINFORCEMENT LEARNING</div>
	<div class="data-row">
	<span class="data-label">CUM. REWARD:</span>
	<span class="data-value reward-value" id="cumulativeReward">0.0</span>
	</div>
	<div class="data-row">
	<span class="data-label">AVG REWARD:</span>
	<span class="data-value reward-value" id="avgReward">0.0</span>
	</div>
	<div class="data-row">
	<span class="data-label">REWARD/EPOCH:</span>
	<span class="data-value reward-value" id="rewardPerEpoch">0.0</span>
	</div>
	<div class="data-row">
	<span class="data-label">POLICY LOSS:</span>
	<span class="data-value reward-value" id="policyLoss">0.00</span>
	</div>
	<div class="data-row">
	<span class="data-label">VALUE LOSS:</span>
	<span class="data-value reward-value" id="valueLoss">0.00</span>
	</div>
	<div class="data-row">
	<span class="data-label">TRAIN STEPS:</span>
	<span class="data-value reward-value" id="trainSteps">0</span>
	</div>
	</div>

	<!-- WAVE VISUALIZER -->
	<canvas id="waveVisualizer"></canvas>

	<!-- PATH VISUALIZER -->
	<canvas id="pathVisualizer"></canvas>

	<!-- NEURAL NETWORK VISUALIZER -->
	<canvas id="nnVisualizer"></canvas>

	<!-- BUTTONS -->
	<div id="viewToggle" class="mirror-btn toggle-btn" title="Toggle FPV/3PV">
	<div class="btn-icon">👁️</div>
	<div>VIEW</div>
	</div>

	<div id="fullscreenBtn" class="mirror-btn toggle-btn" title="Toggle Fullscreen">
	<div class="btn-icon">⛶</div>
	<div>FULL</div>
	</div>

	<div id="emergencyStop" class="mirror-btn danger toggle-btn" title="Emergency Stop">
	<div class="btn-icon">⏹️</div>
	<div>STOP</div>
	</div>

	<!-- CONTROL PANEL -->
	<div id="controlPanel">
	<div class="mirror-btn" id="startBtn">
	<div class="btn-icon">⚡</div>
	<div>START FSD</div>
	</div>

	<div class="mirror-btn" id="pauseBtn">
	<div class="btn-icon">⏸️</div>
	<div>PAUSE</div>
	</div>

	<div class="mirror-btn" id="stopBtn">
	<div class="btn-icon">⏹️</div>
	<div>RESET</div>
	</div>

	<div class="mirror-btn" id="newEpochBtn">
	<div class="btn-icon">🔄</div>
	<div>NEW EPOCH</div>
	</div>

	<div class="mirror-btn" id="exportBtn">
	<div class="btn-icon">💾</div>
	<div>EXPORT</div>
	</div>

	<div style="margin-left: auto; display: flex; gap: 10px;">
	<div class="mirror-btn" id="trainingBtn" title="Training Settings">
	<div class="btn-icon">🧠</div>
	<div>TRAIN</div>
	</div>

	<div class="mirror-btn" id="speedBtn" title="Increase Learning Rate">
	<div class="btn-icon">🚀</div>
	<div>LEARN+</div>
	</div>

	<div class="mirror-btn" id="difficultyBtn" title="Increase Difficulty">
	<div class="btn-icon">🔥</div>
	<div>HARD+</div>
	</div>
	</div>
	</div>
	</div>

	<script>
	// ==================== ENHANCED FSD CONFIGURATION ====================
	const FSD_CONFIG = {
	// Pattern sequence
	patternSequence: ['NW', 'SE', 'NE', 'SW', 'CENTER'],
	currentStep: 0,
	patternCompleted: false,

	// Enhanced portal positions with safe approach zones
	portalPositions: {
	'NW': new THREE.Vector3(-22, 5, 22),
	'NE': new THREE.Vector3(22, 5, 22),
	'SW': new THREE.Vector3(-22, 5, -22),
	'SE': new THREE.Vector3(22, 5, -22),
	'CENTER': new THREE.Vector3(0, 4, 0)
	},

	portals: {},
	activePortal: null,

	obstacles: [],
	floatingObstacles: [],

	// Enhanced drone state with PID controller
	dronePosition: new THREE.Vector3(0, 4, 0),
	droneVelocity: new THREE.Vector3(0, 0, 0),
	droneAcceleration: new THREE.Vector3(0, 0, 0),
	droneRotation: new THREE.Euler(0, 0, 0),
	droneTargetPosition: new THREE.Vector3(0, 4, 0),

	// PID controller for smooth navigation
	pidController: {
	kp: 0.8, // Proportional gain
	ki: 0.05, // Integral gain
	kd: 0.2, // Derivative gain
	integral: new THREE.Vector3(0, 0, 0),
	lastError: new THREE.Vector3(0, 0, 0)
	},

	// FSD Training state
	isTraining: false,
	isPaused: false,
	cameraMode: 'third',
	epoch: 1,
	iteration: 1,
	trainingStep: 0,
	stuckTimer: 0,
	stuckThreshold: 3.0,
	lastProgressTime: 0,
	lastDistanceToTarget: 0,

	// Enhanced Neural Network parameters (PPO-style)
	networkArchitecture: [256, 128, 64, 32],
	learningRate: 0.001,
	explorationRate: 0.9,
	discountFactor: 0.99,
	tdError: 0,
	policyLoss: 0,
	valueLoss: 0,

	// Experience Replay Memory
	memoryBuffer: [],
	maxMemorySize: 50000,
	batchSize: 32,
	trainSteps: 0,

	// Performance metrics
	collisionCount: 0,
	patternStartTime: 0,
	patternBestTime: Infinity,
	totalPathLength: 0,
	lastPosition: new THREE.Vector3(0, 4, 0),
	crossingCount: 0,
	efficiencyScore: 0,
	epochScore: 0,
	successHistory: [],

	// Enhanced environment settings
	environment: {
	roomSize: 60,
	obstacleCount: 15,
	floatingCount: 12,
	floatingMinSpeed: 0.2,
	floatingMaxSpeed: 0.5,
	bounceEnergy: 0.8,
	obstacleRepulsion: 2.0,
	difficultyLevel: 1.0
	},

	// FSD Learning system
	avoidanceMemory: [],
	successfulPaths: [],
	failedPaths: [],
	actionHistory: [],

	// Enhanced telemetry
	telemetryBuffer: [],
	rewardBuffer: [],
	maxBufferSize: 100000,
	cumulativeReward: 0,
	avgReward: 0,
	rewardPerEpoch: [],

	// Enhanced action space with continuous controls
	actionSpace: [
	// Basic movements
	{type: 'forward', vector: new THREE.Vector3(0, 0, -1), weight: 1.0},
	{type: 'backward', vector: new THREE.Vector3(0, 0, 1), weight: 0.8},
	{type: 'left', vector: new THREE.Vector3(-1, 0, 0), weight: 0.8},
	{type: 'right', vector: new THREE.Vector3(1, 0, 0), weight: 0.8},
	{type: 'up', vector: new THREE.Vector3(0, 1, 0), weight: 0.6},
	{type: 'down', vector: new THREE.Vector3(0, -1, 0), weight: 0.6},

	// Diagonal movements
	{type: 'forward_left', vector: new THREE.Vector3(-0.7, 0, -0.7), weight: 0.9},
	{type: 'forward_right', vector: new THREE.Vector3(0.7, 0, -0.7), weight: 0.9},
	{type: 'backward_left', vector: new THREE.Vector3(-0.7, 0, 0.7), weight: 0.7},
	{type: 'backward_right', vector: new THREE.Vector3(0.7, 0, 0.7), weight: 0.7},

	// Advanced movements (added for better navigation)
	{type: 'up_forward', vector: new THREE.Vector3(0, 0.5, -0.8), weight: 0.7},
	{type: 'up_left', vector: new THREE.Vector3(-0.5, 0.5, 0), weight: 0.7},
	{type: 'up_right', vector: new THREE.Vector3(0.5, 0.5, 0), weight: 0.7},
	{type: 'hover', vector: new THREE.Vector3(0, 0.1, 0), weight: 0.5}
	],

	// State normalization constants
	stateNormalization: {
	positionScale: 30,
	velocityScale: 20,
	targetScale: 30,
	distanceScale: 50
	}
	};

	// ==================== ENHANCED NEURAL NETWORK (PPO-STYLE) ====================
	class EnhancedFSDNetwork {
	constructor() {
	this.layers = [256, 128, 64, 32];
	this.weights = [];
	this.biases = [];
	this.targetWeights = [];
	this.targetBiases = [];
	this.initializeWeights();
	this.copyToTarget();

	// Training parameters
	this.learningRate = 0.001;
	this.clipEpsilon = 0.2;
	this.valueCoeff = 0.5;
	this.entropyCoeff = 0.01;
	}

	initializeWeights() {
	for (let i = 0; i < this.layers.length - 1; i++) {
	const rows = this.layers[i + 1];
	const cols = this.layers[i];

	// He initialization for ReLU
	const scale = Math.sqrt(2.0 / cols);
	const weightMatrix = [];
	for (let r = 0; r < rows; r++) {
	const row = [];
	for (let c = 0; c < cols; c++) {
	row.push((Math.random() * 2 - 1) * scale);
	}
	weightMatrix.push(row);
	}

	this.weights.push(weightMatrix);
	this.biases.push(new Array(rows).fill(0.01));
	}
	}

	copyToTarget() {
	this.targetWeights = JSON.parse(JSON.stringify(this.weights));
	this.targetBiases = JSON.parse(JSON.stringify(this.biases));
	}

	softUpdateTarget(tau = 0.01) {
	for (let i = 0; i < this.weights.length; i++) {
	for (let r = 0; r < this.weights[i].length; r++) {
	for (let c = 0; c < this.weights[i][r].length; c++) {
	this.targetWeights[i][r][c] =
	tau * this.weights[i][r][c] + (1 - tau) * this.targetWeights[i][r][c];
	}
	}
	for (let j = 0; j < this.biases[i].length; j++) {
	this.targetBiases[i][j] =
	tau * this.biases[i][j] + (1 - tau) * this.targetBiases[i][j];
	}
	}
	}

	forward(input, useTarget = false) {
	let current = input;
	const weights = useTarget ? this.targetWeights : this.weights;
	const biases = useTarget ? this.targetBiases : this.biases;

	const activations = [input];

	for (let i = 0; i < weights.length; i++) {
	const next = new Array(weights[i].length).fill(0);

	// Matrix multiplication with bias
	for (let r = 0; r < weights[i].length; r++) {
	let sum = biases[i][r];
	for (let c = 0; c < weights[i][r].length; c++) {
	sum += weights[i][r][c] * current[c];
	}
	// Leaky ReLU activation
	next[r] = Math.max(0.01 * sum, sum);
	}

	activations.push(next);
	current = next;
	}

	return {
	output: current,
	activations: activations
	};
	}

	// Get policy (probability distribution over actions)
	getPolicy(state) {
	const input = this.stateToInput(state);
	const result = this.forward(input);

	// Softmax over action space
	const logits = result.output.slice(0, FSD_CONFIG.actionSpace.length);
	const maxLogit = Math.max(...logits);
	const expLogits = logits.map(l => Math.exp(l - maxLogit));
	const sumExp = expLogits.reduce((a, b) => a + b, 0);

	return expLogits.map(exp => exp / sumExp);
	}

	// Get value estimate
	getValue(state) {
	const input = this.stateToInput(state);
	const result = this.forward(input);
	return result.output[FSD_CONFIG.actionSpace.length]; // Value is last output
	}

	// PPO training step
	trainBatch(batch) {
	if (batch.length === 0) return { policyLoss: 0, valueLoss: 0, tdError: 0 };

	let totalPolicyLoss = 0;
	let totalValueLoss = 0;
	let totalTdError = 0;

	for (const experience of batch) {
	const { state, action, reward, nextState, oldProbability, done } = experience;

	// Compute advantages and returns
	const currentValue = this.getValue(state);
	const nextValue = done ? 0 : this.getValue(nextState);
	const targetValue = reward + FSD_CONFIG.discountFactor * nextValue;
	const advantage = targetValue - currentValue;

	// Get new action probability
	const policy = this.getPolicy(state);
	const newProbability = policy[action];

	// Policy loss (clipped PPO)
	const ratio = newProbability / (oldProbability + 1e-8);
	const clippedRatio = Math.max(1 - this.clipEpsilon, Math.min(ratio, 1 + this.clipEpsilon));
	const policyLoss = -Math.min(ratio * advantage, clippedRatio * advantage);

	// Value loss
	const valueLoss = Math.pow(targetValue - currentValue, 2);

	// Update weights (simplified gradient descent)
	totalPolicyLoss += policyLoss;
	totalValueLoss += valueLoss;
	totalTdError += Math.abs(advantage);

	// Apply updates (simplified)
	this.applyUpdate(state, action, policyLoss, valueLoss);
	}

	// Soft update target network
	this.softUpdateTarget(0.01);

	return {
	policyLoss: totalPolicyLoss / batch.length,
	valueLoss: totalValueLoss / batch.length,
	tdError: totalTdError / batch.length
	};
	}

	applyUpdate(state, action, policyLoss, valueLoss) {
	// Simplified gradient descent update
	const input = this.stateToInput(state);
	const result = this.forward(input);

	// Update output layer weights for the taken action
	const lastLayerIndex = this.weights.length - 1;
	const actionIndex = action;

	// Policy update
	const policyGradient = policyLoss * this.learningRate;
	for (let i = 0; i < this.weights[lastLayerIndex][actionIndex].length; i++) {
	this.weights[lastLayerIndex][actionIndex][i] -=
	policyGradient * result.activations[lastLayerIndex][i];
	}
	this.biases[lastLayerIndex][actionIndex] -= policyGradient;

	// Value update (last neuron)
	const valueIndex = this.weights[lastLayerIndex].length - 1;
	const valueGradient = valueLoss * this.learningRate * this.valueCoeff;
	for (let i = 0; i < this.weights[lastLayerIndex][valueIndex].length; i++) {
	this.weights[lastLayerIndex][valueIndex][i] -=
	valueGradient * result.activations[lastLayerIndex][i];
	}
	this.biases[lastLayerIndex][valueIndex] -= valueGradient;
	}

	stateToInput(state) {
	const input = [];
	const norm = FSD_CONFIG.stateNormalization;

	// Drone position (3)
	input.push(state.dronePosition.x / norm.positionScale);
	input.push(state.dronePosition.y / norm.positionScale);
	input.push(state.dronePosition.z / norm.positionScale);

	// Drone velocity (3)
	input.push(state.droneVelocity.x / norm.velocityScale);
	input.push(state.droneVelocity.y / norm.velocityScale);
	input.push(state.droneVelocity.z / norm.velocityScale);

	// Target position (3)
	const target = FSD_CONFIG.portalPositions[state.target];
	if (target) {
	input.push(target.x / norm.targetScale);
	input.push(target.y / norm.targetScale);
	input.push(target.z / norm.targetScale);
	} else {
	input.push(0, 0, 0);
	}

	// Relative vector to target (3)
	const toTarget = target.clone().sub(state.dronePosition);
	input.push(toTarget.x / norm.distanceScale);
	input.push(toTarget.y / norm.distanceScale);
	input.push(toTarget.z / norm.distanceScale);

	// Distance to target
	input.push(state.distanceToTarget / norm.distanceScale);

	// Obstacle proximity (4 directions)
	const obstacleProximity = this.calculateObstacleProximity(state.dronePosition);
	input.push(...obstacleProximity);

	// Current step in pattern
	input.push(state.patternStep / 5);

	// Exploration rate
	input.push(FSD_CONFIG.explorationRate);

	// Pad to 256 inputs
	while (input.length < 256) input.push(0);

	return input.slice(0, 256);
	}

	calculateObstacleProximity(position) {
	const directions = [
	new THREE.Vector3(1, 0, 0), // right
	new THREE.Vector3(-1, 0, 0), // left
	new THREE.Vector3(0, 0, 1), // forward
	new THREE.Vector3(0, 0, -1), // backward
	new THREE.Vector3(0, 1, 0), // up
	new THREE.Vector3(0, -1, 0) // down
	];

	const proximities = [];
	const maxRange = 15;

	for (const dir of directions) {
	let minDistance = maxRange;

	for (const obstacle of FSD_CONFIG.obstacles) {
	if (!obstacle \|\| !obstacle.position) continue;

	// Check if obstacle is in this direction
	const toObstacle = obstacle.position.clone().sub(position);
	const dot = toObstacle.dot(dir);

	if (dot > 0) {
	const distance = toObstacle.length();
	if (distance < minDistance) {
	minDistance = distance;
	}
	}
	}

	// Normalize proximity (0 = close, 1 = far)
	proximities.push(1 - (minDistance / maxRange));
	}

	return proximities;
	}
	}

	// Initialize enhanced neural network
	const enhancedNetwork = new EnhancedFSDNetwork();

	// ==================== THREE.JS SETUP ====================
	let scene, camera, renderer, clock;
	let droneGroup = new THREE.Group();
	let frameCount = 0;

	function setupThreeJS() {
	scene = new THREE.Scene();
	scene.background = new THREE.Color(0x000000);
	scene.fog = new THREE.Fog(0x000000, 10, 100);

	camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
	camera.position.set(0, 20, 35);

	renderer = new THREE.WebGLRenderer({ antialias: true });
	renderer.setSize(window.innerWidth, window.innerHeight);
	renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
	renderer.shadowMap.enabled = true;
	renderer.shadowMap.type = THREE.PCFSoftShadowMap;
	document.getElementById('threeContainer').appendChild(renderer.domElement);

	clock = new THREE.Clock();
	}

	// ==================== ENHANCED SCENE SETUP ====================
	function setupScene() {
	// Clear scene
	while(scene.children.length > 0) {
	const child = scene.children[0];
	if (child.geometry) child.geometry.dispose();
	if (child.material) child.material.dispose();
	scene.remove(child);
	}

	scene.add(droneGroup);
	setupDrone();

	// Enhanced grid floor
	const grid = new THREE.GridHelper(60, 60, 0x002200, 0x001100);
	grid.position.y = 0.1;
	scene.add(grid);

	// Center marker with safe zone
	const centerGeo = new THREE.SphereGeometry(1.0, 16, 16);
	const centerMat = new THREE.MeshBasicMaterial({
	color: 0x00ff00,
	emissive: 0x003000,
	transparent: true,
	opacity: 0.5
	});
	const centerMarker = new THREE.Mesh(centerGeo, centerMat);
	centerMarker.position.set(0, 0.5, 0);
	scene.add(centerMarker);

	// Corner markers
	for (const [name, pos] of Object.entries(FSD_CONFIG.portalPositions)) {
	if (name === 'CENTER') continue;

	const markerGeo = new THREE.SphereGeometry(0.5, 12, 12);
	const markerMat = new THREE.MeshBasicMaterial({
	color: 0xff0000,
	emissive: 0x300000
	});
	const marker = new THREE.Mesh(markerGeo, markerMat);
	marker.position.set(pos.x, 0.5, pos.z);
	marker.userData = { name: name, type: 'portal' };
	scene.add(marker);
	}

	// Enhanced lighting
	scene.add(new THREE.AmbientLight(0x003300));

	const topLight = new THREE.DirectionalLight(0x00ff00, 0.7);
	topLight.position.set(0, 40, 0);
	topLight.castShadow = true;
	scene.add(topLight);

	// Corner lights
	for (const [name, pos] of Object.entries(FSD_CONFIG.portalPositions)) {
	if (name === 'CENTER') continue;

	const cornerLight = new THREE.PointLight(0xff0000, 0.5, 30);
	cornerLight.position.set(pos.x, 10, pos.z);
	scene.add(cornerLight);
	}
	}

	// ==================== ENHANCED DRONE SETUP ====================
	function setupDrone() {
	droneGroup.clear();

	// Drone body
	const bodyGeo = new THREE.BoxGeometry(0.8, 0.15, 0.8);
	const bodyMat = new THREE.MeshBasicMaterial({
	color: 0x00ff00,
	wireframe: true
	});
	const body = new THREE.Mesh(bodyGeo, bodyMat);
	droneGroup.add(body);

	// Enhanced arms
	const armGeo = new THREE.BoxGeometry(1.4, 0.05, 0.05);
	const armMat = new THREE.MeshBasicMaterial({ color: 0x00ff00 });

	for (let i = 0; i < 4; i++) {
	const angle = (i * Math.PI) / 2;
	const arm = new THREE.Mesh(armGeo, armMat);
	arm.position.set(Math.cos(angle) * 0.7, 0, Math.sin(angle) * 0.7);
	droneGroup.add(arm);

	// Enhanced propellers with glow effect
	const propGeo = new THREE.CylinderGeometry(0.2, 0.2, 0.03, 12);
	const propMat = new THREE.MeshBasicMaterial({
	color: 0xff0000,
	emissive: 0x330000
	});
	const prop = new THREE.Mesh(propGeo, propMat);
	prop.position.set(Math.cos(angle) * 0.7, 0.08, Math.sin(angle) * 0.7);
	prop.userData = { rotationSpeed: 15 + Math.random() * 5 };
	droneGroup.add(prop);
	}

	// Enhanced front indicator
	const frontGeo = new THREE.ConeGeometry(0.1, 0.3, 8);
	const frontMat = new THREE.MeshBasicMaterial({
	color: 0x00ffff,
	emissive: 0x003333
	});
	const frontIndicator = new THREE.Mesh(frontGeo, frontMat);
	frontIndicator.position.set(0.5, 0, 0);
	frontIndicator.rotation.z = Math.PI / 2;
	droneGroup.add(frontIndicator);

	// Add orientation indicators
	const orientationGeo = new THREE.SphereGeometry(0.05, 4, 4);
	const orientationMat = new THREE.MeshBasicMaterial({ color: 0xffff00 });

	for (let i = 0; i < 3; i++) {
	const indicator = new THREE.Mesh(orientationGeo, orientationMat);
	indicator.position.set(0, i * 0.1 - 0.1, 0);
	droneGroup.add(indicator);
	}

	droneGroup.position.copy(FSD_CONFIG.dronePosition);
	}

	// ==================== ENHANCED BOUNCING OBSTACLES ====================
	function generateBouncingObstacles() {
	// Clear old obstacles
	FSD_CONFIG.obstacles.forEach(obstacle => {
	if (obstacle.parent) obstacle.parent.remove(obstacle);
	if (obstacle.geometry) obstacle.geometry.dispose();
	if (obstacle.material) obstacle.material.dispose();
	});

	FSD_CONFIG.obstacles = [];
	FSD_CONFIG.floatingObstacles = [];

	const difficulty = FSD_CONFIG.environment.difficultyLevel;
	const roomHalf = FSD_CONFIG.environment.roomSize / 2;

	// Generate obstacles based on difficulty
	const totalObstacles = Math.floor(15 + (difficulty - 1) * 5);
	const floatingCount = Math.floor(12 + (difficulty - 1) * 3);

	for (let i = 0; i < totalObstacles - floatingCount; i++) {
	const type = Math.random() > 0.5 ? 'pillar' : 'wall';
	let geo, mat;

	if (type === 'pillar') {
	const radius = 0.6 + Math.random() * 1.2 * difficulty;
	const height = 4 + Math.random() * 8 * difficulty;
	geo = new THREE.CylinderGeometry(radius, radius, height, 12);
	mat = new THREE.MeshBasicMaterial({
	color: 0x00ff00,
	wireframe: true,
	transparent: true,
	opacity: 0.6
	});

	const obstacle = new THREE.Mesh(geo, mat);

	// Strategic placement to force learning
	let x, z;
	if (i < 4) {
	// Place near portals
	const portalNames = ['NW', 'NE', 'SW', 'SE'];
	const portal = FSD_CONFIG.portalPositions[portalNames[i]];
	x = portal.x + (Math.random() - 0.5) * 8;
	z = portal.z + (Math.random() - 0.5) * 8;
	} else {
	// Random placement
	x = (Math.random() - 0.5) * 50;
	z = (Math.random() - 0.5) * 50;
	}

	obstacle.position.set(x, height / 2, z);
	obstacle.userData = {
	type: 'pillar',
	height: height,
	radius: radius,
	isFloating: false,
	velocity: new THREE.Vector3(0, 0, 0)
	};

	scene.add(obstacle);
	FSD_CONFIG.obstacles.push(obstacle);
	} else {
	const width = 2 + Math.random() * 4 * difficulty;
	const height = 3 + Math.random() * 6 * difficulty;
	const depth = 0.5 + Math.random() * 1.5 * difficulty;
	geo = new THREE.BoxGeometry(width, height, depth);
	mat = new THREE.MeshBasicMaterial({
	color: 0x00ff00,
	wireframe: true,
	transparent: true,
	opacity: 0.6
	});

	const obstacle = new THREE.Mesh(geo, mat);

	// Place walls across key paths
	const angle = Math.random() * Math.PI * 2;
	const distance = 12 + Math.random() * 18;
	const x = Math.cos(angle) * distance;
	const z = Math.sin(angle) * distance;

	obstacle.position.set(x, height / 2, z);
	obstacle.rotation.y = angle;

	obstacle.userData = {
	type: 'wall',
	height: height,
	width: width,
	depth: depth,
	isFloating: false,
	velocity: new THREE.Vector3(0, 0, 0)
	};

	scene.add(obstacle);
	FSD_CONFIG.obstacles.push(obstacle);
	}
	}

	// Enhanced bouncing obstacles
	for (let i = 0; i < floatingCount; i++) {
	const size = 1.2 + Math.random() * 2.5 * difficulty;
	const geo = new THREE.IcosahedronGeometry(size, 1);
	const mat = new THREE.MeshBasicMaterial({
	color: 0xff00ff,
	wireframe: true,
	transparent: true,
	opacity: 0.7
	});

	const obstacle = new THREE.Mesh(geo, mat);

	// Position with bias toward center
	const bias = Math.random();
	const x = (Math.random() - 0.5) * 40 * (bias > 0.7 ? 0.5 : 1);
	const z = (Math.random() - 0.5) * 40 * (bias > 0.7 ? 0.5 : 1);
	const y = 6 + Math.random() * 12;

	obstacle.position.set(x, y, z);

	const speed = FSD_CONFIG.environment.floatingMinSpeed +
	Math.random() * (FSD_CONFIG.environment.floatingMaxSpeed * difficulty - FSD_CONFIG.environment.floatingMinSpeed);
	const angle = Math.random() * Math.PI * 2;
	const velocity = new THREE.Vector3(
	Math.cos(angle) * speed,
	(Math.random() - 0.5) * speed * 0.5,
	Math.sin(angle) * speed
	);

	obstacle.userData = {
	type: 'floating',
	size: size,
	isFloating: true,
	velocity: velocity,
	angularVelocity: new THREE.Vector3(
	(Math.random() - 0.5) * 0.1,
	(Math.random() - 0.5) * 0.1,
	(Math.random() - 0.5) * 0.1
	),
	bounceEnergy: FSD_CONFIG.environment.bounceEnergy,
	originalColor: 0xff00ff
	};

	scene.add(obstacle);
	FSD_CONFIG.obstacles.push(obstacle);
	FSD_CONFIG.floatingObstacles.push(obstacle);
	}
	}

	// ==================== ENHANCED BOUNCING PHYSICS ====================
	function updateBouncingObstacles(delta) {
	const roomHalf = FSD_CONFIG.environment.roomSize / 2;

	for (const obstacle of FSD_CONFIG.floatingObstacles) {
	if (!obstacle \|\| !obstacle.userData) continue;

	const data = obstacle.userData;

	// Apply velocity with time scaling
	obstacle.position.x += data.velocity.x * delta * 60;
	obstacle.position.y += data.velocity.y * delta * 60;
	obstacle.position.z += data.velocity.z * delta * 60;

	// Apply rotation
	obstacle.rotation.x += data.angularVelocity.x;
	obstacle.rotation.y += data.angularVelocity.y;
	obstacle.rotation.z += data.angularVelocity.z;

	// Check bounds with enhanced bounce
	const halfSize = data.size / 2;
	const bounceEnergy = data.bounceEnergy;

	// X bounds
	if (obstacle.position.x - halfSize < -roomHalf \|\| obstacle.position.x + halfSize > roomHalf) {
	data.velocity.x = -data.velocity.x * bounceEnergy;
	// Add slight random variation
	data.velocity.x += (Math.random() - 0.5) * 0.1;
	obstacle.position.x = THREE.MathUtils.clamp(
	obstacle.position.x,
	-roomHalf + halfSize,
	roomHalf - halfSize
	);
	}

	// Y bounds
	if (obstacle.position.y - halfSize < 2 \|\| obstacle.position.y + halfSize > roomHalf - 5) {
	data.velocity.y = -data.velocity.y * bounceEnergy;
	data.velocity.y += (Math.random() - 0.5) * 0.05;
	obstacle.position.y = THREE.MathUtils.clamp(
	obstacle.position.y,
	2 + halfSize,
	roomHalf - 5 - halfSize
	);
	}

	// Z bounds
	if (obstacle.position.z - halfSize < -roomHalf \|\| obstacle.position.z + halfSize > roomHalf) {
	data.velocity.z = -data.velocity.z * bounceEnergy;
	data.velocity.z += (Math.random() - 0.5) * 0.1;
	obstacle.position.z = THREE.MathUtils.clamp(
	obstacle.position.z,
	-roomHalf + halfSize,
	roomHalf - halfSize
	);
	}

	// Gravity effect
	data.velocity.y -= 0.1 * delta;

	// Obstacle-obstacle collisions with momentum transfer
	for (const otherObstacle of FSD_CONFIG.floatingObstacles) {
	if (obstacle === otherObstacle \|\| !otherObstacle.userData) continue;

	const otherData = otherObstacle.userData;
	const distance = obstacle.position.distanceTo(otherObstacle.position);
	const minDistance = (data.size + otherData.size) / 2;

	if (distance < minDistance) {
	// Calculate collision normal
	const normal = new THREE.Vector3()
	.subVectors(obstacle.position, otherObstacle.position)
	.normalize();

	// Calculate relative velocity
	const relativeVelocity = data.velocity.clone().sub(otherData.velocity);
	const normalVelocity = relativeVelocity.dot(normal);

	// Only resolve if moving toward each other
	if (normalVelocity < 0) {
	const impulse = -(1 + bounceEnergy) * normalVelocity /
	(1/data.size + 1/otherData.size);

	data.velocity.add(normal.clone().multiplyScalar(impulse / data.size));
	otherData.velocity.sub(normal.clone().multiplyScalar(impulse / otherData.size));

	// Separate obstacles
	const overlap = minDistance - distance;
	const separation = normal.multiplyScalar(overlap * 0.5);
	obstacle.position.add(separation);
	otherObstacle.position.sub(separation);
	}
	}
	}
	}
	}

	// ==================== ENHANCED PORTAL SETUP ====================
	function createPortals() {
	// Clear old portals
	Object.values(FSD_CONFIG.portals).forEach(portal => {
	if (portal && portal.parent === scene) {
	scene.remove(portal);
	}
	});
	FSD_CONFIG.portals = {};

	for (const [name, position] of Object.entries(FSD_CONFIG.portalPositions)) {
	if (name === 'CENTER') continue;

	// Enhanced portal geometry
	const outerGeo = new THREE.TorusGeometry(2.5, 0.3, 16, 32);
	const outerMat = new THREE.MeshBasicMaterial({
	color: 0x00ff00,
	wireframe: true,
	emissive: 0x003300
	});
	const outerRing = new THREE.Mesh(outerGeo, outerMat);
	outerRing.position.copy(position);
	outerRing.rotation.x = Math.PI / 2;

	// Inner portal with particles
	const innerGeo = new THREE.SphereGeometry(1.5, 16, 16);
	const innerMat = new THREE.MeshBasicMaterial({
	color: 0xff0000,
	wireframe: true,
	transparent: true,
	opacity: 0.7,
	emissive: 0x330000
	});
	const innerSphere = new THREE.Mesh(innerGeo, innerMat);
	innerSphere.position.copy(position);

	// Create portal group
	const portalGroup = new THREE.Group();
	portalGroup.add(outerRing);
	portalGroup.add(innerSphere);
	portalGroup.position.copy(position);

	portalGroup.userData = {
	name: name,
	collected: false,
	position: position.clone(),
	rotationSpeed: 0.03,
	pulsePhase: Math.random() * Math.PI * 2
	};

	scene.add(portalGroup);
	FSD_CONFIG.portals[name] = portalGroup;
	}

	// Set first portal as active
	FSD_CONFIG.currentStep = 0;
	const firstPortalName = FSD_CONFIG.patternSequence[0];
	FSD_CONFIG.activePortal = FSD_CONFIG.portals[firstPortalName];
	}

	// ==================== ENHANCED FSD AUTOPILOT WITH PID CONTROLLER ====================
	function enhancedFSDAutoPilot(delta) {
	if (!FSD_CONFIG.isTraining \|\| FSD_CONFIG.isPaused \|\| FSD_CONFIG.patternCompleted) return;

	try {
	FSD_CONFIG.trainingStep++;
	const currentTime = Date.now();
	const currentTargetName = FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep];

	// Get target position
	let targetPosition;
	if (currentTargetName === 'CENTER') {
	targetPosition = FSD_CONFIG.portalPositions['CENTER'].clone();
	} else {
	targetPosition = FSD_CONFIG.portalPositions[currentTargetName].clone();
	}

	FSD_CONFIG.droneTargetPosition.copy(targetPosition);

	// Get current state
	const currentState = getCurrentState();

	// Choose action using enhanced policy
	let actionIndex;
	let actionProbability = 0;

	if (Math.random() < FSD_CONFIG.explorationRate && FSD_CONFIG.trainingStep < 200) {
	// Exploration phase
	actionIndex = Math.floor(Math.random() * FSD_CONFIG.actionSpace.length);
	actionProbability = 1 / FSD_CONFIG.actionSpace.length;
	} else {
	// Exploitation: use neural network policy
	const policy = enhancedNetwork.getPolicy(currentState);
	actionIndex = sampleFromDistribution(policy);
	actionProbability = policy[actionIndex];
	}

	// Get action vector
	const action = FSD_CONFIG.actionSpace[actionIndex];

	// Calculate enhanced movement with PID controller
	const moveVector = calculateEnhancedMovement(targetPosition, action.vector, delta);

	// Apply movement
	FSD_CONFIG.dronePosition.add(moveVector);

	// Enhanced bounds checking
	const roomHalf = FSD_CONFIG.environment.roomSize / 2;
	const margin = 3;
	FSD_CONFIG.dronePosition.x = THREE.MathUtils.clamp(
	FSD_CONFIG.dronePosition.x,
	-roomHalf + margin,
	roomHalf - margin
	);
	FSD_CONFIG.dronePosition.y = THREE.MathUtils.clamp(
	FSD_CONFIG.dronePosition.y,
	2,
	roomHalf - 8
	);
	FSD_CONFIG.dronePosition.z = THREE.MathUtils.clamp(
	FSD_CONFIG.dronePosition.z,
	-roomHalf + margin,
	roomHalf - margin
	);

	// Update drone visuals with smooth rotation
	droneGroup.position.copy(FSD_CONFIG.dronePosition);

	// Smooth rotation towards movement direction
	if (moveVector.length() > 0.1) {
	const targetQuat = new THREE.Quaternion().setFromUnitVectors(
	new THREE.Vector3(0, 0, 1),
	moveVector.clone().normalize()
	);
	droneGroup.quaternion.slerp(targetQuat, 0.15);
	}

	// Update velocity with smoothing
	const newVelocity = moveVector.divideScalar(delta);
	FSD_CONFIG.droneVelocity.lerp(newVelocity, 0.2);

	// Update path tracking
	const stepDistance = FSD_CONFIG.dronePosition.distanceTo(FSD_CONFIG.lastPosition);
	FSD_CONFIG.totalPathLength += stepDistance;
	FSD_CONFIG.lastPosition.copy(FSD_CONFIG.dronePosition);

	// Calculate distance to target
	const distanceToTarget = FSD_CONFIG.dronePosition.distanceTo(targetPosition);

	// Anti-stuck system
	if (distanceToTarget < FSD_CONFIG.lastDistanceToTarget * 0.99) {
	FSD_CONFIG.stuckTimer = Math.max(0, FSD_CONFIG.stuckTimer - delta * 2);
	FSD_CONFIG.lastProgressTime = currentTime;
	} else {
	FSD_CONFIG.stuckTimer += delta;
	}

	FSD_CONFIG.lastDistanceToTarget = distanceToTarget;

	// Stuck recovery
	if (FSD_CONFIG.stuckTimer > FSD_CONFIG.stuckThreshold) {
	handleEnhancedStuckRecovery();
	}

	// Check if target reached
	if (distanceToTarget < 3.0) {
	handleTargetReached(currentTargetName);
	}

	// Check for center crossings with enhanced detection
	if (Math.abs(FSD_CONFIG.dronePosition.x) < 6 && Math.abs(FSD_CONFIG.dronePosition.z) < 6) {
	if (Math.abs(FSD_CONFIG.lastPosition.x) > 6 \|\| Math.abs(FSD_CONFIG.lastPosition.z) > 6) {
	FSD_CONFIG.crossingCount++;
	addEnhancedReward(8, 'center_crossing');
	}
	}

	// Enhanced collision detection
	if (checkEnhancedCollisions()) {
	addEnhancedReward(-15, 'collision');
	}

	// Calculate immediate reward
	const immediateReward = calculateImmediateReward(distanceToTarget, stepDistance, delta);
	addEnhancedReward(immediateReward, 'movement');

	// Record experience for training
	recordEnhancedExperience(currentState, actionIndex, actionProbability);

	// Periodic training
	if (FSD_CONFIG.trainingStep % 50 === 0 && FSD_CONFIG.memoryBuffer.length >= FSD_CONFIG.batchSize) {
	trainEnhancedNetwork();
	}

	// Log enhanced telemetry
	logEnhancedTelemetry(actionIndex, distanceToTarget);

	// Update avoidance memory
	updateAvoidanceMemory();

	} catch (error) {
	console.error('Enhanced FSD Auto-pilot error:', error);
	}
	}

	function calculateEnhancedMovement(targetPosition, actionVector, delta) {
	// Combine neural network action with PID controller
	const pidOutput = calculatePIDOutput(targetPosition);
	const avoidanceForce = calculateEnhancedAvoidance();

	// Blend forces
	const blendFactor = 0.6;
	const neuralForce = actionVector.clone().multiplyScalar(blendFactor);
	const pidForce = pidOutput.multiplyScalar(1 - blendFactor);

	let finalForce = neuralForce.add(pidForce);

	// Add avoidance with adaptive weight
	const avoidanceWeight = Math.min(2.0, FSD_CONFIG.avoidanceMemory.length / 10);
	finalForce.add(avoidanceForce.multiplyScalar(avoidanceWeight));

	// Normalize and apply speed
	finalForce.normalize();

	// Adaptive speed based on performance
	const baseSpeed = 10 + (FSD_CONFIG.successfulPaths.length * 0.3);
	const distance = FSD_CONFIG.dronePosition.distanceTo(targetPosition);
	const adaptiveSpeed = Math.min(baseSpeed, distance * 0.7);
	const speedBoost = 1 + (FSD_CONFIG.learningRate * 5);

	return finalForce.multiplyScalar(adaptiveSpeed * speedBoost * delta);
	}

	function calculatePIDOutput(targetPosition) {
	const pid = FSD_CONFIG.pidController;
	const error = targetPosition.clone().sub(FSD_CONFIG.dronePosition);

	// Update integral
	pid.integral.add(error.clone().multiplyScalar(pid.ki));

	// Clamp integral to prevent windup
	const maxIntegral = 5;
	pid.integral.x = THREE.MathUtils.clamp(pid.integral.x, -maxIntegral, maxIntegral);
	pid.integral.y = THREE.MathUtils.clamp(pid.integral.y, -maxIntegral, maxIntegral);
	pid.integral.z = THREE.MathUtils.clamp(pid.integral.z, -maxIntegral, maxIntegral);

	// Calculate derivative
	const derivative = error.clone().sub(pid.lastError);

	// PID output
	const output = new THREE.Vector3()
	.add(error.clone().multiplyScalar(pid.kp))
	.add(pid.integral)
	.add(derivative.multiplyScalar(pid.kd));

	// Store error for next iteration
	pid.lastError.copy(error);

	return output;
	}

	function calculateEnhancedAvoidance() {
	const avoidance = new THREE.Vector3(0, 0, 0);
	const dronePos = FSD_CONFIG.dronePosition;

	for (const obstacle of FSD_CONFIG.obstacles) {
	if (!obstacle \|\| !obstacle.position) continue;

	const data = obstacle.userData;
	const obstaclePos = obstacle.position.clone();

	// Predict future position for moving obstacles
	if (data.isFloating && data.velocity) {
	const predictionTime = 0.8;
	obstaclePos.add(data.velocity.clone().multiplyScalar(predictionTime));
	}

	const toDrone = dronePos.clone().sub(obstaclePos);
	const distance = toDrone.length();

	// Calculate safe distance based on obstacle type
	let safeDistance;
	if (data.isFloating) {
	safeDistance = data.size + 4;
	} else if (data.type === 'pillar') {
	safeDistance = data.radius + 3;
	} else {
	safeDistance = Math.max(data.width, data.depth) / 2 + 3;
	}

	if (distance < safeDistance * 2) {
	// Calculate repulsion force (inverse square law)
	const repulsionForce = toDrone.normalize().multiplyScalar(
	Math.pow(safeDistance * 2 / distance, 3)
	);

	// Weight by urgency and obstacle velocity
	let weight = 1.0;
	if (data.isFloating && data.velocity) {
	const approachSpeed = -data.velocity.dot(toDrone.normalize());
	weight += Math.max(0, approachSpeed) * 0.5;
	}

	avoidance.add(repulsionForce.multiplyScalar(weight));
	}
	}

	return avoidance.length() > 0 ? avoidance.normalize() : avoidance;
	}

	function getCurrentState() {
	const currentTarget = FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep];
	return {
	dronePosition: FSD_CONFIG.dronePosition.clone(),
	droneVelocity: FSD_CONFIG.droneVelocity.clone(),
	target: currentTarget,
	distanceToTarget: FSD_CONFIG.dronePosition.distanceTo(
	currentTarget === 'CENTER' ?
	FSD_CONFIG.portalPositions['CENTER'] :
	FSD_CONFIG.portalPositions[currentTarget]
	),
	patternStep: FSD_CONFIG.currentStep
	};
	}

	function sampleFromDistribution(probabilities) {
	const rand = Math.random();
	let cumulative = 0;
	for (let i = 0; i < probabilities.length; i++) {
	cumulative += probabilities[i];
	if (rand <= cumulative) {
	return i;
	}
	}
	return probabilities.length - 1;
	}

	function calculateImmediateReward(distanceToTarget, stepDistance, delta) {
	let reward = 0;

	// Reward for moving toward target
	const distanceImprovement = FSD_CONFIG.lastDistanceToTarget - distanceToTarget;
	reward += distanceImprovement * 0.5;

	// Reward for efficient movement (not too slow, not too fast)
	const speed = stepDistance / delta;
	const optimalSpeed = 8;
	const speedReward = Math.exp(-Math.pow(speed - optimalSpeed, 2) / 50);
	reward += speedReward * 0.1;

	// Small penalty for time passing
	reward -= 0.01;

	return reward;
	}

	function addEnhancedReward(reward, source) {
	FSD_CONFIG.cumulativeReward += reward;

	// Update reward buffer for averaging
	FSD_CONFIG.rewardBuffer.push({
	reward: reward,
	source: source,
	timestamp: Date.now(),
	step: FSD_CONFIG.trainingStep
	});

	// Keep buffer size manageable
	if (FSD_CONFIG.rewardBuffer.length > 1000) {
	FSD_CONFIG.rewardBuffer.shift();
	}

	// Calculate average reward
	const recentRewards = FSD_CONFIG.rewardBuffer.slice(-100);
	FSD_CONFIG.avgReward = recentRewards.reduce((sum, r) => sum + r.reward, 0) / recentRewards.length;
	}

	function recordEnhancedExperience(state, actionIndex, actionProbability) {
	const experience = {
	state: state,
	action: actionIndex,
	oldProbability: actionProbability,
	reward: FSD_CONFIG.cumulativeReward,
	timestamp: Date.now(),
	step: FSD_CONFIG.trainingStep,
	epoch: FSD_CONFIG.epoch,
	iteration: FSD_CONFIG.iteration
	};

	FSD_CONFIG.memoryBuffer.push(experience);
	FSD_CONFIG.actionHistory.push(actionIndex);

	// Keep memory bounded
	if (FSD_CONFIG.memoryBuffer.length > FSD_CONFIG.maxMemorySize) {
	FSD_CONFIG.memoryBuffer.shift();
	}
	if (FSD_CONFIG.actionHistory.length > 100) {
	FSD_CONFIG.actionHistory.shift();
	}
	}

	function trainEnhancedNetwork() {
	if (FSD_CONFIG.memoryBuffer.length < FSD_CONFIG.batchSize) return;

	// Sample random batch
	const batch = [];
	for (let i = 0; i < FSD_CONFIG.batchSize; i++) {
	const randomIndex = Math.floor(Math.random() * FSD_CONFIG.memoryBuffer.length);
	batch.push(FSD_CONFIG.memoryBuffer[randomIndex]);
	}

	// Add next states
	for (const exp of batch) {
	exp.nextState = getCurrentState();
	exp.done = FSD_CONFIG.patternCompleted;
	}

	// Train network
	const losses = enhancedNetwork.trainBatch(batch);

	// Update metrics
	FSD_CONFIG.policyLoss = losses.policyLoss;
	FSD_CONFIG.valueLoss = losses.valueLoss;
	FSD_CONFIG.tdError = losses.tdError;
	FSD_CONFIG.trainSteps++;

	// Update learning parameters
	updateLearningParameters();
	}

	function updateLearningParameters() {
	// Decay exploration rate
	FSD_CONFIG.explorationRate = Math.max(0.05, FSD_CONFIG.explorationRate * 0.999);

	// Adaptive learning rate based on performance
	const successRate = FSD_CONFIG.successHistory.length > 0 ?
	FSD_CONFIG.successHistory.filter(s => s).length / FSD_CONFIG.successHistory.length : 0;

	if (successRate > 0.7) {
	FSD_CONFIG.learningRate = Math.min(0.005, FSD_CONFIG.learningRate * 1.01);
	} else if (successRate < 0.3) {
	FSD_CONFIG.learningRate = Math.max(0.0001, FSD_CONFIG.learningRate * 0.99);
	}

	// Update network learning rate
	enhancedNetwork.learningRate = FSD_CONFIG.learningRate;
	}

	function handleEnhancedStuckRecovery() {
	FSD_CONFIG.stuckTimer = 0;

	// Enhanced recovery: move away from current position
	const recoveryAngle = Math.random() * Math.PI * 2;
	const recoveryDistance = 8;

	FSD_CONFIG.dronePosition.add(new THREE.Vector3(
	Math.cos(recoveryAngle) * recoveryDistance,
	3,
	Math.sin(recoveryAngle) * recoveryDistance
	));

	// Increase exploration temporarily
	FSD_CONFIG.explorationRate = Math.min(0.5, FSD_CONFIG.explorationRate * 1.2);

	showMessage('ENHANCED RECOVERY', 'Drone repositioned and exploration increased');
	}

	function checkEnhancedCollisions() {
	for (const obstacle of FSD_CONFIG.obstacles) {
	if (!obstacle \|\| !obstacle.position) continue;

	const data = obstacle.userData;
	const distance = FSD_CONFIG.dronePosition.distanceTo(obstacle.position);

	let collisionDistance;
	if (data.isFloating) {
	collisionDistance = data.size + 0.8;
	} else if (data.type === 'pillar') {
	collisionDistance = data.radius + 0.8;
	} else {
	collisionDistance = Math.max(data.width, data.depth) / 2 + 0.8;
	}

	if (distance < collisionDistance) {
	handleEnhancedCollision(obstacle);
	return true;
	}
	}
	return false;
	}

	function handleEnhancedCollision(obstacle) {
	if (!FSD_CONFIG.isTraining) return;

	FSD_CONFIG.collisionCount++;

	const data = obstacle.userData;

	// Visual feedback
	const originalColor = obstacle.material.color.getHex();
	obstacle.material.color.setHex(0xff0000);
	if (obstacle.material.emissive) {
	obstacle.material.emissive.setHex(0x330000);
	}

	setTimeout(() => {
	try {
	obstacle.material.color.setHex(data.originalColor \|\| originalColor);
	if (obstacle.material.emissive) {
	obstacle.material.emissive.setHex(0x000000);
	}
	} catch (e) {}
	}, 500);

	// Enhanced bounce physics
	const normal = FSD_CONFIG.dronePosition.clone().sub(obstacle.position).normalize();
	const bounceStrength = 3.0;
	FSD_CONFIG.dronePosition.add(normal.multiplyScalar(bounceStrength));

	// Reduce velocity
	FSD_CONFIG.droneVelocity.multiplyScalar(0.2);

	// Add to avoidance memory with enhanced data
	FSD_CONFIG.avoidanceMemory.push({
	position: obstacle.position.clone(),
	type: data.type,
	size: data.size \|\| data.radius \|\| 2,
	velocity: data.velocity ? data.velocity.clone() : new THREE.Vector3(0, 0, 0),
	timestamp: Date.now(),
	severity: 1.0
	});

	// Keep memory size limited
	if (FSD_CONFIG.avoidanceMemory.length > 50) {
	FSD_CONFIG.avoidanceMemory.shift();
	}
	}

	function updateAvoidanceMemory() {
	// Decay avoidance memory over time
	const currentTime = Date.now();
	FSD_CONFIG.avoidanceMemory = FSD_CONFIG.avoidanceMemory.filter(memory => {
	const age = currentTime - memory.timestamp;
	return age < 10000; // Keep for 10 seconds
	});
	}

	function logEnhancedTelemetry(actionIndex, distanceToTarget) {
	try {
	if (!FSD_CONFIG.isTraining \|\| FSD_CONFIG.isPaused) return;

	const currentTarget = FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep];
	const targetPos = currentTarget === 'CENTER' ?
	FSD_CONFIG.portalPositions['CENTER'] :
	FSD_CONFIG.portalPositions[currentTarget];

	const telemetry = {
	timestamp: Date.now(),
	frame: frameCount++,
	epoch: FSD_CONFIG.epoch,
	iteration: FSD_CONFIG.iteration,
	trainingStep: FSD_CONFIG.trainingStep,

	pattern_step: FSD_CONFIG.currentStep,
	pattern_target: currentTarget,

	position: [FSD_CONFIG.dronePosition.x, FSD_CONFIG.dronePosition.y, FSD_CONFIG.dronePosition.z],
	velocity: [FSD_CONFIG.droneVelocity.x, FSD_CONFIG.droneVelocity.y, FSD_CONFIG.droneVelocity.z],
	rotation: [droneGroup.rotation.x, droneGroup.rotation.y, droneGroup.rotation.z],

	target_position: [targetPos.x, targetPos.y, targetPos.z],
	distance_to_target: distanceToTarget,

	// Neural network metrics
	q_value: enhancedNetwork.getValue(getCurrentState()),
	cumulative_reward: FSD_CONFIG.cumulativeReward,
	exploration_rate: FSD_CONFIG.explorationRate,
	learning_rate: FSD_CONFIG.learningRate,
	td_error: FSD_CONFIG.tdError,
	policy_loss: FSD_CONFIG.policyLoss,
	value_loss: FSD_CONFIG.valueLoss,

	// Performance metrics
	collisions: FSD_CONFIG.collisionCount,
	path_length: FSD_CONFIG.totalPathLength,
	crossing_count: FSD_CONFIG.crossingCount,
	stuck_timer: FSD_CONFIG.stuckTimer,
	avoidance_memory: FSD_CONFIG.avoidanceMemory.length,

	// Environment info
	obstacle_count: FSD_CONFIG.obstacles.length,
	floating_obstacle_count: FSD_CONFIG.floatingObstacles.length,
	difficulty_level: FSD_CONFIG.environment.difficultyLevel,

	// Pattern progress
	pattern_time: (Date.now() - FSD_CONFIG.patternStartTime) / 1000,
	pattern_completed: FSD_CONFIG.patternCompleted,

	// Training info
	memory_buffer_size: FSD_CONFIG.memoryBuffer.length,
	successful_paths_count: FSD_CONFIG.successfulPaths.length,
	train_steps: FSD_CONFIG.trainSteps,
	avg_reward: FSD_CONFIG.avgReward
	};

	FSD_CONFIG.telemetryBuffer.push(telemetry);

	if (FSD_CONFIG.telemetryBuffer.length > FSD_CONFIG.maxBufferSize) {
	FSD_CONFIG.telemetryBuffer = FSD_CONFIG.telemetryBuffer.slice(-FSD_CONFIG.maxBufferSize);
	}

	} catch (error) {
	console.error('Enhanced telemetry error:', error);
	}
	}

	// ==================== ENHANCED TARGET REACHED HANDLER ====================
	function handleTargetReached(targetName) {
	if (targetName === 'CENTER') {
	completeEnhancedPattern();
	return;
	}

	const portal = FSD_CONFIG.portals[targetName];
	if (portal && !portal.userData.collected) {
	portal.userData.collected = true;

	// Enhanced visual feedback
	portal.children.forEach(child => {
	if (child.material) {
	child.material.color.setHex(0x00aa00);
	if (child.material.emissive) {
	child.material.emissive.setHex(0x003300);
	}
	}
	});

	addEnhancedReward(25, 'portal_reached');
	}

	FSD_CONFIG.currentStep++;

	if (FSD_CONFIG.currentStep < FSD_CONFIG.patternSequence.length) {
	const nextTargetName = FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep];

	if (nextTargetName === 'CENTER') {
	FSD_CONFIG.activePortal = null;
	showMessage('RETURN TO CENTER', 'Complete pattern by returning to center');
	} else {
	FSD_CONFIG.activePortal = FSD_CONFIG.portals[nextTargetName];
	showMessage('NEXT TARGET', `${targetName} → ${nextTargetName}`);
	}

	addEnhancedReward(10, 'pattern_progress');
	updateUI();
	}
	}

	function completeEnhancedPattern() {
	FSD_CONFIG.patternCompleted = true;
	const elapsedTime = (Date.now() - FSD_CONFIG.patternStartTime) / 1000;

	// Calculate enhanced score
	const idealPath = calculateIdealPathLength();
	const efficiency = FSD_CONFIG.totalPathLength > 0 ?
	(idealPath / FSD_CONFIG.totalPathLength) * 100 : 0;
	FSD_CONFIG.efficiencyScore = efficiency;

	// Time bonus (faster = better)
	const timeBonus = Math.max(0, 45 - elapsedTime) * 0.8;

	// Collision penalty
	const collisionPenalty = FSD_CONFIG.collisionCount * 3;

	// Efficiency bonus
	const efficiencyBonus = efficiency > 85 ? 20 :
	efficiency > 70 ? 10 : 0;

	// Calculate epoch score
	FSD_CONFIG.epochScore = efficiency - collisionPenalty + timeBonus + efficiencyBonus;

	// Update best time
	if (elapsedTime < FSD_CONFIG.patternBestTime) {
	FSD_CONFIG.patternBestTime = elapsedTime;
	}

	// Record success
	const success = FSD_CONFIG.collisionCount === 0 && efficiency > 80;
	FSD_CONFIG.successHistory.push(success);
	if (FSD_CONFIG.successHistory.length > 20) FSD_CONFIG.successHistory.shift();

	// Large reward for completing pattern
	addEnhancedReward(100 + timeBonus + efficiencyBonus - collisionPenalty, 'pattern_complete');

	// Record successful path
	const successfulPath = {
	epoch: FSD_CONFIG.epoch,
	iteration: FSD_CONFIG.iteration,
	time: elapsedTime,
	collisions: FSD_CONFIG.collisionCount,
	pathLength: FSD_CONFIG.totalPathLength,
	efficiency: efficiency,
	score: FSD_CONFIG.epochScore,
	cumulativeReward: FSD_CONFIG.cumulativeReward,
	explorationRate: FSD_CONFIG.explorationRate,
	timestamp: Date.now()
	};

	FSD_CONFIG.successfulPaths.push(successfulPath);

	// Keep only recent successful paths
	if (FSD_CONFIG.successfulPaths.length > 30) {
	FSD_CONFIG.successfulPaths.shift();
	}

	// Add to reward per epoch tracking
	FSD_CONFIG.rewardPerEpoch.push(FSD_CONFIG.cumulativeReward);
	if (FSD_CONFIG.rewardPerEpoch.length > 10) {
	FSD_CONFIG.rewardPerEpoch.shift();
	}

	showMessage('ENHANCED PATTERN COMPLETE!',
	`Time: ${elapsedTime.toFixed(2)}s \| Score: ${FSD_CONFIG.epochScore.toFixed(2)} \| Efficiency: ${efficiency.toFixed(1)}%`);

	// Update learning parameters based on performance
	updateEnhancedLearningParameters(success, efficiency, elapsedTime);

	updateUI();

	// Auto-start next iteration after delay
	setTimeout(() => {
	if (FSD_CONFIG.isTraining && !FSD_CONFIG.isPaused) {
	FSD_CONFIG.iteration++;
	startPattern();
	}
	}, 2500);
	}

	function updateEnhancedLearningParameters(success, efficiency, elapsedTime) {
	// Decrease exploration rate
	FSD_CONFIG.explorationRate = Math.max(0.05, FSD_CONFIG.explorationRate * 0.97);

	// Adjust learning rate based on performance
	if (success && efficiency > 75 && elapsedTime < FSD_CONFIG.patternBestTime * 1.3) {
	FSD_CONFIG.learningRate = Math.min(0.005, FSD_CONFIG.learningRate * 1.05);
	} else if (!success \|\| efficiency < 60) {
	FSD_CONFIG.learningRate = Math.max(0.0001, FSD_CONFIG.learningRate * 0.95);
	}

	// Update network learning rate
	enhancedNetwork.learningRate = FSD_CONFIG.learningRate;
	}

	function calculateIdealPathLength() {
	let totalDistance = 0;
	let lastPosition = FSD_CONFIG.portalPositions['CENTER'];

	for (const portalName of FSD_CONFIG.patternSequence) {
	const position = FSD_CONFIG.portalPositions[portalName];
	totalDistance += lastPosition.distanceTo(position);
	lastPosition = position;
	}

	return totalDistance;
	}

	// ==================== ENHANCED UI UPDATES ====================
	function updateUI() {
	try {
	// Enhanced telemetry display
	document.getElementById('altitude').textContent = FSD_CONFIG.dronePosition.y.toFixed(1) + 'm';
	document.getElementById('speed').textContent = FSD_CONFIG.droneVelocity.length().toFixed(1) + 'm/s';
	document.getElementById('velocity').textContent =
	`${FSD_CONFIG.droneVelocity.x.toFixed(1)}/${FSD_CONFIG.droneVelocity.y.toFixed(1)}/${FSD_CONFIG.droneVelocity.z.toFixed(1)}`;

	// Distance to target
	const currentTarget = FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep];
	const targetPos = currentTarget === 'CENTER' ?
	FSD_CONFIG.portalPositions['CENTER'] :
	FSD_CONFIG.portalPositions[currentTarget];
	const distance = FSD_CONFIG.dronePosition.distanceTo(targetPos);
	document.getElementById('distanceToTarget').textContent = distance.toFixed(1) + 'm';

	document.getElementById('collisionCount').textContent = FSD_CONFIG.collisionCount;
	document.getElementById('pathLength').textContent = FSD_CONFIG.totalPathLength.toFixed(1) + 'm';
	document.getElementById('crossingCount').textContent = FSD_CONFIG.crossingCount;

	// Progress info
	document.getElementById('epochNumber').textContent = FSD_CONFIG.epoch;
	document.getElementById('iterationNumber').textContent = FSD_CONFIG.iteration;
	document.getElementById('trainingStep').textContent = FSD_CONFIG.trainingStep;
	document.getElementById('patternStep').textContent = `${FSD_CONFIG.currentStep + 1}/${FSD_CONFIG.patternSequence.length}`;

	const nextPortal = FSD_CONFIG.currentStep < FSD_CONFIG.patternSequence.length ?
	FSD_CONFIG.patternSequence[FSD_CONFIG.currentStep] : 'COMPLETE';
	document.getElementById('nextPortal').textContent = nextPortal;

	// Progress bar
	const progress = (FSD_CONFIG.currentStep / FSD_CONFIG.patternSequence.length) * 100;
	document.getElementById('patternProgressBar').style.width = `${progress}%`;

	// Time
	const elapsedTime = FSD_CONFIG.patternStartTime > 0 ?
	((Date.now() - FSD_CONFIG.patternStartTime) / 1000).toFixed(1) : '0.0';
	document.getElementById('patternTime').textContent = elapsedTime + 's';
	document.getElementById('bestTime').textContent =
	FSD_CONFIG.patternBestTime === Infinity ? '∞' : FSD_CONFIG.patternBestTime.toFixed(2) + 's';
	document.getElementById('epochScore').textContent = FSD_CONFIG.epochScore.toFixed(2);

	// Efficiency
	const idealPath = calculateIdealPathLength();
	const efficiency = FSD_CONFIG.totalPathLength > 0 ?
	(idealPath / FSD_CONFIG.totalPathLength * 100).toFixed(1) : '0.0';
	document.getElementById('efficiency').textContent = efficiency + '%';

	// Pattern panel
	document.getElementById('patternSequence').textContent =
	FSD_CONFIG.patternSequence.join('→');
	document.getElementById('avoidanceScore').textContent =
	FSD_CONFIG.avoidanceMemory.length > 0 ?
	(FSD_CONFIG.avoidanceMemory.length / 50).toFixed(2) : '0.00';

	// Success rate
	const successRate = FSD_CONFIG.successHistory.length > 0 ?
	(FSD_CONFIG.successHistory.filter(s => s).length / FSD_CONFIG.successHistory.length * 100).toFixed(0) : '0';
	document.getElementById('successRate').textContent = successRate + '%';

	document.getElementById('difficultyLevel').textContent = FSD_CONFIG.environment.difficultyLevel.toFixed(1);

	// FSD panel
	document.getElementById('networkArch').textContent = enhancedNetwork.layers.join('-');
	document.getElementById('learningRate').textContent = FSD_CONFIG.learningRate.toFixed(4);
	document.getElementById('explorationRate').textContent = FSD_CONFIG.explorationRate.toFixed(3);
	document.getElementById('qValue').textContent = enhancedNetwork.getValue(getCurrentState()).toFixed(3);
	document.getElementById('tdError').textContent = FSD_CONFIG.tdError.toFixed(4);
	document.getElementById('memorySize').textContent = FSD_CONFIG.memoryBuffer.length;
	document.getElementById('batchSize').textContent = FSD_CONFIG.batchSize;

	// Reward panel
	document.getElementById('cumulativeReward').textContent = FSD_CONFIG.cumulativeReward.toFixed(1);
	document.getElementById('avgReward').textContent = FSD_CONFIG.avgReward.toFixed(2);

	const recentRewards = FSD_CONFIG.rewardPerEpoch.slice(-5);
	const avgRewardPerEpoch = recentRewards.length > 0 ?
	recentRewards.reduce((a, b) => a + b, 0) / recentRewards.length : 0;
	document.getElementById('rewardPerEpoch').textContent = avgRewardPerEpoch.toFixed(1);

	document.getElementById('policyLoss').textContent = FSD_CONFIG.policyLoss.toFixed(4);
	document.getElementById('valueLoss').textContent = FSD_CONFIG.valueLoss.toFixed(4);
	document.getElementById('trainSteps').textContent = FSD_CONFIG.trainSteps;

	// Status
	const statusDot = document.getElementById('statusDot');
	const statusText = document.getElementById('statusText');

	if (FSD_CONFIG.isPaused) {
	statusDot.style.background = '#ff0';
	statusText.textContent = 'PAUSED';
	} else if (FSD_CONFIG.isTraining) {
	statusDot.style.background = '#0f0';
	statusText.textContent = `EPOCH ${FSD_CONFIG.epoch} \| ITER ${FSD_CONFIG.iteration} \| STEP ${FSD_CONFIG.trainingStep}`;
	} else {
	statusDot.style.background = '#f00';
	statusText.textContent = 'ENHANCED FSD READY';
	}

	// Update visualizers
	drawEnhancedWave();
	drawEnhancedPath();
	drawNeuralNetwork();

	} catch (error) {
	console.error('Enhanced UI update error:', error);
	}
	}

	// ==================== ENHANCED VISUALIZERS ====================
	const waveCanvas = document.getElementById('waveVisualizer');
	const waveCtx = waveCanvas.getContext('2d');
	const pathCanvas = document.getElementById('pathVisualizer');
	const pathCtx = pathCanvas.getContext('2d');
	const nnCanvas = document.getElementById('nnVisualizer');
	const nnCtx = nnCanvas.getContext('2d');

	let waveData = [];
	let pathData = [];

	function drawEnhancedWave() {
	if (!waveCanvas \|\| !waveCtx) return;

	waveCanvas.width = waveCanvas.offsetWidth;
	waveCanvas.height = waveCanvas.offsetHeight;

	// Clear with gradient
	const gradient = waveCtx.createLinearGradient(0, 0, waveCanvas.width, 0);
	gradient.addColorStop(0, 'rgba(0, 10, 0, 0.8)');
	gradient.addColorStop(1, 'rgba(0, 20, 0, 0.6)');
	waveCtx.fillStyle = gradient;
	waveCtx.fillRect(0, 0, waveCanvas.width, waveCanvas.height);

	// Enhanced grid
	waveCtx.strokeStyle = 'rgba(0, 255, 0, 0.15)';
	waveCtx.lineWidth = 1;

	for (let x = 0; x < waveCanvas.width; x += 25) {
	waveCtx.beginPath();
	waveCtx.moveTo(x, 0);
	waveCtx.lineTo(x, waveCanvas.height);
	waveCtx.stroke();
	}

	for (let y = 0; y < waveCanvas.height; y += 25) {
	waveCtx.beginPath();
	waveCtx.moveTo(0, y);
	waveCtx.lineTo(waveCanvas.width, y);
	waveCtx.stroke();
	}

	// Add current data
	waveData.push({
	altitude: FSD_CONFIG.dronePosition.y,
	speed: FSD_CONFIG.droneVelocity.length(),
	reward: FSD_CONFIG.cumulativeReward,
	qValue: enhancedNetwork.getValue(getCurrentState()),
	time: Date.now()
	});

	if (waveData.length > 120) waveData.shift();

	// Draw multiple metrics
	if (waveData.length > 1) {
	// Speed line (green)
	waveCtx.strokeStyle = '#0f0';
	waveCtx.lineWidth = 2;
	waveCtx.beginPath();

	waveData.forEach((point, i) => {
	const x = (i / waveData.length) * waveCanvas.width;
	const y = waveCanvas.height - (point.speed / 25 * waveCanvas.height);

	if (i === 0) waveCtx.moveTo(x, y);
	else waveCtx.lineTo(x, y);
	});
	waveCtx.stroke();

	// Reward line (magenta)
	waveCtx.strokeStyle = '#ff00ff';
	waveCtx.lineWidth = 1.5;
	waveCtx.beginPath();

	const rewards = waveData.map(p => p.reward);
	const minReward = Math.min(...rewards);
	const maxReward = Math.max(...rewards);
	const rewardRange = Math.max(1, maxReward - minReward);

	waveData.forEach((point, i) => {
	const x = (i / waveData.length) * waveCanvas.width;
	const normalizedReward = (point.reward - minReward) / rewardRange;
	const y = waveCanvas.height - (normalizedReward * waveCanvas.height * 0.7);

	if (i === 0) waveCtx.moveTo(x, y);
	else waveCtx.lineTo(x, y);
	});
	waveCtx.stroke();

	// Q-value line (cyan)
	waveCtx.strokeStyle = '#0ff';
	waveCtx.lineWidth = 1.2;
	waveCtx.beginPath();

	const qValues = waveData.map(p => p.qValue);
	const minQ = Math.min(...qValues);
	const maxQ = Math.max(...qValues);
	const qRange = Math.max(0.1, maxQ - minQ);

	waveData.forEach((point, i) => {
	const x = (i / waveData.length) * waveCanvas.width;
	const normalizedQ = (point.qValue - minQ) / qRange;
	const y = waveCanvas.height - (normalizedQ * waveCanvas.height * 0.6);

	if (i === 0) waveCtx.moveTo(x, y);
	else waveCtx.lineTo(x, y);
	});
	waveCtx.stroke();

	// Draw current values
	const current = waveData[waveData.length - 1];
	waveCtx.fillStyle = '#0f0';
	waveCtx.font = '8px monospace';
	waveCtx.fillText(`Speed: ${current.speed.toFixed(1)}`, 5, 12);
	waveCtx.fillStyle = '#ff00ff';
	waveCtx.fillText(`Reward: ${current.reward.toFixed(1)}`, 5, 24);
	waveCtx.fillStyle = '#0ff';
	waveCtx.fillText(`Q: ${current.qValue.toFixed(3)}`, 5, 36);
	}
	}

	function drawEnhancedPath() {
	if (!pathCanvas \|\| !pathCtx) return;

	pathCanvas.width = pathCanvas.offsetWidth;
	pathCanvas.height = pathCanvas.offsetHeight;

	// Clear with gradient
	const gradient = pathCtx.createRadialGradient(
	pathCanvas.width/2, pathCanvas.height/2, 0,
	pathCanvas.width/2, pathCanvas.height/2, pathCanvas.width/2
	);
	gradient.addColorStop(0, 'rgba(0, 20, 20, 0.7)');
	gradient.addColorStop(1, 'rgba(0, 10, 10, 0.9)');
	pathCtx.fillStyle = gradient;
	pathCtx.fillRect(0, 0, pathCanvas.width, pathCanvas.height);

	// Draw grid for 60x60 area
	const scale = Math.min(pathCanvas.width, pathCanvas.height) / 60;
	const offsetX = pathCanvas.width / 2;
	const offsetY = pathCanvas.height / 2;

	// Enhanced grid
	pathCtx.strokeStyle = 'rgba(0, 255, 255, 0.15)';
	pathCtx.lineWidth = 0.5;

	for (let x = -30; x <= 30; x += 5) {
	const screenX = offsetX + x * scale;
	pathCtx.beginPath();
	pathCtx.moveTo(screenX, 0);
	pathCtx.lineTo(screenX, pathCanvas.height);
	pathCtx.stroke();
	}

	for (let y = -30; y <= 30; y += 5) {
	const screenY = offsetY + y * scale;
	pathCtx.beginPath();
	pathCtx.moveTo(0, screenY);
	pathCtx.lineTo(pathCanvas.width, screenY);
	pathCtx.stroke();
	}

	// Draw portals
	for (const [name, pos] of Object.entries(FSD_CONFIG.portalPositions)) {
	let color;
	if (name === 'CENTER') {
	color = '#ff0';
	} else {
	color = FSD_CONFIG.portals[name]?.userData.collected ? '#0a0' : '#f00';
	}

	const screenX = offsetX + pos.x * scale;
	const screenY = offsetY - pos.z * scale;

	// Portal glow effect
	pathCtx.shadowColor = color;
	pathCtx.shadowBlur = 10;
	pathCtx.fillStyle = color;
	pathCtx.beginPath();
	pathCtx.arc(screenX, screenY, 6, 0, Math.PI * 2);
	pathCtx.fill();
	pathCtx.shadowBlur = 0;

	// Portal border
	pathCtx.strokeStyle = '#fff';
	pathCtx.lineWidth = 1;
	pathCtx.beginPath();
	pathCtx.arc(screenX, screenY, 6, 0, Math.PI * 2);
	pathCtx.stroke();

	// Label
	pathCtx.fillStyle = '#fff';
	pathCtx.font = '9px monospace';
	pathCtx.textAlign = 'center';
	pathCtx.fillText(name, screenX, screenY - 12);
	}

	// Draw drone path with enhanced visualization
	if (pathData.length > 1) {
	// Draw path with gradient based on speed and time
	for (let i = 1; i < pathData.length; i++) {
	const prev = pathData[i - 1];
	const current = pathData[i];

	const screenX1 = offsetX + prev.x * scale;
	const screenY1 = offsetY - prev.z * scale;
	const screenX2 = offsetX + current.x * scale;
	const screenY2 = offsetY - current.z * scale;

	// Calculate line properties based on time and speed
	const timeDiff = current.time - prev.time;
	const distance = Math.sqrt(Math.pow(current.x - prev.x, 2) + Math.pow(current.z - prev.z, 2));
	const speed = timeDiff > 0 ? distance / timeDiff * 1000 : 0;

	// Color based on speed (blue = slow, green = medium, red = fast)
	let r, g, b;
	if (speed < 5) {
	r = 0; g = Math.floor(255 * (speed / 5)); b = 255;
	} else if (speed < 10) {
	r = Math.floor(255 * ((speed - 5) / 5)); g = 255; b = 0;
	} else {
	r = 255; g = Math.floor(255 * (1 - (speed - 10) / 10)); b = 0;
	}

	// Width based on recency
	const age = Date.now() - current.time;
	const width = Math.max(1, 3 * (1 - age / 10000));

	pathCtx.strokeStyle = `rgb(${r}, ${g}, ${b})`;
	pathCtx.lineWidth = width;
	pathCtx.beginPath();
	pathCtx.moveTo(screenX1, screenY1);
	pathCtx.lineTo(screenX2, screenY2);
	pathCtx.stroke();
	}

	// Draw current position
	const currentX = offsetX + FSD_CONFIG.dronePosition.x * scale;
	const currentY = offsetY - FSD_CONFIG.dronePosition.z * scale;

	// Drone indicator with orientation
	pathCtx.fillStyle = '#0f0';
	pathCtx.beginPath();
	pathCtx.arc(currentX, currentY, 5, 0, Math.PI * 2);
	pathCtx.fill();

	pathCtx.strokeStyle = '#0f0';
	pathCtx.lineWidth = 1;
	pathCtx.beginPath();
	pathCtx.arc(currentX, currentY, 5, 0, Math.PI * 2);
	pathCtx.stroke();

	// Draw orientation line
	const forward = new THREE.Vector3(0, 0, -1);
	forward.applyQuaternion(droneGroup.quaternion);
	const forwardX = forward.x * 8;
	const forwardZ = forward.z * 8;

	pathCtx.strokeStyle = '#0ff';
	pathCtx.lineWidth = 2;
	pathCtx.beginPath();
	pathCtx.moveTo(currentX, currentY);
	pathCtx.lineTo(currentX + forwardX * scale, currentY - forwardZ * scale);
	pathCtx.stroke();

	// Draw velocity vector
	if (FSD_CONFIG.droneVelocity.length() > 0.1) {
	const velX = FSD_CONFIG.droneVelocity.x * 2;
	const velZ = FSD_CONFIG.droneVelocity.z * 2;

	pathCtx.strokeStyle = '#ff0';
	pathCtx.lineWidth = 1.5;
	pathCtx.beginPath();
	pathCtx.moveTo(currentX, currentY);
	pathCtx.lineTo(currentX + velX * scale, currentY - velZ * scale);
	pathCtx.stroke();

	// Velocity magnitude circle
	const speed = FSD_CONFIG.droneVelocity.length();
	const speedRadius = Math.min(12, speed * 1.5);
	pathCtx.strokeStyle = 'rgba(255, 255, 0, 0.5)';
	pathCtx.lineWidth = 1;
	pathCtx.beginPath();
	pathCtx.arc(currentX, currentY, speedRadius, 0, Math.PI * 2);
	pathCtx.stroke();
	}
	}

	// Add current position to path
	pathData.push({
	x: FSD_CONFIG.dronePosition.x,
	z: FSD_CONFIG.dronePosition.z,
	time: Date.now()
	});

	// Keep recent path (more points for better visualization)
	if (pathData.length > 800) {
	pathData = pathData.slice(-800);
	}
	}

	function drawNeuralNetwork() {
	if (!nnCanvas \|\| !nnCtx) return;

	nnCanvas.width = nnCanvas.offsetWidth;
	nnCanvas.height = nnCanvas.offsetHeight;

	// Clear
	nnCtx.fillStyle = 'rgba(0, 10, 10, 0.8)';
	nnCtx.fillRect(0, 0, nnCanvas.width, nnCanvas.height);

	// Network architecture visualization
	const layers = enhancedNetwork.layers;
	const neuronRadius = 3;
	const layerSpacing = (nnCanvas.width - 40) / (layers.length - 1);
	const maxNeurons = Math.max(...layers);

	// Draw neurons
	for (let l = 0; l < layers.length; l++) {
	const neuronCount = layers[l];
	const x = 20 + l * layerSpacing;

	for (let n = 0; n < neuronCount; n++) {
	const y = nnCanvas.height / 2 + (n - neuronCount/2) * (nnCanvas.height / (maxNeurons + 2));

	// Neuron activation level (simulated)
	const activation = Math.random() * 0.5 + 0.3; // Simulated for visualization

	// Draw neuron
	const gradient = nnCtx.createRadialGradient(x, y, 0, x, y, neuronRadius * 2);
	gradient.addColorStop(0, `rgba(255, ${Math.floor(255 * activation)}, 255, 0.8)`);
	gradient.addColorStop(1, `rgba(128, ${Math.floor(128 * activation)}, 255, 0.3)`);

	nnCtx.fillStyle = gradient;
	nnCtx.beginPath();
	nnCtx.arc(x, y, neuronRadius, 0, Math.PI * 2);
	nnCtx.fill();

	// Neuron border
	nnCtx.strokeStyle = `rgba(255, ${Math.floor(255 * activation)}, 255, 0.6)`;
	nnCtx.lineWidth = 1;
	nnCtx.beginPath();
	nnCtx.arc(x, y, neuronRadius, 0, Math.PI * 2);
	nnCtx.stroke();
	}
	}

	// Draw layer labels
	nnCtx.fillStyle = '#ff00ff';
	nnCtx.font = '8px monospace';
	nnCtx.textAlign = 'center';

	for (let l = 0; l < layers.length; l++) {
	const x = 20 + l * layerSpacing;
	nnCtx.fillText(`L${l+1}: ${layers[l]}`, x, 15);
	}

	// Draw network info
	nnCtx.fillStyle = '#0ff';
	nnCtx.font = '7px monospace';
	nnCtx.textAlign = 'left';
	nnCtx.fillText(`Learning: ${FSD_CONFIG.learningRate.toFixed(4)}`, 5, nnCanvas.height - 25);
	nnCtx.fillText(`Exploration: ${FSD_CONFIG.explorationRate.toFixed(3)}`, 5, nnCanvas.height - 15);
	nnCtx.fillText(`Memory: ${FSD_CONFIG.memoryBuffer.length}/${FSD_CONFIG.maxMemorySize}`, 5, nnCanvas.height - 5);
	}

	// ==================== MESSAGE SYSTEM ====================
	function showMessage(title, detail) {
	const overlay = document.getElementById('messageOverlay');
	const titleEl = document.getElementById('messageTitle');
	const detailEl = document.getElementById('messageDetail');

	titleEl.textContent = title;
	detailEl.textContent = detail;

	overlay.style.display = 'block';

	setTimeout(() => {
	overlay.style.display = 'none';
	}, 2000);
	}

	// ==================== CAMERA CONTROL ====================
	function updateCamera() {
	if (FSD_CONFIG.cameraMode === 'first') {
	// First-person view
	camera.position.copy(droneGroup.position);
	camera.position.y += 0.3;
	camera.position.z += 0.8;
	camera.rotation.copy(droneGroup.rotation);
	} else {
	// Third-person view with smooth following
	const cameraOffset = new THREE.Vector3(0, 12, 20);
	const idealCameraPos = droneGroup.position.clone().add(cameraOffset);
	camera.position.lerp(idealCameraPos, 0.1);
	camera.lookAt(droneGroup.position);
	}
	}

	// ==================== ENHANCED CONTROL FUNCTIONS ====================
	function startFSDTraining() {
	if (FSD_CONFIG.isTraining && !FSD_CONFIG.isPaused) return;

	if (FSD_CONFIG.isTraining && FSD_CONFIG.isPaused) {
	FSD_CONFIG.isPaused = false;
	clock.start();
	document.getElementById('pauseBtn').classList.remove('active');
	document.getElementById('startBtn').classList.add('active');
	} else {
	FSD_CONFIG.isTraining = true;
	FSD_CONFIG.isPaused = false;
	clock.start();
	startPattern();
	document.getElementById('startBtn').classList.add('active');
	document.getElementById('pauseBtn').classList.remove('active');
	document.getElementById('stopBtn').classList.remove('active');
	}

	showMessage('ENHANCED FSD TRAINING STARTED',
	`Epoch ${FSD_CONFIG.epoch} \| Network: ${enhancedNetwork.layers.join('-')} \| LR: ${FSD_CONFIG.learningRate.toFixed(4)}`);
	updateUI();
	}

	function pauseTraining() {
	if (!FSD_CONFIG.isTraining) return;

	FSD_CONFIG.isPaused = !FSD_CONFIG.isPaused;
	if (FSD_CONFIG.isPaused) {
	clock.stop();
	document.getElementById('pauseBtn').classList.add('active');
	document.getElementById('startBtn').classList.remove('active');
	} else {
	clock.start();
	document.getElementById('pauseBtn').classList.remove('active');
	document.getElementById('startBtn').classList.add('active');
	}

	showMessage(FSD_CONFIG.isPaused ? 'TRAINING PAUSED' : 'TRAINING RESUMED',
	`Epoch ${FSD_CONFIG.epoch} \| Iteration ${FSD_CONFIG.iteration}`);
	updateUI();
	}

	function stopTraining() {
	FSD_CONFIG.isTraining = false;
	FSD_CONFIG.isPaused = false;
	clock.stop();

	// Reset drone to center
	FSD_CONFIG.dronePosition.set(0, 4, 0);
	FSD_CONFIG.droneVelocity.set(0, 0, 0);
	droneGroup.position.copy(FSD_CONFIG.dronePosition);
	droneGroup.rotation.set(0, 0, 0);

	// Reset PID controller
	FSD_CONFIG.pidController.integral.set(0, 0, 0);
	FSD_CONFIG.pidController.lastError.set(0, 0, 0);

	document.getElementById('startBtn').classList.remove('active');
	document.getElementById('pauseBtn').classList.remove('active');
	document.getElementById('stopBtn').classList.add('active');

	showMessage('TRAINING STOPPED', 'Enhanced neural network preserved for next session');
	updateUI();
	}

	function emergencyStop() {
	document.body.style.backgroundColor = '#300';
	setTimeout(() => {
	document.body.style.backgroundColor = '#000';
	}, 200);

	stopTraining();

	// Reset metrics
	FSD_CONFIG.collisionCount = 0;
	FSD_CONFIG.totalPathLength = 0;
	FSD_CONFIG.crossingCount = 0;
	FSD_CONFIG.patternCompleted = false;
	FSD_CONFIG.currentStep = 0;
	FSD_CONFIG.avoidanceMemory = [];
	FSD_CONFIG.cumulativeReward = 0;

	document.getElementById('statusText').textContent = 'EMERGENCY STOP';
	document.getElementById('statusDot').style.background = '#f00';

	setTimeout(() => {
	generateNewEpoch();
	updateUI();
	}, 1000);
	}

	function startPattern() {
	FSD_CONFIG.patternStartTime = Date.now();
	FSD_CONFIG.patternCompleted = false;
	FSD_CONFIG.currentStep = 0;
	FSD_CONFIG.collisionCount = 0;
	FSD_CONFIG.totalPathLength = 0;
	FSD_CONFIG.lastPosition.copy(FSD_CONFIG.dronePosition);
	FSD_CONFIG.crossingCount = 0;
	FSD_CONFIG.stuckTimer = 0;
	FSD_CONFIG.trainingStep = 0;
	FSD_CONFIG.lastProgressTime = Date.now();
	FSD_CONFIG.lastDistanceToTarget = 0;
	FSD_CONFIG.cumulativeReward = 0;
	FSD_CONFIG.avgReward = 0;

	// Reset drone position
	FSD_CONFIG.dronePosition.set(0, 4, 0);
	FSD_CONFIG.droneVelocity.set(0, 0, 0);

	// Reset PID controller
	FSD_CONFIG.pidController.integral.set(0, 0, 0);
	FSD_CONFIG.pidController.lastError.set(0, 0, 0);

	const firstPortalName = FSD_CONFIG.patternSequence[0];
	FSD_CONFIG.activePortal = FSD_CONFIG.portals[firstPortalName];

	// Reset portal collection states
	Object.values(FSD_CONFIG.portals).forEach(portal => {
	if (portal && portal.userData) {
	portal.userData.collected = false;
	portal.children.forEach(child => {
	if (child.material) {
	child.material.color.setHex(child === portal.children[1] ? 0xff0000 : 0x00ff00);
	if (child.material.emissive) {
	child.material.emissive.setHex(child === portal.children[1] ? 0x330000 : 0x003300);
	}
	}
	});
	}
	});

	showMessage('ENHANCED TRAINING ITERATION',
	`Epoch ${FSD_CONFIG.epoch} \| Iteration ${FSD_CONFIG.iteration} \| Target: ${firstPortalName}`);

	updateUI();
	}

	function generateNewEpoch() {
	FSD_CONFIG.epoch++;
	FSD_CONFIG.iteration = 1;

	// Increase difficulty with each epoch
	if (FSD_CONFIG.epoch % 2 === 0) {
	FSD_CONFIG.environment.difficultyLevel = Math.min(3.0, FSD_CONFIG.environment.difficultyLevel + 0.2);
	FSD_CONFIG.environment.floatingCount = Math.min(25, Math.floor(12 + FSD_CONFIG.environment.difficultyLevel * 3));
	FSD_CONFIG.environment.floatingMaxSpeed = Math.min(1.5, 0.5 + FSD_CONFIG.environment.difficultyLevel * 0.3);
	FSD_CONFIG.environment.bounceEnergy = Math.max(0.6, 0.8 - (FSD_CONFIG.environment.difficultyLevel - 1) * 0.1);
	}

	// Reset learning parameters for new epoch
	FSD_CONFIG.explorationRate = Math.max(0.1, 0.9 * Math.pow(0.95, FSD_CONFIG.epoch - 1));
	FSD_CONFIG.learningRate = 0.001 * Math.pow(0.99, FSD_CONFIG.epoch - 1);
	enhancedNetwork.learningRate = FSD_CONFIG.learningRate;

	generateBouncingObstacles();
	createPortals();
	startPattern();

	showMessage('ENHANCED EPOCH ' + FSD_CONFIG.epoch,
	`Difficulty: ${FSD_CONFIG.environment.difficultyLevel.toFixed(1)}x \| ` +
	`Obstacles: ${FSD_CONFIG.obstacles.length} \| ` +
	`Learning Rate: ${FSD_CONFIG.learningRate.toFixed(4)}`);
	}

	function increaseLearningRate() {
	FSD_CONFIG.learningRate = Math.min(0.01, FSD_CONFIG.learningRate * 1.5);
	enhancedNetwork.learningRate = FSD_CONFIG.learningRate;
	FSD_CONFIG.explorationRate = Math.max(0.05, FSD_CONFIG.explorationRate * 0.8);

	showMessage('LEARNING RATE BOOSTED',
	`LR: ${FSD_CONFIG.learningRate.toFixed(4)} \| Exploration: ${(FSD_CONFIG.explorationRate * 100).toFixed(1)}%`);

	updateUI();
	}

	function increaseDifficulty() {
	FSD_CONFIG.environment.difficultyLevel = Math.min(4.0, FSD_CONFIG.environment.difficultyLevel + 0.3);
	FSD_CONFIG.environment.floatingCount = Math.min(30, FSD_CONFIG.environment.floatingCount + 2);
	FSD_CONFIG.environment.floatingMaxSpeed = Math.min(2.0, FSD_CONFIG.environment.floatingMaxSpeed + 0.2);
	FSD_CONFIG.environment.obstacleCount = Math.min(30, FSD_CONFIG.environment.obstacleCount + 2);

	generateBouncingObstacles();

	showMessage('DIFFICULTY INCREASED',
	`Level: ${FSD_CONFIG.environment.difficultyLevel.toFixed(1)}x \| ` +
	`Floating: ${FSD_CONFIG.environment.floatingCount} \| ` +
	`Speed: ${FSD_CONFIG.environment.floatingMaxSpeed.toFixed(1)}`);

	updateUI();
	}

	function toggleView() {
	FSD_CONFIG.cameraMode = FSD_CONFIG.cameraMode === 'first' ? 'third' : 'first';
	document.getElementById('viewToggle').classList.toggle('active');
	}

	function toggleFullscreen() {
	if (!document.fullscreenElement) {
	document.documentElement.requestFullscreen();
	} else {
	document.exitFullscreen();
	}

	document.getElementById('fullscreenBtn').classList.toggle('active');
	}

	async function exportDataset() {
	if (FSD_CONFIG.telemetryBuffer.length === 0) {
	showMessage('NO DATA', 'No training data collected yet!');
	return;
	}

	const metadata = {
	generator: "enhanced-fsd-trainer-v3",
	version: "3.0",
	export_date: new Date().toISOString(),
	pattern: FSD_CONFIG.patternSequence.join('→'),
	total_epochs: FSD_CONFIG.epoch,
	total_iterations: FSD_CONFIG.iteration,
	total_training_steps: FSD_CONFIG.trainingStep,
	total_frames: FSD_CONFIG.telemetryBuffer.length,
	total_collisions: FSD_CONFIG.collisionCount,
	best_time: FSD_CONFIG.patternBestTime,
	success_rate: FSD_CONFIG.successHistory.length > 0 ?
	(FSD_CONFIG.successHistory.filter(s => s).length / FSD_CONFIG.successHistory.length * 100).toFixed(1) + '%' : '0%',

	// Neural network info
	network_architecture: enhancedNetwork.layers,
	final_learning_rate: FSD_CONFIG.learningRate,
	final_exploration_rate: FSD_CONFIG.explorationRate,
	total_train_steps: FSD_CONFIG.trainSteps,

	// Environment info
	environment_config: FSD_CONFIG.environment,
	difficulty_level: FSD_CONFIG.environment.difficultyLevel,

	// Performance metrics
	average_reward: FSD_CONFIG.avgReward,
	cumulative_reward: FSD_CONFIG.cumulativeReward,
	policy_loss: FSD_CONFIG.policyLoss,
	value_loss: FSD_CONFIG.valueLoss,
	td_error: FSD_CONFIG.tdError
	};

	const zip = new JSZip();

	// Enhanced telemetry data
	const telemetryJsonl = FSD_CONFIG.telemetryBuffer.map(t => JSON.stringify(t)).join('\n');
	zip.file("enhanced_telemetry.jsonl", telemetryJsonl);

	// Training experiences
	const experiencesJsonl = FSD_CONFIG.memoryBuffer.map(e => JSON.stringify(e)).join('\n');
	zip.file("training_experiences.jsonl", experiencesJsonl);

	// CSV for analysis
	const headers = [
	'timestamp', 'frame', 'epoch', 'iteration', 'training_step', 'pattern_step', 'pattern_target',
	'pos_x', 'pos_y', 'pos_z', 'vel_x', 'vel_y', 'vel_z',
	'target_x', 'target_y', 'target_z', 'distance_to_target',
	'q_value', 'cumulative_reward', 'exploration_rate', 'learning_rate',
	'td_error', 'policy_loss', 'value_loss',
	'collisions', 'path_length', 'crossing_count', 'stuck_timer',
	'obstacle_count', 'difficulty_level',
	'pattern_time', 'pattern_completed',
	'memory_buffer_size', 'train_steps', 'avg_reward'
	];

	const csvRows = FSD_CONFIG.telemetryBuffer.map(t => [
	t.timestamp,
	t.frame,
	t.epoch,
	t.iteration,
	t.training_step,
	t.pattern_step,
	t.pattern_target,
	t.position[0].toFixed(4),
	t.position[1].toFixed(4),
	t.position[2].toFixed(4),
	t.velocity[0].toFixed(4),
	t.velocity[1].toFixed(4),
	t.velocity[2].toFixed(4),
	t.target_position[0].toFixed(4),
	t.target_position[1].toFixed(4),
	t.target_position[2].toFixed(4),
	t.distance_to_target.toFixed(4),
	t.q_value?.toFixed(4) \|\| '0',
	t.cumulative_reward.toFixed(4),
	t.exploration_rate.toFixed(4),
	t.learning_rate.toFixed(4),
	t.td_error?.toFixed(4) \|\| '0',
	t.policy_loss?.toFixed(4) \|\| '0',
	t.value_loss?.toFixed(4) \|\| '0',
	t.collisions,
	t.path_length.toFixed(2),
	t.crossing_count,
	t.stuck_timer?.toFixed(2) \|\| '0',
	t.obstacle_count,
	t.difficulty_level?.toFixed(2) \|\| '1.0',
	t.pattern_time.toFixed(4),
	t.pattern_completed,
	t.memory_buffer_size,
	t.train_steps \|\| '0',
	t.avg_reward?.toFixed(4) \|\| '0'
	].join(','));

	const csvContent = headers.join(',') + '\n' + csvRows.join('\n');
	zip.file("enhanced_telemetry.csv", csvContent);

	// Metadata
	zip.file("metadata.json", JSON.stringify(metadata, null, 2));

	// Successful paths
	if (FSD_CONFIG.successfulPaths.length > 0) {
	zip.file("successful_paths.json", JSON.stringify(FSD_CONFIG.successfulPaths, null, 2));
	}

	// Neural network weights (simplified)
	const networkData = {
	architecture: enhancedNetwork.layers,
	weights_shape: enhancedNetwork.weights.map(w => [w.length, w[0].length]),
	biases_shape: enhancedNetwork.biases.map(b => b.length),
	learning_rate: enhancedNetwork.learningRate,
	export_timestamp: Date.now()
	};
	zip.file("enhanced_network.json", JSON.stringify(networkData, null, 2));

	const content = await zip.generateAsync({type: "blob"});
	const url = URL.createObjectURL(content);
	const a = document.createElement('a');
	a.href = url;
	a.download = `enhanced-fsd-dataset-epoch${FSD_CONFIG.epoch}-v3-${Date.now()}.zip`;
	document.body.appendChild(a);
	a.click();
	document.body.removeChild(a);
	URL.revokeObjectURL(url);

	showMessage('ENHANCED DATASET EXPORTED',
	`${FSD_CONFIG.telemetryBuffer.length} frames \| ` +
	`${FSD_CONFIG.memoryBuffer.length} experiences \| ` +
	`${FSD_CONFIG.trainSteps} training steps`);
	}

	// ==================== EVENT HANDLERS ====================
	function setupEventListeners() {
	document.getElementById('startBtn').addEventListener('click', startFSDTraining);
	document.getElementById('pauseBtn').addEventListener('click', pauseTraining);
	document.getElementById('stopBtn').addEventListener('click', stopTraining);
	document.getElementById('exportBtn').addEventListener('click', exportDataset);
	document.getElementById('emergencyStop').addEventListener('click', emergencyStop);
	document.getElementById('viewToggle').addEventListener('click', toggleView);
	document.getElementById('fullscreenBtn').addEventListener('click', toggleFullscreen);
	document.getElementById('newEpochBtn').addEventListener('click', generateNewEpoch);
	document.getElementById('speedBtn').addEventListener('click', increaseLearningRate);
	document.getElementById('difficultyBtn').addEventListener('click', increaseDifficulty);
	document.getElementById('trainingBtn').addEventListener('click', () => {
	showMessage('ENHANCED FSD TRAINING STATUS',
	`Network: ${enhancedNetwork.layers.join('-')}\n` +
	`Learning Rate: ${FSD_CONFIG.learningRate.toFixed(4)}\n` +
	`Exploration: ${(FSD_CONFIG.explorationRate * 100).toFixed(1)}%\n` +
	`Memory: ${FSD_CONFIG.memoryBuffer.length}/${FSD_CONFIG.maxMemorySize}\n` +
	`Training Steps: ${FSD_CONFIG.trainSteps}`);
	});
	}

	// ==================== INITIALIZATION ====================
	function init() {
	setupThreeJS();
	setupScene();
	generateBouncingObstacles();
	createPortals();
	setupEventListeners();
	updateUI();

	document.getElementById('stopBtn').classList.add('active');
	document.getElementById('statusText').textContent = 'ENHANCED FSD READY FOR TRAINING';

	showMessage('ENHANCED FSD TRAINER v3.0',
	'256-128-64-32 Neural Network with PPO Training\n' +
	'Enhanced Obstacle Avoidance with PID Control\n' +
	'Real-time Telemetry and Visualization\n' +
	'Adaptive Difficulty and Learning Rate');

	function animate() {
	requestAnimationFrame(animate);

	const delta = Math.min(clock.getDelta(), 0.05);

	if (FSD_CONFIG.isTraining && !FSD_CONFIG.isPaused) {
	// Enhanced autopilot
	enhancedFSDAutoPilot(delta);

	// Update bouncing obstacles
	updateBouncingObstacles(delta);

	// Animate portals
	Object.values(FSD_CONFIG.portals).forEach(portal => {
	if (portal && portal.userData) {
	if (!portal.userData.collected) {
	portal.rotation.y += portal.userData.rotationSpeed;
	// Pulse effect
	portal.userData.pulsePhase += 0.1;
	const pulse = 0.7 + 0.3 * Math.sin(portal.userData.pulsePhase);
	portal.children.forEach(child => {
	if (child.material && child.material.opacity !== undefined) {
	child.material.opacity = pulse * 0.7;
	}
	});
	}
	}
	});

	// Rotate drone propellers
	droneGroup.children.forEach(child => {
	if (child.userData && child.userData.rotationSpeed) {
	child.rotation.y += child.userData.rotationSpeed * delta * 10;
	}
	});
	}

	// Update camera
	updateCamera();

	// Update UI every frame
	updateUI();

	renderer.render(scene, camera);
	}

	animate();
	}

	// ==================== WINDOW RESIZE ====================
	window.addEventListener('resize', () => {
	if (camera && renderer) {
	camera.aspect = window.innerWidth / window.innerHeight;
	camera.updateProjectionMatrix();
	renderer.setSize(window.innerWidth, window.innerHeight);

	[waveCanvas, pathCanvas, nnCanvas].forEach(canvas => {
	if (canvas) {
	canvas.width = canvas.offsetWidth;
	canvas.height = canvas.offsetHeight;
	}
	});
	}
	});

	// ==================== START APPLICATION ====================
	window.addEventListener('load', init);
	</script>
	</body>
	</html>