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

/**** 
* Classes
****/ 
var Character = Container.expand(function (level) {
	var self = Container.call(this);
	self.level = level || 1;
	self.merging = false;
	self.settled = false;
	self.velocityX = 0;
	self.velocityY = 0;
	self.gravity = 0.5;
	self.bounce = 0.3;
	self.friction = 0.98;
	var graphics = self.attachAsset('character' + self.level, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.radius = graphics.width / 2;
	// Add character labels for visual feedback
	var levelText = new Text2(self.level.toString(), {
		size: 40,
		fill: 0x000000
	});
	levelText.anchor.set(0.5, 0.5);
	self.addChild(levelText);
	self.update = function () {
		if (self.merging) return;
		// Apply gravity
		self.velocityY += self.gravity;
		// Apply velocity
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Apply friction
		self.velocityX *= self.friction;
		// Check collision with walls
		if (self.x - self.radius <= leftWall.x + leftWall.width / 2) {
			self.x = leftWall.x + leftWall.width / 2 + self.radius;
			self.velocityX = Math.abs(self.velocityX) * self.bounce;
			if (self.velocityX > 1) {
				LK.getSound('bounce').play();
			}
		}
		if (self.x + self.radius >= rightWall.x - rightWall.width / 2) {
			self.x = rightWall.x - rightWall.width / 2 - self.radius;
			self.velocityX = -Math.abs(self.velocityX) * self.bounce;
			if (self.velocityX < -1) {
				LK.getSound('bounce').play();
			}
		}
		// Check collision with floor
		if (self.y + self.radius >= floor.y - floor.height / 2) {
			self.y = floor.y - floor.height / 2 - self.radius;
			self.velocityY = -Math.abs(self.velocityY) * self.bounce;
			if (Math.abs(self.velocityY) < 2) {
				self.velocityY = 0;
				self.settled = true;
			}
			if (Math.abs(self.velocityY) > 1) {
				LK.getSound('bounce').play();
			}
		}
		// Check for collisions with other characters
		for (var i = 0; i < characters.length; i++) {
			var other = characters[i];
			if (other !== self && !other.merging && !self.merging) {
				var distance = Math.sqrt(Math.pow(self.x - other.x, 2) + Math.pow(self.y - other.y, 2));
				var minDistance = self.radius + other.radius;
				// Check for collision
				if (distance < minDistance && distance > 0) {
					// Calculate collision normal
					var normalX = (other.x - self.x) / distance;
					var normalY = (other.y - self.y) / distance;
					// Separate objects
					var overlap = minDistance - distance;
					var separationX = normalX * overlap * 0.5;
					var separationY = normalY * overlap * 0.5;
					self.x -= separationX;
					self.y -= separationY;
					other.x += separationX;
					other.y += separationY;
					// Calculate relative velocity
					var relativeVelX = self.velocityX - other.velocityX;
					var relativeVelY = self.velocityY - other.velocityY;
					// Calculate collision velocity in collision normal direction
					var collisionVelocity = relativeVelX * normalX + relativeVelY * normalY;
					// Only resolve if objects are moving towards each other
					if (collisionVelocity > 0) {
						// Calculate collision impulse
						var restitution = 0.4; // Bounce factor
						var impulse = -(1 + restitution) * collisionVelocity;
						// Apply impulse to velocities
						self.velocityX += impulse * normalX;
						self.velocityY += impulse * normalY;
						other.velocityX -= impulse * normalX;
						other.velocityY -= impulse * normalY;
						// Play bounce sound if collision is significant
						if (Math.abs(impulse) > 1) {
							LK.getSound('bounce').play();
						}
					}
					// Check for merging only if same level and close enough
					if (other.level === self.level && distance < minDistance - 5) {
						self.mergeWith(other);
						break;
					}
				}
			}
		}
	};
	self.mergeWith = function (other) {
		if (self.merging || other.merging) return;
		if (self.level >= 8) return; // Max level reached
		self.merging = true;
		other.merging = true;
		// Calculate merge position
		var mergeX = (self.x + other.x) / 2;
		var mergeY = (self.y + other.y) / 2;
		// Play merge sound
		LK.getSound('merge').play();
		// Create merge effect
		tween(self, {
			alpha: 0,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 200,
			easing: tween.easeOut
		});
		tween(other, {
			alpha: 0,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 200,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Remove old characters
				var selfIndex = characters.indexOf(self);
				var otherIndex = characters.indexOf(other);
				if (selfIndex > -1) characters.splice(selfIndex, 1);
				if (otherIndex > -1) characters.splice(otherIndex, 1);
				self.destroy();
				other.destroy();
				// Create new character
				var newCharacter = new Character(self.level + 1);
				newCharacter.x = mergeX;
				newCharacter.y = mergeY;
				newCharacter.velocityY = -5; // Small upward bounce
				characters.push(newCharacter);
				gameContainer.addChild(newCharacter);
				// Update score
				LK.setScore(LK.getScore() + self.level * 10);
				scoreText.setText(LK.getScore());
				// Spawn effect
				tween(newCharacter, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.bounceOut
				});
				newCharacter.scaleX = 0.5;
				newCharacter.scaleY = 0.5;
			}
		});
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Sound effects
// Drop zone indicator
// Container walls
// Pink circle - ultimate
// Orange circle - capybara with hat
// Purple circle - capybara
// Yellow circle - giant duck
// Green circle - duck
// Blue circle - cat with glasses
// Teal circle - cat
// Red circle - basic
// Character assets - progression from simple to complex
// Game variables
var characters = [];
var nextCharacterLevel = 1;
var dropPosition = 1024; // Center of screen
var gameOver = false;
var dropCooldown = 0;
// Create game container
var gameContainer = new Container();
game.addChild(gameContainer);
// Create container walls and floor
var leftWall = gameContainer.attachAsset('wall', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 624,
	y: 1866
});
var rightWall = gameContainer.attachAsset('wall', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1424,
	y: 1866
});
var floor = gameContainer.attachAsset('floor', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 2166
});
// Create drop zone indicator
var dropZone = gameContainer.attachAsset('dropZone', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: dropPosition,
	y: 1400,
	alpha: 0.3
});
// Create UI elements
var scoreText = new Text2('0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
scoreText.y = 100;
var nextCharacterText = new Text2('Next: Level 1', {
	size: 60,
	fill: 0xFFFFFF
});
nextCharacterText.anchor.set(0.5, 0);
LK.gui.top.addChild(nextCharacterText);
nextCharacterText.y = 200;
// Game over line
var gameOverLine = new Container();
var lineGraphics = LK.getAsset('floor', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 800,
	height: 5
});
lineGraphics.tint = 0xFF0000;
lineGraphics.alpha = 0.5;
gameOverLine.addChild(lineGraphics);
gameOverLine.x = 1024;
gameOverLine.y = 1450;
gameContainer.addChild(gameOverLine);
// Check if there are any matching characters for the given level
function hasMatchingCharacters(level) {
	var count = 0;
	for (var i = 0; i < characters.length; i++) {
		if (characters[i].level === level && !characters[i].merging) {
			count++;
			if (count >= 2) return true;
		}
	}
	return false;
}
// Generate next character level (weighted towards lower levels)
function generateNextCharacter() {
	var rand = Math.random();
	if (rand < 0.4) return 1;
	if (rand < 0.7) return 2;
	if (rand < 0.85) return 3;
	if (rand < 0.95) return 4;
	return 5;
}
// Check if game is over - disabled for infinite gameplay
function checkGameOver() {
	// Game over functionality removed - infinite game
	return false;
}
// Drop character
function dropCharacter() {
	if (dropCooldown > 0) return;
	var character = new Character(nextCharacterLevel);
	character.x = dropPosition;
	character.y = 1300;
	character.velocityY = 2;
	characters.push(character);
	gameContainer.addChild(character);
	// Play drop sound
	LK.getSound('drop').play();
	// Generate next character
	nextCharacterLevel = generateNextCharacter();
	nextCharacterText.setText('Next: Level ' + nextCharacterLevel);
	// Set cooldown
	dropCooldown = 30; // 0.5 seconds at 60fps
}
// Handle mouse/touch input
game.move = function (x, y, obj) {
	// Update drop position
	dropPosition = Math.max(leftWall.x + leftWall.width / 2 + 60, Math.min(rightWall.x - rightWall.width / 2 - 60, x));
	dropZone.x = dropPosition;
};
game.down = function (x, y, obj) {
	// Update drop position and drop character
	dropPosition = Math.max(leftWall.x + leftWall.width / 2 + 60, Math.min(rightWall.x - rightWall.width / 2 - 60, x));
	dropZone.x = dropPosition;
	dropCharacter();
};
// Main game loop
game.update = function () {
	// Update cooldown
	if (dropCooldown > 0) {
		dropCooldown--;
	}
	// Update drop zone alpha based on cooldown
	dropZone.alpha = dropCooldown > 0 ? 0.1 : 0.3;
	// Clean up destroyed characters
	for (var i = characters.length - 1; i >= 0; i--) {
		if (characters[i].destroyed) {
			characters.splice(i, 1);
		}
	}
};
// Initialize first character level
nextCharacterLevel = generateNextCharacter();
nextCharacterText.setText('Next: Level ' + nextCharacterLevel);

