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

/**** 
* Classes
****/ 
var Enemy = Container.expand(function (lane, yPos, beatIndex) {
	var self = Container.call(this);
	// Store original color for flash effect - must be done before attaching asset if asset tint is used
	// However, shape assets don't have a tint property directly, they have color.
	// We will access the child graphics object's tint if needed. For now, assuming direct manipulation.
	// var enemyGraphics = self.attachAsset('enemy', {anchorX: 0.5, anchorY: 0.5});
	// self.originalTint = enemyGraphics.tint; // This would be for tintable assets
	self.showHitEffect = function () {
		LK.getSound('hitSound').play();
		// Simple scale and fade out effect
		tween(self, {
			scaleX: 1.5,
			scaleY: 1.5,
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				self.active = false; // Mark for removal
				// Actual removal will be handled in game.update
			}
		});
	};
	self.showMissEffect = function () {
		LK.getSound('missSound').play();
		var enemyGraphics = self.children[0];
		var originalColor = 0xff6347; // Storing original color of the shape, as tint applies over it
		// Tint red briefly then back to original, then fade slightly
		tween(enemyGraphics, {
			tint: 0xff0000
		}, {
			// Tint to red
			duration: 150,
			onFinish: function onFinish() {
				tween(enemyGraphics, {
					tint: 0xffffff
				}, {
					// Tint back to neutral (so original color shows)
					duration: 150,
					onFinish: function onFinish() {
						self.alpha = 0.4; // Visually indicate it's missed and processed
						self.active = false; // Mark for removal after visual indication
					}
				});
			}
		});
	};
	// Properties must be defined after methods that might use them if not careful with `this` context issues
	// but for simple assignment, it's fine.
	var enemyGraphics = self.attachAsset('enemy', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// self.originalColor = enemyGraphics.color; // color is a definition-time property, not runtime for shapes
	self.lane = lane;
	self.yPos = yPos; // Target Y position
	self.beatIndex = beatIndex; // Beat index in the 8-beat cycle (0-7)
	self.active = true; // Still in play, not hit or missed
	self.isHit = false;
	self.isMissed = false; // Flag to ensure miss is processed only once
	self.markedForRemoval = false;
	return self;
});

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

