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

/**** 
* Classes
****/ 
// Confetti for success
var Confetti = Container.expand(function () {
	var self = Container.call(this);
	var asset = self.attachAsset('confetti', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.vx = (Math.random() - 0.5) * 20;
	self.vy = -Math.random() * 20 - 10;
	self.life = 40 + Math.random() * 20;
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
		self.vy += 1.2;
		self.life--;
		asset.rotation += 0.2;
		if (self.life <= 0) {
			self.destroy();
		}
	};
	return self;
});
// Fail splash for miss
var FailSplash = Container.expand(function () {
	var self = Container.call(this);
	var asset = self.attachAsset('failSplash', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	asset.alpha = 0.7;
	self.life = 20;
	self.update = function () {
		asset.scaleX += 0.1;
		asset.scaleY += 0.1;
		asset.alpha -= 0.03;
		self.life--;
		if (self.life <= 0) {
			self.destroy();
		}
	};
	return self;
});
// Note: All note types (tap, hold, glide) are handled by the Note class with type property.
var Note = Container.expand(function () {
	var self = Container.call(this);
	// Properties: type ('tap', 'hold', 'glide'), pitch (0-1), time, duration (for hold/glide), glideTo (for glide)
	self.type = 'tap';
	self.pitch = 0.5; // 0 (bottom) to 1 (top)
	self.time = 0; // When the note should be hit (in ms)
	self.duration = 0; // For hold/glide notes (ms)
	self.glideTo = null; // For glide notes: target pitch (0-1)
	// Visuals: Remove the long bar for all notes, only use the note head and curveBars for visual
	// Create a tiny invisible asset to keep .noteAsset for hit/miss feedback, but don't show a long bar
	var noteAsset = self.attachAsset('holdBar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	noteAsset.width = 1;
	noteAsset.height = 1;
	noteAsset.alpha = 0; // Hide the main bar, only use for scaling feedback
	self.noteAsset = noteAsset;
	// Add a note head (noteTap) at the start of every note for good catch feedback
	var noteHead = self.attachAsset('noteTap', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Showdown: make note head larger and more distinct for musical section
	noteHead.width = 100;
	noteHead.height = 100;
	noteHead.x = -noteAsset.width / 2; // Start at the left end of the bar
	noteHead.y = 0;
	self.noteHead = noteHead;
	// Curvy bar for duration: approximate with a sequence of small rectangles to simulate a curve
	self.curveBars = [];
	var curveBarCount = 22; // More = smoother, more musical
	for (var i = 0; i < curveBarCount; i++) {
		var seg = self.attachAsset('holdBar', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Showdown: make curve bars more musical and visually clear
		seg.width = 22;
		seg.height = 30;
		seg.alpha = 0.8;
		if (self.type === 'tap') {
			seg.tint = 0x66ccff;
		} else if (self.type === 'hold') {
			seg.tint = 0x44dd88;
		} else if (self.type === 'glide') {
			seg.tint = 0xff66aa;
		} else {
			seg.tint = 0xffffff;
		}
		self.curveBars.push(seg);
	}
	// State
	self.hit = false; // Whether the note has been hit
	self.missed = false; // Whether the note was missed
	// For glide: cache start/end pitch
	self.glideStart = null;
	self.glideEnd = null;
	// Update visuals per frame
	self.update = function () {
		// All notes are now click-and-hold for a variable duration (not just tap)
		// The bar is always horizontal and its length reflects the duration
		// For tap: treat as a short hold, so bar length is based on tapHoldDuration
		var tapHoldDuration = 400; // ms, how long you must hold for a tap note (difficulty can adjust this)
		var barLen = 0;
		var startPitch = self.pitch;
		var endPitch = self.pitch;
		if (self.type === 'tap') {
			barLen = Math.max(80, tapHoldDuration * noteSpeed);
			self.duration = tapHoldDuration;
		} else if (self.type === 'hold') {
			barLen = Math.max(80, (self.duration || 1) * noteSpeed);
		} else if (self.type === 'glide') {
			barLen = Math.max(80, (self.duration || 1) * noteSpeed);
			startPitch = self.glideStart !== null ? self.glideStart : self.pitch;
			endPitch = self.glideEnd !== null ? self.glideEnd : self.pitch;
		}
		// The main bar is hidden, so only show the note head and curveBars as small segments
		self.noteAsset.x = 0;
		self.noteAsset.y = 0;
		// Place the note head at the start of the bar
		if (self.noteHead) {
			self.noteHead.x = -barLen / 2;
			self.noteHead.y = 0;
		}
		// Only show curveBars for hold and glide notes, hide for tap
		for (var i = 0; i < self.curveBars.length; i++) {
			var seg = self.curveBars[i];
			var t = i / (self.curveBars.length - 1);
			var x = t * barLen;
			var y = 0;
			var show = false;
			if (self.type === 'tap') {
				// Hide curveBars for tap notes
				seg.visible = false;
				continue;
			} else if (self.type === 'hold') {
				// Use holdShape and holdShapeParams for custom shapes (curvy, zigzag, diagonal, flat)
				var shape = self.holdShape || (self.holdShapeParams ? 'custom' : null);
				var params = self.holdShapeParams || {};
				if (shape === 'zigzag') {
					// Zigzag: alternate up/down with frequency and amplitude
					var amp = typeof params.amplitude === "number" ? params.amplitude : 0.12;
					var freq = typeof params.frequency === "number" ? params.frequency : 3;
					var phase = typeof params.phase === "number" ? params.phase : 0;
					// Zigzag in pitch space, then convert to y
					var pitchOffset = Math.sin(t * Math.PI * freq + phase) * amp;
					y = pitchToY(self.pitch + pitchOffset) - pitchToY(self.pitch);
				} else if (shape === 'curvy') {
					// Curvy: smooth sine wave
					var amp = typeof params.amplitude === "number" ? params.amplitude : 0.13;
					var freq = typeof params.frequency === "number" ? params.frequency : 2.2;
					var phase = typeof params.phase === "number" ? params.phase : 0;
					var pitchOffset = Math.sin(t * Math.PI * freq + phase) * amp;
					y = pitchToY(self.pitch + pitchOffset) - pitchToY(self.pitch);
				} else if (shape === 'diagonal') {
					// Diagonal: linear pitch change
					var slope = typeof params.slope === "number" ? params.slope : 0.1;
					var pitchOffset = t * slope;
					y = pitchToY(self.pitch + pitchOffset) - pitchToY(self.pitch);
				} else if (shape === 'custom') {
					// fallback: flat
					y = 0;
				} else {
					// fallback: flat
					y = 0;
				}
				show = true;
			} else if (self.type === 'glide') {
				// Interpolate pitch for glide
				var pitch = lerp(startPitch, endPitch, t);
				var y0 = pitchToY(startPitch);
				var y1 = pitchToY(endPitch);
				y = lerp(y0, y1, t) - pitchToY(self.pitch);
				show = true;
			}
			// Only show every other segment for a "dotted" look, or randomize for zigzag
			if (show) {
				if (self.type === 'hold' && self.holdShape === 'curvy') {
					// For curvy, show every other segment for a dotted curve
					seg.visible = i % 2 === 0;
				} else if (self.type === 'hold' && self.holdShape === 'zigzag') {
					// For zigzag, show all segments for a solid zigzag
					seg.visible = true;
				} else if (self.type === 'hold' && self.holdShape === 'diagonal') {
					// For diagonal, show every segment for a dashed line
					seg.visible = i % 2 === 0;
				} else if (self.type === 'hold') {
					// For flat/custom, show all segments
					seg.visible = true;
				} else if (self.type === 'glide') {
					// For glide, show every other segment for a dotted line
					seg.visible = i % 2 === 0;
				} else {
					seg.visible = false;
				}
			} else {
				seg.visible = false;
			}
			seg.x = x - barLen / 2 + 60;
			seg.y = y;
			seg.rotation = 0;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Trombone pitch sound assets for different pitch levels
// --- Constants ---
// Trombone Slide Showdown - Asset Initialization
// Note: Asset creation is handled automatically by LK based on usage below.
// Trombone slide bar (vertical pitch bar)
// Note types
// Hold bar (for hold notes)
// Hit zone
// Comedic feedback
// Sounds (placeholders, actual sound assets will be loaded by LK)
// Music (background track)
// 10 different slide up and 10 different slide down assets
// 10 slide down sounds, evenly split across the sample
// 10 slide up sounds, evenly split across the sample
function _typeof(o) {
	"@babel/helpers - typeof";
	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _defineProperty(e, r, t) {
	return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
		value: t,
		enumerable: !0,
		configurable: !0,
		writable: !0
	}) : e[r] = t, e;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : i + "";
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) return t;
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) return i;
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
var gameWidth = 2048;
var gameHeight = 2732;
// Pitch bar (vertical, left side)
var pitchBarHeight = 1800;
var pitchBarY = (gameHeight - pitchBarHeight) / 2;
var pitchBarX = 120;
// Hit zone (where notes should be hit)
var hitZoneX = 340;
var hitZoneWidth = 140;
// Note scroll area
var noteStartX = gameWidth + 1000; // Offscreen right (even further than before)
var noteEndX = hitZoneX; // Hit zone
// Note speed (pixels per ms)
var noteSpeed = 1.2; // px/ms (tune for difficulty)
// --- State ---
var notes = []; // All notes in the song
var activeNotes = []; // Notes currently on screen
var currentTime = 0; // ms since song start
var songStarted = false;
var songEnded = false;
var score = 0;
var combo = 0;
var maxCombo = 0;
var accuracySum = 0;
var accuracyCount = 0;
// --- Song Selection Menu ---
// Rebuild hold note data to generate zigzag, curvy, diagonal, flat, and random horizontal hold bars
function randomHoldShape(pitch, duration, idx) {
	// Avoid too vertical, favor horizontal/curvy/zigzag/diagonal/flat
	var shapes = ['zigzag', 'curvy', 'diagonal', 'flat'];
	// Weighted: more horizontal/curvy/zigzag
	var weights = [2, 2, 1, 1];
	var total = 0;
	for (var i = 0; i < weights.length; i++) total += weights[i];
	var r = Math.random() * total;
	var acc = 0;
	var shape = 'curvy';
	for (var i = 0; i < shapes.length; i++) {
		acc += weights[i];
		if (r < acc) {
			shape = shapes[i];
			break;
		}
	}
	// Parameters for each shape
	if (shape === 'zigzag') {
		return {
			holdShape: 'zigzag',
			holdShapeParams: {
				amplitude: 0.09 + Math.random() * 0.07,
				// 0.09-0.16
				frequency: 2 + Math.random() * 2.5,
				// 2-4.5
				phase: Math.random() * Math.PI * 2
			}
		};
	} else if (shape === 'curvy') {
		return {
			holdShape: 'curvy',
			holdShapeParams: {
				amplitude: 0.08 + Math.random() * 0.08,
				// 0.08-0.16
				frequency: 1.2 + Math.random() * 1.8,
				// 1.2-3
				phase: Math.random() * Math.PI * 2
			}
		};
	} else if (shape === 'diagonal') {
		// Slope: -0.18 to 0.18, but not too steep
		var slope = (Math.random() - 0.5) * 0.28;
		if (Math.abs(slope) < 0.08) slope = slope < 0 ? -0.12 : 0.12;
		return {
			holdShape: 'diagonal',
			holdShapeParams: {
				slope: slope
			}
		};
	} else if (shape === 'flat') {
		return {
			holdShape: 'diagonal',
			holdShapeParams: {
				slope: 0
			}
		};
	}
	// fallback
	return {
		holdShape: 'curvy',
		holdShapeParams: {
			amplitude: 0.1,
			frequency: 2,
			phase: 0
		}
	};
}
// Build a new songList with only hold and glide notes, each hold note gets a random zigzag, curvy, flat, or diagonal shape
var songList = [{
	name: "Showdown (Default)",
	id: "bgmusic",
	notes: function () {
		// --- Note spacing: short, normal, long ---
		// Short: 800ms, Normal: 1600ms, Long: 2400ms
		var spacingTypes = [800,
		// short
		1200,
		// short/normal
		1600,
		// normal
		2000,
		// normal/long
		2400 // long
		];
		// Helper to pick a random spacing
		function randomSpacing() {
			var idx = Math.floor(Math.random() * spacingTypes.length);
			return spacingTypes[idx];
		}
		// --- Showdown music section: more musical, more variety, more notes, more shapes ---
		var baseNotes = [];
		var t = 3400;
		// Section 1: Alternating short/normal/long, up and down
		for (var i = 0; i < 8; i++) {
			var spacing = i % 3 === 0 ? 800 : i % 3 === 1 ? 1600 : 2400;
			baseNotes.push({
				type: i % 2 === 0 ? 'hold' : 'glide',
				time: t,
				pitch: i % 2 === 0 ? 0.3 + 0.1 * i : 0.8 - 0.1 * i,
				duration: i % 2 === 0 ? 1000 + 200 * (i % 3) : 1200 + 200 * (i % 2),
				glideTo: i % 2 === 1 ? i % 4 === 1 ? 0.2 + 0.1 * i : 0.8 - 0.1 * i : undefined
			});
			t += spacing;
		}
		// Section 2: Quick short bursts
		for (var i = 0; i < 6; i++) {
			var spacing = randomSpacing();
			baseNotes.push({
				type: i % 2 === 0 ? 'hold' : 'glide',
				time: t,
				pitch: 0.5 + 0.2 * Math.sin(i),
				duration: 900 + 100 * (i % 2),
				glideTo: i % 2 === 1 ? 0.4 + 0.2 * Math.cos(i) : undefined
			});
			t += spacing;
		}
		// Section 3: Normal/long, up and down
		for (var i = 0; i < 8; i++) {
			var spacing = i % 2 === 0 ? 1600 : 2400;
			baseNotes.push({
				type: i % 2 === 0 ? 'hold' : 'glide',
				time: t,
				pitch: i % 2 === 0 ? 0.2 + 0.07 * i : 0.8 - 0.07 * i,
				duration: 1200 + 200 * (i % 3),
				glideTo: i % 2 === 1 ? 0.1 + 0.07 * i : undefined
			});
			t += spacing;
		}
		// Section 4: Fast short notes
		for (var i = 0; i < 6; i++) {
			var spacing = 800;
			baseNotes.push({
				type: i % 2 === 0 ? 'hold' : 'glide',
				time: t,
				pitch: 0.3 + 0.1 * (i % 3),
				duration: 900,
				glideTo: i % 2 === 1 ? 0.7 - 0.1 * (i % 3) : undefined
			});
			t += spacing;
		}
		// Section 5: Big finish, long notes
		for (var i = 0; i < 4; i++) {
			var spacing = 2400;
			baseNotes.push({
				type: i % 2 === 0 ? 'hold' : 'glide',
				time: t,
				pitch: 0.4 + 0.1 * i,
				duration: 1200 + 200 * i,
				glideTo: i % 2 === 1 ? 0.1 + 0.2 * i : undefined
			});
			t += spacing;
		}
		// For each note, force all to be 'hold' type for click-hold mechanic, and ensure no gaps between notes
		var notes = [];
		var lastEndTime = 0;
		for (var i = 0; i < baseNotes.length; i++) {
			var n = {};
			for (var k in baseNotes[i]) n[k] = baseNotes[i][k];
			// For each note, force all to be 'hold' type for click-hold mechanic, and allow some gaps between notes.
			n.type = 'hold';
			// --- Make some notes longer and some shorter ---
			// 30% chance to be short, 40% normal, 30% long
			var durRand = Math.random();
			if (durRand < 0.3) {
				n.duration = 800 + Math.floor(Math.random() * 200); // short
			} else if (durRand < 0.7) {
				n.duration = 1400 + Math.floor(Math.random() * 300); // normal
			} else {
				n.duration = 2000 + Math.floor(Math.random() * 400); // long
			}
			// For tap notes, treat as short hold
			if (baseNotes[i].type === 'tap') {
				n.duration = 400;
			}
			// Allow some notes to have a gap before them (randomly, 30% chance, but never before the first note)
			var insertGap = false;
			var gapLength = 0;
			if (i > 0 && Math.random() < 0.3) {
				insertGap = true;
				// Pick a random gap length (short/normal/long)
				var gapOptions = [400, 800, 1200];
				gapLength = gapOptions[Math.floor(Math.random() * gapOptions.length)];
			}
			// Set this note's time to exactly when the previous note ends, plus gap if any
			// Always add a minimum gap after a hold note's end before the next noteTap
			var minGapAfterHold = 320; // ms, adjust for desired spacing
			if (i === 0) {
				// First note, keep its time
				lastEndTime = n.time + (n.duration || 0);
			} else {
				// Always add a minimum gap after a hold note
				n.time = lastEndTime + minGapAfterHold + gapLength;
				lastEndTime = n.time + (n.duration || 0);
			}
			// All hold notes get a random shape (zigzag, curvy, diagonal, flat) and random up/down direction
			if (n.type === 'hold' && n.duration && n.duration > 0) {
				// 50% chance to reverse (start up, finish down or vice versa)
				var shapeData = randomHoldShape(n.pitch, n.duration, i);
				n.holdShape = shapeData.holdShape;
				n.holdShapeParams = shapeData.holdShapeParams;
				// Randomly flip direction for diagonal, zigzag, curvy
				if (Math.random() < 0.5) {
					if (n.holdShape === 'diagonal' && n.holdShapeParams) {
						n.holdShapeParams.slope = -n.holdShapeParams.slope;
					}
					if (n.holdShapeParams && typeof n.holdShapeParams.amplitude === "number") {
						n.holdShapeParams.amplitude = -n.holdShapeParams.amplitude;
					}
					if (n.holdShapeParams && typeof n.holdShapeParams.phase === "number") {
						n.holdShapeParams.phase += Math.PI;
					}
				}
			}
			notes.push(n);
		}
		return notes;
	}()
}];
var menuContainer = new Container();
game.addChild(menuContainer);
// Menu background REMOVED (pitchBarBg)
var menuTitle = new Text2("Select a Song", {
	size: 120,
	fill: 0xFFE066
});
menuTitle.anchor.set(0.5, 0);
menuTitle.x = gameWidth / 2;
menuTitle.y = gameHeight / 2 - 350;
menuContainer.addChild(menuTitle);
var menuButtons = [];
for (var i = 0; i < songList.length; i++) {
	(function (idx) {
		var song = songList[idx];
		var btn = new Text2(song.name, {
			size: 90,
			fill: "#fff"
		});
		btn.anchor.set(0.5, 0.5);
		btn.x = gameWidth / 2;
		btn.y = gameHeight / 2 - 100 + idx * 180;
		btn.interactive = true;
		btn.buttonMode = true;
		btn.songIndex = idx;
		btn.alpha = 0.92;
		btn.bg = LK.getAsset('holdBar', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		btn.bg.width = 700;
		btn.bg.height = 140;
		btn.bg.x = btn.x;
		btn.bg.y = btn.y;
		btn.bg.alpha = 0.35;
		menuContainer.addChild(btn.bg);
		menuContainer.addChild(btn);
		menuButtons.push(btn);
		btn.down = function (x, y, obj) {
			selectSong(idx);
		};
	})(i);
}
function selectSong(idx) {
	// Set up the selected song
	selectedSong = songList[idx];
	notes = [];
	for (var n = 0; n < selectedSong.notes.length; n++) {
		// Deep copy to avoid mutation
		var noteData = {};
		for (var k in selectedSong.notes[n]) noteData[k] = selectedSong.notes[n][k];
		notes.push(noteData);
	}
	// Remove menu
	menuContainer.visible = false;
	menuContainer.interactive = false;
	menuActive = false;
	// Start game
	songStarted = false;
	songEnded = false;
	currentTime = 0;
	score = 0;
	combo = 0;
	maxCombo = 0;
	accuracySum = 0;
	accuracyCount = 0;
	// Show UI/gameplay elements
	pitchBarActive.visible = true;
	hitZone.visible = true;
	scoreTxt.visible = true;
	comboTxt.visible = true;
	feedbackTxt.visible = true;
}
var selectedSong = null;
var menuActive = true;
// --- UI Elements ---
// Pitch bar background REMOVED
// Pitch bar active marker (shows current player pitch)
var pitchBarActive = LK.getAsset('pitchBarActive', {
	anchorX: 0.5,
	anchorY: 0.5
});
pitchBarActive.x = pitchBarX;
pitchBarActive.y = pitchBarY + pitchBarHeight / 2;
game.addChild(pitchBarActive);
// Perfect zone indicator (shows the "perfect" pitch window)
var perfectZoneBar = LK.getAsset('holdBar', {
	anchorX: 0.5,
	anchorY: 0.5
});
perfectZoneBar.width = 80;
perfectZoneBar.height = 36;
perfectZoneBar.alpha = 0.5;
perfectZoneBar.tint = 0xfff700;
perfectZoneBar.x = pitchBarX - 60;
perfectZoneBar.y = pitchBarActive.y;
game.addChild(perfectZoneBar);
// Pitch deviation indicator (shows how far off pitch the player is)
var pitchDeviationBar = LK.getAsset('holdBar', {
	anchorX: 0.5,
	anchorY: 0.5
});
pitchDeviationBar.width = 24;
pitchDeviationBar.height = 120;
pitchDeviationBar.alpha = 0.7;
pitchDeviationBar.tint = 0xff3333;
pitchDeviationBar.x = pitchBarX + 60;
pitchDeviationBar.y = pitchBarActive.y;
game.addChild(pitchDeviationBar);
// Avatar reaction (mirrors performance quality)
var avatarFace = LK.getAsset('noteTap', {
	anchorX: 0.5,
	anchorY: 0.5
});
avatarFace.x = gameWidth - 220;
avatarFace.y = gameHeight - 320;
avatarFace.scaleX = 2.2;
avatarFace.scaleY = 2.2;
avatarFace.alpha = 0.92;
game.addChild(avatarFace);
// Hit zone
var hitZone = LK.getAsset('hitZone', {
	anchorX: 0.5,
	anchorY: 0.5
});
hitZone.x = hitZoneX;
hitZone.y = gameHeight / 2;
hitZone.alpha = 0.13;
game.addChild(hitZone);
// Score text
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Combo text
var comboTxt = new Text2('', {
	size: 80,
	fill: 0xFFE066
});
comboTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(comboTxt);
comboTxt.y = 130;
// Feedback text (shows "Great!", "Miss!", etc)
var feedbackTxt = new Text2('', {
	size: 120,
	fill: 0xFF66AA
});
feedbackTxt.anchor.set(0.5, 0.5);
LK.gui.center.addChild(feedbackTxt);
// Hide gameplay UI until song is selected
pitchBarActive.visible = false;
hitZone.visible = false;
scoreTxt.visible = false;
comboTxt.visible = false;
feedbackTxt.visible = false;
// --- Player Pitch State ---
var playerPitch = 0.5; // 0 (bottom) to 1 (top)
var isSliding = false;
// --- PitchBarActive Sound State ---
var pitchBarSound = null;
var pitchBarSoundId = null;
var pitchBarSoundPlaying = false;
var lastPitchBarPitch = null;
var pitchBarSoundType = null; // "up" or "down"
// Array for 10 slide sounds (slide0 to slide9)
var slideSounds = [];
for (var i = 0; i < 10; i++) {
	slideSounds.push(LK.getSound('slide' + i));
}
// --- Song Data (set by menu) ---
notes = [];
// --- Helper Functions ---
function clamp(val, min, max) {
	return val < min ? min : val > max ? max : val;
}
function lerp(a, b, t) {
	return a + (b - a) * t;
}
// Converts pitch (0-1) to y position on pitch bar
function pitchToY(pitch) {
	return pitchBarY + (1 - pitch) * pitchBarHeight;
}
// Converts y position to pitch (0-1)
function yToPitch(y) {
	var rel = (y - pitchBarY) / pitchBarHeight;
	return clamp(1 - rel, 0, 1);
}
// Spawns a note object and adds to game
function spawnNote(noteData) {
	// All notes are now click-and-hold, and cannot cross (no overlap in time)
	var note = new Note();
	// Force all notes to be 'hold' type for click-hold mechanic
	note.type = 'hold';
	note.pitch = noteData.pitch;
	note.time = noteData.time;
	// For tap notes, treat as short hold
	if (noteData.type === 'tap') {
		note.duration = 400;
	} else {
		note.duration = noteData.duration || 0;
	}
	note.glideTo = null;
	note.hit = false;
	note.missed = false;
	// Always spawn notes fully offscreen right, never in the middle
	note.x = noteStartX;
	note.y = pitchToY(note.pitch);
	// Defensive: for noteTap with holdBar, force x to noteStartX as well
	if (note.type === 'tap' || note.type === 'hold' || note.type === 'glide') {
		note.x = noteStartX;
	}
	// Assign hold shape if present
	if (noteData.holdShape) {
		note.holdShape = noteData.holdShape;
		note.holdShapeParams = noteData.holdShapeParams;
	}
	activeNotes.push(note);
	game.addChild(note);
}
// Shows feedback text and clears after a short time
function showFeedback(text, color) {
	feedbackTxt.setText(text);
	feedbackTxt.setStyle({
		fill: color
	});
	feedbackTxt.alpha = 1;
	tween(feedbackTxt, {
		alpha: 0
	}, {
		duration: 700,
		easing: tween.linear
	});
}
// Spawns confetti at (x, y)
function spawnConfetti(x, y) {
	for (var i = 0; i < 10; i++) {
		var c = new Confetti();
		c.x = x;
		c.y = y;
		game.addChild(c);
	}
}
// Spawns fail splash at (x, y)
function spawnFailSplash(x, y) {
	var s = new FailSplash();
	s.x = x;
	s.y = y;
	game.addChild(s);
}
// --- Input Handling ---
// The player can press/hold anywhere on the vertical pitch field to set pitch.
// The vertical position of the cursor/finger determines the pitch (0-1).
// The player must press/hold as the note enters the hit zone, and track pitch for glides/holds.
var pitchFieldActive = false; // True if player is pressing/holding
var pitchFieldY = pitchBarY + pitchBarHeight / 2; // Last y position of input
game.down = function (x, y, obj) {
	if (menuActive) return;
	// Allow input anywhere on the screen to control pitch
	pitchFieldActive = true;
	isSliding = true;
	pitchFieldY = y;
	playerPitch = yToPitch(y);
	updatePitchBar();
	// --- Slide region sound logic: replay slide0-slide9 sound as long as user is holding, like Trombone Champ ---
	// Calculate which slide region we're in
	var idx = 0;
	if (pitchBarActive && typeof pitchBarActive.y === "number") {
		var rel = (pitchBarActive.y - pitchBarY) / pitchBarHeight;
		rel = Math.max(0, Math.min(1, rel));
		idx = Math.floor((1 - rel) * 10); // 0 = bottom, 9 = top
		if (idx < 0) idx = 0;
		if (idx > 9) idx = 9;
	}
	if (typeof game.lastSlideSoundIdx === "undefined") {
		game.lastSlideSoundIdx = -1;
	}
	if (typeof game.lastSlideSoundType === "undefined") {
		game.lastSlideSoundType = null;
	}
	pitchBarSound = slideSounds[idx];
	pitchBarSoundType = "down"; // Default to down on click
	var minRate = 0.7;
	var maxRate = 1.3;
	var rate = minRate + (maxRate - minRate) * playerPitch;
	var playOptions = {
		loop: false,
		volume: 1.0,
		rate: rate
	};
	// Always stop previous sound and play new one for this region, like Trombone Champ
	if (pitchBarSound && typeof pitchBarSound.stop === "function" && pitchBarSoundId !== null) {
		pitchBarSound.stop(pitchBarSoundId);
	}
	pitchBarSoundId = pitchBarSound.play(playOptions);
	pitchBarSoundPlaying = true;
	game.lastSlideSoundIdx = idx;
	game.lastSlideSoundType = "down";
	if (pitchBarSound && typeof pitchBarSound.setRate === "function") {
		pitchBarSound.setRate(pitchBarSoundId, rate);
	}
};
game.move = function (x, y, obj) {
	if (menuActive) return;
	if (pitchFieldActive) {
		pitchFieldY = y;
		playerPitch = yToPitch(y);
		updatePitchBar();
		// Update slide sound pitch (rate) in real time
		if (pitchBarSound && typeof pitchBarSound.setRate === "function" && pitchBarSoundId !== null) {
			var minRate = 0.7;
			var maxRate = 1.3;
			var rate = minRate + (maxRate - minRate) * playerPitch;
			pitchBarSound.setRate(pitchBarSoundId, rate);
		}
	}
};
game.up = function (x, y, obj) {
	if (menuActive) return;
	pitchFieldActive = false;
	isSliding = false;
	// Pause the slide sound if it's playing (do not stop, so it can be resumed)
	if (pitchBarSound && pitchBarSoundPlaying && typeof pitchBarSound.pause === "function" && pitchBarSoundId !== null) {
		pitchBarSound.pause(pitchBarSoundId);
	}
};
// Update pitch bar marker position
function updatePitchBar() {
	pitchBarActive.y = pitchToY(playerPitch);
}
// --- Game Loop ---
game.update = function () {
	if (menuActive) {
		// Stop pitchBarActive sound if playing
		if (pitchBarSound && pitchBarSoundPlaying) {
			pitchBarSound.stop();
			pitchBarSoundPlaying = false;
			pitchBarSoundId = null;
		}
		// Block game update until song is selected
		return;
	}
	// --- PitchBarActive Sound Logic ---
	// Only play slide sound while holding (isSliding) and pitchBarActive is visible
	if (pitchBarActive.visible && isSliding) {
		// Track last Y for pitchBarActive to determine direction
		if (typeof pitchBarActive.lastY === "undefined") {
			pitchBarActive.lastY = pitchBarActive.y;
		}
		var movingDown = false;
		var movingUp = false;
		if (pitchBarActive.y > pitchBarActive.lastY + 1) {
			movingDown = true;
		} else if (pitchBarActive.y < pitchBarActive.lastY - 1) {
			movingUp = true;
		}
		// Choose sound type and volume
		var slideVolume = 0.7;
		var newSoundType = null;
		if (movingDown) {
			slideVolume = 1.0;
			newSoundType = "down";
		} else if (movingUp) {
			slideVolume = 0.35;
			newSoundType = "up";
		} else {
			// Not moving, keep last type or default to down
			newSoundType = pitchBarSoundType || "down";
		}
		// Divide pitch bar into 10 equal horizontal regions, label bottom as slide0 and top as slide9
		var idx = 0;
		if (pitchBarActive && typeof pitchBarActive.y === "number") {
			// Calculate relative position from bottom (0) to top (1)
			var rel = (pitchBarActive.y - pitchBarY) / pitchBarHeight;
			rel = Math.max(0, Math.min(1, rel));
			idx = Math.floor((1 - rel) * 10); // 0 = bottom, 9 = top
			if (idx < 0) idx = 0;
			if (idx > 9) idx = 9;
			// Label the region for debug/UX
			if (!game.slideSoundTxt) {
				game.slideSoundTxt = new Text2('', {
					size: 60,
					fill: "#fff"
				});
				game.slideSoundTxt.anchor.set(0.5, 0.5);
				game.slideSoundTxt.x = pitchBarActive.x + 220;
				game.slideSoundTxt.y = pitchBarActive.y;
				game.addChild(game.slideSoundTxt);
			}
			var soundLabel = "slide" + idx;
			game.slideSoundTxt.setText(soundLabel);
			game.slideSoundTxt.x = pitchBarActive.x + 220;
			game.slideSoundTxt.y = pitchBarActive.y;
			game.slideSoundTxt.visible = true;
		}
		if (typeof game.lastSlideSoundIdx === "undefined") {
			game.lastSlideSoundIdx = -1;
		}
		if (typeof game.lastSlideSoundType === "undefined") {
			game.lastSlideSoundType = null;
		}
		// Only play the slide sound if region or direction changed, and do not replay if still in same region
		if (pitchBarSoundType !== newSoundType || game.lastSlideSoundIdx !== idx) {
			// Stop previous sound if playing
			if (pitchBarSound && pitchBarSoundPlaying && typeof pitchBarSound.stop === "function" && pitchBarSoundId !== null) {
				pitchBarSound.stop(pitchBarSoundId);
				pitchBarSoundPlaying = false;
				pitchBarSoundId = null;
			}
			// Set new sound asset: pick one of 10 based on pitchBarActive position
			pitchBarSound = slideSounds[idx];
			pitchBarSoundType = newSoundType;
			// Show which slide sound is mapped to pitchBarActive
			if (!game.slideSoundTxt) {
				game.slideSoundTxt = new Text2('', {
					size: 60,
					fill: "#fff"
				});
				game.slideSoundTxt.anchor.set(0.5, 0.5);
				game.slideSoundTxt.x = pitchBarActive.x + 220;
				game.slideSoundTxt.y = pitchBarActive.y;
				game.addChild(game.slideSoundTxt);
			}
			var soundLabel = "slide" + idx;
			game.slideSoundTxt.setText(soundLabel);
			game.slideSoundTxt.x = pitchBarActive.x + 220;
			game.slideSoundTxt.y = pitchBarActive.y;
			game.slideSoundTxt.visible = true;
			// Play the new sound immediately if holding and region changed
			if (isSliding && pitchBarActive.visible) {
				var minRate = 0.7;
				var maxRate = 1.3;
				var rate = minRate + (maxRate - minRate) * playerPitch;
				var playOptions = {
					loop: false,
					volume: slideVolume,
					rate: rate
				};
				pitchBarSoundId = pitchBarSound.play(playOptions);
				pitchBarSoundPlaying = true;
				game.lastSlideSoundIdx = idx;
				game.lastSlideSoundType = newSoundType;
			}
			// Do not replay sound here if still holding in the same region
		} else {
			// If still in the same region, do not replay or restart the sound, just keep it as is.
			// This prevents replaying or restarting the sound if the region hasn't changed.
			// (No sound restart here)
		}
		pitchBarActive.lastY = pitchBarActive.y;
		// If the sound has ended, replay it at the current position while holding in the same region (Y coordinate)
		if (typeof game.slideSoundLastReplay === "undefined") {
			game.slideSoundLastReplay = {};
		}
		if (isSliding && pitchBarSound && typeof pitchBarSound.isPlaying === "function" && pitchBarSoundId !== null) {
			var regionKey = "" + game.lastSlideSoundIdx;
			// If the sound is not playing, replay it immediately (fixes bug where it sometimes doesn't play)
			if (!pitchBarSound.isPlaying(pitchBarSoundId)) {
				// Stop any previous instance before replaying to prevent overlap
				if (typeof pitchBarSound.stop === "function" && pitchBarSoundId !== null) {
					pitchBarSound.stop(pitchBarSoundId);
				}
				// Replay the sound if ended and still holding, at the last known position if possible
				var minRate = 0.7;
				var maxRate = 1.3;
				var rate = minRate + (maxRate - minRate) * playerPitch;
				var playOptions = {
					loop: false,
					volume: slideVolume,
					rate: rate
				};
				// Always restart from the beginning for infinite replay while holding
				pitchBarSoundId = pitchBarSound.play(playOptions);
				pitchBarSoundPlaying = true;
				game.slideSoundLastReplay[regionKey] = Date.now();
				// game.lastSlideSoundIdx and game.lastSlideSoundType remain unchanged
			} else {
				pitchBarSoundPlaying = true;
				// Adjust volume in real time if possible
				if (typeof pitchBarSound.setVolume === "function") {
					pitchBarSound.setVolume(pitchBarSoundId, slideVolume);
				}
			}
		}
		// Do not start a new sound here if already playing or paused; only replay when ended and still holding in the same region
		// Only set rate if sound is playing or paused, do not start a new one here
		if (typeof pitchBarSound.setRate === "function" && pitchBarSoundId !== null) {
			// playerPitch is 0 (bottom) to 1 (top)
			// Map to rate: 0.7 (low) to 1.3 (high)
			var minRate = 0.7;
			var maxRate = 1.3;
			var rate = minRate + (maxRate - minRate) * playerPitch;
			pitchBarSound.setRate(pitchBarSoundId, rate);
		}
	} else {
		// Stop sound immediately if not holding or not visible (no delay)
		if (pitchBarSound && pitchBarSoundPlaying && typeof pitchBarSound.stop === "function" && pitchBarSoundId !== null) {
			pitchBarSound.stop(pitchBarSoundId);
			pitchBarSoundPlaying = false;
			pitchBarSoundId = null;
		}
		// Hide slide sound label if present
		if (game.slideSoundTxt) {
			game.slideSoundTxt.visible = false;
		}
	}
	if (!songStarted) {
		// Start music and timer
		LK.playMusic(selectedSong ? selectedSong.id : 'bgmusic');
		songStarted = true;
		currentTime = 0;
		score = 0;
		combo = 0;
		maxCombo = 0;
		accuracySum = 0;
		accuracyCount = 0;
		scoreTxt.setText('0');
		comboTxt.setText('');
		feedbackTxt.setText('');
		// Remove any old notes
		for (var i = activeNotes.length - 1; i >= 0; i--) {
			activeNotes[i].destroy();
			activeNotes.splice(i, 1);
		}
	}
	// Advance time
	currentTime += 1000 / 60; // 60 FPS
	// --- Visual pitch deviation indicator and avatar reaction ---
	var minPitchDiff = 1.0;
	var bestType = null;
	var bestPitch = null;
	for (var i = 0; i < activeNotes.length; i++) {
		var note = activeNotes[i];
		if (!note.hit && !note.missed) {
			// Only consider notes in the hit zone
			var inHitZone = Math.abs(note.x - hitZoneX) < hitZoneWidth / 2;
			if (inHitZone) {
				var targetPitch = note.pitch;
				if (note.type === 'glide') {
					var glideT = clamp((currentTime - note.time) / note.duration, 0, 1);
					targetPitch = lerp(note.glideStart, note.glideEnd, glideT);
				}
				var diff = Math.abs(playerPitch - targetPitch);
				if (diff < minPitchDiff) {
					minPitchDiff = diff;
					bestType = note.type;
					bestPitch = targetPitch;
				}
			}
		}
	}
	// Show deviation bar only if a note is in the hit zone
	if (minPitchDiff < 1.0) {
		pitchDeviationBar.visible = true;
		pitchDeviationBar.y = pitchBarActive.y;
		// Color: green if close, yellow if moderate, red if far
		if (minPitchDiff < 0.07) {
			pitchDeviationBar.tint = 0x44dd88;
		} else if (minPitchDiff < 0.15) {
			pitchDeviationBar.tint = 0xffe066;
		} else {
			pitchDeviationBar.tint = 0xff3333;
		}
		// Height: larger if more off
		pitchDeviationBar.height = 120 + minPitchDiff * 400;
		// Perfect zone indicator follows the current note's target pitch
		if (bestPitch !== null) {
			perfectZoneBar.visible = true;
			perfectZoneBar.y = pitchToY(bestPitch);
		} else {
			perfectZoneBar.visible = false;
		}
	} else {
		pitchDeviationBar.visible = false;
		perfectZoneBar.visible = false;
	}
	// Avatar reaction: happy if close, worried if off, shocked if very off
	if (minPitchDiff < 0.07) {
		avatarFace.tint = 0x44dd88; // happy
		avatarFace.scaleX = 2.2;
		avatarFace.scaleY = 2.2;
	} else if (minPitchDiff < 0.15) {
		avatarFace.tint = 0xffe066; // worried
		avatarFace.scaleX = 2.0;
		avatarFace.scaleY = 2.0;
	} else if (minPitchDiff < 1.0) {
		avatarFace.tint = 0xff3333; // shocked
		avatarFace.scaleX = 2.4;
		avatarFace.scaleY = 2.4;
	} else {
		avatarFace.tint = 0xffffff;
		avatarFace.scaleX = 2.2;
		avatarFace.scaleY = 2.2;
	}
	// Spawn notes as they come into view, only when their time is reached (like Trombone Champ)
	for (var i = 0; i < notes.length; i++) {
		var noteData = notes[i];
		// Only spawn if not already spawned and the note's scheduled time minus travel time is reached
		// This ensures notes start offscreen right and scroll in, not appear in the middle
		var noteTravelTime = (noteStartX - hitZoneX) / noteSpeed;
		// Only spawn if we are before the note's scheduled time (so it scrolls in)
		// Defensive: never spawn late notes in the middle of the screen
		if (!noteData.spawned && currentTime >= noteData.time - noteTravelTime && currentTime <= noteData.time - 10) {
			spawnNote(noteData);
			noteData.spawned = true;
		} else if (!noteData.spawned && (currentTime > noteData.time - 10 || currentTime < noteData.time - noteTravelTime)) {
			// If a note was not spawned at the correct time, or if currentTime is outside the valid window, never spawn it late in the middle of the screen
			// (e.g. if currentTime > noteData.time - 10, or if currentTime < noteData.time - noteTravelTime, do not spawn)
			noteData.spawned = true; // Mark as skipped
		}
	}
	// Update notes
	for (var i = activeNotes.length - 1; i >= 0; i--) {
		var note = activeNotes[i];
		// Calculate note's current x based on time
		var noteTravelTime = (noteStartX - hitZoneX) / noteSpeed;
		var t = currentTime - (note.time - noteTravelTime);
		// Notes start at the right and move left toward the hit zone
		if (t < 0) {
			// Not yet on screen, keep fully offscreen right
			note.x = noteStartX;
		} else {
			note.x = noteStartX - t * noteSpeed;
			// Clamp so note never appears in the middle before scrolling in
			if (note.x > noteStartX) note.x = noteStartX;
			// Defensive: never allow any note to appear left of noteStartX before scrolling in
			if (t < 0 && note.x !== noteStartX) note.x = noteStartX;
		}
		// Clamp to hitZoneX and continue left after
		if (note.x < hitZoneX) note.x = hitZoneX + (note.x - hitZoneX);
		// For all notes: y position is fixed to their initial pitch, even for glides (no vertical movement)
		if (!note.hit && !note.missed) {
			note.y = pitchToY(note.pitch);
		}
		// If hit or missed, do not update y (freeze at last value)
		// Remove notes that have gone far enough offscreen left
		if (note.x < -650) {
			note.destroy();
			activeNotes.splice(i, 1);
			continue;
		}
		// Check for hit/miss
		if (!note.hit && !note.missed) {
			// Tap note: now must be click-and-hold in hit zone for a short time (like a mini-hold)
			if (note.type === 'tap') {
				var tapHoldDuration = 400; // ms, must match Note class
				var hitWindow = tapHoldDuration; // ms, tap is now a short hold
				var timeDiff = Math.abs(currentTime - note.time);
				var inHitZone = Math.abs(note.x - hitZoneX) < hitZoneWidth / 2;
				var pitchDiff = Math.abs(playerPitch - note.pitch);
				if (inHitZone && timeDiff < hitWindow) {
					if (isSliding && pitchDiff < 0.12) {
						// Good hold (tap is now a short hold)
						if (!note.holdStarted) {
							note.holdStarted = true;
							note.holdScore = 0;
							note.holdTicks = 0;
							note.holdReleased = false; // Track if player released at end
							// Do not play slide sound when catching tap notes; only focus on click/release for sound
							if (!note.slideSoundPlayed) {
								note.slideSoundPlayed = true;
							}
						}
						note.holdScore += 1;
						note.holdTicks += 1;
						note.noteAsset.scaleX = 1.2;
						note.noteAsset.scaleY = 1.2;
					} else if (note.holdStarted) {
						note.noteAsset.scaleX = 1;
						note.noteAsset.scaleY = 1;
					}
					// Track if player released before end of tap hold
					if (note.holdStarted && !isSliding && !note.holdReleased) {
						note.holdReleased = true;
					}
				}
				// End of tap "hold" (after hitWindow)
				if (currentTime > note.time + hitWindow && !note.hit) {
					note.hit = true;
					var tapAcc = note.holdTicks ? note.holdScore / note.holdTicks : 0;
					// Only allow combo if player started at correct time AND released at end (not still holding)
					if (tapAcc > 0.7 && note.holdStarted && note.holdReleased) {
						// Combo multiplier: +10% per 10 combo, up to 2x
						var comboMult = 1 + Math.floor(combo / 10) * 0.1;
						if (comboMult > 2) comboMult = 2;
						// Perfect zone: if tapAcc > 0.97, +50 bonus
						var baseScore = 100;
						if (tapAcc > 0.97) baseScore += 50;
						score += Math.round(baseScore * comboMult);
						combo += 1;
						if (combo > maxCombo) maxCombo = combo;
						accuracySum += tapAcc;
						accuracyCount++;
						scoreTxt.setText(score + '');
						comboTxt.setText(combo > 1 ? combo + ' Combo!' : '');
						// Feedback text based on accuracy
						var fbText = '';
						var fbColor = "#ffe066";
						if (tapAcc > 0.97) {
							fbText = 'Perfect!';
							fbColor = "#fff700";
						} else if (tapAcc > 0.90) {
							fbText = 'Awesome!';
							fbColor = "#aaffaa";
						} else if (tapAcc > 0.80) {
							fbText = 'Good!';
							fbColor = "#66ccff";
						} else {
							fbText = 'Bad!';
							fbColor = "#ffcc66";
						}
						showFeedback(fbText, fbColor);
						spawnConfetti(note.x, note.y);
						LK.getSound('hit').play();
					} else {
						combo = 0;
						comboTxt.setText('');
						showFeedback('Miss!', "#ff3333");
						spawnFailSplash(note.x, note.y);
						LK.getSound('miss').play();
					}
				}
				// Missed if passed hit window and not started
				if (currentTime > note.time + hitWindow + 200 && !note.hit) {
					note.missed = true;
					combo = 0;
					comboTxt.setText('');
					showFeedback('Miss!', "#ff3333");
					spawnFailSplash(note.x, note.y);
					LK.getSound('miss').play();
				}
			}
			// Hold note: must hold correct pitch during duration (horizontal, click-and-hold)
			else if (note.type === 'hold') {
				var holdStart = note.time;
				var holdEnd = note.time + note.duration;
				var inHoldZone = currentTime >= holdStart - 180 && currentTime <= holdEnd + 180;
				var inHitZone = Math.abs(note.x - hitZoneX) < hitZoneWidth / 2;
				// --- HEAD CATCH LOGIC ---
				// Only allow hold scoring if the head of the note is caught in the hit zone at the correct time and pitch
				if (!note.headCaught) {
					// Check if the head of the note (the first frame it enters the hit zone) is caught
					var headInZone = Math.abs(note.x - hitZoneX) < hitZoneWidth / 2;
					var headTimeOk = Math.abs(currentTime - holdStart) < 180;
					var headPitchOk = Math.abs(playerPitch - note.pitch) < 0.13 && isSliding;
					if (headInZone && headTimeOk && headPitchOk) {
						note.headCaught = true;
						note.holdStarted = true;
						note.holdScore = 0;
						note.holdTicks = 0;
						// Do not play slide sound when catching hold note head; only focus on click/release for sound
						if (!note.slideSoundPlayed) {
							note.slideSoundPlayed = true;
						}
						note.headCatchTime = currentTime;
						note.noteAsset.scaleX = 1.2;
						note.noteAsset.scaleY = 1.2;
					}
				}
				// Only allow hold scoring if head was caught
				if (note.headCaught && inHoldZone && inHitZone) {
					if (isSliding && Math.abs(playerPitch - note.pitch) < 0.13) {
						// Good hold
						note.holdScore += 1;
						note.holdTicks += 1;
						note.noteAsset.scaleX = 1.2;
						note.noteAsset.scaleY = 1.2;
					} else {
						note.noteAsset.scaleX = 1;
						note.noteAsset.scaleY = 1;
					}
					// Track if player released before end of hold
					if (!isSliding && !note.holdReleased) {
						note.holdReleased = true;
					}
				} else if (note.holdStarted) {
					note.noteAsset.scaleX = 1;
					note.noteAsset.scaleY = 1;
				}
				// End of hold: only if head was caught
				if (currentTime > holdEnd && !note.hit) {
					note.hit = true;
					var holdAcc = note.holdTicks ? note.holdScore / note.holdTicks : 0;
					// Only allow combo if head was caught, accuracy is good, and player released at end
					if (note.headCaught && holdAcc > 0.7 && note.holdReleased) {
						score += 180;
						combo += 1;
						if (combo > maxCombo) maxCombo = combo;
						accuracySum += holdAcc;
						accuracyCount++;
						scoreTxt.setText(score + '');
						comboTxt.setText(combo > 1 ? combo + ' Combo!' : '');
						// Feedback text based on accuracy
						var fbText = '';
						var fbColor = "#44dd88";
						if (holdAcc > 0.97) {
							fbText = 'Perfect!';
							fbColor = "#fff700";
						} else if (holdAcc > 0.90) {
							fbText = 'Awesome!';
							fbColor = "#aaffaa";
						} else if (holdAcc > 0.80) {
							fbText = 'Good!';
							fbColor = "#66ccff";
						} else {
							fbText = 'Bad!';
							fbColor = "#ffcc66";
						}
						showFeedback(fbText, fbColor);
						spawnConfetti(note.x, note.y);
						LK.getSound('tromboneGood').play();
					} else {
						combo = 0;
						comboTxt.setText('');
						showFeedback('Miss!', "#ff3333");
						spawnFailSplash(note.x, note.y);
						LK.getSound('miss').play();
					}
				}
				// Missed if passed hold window and not started or head not caught
				if (currentTime > holdEnd + 200 && !note.hit) {
					note.missed = true;
					combo = 0;
					comboTxt.setText('');
					showFeedback('Miss!', "#ff3333");
					spawnFailSplash(note.x, note.y);
					LK.getSound('miss').play();
				}
			}
			// Glide note: must follow pitch from start to end (horizontal, click-and-hold)
			else if (note.type === 'glide') {
				var glideStart = note.time;
				var glideEnd = note.time + note.duration;
				var inGlideZone = currentTime >= glideStart - 180 && currentTime <= glideEnd + 180;
				var inHitZone = Math.abs(note.x - hitZoneX) < hitZoneWidth / 2;
				if (inGlideZone && inHitZone) {
					var glideT = clamp((currentTime - glideStart) / note.duration, 0, 1);
					var targetPitch = lerp(note.glideStart, note.glideEnd, glideT);
					var pitchDiff = Math.abs(playerPitch - targetPitch);
					if (isSliding && pitchDiff < 0.15) {
						// Good glide
						if (!note.glideStarted) {
							note.glideStarted = true;
							note.glideScore = 0;
							note.glideTicks = 0;
							note.glideReleased = false; // Track if player released at end
							// Do not play slide sound when catching glide note start; only focus on click/release for sound
							if (!note.slideSoundPlayed) {
								note.slideSoundPlayed = true;
							}
						}
						note.glideScore += 1;
						note.glideTicks += 1;
						note.noteAsset.scaleX = 1.2;
						note.noteAsset.scaleY = 1.2;
						// Track if player released before end of glide
						if (note.glideStarted && !isSliding && !note.glideReleased) {
							note.glideReleased = true;
						}
					} else if (note.glideStarted) {
						note.noteAsset.scaleX = 1;
						note.noteAsset.scaleY = 1;
					}
				}
				// End of glide
				if (currentTime > glideEnd && !note.hit) {
					note.hit = true;
					var glideAcc = note.glideTicks ? note.glideScore / note.glideTicks : 0;
					// Only allow combo if accuracy is good, and player released at end
					if (glideAcc > 0.7 && note.glideStarted && note.glideReleased) {
						score += 200;
						combo += 1;
						if (combo > maxCombo) maxCombo = combo;
						accuracySum += glideAcc;
						accuracyCount++;
						scoreTxt.setText(score + '');
						comboTxt.setText(combo > 1 ? combo + ' Combo!' : '');
						// Feedback text based on accuracy
						var fbText = '';
						var fbColor = "#ff66aa";
						if (glideAcc > 0.97) {
							fbText = 'Perfect!';
							fbColor = "#fff700";
						} else if (glideAcc > 0.90) {
							fbText = 'Awesome!';
							fbColor = "#aaffaa";
						} else if (glideAcc > 0.80) {
							fbText = 'Good!';
							fbColor = "#66ccff";
						} else {
							fbText = 'Bad!';
							fbColor = "#ffcc66";
						}
						showFeedback(fbText, fbColor);
						spawnConfetti(note.x, note.y);
						LK.getSound('tromboneGood').play();
					} else {
						combo = 0;
						comboTxt.setText('');
						showFeedback('Miss!', "#ff3333");
						spawnFailSplash(note.x, note.y);
						LK.getSound('miss').play();
					}
				}
				// Missed if passed glide window and not started
				if (currentTime > glideEnd + 200 && !note.hit) {
					note.missed = true;
					combo = 0;
					comboTxt.setText('');
					showFeedback('Miss!', "#ff3333");
					spawnFailSplash(note.x, note.y);
					LK.getSound('miss').play();
				}
			}
		}
	}
	// Remove hit/missed notes after a delay
	for (var i = activeNotes.length - 1; i >= 0; i--) {
		var note = activeNotes[i];
		if ((note.hit || note.missed) && currentTime - note.time > 800) {
			// Reset slideSoundPlayed so it can be triggered again for new notes
			note.slideSoundPlayed = false;
			note.destroy();
			activeNotes.splice(i, 1);
		}
	}
	// End of song
	if (!songEnded && currentTime > notes[notes.length - 1].time + 3000) {
		songEnded = true;
		// Calculate accuracy and rank
		var acc = accuracyCount ? Math.round(accuracySum / accuracyCount * 100) : 0;
		var rank = "D";
		if (acc >= 98 && score > 1200) {
			rank = "S";
		} else if (acc >= 90 && score > 1000) {
			rank = "A";
		} else if (acc >= 80 && score > 800) {
			rank = "B";
		} else if (acc >= 60 && score > 500) {
			rank = "C";
		}
		// --- LIKE POINT END SECTION ---
		// This is the "end section of like point" where you can finalize points, score, and show results.
		// (You can add any additional logic here for 'like point' if needed.)
		// Hide gameplay UI
		pitchBarActive.visible = false;
		hitZone.visible = false;
		scoreTxt.visible = false;
		comboTxt.visible = false;
		feedbackTxt.visible = false;
		// Show result overlay
		if (typeof resultOverlay !== "undefined" && resultOverlay) {
			resultOverlay.destroy();
		}
		var resultOverlay = new Container();
		game.addChild(resultOverlay);
		// Dim background REMOVED (pitchBarBg)
		// Title
		var resultTitle = new Text2("Episode Complete!", {
			size: 120,
			fill: 0xFFE066
		});
		resultTitle.anchor.set(0.5, 0);
		resultTitle.x = gameWidth / 2;
		resultTitle.y = gameHeight / 2 - 480;
		resultOverlay.addChild(resultTitle);
		// Rank
		var rankText = new Text2("Rank: " + rank, {
			size: 200,
			fill: rank === "S" ? "#ffd700" : rank === "A" ? "#aaffaa" : rank === "B" ? "#66ccff" : rank === "C" ? "#ffcc66" : "#ff6666"
		});
		rankText.anchor.set(0.5, 0);
		rankText.x = gameWidth / 2;
		rankText.y = gameHeight / 2 - 260;
		resultOverlay.addChild(rankText);
		// Score, Combo, Accuracy
		var resultStats = new Text2("Score: " + score + "\nMax Combo: " + maxCombo + "\nAccuracy: " + acc + "%", {
			size: 90,
			fill: "#fff"
		});
		resultStats.anchor.set(0.5, 0);
		resultStats.x = gameWidth / 2;
		resultStats.y = gameHeight / 2 - 10;
		resultOverlay.addChild(resultStats);
		// Menu button
		var menuBtnBg = LK.getAsset('holdBar', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		menuBtnBg.width = 500;
		menuBtnBg.height = 120;
		menuBtnBg.x = gameWidth / 2;
		menuBtnBg.y = gameHeight / 2 + 350;
		menuBtnBg.alpha = 0.4;
		resultOverlay.addChild(menuBtnBg);
		var menuBtn = new Text2("Back to Menu", {
			size: 90,
			fill: 0xFFE066
		});
		menuBtn.anchor.set(0.5, 0.5);
		menuBtn.x = gameWidth / 2;
		menuBtn.y = gameHeight / 2 + 350;
		menuBtn.interactive = true;
		menuBtn.buttonMode = true;
		resultOverlay.addChild(menuBtn);
		menuBtn.down = function (x, y, obj) {
			// Remove overlay, show menu, reset state
			resultOverlay.destroy();
			menuContainer.visible = true;
			menuContainer.interactive = true;
			menuActive = true;
			// Hide gameplay UI
			pitchBarActive.visible = false;
			hitZone.visible = false;
			scoreTxt.visible = false;
			comboTxt.visible = false;
			feedbackTxt.visible = false;
			// Remove all notes
			for (var i = activeNotes.length - 1; i >= 0; i--) {
				activeNotes[i].destroy();
				activeNotes.splice(i, 1);
			}
			// Reset song state
			songStarted = false;
			songEnded = false;
			currentTime = 0;
			score = 0;
			combo = 0;
			maxCombo = 0;
			accuracySum = 0;
			accuracyCount = 0;
		};
		// Block further game update until menu is shown again
		return;
	}
};
// --- Start music ---
// Now handled in game.update after song selection

===================================================================
--- original.js
+++ change.js
@@ -225,22 +225,22 @@
 
 /**** 
 * Game Code
 ****/ 
-// 10 slide up sounds, evenly split across the sample
-// 10 slide down sounds, evenly split across the sample
-// 10 different slide up and 10 different slide down assets
-// Music (background track)
-// Sounds (placeholders, actual sound assets will be loaded by LK)
-// Comedic feedback
-// Hit zone
-// Hold bar (for hold notes)
-// Note types
-// Trombone slide bar (vertical pitch bar)
-// Note: Asset creation is handled automatically by LK based on usage below.
-// Trombone Slide Showdown - Asset Initialization
-// --- Constants ---
 // Trombone pitch sound assets for different pitch levels
+// --- Constants ---
+// Trombone Slide Showdown - Asset Initialization
+// Note: Asset creation is handled automatically by LK based on usage below.
+// Trombone slide bar (vertical pitch bar)
+// Note types
+// Hold bar (for hold notes)
+// Hit zone
+// Comedic feedback
+// Sounds (placeholders, actual sound assets will be loaded by LK)
+// Music (background track)
+// 10 different slide up and 10 different slide down assets
+// 10 slide down sounds, evenly split across the sample
+// 10 slide up sounds, evenly split across the sample
 function _typeof(o) {
 	"@babel/helpers - typeof";
 	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
 		return typeof o;
@@ -1121,11 +1121,11 @@
 		// Defensive: never spawn late notes in the middle of the screen
 		if (!noteData.spawned && currentTime >= noteData.time - noteTravelTime && currentTime <= noteData.time - 10) {
 			spawnNote(noteData);
 			noteData.spawned = true;
-		} else if (!noteData.spawned && currentTime > noteData.time - 10) {
-			// If a note was not spawned at the correct time, never spawn it late in the middle of the screen
-			// (e.g. if currentTime > noteData.time - 10, do not spawn)
+		} else if (!noteData.spawned && (currentTime > noteData.time - 10 || currentTime < noteData.time - noteTravelTime)) {
+			// If a note was not spawned at the correct time, or if currentTime is outside the valid window, never spawn it late in the middle of the screen
+			// (e.g. if currentTime > noteData.time - 10, or if currentTime < noteData.time - noteTravelTime, do not spawn)
 			noteData.spawned = true; // Mark as skipped
 		}
 	}
 	// Update notes