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

/**** 
* Classes
****/ 
var StackedBlock = Container.expand(function () {
	var self = Container.call(this);
	var block = self.attachAsset('block', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Physics properties for collision
	self.velocityX = 0;
	self.velocityY = 0;
	self.mass = 1;
	self.restitution = 0.3; // Bounce factor
	self.friction = 0.8; // Friction coefficient
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var stackedBlocks = [];
var gameHeight = 2732;
var gameWidth = 2048;
var groundLevel = gameHeight - 120;
var stackHeight = 0;
var gameActive = true;
// Create foundation block
var foundation = new StackedBlock();
foundation.x = gameWidth / 2;
foundation.y = gameHeight - 120; // Move to bottom of screen
game.addChild(foundation);
stackedBlocks.push(foundation);
stackHeight = foundation.y;
// Create rope hanging from top center
var rope = LK.getAsset('rope', {
	anchorX: 0.5,
	anchorY: 0
});
rope.x = gameWidth / 2;
rope.y = 0; // Rope starts at top of screen
game.addChild(rope);
// Create swinging block at the end of rope
var swingingBlock = LK.getAsset('swingingBlock', {
	anchorX: 0.5,
	anchorY: 0.5
});
swingingBlock.x = 0;
swingingBlock.y = rope.height + 100; // Extend the rope length by moving block further down
rope.addChild(swingingBlock);
// Natural pendulum swing variables
var swingTime = 0;
var swingSpeed = 0.03; // Controls swing speed
var swingAmplitude = 0.6; // Controls swing range (max rotation)
// Score display
var scoreTxt = new Text2('Blocks: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Touch handler to drop the block
game.down = function (x, y, obj) {
	if (!gameActive || !swingingBlock.parent) return;
	// Get the current world position of the swinging block
	var worldPos = rope.toGlobal(swingingBlock.position);
	var gamePos = game.toLocal(worldPos);
	// Detach from rope and add to game
	rope.removeChild(swingingBlock);
	game.addChild(swingingBlock);
	// Set position in game coordinates
	swingingBlock.x = gamePos.x;
	swingingBlock.y = gamePos.y;
	// Add falling velocity
	swingingBlock.velocityY = 0;
	swingingBlock.gravity = 0.8;
	swingingBlock.falling = true;
};
// Update function for falling blocks
game.update = function () {
	// Update rope swing with natural pendulum motion
	if (rope && !swingingBlock.falling) {
		swingTime += swingSpeed;
		rope.rotation = Math.sin(swingTime) * swingAmplitude;
		// Add vertical swinging motion to the swinging block
		var verticalOffset = Math.cos(swingTime * 2) * 30; // Vertical swing with smaller amplitude
		swingingBlock.y = rope.height + 100 + verticalOffset;
	}
	// Update physics for all stacked blocks
	for (var p = 0; p < stackedBlocks.length; p++) {
		var block = stackedBlocks[p];
		if (block.velocityX !== undefined && Math.abs(block.velocityX) > 0.1) {
			block.x += block.velocityX;
			// Apply friction to horizontal movement
			block.velocityX *= block.friction || 0.9;
		}
		if (block.velocityY !== undefined && Math.abs(block.velocityY) > 0.1) {
			block.y += block.velocityY;
			// Apply gravity and damping
			block.velocityY = block.velocityY * 0.98 + 0.1;
		}
	}
	if (swingingBlock.falling) {
		swingingBlock.velocityY += swingingBlock.gravity;
		swingingBlock.y += swingingBlock.velocityY;
		// Check collision with any stacked block using Y position bounds
		var hasCollision = false;
		var nextY = swingingBlock.y + swingingBlock.velocityY + swingingBlock.gravity;
		for (var i = 0; i < stackedBlocks.length; i++) {
			var block = stackedBlocks[i];
			var blockTop = block.y - block.height / 2;
			var blockBottom = block.y + block.height / 2;
			var swingingTop = swingingBlock.y - swingingBlock.height / 2;
			var swingingBottom = nextY + swingingBlock.height / 2;
			// Check if falling block will intersect or has passed through this block
			if (swingingTop <= blockBottom && swingingBottom >= blockTop) {
				// Also check X overlap for more accurate collision
				var swingingLeft = swingingBlock.x - swingingBlock.width / 2;
				var swingingRight = swingingBlock.x + swingingBlock.width / 2;
				var blockLeft = block.x - block.width / 2;
				var blockRight = block.x + block.width / 2;
				if (swingingLeft < blockRight && swingingRight > blockLeft) {
					hasCollision = true;
					break;
				}
			}
		}
		if (hasCollision) {
			// Find the topmost block that the swinging block collided with
			var targetBlock = null;
			var highestY = gameHeight;
			for (var k = 0; k < stackedBlocks.length; k++) {
				if (swingingBlock.intersects(stackedBlocks[k]) && stackedBlocks[k].y < highestY) {
					targetBlock = stackedBlocks[k];
					highestY = stackedBlocks[k].y;
				}
			}
			// Apply collision physics
			if (targetBlock) {
				// Calculate collision normal and relative velocity
				var collisionNormalY = swingingBlock.y < targetBlock.y ? -1 : 1;
				var relativeVelocityY = swingingBlock.velocityY - (targetBlock.velocityY || 0);
				// Calculate impulse for realistic collision response
				var impulse = -(1 + (swingingBlock.restitution || 0.3)) * relativeVelocityY;
				impulse = impulse / ((swingingBlock.mass || 1) + (targetBlock.mass || 1));
				// Apply impulse to both blocks
				var swingingImpulse = impulse * (targetBlock.mass || 1);
				var targetImpulse = -impulse * (swingingBlock.mass || 1);
				// Update velocities with collision response
				swingingBlock.velocityY += swingingImpulse * collisionNormalY;
				if (targetBlock.velocityY !== undefined) {
					targetBlock.velocityY += targetImpulse * collisionNormalY;
				}
				// Add horizontal collision effects for more realistic physics
				var horizontalDistance = swingingBlock.x - targetBlock.x;
				if (Math.abs(horizontalDistance) > 0) {
					var horizontalForce = horizontalDistance > 0 ? 1 : -1;
					swingingBlock.velocityX = (swingingBlock.velocityX || 0) + horizontalForce * 3;
					// Apply friction to horizontal movement
					tween(swingingBlock, {
						velocityX: 0
					}, {
						duration: 1000,
						easing: tween.easeOut
					});
				}
				// Create visual impact effect
				LK.effects.flashObject(targetBlock, 0xffff00, 200);
				LK.effects.flashObject(swingingBlock, 0xff6600, 200);
			}
			if (targetBlock) {
				// Check if the swinging block covers at least half of the target block
				var swingingLeft = swingingBlock.x - swingingBlock.width / 2;
				var swingingRight = swingingBlock.x + swingingBlock.width / 2;
				var targetLeft = targetBlock.x - targetBlock.width / 2;
				var targetRight = targetBlock.x + targetBlock.width / 2;
				// Calculate overlap
				var overlapLeft = Math.max(swingingLeft, targetLeft);
				var overlapRight = Math.min(swingingRight, targetRight);
				var overlapWidth = Math.max(0, overlapRight - overlapLeft);
				// Check if overlap is at least half of the target block width
				var requiredCoverage = targetBlock.width / 2;
				// Check for quarter coverage (1/4) to trigger natural fall with rotation
				var quarterCoverage = targetBlock.width / 4;
				if (overlapWidth <= quarterCoverage && overlapWidth > 0) {
					// Block is barely touching - make it fall naturally with rotation
					swingingBlock.falling = true;
					swingingBlock.velocityY = Math.max(swingingBlock.velocityY, 2); // Ensure some downward velocity
					// Add natural rotation based on which side is touching
					var rotationDirection = swingingBlock.x < targetBlock.x ? -1 : 1;
					tween(swingingBlock, {
						rotation: swingingBlock.rotation + rotationDirection * Math.PI * 2
					}, {
						duration: 1500,
						easing: tween.easeOut
					});
					// Game over - player loses
					gameActive = false;
					LK.setTimeout(function () {
						LK.showGameOver();
					}, 800); // Delay to show the rotation effect
				} else if (overlapWidth >= requiredCoverage) {
					// Award 1 point
					LK.setScore(LK.getScore() + 1);
					scoreTxt.setText('Blocks: ' + LK.getScore());
					// Place block on stack
					swingingBlock.falling = false;
					swingingBlock.velocityY = 0;
					stackHeight -= 240; // Move stack up by block height
					swingingBlock.y = stackHeight;
					stackedBlocks.push(swingingBlock);
					// If this is the second red block (score 2), start sliding foundation down
					if (LK.getScore() >= 2) {
						// Move foundation and all stacked blocks down by one block height
						for (var j = 0; j < stackedBlocks.length; j++) {
							tween(stackedBlocks[j], {
								y: stackedBlocks[j].y + 240
							}, {
								duration: 500,
								easing: tween.easeInOut
							});
						}
						// Update stack height
						stackHeight += 240;
					}
					// Create new swinging block
					swingingBlock = LK.getAsset('swingingBlock', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					swingingBlock.x = 0;
					swingingBlock.y = rope.height + 100;
					// Initialize physics properties
					swingingBlock.velocityX = 0;
					swingingBlock.velocityY = 0;
					swingingBlock.mass = 1;
					swingingBlock.restitution = 0.4;
					swingingBlock.friction = 0.8;
					rope.addChild(swingingBlock);
				} else {
					// Not enough coverage - continue falling
					swingingBlock.falling = true;
				}
			}
		}
		// Check if block has fallen below the screen
		else if (swingingBlock.y > gameHeight + 200) {
			// Game over - player missed the target
			gameActive = false;
			LK.showGameOver();
		}
	}
};
;

===================================================================
--- original.js
+++ change.js
@@ -11,8 +11,14 @@
 	var block = self.attachAsset('block', {
 		anchorX: 0.5,
 		anchorY: 0.5
 	});
+	// Physics properties for collision
+	self.velocityX = 0;
+	self.velocityY = 0;
+	self.mass = 1;
+	self.restitution = 0.3; // Bounce factor
+	self.friction = 0.8; // Friction coefficient
 	return self;
 });
 
 /**** 
@@ -92,8 +98,22 @@
 		// Add vertical swinging motion to the swinging block
 		var verticalOffset = Math.cos(swingTime * 2) * 30; // Vertical swing with smaller amplitude
 		swingingBlock.y = rope.height + 100 + verticalOffset;
 	}
+	// Update physics for all stacked blocks
+	for (var p = 0; p < stackedBlocks.length; p++) {
+		var block = stackedBlocks[p];
+		if (block.velocityX !== undefined && Math.abs(block.velocityX) > 0.1) {
+			block.x += block.velocityX;
+			// Apply friction to horizontal movement
+			block.velocityX *= block.friction || 0.9;
+		}
+		if (block.velocityY !== undefined && Math.abs(block.velocityY) > 0.1) {
+			block.y += block.velocityY;
+			// Apply gravity and damping
+			block.velocityY = block.velocityY * 0.98 + 0.1;
+		}
+	}
 	if (swingingBlock.falling) {
 		swingingBlock.velocityY += swingingBlock.gravity;
 		swingingBlock.y += swingingBlock.velocityY;
 		// Check collision with any stacked block using Y position bounds
@@ -127,9 +147,42 @@
 					targetBlock = stackedBlocks[k];
 					highestY = stackedBlocks[k].y;
 				}
 			}
+			// Apply collision physics
 			if (targetBlock) {
+				// Calculate collision normal and relative velocity
+				var collisionNormalY = swingingBlock.y < targetBlock.y ? -1 : 1;
+				var relativeVelocityY = swingingBlock.velocityY - (targetBlock.velocityY || 0);
+				// Calculate impulse for realistic collision response
+				var impulse = -(1 + (swingingBlock.restitution || 0.3)) * relativeVelocityY;
+				impulse = impulse / ((swingingBlock.mass || 1) + (targetBlock.mass || 1));
+				// Apply impulse to both blocks
+				var swingingImpulse = impulse * (targetBlock.mass || 1);
+				var targetImpulse = -impulse * (swingingBlock.mass || 1);
+				// Update velocities with collision response
+				swingingBlock.velocityY += swingingImpulse * collisionNormalY;
+				if (targetBlock.velocityY !== undefined) {
+					targetBlock.velocityY += targetImpulse * collisionNormalY;
+				}
+				// Add horizontal collision effects for more realistic physics
+				var horizontalDistance = swingingBlock.x - targetBlock.x;
+				if (Math.abs(horizontalDistance) > 0) {
+					var horizontalForce = horizontalDistance > 0 ? 1 : -1;
+					swingingBlock.velocityX = (swingingBlock.velocityX || 0) + horizontalForce * 3;
+					// Apply friction to horizontal movement
+					tween(swingingBlock, {
+						velocityX: 0
+					}, {
+						duration: 1000,
+						easing: tween.easeOut
+					});
+				}
+				// Create visual impact effect
+				LK.effects.flashObject(targetBlock, 0xffff00, 200);
+				LK.effects.flashObject(swingingBlock, 0xff6600, 200);
+			}
+			if (targetBlock) {
 				// Check if the swinging block covers at least half of the target block
 				var swingingLeft = swingingBlock.x - swingingBlock.width / 2;
 				var swingingRight = swingingBlock.x + swingingBlock.width / 2;
 				var targetLeft = targetBlock.x - targetBlock.width / 2;
@@ -141,10 +194,10 @@
 				// Check if overlap is at least half of the target block width
 				var requiredCoverage = targetBlock.width / 2;
 				// Check for quarter coverage (1/4) to trigger natural fall with rotation
 				var quarterCoverage = targetBlock.width / 4;
-				if (overlapWidth < quarterCoverage && overlapWidth > 0) {
-					// Block has minimal contact - make it fall naturally with rotation
+				if (overlapWidth <= quarterCoverage && overlapWidth > 0) {
+					// Block is barely touching - make it fall naturally with rotation
 					swingingBlock.falling = true;
 					swingingBlock.velocityY = Math.max(swingingBlock.velocityY, 2); // Ensure some downward velocity
 					// Add natural rotation based on which side is touching
 					var rotationDirection = swingingBlock.x < targetBlock.x ? -1 : 1;
@@ -189,8 +242,14 @@
 						anchorY: 0.5
 					});
 					swingingBlock.x = 0;
 					swingingBlock.y = rope.height + 100;
+					// Initialize physics properties
+					swingingBlock.velocityX = 0;
+					swingingBlock.velocityY = 0;
+					swingingBlock.mass = 1;
+					swingingBlock.restitution = 0.4;
+					swingingBlock.friction = 0.8;
 					rope.addChild(swingingBlock);
 				} else {
 					// Not enough coverage - continue falling
 					swingingBlock.falling = true;