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

/**** 
* Classes
****/ 
var ChickenJockey = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach chicken asset
	var chickenGraphics = self.attachAsset('chicken', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Physics properties
	self.vx = 0;
	self.vy = 0;
	self.gravity = 0.5;
	self.bounceDecay = 0.7; // Reduced bounce decay for more sustained bounces
	self.friction = 0.998; // Increased horizontal friction for less horizontal drift
	self.launched = false;
	self.bounceCount = 0;
	self.maxBounces = 5; // Allow 5 bounces per swipe
	// Rotation properties
	self.rotationSpeed = 0;
	self.launch = function (power, angle) {
		// Convert angle to radians
		var radians = angle * Math.PI / 180;
		// Set initial velocity based on power and angle
		self.vx = Math.cos(radians) * power;
		self.vy = Math.sin(radians) * power;
		// Set rotation speed based on velocity
		self.rotationSpeed = power / 50;
		self.launched = true;
		self.bounceCount = 0;
		// Play launch sound
		LK.getSound('launch').play();
	};
	self.reset = function () {
		self.vx = 0;
		self.vy = 0;
		self.rotation = 0;
		self.rotationSpeed = 0;
		self.launched = false;
		self.bounceCount = 0;
		self.maxBounces = 60; // Set the max bounces here too
	};
	self.update = function () {
		// Trace path for chicken
		if (!self.path) {
			self.path = [];
		}
		self.path.push({
			x: self.x,
			y: self.y
		});
		if (!self.launched) {
			return;
		}
		// Apply physics
		self.vy += self.gravity;
		self.x += self.vx;
		self.y += self.vy;
		self.vx *= self.friction;
		// Apply rotation
		self.rotation += self.rotationSpeed;
		// Check if stopped
		if (Math.abs(self.vx) < 0.5 && Math.abs(self.vy) < 0.5 && self.bounceCount > 0) {
			self.launched = false;
			// Notify game that chicken jockey has stopped
			if (typeof game.onChickenJockeyStop === 'function') {
				game.onChickenJockeyStop();
			}
		}
		// Check if max bounces reached
		if (self.bounceCount >= self.maxBounces) {
			self.launched = false;
			// Notify game that max bounces reached
			if (typeof game.onMaxBouncesReached === 'function') {
				game.onMaxBouncesReached();
			}
		}
	};
	return self;
});
var Popcorn = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach popcorn asset
	var popcornGraphics = self.attachAsset('popcorn', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add slight animation
	self.animationOffset = Math.random() * Math.PI * 2;
	self.animationSpeed = 0.03 + Math.random() * 0.02;
	self.baseY = 0;
	self.collect = function () {
		// Play collect sound
		LK.getSound('collect').play();
		// Flash effect
		LK.effects.flashObject(self, 0xFFFFFF, 200);
		// Animate collection (flying up)
		tween(self, {
			y: self.y - 100,
			alpha: 0
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Remove from parent
				if (self.parent) {
					self.parent.removeChild(self);
				}
			}
		});
	};
	self.update = function () {
		// Hover animation
		if (self.baseY === 0) {
			self.baseY = self.y;
		}
		self.y = self.baseY + Math.sin(LK.ticks * self.animationSpeed + self.animationOffset) * 5;
	};
	return self;
});
var Rope = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach rope asset
	var ropeGraphics = self.attachAsset('rope', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Rope properties
	self.tension = 0.5; // Reduced tension for less chaotic bounces
	self.bounce = function (chickenJockey) {
		// Calculate new velocity based on collision angle and rope tension
		var normalAngle = Math.atan2(chickenJockey.y - self.y, chickenJockey.x - self.x); // Angle from rope to chicken
		// Calculate new velocity based on angle and tension
		var speed = Math.sqrt(chickenJockey.vx * chickenJockey.vx + chickenJockey.vy * chickenJockey.vy);
		var bounceAngle = 2 * normalAngle - Math.atan2(chickenJockey.vy, chickenJockey.vx); // Angle of reflection
		var bounceForce = speed * self.tension;
		chickenJockey.vx = Math.cos(bounceAngle) * bounceForce * chickenJockey.bounceDecay;
		chickenJockey.vy = Math.sin(bounceAngle) * bounceForce * chickenJockey.bounceDecay;
		// Increment bounce count
		chickenJockey.bounceCount++;
		// Play bounce sound
		LK.getSound('bounce').play();
		// Flash rope to indicate bounce
		LK.effects.flashObject(self, 0xFFFFFF, 200);
	};
	self.intersectsWithPoint = function (x, y) {
		var halfWidth = ropeGraphics.width / 2;
		var halfHeight = ropeGraphics.height / 2;
		// Check if point is within the rope's bounding box
		return x >= self.x - halfWidth && x <= self.x + halfWidth && y >= self.y - halfHeight && y <= self.y + halfHeight;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var gameState = "ready"; // ready, aiming, launched, gameOver
var score = 0;
var launches = 0;
var maxLaunches = 5;
var popcorns = [];
var ropes = [];
// Create wrestling arena
var arena = game.addChild(LK.getAsset('arena', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 / 2,
	y: 2732 / 2
}));
// Create chicken jockey
var chickenJockey = game.addChild(new ChickenJockey());
// Game boundaries
var bounds = {
	left: arena.x - arena.width / 2,
	right: arena.x + arena.width / 2,
	top: arena.y - arena.height / 2,
	bottom: arena.y + arena.height / 2
};
// Create GUI elements
var scoreText = new Text2("Score: 0", {
	size: 70,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
var launchesText = new Text2("Launches: 0/" + maxLaunches, {
	size: 50,
	fill: 0xFFFFFF
});
launchesText.anchor.set(0, 0);
launchesText.x = 120; // Avoid top-left corner
launchesText.y = 20;
LK.gui.topLeft.addChild(launchesText);
var instructionText = new Text2("Drag to aim and launch the chicken!", {
	size: 40,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 100;
LK.gui.top.addChild(instructionText);
// Initialize game
function initGame() {
	// Reset variables
	score = 0;
	launches = 0;
	maxLaunches = 15;
	gameState = "ready";
	// Update UI
	scoreText.setText("Score: " + score);
	launchesText.setText("Launches: " + launches + "/" + maxLaunches);
	instructionText.setText("Swipe to launch the chicken! Reach 5000 to win!");
	// Reset chicken jockey
	resetChickenJockey();
	// Clear existing popcorn and ropes
	clearPopcornsAndRopes();
	// Create ropes around the arena
	createRopes();
	// Create popcorn scattered around the arena
	createPopcorn(25);
	// Play background music
	LK.playMusic('gameMusic');
}
function resetChickenJockey() {
	chickenJockey.reset();
	// Position chicken in the center of the arena
	chickenJockey.x = arena.x;
	chickenJockey.y = arena.y;
}
function clearPopcornsAndRopes() {
	// Remove all popcorn
	for (var i = 0; i < popcorns.length; i++) {
		if (popcorns[i].parent) {
			popcorns[i].parent.removeChild(popcorns[i]);
		}
	}
	popcorns = [];
	// Remove all ropes
	for (var i = 0; i < ropes.length; i++) {
		if (ropes[i].parent) {
			ropes[i].parent.removeChild(ropes[i]);
		}
	}
	ropes = [];
}
function createRopes() {
	// Create top rope
	var topRope = new Rope();
	topRope.x = arena.x;
	topRope.y = bounds.top + 100;
	game.addChild(topRope);
	ropes.push(topRope);
	// Create right rope
	var rightRope = new Rope();
	rightRope.x = bounds.right - 100;
	rightRope.y = arena.y;
	rightRope.rotation = Math.PI / 2; // Rotate 90 degrees
	game.addChild(rightRope);
	ropes.push(rightRope);
	// Create bottom rope
	var bottomRope = new Rope();
	bottomRope.x = arena.x;
	bottomRope.y = bounds.bottom - 100;
	game.addChild(bottomRope);
	ropes.push(bottomRope);
	// Create left rope
	var leftRope = new Rope();
	leftRope.x = bounds.left + 100;
	leftRope.y = arena.y;
	leftRope.rotation = Math.PI / 2; // Rotate 90 degrees
	game.addChild(leftRope);
	ropes.push(leftRope);
}
function createPopcorn(count) {
	for (var i = 0; i < count; i++) {
		var popcorn = new Popcorn();
		// Random position within arena bounds
		popcorn.x = bounds.left + 100 + Math.random() * (arena.width - 200);
		popcorn.y = bounds.top + 100 + Math.random() * (arena.height - 200);
		// Add to game
		game.addChild(popcorn);
		popcorns.push(popcorn);
	}
}
// Game events
game.onChickenJockeyStop = function () {
	gameState = "ready";
	// Check if we need to add more popcorn
	if (popcorns.length < 10) {
		createPopcorn(10);
	}
	// Check if out of launches
	if (launches >= maxLaunches) {
		// Check if out of launches
		if (launches >= maxLaunches) {
			// Game over
			// Check for win condition
			if (score >= 5000) {
				instructionText.setText("You Win! Final Score: " + score);
				gameState = "gameOver";
				// Show win after a short delay
				LK.setTimeout(function () {
					LK.showYouWin();
				}, 2000);
			} else {
				// Game over
				instructionText.setText("Game Over! Final Score: " + score);
				gameState = "gameOver";
				// Show game over after a short delay
				LK.setTimeout(function () {
					LK.showGameOver();
				}, 2000);
			}
		}
	} else {
		// Reset for next launch
		resetChickenJockey();
		instructionText.setText("Drag to aim and launch the chicken!");
	}
};
game.onMaxBouncesReached = function () {
	// Same as onChickenJockeyStop for now
	game.onChickenJockeyStop();
};
// Input handling
var dragStartX = 0;
var dragStartY = 0;
var dragEndX = 0;
var dragEndY = 0;
game.down = function (x, y, obj) {
	if (gameState === "ready") {
		gameState = "aiming";
		dragStartX = x;
		dragStartY = y;
		instructionText.setText("Swipe to launch the chicken!");
	}
};
game.move = function (x, y, obj) {
	if (gameState === "aiming") {}
};
game.up = function (x, y, obj) {
	if (gameState === "aiming") {
		// Calculate swipe distance and direction
		// Record drag end position
		dragEndX = x;
		dragEndY = y;
		// Calculate swipe distance and direction
		var dx = dragEndX - dragStartX;
		var dy = dragEndY - dragStartY;
		var distance = Math.sqrt(dx * dx + dy * dy);
		// Only launch if there was a significant swipe (prevents accidental taps)
		if (distance > 20) {
			// Launch the chicken with fixed parameters or calculate based on swipe directly
			// Calculate power based on swipe distance
			var power = Math.min(distance, 300) * 0.3; // Increased multiplier for more sensitivity
			// Calculate angle based on swipe direction (from drag start to drag end)
			var angle = Math.atan2(dy, dx) * 180 / Math.PI;
			chickenJockey.launch(power, angle);
			// Update game state
			gameState = "launched";
			launches++;
			launchesText.setText("Launches: " + launches + "/" + maxLaunches);
			instructionText.setText("Watch the chicken bounce!");
		} else {
			// Cancel the launch if it was just a tap
			gameState = "ready";
		}
	}
};
// Main game loop
game.update = function () {
	// Update all game objects
	if (gameState === "launched") {
		chickenJockey.update();
		// Draw path
		if (chickenJockey.path && chickenJockey.path.length > 1) {
			for (var i = 0; i < chickenJockey.path.length - 1; i++) {
				var start = chickenJockey.path[i];
				var end = chickenJockey.path[i + 1];
				var line = new Container();
				var lineGraphics = new Graphics();
				lineGraphics.lineStyle(2, 0xFFFFFF, 1);
				lineGraphics.moveTo(start.x, start.y);
				lineGraphics.lineTo(end.x, end.y);
				line.addChild(lineGraphics);
				game.addChild(line);
			}
		}
		// Check for collisions with arena boundaries
		if (chickenJockey.x < bounds.left) {
			chickenJockey.x = bounds.left;
			chickenJockey.vx = -chickenJockey.vx * chickenJockey.bounceDecay; // Apply decay on horizontal bounce
			chickenJockey.bounceCount++;
			LK.getSound('bounce').play();
		} else if (chickenJockey.x > bounds.right) {
			chickenJockey.x = bounds.right;
			chickenJockey.vx = -chickenJockey.vx * chickenJockey.bounceDecay; // Apply decay on horizontal bounce
			chickenJockey.bounceCount++;
			LK.getSound('bounce').play();
		}
		if (chickenJockey.y < bounds.top) {
			chickenJockey.y = bounds.top;
			chickenJockey.vy = -chickenJockey.vy * chickenJockey.bounceDecay; // Apply decay on vertical bounce
			chickenJockey.bounceCount++;
			LK.getSound('bounce').play();
		} else if (chickenJockey.y > bounds.bottom) {
			chickenJockey.y = bounds.bottom;
			chickenJockey.vy = -chickenJockey.vy * chickenJockey.bounceDecay; // Apply decay on vertical bounce
			chickenJockey.bounceCount++;
			LK.getSound('bounce').play();
		}
		// Check for collisions with ropes
		for (var i = 0; i < ropes.length; i++) {
			if (chickenJockey.intersects(ropes[i])) {
				ropes[i].bounce(chickenJockey);
			}
		}
		// Check for collisions with popcorn
		for (var i = popcorns.length - 1; i >= 0; i--) {
			if (chickenJockey.intersects(popcorns[i])) {
				// Collect popcorn
				popcorns[i].collect();
				// Remove from array
				popcorns.splice(i, 1);
				// Increase score
				score += 10;
				scoreText.setText("Score: " + score);
				// Save score to LK
				LK.setScore(score);
				// Reset launches when score reaches 1000
				if (score >= 1000) {
					launches = 0;
					launchesText.setText("Launches: " + launches + "/" + maxLaunches);
				}
			}
		}
	}
	// Update popcorn animations
	for (var i = 0; i < popcorns.length; i++) {
		popcorns[i].update();
	}
};
// Initialize the game
initGame();

===================================================================
--- original.js
+++ change.js
@@ -391,16 +391,14 @@
 		if (chickenJockey.path && chickenJockey.path.length > 1) {
 			for (var i = 0; i < chickenJockey.path.length - 1; i++) {
 				var start = chickenJockey.path[i];
 				var end = chickenJockey.path[i + 1];
-				var line = new LK.Line({
-					x1: start.x,
-					y1: start.y,
-					x2: end.x,
-					y2: end.y,
-					color: 0xFFFFFF,
-					width: 2
-				});
+				var line = new Container();
+				var lineGraphics = new Graphics();
+				lineGraphics.lineStyle(2, 0xFFFFFF, 1);
+				lineGraphics.moveTo(start.x, start.y);
+				lineGraphics.lineTo(end.x, end.y);
+				line.addChild(lineGraphics);
 				game.addChild(line);
 			}
 		}
 		// Check for collisions with arena boundaries