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

/**** 
* Classes
****/ 
// Ball class: bounces, shrinks on hit, rebounds off everything
var Ball = Container.expand(function () {
	var self = Container.call(this);
	// Ball type: 'red' or 'green'
	self.type = 'red';
	self.radius = 90; // initial radius
	self.minRadius = 40; // minimum radius after shrinking
	self.shrinkAmount = 18; // how much to shrink per hit
	// Attach asset
	self.asset = null;
	self.setType = function (type) {
		self.type = type;
		if (self.asset) self.removeChild(self.asset);
		var assetId = type === 'red' ? 'ballRed' : 'ballGreen';
		self.asset = self.attachAsset(assetId, {
			anchorX: 0.5,
			anchorY: 0.5,
			width: self.radius * 2,
			height: self.radius * 2
		});
	};
	// Set initial type
	self.setType(self.type);
	// Physics
	self.vx = 0;
	self.vy = 0;
	self.bounce = 0.98; // energy loss on bounce
	self.gravity = 1.2;
	// For collision detection
	self.getRadius = function () {
		return self.radius;
	};
	// Shrink ball
	self.shrink = function () {
		if (self.radius > self.minRadius) {
			self.radius -= self.shrinkAmount;
			if (self.radius < self.minRadius) self.radius = self.minRadius;
			// Animate shrink
			tween(self.asset, {
				width: self.radius * 2,
				height: self.radius * 2
			}, {
				duration: 180,
				easing: tween.easeOut
			});
		}
	};
	// Update per frame
	self.update = function () {
		// Move
		self.x += self.vx;
		self.y += self.vy;
		// Gravity
		self.vy += self.gravity;
		// Bounce off walls
		if (self.x - self.radius < 0) {
			self.x = self.radius;
			self.vx = -self.vx * self.bounce;
		}
		if (self.x + self.radius > 2048) {
			self.x = 2048 - self.radius;
			self.vx = -self.vx * self.bounce;
		}
		// Bounce off floor/ceiling
		if (self.y - self.radius < 0) {
			self.y = self.radius;
			self.vy = -self.vy * self.bounce;
		}
		if (self.y + self.radius > 2732) {
			self.y = 2732 - self.radius;
			self.vy = -self.vy * self.bounce;
		}
		// --- Prevent balls from ever crossing the aimLine ---
		// Only enforce if aimLine exists and is visible
		if (typeof aimLine !== "undefined" && aimLine && aimLine.visible) {
			// Calculate the normal vector of the aimLine
			var dx = Math.cos(aimLine.rotation);
			var dy = Math.sin(aimLine.rotation);
			// Vector from aimLine start to ball center
			var px = self.x - aimLine.x;
			var py = self.y - aimLine.y;
			// Project vector onto aimLine direction to get closest point on the line
			var proj = px * dx + py * dy;
			// Clamp projection to the aimLine segment
			var len = aimLine.width;
			if (proj < 0) proj = 0;
			if (proj > len) proj = len;
			// Closest point on the aimLine
			var closestX = aimLine.x + dx * proj;
			var closestY = aimLine.y + dy * proj;
			// Distance from ball center to closest point
			var distX = self.x - closestX;
			var distY = self.y - closestY;
			var dist = Math.sqrt(distX * distX + distY * distY);
			if (dist < self.radius) {
				// Ball is overlapping the aimLine, push it out and reflect velocity
				var overlap = self.radius - dist;
				// Defensive: avoid division by zero
				if (dist === 0) {
					distX = 1;
					distY = 0;
					dist = 1;
				}
				var nx = distX / dist;
				var ny = distY / dist;
				self.x += nx * overlap;
				self.y += ny * overlap;
				// Reflect velocity
				var dot = self.vx * nx + self.vy * ny;
				self.vx -= 2 * dot * nx;
				self.vy -= 2 * dot * ny;
				// Dampen to simulate energy loss
				self.vx *= self.bounce;
				self.vy *= self.bounce;
			}
		}
	};
	return self;
});
// Chain class: fires in direction, stops at collision or edge
var Chain = Container.expand(function () {
	var self = Container.call(this);
	// Chain is a series of segments
	self.segments = [];
	self.segmentLength = 64;
	self.maxSegments = 32;
	self.dirX = 0;
	self.dirY = 0;
	self.originX = 0;
	self.originY = 0;
	self.active = true;
	// For collision
	self.getTip = function () {
		if (self.segments.length === 0) return {
			x: self.originX,
			y: self.originY
		};
		var last = self.segments[self.segments.length - 1];
		return {
			x: last.x,
			y: last.y
		};
	};
	// Initialize chain
	self.fire = function (originX, originY, dirX, dirY) {
		self.originX = originX;
		self.originY = originY;
		self.dirX = dirX;
		self.dirY = dirY;
		self.segments = [];
		self.active = true;
		// Remove old children
		while (self.children.length) self.removeChild(self.children[0]);
		// Add first segment
		var seg = LK.getAsset('chain', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		seg.x = originX;
		seg.y = originY;
		self.addChild(seg);
		self.segments.push(seg);
	};
	// Update per frame
	self.update = function () {
		if (!self.active) return;
		// Defensive: Only proceed if there is at least one segment
		if (self.segments.length === 0) return;
		// Add new segment in direction
		var last = self.segments[self.segments.length - 1];
		var nx = last.x + self.dirX * self.segmentLength;
		var ny = last.y + self.dirY * self.segmentLength;
		// Stop if out of bounds
		if (nx < 0 || nx > 2048 || ny < 0 || ny > 2732) {
			self.active = false;
			return;
		}
		// Add new segment
		var seg = LK.getAsset('chain', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		seg.x = nx;
		seg.y = ny;
		self.addChild(seg);
		self.segments.push(seg);
		// Limit length
		if (self.segments.length > self.maxSegments) {
			self.active = false;
		}
	};
	// Remove all segments
	self.clear = function () {
		while (self.children.length) self.removeChild(self.children[0]);
		self.segments = [];
		self.active = false;
	};
	return self;
});
// Robot class: moves left/right, fires chain
var Robot = Container.expand(function () {
	var self = Container.call(this);
	self.asset = self.attachAsset('robot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = self.asset.width;
	self.height = self.asset.height;
	// For movement
	self.speed = 0;
	self.maxSpeed = 32;
	self.targetX = 1024;
	// For collision
	// Update per frame
	self.update = function () {
		// Move towards targetX
		var dx = self.targetX - self.x;
		if (Math.abs(dx) > 8) {
			self.speed = Math.max(-self.maxSpeed, Math.min(self.maxSpeed, dx * 0.25));
			self.x += self.speed;
		} else {
			self.x = self.targetX;
			self.speed = 0;
		}
		// Clamp to screen
		if (self.x < self.width / 2) self.x = self.width / 2;
		if (self.x > 2048 - self.width / 2) self.x = 2048 - self.width / 2;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Game variables ---
// Robot: blue box
// Ball: red
// Ball: green
// Chain: yellow box (thin)
// Aiming line: white box (thin, will be scaled)
var robot = new Robot();
var balls = [];
var chain = new Chain();
var aimLine = null;
var isAiming = false;
var aimStart = {
	x: 0,
	y: 0
};
var aimEnd = {
	x: 0,
	y: 0
};
var canFire = true;
var fireCooldown = 18; // frames between shots
var fireTimer = 0;
var score = 0;
var scoreTxt = null;
// --- Add robot ---
robot.x = 1024;
robot.y = 2732 - 120;
game.addChild(robot);
// --- Add balls ---
var ball1 = new Ball();
ball1.setType('red');
ball1.radius = 160; // enlarged radius
ball1.asset.width = ball1.radius * 2;
ball1.asset.height = ball1.radius * 2;
ball1.x = 600;
ball1.y = 800;
// Set initial velocity to make the ball start moving
ball1.vx = 18;
ball1.vy = -22;
balls.push(ball1);
game.addChild(ball1);
var ball2 = new Ball();
ball2.setType('green');
ball2.radius = 160; // enlarged radius
ball2.asset.width = ball2.radius * 2;
ball2.asset.height = ball2.radius * 2;
ball2.x = 1448;
ball2.y = 900;
// Set initial velocity to make the ball start moving
ball2.vx = -16;
ball2.vy = -18;
balls.push(ball2);
game.addChild(ball2);
// --- Add chain (hidden at start) ---
game.addChild(chain);
// --- Score text ---
scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Aiming line ---
function updateAimLine() {
	if (!aimLine) {
		aimLine = LK.getAsset('aimLine', {
			anchorX: 0,
			anchorY: 0.5
		});
		aimLine.alpha = 0.5;
		game.addChild(aimLine);
	}
	var dx = aimEnd.x - aimStart.x;
	var dy = aimEnd.y - aimStart.y;
	var len = Math.sqrt(dx * dx + dy * dy);
	if (len < 80) len = 80; // minimum length
	aimLine.x = aimStart.x;
	aimLine.y = aimStart.y;
	aimLine.width = len;
	aimLine.height = 16;
	aimLine.rotation = Math.atan2(dy, dx);
	aimLine.visible = true;
}
function hideAimLine() {
	if (aimLine) aimLine.visible = false;
}
// --- Input handling ---
game.down = function (x, y, obj) {
	// Only allow aiming if touch is in lower 1/3 of screen
	if (y > 2732 - 600) {
		isAiming = true;
		aimStart.x = robot.x;
		aimStart.y = robot.y - robot.height / 2;
		aimEnd.x = x;
		aimEnd.y = y;
		updateAimLine();
	}
};
game.move = function (x, y, obj) {
	if (isAiming) {
		// Update aim direction
		aimEnd.x = x;
		aimEnd.y = y;
		updateAimLine();
	} else {
		// Move robot left/right only
		robot.targetX = x;
	}
};
game.up = function (x, y, obj) {
	if (isAiming && canFire) {
		// Fire chain in direction
		var dx = aimEnd.x - aimStart.x;
		var dy = aimEnd.y - aimStart.y;
		var len = Math.sqrt(dx * dx + dy * dy);
		if (len > 80) {
			var dirX = dx / len;
			var dirY = dy / len;
			chain.clear();
			chain.fire(aimStart.x, aimStart.y, dirX, dirY);
			canFire = false;
			fireTimer = fireCooldown;
		}
	}
	isAiming = false;
	hideAimLine();
};
// --- Ball-ball collision ---
function ballsCollide(b1, b2) {
	var dx = b1.x - b2.x;
	var dy = b1.y - b2.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	return dist < b1.radius + b2.radius;
}
function resolveBallCollision(b1, b2) {
	var dx = b1.x - b2.x;
	var dy = b1.y - b2.y;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist === 0) return;
	var overlap = b1.radius + b2.radius - dist;
	if (overlap > 0) {
		// Push balls apart
		var nx = dx / dist;
		var ny = dy / dist;
		b1.x += nx * (overlap / 2);
		b1.y += ny * (overlap / 2);
		b2.x -= nx * (overlap / 2);
		b2.y -= ny * (overlap / 2);
		// Exchange velocities (elastic)
		var tx = nx;
		var ty = ny;
		var v1 = b1.vx * tx + b1.vy * ty;
		var v2 = b2.vx * tx + b2.vy * ty;
		var m1 = b1.radius;
		var m2 = b2.radius;
		var newV1 = (v1 * (m1 - m2) + 2 * m2 * v2) / (m1 + m2);
		var newV2 = (v2 * (m2 - m1) + 2 * m1 * v1) / (m1 + m2);
		b1.vx += (newV1 - v1) * tx;
		b1.vy += (newV1 - v1) * ty;
		b2.vx += (newV2 - v2) * tx;
		b2.vy += (newV2 - v2) * ty;
	}
}
// --- Ball-robot collision ---
function ballHitsRobot(ball, robot) {
	var bounds = robot.getBounds();
	// Closest point on robot to ball center
	var cx = Math.max(bounds.left, Math.min(ball.x, bounds.right));
	var cy = Math.max(bounds.top, Math.min(ball.y, bounds.bottom));
	var dx = ball.x - cx;
	var dy = ball.y - cy;
	var dist = Math.sqrt(dx * dx + dy * dy);
	return dist < ball.radius;
}
function resolveBallRobotCollision(ball, robot) {
	var bounds = robot.getBounds();
	var cx = Math.max(bounds.left, Math.min(ball.x, bounds.right));
	var cy = Math.max(bounds.top, Math.min(ball.y, bounds.bottom));
	var dx = ball.x - cx;
	var dy = ball.y - cy;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist === 0) return;
	var overlap = ball.radius - dist;
	if (overlap > 0) {
		// Push ball out
		var nx = dx / dist;
		var ny = dy / dist;
		ball.x += nx * overlap;
		ball.y += ny * overlap;
		// Reflect velocity
		var dot = ball.vx * nx + ball.vy * ny;
		ball.vx -= 2 * dot * nx;
		ball.vy -= 2 * dot * ny;
		ball.vx *= 0.9;
		ball.vy *= 0.9;
	}
}
// --- Chain-ball collision ---
function chainHitsBall(chain, ball) {
	// Check each segment
	for (var i = 0; i < chain.segments.length; ++i) {
		var seg = chain.segments[i];
		var dx = seg.x - ball.x;
		var dy = seg.y - ball.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < ball.radius) {
			return true;
		}
	}
	return false;
}
// --- Chain stops at first collision with ball or wall ---
function updateChainCollisions() {
	if (!chain.active) return;
	for (var i = 0; i < balls.length; ++i) {
		if (chainHitsBall(chain, balls[i])) {
			var hitBall = balls[i];
			// --- Chain acts as a barrier: bounce ball off chain, do not allow pass-through ---
			// Find the closest segment that collides
			var closestSeg = null;
			var minDist = Infinity;
			for (var j = 0; j < chain.segments.length; ++j) {
				var seg = chain.segments[j];
				var dx = seg.x - hitBall.x;
				var dy = seg.y - hitBall.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist < hitBall.radius && dist < minDist) {
					minDist = dist;
					closestSeg = seg;
				}
			}
			if (closestSeg) {
				// Push ball out of the chain segment and reflect velocity (barrier bounce)
				var dx = hitBall.x - closestSeg.x;
				var dy = hitBall.y - closestSeg.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist === 0) {
					// Avoid division by zero, nudge
					dx = 1;
					dy = 0;
					dist = 1;
				}
				var overlap = hitBall.radius - dist;
				if (overlap > 0) {
					var nx = dx / dist;
					var ny = dy / dist;
					// Move ball out of the chain
					hitBall.x += nx * overlap;
					hitBall.y += ny * overlap;
					// --- Ball bounce off chain, just like ball-ball collision ---
					// Project velocity onto normal
					var dot = hitBall.vx * nx + hitBall.vy * ny;
					// Reflect velocity (elastic bounce)
					hitBall.vx -= 2 * dot * nx;
					hitBall.vy -= 2 * dot * ny;
					// Dampen to simulate energy loss (same as ball-ball)
					hitBall.vx *= hitBall.bounce;
					hitBall.vy *= hitBall.bounce;
				}
				// Do NOT deactivate the chain here; allow it to persist as a barrier (chain acts as a wall)
			}
			// --- Shrink and split logic ---
			if (hitBall.radius > hitBall.minRadius + hitBall.shrinkAmount) {
				// Shrink first
				hitBall.shrink();
				// Split into two balls
				var newRadius = Math.max(hitBall.radius / 1.5, hitBall.minRadius);
				for (var s = 0; s < 2; ++s) {
					var newBall = new Ball();
					newBall.setType(hitBall.type);
					newBall.radius = newRadius;
					newBall.asset.width = newRadius * 2;
					newBall.asset.height = newRadius * 2;
					// Offset new balls slightly to avoid overlap
					var angle = Math.PI / 4 + s * (Math.PI / 2);
					newBall.x = hitBall.x + Math.cos(angle) * newRadius;
					newBall.y = hitBall.y + Math.sin(angle) * newRadius;
					// Give them some velocity away from each other
					newBall.vx = hitBall.vx + (s === 0 ? -12 : 12);
					newBall.vy = hitBall.vy - 10;
					balls.push(newBall);
					game.addChild(newBall);
				}
				// Remove the original ball
				game.removeChild(hitBall);
				balls.splice(i, 1);
				i--; // adjust index after removal
			} else {
				// If too small, just shrink
				hitBall.shrink();
			}
			score += 1;
			scoreTxt.setText(score);
			// Flash ball
			LK.effects.flashObject(hitBall, 0xffff00, 200);
			break;
		}
	}
}
// --- Game update loop ---
game.update = function () {
	// Update robot
	robot.update();
	// Update balls
	for (var i = 0; i < balls.length; ++i) {
		balls[i].update();
		// --- Enforce chain as a barrier every frame, so balls never pass through ---
		if (chain.active) {
			// For each segment, check collision and bounce if needed
			for (var j = 0; j < chain.segments.length; ++j) {
				var seg = chain.segments[j];
				var dx = balls[i].x - seg.x;
				var dy = balls[i].y - seg.y;
				var dist = Math.sqrt(dx * dx + dy * dy);
				if (dist < balls[i].radius) {
					// Push ball out of the chain segment and reflect velocity (barrier bounce)
					var overlap = balls[i].radius - dist;
					if (dist === 0) {
						dx = 1;
						dy = 0;
						dist = 1;
					}
					var nx = dx / dist;
					var ny = dy / dist;
					balls[i].x += nx * overlap;
					balls[i].y += ny * overlap;
					// Project velocity onto normal
					var dot = balls[i].vx * nx + balls[i].vy * ny;
					// Reflect velocity (elastic bounce)
					balls[i].vx -= 2 * dot * nx;
					balls[i].vy -= 2 * dot * ny;
					// Dampen to simulate energy loss (same as ball-ball)
					balls[i].vx *= balls[i].bounce;
					balls[i].vy *= balls[i].bounce;
				}
			}
		}
	}
	// Ball-ball collision
	if (balls.length >= 2) {
		if (ballsCollide(balls[0], balls[1])) {
			resolveBallCollision(balls[0], balls[1]);
		}
	}
	// Ball-robot collision
	for (var i = 0; i < balls.length; ++i) {
		if (ballHitsRobot(balls[i], robot)) {
			resolveBallRobotCollision(balls[i], robot);
			// Game over
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
			return;
		}
	}
	// Update chain
	if (chain.active) {
		chain.update();
		updateChainCollisions();
	}
	// Fire cooldown
	if (!canFire) {
		fireTimer--;
		if (fireTimer <= 0) {
			canFire = true;
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -77,8 +77,52 @@
 		if (self.y + self.radius > 2732) {
 			self.y = 2732 - self.radius;
 			self.vy = -self.vy * self.bounce;
 		}
+		// --- Prevent balls from ever crossing the aimLine ---
+		// Only enforce if aimLine exists and is visible
+		if (typeof aimLine !== "undefined" && aimLine && aimLine.visible) {
+			// Calculate the normal vector of the aimLine
+			var dx = Math.cos(aimLine.rotation);
+			var dy = Math.sin(aimLine.rotation);
+			// Vector from aimLine start to ball center
+			var px = self.x - aimLine.x;
+			var py = self.y - aimLine.y;
+			// Project vector onto aimLine direction to get closest point on the line
+			var proj = px * dx + py * dy;
+			// Clamp projection to the aimLine segment
+			var len = aimLine.width;
+			if (proj < 0) proj = 0;
+			if (proj > len) proj = len;
+			// Closest point on the aimLine
+			var closestX = aimLine.x + dx * proj;
+			var closestY = aimLine.y + dy * proj;
+			// Distance from ball center to closest point
+			var distX = self.x - closestX;
+			var distY = self.y - closestY;
+			var dist = Math.sqrt(distX * distX + distY * distY);
+			if (dist < self.radius) {
+				// Ball is overlapping the aimLine, push it out and reflect velocity
+				var overlap = self.radius - dist;
+				// Defensive: avoid division by zero
+				if (dist === 0) {
+					distX = 1;
+					distY = 0;
+					dist = 1;
+				}
+				var nx = distX / dist;
+				var ny = distY / dist;
+				self.x += nx * overlap;
+				self.y += ny * overlap;
+				// Reflect velocity
+				var dot = self.vx * nx + self.vy * ny;
+				self.vx -= 2 * dot * nx;
+				self.vy -= 2 * dot * ny;
+				// Dampen to simulate energy loss
+				self.vx *= self.bounce;
+				self.vy *= self.bounce;
+			}
+		}
 	};
 	return self;
 });
 // Chain class: fires in direction, stops at collision or edge