/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
var Note = Container.expand(function (noteData, spawnTime) {
	var self = Container.call(this);
	// Note properties
	self.noteData = noteData;
	self.type = noteData.type; // 'tap', 'hold', 'flick'
	self.targetX = noteData.x;
	self.targetY = noteData.y;
	self.color = noteData.color || 0x00ffff;
	self.hitTime = noteData.time;
	self.duration = noteData.duration || 0; // For hold notes
	// self.flickTarget = noteData.flickTarget || null; // Removed
	self.spawnTime = spawnTime;
	self.zone = noteData.x < GAME_WIDTH / 2 ? 'left' : 'right'; // Determine zone
	// self.requiredFlickDirection = noteData.flickDirection || null; // Removed
	// State
	self.active = true;
	self.isHit = false;
	self.isMissed = false;
	self.isSpawning = true;
	self.isHolding = false; // True if player is currently holding this note
	self.holdSuccessfullyCompleted = false; // True if hold was completed successfully
	self.holdParticles = []; // Stores active connection particles for this hold note
	self.lastParticleEmissionTime = 0; // For throttling particle emission
	self.PARTICLE_EMISSION_INTERVAL = 50; // Emit particles every 50ms during hold
	// self.isHolding = false; // For hold notes // Duplicate line, already declared above
	self.holdStarted = false;
	// Visual components
	var assetName = self.type === 'hold' ? 'holdNoteCore' : 'noteCore'; // Removed flickNoteCore
	self.noteGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.noteGraphics.tint = self.color;
	// self.flickDirectionIndicator logic removed
	self.glowRing = self.attachAsset('glowRing', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.glowRing.tint = self.color;
	self.glowRing.alpha = 0.3;
	// Position
	self.x = self.targetX;
	self.y = self.targetY;
	// Start invisible and scale up
	self.alpha = 0;
	self.scaleX = 0.1;
	self.scaleY = 0.1;
	// Define createHoldTrail method first
	self.createHoldTrail = function () {
		// Determine scanner direction at hit time
		var cycleTime = self.hitTime % SCANNER_CYCLE_DURATION;
		var scannerMovingUp = cycleTime < SCANNER_HALF_CYCLE;
		var direction = scannerMovingUp ? -1 : 1; // -1 for up, 1 for down
		// Calculate actual trail length in pixels based on duration and scanner speed
		var actualTrailPixelLength = self.duration / SCANNER_HALF_CYCLE * PLAY_AREA_HEIGHT;
		if (actualTrailPixelLength < 0) actualTrailPixelLength = 0; // Ensure length is not negative
		// Create the main connecting trail line
		var trailLine = self.attachAsset('holdTrail', {
			anchorX: 0.5,
			anchorY: 0 // Anchor at the top of the trail asset
		});
		trailLine.tint = self.color;
		trailLine.alpha = 0.6;
		trailLine.width = 20; // Set a visible width for the trail line
		trailLine.height = actualTrailPixelLength;
		if (direction === -1) {
			// Trail goes upwards from the note
			trailLine.y = -actualTrailPixelLength;
		} else {
			// Trail goes downwards from the note
			trailLine.y = 0; // AnchorY is 0, so top of trailLine is at note's y
		}
		self.holdTrails.push(trailLine);
		// Add end indicator note, positioned relative to the start note
		self.endNote = self.attachAsset('noteCore', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.endNote.tint = self.color;
		self.endNote.alpha = 0.8;
		self.endNote.scaleX = 0.7;
		self.endNote.scaleY = 0.7;
		self.endNote.y = actualTrailPixelLength * direction;
		// Add a subtle glow to the end note, positioned with the end note
		self.endGlow = self.attachAsset('glowRing', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.endGlow.tint = self.color;
		self.endGlow.alpha = 0.2;
		self.endGlow.scaleX = 0.5;
		self.endGlow.scaleY = 0.5;
		self.endGlow.y = actualTrailPixelLength * direction;
	};
	// Hold trail for hold notes
	self.holdTrails = [];
	if (self.type === 'hold' && self.duration > 0) {
		self.createHoldTrail();
	}
	self.spawnIn = function () {
		self.isSpawning = true;
		tween(self, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isSpawning = false;
			}
		});
	};
	self.showHitEffect = function () {
		// Primarily for TAP notes now
		LK.getSound('hitSound').play();
		self.explodeIntoParticles();
		// For tap notes, there's no endNote or endGlow to clean typically.
		// This method makes the note inactive.
		tween(self, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				self.active = false;
			}
		});
	};
	self.startHoldEffect = function () {
		// Called for HOLD note initial interaction
		LK.getSound('hitSound').play();
		// Visual cue for hold start, e.g., a slight pulse. Note remains active.
		tween(self.noteGraphics, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(self.noteGraphics, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 100
				});
			}
		});
		// EndNote and EndGlow MUST remain visible. Note itself is not deactivated here.
	};
	// self.showFlickEffect method removed.
	// self.createFlickTrail method is now obsolete and removed.
	self.showMissEffect = function () {
		LK.getSound('missSound').play();
		// Flick direction indicator cleanup removed
		tween(self.noteGraphics, {
			tint: 0xff0000
		}, {
			duration: 150,
			onFinish: function onFinish() {
				tween(self, {
					alpha: 0.3
				}, {
					duration: 300,
					onFinish: function onFinish() {
						self.active = false;
					}
				});
			}
		});
	};
	self.explodeIntoParticles = function () {
		// Flick direction indicator cleanup removed
		var particleCount = 12;
		for (var i = 0; i < particleCount; i++) {
			var particle = game.attachAsset('particle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			particle.tint = self.color;
			particle.x = self.x;
			particle.y = self.y;
			var angle = i / particleCount * Math.PI * 2;
			var speed = 150 + Math.random() * 100;
			var targetX = self.x + Math.cos(angle) * speed;
			var targetY = self.y + Math.sin(angle) * speed;
			tween(particle, {
				x: targetX,
				y: targetY,
				alpha: 0,
				scaleX: 0.3,
				scaleY: 0.3
			}, {
				duration: 600,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					if (particle && particle.destroy) {
						particle.destroy();
					}
				}
			});
		}
	};
	self.updateHoldEffects = function (scannerCurrentY) {
		if (self.type === 'hold' && self.isHolding && self.active && !self.holdSuccessfullyCompleted && !self.isMissed) {
			var currentTime = Date.now();
			if (currentTime - self.lastParticleEmissionTime > self.PARTICLE_EMISSION_INTERVAL) {
				self.lastParticleEmissionTime = currentTime;
				var trailStartY = self.y;
				var trailEndY = self.y + (self.endNote ? self.endNote.y : 0); // endNote.y is relative
				var scannerIsOverTrail = self.endNote && scannerCurrentY >= Math.min(trailStartY, trailEndY) && scannerCurrentY <= Math.max(trailStartY, trailEndY);
				if (scannerIsOverTrail) {
					var particle = game.attachAsset('holdConnectionParticle', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					particle.x = self.x;
					particle.y = scannerCurrentY;
					particle.tint = self.color;
					particle.alpha = 0.8;
					self.holdParticles.push(particle);
					tween(particle, {
						alpha: 0,
						scaleX: 0.2,
						scaleY: 0.2
					}, {
						duration: 500,
						easing: tween.easeOut,
						onFinish: function onFinish() {
							if (particle && particle.destroy) particle.destroy();
							var index = self.holdParticles.indexOf(particle);
							if (index > -1) self.holdParticles.splice(index, 1);
						}
					});
				}
			}
		}
	};
	self.cleanupHoldVisuals = function () {
		self.holdParticles.forEach(function (p) {
			if (p && p.destroy) p.destroy();
		});
		self.holdParticles = [];
		if (self.endNote && self.endNote.destroy) self.endNote.destroy();
		if (self.endGlow && self.endGlow.destroy) self.endGlow.destroy();
		self.endNote = null;
		self.endGlow = null;
		self.holdTrails.forEach(function (trail) {
			if (trail && trail.destroy) trail.destroy();
		});
		self.holdTrails = [];
	};
	self.completeHold = function () {
		if (self.holdSuccessfullyCompleted || self.isMissed) return;
		self.holdSuccessfullyCompleted = true;
		self.isHolding = false;
		self.explodeIntoParticles(); // Main note explosion
		self.cleanupHoldVisuals(); // Clean up trail, end note, particles
		// The main note (self) will become inactive due to explodeIntoParticles tween or explicitly here
		tween(self, {
			alpha: 0
		}, {
			duration: 100,
			delay: 100,
			onFinish: function onFinish() {
				self.active = false;
			}
		});
	};
	self.failHold = function () {
		if (self.isMissed || self.holdSuccessfullyCompleted) return;
		self.isMissed = true;
		self.isHolding = false;
		self.showMissEffect(); // Main note shows miss effect
		self.cleanupHoldVisuals(); // Clean up trail, end note, particles
		// self.active will be set to false by showMissEffect's tween's onFinish
	};
	return self;
});
var Scanner = Container.expand(function () {
	var self = Container.call(this);
	self.glow = self.attachAsset('scannerGlow', {
		anchorX: 0,
		anchorY: 0.5
	});
	self.glow.alpha = 0.3;
	self.line = self.attachAsset('scannerLine', {
		anchorX: 0,
		anchorY: 0.5
	});
	self.x = 0;
	self.isMovingUp = true; // Start moving up
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Game Constants
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var BPM = 120;
var BEAT_DURATION_MS = 60 / BPM * 1000;
var SCANNER_Y_MIN = 200;
var SCANNER_Y_MAX = GAME_HEIGHT - 300;
var PLAY_AREA_HEIGHT = SCANNER_Y_MAX - SCANNER_Y_MIN;
var HIT_TOLERANCE_PX = 80;
var TARGET_SCORE_TO_WIN = 1500;
var NOTE_SPAWN_AHEAD_MS = 800; // Reduced to 800ms to prevent mass spawning
var SCANNER_CYCLE_DURATION = 4000;
var SCANNER_HALF_CYCLE = SCANNER_CYCLE_DURATION / 2;
var HIT_TOLERANCE_PX_FOR_HOLD_END = 100; // Tolerance for releasing hold note at the end
var HOLD_END_GRACE_PERIOD_MS = 250; // Grace period for hold note release time vs scanner position
// var MIN_FLICK_DISTANCE = 75; // Removed
// Game State Variables
var activeHoldNotes = {}; // Stores the currently active hold note, keyed by 'left' or 'right' zone
// var activeFlickPrimer = null; // Removed
var scoreTxt;
var countdownTxt;
var scanner;
var scannerIsMovingUp = true;
var gameStartTime;
var gameStarted = false;
var notes = [];
var currentSongData;
var spawnedNotes = []; // Using array instead of Set
var leftZone, rightZone;
var isDragging = false;
var dragStartX, dragStartY;
var currentTrail = [];
// Color palette for notes
var NOTE_COLORS = [0x00ffff,
// Cyan
0xff00ff,
// Magenta  
0xffff00,
// Yellow
0x00ff00,
// Green
0xff8800,
// Orange
0x8800ff // Purple
];
// Song Pattern System
// Pattern Templates - reusable note patterns
var PatternTemplates = {
	// Basic patterns
	tapLeft: function tapLeft(startTime) {
		return [{
			time: startTime,
			type: 'tap',
			zone: 'left'
		}];
	},
	tapRight: function tapRight(startTime) {
		return [{
			time: startTime,
			type: 'tap',
			zone: 'right'
		}];
	},
	syncTap: function syncTap(startTime) {
		return [{
			time: startTime,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime,
			type: 'tap',
			zone: 'right'
		}];
	},
	// Alternating patterns
	leftRightTaps: function leftRightTaps(startTime, spacing) {
		spacing = spacing || 500; // Default to beat spacing
		return [{
			time: startTime,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime + spacing,
			type: 'tap',
			zone: 'right'
		}];
	},
	rightLeftTaps: function rightLeftTaps(startTime, spacing) {
		spacing = spacing || 500;
		return [{
			time: startTime,
			type: 'tap',
			zone: 'right'
		}, {
			time: startTime + spacing,
			type: 'tap',
			zone: 'left'
		}];
	},
	// Hold patterns
	holdLeft: function holdLeft(startTime, duration) {
		duration = duration || 1000;
		return [{
			time: startTime,
			type: 'hold',
			zone: 'left',
			duration: duration
		}];
	},
	holdRight: function holdRight(startTime, duration) {
		duration = duration || 1000;
		return [{
			time: startTime,
			type: 'hold',
			zone: 'right',
			duration: duration
		}];
	},
	syncHold: function syncHold(startTime, duration) {
		duration = duration || 1000;
		return [{
			time: startTime,
			type: 'hold',
			zone: 'left',
			duration: duration
		}, {
			time: startTime,
			type: 'hold',
			zone: 'right',
			duration: duration
		}];
	},
	// Complex patterns
	tripletTaps: function tripletTaps(startTime, zone, spacing) {
		spacing = spacing || 167; // Triplet timing
		return [{
			time: startTime,
			type: 'tap',
			zone: zone
		}, {
			time: startTime + spacing,
			type: 'tap',
			zone: zone
		}, {
			time: startTime + spacing * 2,
			type: 'tap',
			zone: zone
		}];
	},
	alternatingTriplets: function alternatingTriplets(startTime, spacing) {
		spacing = spacing || 167;
		return [{
			time: startTime,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime + spacing,
			type: 'tap',
			zone: 'right'
		}, {
			time: startTime + spacing * 2,
			type: 'tap',
			zone: 'left'
		}];
	},
	buildUp: function buildUp(startTime) {
		return [{
			time: startTime,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime + 250,
			type: 'tap',
			zone: 'right'
		}, {
			time: startTime + 500,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime + 625,
			type: 'tap',
			zone: 'right'
		}, {
			time: startTime + 750,
			type: 'tap',
			zone: 'left'
		}, {
			time: startTime + 875,
			type: 'tap',
			zone: 'right'
		}];
	},
	holdWithTaps: function holdWithTaps(startTime, holdZone, holdDuration) {
		var tapZone = holdZone === 'left' ? 'right' : 'left';
		holdDuration = holdDuration || 2000;
		return [{
			time: startTime,
			type: 'hold',
			zone: holdZone,
			duration: holdDuration
		}, {
			time: startTime + 500,
			type: 'tap',
			zone: tapZone
		}, {
			time: startTime + 1000,
			type: 'tap',
			zone: tapZone
		}, {
			time: startTime + 1500,
			type: 'tap',
			zone: tapZone
		}];
	}
};
var SongGenerator = {
	generateSong: function generateSong(config) {
		var notes = [];
		var totalLength = config.totalLength || 202136;
		var startTime = config.startDelay || 2000;
		notes = this.generateZoneAwareSong(startTime, totalLength);
		notes.sort(function (a, b) {
			return a.time - b.time;
		}); // Ensure notes are sorted
		return notes;
	},
	generateZoneAwareSong: function generateZoneAwareSong(startTime, songTotalLength) {
		var notes = [];
		var currentTime = startTime;
		// Track when each zone will be free
		var zoneFreeTime = {
			left: startTime,
			right: startTime
		};
		// Minimum spacing between notes (human reaction time)
		var MIN_SAME_ZONE_SPACING = 400; // 400ms minimum in same zone
		var MIN_DIFFERENT_ZONE_SPACING = 200; // 200ms minimum between different zones
		var MIN_SYNC_SPACING = 800; // 800ms minimum between sync notes
		var lastSyncTime = startTime - MIN_SYNC_SPACING; // Initialize to allow early sync
		// Define sections with different complexities
		var sections = [{
			start: 0,
			end: 16000,
			complexity: 'simple'
		}, {
			start: 16000,
			end: 48000,
			complexity: 'medium'
		}, {
			start: 48000,
			end: 72000,
			complexity: 'medium'
		},
		// Original: chorus1, intensity 0.8
		{
			start: 72000,
			end: 104000,
			complexity: 'medium'
		}, {
			start: 104000,
			end: 128000,
			complexity: 'complex'
		},
		// Original: chorus2, intensity 0.9
		{
			start: 128000,
			end: 160000,
			complexity: 'medium'
		}, {
			start: 160000,
			end: 184000,
			complexity: 'complex'
		},
		// Original: finalchorus, intensity 1.0
		{
			start: 184000,
			end: songTotalLength,
			complexity: 'simple'
		} // Ensure it goes to the end
		];
		for (var s = 0; s < sections.length; s++) {
			var section = sections[s];
			var sectionStartTime = startTime + section.start;
			var sectionEndTime = startTime + section.end;
			if (sectionEndTime > startTime + songTotalLength) {
				sectionEndTime = startTime + songTotalLength;
			}
			if (sectionStartTime >= sectionEndTime) continue;
			currentTime = Math.max(currentTime, sectionStartTime);
			while (currentTime < sectionEndTime - 1000) {
				// Leave 1s buffer at end of section
				var pattern = this.selectPattern(section.complexity, zoneFreeTime, currentTime, lastSyncTime);
				var patternResult = this.placePattern(pattern, currentTime, zoneFreeTime, MIN_SAME_ZONE_SPACING, MIN_DIFFERENT_ZONE_SPACING, sectionEndTime);
				if (patternResult.notes.length > 0) {
					var allNotesFit = true;
					for (var ni = 0; ni < patternResult.notes.length; ni++) {
						if (patternResult.notes[ni].time + (patternResult.notes[ni].duration || 0) > sectionEndTime - 200) {
							// Check end time
							allNotesFit = false;
							break;
						}
					}
					if (allNotesFit) {
						notes = notes.concat(patternResult.notes);
						currentTime = patternResult.nextTime;
						if (pattern.type === 'sync') {
							lastSyncTime = patternResult.notes[0].time; // Time of the sync notes themselves
						}
					} else {
						currentTime += 300; // Advance time if pattern didn't fit
					}
				} else {
					currentTime += 300; // If pattern couldn't be placed, advance time
				}
				if (currentTime >= sectionEndTime - 1000) break;
			}
		}
		return notes;
	},
	selectPattern: function selectPattern(complexity, zoneFreeTime, currentTime, lastSyncTime) {
		var patterns = [];
		var MIN_SYNC_SPACING = 800; // Local constant for clarity
		if (complexity === 'simple') {
			patterns = [{
				type: 'single',
				zone: 'left',
				duration: 500
			}, {
				type: 'single',
				zone: 'right',
				duration: 500
			}, {
				type: 'rest',
				duration: 1000
			}];
			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
				patterns.push({
					type: 'sync',
					duration: 600
				});
			}
		} else if (complexity === 'medium') {
			patterns = [{
				type: 'single',
				zone: 'left',
				duration: 400
			}, {
				type: 'single',
				zone: 'right',
				duration: 400
			}, {
				type: 'alternating',
				duration: 600
			},
			// two taps, 250ms apart
			{
				type: 'hold',
				zone: 'left',
				holdDuration: 1500,
				duration: 800
			}, {
				type: 'hold',
				zone: 'right',
				holdDuration: 1500,
				duration: 800
			}, {
				type: 'rest',
				duration: 800
			}];
			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
				patterns.push({
					type: 'sync',
					duration: 600
				});
			}
		} else {
			// complex
			patterns = [{
				type: 'single',
				zone: 'left',
				duration: 300
			}, {
				type: 'single',
				zone: 'right',
				duration: 300
			}, {
				type: 'alternating',
				duration: 500
			},
			// two taps, 250ms apart
			{
				type: 'hold',
				zone: 'left',
				holdDuration: 1500,
				duration: 800
			}, {
				type: 'hold',
				zone: 'right',
				holdDuration: 1500,
				duration: 800
			}, {
				type: 'holdWithTaps',
				zone: 'left',
				holdDuration: 2000,
				duration: 1000
			}, {
				type: 'holdWithTaps',
				zone: 'right',
				holdDuration: 2000,
				duration: 1000
			}];
			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
				patterns.push({
					type: 'sync',
					duration: 500
				}); // Shorter duration for sync in complex sections
			}
		}
		return patterns[Math.floor(Math.random() * patterns.length)];
	},
	placePattern: function placePattern(pattern, requestedTime, zoneFreeTime, minSameZoneSpacing, minDiffZoneSpacing, sectionEndTime) {
		var notes = [];
		var earliestTime = requestedTime;
		var nextTimeAdvance = pattern.duration || 500; // Default advancement
		if (pattern.type === 'single') {
			earliestTime = Math.max(requestedTime, zoneFreeTime[pattern.zone]);
			if (earliestTime + (pattern.duration || 0) < sectionEndTime) {
				notes.push({
					time: earliestTime,
					type: 'tap',
					zone: pattern.zone
				});
				zoneFreeTime[pattern.zone] = earliestTime + minSameZoneSpacing;
				return {
					notes: notes,
					nextTime: earliestTime + nextTimeAdvance
				};
			}
		} else if (pattern.type === 'sync') {
			earliestTime = Math.max(requestedTime, zoneFreeTime.left, zoneFreeTime.right);
			if (earliestTime + (pattern.duration || 0) < sectionEndTime) {
				notes.push({
					time: earliestTime,
					type: 'tap',
					zone: 'left'
				});
				notes.push({
					time: earliestTime,
					type: 'tap',
					zone: 'right'
				});
				zoneFreeTime.left = earliestTime + minSameZoneSpacing;
				zoneFreeTime.right = earliestTime + minSameZoneSpacing;
				return {
					notes: notes,
					nextTime: earliestTime + nextTimeAdvance
				};
			}
		} else if (pattern.type === 'alternating') {
			// Attempt Left then Right
			var firstZone = Math.random() < 0.5 ? 'left' : 'right';
			var secondZone = firstZone === 'left' ? 'right' : 'left';
			var t1 = Math.max(requestedTime, zoneFreeTime[firstZone]);
			var t2 = Math.max(t1 + minDiffZoneSpacing, zoneFreeTime[secondZone]);
			if (t2 + (pattern.duration || 0) - (t2 - t1) < sectionEndTime) {
				// check if second note fits
				notes.push({
					time: t1,
					type: 'tap',
					zone: firstZone
				});
				notes.push({
					time: t2,
					type: 'tap',
					zone: secondZone
				});
				zoneFreeTime[firstZone] = t1 + minSameZoneSpacing;
				zoneFreeTime[secondZone] = t2 + minSameZoneSpacing;
				return {
					notes: notes,
					nextTime: t2 + minDiffZoneSpacing
				}; // Next logical placement time
			}
		} else if (pattern.type === 'hold') {
			earliestTime = Math.max(requestedTime, zoneFreeTime[pattern.zone]);
			var holdDuration = pattern.holdDuration || 1500;
			if (earliestTime + holdDuration < sectionEndTime) {
				notes.push({
					time: earliestTime,
					type: 'hold',
					zone: pattern.zone,
					duration: holdDuration
				});
				zoneFreeTime[pattern.zone] = earliestTime + holdDuration + 200; // Buffer after hold
				return {
					notes: notes,
					nextTime: earliestTime + nextTimeAdvance
				}; // Pattern's own duration logic
			}
		} else if (pattern.type === 'holdWithTaps') {
			var holdZone = pattern.zone;
			var tapZone = holdZone === 'left' ? 'right' : 'left';
			var holdStart = Math.max(requestedTime, zoneFreeTime[holdZone]);
			var mainHoldDuration = pattern.holdDuration || 2000;
			if (holdStart + mainHoldDuration < sectionEndTime) {
				notes.push({
					time: holdStart,
					type: 'hold',
					zone: holdZone,
					duration: mainHoldDuration
				});
				zoneFreeTime[holdZone] = holdStart + mainHoldDuration + 200;
				var tap1Time = Math.max(holdStart + 500, zoneFreeTime[tapZone]);
				if (tap1Time < holdStart + mainHoldDuration - 500 && tap1Time + minSameZoneSpacing < sectionEndTime) {
					notes.push({
						time: tap1Time,
						type: 'tap',
						zone: tapZone
					});
					zoneFreeTime[tapZone] = tap1Time + minSameZoneSpacing;
					var tap2Time = Math.max(tap1Time + minSameZoneSpacing, zoneFreeTime[tapZone]); // Ensure tap2 is after tap1 is free
					if (tap2Time < holdStart + mainHoldDuration - 200 && tap2Time + minSameZoneSpacing < sectionEndTime) {
						notes.push({
							time: tap2Time,
							type: 'tap',
							zone: tapZone
						});
						zoneFreeTime[tapZone] = tap2Time + minSameZoneSpacing;
					}
				}
				return {
					notes: notes,
					nextTime: holdStart + nextTimeAdvance
				};
			}
		} else if (pattern.type === 'rest') {
			return {
				notes: [],
				nextTime: requestedTime + (pattern.duration || 500)
			};
		}
		return {
			notes: [],
			nextTime: requestedTime + 100
		}; // Failed to place, small advance
	}
};
// Simpler song database
var SongDatabase = {
	'gameMusic': {
		bpm: 120,
		scannerCycleDuration: 4000,
		totalLength: 202136,
		notes: null
	}
};
// Generate with the new system
SongDatabase['gameMusic'].notes = SongGenerator.generateSong({
	startDelay: 2000,
	totalLength: SongDatabase['gameMusic'].totalLength
});
var defaultSongData = SongDatabase['gameMusic'];
// Helper function to add new songs easily
function addSong(songId, config) {
	SongDatabase[songId] = {
		bpm: config.bpm || 120,
		scannerCycleDuration: config.scannerCycleDuration || 4000,
		totalLength: config.totalLength,
		notes: config.customNotes || SongGenerator.generateSong(config)
	};
}
// Example of adding a new song:
/*
addSong('newSong', {
	bpm: 140,
	totalLength: 180000, // 3 minutes
	startDelay: 1500,
	verseCount: 2,
	verseLength: 30000
});
*/
function calculateNotePosition(noteTime) {
	// Calculate where scanner will be when note should be hit
	var cycleTime = noteTime % SCANNER_CYCLE_DURATION;
	var y;
	if (cycleTime < SCANNER_HALF_CYCLE) {
		// First half: moving up from bottom to top
		var progress = cycleTime / SCANNER_HALF_CYCLE;
		y = SCANNER_Y_MAX - progress * PLAY_AREA_HEIGHT;
	} else {
		// Second half: moving down from top to bottom  
		var progress = (cycleTime - SCANNER_HALF_CYCLE) / SCANNER_HALF_CYCLE;
		y = SCANNER_Y_MIN + progress * PLAY_AREA_HEIGHT;
	}
	return y;
}
function calculateZoneX(zone) {
	// Calculate random X position within the specified zone
	if (zone === 'left') {
		return 200 + Math.random() * (GAME_WIDTH / 2 - 400); // Leave some margin
	} else {
		return GAME_WIDTH / 2 + 200 + Math.random() * (GAME_WIDTH / 2 - 400);
	}
}
function createZoneIndicators() {
	// Left zone indicator
	leftZone = game.attachAsset('zoneIndicator', {
		anchorX: 0,
		anchorY: 0
	});
	leftZone.x = 0;
	leftZone.y = 0;
	leftZone.width = GAME_WIDTH / 2;
	leftZone.alpha = 0.1;
	leftZone.tint = 0x00ffff;
	// Right zone indicator  
	rightZone = game.attachAsset('zoneIndicator', {
		anchorX: 0,
		anchorY: 0
	});
	rightZone.x = GAME_WIDTH / 2;
	rightZone.y = 0;
	rightZone.width = GAME_WIDTH / 2;
	rightZone.alpha = 0.1;
	rightZone.tint = 0xff00ff;
}
// function createFlickResultNote is removed as it's no longer used.
function startCountdown() {
	countdownTxt = new Text2('3', {
		size: 200,
		fill: 0xFFFFFF
	});
	countdownTxt.anchor.set(0.5, 0.5);
	countdownTxt.x = GAME_WIDTH / 2;
	countdownTxt.y = GAME_HEIGHT / 2;
	game.addChild(countdownTxt);
	var count = 3;
	var countdownInterval = LK.setInterval(function () {
		count--;
		if (count > 0) {
			countdownTxt.setText(count.toString());
		} else if (count === 0) {
			countdownTxt.setText('GO!');
		} else {
			LK.clearInterval(countdownInterval);
			if (countdownTxt && countdownTxt.destroy) {
				countdownTxt.destroy();
			}
			startGame();
		}
	}, 1000);
}
function startGame() {
	gameStarted = true;
	gameStartTime = Date.now();
	moveScanner();
	LK.playMusic('gameMusic', {
		loop: true
	});
	// updateHealthDisplay function is removed.
}
function moveScanner() {
	if (!scanner || !gameStarted) return;
	tween.stop(scanner);
	var targetY = scannerIsMovingUp ? SCANNER_Y_MIN : SCANNER_Y_MAX;
	tween(scanner, {
		y: targetY
	}, {
		duration: SCANNER_CYCLE_DURATION / 2,
		easing: tween.linear,
		onFinish: function onFinish() {
			scannerIsMovingUp = !scannerIsMovingUp;
			moveScanner();
		}
	});
}
function spawnNotesForCurrentTime(currentTime) {
	if (!currentSongData) return;
	currentSongData.notes.forEach(function (noteData, index) {
		var noteKey = index + '_' + noteData.time;
		// Check if already spawned
		var alreadySpawned = false;
		for (var i = 0; i < spawnedNotes.length; i++) {
			if (spawnedNotes[i] === noteKey) {
				alreadySpawned = true;
				break;
			}
		}
		// Only spawn if note time is approaching and not yet spawned
		if (!alreadySpawned && currentTime >= noteData.time - NOTE_SPAWN_AHEAD_MS && currentTime <= noteData.time - NOTE_SPAWN_AHEAD_MS + 100) {
			// Narrow spawn window
			// Calculate proper position
			var calculatedY = calculateNotePosition(noteData.time);
			var calculatedX = calculateZoneX(noteData.zone);
			// Create note data with calculated positions
			var processedNoteData = {
				time: noteData.time,
				type: noteData.type,
				x: calculatedX,
				y: calculatedY,
				color: NOTE_COLORS[Math.floor(Math.random() * NOTE_COLORS.length)],
				duration: noteData.duration
				// flickDirection: noteData.flickDirection // Removed
			};
			// Flick target logic is removed
			var note = new Note(processedNoteData, currentTime);
			notes.push(note);
			game.addChild(note);
			note.spawnIn();
			spawnedNotes.push(noteKey);
		}
	});
}
function setupGame() {
	LK.setScore(0);
	// playerHealth = INITIAL_PLAYER_HEALTH; // playerHealth assignment removed
	gameStarted = false;
	// Score Text
	if (scoreTxt && scoreTxt.destroy) {
		scoreTxt.destroy();
	}
	scoreTxt = new Text2('0', {
		size: 100,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreTxt);
	scoreTxt.setText(LK.getScore());
	// Health Display removed
	// Zone indicators
	createZoneIndicators();
	// Scanner - start at bottom
	if (scanner && scanner.destroy) {
		scanner.destroy();
	}
	scanner = new Scanner();
	scanner.y = SCANNER_Y_MAX; // Start at bottom
	game.addChild(scanner);
	// Clear previous notes
	notes.forEach(function (note) {
		if (note && note.destroy) {
			note.destroy();
		}
	});
	notes = [];
	spawnedNotes = [];
	// Load song data
	currentSongData = defaultSongData;
	BPM = currentSongData.bpm;
	BEAT_DURATION_MS = 60 / BPM * 1000;
	scannerIsMovingUp = true; // Will move up first
	// Start countdown instead of immediate game start
	startCountdown();
}
function checkZoneHit(x, y) {
	var hitZone = x < GAME_WIDTH / 2 ? 'left' : 'right';
	var currentTime = Date.now() - gameStartTime;
	for (var i = notes.length - 1; i >= 0; i--) {
		var note = notes[i];
		if (!note || !note.active || note.isHit || note.isSpawning) continue;
		// Check if note is in the same zone
		if (note.zone === hitZone) {
			var scannerDiff = Math.abs(scanner.y - note.y);
			var timeDiff = Math.abs(currentTime - note.hitTime);
			if (scannerDiff < HIT_TOLERANCE_PX) {
				note.isHit = true; // Mark as initially judged for timing. Actual success for hold comes later.
				var points = 0;
				// Removed flick note type check
				if (note.type === 'tap') {
					note.showHitEffect(); // Makes note inactive
					points = timeDiff < 50 ? 20 : timeDiff < 100 ? 15 : 10;
					LK.setScore(LK.getScore() + points);
					scoreTxt.setText(LK.getScore());
					if (LK.getScore() >= TARGET_SCORE_TO_WIN) {
						LK.showYouWin();
						gameStartTime = null;
						gameStarted = false;
						tween.stop(scanner);
						return;
					}
				} else if (note.type === 'hold') {
					note.startHoldEffect(); // Prepares note for holding, does NOT make inactive
					// Points for hold notes are awarded on successful completion (in game.up)
				}
				// Removed general points block as it's now specific to tap notes here.
				break; //{4u} // Found and processed a note for this hit
			}
		}
	}
}
// Initial setup call
setupGame();
game.down = function (x, y, obj) {
	if (!gameStarted) return; //{4L} // playerHealth check removed
	checkZoneHit(x, y); // This will set note.isHit for taps and call startHoldEffect for holds.
	var hitZoneForDown = x < GAME_WIDTH / 2 ? 'left' : 'right';
	// Logic for starting a hold
	// activeFlickPrimer = null; // Removed
	for (var i = 0; i < notes.length; i++) {
		var note = notes[i];
		if (!note.active || note.isSpawning || note.holdSuccessfullyCompleted || note.isMissed) continue;
		if (note.zone === hitZoneForDown && note.isHit) {
			// note.isHit was set by checkZoneHit if timing was good
			if (note.type === 'hold' && !note.isHolding) {
				// checkZoneHit already called startHoldEffect if proximity was good.
				// Here we confirm and set isHolding.
				if (Math.abs(scanner.y - note.y) < HIT_TOLERANCE_PX) {
					note.isHolding = true;
					activeHoldNotes[note.zone] = note;
					// A flick note should not also be a hold note. // Comment remains for context, but flick logic is gone.
				}
				// Removed 'else if (note.type === 'flick' ...)' block
			} //{4I} // This closing brace now corresponds to 'if (note.type === 'hold' ...)'
		}
	}
	isDragging = true; // Still useful for game.up to know a drag sequence occurred
	dragStartX = x; // General drag start, flick primer uses its own copy
	dragStartY = y;
	// currentTrail related lines removed as trails are gone.
};
game.move = function (x, y, obj) {
	if (!isDragging || !gameStarted) return;
	// Particle trail logic removed. This function can be empty or used for other drag-move effects if needed later.
};
game.up = function (x, y, obj) {
	if (!gameStarted) return; // Allow processing even if not dragging for safety, but check gameStarted
	var releasedZone = x < GAME_WIDTH / 2 ? 'left' : 'right';
	// Flick logic (activeFlickPrimer related) removed entirely.
	// Now, directly handle hold note release.
	var heldNote = activeHoldNotes[releasedZone];
	if (heldNote && heldNote.isHolding) {
		heldNote.isHolding = false; // Stop particle effects etc.
		delete activeHoldNotes[releasedZone];
		var currentTimeMs = Date.now() - gameStartTime;
		var noteExpectedEndTimeMs = heldNote.hitTime + heldNote.duration;
		var absoluteEndNoteY = heldNote.y + (heldNote.endNote ? heldNote.endNote.y : 0); // endNote.y is relative
		// Determine scanner direction at hit time for this note (needed for correct end check if trail goes up)
		var hitTimeCycle = heldNote.hitTime % SCANNER_CYCLE_DURATION;
		var noteScannerMovingUp = hitTimeCycle < SCANNER_HALF_CYCLE;
		var trailDirection = noteScannerMovingUp ? -1 : 1;
		var scannerAtEnd;
		if (trailDirection === -1) {
			// Trail goes upwards
			scannerAtEnd = scanner.y <= absoluteEndNoteY + HIT_TOLERANCE_PX_FOR_HOLD_END && scanner.y >= absoluteEndNoteY - HIT_TOLERANCE_PX_FOR_HOLD_END / 2; // Scanner near or slightly past the end upwardly
		} else {
			// Trail goes downwards
			scannerAtEnd = scanner.y >= absoluteEndNoteY - HIT_TOLERANCE_PX_FOR_HOLD_END && scanner.y <= absoluteEndNoteY + HIT_TOLERANCE_PX_FOR_HOLD_END / 2; // Scanner near or slightly past the end downwardly
		}
		var timeReachedOrPassedEnd = currentTimeMs >= noteExpectedEndTimeMs - HOLD_END_GRACE_PERIOD_MS;
		var timeNotTooLate = currentTimeMs <= noteExpectedEndTimeMs + HOLD_END_GRACE_PERIOD_MS + 200; // Not held excessively long
		if (scannerAtEnd && timeReachedOrPassedEnd && timeNotTooLate) {
			heldNote.completeHold();
			LK.setScore(LK.getScore() + 50); // More points for a successful hold
			scoreTxt.setText(LK.getScore());
			if (LK.getScore() >= TARGET_SCORE_TO_WIN) {
				LK.showYouWin();
				gameStartTime = null;
				gameStarted = false;
				tween.stop(scanner);
			}
		} else {
			heldNote.failHold();
			// playerHealth--;//{5x} // Health decrement removed
			// updateHealthDisplay();//{5y} // Health display update removed
		}
	}
	// This bracket no longer closes an "else" block, but the "if (heldNote && heldNote.isHolding)" block.
	isDragging = false; // Reset general dragging flag.
	// currentTrail cleanup is removed as it's no longer created.
};
game.update = function () {
	if (!gameStarted) return; //{5C} // playerHealth check removed
	var currentTime = Date.now() - gameStartTime;
	spawnNotesForCurrentTime(currentTime);
	for (var i = notes.length - 1; i >= 0; i--) {
		var note = notes[i];
		if (!note) {
			notes.splice(i, 1);
			continue;
		}
		// Update hold effects if note is being held
		if (note.type === 'hold' && note.isHolding && note.active && !note.holdSuccessfullyCompleted && !note.isMissed) {
			note.updateHoldEffects(scanner.y);
			// Fail-safe for holds that are held too long past their end time
			var currentTimeMsForUpdate = Date.now() - gameStartTime;
			var noteExpectedEndTimeMsForUpdate = note.hitTime + note.duration;
			if (currentTimeMsForUpdate > noteExpectedEndTimeMsForUpdate + HOLD_END_GRACE_PERIOD_MS + 500) {
				// 500ms buffer
				if (activeHoldNotes[note.zone] === note) {
					// Still registered as actively held
					note.failHold();
					// playerHealth--;//{5I} // Health decrement removed
					// updateHealthDisplay();//{5J} // Health display update removed
					delete activeHoldNotes[note.zone];
				}
			}
		}
		// Check for missed notes
		if (note.active && !note.isHit && !note.isMissed && !note.isSpawning) {
			var timeDiff = currentTime - note.hitTime;
			var scannerPassed = false;
			if (scannerIsMovingUp && scanner.y < note.y - 50) {
				scannerPassed = true;
			} else if (!scannerIsMovingUp && scanner.y > note.y + 50) {
				scannerPassed = true;
			}
			if (scannerPassed && timeDiff > 300) {
				note.isMissed = true;
				note.showMissEffect();
				// playerHealth--;//{5Q} // Health decrement removed
				// updateHealthDisplay();//{5R} // Health display update removed
				// if (playerHealth <= 0) {//{5S} // Game over check removed
				// return;
				// }
			}
		}
		// Cleanup inactive notes
		if (!note.active) {
			notes.splice(i, 1);
			if (game.children.indexOf(note) > -1) {
				game.removeChild(note);
			}
			if (note.destroy) {
				note.destroy();
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -530,310 +530,348 @@
 	generateSong: function generateSong(config) {
 		var notes = [];
 		var totalLength = config.totalLength || 202136;
 		var startTime = config.startDelay || 2000;
-		// Generate notes with consistent density throughout the song
-		notes = this.generateDensityBasedSong(startTime, totalLength);
-		// Original cleanupNotes is removed as density based approach should ideally manage conflicts by design.
-		// If conflicts are still an issue, a similar cleanup function might be needed or adjustments to generation logic.
-		// For now, let's assume the new generator produces clean notes or that cleanup will be added later if necessary.
+		notes = this.generateZoneAwareSong(startTime, totalLength);
 		notes.sort(function (a, b) {
 			return a.time - b.time;
 		}); // Ensure notes are sorted
 		return notes;
 	},
-	generateDensityBasedSong: function generateDensityBasedSong(startTime, songTotalLength) {
-		// songTotalLength is the total duration of the song audio
+	generateZoneAwareSong: function generateZoneAwareSong(startTime, songTotalLength) {
 		var notes = [];
-		// Define sections relative to the song's actual start time (0 for song's beginning)
-		// The 'startTime' parameter for generateSong is an offset *before* the song's actual 0-time for notes
+		var currentTime = startTime;
+		// Track when each zone will be free
+		var zoneFreeTime = {
+			left: startTime,
+			right: startTime
+		};
+		// Minimum spacing between notes (human reaction time)
+		var MIN_SAME_ZONE_SPACING = 400; // 400ms minimum in same zone
+		var MIN_DIFFERENT_ZONE_SPACING = 200; // 200ms minimum between different zones
+		var MIN_SYNC_SPACING = 800; // 800ms minimum between sync notes
+		var lastSyncTime = startTime - MIN_SYNC_SPACING; // Initialize to allow early sync
+		// Define sections with different complexities
 		var sections = [{
 			start: 0,
 			end: 16000,
-			intensity: 0.3,
-			name: 'intro'
+			complexity: 'simple'
 		}, {
 			start: 16000,
 			end: 48000,
-			intensity: 0.6,
-			name: 'verse1'
+			complexity: 'medium'
 		}, {
 			start: 48000,
 			end: 72000,
-			intensity: 0.8,
-			name: 'chorus1'
-		}, {
+			complexity: 'medium'
+		},
+		// Original: chorus1, intensity 0.8
+		{
 			start: 72000,
 			end: 104000,
-			intensity: 0.6,
-			name: 'verse2'
+			complexity: 'medium'
 		}, {
 			start: 104000,
 			end: 128000,
-			intensity: 0.9,
-			name: 'chorus2'
-		}, {
+			complexity: 'complex'
+		},
+		// Original: chorus2, intensity 0.9
+		{
 			start: 128000,
 			end: 160000,
-			intensity: 0.7,
-			name: 'verse3'
+			complexity: 'medium'
 		}, {
 			start: 160000,
 			end: 184000,
-			intensity: 1.0,
-			name: 'finalchorus'
-		}, {
+			complexity: 'complex'
+		},
+		// Original: finalchorus, intensity 1.0
+		{
 			start: 184000,
-			end: 202136,
-			intensity: 0.4,
-			name: 'outro'
-		} // Ensure last section ends at songTotalLength
+			end: songTotalLength,
+			complexity: 'simple'
+		} // Ensure it goes to the end
 		];
-		var beatInterval = 500; // Base beat (120 BPM = 500ms per beat)
 		for (var s = 0; s < sections.length; s++) {
 			var section = sections[s];
-			// Adjust section start and end times by the initial `startTime` delay for note spawning
 			var sectionStartTime = startTime + section.start;
 			var sectionEndTime = startTime + section.end;
-			// Ensure sectionEndTime does not exceed the overall song length plus start delay
 			if (sectionEndTime > startTime + songTotalLength) {
 				sectionEndTime = startTime + songTotalLength;
 			}
-			if (sectionStartTime >= sectionEndTime) continue; // Skip if section has no duration
-			var sectionNotes = this.generateSection(sectionStartTime, sectionEndTime, section.intensity, beatInterval);
-			notes = notes.concat(sectionNotes);
-		}
-		return notes;
-	},
-	generateSection: function generateSection(startTime, endTime, intensity, beatInterval) {
-		var notes = [];
-		var currentTime = startTime;
-		var patterns = this.getPatterns(intensity);
-		var patternIndex = 0;
-		var lastNoteTimes = {
-			left: -Infinity,
-			right: -Infinity
-		}; // Track last note time for each zone
-		var MIN_SPACING = 200; // Minimum ms between notes in the same zone
-		while (currentTime < endTime - 1000) {
-			// Leave 1s buffer at end of section
-			if (patterns.length === 0) break; // No patterns for this intensity
-			var patternDef = patterns[patternIndex % patterns.length];
-			var patternNotesRaw = this.createPattern(patternDef, currentTime);
-			var validPatternNotes = [];
-			var patternDuration = patternDef.duration; // Use defined duration
-			var canPlaceAll = true;
-			for (var k = 0; k < patternNotesRaw.length; k++) {
-				var rawNote = patternNotesRaw[k];
-				if (rawNote.time < endTime - 500) {
-					// Check if note fits in section
-					// Check spacing for the specific zone
-					var lastTimeInZone = lastNoteTimes[rawNote.zone];
-					if (rawNote.time - lastTimeInZone < MIN_SPACING) {
-						// Check for holds, if it's a hold, the spacing might need to consider its duration
-						if (rawNote.type === 'hold' && rawNote.time - lastTimeInZone < (rawNote.duration || 1000)) {
-							canPlaceAll = false;
+			if (sectionStartTime >= sectionEndTime) continue;
+			currentTime = Math.max(currentTime, sectionStartTime);
+			while (currentTime < sectionEndTime - 1000) {
+				// Leave 1s buffer at end of section
+				var pattern = this.selectPattern(section.complexity, zoneFreeTime, currentTime, lastSyncTime);
+				var patternResult = this.placePattern(pattern, currentTime, zoneFreeTime, MIN_SAME_ZONE_SPACING, MIN_DIFFERENT_ZONE_SPACING, sectionEndTime);
+				if (patternResult.notes.length > 0) {
+					var allNotesFit = true;
+					for (var ni = 0; ni < patternResult.notes.length; ni++) {
+						if (patternResult.notes[ni].time + (patternResult.notes[ni].duration || 0) > sectionEndTime - 200) {
+							// Check end time
+							allNotesFit = false;
 							break;
-						} else if (rawNote.type !== 'hold') {
-							canPlaceAll = false;
-							break;
 						}
 					}
+					if (allNotesFit) {
+						notes = notes.concat(patternResult.notes);
+						currentTime = patternResult.nextTime;
+						if (pattern.type === 'sync') {
+							lastSyncTime = patternResult.notes[0].time; // Time of the sync notes themselves
+						}
+					} else {
+						currentTime += 300; // Advance time if pattern didn't fit
+					}
 				} else {
-					canPlaceAll = false; // Note extends beyond section
-					break;
+					currentTime += 300; // If pattern couldn't be placed, advance time
 				}
+				if (currentTime >= sectionEndTime - 1000) break;
 			}
-			if (canPlaceAll) {
-				for (var l = 0; l < patternNotesRaw.length; l++) {
-					var noteToAdd = patternNotesRaw[l];
-					validPatternNotes.push(noteToAdd);
-					lastNoteTimes[noteToAdd.zone] = noteToAdd.time + (noteToAdd.type === 'hold' ? noteToAdd.duration || 0 : 0);
-				}
-				notes = notes.concat(validPatternNotes);
-			}
-			currentTime += patternDuration;
-			patternIndex++;
-			currentTime += Math.random() * 100 - 50; // ±50ms variation
-			if (currentTime < startTime) currentTime = startTime; // Ensure currentTime does not go backward
 		}
 		return notes;
 	},
-	getPatterns: function getPatterns(intensity) {
-		if (intensity <= 0.4) {
-			// Low intensity - simple patterns
-			return [{
+	selectPattern: function selectPattern(complexity, zoneFreeTime, currentTime, lastSyncTime) {
+		var patterns = [];
+		var MIN_SYNC_SPACING = 800; // Local constant for clarity
+		if (complexity === 'simple') {
+			patterns = [{
 				type: 'single',
 				zone: 'left',
-				duration: 1000
+				duration: 500
 			}, {
 				type: 'single',
 				zone: 'right',
-				duration: 1000
+				duration: 500
 			}, {
-				type: 'sync',
-				duration: 1000
-			}, {
 				type: 'rest',
 				duration: 1000
 			}];
-		} else if (intensity <= 0.7) {
-			// Medium intensity
-			return [{
-				type: 'alternating',
-				duration: 1000
-			},
-			// Two taps, 250ms apart
-			{
-				type: 'sync',
-				duration: 500
-			}, {
+			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
+				patterns.push({
+					type: 'sync',
+					duration: 600
+				});
+			}
+		} else if (complexity === 'medium') {
+			patterns = [{
 				type: 'single',
 				zone: 'left',
-				duration: 500
+				duration: 400
 			}, {
 				type: 'single',
 				zone: 'right',
-				duration: 500
+				duration: 400
 			}, {
+				type: 'alternating',
+				duration: 600
+			},
+			// two taps, 250ms apart
+			{
 				type: 'hold',
 				zone: 'left',
-				duration: 2000,
-				holdLength: 1500
+				holdDuration: 1500,
+				duration: 800
 			}, {
 				type: 'hold',
 				zone: 'right',
-				duration: 2000,
-				holdLength: 1500
+				holdDuration: 1500,
+				duration: 800
+			}, {
+				type: 'rest',
+				duration: 800
 			}];
+			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
+				patterns.push({
+					type: 'sync',
+					duration: 600
+				});
+			}
 		} else {
-			// High intensity
-			return [{
-				type: 'sync',
-				duration: 500
+			// complex
+			patterns = [{
+				type: 'single',
+				zone: 'left',
+				duration: 300
 			}, {
+				type: 'single',
+				zone: 'right',
+				duration: 300
+			}, {
 				type: 'alternating',
 				duration: 500
 			},
-			// Two taps, 250ms apart
+			// two taps, 250ms apart
 			{
-				type: 'triplet',
+				type: 'hold',
 				zone: 'left',
-				duration: 750
-			},
-			// 3 taps, 167ms apart
-			{
-				type: 'triplet',
+				holdDuration: 1500,
+				duration: 800
+			}, {
+				type: 'hold',
 				zone: 'right',
-				duration: 750
+				holdDuration: 1500,
+				duration: 800
 			}, {
-				type: 'sync',
-				duration: 250
-			},
-			// Quick sync
-			{
 				type: 'holdWithTaps',
 				zone: 'left',
-				duration: 2500,
-				holdLength: 2000
+				holdDuration: 2000,
+				duration: 1000
+			}, {
+				type: 'holdWithTaps',
+				zone: 'right',
+				holdDuration: 2000,
+				duration: 1000
 			}];
+			if (currentTime - lastSyncTime >= MIN_SYNC_SPACING) {
+				patterns.push({
+					type: 'sync',
+					duration: 500
+				}); // Shorter duration for sync in complex sections
+			}
 		}
+		return patterns[Math.floor(Math.random() * patterns.length)];
 	},
-	createPattern: function createPattern(pattern, startTime) {
+	placePattern: function placePattern(pattern, requestedTime, zoneFreeTime, minSameZoneSpacing, minDiffZoneSpacing, sectionEndTime) {
 		var notes = [];
-		switch (pattern.type) {
-			case 'single':
+		var earliestTime = requestedTime;
+		var nextTimeAdvance = pattern.duration || 500; // Default advancement
+		if (pattern.type === 'single') {
+			earliestTime = Math.max(requestedTime, zoneFreeTime[pattern.zone]);
+			if (earliestTime + (pattern.duration || 0) < sectionEndTime) {
 				notes.push({
-					time: startTime,
+					time: earliestTime,
 					type: 'tap',
 					zone: pattern.zone
 				});
-				break;
-			case 'sync':
+				zoneFreeTime[pattern.zone] = earliestTime + minSameZoneSpacing;
+				return {
+					notes: notes,
+					nextTime: earliestTime + nextTimeAdvance
+				};
+			}
+		} else if (pattern.type === 'sync') {
+			earliestTime = Math.max(requestedTime, zoneFreeTime.left, zoneFreeTime.right);
+			if (earliestTime + (pattern.duration || 0) < sectionEndTime) {
 				notes.push({
-					time: startTime,
+					time: earliestTime,
 					type: 'tap',
 					zone: 'left'
 				});
 				notes.push({
-					time: startTime,
+					time: earliestTime,
 					type: 'tap',
 					zone: 'right'
 				});
-				break;
-			case 'alternating':
-				// Assumes left then right, 250ms spacing within a 500ms or 1000ms pattern duration
+				zoneFreeTime.left = earliestTime + minSameZoneSpacing;
+				zoneFreeTime.right = earliestTime + minSameZoneSpacing;
+				return {
+					notes: notes,
+					nextTime: earliestTime + nextTimeAdvance
+				};
+			}
+		} else if (pattern.type === 'alternating') {
+			// Attempt Left then Right
+			var firstZone = Math.random() < 0.5 ? 'left' : 'right';
+			var secondZone = firstZone === 'left' ? 'right' : 'left';
+			var t1 = Math.max(requestedTime, zoneFreeTime[firstZone]);
+			var t2 = Math.max(t1 + minDiffZoneSpacing, zoneFreeTime[secondZone]);
+			if (t2 + (pattern.duration || 0) - (t2 - t1) < sectionEndTime) {
+				// check if second note fits
 				notes.push({
-					time: startTime,
+					time: t1,
 					type: 'tap',
-					zone: 'left'
+					zone: firstZone
 				});
 				notes.push({
-					time: startTime + 250,
+					time: t2,
 					type: 'tap',
-					zone: 'right'
+					zone: secondZone
 				});
-				break;
-			case 'triplet':
-				// 3 taps, 167ms spacing
-				for (var i = 0; i < 3; i++) {
-					notes.push({
-						time: startTime + i * 167,
-						type: 'tap',
-						zone: pattern.zone
-					});
-				}
-				break;
-			case 'hold':
+				zoneFreeTime[firstZone] = t1 + minSameZoneSpacing;
+				zoneFreeTime[secondZone] = t2 + minSameZoneSpacing;
+				return {
+					notes: notes,
+					nextTime: t2 + minDiffZoneSpacing
+				}; // Next logical placement time
+			}
+		} else if (pattern.type === 'hold') {
+			earliestTime = Math.max(requestedTime, zoneFreeTime[pattern.zone]);
+			var holdDuration = pattern.holdDuration || 1500;
+			if (earliestTime + holdDuration < sectionEndTime) {
 				notes.push({
-					time: startTime,
+					time: earliestTime,
 					type: 'hold',
 					zone: pattern.zone,
-					duration: pattern.holdLength || 1500
+					duration: holdDuration
 				});
-				break;
-			case 'holdWithTaps':
+				zoneFreeTime[pattern.zone] = earliestTime + holdDuration + 200; // Buffer after hold
+				return {
+					notes: notes,
+					nextTime: earliestTime + nextTimeAdvance
+				}; // Pattern's own duration logic
+			}
+		} else if (pattern.type === 'holdWithTaps') {
+			var holdZone = pattern.zone;
+			var tapZone = holdZone === 'left' ? 'right' : 'left';
+			var holdStart = Math.max(requestedTime, zoneFreeTime[holdZone]);
+			var mainHoldDuration = pattern.holdDuration || 2000;
+			if (holdStart + mainHoldDuration < sectionEndTime) {
 				notes.push({
-					time: startTime,
+					time: holdStart,
 					type: 'hold',
-					zone: pattern.zone,
-					duration: pattern.holdLength || 2000
+					zone: holdZone,
+					duration: mainHoldDuration
 				});
-				var tapZone = pattern.zone === 'left' ? 'right' : 'left';
-				notes.push({
-					time: startTime + 500,
-					type: 'tap',
-					zone: tapZone
-				});
-				notes.push({
-					time: startTime + 1000,
-					type: 'tap',
-					zone: tapZone
-				});
-				break;
-			case 'rest':
-				// No notes
-				break;
+				zoneFreeTime[holdZone] = holdStart + mainHoldDuration + 200;
+				var tap1Time = Math.max(holdStart + 500, zoneFreeTime[tapZone]);
+				if (tap1Time < holdStart + mainHoldDuration - 500 && tap1Time + minSameZoneSpacing < sectionEndTime) {
+					notes.push({
+						time: tap1Time,
+						type: 'tap',
+						zone: tapZone
+					});
+					zoneFreeTime[tapZone] = tap1Time + minSameZoneSpacing;
+					var tap2Time = Math.max(tap1Time + minSameZoneSpacing, zoneFreeTime[tapZone]); // Ensure tap2 is after tap1 is free
+					if (tap2Time < holdStart + mainHoldDuration - 200 && tap2Time + minSameZoneSpacing < sectionEndTime) {
+						notes.push({
+							time: tap2Time,
+							type: 'tap',
+							zone: tapZone
+						});
+						zoneFreeTime[tapZone] = tap2Time + minSameZoneSpacing;
+					}
+				}
+				return {
+					notes: notes,
+					nextTime: holdStart + nextTimeAdvance
+				};
+			}
+		} else if (pattern.type === 'rest') {
+			return {
+				notes: [],
+				nextTime: requestedTime + (pattern.duration || 500)
+			};
 		}
-		return notes;
+		return {
+			notes: [],
+			nextTime: requestedTime + 100
+		}; // Failed to place, small advance
 	}
 };
 // Simpler song database
 var SongDatabase = {
 	'gameMusic': {
 		bpm: 120,
-		// Remains for reference, but new generator doesn't directly use it
 		scannerCycleDuration: 4000,
 		totalLength: 202136,
-		// Actual duration of the music track
 		notes: null
 	}
 };
 // Generate with the new system
 SongDatabase['gameMusic'].notes = SongGenerator.generateSong({
 	startDelay: 2000,
-	// Time before the first note appears, relative to game start
-	totalLength: SongDatabase['gameMusic'].totalLength // Pass the song's actual total length
+	totalLength: SongDatabase['gameMusic'].totalLength
 });
 var defaultSongData = SongDatabase['gameMusic'];
 // Helper function to add new songs easily
 function addSong(songId, config) {