===================================================================
--- original.js
+++ change.js
@@ -63,16 +63,52 @@
 			if (Math.abs(self.velocityY) > 1) {
 				LK.getSound('bounce').play();
 			}
 		}
-		// Check for merging with other characters
+		// Check for collisions with other characters
 		for (var i = 0; i < characters.length; i++) {
 			var other = characters[i];
-			if (other !== self && other.level === self.level && !other.merging && !self.merging) {
+			if (other !== self && !other.merging && !self.merging) {
 				var distance = Math.sqrt(Math.pow(self.x - other.x, 2) + Math.pow(self.y - other.y, 2));
-				if (distance < self.radius + other.radius - 10) {
-					self.mergeWith(other);
-					break;
+				var minDistance = self.radius + other.radius;
+				// Check for collision
+				if (distance < minDistance && distance > 0) {
+					// Calculate collision normal
+					var normalX = (other.x - self.x) / distance;
+					var normalY = (other.y - self.y) / distance;
+					// Separate objects
+					var overlap = minDistance - distance;
+					var separationX = normalX * overlap * 0.5;
+					var separationY = normalY * overlap * 0.5;
+					self.x -= separationX;
+					self.y -= separationY;
+					other.x += separationX;
+					other.y += separationY;
+					// Calculate relative velocity
+					var relativeVelX = self.velocityX - other.velocityX;
+					var relativeVelY = self.velocityY - other.velocityY;
+					// Calculate collision velocity in collision normal direction
+					var collisionVelocity = relativeVelX * normalX + relativeVelY * normalY;
+					// Only resolve if objects are moving towards each other
+					if (collisionVelocity > 0) {
+						// Calculate collision impulse
+						var restitution = 0.4; // Bounce factor
+						var impulse = -(1 + restitution) * collisionVelocity;
+						// Apply impulse to velocities
+						self.velocityX += impulse * normalX;
+						self.velocityY += impulse * normalY;
+						other.velocityX -= impulse * normalX;
+						other.velocityY -= impulse * normalY;
+						// Play bounce sound if collision is significant
+						if (Math.abs(impulse) > 1) {
+							LK.getSound('bounce').play();
+						}
+					}
+					// Check for merging only if same level and close enough
+					if (other.level === self.level && distance < minDistance - 5) {
+						self.mergeWith(other);
+						break;
+					}
 				}
 			}
 		}
 	};