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

/**** 
* Classes
****/ 
// Penguin class
var Penguin = Container.expand(function () {
	var self = Container.call(this);
	// Penguin id: 1 or 2
	self.penguinId = 1;
	// Attach penguin asset
	var penguinGfx = self.attachAsset(self.penguinId === 1 ? 'penguin1' : 'penguin2', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: -1 // Flip horizontally to show penguin's back
	});
	// Used for drag
	self.isDragging = false;
	// Used for aiming
	self.aimLine = null;
	// Used for touch start position
	self.startDragX = 0;
	self.startDragY = 0;
	// Used for aiming vector
	self.aimVX = 0;
	self.aimVY = 0;
	// Used for aiming bar
	self.aimBar = null;
	// Used for cooldown
	self.canThrow = true;
	// Used for tracking last position for drag
	self.lastDragX = 0;
	self.lastDragY = 0;
	// Used for showing aim
	self.showAim = function (x, y) {
		// Not implemented: no line drawing in LK, so skip
	};
	// Used for hiding aim
	self.hideAim = function () {
		// Not implemented: no line drawing in LK, so skip
	};
	return self;
});
// Snowball class
var Snowball = Container.expand(function () {
	var self = Container.call(this);
	// Attach snowball asset
	var snowballGfx = self.attachAsset('snowball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Who fired this snowball? 1 or 2
	self.owner = 1;
	// Velocity
	self.vx = 0;
	self.vy = 0;
	// Used for bounce cooldown
	self.bounced = false;
	// Update method
	self.update = function () {
		self.x += self.vx;
		self.y += self.vy;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87ceeb // Light blue sky
});

/**** 
* Game Code
****/ 
// Game constants
// Penguin (player 1)
// Penguin (player 2)
// Snowball
// Castle wall (center)
var GAME_WIDTH = 2048;
var GAME_HEIGHT = 2732;
// Center wall
var wall = LK.getAsset('castleWall', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: GAME_WIDTH / 2,
	y: GAME_HEIGHT / 2,
	rotation: Math.PI / 2 // Rotate 90 degrees to make it horizontal
});
game.addChild(wall);
// Penguins
var penguin1 = new Penguin();
penguin1.penguinId = 1;
penguin1.x = GAME_WIDTH / 2;
penguin1.y = GAME_HEIGHT - 350;
game.addChild(penguin1);
var penguin2 = new Penguin();
penguin2.penguinId = 2;
penguin2.x = GAME_WIDTH / 2;
penguin2.y = 350;
game.addChild(penguin2);
// Set correct asset for penguin2
penguin2.removeChildAt(0);
penguin2.attachAsset('penguin2', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: -1 // Flip horizontally to show penguin's back
});
// Score
var score1 = 0;
var score2 = 0;
// Score text
var scoreTxt = new Text2('0 : 0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Snowballs array
var snowballs = [];
// Drag/aim state
var dragPenguin = null;
var dragStartX = 0;
var dragStartY = 0;
var dragCurrentX = 0;
var dragCurrentY = 0;
// Power bar state
var powerBar = null;
var powerBarBg = null;
var powerBarValue = 0;
var powerBarInterval = null;
var powerBarMax = 1.0; // max fill
var powerBarMin = 0.2; // min fill
var powerBarSpeed = 0.012; // fill per tick
// Only allow one penguin to be dragged at a time
function isTouchOnPenguin(x, y, penguin) {
	// Simple bounding box check
	var px = penguin.x;
	var py = penguin.y;
	var w = penguin.width || 140;
	var h = penguin.height || 180;
	return x > px - w / 2 && x < px + w / 2 && y > py - h / 2 && y < py + h / 2;
}
// Only allow dragging own penguin (player 1: bottom, player 2: top)
game.down = function (x, y, obj) {
	// Don't allow drag in top 100x100 (menu)
	if (x < 100 && y < 100) return;
	// Only allow drag on penguin1 (player) for now
	if (isTouchOnPenguin(x, y, penguin1)) {
		dragPenguin = penguin1;
		dragStartX = x;
		dragStartY = y;
		dragCurrentX = x;
		dragCurrentY = y;
		penguin1.isDragging = true;
		// Show power bar next to penguin1
		if (powerBarBg) {
			powerBarBg.destroy();
			powerBarBg = null;
		}
		if (powerBar) {
			powerBar.destroy();
			powerBar = null;
		}
		// Background bar
		powerBarBg = LK.getAsset('snowball', {
			anchorX: 0,
			anchorY: 0.5,
			width: 40,
			height: 180,
			color: 0xcccccc
		});
		powerBarBg.x = penguin1.x + 90;
		powerBarBg.y = penguin1.y;
		game.addChild(powerBarBg);
		// Foreground (fill) bar
		powerBar = LK.getAsset('snowball', {
			anchorX: 0,
			anchorY: 0.5,
			width: 36,
			height: 0,
			// will be set by fill
			color: 0x4fc3f7
		});
		powerBar.x = penguin1.x + 92;
		powerBar.y = penguin1.y + 90; // start at bottom
		game.addChild(powerBar);
		powerBarValue = powerBarMin;
		// Animate fill
		if (powerBarInterval) LK.clearInterval(powerBarInterval);
		powerBarInterval = LK.setInterval(function () {
			if (!dragPenguin) return;
			powerBarValue += powerBarSpeed;
			if (powerBarValue > powerBarMax) powerBarValue = powerBarMax;
			// Update bar height and position
			var maxHeight = 180;
			var fillHeight = Math.max(0, Math.floor(maxHeight * powerBarValue));
			powerBar.height = fillHeight;
			powerBar.y = penguin1.y + 90 - fillHeight;
		}, 16);
	}
	// For two player: allow penguin2 drag if touch is in top half
	else if (isTouchOnPenguin(x, y, penguin2)) {
		dragPenguin = penguin2;
		dragStartX = x;
		dragStartY = y;
		dragCurrentX = x;
		dragCurrentY = y;
		penguin2.isDragging = true;
		// Show power bar next to penguin2
		if (powerBarBg) {
			powerBarBg.destroy();
			powerBarBg = null;
		}
		if (powerBar) {
			powerBar.destroy();
			powerBar = null;
		}
		// Background bar
		powerBarBg = LK.getAsset('snowball', {
			anchorX: 0,
			anchorY: 0.5,
			width: 40,
			height: 180,
			color: 0xcccccc
		});
		powerBarBg.x = penguin2.x + 90;
		powerBarBg.y = penguin2.y;
		game.addChild(powerBarBg);
		// Foreground (fill) bar
		powerBar = LK.getAsset('snowball', {
			anchorX: 0,
			anchorY: 0.5,
			width: 36,
			height: 0,
			// will be set by fill
			color: 0x4fc3f7
		});
		powerBar.x = penguin2.x + 92;
		powerBar.y = penguin2.y + 90; // start at bottom
		game.addChild(powerBar);
		powerBarValue = powerBarMin;
		// Animate fill
		if (powerBarInterval) LK.clearInterval(powerBarInterval);
		powerBarInterval = LK.setInterval(function () {
			if (!dragPenguin) return;
			powerBarValue += powerBarSpeed;
			if (powerBarValue > powerBarMax) powerBarValue = powerBarMax;
			// Update bar height and position
			var maxHeight = 180;
			var fillHeight = Math.max(0, Math.floor(maxHeight * powerBarValue));
			powerBar.height = fillHeight;
			powerBar.y = penguin2.y + 90 - fillHeight;
		}, 16);
	}
};
game.move = function (x, y, obj) {
	if (!dragPenguin) return;
	// Clamp drag to own half
	if (dragPenguin === penguin1 && y < GAME_HEIGHT / 2 + 100) y = GAME_HEIGHT / 2 + 100;
	if (dragPenguin === penguin2 && y > GAME_HEIGHT / 2 - 100) y = GAME_HEIGHT / 2 - 100;
	// Clamp to game area
	var minX = 120,
		maxX = GAME_WIDTH - 120;
	var minY = 120,
		maxY = GAME_HEIGHT - 120;
	x = Math.max(minX, Math.min(maxX, x));
	y = Math.max(minY, Math.min(maxY, y));
	dragCurrentX = x;
	dragCurrentY = y;
	// Move penguin
	dragPenguin.x = x;
	dragPenguin.y = y;
	// --- Aiming bar logic ---
	var penguin = dragPenguin;
	if (penguin) {
		// Remove old aimBar if exists
		if (penguin.aimBar) {
			penguin.aimBar.destroy();
			penguin.aimBar = null;
		}
		// Only show aim bar if drag distance is enough
		var dx = dragCurrentX - dragStartX;
		var dy = dragCurrentY - dragStartY;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist > 20) {
			// Always aim toward the opposing penguin
			var target = penguin === penguin1 ? penguin2 : penguin1;
			var tx = target.x - penguin.x;
			var ty = target.y - penguin.y;
			var angle = Math.atan2(ty, tx);
			// Bar length
			var barLen = 220;
			// Create bar as a thin tall rectangle (use a box shape)
			var bar = LK.getAsset('snowball', {
				anchorX: 0.5,
				anchorY: 1,
				width: 18,
				height: barLen,
				color: 0x4fc3f7
			});
			// Place under penguin
			bar.x = penguin.x;
			bar.y = penguin.y + 90;
			// Rotate to aim direction
			bar.rotation = angle + Math.PI / 2;
			game.addChild(bar);
			penguin.aimBar = bar;
		}
	}
	// Move power bar if visible
	if (powerBarBg && dragPenguin) {
		powerBarBg.x = dragPenguin.x + 90;
		powerBarBg.y = dragPenguin.y;
	}
	if (powerBar && dragPenguin) {
		powerBar.x = dragPenguin.x + 92;
		// keep y at bottom, height is set by interval
	}
};
game.up = function (x, y, obj) {
	if (!dragPenguin) return;
	// Hide power bar
	if (powerBarBg) {
		powerBarBg.destroy();
		powerBarBg = null;
	}
	if (powerBar) {
		powerBar.destroy();
		powerBar = null;
	}
	if (powerBarInterval) {
		LK.clearInterval(powerBarInterval);
		powerBarInterval = null;
	}
	// Only allow throw if drag distance is enough and cooldown is over
	var dx = dragCurrentX - dragStartX;
	var dy = dragCurrentY - dragStartY;
	var dist = Math.sqrt(dx * dx + dy * dy);
	// Only allow throw if drag is a "flick" (distance > 80)
	if (dist > 80 && dragPenguin.canThrow) {
		// Always throw toward the opposing penguin, power only affects distance
		var basePower = powerBarValue || powerBarMin;
		var thrower = dragPenguin;
		var target = thrower === penguin1 ? penguin2 : penguin1;
		// Calculate direction vector from thrower to target
		var tx = target.x - thrower.x;
		var ty = target.y - thrower.y;
		var len = Math.sqrt(tx * tx + ty * ty);
		// Normalize direction
		var dirX = tx / len;
		var dirY = ty / len;
		// Set velocity magnitude based on power
		var minV = 18;
		var maxV = 55;
		var velocity = minV + (maxV - minV) * ((basePower - powerBarMin) / (powerBarMax - powerBarMin));
		// Clamp velocity
		if (velocity < minV) velocity = minV;
		if (velocity > maxV) velocity = maxV;
		// Final velocity
		var vx = dirX * velocity;
		var vy = dirY * velocity;
		// Create snowball
		var snowball = new Snowball();
		snowball.owner = dragPenguin === penguin1 ? 1 : 2;
		snowball.x = dragPenguin.x;
		snowball.y = dragPenguin.y + (snowball.owner === 1 ? -90 : 90);
		snowball.vx = vx;
		snowball.vy = vy;
		snowballs.push(snowball);
		game.addChild(snowball);
		// Cooldown: prevent spamming
		dragPenguin.canThrow = false;
		var cooldownPenguin = dragPenguin;
		LK.setTimeout(function () {
			if (cooldownPenguin) {
				cooldownPenguin.canThrow = true;
			}
		}, 600);
	}
	// Remove aim bar if exists
	if (dragPenguin && dragPenguin.aimBar) {
		dragPenguin.aimBar.destroy();
		dragPenguin.aimBar = null;
	}
	dragPenguin.isDragging = false;
	dragPenguin = null;
};
/**
* Helper: check collision between two containers (bounding box)
*/
function isIntersect(a, b) {
	var ax = a.x,
		ay = a.y,
		aw = a.width || 100,
		ah = a.height || 100;
	var bx = b.x,
		by = b.y,
		bw = b.width || 100,
		bh = b.height || 100;
	return ax - aw / 2 < bx + bw / 2 && ax + aw / 2 > bx - bw / 2 && ay - ah / 2 < by + bh / 2 && ay + ah / 2 > by - bh / 2;
}
// Update score text
function updateScore() {
	scoreTxt.setText(score1 + " : " + score2);
}
// Game update loop
game.update = function () {
	// Update snowballs
	for (var i = snowballs.length - 1; i >= 0; i--) {
		var sb = snowballs[i];
		sb.update();
		// Gravity
		sb.vy += 0.7;
		// Friction
		sb.vx *= 0.99;
		sb.vy *= 0.99;
		// Out of bounds: remove
		if (sb.x < -100 || sb.x > GAME_WIDTH + 100 || sb.y < -100 || sb.y > GAME_HEIGHT + 100) {
			sb.destroy();
			snowballs.splice(i, 1);
			continue;
		}
		// Bounce off wall (castle)
		if (!sb.bounced && isIntersect(sb, wall)) {
			// Only bounce once per wall hit
			sb.bounced = true;
			// Simple bounce: invert vx, dampen
			sb.vx = -sb.vx * 0.7;
			// Add a little random to vy
			sb.vy = sb.vy * 0.8 + (Math.random() - 0.5) * 6;
			// Move out of wall
			if (sb.x < wall.x) sb.x = wall.x - wall.width / 2 - 40;else sb.x = wall.x + wall.width / 2 + 40;
			// Flash wall
			LK.effects.flashObject(wall, 0x99ccff, 200);
		}
		// Reset bounce flag if not intersecting
		if (!isIntersect(sb, wall)) {
			sb.bounced = false;
		}
		// Hit penguin (opponent only)
		if (sb.owner === 1 && isIntersect(sb, penguin2)) {
			// Score for player 1
			score1 += 1;
			updateScore();
			LK.effects.flashObject(penguin2, 0xffffff, 400);
			sb.destroy();
			snowballs.splice(i, 1);
			// Win condition
			if (score1 >= 5) {
				LK.showYouWin();
			}
			continue;
		}
		if (sb.owner === 2 && isIntersect(sb, penguin1)) {
			// Score for player 2
			score2 += 1;
			updateScore();
			LK.effects.flashObject(penguin1, 0xffffff, 400);
			sb.destroy();
			snowballs.splice(i, 1);
			// Lose condition
			if (score2 >= 5) {
				LK.showGameOver();
			}
			continue;
		}
	}
};
// Initial score
updateScore();

