/**** 
* Classes
****/ 
// EnemyBike class: faster enemy type
var EnemyBike = Container.expand(function () {
	var self = Container.call(this);
	// Attach enemyBike asset (image, facing upward)
	var bike = self.attachAsset('enemyBike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set vertical speed (will be set on spawn)
	self.speedY = 24;
	// Track lastY for event triggers
	self.lastY = self.y;
	self.update = function () {
		self.lastY = self.y;
		self.y += self.speedY;
		// EnemyBike moves straight down in its lane
	};
	return self;
});
// Motorcycle class: player-controlled bike
var Motorcycle = Container.expand(function () {
	var self = Container.call(this);
	// Attach motorcycle asset (image, facing upward)
	var bike = self.attachAsset('motorcycle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set initial speed and direction
	self.speedY = 18; // vertical speed (track scrolls down)
	self.laneSpeed = 0; // horizontal speed (player control)
	self.maxX = 2048 - bike.width / 2;
	self.minX = bike.width / 2;
	// Track lastX for event triggers
	self.lastX = self.x;
	// Update method: move forward, apply lane movement
	self.update = function () {
		self.lastX = self.x;
		self.x += self.laneSpeed;
		// Clamp to track bounds
		if (self.x < self.minX) self.x = self.minX;
		if (self.x > self.maxX) self.x = self.maxX;
	};
	return self;
});
// Obstacle class: static/dynamic hazards
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	// Attach obstacle asset (box, red)
	var obs = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set vertical speed (scrolls with track)
	self.speedY = 18;
	// Track lastY for event triggers
	self.lastY = self.y;
	self.update = function () {
		self.lastY = self.y;
		self.y += self.speedY;
	};
	return self;
});
// PowerUp class: collectible items
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	// Attach powerup asset (ellipse, yellow)
	var pu = self.attachAsset('powerup', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speedY = 18;
	self.lastY = self.y;
	self.update = function () {
		self.lastY = self.y;
		self.y += self.speedY;
	};
	return self;
});
// PunchProjectile class: short-range punch effect
var PunchProjectile = Container.expand(function () {
	var self = Container.call(this);
	// Use a 20px diameter glowing blue orb as the punch effect (debug)
	var orb = self.attachAsset('laneDash', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 20,
		height: 20,
		color: 0x22aaff // bright blue
	});
	// Add a glow effect: larger, semi-transparent blue circle
	var glow = self.attachAsset('laneDash', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 40,
		height: 40,
		color: 0x22aaff
	});
	glow.alpha = 0.5;
	self.addChild(glow);
	self.addChild(orb);
	orb.alpha = 1.0;
	self.speedY = -1; // Slow upward movement for visualization
	self.startY = 0; // Will be set on spawn
	self.traveled = 0;
	self.update = function () {
		// On first update, set startY to initial Y position
		if (typeof self.startY === "undefined" || self.startY === 0) {
			self.startY = self.y;
		}
		self.y += self.speedY;
		// Calculate how far we've moved upward (negative direction)
		self.traveled = self.startY - self.y;
		// Only disappear after moving 40px upward from initial Y
		if (self.traveled >= 40) {
			self.destroy();
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
// Motorcycle asset (blue box)
// Obstacle asset (red box)
// PowerUp asset (yellow ellipse)
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// --- Update punch projectiles and check for enemy hits ---
// --- Auto-punch timer ---
var punchInterval = 120; // 2 seconds at 60fps
var punchTimer = 0;
// (auto-punch logic moved to game.update)
// Road background: gray
// --- Game State ---
// PowerUp asset (yellow ellipse)
// Obstacle asset (red box)
// Motorcycle asset (blue box)
// --- Road Background ---
var roadCenterX = 2048 / 2;
var roadBg1 = LK.getAsset('roadBg', {
	anchorX: 0.5,
	anchorY: 0,
	width: 1200,
	height: 2732,
	x: roadCenterX,
	y: 0
});
var roadBg2 = LK.getAsset('roadBg', {
	anchorX: 0.5,
	anchorY: 0,
	width: 1200,
	height: 2732,
	x: roadCenterX,
	y: -2732
});
// If the asset doesn't exist, create it as a gray box
if (!roadBg1) {
	roadBg1 = LK.getAsset('roadBg', {
		anchorX: 0.5,
		anchorY: 0,
		width: 1200,
		height: 2732,
		x: roadCenterX,
		y: 0
	});
	roadBg2 = LK.getAsset('roadBg', {
		anchorX: 0.5,
		anchorY: 0,
		width: 1200,
		height: 2732,
		x: roadCenterX,
		y: -2732
	});
}
game.addChild(roadBg1);
game.addChild(roadBg2);
// Lane definitions for 3-lane road (centered, full width 2048)
var laneCount = 3;
var laneWidth = 400;
var laneX = [2048 / 2 - laneWidth,
// left lane center
2048 / 2,
// center lane center
2048 / 2 + laneWidth // right lane center
];
// --- Lane Lines (dashed) ---
var laneLineContainers = [];
var laneLineCount = 2; // 2 lines between 3 lanes
var dashHeight = 80;
var dashGap = 80;
var lineWidth = 16;
var lineColor = 0xffffff;
var roadTop = 0;
var roadBottom = 2732;
var dashesPerLine = Math.ceil((roadBottom - roadTop) / (dashHeight + dashGap)) + 2;
for (var i = 0; i < laneLineCount; i++) {
	var lineContainer = new Container();
	var x = (laneX[i] + laneX[i + 1]) / 2;
	for (var d = 0; d < dashesPerLine; d++) {
		// Use the laneDash asset for white dashes
		var dash = LK.getAsset('laneDash', {
			width: lineWidth,
			height: dashHeight,
			anchorX: 0.5,
			anchorY: 0
		});
		dash.x = x;
		dash.y = roadTop + d * (dashHeight + dashGap);
		lineContainer.addChild(dash);
	}
	laneLineContainers.push(lineContainer);
	game.addChild(lineContainer);
}
var player = new Motorcycle();
player.x = 2048 / 2; // Center horizontally
player.y = 2732 - 220; // Place near bottom (220 is half the motorcycle height)
game.addChild(player);
var obstacles = [];
var enemyBikes = [];
var powerups = [];
var punchProjectiles = []; // Array for punch projectiles
// --- Score ---
var score = 0;
var distance = 0;
// --- Health ---
var playerHealth = 3;
var maxPlayerHealth = 3;
// Container for tire icons
var healthIcons = new Container();
healthIcons.x = 110;
healthIcons.y = 0;
LK.gui.top.addChild(healthIcons);
// Helper to update tire icons
function updateHealthIcons() {
	// Remove all previous icons
	while (healthIcons.children.length > 0) {
		var c = healthIcons.children.pop();
		if (c && typeof c.destroy === "function") c.destroy();
	}
	// Add one tire icon per health
	for (var h = 0; h < playerHealth; h++) {
		var tire = LK.getAsset('tireIcon', {
			anchorX: 0,
			anchorY: 0,
			width: 90,
			height: 90
		});
		tire.x = h * 100;
		tire.y = 10;
		healthIcons.addChild(tire);
	}
}
updateHealthIcons();
// Score display
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
// Anchor to the right edge, top (1, 0)
scoreTxt.anchor.set(1, 0);
// Add to top-right GUI overlay
LK.gui.topRight.addChild(scoreTxt);
// (Punch button removed)
// Touch drag to steer
var dragActive = false;
var dragOffsetX = 0;
game.down = function (x, y, obj) {
	// (Punch logic on right half tap removed)
	// Only start drag if touch is near the player
	var dx = x - player.x;
	var dy = y - player.y;
	if (dx * dx + dy * dy < 300 * 300) {
		dragActive = true;
		dragOffsetX = player.x - x;
	}
};
game.move = function (x, y, obj) {
	if (dragActive) {
		player.x = x + dragOffsetX;
	}
};
game.up = function (x, y, obj) {
	dragActive = false;
};
// --- Spawning logic ---
var obstacleTimer = 0;
var powerupTimer = 0;
// --- Difficulty scaling ---
var enemyBaseSpeed = 24; // initial EnemyBike speed
var enemySpeed = enemyBaseSpeed;
var enemyBaseSpawnInterval = 40; // initial spawn interval (frames)
var enemySpawnInterval = enemyBaseSpawnInterval;
var difficultyTimer = 0; // counts frames for difficulty increase
var difficultyInterval = 600; // every 600 frames (~10s at 60fps), increase difficulty
var enemySpeedIncrement = 2; // how much to increase speed each interval
var enemySpawnDecrement = 4; // how much to decrease spawn interval each interval (minimum capped)
var minEnemySpawnInterval = 12; // minimum allowed spawn interval
// --- Main update loop ---
game.update = function () {
	// --- Fire punchProjectile every 2 seconds ---
	punchTimer++;
	if (punchTimer >= punchInterval) {
		punchTimer = 0;
		var punch = new PunchProjectile();
		punch.x = player.x;
		punch.y = player.y - 100; // In front of player
		game.addChild(punch);
		punchProjectiles.push(punch);
	}
	// Ensure all punchProjectiles are attached to the game and visible as they move
	for (var i = 0; i < punchProjectiles.length; i++) {
		var proj = punchProjectiles[i];
		if (!proj.parent) {
			game.addChild(proj);
		}
	}
	// Scroll road background downward to simulate forward motion
	roadBg1.y += player.speedY;
	roadBg2.y += player.speedY;
	// Loop backgrounds
	if (roadBg1.y >= 2732) {
		roadBg1.y = roadBg2.y - 2732;
	}
	if (roadBg2.y >= 2732) {
		roadBg2.y = roadBg1.y - 2732;
	}
	// Scroll and loop lane lines downward
	for (var i = 0; i < laneLineContainers.length; i++) {
		var lineContainer = laneLineContainers[i];
		for (var j = 0; j < lineContainer.children.length; j++) {
			var dash = lineContainer.children[j];
			dash.y += player.speedY;
			if (dash.y > 2732) {
				dash.y -= (dashHeight + dashGap) * lineContainer.children.length;
				// This ensures the dash loops back to the top
			}
		}
	}
	// Move player (handled in class)
	player.update();
	// Scroll obstacles and powerups
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		obs.update();
		// Remove if off screen
		if (obs.lastY < 2732 && obs.y >= 2732 + 100) {
			obs.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision detection (trigger on first intersect)
		if (!obs.lastWasIntersecting && obs.intersects(player)) {
			LK.effects.flashScreen(0xff0000, 800);
			LK.showGameOver();
			return;
		}
		obs.lastWasIntersecting = obs.intersects(player);
	}
	// Handle enemyBikes
	for (var i = enemyBikes.length - 1; i >= 0; i--) {
		var eb = enemyBikes[i];
		eb.update();
		// Remove if off screen
		if (eb.lastY < 2732 && eb.y >= 2732 + 100) {
			eb.destroy();
			enemyBikes.splice(i, 1);
			continue;
		}
		// Collision detection (trigger on first intersect)
		if (!eb.lastWasIntersecting && eb.intersects(player)) {
			LK.effects.flashScreen(0xff0000, 800);
			playerHealth--;
			// Update health icon display
			updateHealthIcons();
			if (playerHealth <= 0) {
				LK.showGameOver();
				return;
			}
		}
		eb.lastWasIntersecting = eb.intersects(player);
		// (auto-punch logic removed)
	}
	// --- Auto-punch: (removed, replaced by timed punch below)
	// Auto-punch logic: punch any enemyBike within punchHitboxRect in front of the player
	var punchHitboxWidth = 120; // width of punch area (in front of player)
	var punchHitboxHeight = 180; // height of punch area (centered on player)
	var punchHitboxOffset = 60; // how far in front of player the hitbox starts
	var punchHitboxRect = {
		x: player.x - punchHitboxWidth / 2,
		y: player.y - punchHitboxOffset - punchHitboxHeight,
		width: punchHitboxWidth,
		height: punchHitboxHeight
	};
	// Listen for the 'enemyInPunchRange' event and punch using punchHitboxRect
	if (typeof LK !== "undefined" && typeof LK.on === "function") {
		LK.on('enemyInPunchRange', function () {
			// When the event is triggered, punch all enemyBikes within punchHitboxRect
			for (var j = enemyBikes.length - 1; j >= 0; j--) {
				var eb2 = enemyBikes[j];
				if (eb2.x >= punchHitboxRect.x && eb2.x <= punchHitboxRect.x + punchHitboxRect.width && eb2.y >= punchHitboxRect.y && eb2.y <= punchHitboxRect.y + punchHitboxRect.height) {
					// Trigger punch: destroy the enemy and remove from array
					eb2.destroy();
					enemyBikes.splice(j, 1);
				}
			}
		});
	}
	// --- Update punch projectiles and check for enemy hits ---
	for (var i = punchProjectiles.length - 1; i >= 0; i--) {
		var proj = punchProjectiles[i];
		proj.update();
		// Remove if destroyed or off screen
		if (proj._destroyed || proj.y < -100) {
			punchProjectiles.splice(i, 1);
			continue;
		}
		// Check collision with enemyBikes
		var hit = false;
		for (var j = enemyBikes.length - 1; j >= 0; j--) {
			var eb = enemyBikes[j];
			// Calculate distance between centers
			var dx = proj.x - eb.x;
			var dy = proj.y - eb.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			// Use a 10px collision radius for punchProjectile
			if (dist <= 10) {
				// Destroy both projectile and enemy
				eb.destroy();
				enemyBikes.splice(j, 1);
				proj.destroy();
				punchProjectiles.splice(i, 1);
				score += 5;
				scoreTxt.setText(score);
				hit = true;
				break;
			}
		}
		if (hit) continue;
		// (removal by traveled 40px is now handled inside PunchProjectile class update)
	}
	for (var i = powerups.length - 1; i >= 0; i--) {
		var pu = powerups[i];
		pu.update();
		// Remove if off screen
		if (pu.lastY < 2732 && pu.y >= 2732 + 100) {
			pu.destroy();
			powerups.splice(i, 1);
			continue;
		}
		// Collect powerup
		if (!pu.lastWasIntersecting && pu.intersects(player)) {
			score += 10;
			scoreTxt.setText(score);
			pu.destroy();
			powerups.splice(i, 1);
			continue;
		}
		pu.lastWasIntersecting = pu.intersects(player);
	}
	// --- Difficulty scaling ---
	difficultyTimer++;
	if (difficultyTimer >= difficultyInterval) {
		difficultyTimer = 0;
		// Increase enemy speed
		enemySpeed += enemySpeedIncrement;
		// Decrease spawn interval, but not below minimum
		enemySpawnInterval -= enemySpawnDecrement;
		if (enemySpawnInterval < minEnemySpawnInterval) enemySpawnInterval = minEnemySpawnInterval;
	}
	// --- Spawning ---
	obstacleTimer++;
	if (obstacleTimer > enemySpawnInterval) {
		obstacleTimer = 0;
		// Randomly decide to spawn an Obstacle or an EnemyBike (e.g. 70% car, 30% enemyBike)
		if (Math.random() < 0.3) {
			var laneIdx = Math.floor(Math.random() * laneCount);
			var eb = new EnemyBike();
			eb.laneIdx = laneIdx; // Store lane index for reference
			eb.x = laneX[laneIdx];
			eb.y = -100;
			eb.lastWasIntersecting = false;
			eb.speedY = enemySpeed; // Set current enemy speed
			game.addChild(eb);
			enemyBikes.push(eb);
		} else {
			var obs = new Obstacle();
			// Place obstacle in a random lane
			var laneIdx = Math.floor(Math.random() * laneCount);
			obs.x = laneX[laneIdx];
			obs.y = -100;
			obs.lastWasIntersecting = false;
			game.addChild(obs);
			obstacles.push(obs);
		}
	}
	powerupTimer++;
	if (powerupTimer > 120) {
		powerupTimer = 0;
		var pu = new PowerUp();
		// Place powerup in a random lane
		var laneIdx = Math.floor(Math.random() * laneCount);
		pu.x = laneX[laneIdx];
		pu.y = -100;
		pu.lastWasIntersecting = false;
		game.addChild(pu);
		powerups.push(pu);
	}
	// --- Distance/score ---
	distance += player.speedY;
	if (distance % 1000 < player.speedY) {
		score += 1;
		scoreTxt.setText(score);
	}
	// Win condition: reach distance
	if (distance > 20000) {
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -426,9 +426,14 @@
 		// Check collision with enemyBikes
 		var hit = false;
 		for (var j = enemyBikes.length - 1; j >= 0; j--) {
 			var eb = enemyBikes[j];
-			if (proj.intersects(eb)) {
+			// Calculate distance between centers
+			var dx = proj.x - eb.x;
+			var dy = proj.y - eb.y;
+			var dist = Math.sqrt(dx * dx + dy * dy);
+			// Use a 10px collision radius for punchProjectile
+			if (dist <= 10) {
 				// Destroy both projectile and enemy
 				eb.destroy();
 				enemyBikes.splice(j, 1);
 				proj.destroy();