/**** 
* 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)
	// HoldBar and curveBars visual assets for notes
	self.noteAsset = null;
	self.holdBar = null;
	self.curveBars = [];
	// 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;
	// --- HoldBar/CurveBar style selection ---
	// Only for hold and glide notes
	self.holdBarStyle = null;
	if (self.type === 'hold' || self.type === 'glide') {
		// Randomly pick a style: 0=flat, 1=diagonal, 2=curvy, 3=zigzag
		self.holdBarStyle = Math.floor(Math.random() * 4);
	}
	// Attach note head asset
	if (self.type === 'tap') {
		self.noteAsset = self.attachAsset('noteTap', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (self.type === 'hold') {
		self.noteAsset = self.attachAsset('noteHold', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	} else if (self.type === 'glide') {
		self.noteAsset = self.attachAsset('noteGlide', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	}
	// Attach holdBar/curveBar for hold and glide notes
	if (self.type === 'hold' || self.type === 'glide') {
		// Remove any previous bars
		if (self.holdBar) {
			self.removeChild(self.holdBar);
			self.holdBar = null;
		}
		for (var i = 0; i < self.curveBars.length; i++) {
			self.removeChild(self.curveBars[i]);
		}
		self.curveBars = [];
		// Bar color
		var barAssetId = 'holdBar';
		var barColor = 0x44dd88;
		var barAlpha = 0.7;
		// Calculate bar start/end positions
		var startX = 0,
			startY = 0,
			endX = 0,
			endY = 0;
		var barLen = 0;
		var barAngle = 0;
		var barWidth = 36;
		var barHeight = 0;
		// For horizontal movement: bar goes from note head (self.x, self.y) to where the tail will be
		// The bar is drawn relative to the note head (self), so we use local coordinates
		// The bar always starts at (0,0) in self's local space
		// For hold: bar is flat or diagonal/curvy/zigzag, but always from head to tail
		if (self.type === 'hold') {
			// End X is how far the note will travel during duration
			var durationPx = (self.duration || 1200) * 1.2; // noteSpeed
			endX = -durationPx;
			// End Y: for diagonal/curvy/zigzag, add some Y offset
			if (self.holdBarStyle === 0) {
				// flat
				endY = 0;
			} else if (self.holdBarStyle === 1) {
				// diagonal
				endY = (Math.random() > 0.5 ? 1 : -1) * 180;
			} else if (self.holdBarStyle === 2) {
				// curvy
				endY = (Math.random() > 0.5 ? 1 : -1) * 120;
			} else if (self.holdBarStyle === 3) {
				// zigzag
				endY = (Math.random() > 0.5 ? 1 : -1) * 160;
			}
			barLen = Math.sqrt(endX * endX + endY * endY);
			barAngle = Math.atan2(endY, endX);
			// For flat/diagonal: single bar
			if (self.holdBarStyle === 0 || self.holdBarStyle === 1) {
				self.holdBar = LK.getAsset(barAssetId, {
					anchorX: 0,
					anchorY: 0.5
				});
				self.holdBar.width = barLen;
				self.holdBar.height = barWidth;
				self.holdBar.x = 0;
				self.holdBar.y = 0;
				self.holdBar.rotation = barAngle;
				self.holdBar.alpha = barAlpha;
				self.holdBar.tint = barColor;
				self.addChild(self.holdBar);
			}
			// For curvy: use 3 bars, each rotated a bit, to fake a curve
			else if (self.holdBarStyle === 2) {
				var segs = 3;
				for (var s = 0; s < segs; s++) {
					var seg = LK.getAsset(barAssetId, {
						anchorX: 0,
						anchorY: 0.5
					});
					seg.width = barLen / segs;
					seg.height = barWidth;
					seg.x = barLen / segs * s * Math.cos(barAngle);
					seg.y = barLen / segs * s * Math.sin(barAngle) + Math.sin(s * Math.PI / (segs - 1)) * 60;
					seg.rotation = barAngle + Math.sin(s * Math.PI / (segs - 1)) * 0.35;
					seg.alpha = barAlpha;
					seg.tint = barColor;
					self.addChild(seg);
					self.curveBars.push(seg);
				}
			}
			// For zigzag: use 4 bars, alternating y
			else if (self.holdBarStyle === 3) {
				var segs = 4;
				for (var s = 0; s < segs; s++) {
					var seg = LK.getAsset(barAssetId, {
						anchorX: 0,
						anchorY: 0.5
					});
					seg.width = barLen / segs;
					seg.height = barWidth;
					seg.x = barLen / segs * s * Math.cos(barAngle);
					seg.y = barLen / segs * s * Math.sin(barAngle) + (s % 2 === 0 ? 60 : -60);
					seg.rotation = barAngle;
					seg.alpha = barAlpha;
					seg.tint = barColor;
					self.addChild(seg);
					self.curveBars.push(seg);
				}
			}
		}
		// For glide: bar goes from head to tail, but y is based on pitch glide
		else if (self.type === 'glide') {
			var durationPx = (self.duration || 1200) * 1.2;
			endX = -durationPx;
			// End Y is the difference in pitch mapped to pixels
			var pitchDelta = (self.glideTo !== null ? self.glideTo : self.pitch) - self.pitch;
			endY = -pitchDelta * 1800; // pitchBarHeight
			barLen = Math.sqrt(endX * endX + endY * endY);
			barAngle = Math.atan2(endY, endX);
			// For flat/diagonal: single bar
			if (self.holdBarStyle === 0 || self.holdBarStyle === 1) {
				self.holdBar = LK.getAsset(barAssetId, {
					anchorX: 0,
					anchorY: 0.5
				});
				self.holdBar.width = barLen;
				self.holdBar.height = barWidth;
				self.holdBar.x = 0;
				self.holdBar.y = 0;
				self.holdBar.rotation = barAngle;
				self.holdBar.alpha = barAlpha;
				self.holdBar.tint = barColor;
				self.addChild(self.holdBar);
			}
			// For curvy: use 3 bars, each rotated a bit, to fake a curve
			else if (self.holdBarStyle === 2) {
				var segs = 3;
				for (var s = 0; s < segs; s++) {
					var seg = LK.getAsset(barAssetId, {
						anchorX: 0,
						anchorY: 0.5
					});
					seg.width = barLen / segs;
					seg.height = barWidth;
					// Interpolate y between start and end, add curve
					var t = s / (segs - 1);
					seg.x = barLen / segs * s * Math.cos(barAngle);
					seg.y = barLen / segs * s * Math.sin(barAngle) + Math.sin(t * Math.PI) * 80;
					seg.rotation = barAngle + Math.sin(t * Math.PI) * 0.35;
					seg.alpha = barAlpha;
					seg.tint = barColor;
					self.addChild(seg);
					self.curveBars.push(seg);
				}
			}
			// For zigzag: use 4 bars, alternating y
			else if (self.holdBarStyle === 3) {
				var segs = 4;
				for (var s = 0; s < segs; s++) {
					var seg = LK.getAsset(barAssetId, {
						anchorX: 0,
						anchorY: 0.5
					});
					seg.width = barLen / segs;
					seg.height = barWidth;
					var t = s / (segs - 1);
					seg.x = barLen / segs * s * Math.cos(barAngle);
					seg.y = barLen / segs * s * Math.sin(barAngle) + (s % 2 === 0 ? 70 : -70);
					seg.rotation = barAngle;
					seg.alpha = barAlpha;
					seg.tint = barColor;
					self.addChild(seg);
					self.curveBars.push(seg);
				}
			}
		}
	}
	// Update visuals per frame
	self.update = function () {
		// No holdBar or curveBars drawing logic; nothing to draw for hold bar
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// --- 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)
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 + 200; // Offscreen right
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 ---
var songList = [{
	name: "Showdown (Default)",
	id: "bgmusic",
	notes: [
	// --- First phrase (0-20s) ---
	{
		type: 'tap',
		time: 1000,
		pitch: 0.2
	}, {
		type: 'tap',
		time: 1800,
		pitch: 0.7
	}, {
		type: 'tap',
		time: 2600,
		pitch: 0.5
	}, {
		type: 'hold',
		time: 3400,
		pitch: 0.3,
		duration: 1200
	}, {
		type: 'glide',
		time: 5000,
		pitch: 0.8,
		duration: 1200,
		glideTo: 0.2
	}, {
		type: 'tap',
		time: 6700,
		pitch: 0.6
	}, {
		type: 'tap',
		time: 7400,
		pitch: 0.4
	}, {
		type: 'tap',
		time: 8100,
		pitch: 0.5
	}, {
		type: 'hold',
		time: 8800,
		pitch: 0.7,
		duration: 1000
	}, {
		type: 'glide',
		time: 10200,
		pitch: 0.2,
		duration: 1000,
		glideTo: 0.8
	},
	// --- Second phrase (20-40s) ---
	{
		type: 'tap',
		time: 12000,
		pitch: 0.3
	}, {
		type: 'tap',
		time: 12800,
		pitch: 0.6
	}, {
		type: 'hold',
		time: 13600,
		pitch: 0.5,
		duration: 1200
	}, {
		type: 'glide',
		time: 15200,
		pitch: 0.7,
		duration: 1200,
		glideTo: 0.4
	}, {
		type: 'tap',
		time: 17000,
		pitch: 0.2
	}, {
		type: 'tap',
		time: 17800,
		pitch: 0.8
	}, {
		type: 'hold',
		time: 18600,
		pitch: 0.6,
		duration: 1000
	}, {
		type: 'glide',
		time: 20000,
		pitch: 0.3,
		duration: 1000,
		glideTo: 0.7
	},
	// --- Third phrase (40-60s) ---
	{
		type: 'tap',
		time: 21800,
		pitch: 0.5
	}, {
		type: 'tap',
		time: 22600,
		pitch: 0.4
	}, {
		type: 'hold',
		time: 23400,
		pitch: 0.2,
		duration: 1200
	}, {
		type: 'glide',
		time: 25000,
		pitch: 0.8,
		duration: 1200,
		glideTo: 0.1
	}, {
		type: 'tap',
		time: 26800,
		pitch: 0.6
	}, {
		type: 'tap',
		time: 27600,
		pitch: 0.3
	}, {
		type: 'hold',
		time: 28400,
		pitch: 0.7,
		duration: 1000
	}, {
		type: 'glide',
		time: 29800,
		pitch: 0.2,
		duration: 1000,
		glideTo: 0.9
	},
	// --- Fourth phrase (60-80s) ---
	{
		type: 'tap',
		time: 31600,
		pitch: 0.4
	}, {
		type: 'tap',
		time: 32400,
		pitch: 0.8
	}, {
		type: 'hold',
		time: 33200,
		pitch: 0.5,
		duration: 1200
	}, {
		type: 'glide',
		time: 34800,
		pitch: 0.6,
		duration: 1200,
		glideTo: 0.2
	}, {
		type: 'tap',
		time: 36600,
		pitch: 0.7
	}, {
		type: 'tap',
		time: 37400,
		pitch: 0.3
	}, {
		type: 'hold',
		time: 38200,
		pitch: 0.2,
		duration: 1000
	}, {
		type: 'glide',
		time: 39600,
		pitch: 0.8,
		duration: 1000,
		glideTo: 0.5
	},
	// --- Fifth phrase (80-100s) ---
	{
		type: 'tap',
		time: 41400,
		pitch: 0.6
	}, {
		type: 'tap',
		time: 42200,
		pitch: 0.2
	}, {
		type: 'hold',
		time: 43000,
		pitch: 0.7,
		duration: 1200
	}, {
		type: 'glide',
		time: 44600,
		pitch: 0.3,
		duration: 1200,
		glideTo: 0.8
	}, {
		type: 'tap',
		time: 46400,
		pitch: 0.5
	}, {
		type: 'tap',
		time: 47200,
		pitch: 0.4
	}, {
		type: 'hold',
		time: 48000,
		pitch: 0.6,
		duration: 1000
	}, {
		type: 'glide',
		time: 49400,
		pitch: 0.2,
		duration: 1000,
		glideTo: 0.7
	},
	// --- Final phrase (100-120s) ---
	{
		type: 'tap',
		time: 51200,
		pitch: 0.8
	}, {
		type: 'tap',
		time: 52000,
		pitch: 0.3
	}, {
		type: 'hold',
		time: 52800,
		pitch: 0.5,
		duration: 1200
	}, {
		type: 'glide',
		time: 54400,
		pitch: 0.7,
		duration: 1200,
		glideTo: 0.2
	}, {
		type: 'tap',
		time: 56200,
		pitch: 0.6
	}, {
		type: 'tap',
		time: 57000,
		pitch: 0.4
	}, {
		type: 'hold',
		time: 57800,
		pitch: 0.2,
		duration: 1000
	}, {
		type: 'glide',
		time: 59200,
		pitch: 0.8,
		duration: 1000,
		glideTo: 0.5
	},
	// --- Big finish (last 10s) ---
	{
		type: 'tap',
		time: 61000,
		pitch: 0.5
	}, {
		type: 'tap',
		time: 61800,
		pitch: 0.7
	}, {
		type: 'hold',
		time: 62600,
		pitch: 0.3,
		duration: 1200
	}, {
		type: 'glide',
		time: 64200,
		pitch: 0.6,
		duration: 1200,
		glideTo: 0.1
	}, {
		type: 'tap',
		time: 66000,
		pitch: 0.8
	}, {
		type: 'tap',
		time: 66800,
		pitch: 0.2
	}, {
		type: 'hold',
		time: 67600,
		pitch: 0.4,
		duration: 1000
	}, {
		type: 'glide',
		time: 69000,
		pitch: 0.7,
		duration: 1000,
		glideTo: 0.5
	}]
}
// Add more songs here as needed
// { name: "Another Song", id: "music2", notes: [...] }
];
var menuContainer = new Container();
game.addChild(menuContainer);
var menuBg = LK.getAsset('pitchBarBg', {
	anchorX: 0.5,
	anchorY: 0.5
});
menuBg.width = 900;
menuBg.height = 900;
menuBg.x = gameWidth / 2;
menuBg.y = gameHeight / 2;
menuBg.alpha = 0.92;
menuContainer.addChild(menuBg);
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
	pitchBarBg.visible = true;
	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
var pitchBarBg = LK.getAsset('pitchBarBg', {
	anchorX: 0.5,
	anchorY: 0
});
pitchBarBg.x = pitchBarX;
pitchBarBg.y = pitchBarY;
game.addChild(pitchBarBg);
// 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
pitchBarBg.visible = false;
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;
// --- 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) {
	var note = new Note();
	note.type = noteData.type;
	note.pitch = noteData.pitch;
	note.time = noteData.time;
	note.duration = noteData.duration || 0;
	note.glideTo = noteData.glideTo !== undefined ? noteData.glideTo : null;
	note.hit = false;
	note.missed = false;
	note.x = noteStartX;
	note.y = pitchToY(note.pitch);
	// For glide: cache start/end pitch
	if (note.type === 'glide') {
		note.glideStart = note.pitch;
		note.glideEnd = note.glideTo;
	}
	// All notes are now click-and-hold (handled in game.update logic)
	// Visuals are handled in Note class (rotated, horizontal bar)
	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;
	// Only allow input on the vertical pitch field (left 240px of screen)
	if (x < pitchBarX - 100 || x > pitchBarX + 100) return;
	pitchFieldActive = true;
	isSliding = true;
	pitchFieldY = y;
	playerPitch = yToPitch(y);
	updatePitchBar();
};
game.move = function (x, y, obj) {
	if (menuActive) return;
	if (pitchFieldActive) {
		pitchFieldY = y;
		playerPitch = yToPitch(y);
		updatePitchBar();
	}
};
game.up = function (x, y, obj) {
	if (menuActive) return;
	pitchFieldActive = false;
	isSliding = false;
};
// Update pitch bar marker position
function updatePitchBar() {
	pitchBarActive.y = pitchToY(playerPitch);
}
// --- Game Loop ---
game.update = function () {
	if (menuActive) {
		// Block game update until song is selected
		return;
	}
	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
	for (var i = 0; i < notes.length; i++) {
		var noteData = notes[i];
		if (!noteData.spawned && noteData.time - (noteStartX - hitZoneX) / noteSpeed < currentTime) {
			spawnNote(noteData);
			noteData.spawned = true;
		}
	}
	// Update notes
	for (var i = activeNotes.length - 1; i >= 0; i--) {
		var note = activeNotes[i];
		// Calculate note's current x based on time
		var noteTime = note.time;
		var t = noteTime - currentTime;
		note.x = hitZoneX + t * noteSpeed;
		// 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 offscreen left
		if (note.x < -200) {
			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;
							LK.getSound('slide').play();
						}
						note.holdScore += 1;
						note.holdTicks += 1;
						if (note.noteAsset) {
							note.noteAsset.scaleX = 1.2;
							note.noteAsset.scaleY = 1.2;
						}
					} else if (note.holdStarted) {
						if (note.noteAsset) {
							note.noteAsset.scaleX = 1;
							note.noteAsset.scaleY = 1;
						}
					}
				}
				// 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;
					if (tapAcc > 0.7) {
						// 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;
						LK.getSound('slide').play();
						note.headCatchTime = currentTime;
						if (note.noteAsset) {
							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;
						if (note.noteAsset) {
							note.noteAsset.scaleX = 1.2;
							note.noteAsset.scaleY = 1.2;
						}
					} else {
						if (note.noteAsset) {
							note.noteAsset.scaleX = 1;
							note.noteAsset.scaleY = 1;
						}
					}
				} else if (note.holdStarted) {
					if (note.noteAsset) {
						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;
					if (note.headCaught && holdAcc > 0.7) {
						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;
							LK.getSound('slide').play();
						}
						note.glideScore += 1;
						note.glideTicks += 1;
						if (note.noteAsset) {
							note.noteAsset.scaleX = 1.2;
							note.noteAsset.scaleY = 1.2;
						}
					} else if (note.glideStarted) {
						if (note.noteAsset) {
							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;
					if (glideAcc > 0.7) {
						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) {
			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";
		}
		// Hide gameplay UI
		pitchBarBg.visible = false;
		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
		var overlayBg = LK.getAsset('pitchBarBg', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		overlayBg.width = 1100;
		overlayBg.height = 1200;
		overlayBg.x = gameWidth / 2;
		overlayBg.y = gameHeight / 2;
		overlayBg.alpha = 0.96;
		resultOverlay.addChild(overlayBg);
		// 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
			pitchBarBg.visible = false;
			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
@@ -56,17 +56,211 @@
 	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)
-	// No holdBar or curveBars visual assets for notes; only the note head will be visible
+	// HoldBar and curveBars visual assets for notes
 	self.noteAsset = null;
+	self.holdBar = null;
 	self.curveBars = [];
 	// 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;
+	// --- HoldBar/CurveBar style selection ---
+	// Only for hold and glide notes
+	self.holdBarStyle = null;
+	if (self.type === 'hold' || self.type === 'glide') {
+		// Randomly pick a style: 0=flat, 1=diagonal, 2=curvy, 3=zigzag
+		self.holdBarStyle = Math.floor(Math.random() * 4);
+	}
+	// Attach note head asset
+	if (self.type === 'tap') {
+		self.noteAsset = self.attachAsset('noteTap', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else if (self.type === 'hold') {
+		self.noteAsset = self.attachAsset('noteHold', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else if (self.type === 'glide') {
+		self.noteAsset = self.attachAsset('noteGlide', {
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	}
+	// Attach holdBar/curveBar for hold and glide notes
+	if (self.type === 'hold' || self.type === 'glide') {
+		// Remove any previous bars
+		if (self.holdBar) {
+			self.removeChild(self.holdBar);
+			self.holdBar = null;
+		}
+		for (var i = 0; i < self.curveBars.length; i++) {
+			self.removeChild(self.curveBars[i]);
+		}
+		self.curveBars = [];
+		// Bar color
+		var barAssetId = 'holdBar';
+		var barColor = 0x44dd88;
+		var barAlpha = 0.7;
+		// Calculate bar start/end positions
+		var startX = 0,
+			startY = 0,
+			endX = 0,
+			endY = 0;
+		var barLen = 0;
+		var barAngle = 0;
+		var barWidth = 36;
+		var barHeight = 0;
+		// For horizontal movement: bar goes from note head (self.x, self.y) to where the tail will be
+		// The bar is drawn relative to the note head (self), so we use local coordinates
+		// The bar always starts at (0,0) in self's local space
+		// For hold: bar is flat or diagonal/curvy/zigzag, but always from head to tail
+		if (self.type === 'hold') {
+			// End X is how far the note will travel during duration
+			var durationPx = (self.duration || 1200) * 1.2; // noteSpeed
+			endX = -durationPx;
+			// End Y: for diagonal/curvy/zigzag, add some Y offset
+			if (self.holdBarStyle === 0) {
+				// flat
+				endY = 0;
+			} else if (self.holdBarStyle === 1) {
+				// diagonal
+				endY = (Math.random() > 0.5 ? 1 : -1) * 180;
+			} else if (self.holdBarStyle === 2) {
+				// curvy
+				endY = (Math.random() > 0.5 ? 1 : -1) * 120;
+			} else if (self.holdBarStyle === 3) {
+				// zigzag
+				endY = (Math.random() > 0.5 ? 1 : -1) * 160;
+			}
+			barLen = Math.sqrt(endX * endX + endY * endY);
+			barAngle = Math.atan2(endY, endX);
+			// For flat/diagonal: single bar
+			if (self.holdBarStyle === 0 || self.holdBarStyle === 1) {
+				self.holdBar = LK.getAsset(barAssetId, {
+					anchorX: 0,
+					anchorY: 0.5
+				});
+				self.holdBar.width = barLen;
+				self.holdBar.height = barWidth;
+				self.holdBar.x = 0;
+				self.holdBar.y = 0;
+				self.holdBar.rotation = barAngle;
+				self.holdBar.alpha = barAlpha;
+				self.holdBar.tint = barColor;
+				self.addChild(self.holdBar);
+			}
+			// For curvy: use 3 bars, each rotated a bit, to fake a curve
+			else if (self.holdBarStyle === 2) {
+				var segs = 3;
+				for (var s = 0; s < segs; s++) {
+					var seg = LK.getAsset(barAssetId, {
+						anchorX: 0,
+						anchorY: 0.5
+					});
+					seg.width = barLen / segs;
+					seg.height = barWidth;
+					seg.x = barLen / segs * s * Math.cos(barAngle);
+					seg.y = barLen / segs * s * Math.sin(barAngle) + Math.sin(s * Math.PI / (segs - 1)) * 60;
+					seg.rotation = barAngle + Math.sin(s * Math.PI / (segs - 1)) * 0.35;
+					seg.alpha = barAlpha;
+					seg.tint = barColor;
+					self.addChild(seg);
+					self.curveBars.push(seg);
+				}
+			}
+			// For zigzag: use 4 bars, alternating y
+			else if (self.holdBarStyle === 3) {
+				var segs = 4;
+				for (var s = 0; s < segs; s++) {
+					var seg = LK.getAsset(barAssetId, {
+						anchorX: 0,
+						anchorY: 0.5
+					});
+					seg.width = barLen / segs;
+					seg.height = barWidth;
+					seg.x = barLen / segs * s * Math.cos(barAngle);
+					seg.y = barLen / segs * s * Math.sin(barAngle) + (s % 2 === 0 ? 60 : -60);
+					seg.rotation = barAngle;
+					seg.alpha = barAlpha;
+					seg.tint = barColor;
+					self.addChild(seg);
+					self.curveBars.push(seg);
+				}
+			}
+		}
+		// For glide: bar goes from head to tail, but y is based on pitch glide
+		else if (self.type === 'glide') {
+			var durationPx = (self.duration || 1200) * 1.2;
+			endX = -durationPx;
+			// End Y is the difference in pitch mapped to pixels
+			var pitchDelta = (self.glideTo !== null ? self.glideTo : self.pitch) - self.pitch;
+			endY = -pitchDelta * 1800; // pitchBarHeight
+			barLen = Math.sqrt(endX * endX + endY * endY);
+			barAngle = Math.atan2(endY, endX);
+			// For flat/diagonal: single bar
+			if (self.holdBarStyle === 0 || self.holdBarStyle === 1) {
+				self.holdBar = LK.getAsset(barAssetId, {
+					anchorX: 0,
+					anchorY: 0.5
+				});
+				self.holdBar.width = barLen;
+				self.holdBar.height = barWidth;
+				self.holdBar.x = 0;
+				self.holdBar.y = 0;
+				self.holdBar.rotation = barAngle;
+				self.holdBar.alpha = barAlpha;
+				self.holdBar.tint = barColor;
+				self.addChild(self.holdBar);
+			}
+			// For curvy: use 3 bars, each rotated a bit, to fake a curve
+			else if (self.holdBarStyle === 2) {
+				var segs = 3;
+				for (var s = 0; s < segs; s++) {
+					var seg = LK.getAsset(barAssetId, {
+						anchorX: 0,
+						anchorY: 0.5
+					});
+					seg.width = barLen / segs;
+					seg.height = barWidth;
+					// Interpolate y between start and end, add curve
+					var t = s / (segs - 1);
+					seg.x = barLen / segs * s * Math.cos(barAngle);
+					seg.y = barLen / segs * s * Math.sin(barAngle) + Math.sin(t * Math.PI) * 80;
+					seg.rotation = barAngle + Math.sin(t * Math.PI) * 0.35;
+					seg.alpha = barAlpha;
+					seg.tint = barColor;
+					self.addChild(seg);
+					self.curveBars.push(seg);
+				}
+			}
+			// For zigzag: use 4 bars, alternating y
+			else if (self.holdBarStyle === 3) {
+				var segs = 4;
+				for (var s = 0; s < segs; s++) {
+					var seg = LK.getAsset(barAssetId, {
+						anchorX: 0,
+						anchorY: 0.5
+					});
+					seg.width = barLen / segs;
+					seg.height = barWidth;
+					var t = s / (segs - 1);
+					seg.x = barLen / segs * s * Math.cos(barAngle);
+					seg.y = barLen / segs * s * Math.sin(barAngle) + (s % 2 === 0 ? 70 : -70);
+					seg.rotation = barAngle;
+					seg.alpha = barAlpha;
+					seg.tint = barColor;
+					self.addChild(seg);
+					self.curveBars.push(seg);
+				}
+			}
+		}
+	}
 	// Update visuals per frame
 	self.update = function () {
 		// No holdBar or curveBars drawing logic; nothing to draw for hold bar
 	};