/**** 
* Game Code
****/ 
// Game Constants
// Tomato color
// Cyan
// Dark grey
// Red
// Yellow for tap
// Placeholder music ID
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
var LANE_COUNT = 3;
var LANE_WIDTH = GAME_WIDTH / LANE_COUNT;
var BPM = 105; // Beats per minute
var BEAT_DURATION_MS = 60 / BPM * 1000;
var BEATS_PER_DIRECTION = 4; // 4 beats down, 4 beats up
var TOTAL_BEATS_IN_CYCLE = BEATS_PER_DIRECTION * 2; // 8 beats per full cycle
var ONE_WAY_TRAVEL_DURATION_MS = BEATS_PER_DIRECTION * BEAT_DURATION_MS;
var TIMING_BAR_Y_MIN = 200; // Top travel position of timing bar (avoid top-left area)
var TIMING_BAR_Y_MAX = GAME_HEIGHT - 350; // Bottom travel position (leave space for lane indicators + margin)
var PLAY_AREA_HEIGHT = TIMING_BAR_Y_MAX - TIMING_BAR_Y_MIN;
var INITIAL_PLAYER_HEALTH = 5;
var HIT_TOLERANCE_PX = 85; // Generous tolerance for timing bar alignment with enemy center
var TARGET_SCORE_TO_WIN = 500; // Score based on 10 points per hit
// Game State Variables
var playerHealth;
var healthPips = [];
var scoreTxt;
var timingBar;
var timingBarIsMovingDown = true;
var currentBeatInCycle = 0; // 0-7
var masterBeatTimer;
var enemies = [];
var enemyYPositions = []; // Pre-calculated Y positions for enemies based on beat index
var currentWaveIndex = 0;
// levelData: Array of waves. Each wave is an array of enemy spawns for an 8-beat cycle.
// { beatIndex: 0-7, laneIndex: 0-2 }
// Max 2 enemies per beatIndex
var levelData = [
// Wave 1
[{
	beatIndex: 0,
	laneIndex: 1
}, {
	beatIndex: 1,
	laneIndex: 0
}, {
	beatIndex: 2,
	laneIndex: 2
}, {
	beatIndex: 3,
	laneIndex: 1
}, {
	beatIndex: 4,
	laneIndex: 1
}, {
	beatIndex: 5,
	laneIndex: 2
}, {
	beatIndex: 6,
	laneIndex: 0
}, {
	beatIndex: 7,
	laneIndex: 1
}],
// Wave 2
[{
	beatIndex: 0,
	laneIndex: 0
}, {
	beatIndex: 0,
	laneIndex: 2
}, {
	beatIndex: 1,
	laneIndex: 1
}, {
	beatIndex: 2,
	laneIndex: 0
}, {
	beatIndex: 2,
	laneIndex: 1
}, {
	beatIndex: 3,
	laneIndex: 2
}, {
	beatIndex: 4,
	laneIndex: 0
}, {
	beatIndex: 4,
	laneIndex: 2
}, {
	beatIndex: 5,
	laneIndex: 1
}, {
	beatIndex: 6,
	laneIndex: 0
}, {
	beatIndex: 6,
	laneIndex: 1
}, {
	beatIndex: 7,
	laneIndex: 2
}],
// Wave 3 (more dense)
[{
	beatIndex: 0,
	laneIndex: 0
}, {
	beatIndex: 0,
	laneIndex: 1
}, {
	beatIndex: 1,
	laneIndex: 1
}, {
	beatIndex: 1,
	laneIndex: 2
}, {
	beatIndex: 2,
	laneIndex: 0
}, {
	beatIndex: 2,
	laneIndex: 2
}, {
	beatIndex: 3,
	laneIndex: 0
}, {
	beatIndex: 3,
	laneIndex: 1
}, {
	beatIndex: 4,
	laneIndex: 2
}, {
	beatIndex: 4,
	laneIndex: 1
}, {
	beatIndex: 5,
	laneIndex: 0
}, {
	beatIndex: 5,
	laneIndex: 1
}, {
	beatIndex: 6,
	laneIndex: 2
}, {
	beatIndex: 6,
	laneIndex: 0
}, {
	beatIndex: 7,
	laneIndex: 1
}, {
	beatIndex: 7,
	laneIndex: 2
}],
// Wave 4
[{
	beatIndex: 0,
	laneIndex: 1
}, {
	beatIndex: 1,
	laneIndex: 0
}, {
	beatIndex: 1,
	laneIndex: 2
}, {
	beatIndex: 2,
	laneIndex: 1
}, {
	beatIndex: 2,
	laneIndex: 0
}, {
	beatIndex: 3,
	laneIndex: 2
}, {
	beatIndex: 3,
	laneIndex: 0
}, {
	beatIndex: 4,
	laneIndex: 1
}, {
	beatIndex: 5,
	laneIndex: 0
}, {
	beatIndex: 5,
	laneIndex: 2
}, {
	beatIndex: 6,
	laneIndex: 1
}, {
	beatIndex: 6,
	laneIndex: 2
}, {
	beatIndex: 7,
	laneIndex: 0
}, {
	beatIndex: 7,
	laneIndex: 1
}]];
function calculateEnemyYPositions() {
	enemyYPositions = [];
	// Calculate safe spawn area (exclude top and bottom 10%)
	var safePlayAreaHeight = PLAY_AREA_HEIGHT * 0.8; // 80% of original height
	var safeAreaStart = TIMING_BAR_Y_MIN + PLAY_AREA_HEIGHT * 0.1; // Start 10% down from top
	// Downward stroke (beats 0-3)
	for (var i = 0; i < BEATS_PER_DIRECTION; i++) {
		if (BEATS_PER_DIRECTION <= 1) {
			// Avoid division by zero if only one beat slot
			enemyYPositions.push(safeAreaStart + safePlayAreaHeight / 2);
		} else {
			enemyYPositions.push(safeAreaStart + i / (BEATS_PER_DIRECTION - 1) * safePlayAreaHeight);
		}
	}
	// Upward stroke (beats 4-7)
	for (var i = 0; i < BEATS_PER_DIRECTION; i++) {
		if (BEATS_PER_DIRECTION <= 1) {
			enemyYPositions.push(safeAreaStart + safePlayAreaHeight / 2);
		} else {
			// These are the Y positions the bar hits on beats 4,5,6,7. Beat 4 is at safe bottom.
			var safeAreaEnd = safeAreaStart + safePlayAreaHeight;
			enemyYPositions.push(safeAreaEnd - i / (BEATS_PER_DIRECTION - 1) * safePlayAreaHeight);
		}
	}
}
function initHealthDisplay() {
	healthPips.forEach(function (pip) {
		if (pip && pip.destroy) pip.destroy();
	}); // Check pip before destroy
	healthPips = [];
	var pipSpacing = 70; // Spacing between centers of pips
	var totalPipsWidth = (INITIAL_PLAYER_HEALTH - 1) * pipSpacing + 60; // 60 is pip width
	var startX = GAME_WIDTH - totalPipsWidth - 30; // 30 is padding from right edge
	for (var i = 0; i < INITIAL_PLAYER_HEALTH; i++) {
		var pip = LK.getAsset('healthPip', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		pip.x = startX + i * pipSpacing;
		pip.y = 70; // Positioned below top edge, avoiding top-left corner (100x100)
		LK.gui.top.addChild(pip); // Add to general GUI layer, specifically top section
		healthPips.push(pip);
	}
}
function updateHealthDisplay() {
	for (var i = 0; i < healthPips.length; i++) {
		if (healthPips[i]) healthPips[i].visible = i < playerHealth;
	}
	if (playerHealth <= 0) {
		LK.showGameOver();
		if (masterBeatTimer) LK.clearInterval(masterBeatTimer);
		masterBeatTimer = null; // Clear timer reference
		tween.stop(timingBar); // Stop bar movement
	}
}
function spawnEnemiesForCurrentCycle() {
	if (currentWaveIndex >= levelData.length && levelData.length > 0) {
		// All unique waves cleared, repeat last wave if desired or stop.
		currentWaveIndex = levelData.length - 1;
	}
	if (levelData.length === 0) return; // No levels defined
	var wave = levelData[currentWaveIndex];
	wave.forEach(function (enemyData) {
		var lane = enemyData.laneIndex;
		var beat = enemyData.beatIndex; // This is 0-7, maps to enemyYPositions
		var yPos = enemyYPositions[beat];
		var newEnemy = new Enemy(lane, yPos, beat);
		newEnemy.x = lane * LANE_WIDTH + LANE_WIDTH / 2;
		newEnemy.y = yPos;
		enemies.push(newEnemy);
		game.addChild(newEnemy);
	});
}
function moveTimingBar() {
	if (!timingBar) return; // Safety check
	tween.stop(timingBar);
	var targetY;
	if (timingBarIsMovingDown) {
		targetY = TIMING_BAR_Y_MAX;
	} else {
		targetY = TIMING_BAR_Y_MIN;
	}
	// Ensure bar starts at the correct position if it drifted
	timingBar.y = timingBarIsMovingDown ? TIMING_BAR_Y_MIN : TIMING_BAR_Y_MAX;
	tween(timingBar, {
		y: targetY
	}, {
		duration: ONE_WAY_TRAVEL_DURATION_MS,
		easing: tween.linear
	});
}
function onBeat() {
	currentBeatInCycle++;
	if (currentBeatInCycle >= TOTAL_BEATS_IN_CYCLE) {
		currentBeatInCycle = 0;
		currentWaveIndex++;
	}
	if (currentBeatInCycle === 0) {
		// Start of downward movement
		timingBarIsMovingDown = true;
		moveTimingBar();
		spawnEnemiesForCurrentCycle();
	} else if (currentBeatInCycle === BEATS_PER_DIRECTION) {
		// Start of upward movement
		timingBarIsMovingDown = false;
		moveTimingBar();
	}
}
function setupGame() {
	LK.setScore(0); // Reset score at game start
	playerHealth = INITIAL_PLAYER_HEALTH;
	// Score Text
	if (scoreTxt && scoreTxt.destroy) scoreTxt.destroy();
	scoreTxt = new Text2('0', {
		size: 100,
		fill: 0xFFFFFF
	});
	scoreTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(scoreTxt);
	scoreTxt.setText(LK.getScore());
	// Health Display
	initHealthDisplay();
	updateHealthDisplay();
	calculateEnemyYPositions();
	if (timingBar && timingBar.destroy) timingBar.destroy();
	timingBar = game.attachAsset('timingBar', {
		anchorX: 0,
		anchorY: 0.5
	});
	timingBar.x = 0;
	timingBar.y = TIMING_BAR_Y_MIN;
	// Remove old lane indicators if any from previous game instances
	// This is tricky as they are not stored in an array. For now, assume engine clears on reset.
	// For MVP, we'll re-add. Proper cleanup would involve tracking them.
	for (var i = 0; i < LANE_COUNT; i++) {
		var indicator = game.attachAsset('laneIndicator', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		indicator.x = i * LANE_WIDTH + LANE_WIDTH / 2;
		indicator.y = GAME_HEIGHT - 20;
		indicator.alpha = 0.5;
	}
	enemies.forEach(function (e) {
		if (e && e.destroy) e.destroy();
	});
	enemies = [];
	currentBeatInCycle = -1;
	currentWaveIndex = 0;
	timingBarIsMovingDown = true;
	if (masterBeatTimer) LK.clearInterval(masterBeatTimer);
	masterBeatTimer = LK.setInterval(onBeat, BEAT_DURATION_MS);
	onBeat();
	LK.playMusic('gameMusic', {
		loop: true
	});
}
// Initial setup call
setupGame();
game.down = function (x, y, obj) {
	if (playerHealth <= 0) return; // Don't process taps if game over
	var tappedLane = Math.floor(x / LANE_WIDTH);
	if (tappedLane < 0 || tappedLane >= LANE_COUNT) return;
	var feedback = game.attachAsset('tapFeedback', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	feedback.x = tappedLane * LANE_WIDTH + LANE_WIDTH / 2;
	feedback.y = timingBar.y;
	feedback.alpha = 0.7;
	tween(feedback, {
		alpha: 0,
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 300,
		onFinish: function onFinish() {
			if (feedback && feedback.destroy) feedback.destroy();
		}
	});
	var hitOccurred = false;
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (enemy && enemy.active && !enemy.isHit && enemy.lane === tappedLane) {
			if (Math.abs(timingBar.y - enemy.yPos) < HIT_TOLERANCE_PX) {
				enemy.isHit = true;
				// enemy.active = false; // Effects will set this or markForRemoval
				enemy.showHitEffect();
				LK.setScore(LK.getScore() + 10);
				scoreTxt.setText(LK.getScore());
				hitOccurred = true;
				if (LK.getScore() >= TARGET_SCORE_TO_WIN) {
					LK.showYouWin();
					if (masterBeatTimer) LK.clearInterval(masterBeatTimer);
					masterBeatTimer = null;
					tween.stop(timingBar);
					return;
				}
				break;
			}
		}
	}
};
game.update = function () {
	if (playerHealth <= 0 && masterBeatTimer) {
		// Game ended, ensure timer is stopped
		LK.clearInterval(masterBeatTimer);
		masterBeatTimer = null;
		tween.stop(timingBar);
		return;
	}
	if (!masterBeatTimer && playerHealth > 0) {// If timer somehow stopped but game should run
		// This case should ideally not happen if LK.showGameOver stops game logic or resets.
		// For safety, one might re-initialize part of the game logic, but it's complex.
	}
	for (var i = enemies.length - 1; i >= 0; i--) {
		var enemy = enemies[i];
		if (!enemy) {
			// Safety check if an enemy got nulled out
			enemies.splice(i, 1);
			continue;
		}
		if (enemy.active && !enemy.isHit && !enemy.isMissed) {
			var barPassedEnemy = false;
			// Use enemy height for more accurate pass detection relative to its visual bounds
			var enemyVisualHeight = enemy.children[0] ? enemy.children[0].height : 100; // default if not found
			if (timingBarIsMovingDown && timingBar.y > enemy.yPos + enemyVisualHeight / 2 + 5) {
				barPassedEnemy = true;
			} else if (!timingBarIsMovingDown && timingBar.y < enemy.yPos - enemyVisualHeight / 2 - 5) {
				barPassedEnemy = true;
			}
			if (barPassedEnemy) {
				enemy.isMissed = true;
				// enemy.active = false; // showMissEffect will handle this transition
				enemy.showMissEffect();
				playerHealth--;
				updateHealthDisplay();
				if (playerHealth <= 0) return;
			}
		}
		// Cleanup logic
		if (enemy.markedForRemoval) {
			// If an effect flagged it for removal
			enemies.splice(i, 1);
			if (game.children.indexOf(enemy) > -1) game.removeChild(enemy); // ensure it's a child before removing
			if (enemy.destroy) enemy.destroy();
		} else if (!enemy.active) {
			// General check for inactive enemies (after effects might finish)
			// Hit enemies fade out and set active=false.
			// Missed enemies dim and set active=false.
			// This part handles removal after their visual effects are somewhat done.
			var isEffectDone = enemy.isHit && enemy.alpha < 0.05 || enemy.isMissed && enemy.alpha < 0.45;
			if (isEffectDone) {
				enemy.markedForRemoval = true; // Mark for next frame removal to be safe
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -78,15 +78,15 @@
 
 /**** 
 * Game Code
 ****/ 
-// Placeholder music ID
-// Yellow for tap
-// Red
-// Dark grey
-// Cyan
-// Tomato color
 // Game Constants
+// Tomato color
+// Cyan
+// Dark grey
+// Red
+// Yellow for tap
+// Placeholder music ID
 var GAME_WIDTH = 2048;
 var GAME_HEIGHT = 2732;
 var LANE_COUNT = 3;
 var LANE_WIDTH = GAME_WIDTH / LANE_COUNT;
@@ -275,24 +275,28 @@
 	laneIndex: 1
 }]];
 function calculateEnemyYPositions() {
 	enemyYPositions = [];
+	// Calculate safe spawn area (exclude top and bottom 10%)
+	var safePlayAreaHeight = PLAY_AREA_HEIGHT * 0.8; // 80% of original height
+	var safeAreaStart = TIMING_BAR_Y_MIN + PLAY_AREA_HEIGHT * 0.1; // Start 10% down from top
 	// Downward stroke (beats 0-3)
 	for (var i = 0; i < BEATS_PER_DIRECTION; i++) {
 		if (BEATS_PER_DIRECTION <= 1) {
 			// Avoid division by zero if only one beat slot
-			enemyYPositions.push(TIMING_BAR_Y_MIN + PLAY_AREA_HEIGHT / 2);
+			enemyYPositions.push(safeAreaStart + safePlayAreaHeight / 2);
 		} else {
-			enemyYPositions.push(TIMING_BAR_Y_MIN + i / (BEATS_PER_DIRECTION - 1) * PLAY_AREA_HEIGHT);
+			enemyYPositions.push(safeAreaStart + i / (BEATS_PER_DIRECTION - 1) * safePlayAreaHeight);
 		}
 	}
 	// Upward stroke (beats 4-7)
 	for (var i = 0; i < BEATS_PER_DIRECTION; i++) {
 		if (BEATS_PER_DIRECTION <= 1) {
-			enemyYPositions.push(TIMING_BAR_Y_MIN + PLAY_AREA_HEIGHT / 2);
+			enemyYPositions.push(safeAreaStart + safePlayAreaHeight / 2);
 		} else {
-			// These are the Y positions the bar hits on beats 4,5,6,7. Beat 4 is at TIMING_BAR_Y_MAX.
-			enemyYPositions.push(TIMING_BAR_Y_MAX - i / (BEATS_PER_DIRECTION - 1) * PLAY_AREA_HEIGHT);
+			// These are the Y positions the bar hits on beats 4,5,6,7. Beat 4 is at safe bottom.
+			var safeAreaEnd = safeAreaStart + safePlayAreaHeight;
+			enemyYPositions.push(safeAreaEnd - i / (BEATS_PER_DIRECTION - 1) * safePlayAreaHeight);
 		}
 	}
 }
 function initHealthDisplay() {