===================================================================
--- original.js
+++ change.js
@@ -76,13 +76,13 @@
 
 /**** 
 * Game Code
 ****/ 
-// Castle wall (center)
-// Snowball
-// Penguin (player 2)
-// Penguin (player 1)
 // Game constants
+// Penguin (player 1)
+// Penguin (player 2)
+// Snowball
+// Castle wall (center)
 var GAME_WIDTH = 2048;
 var GAME_HEIGHT = 2732;
 // Center wall
 var wall = LK.getAsset('castleWall', {
@@ -288,19 +288,22 @@
 		var dx = dragCurrentX - dragStartX;
 		var dy = dragCurrentY - dragStartY;
 		var dist = Math.sqrt(dx * dx + dy * dy);
 		if (dist > 20) {
-			// Calculate angle (opposite direction of drag)
-			var angle = Math.atan2(dragStartY - dragCurrentY, dragStartX - dragCurrentX);
+			// Always aim toward the opposing penguin
+			var target = penguin === penguin1 ? penguin2 : penguin1;
+			var tx = target.x - penguin.x;
+			var ty = target.y - penguin.y;
+			var angle = Math.atan2(ty, tx);
 			// Bar length
 			var barLen = 220;
 			// Create bar as a thin tall rectangle (use a box shape)
 			var bar = LK.getAsset('snowball', {
 				anchorX: 0.5,
 				anchorY: 1,
 				width: 18,
 				height: barLen,
-				color: 0xff0000
+				color: 0x4fc3f7
 			});
 			// Place under penguin
 			bar.x = penguin.x;
 			bar.y = penguin.y + 90;
@@ -340,19 +343,29 @@
 	var dy = dragCurrentY - dragStartY;
 	var dist = Math.sqrt(dx * dx + dy * dy);
 	// Only allow throw if drag is a "flick" (distance > 80)
 	if (dist > 80 && dragPenguin.canThrow) {
-		// Calculate velocity (opposite direction of drag)
-		// Use powerBarValue to scale the velocity
+		// Always throw toward the opposing penguin, power only affects distance
 		var basePower = powerBarValue || powerBarMin;
-		var vx = (dragStartX - dragCurrentX) * 0.18 * basePower;
-		var vy = (dragStartY - dragCurrentY) * 0.18 * basePower;
+		var thrower = dragPenguin;
+		var target = thrower === penguin1 ? penguin2 : penguin1;
+		// Calculate direction vector from thrower to target
+		var tx = target.x - thrower.x;
+		var ty = target.y - thrower.y;
+		var len = Math.sqrt(tx * tx + ty * ty);
+		// Normalize direction
+		var dirX = tx / len;
+		var dirY = ty / len;
+		// Set velocity magnitude based on power
+		var minV = 18;
+		var maxV = 55;
+		var velocity = minV + (maxV - minV) * ((basePower - powerBarMin) / (powerBarMax - powerBarMin));
 		// Clamp velocity
-		var maxV = 55 * basePower;
-		if (vx > maxV) vx = maxV;
-		if (vx < -maxV) vx = -maxV;
-		if (vy > maxV) vy = maxV;
-		if (vy < -maxV) vy = -maxV;
+		if (velocity < minV) velocity = minV;
+		if (velocity > maxV) velocity = maxV;
+		// Final velocity
+		var vx = dirX * velocity;
+		var vy = dirY * velocity;
 		// Create snowball
 		var snowball = new Snowball();
 		snowball.owner = dragPenguin === penguin1 ? 1 : 2;
 		snowball.x = dragPenguin.x;