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

/**** 
* Classes
****/ 
var DropShape = Container.expand(function (shapeType, color, shapeForm) {
	var self = Container.call(this);
	self.shapeType = shapeType;
	self.color = color;
	self.shapeForm = shapeForm;
	self.speed = 0;
	self.targetY = 0;
	self.isMoving = false;
	self.lane = 0;
	self.row = -1;
	var assetId = color + shapeForm;
	var shapeGraphics = self.attachAsset(assetId, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.startDrop = function (lane, startY, endY) {
		self.lane = lane;
		self.y = startY;
		self.targetY = endY;
		self.speed = 60;
		self.isMoving = true;
		// Add slot machine spinning effect
		tween(self, {
			rotation: Math.PI * 4
		}, {
			duration: 2000,
			easing: tween.easeOut
		});
	};
	self.update = function () {
		if (self.isMoving) {
			self.y += self.speed;
			// Faster settling with quicker deceleration
			var distanceToTarget = Math.abs(self.targetY - self.y);
			if (distanceToTarget < 100) {
				self.speed = Math.max(1, self.speed * 0.75);
			}
			// Stop at target with bounce effect
			if (self.y >= self.targetY) {
				self.y = self.targetY;
				self.isMoving = false;
				self.speed = 0;
				// Add settling bounce animation
				tween(self, {
					scaleY: 0.9
				}, {
					duration: 100,
					onFinish: function onFinish() {
						tween(self, {
							scaleY: 1.0
						}, {
							duration: 150,
							easing: tween.bounceOut
						});
					}
				});
				// Calculate which row this shape is in
				self.row = Math.floor((self.y - gridStartY) / (cellSize + cellMargin));
			}
		}
	};
	return self;
});
var Lever = Container.expand(function () {
	var self = Container.call(this);
	self.isPulled = false;
	self.canPull = true;
	var leverBase = self.attachAsset('lever', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	var leverHandle = self.attachAsset('leverHandle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	leverHandle.y = -700;
	self.pull = function () {
		if (!self.canPull || isShifting) return;
		self.canPull = false;
		self.isPulled = true;
		LK.getSound('leverPull').play();
		// Animate lever handle moving down when pulled
		tween(leverHandle, {
			y: -400
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Reset lever state with delay
		LK.setTimeout(function () {
			self.isPulled = false;
			// Animate lever handle back up when released
			tween(leverHandle, {
				y: -700
			}, {
				duration: 250,
				easing: tween.bounceOut
			});
		}, 350);
		// Allow next pull after 1 second
		LK.setTimeout(function () {
			self.canPull = true;
		}, 1000);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
var lanes = [];
var dropShapes = [];
var cellSize = 300; // Square cell size
var cellMargin = 15; // 15 pixel margin between cells
var totalGridWidth = 4 * cellSize + 3 * cellMargin; // Total width of 4 columns with margins
var totalGridHeight = 5 * cellSize + 4 * cellMargin; // Total height of 5 rows with margins
var gridStartX = (2048 - totalGridWidth) / 2 - 200; // Shift the 4x5 grid to the left
var gridStartY = 600;
var laneWidth = cellSize + cellMargin; // Width per column including margin
var laneBackgroundWidth = cellSize; // Square cell background
var cellHeight = cellSize + cellMargin; // Height per row including margin
var shapeTypes = ['red', 'blue', 'green', 'yellow'];
var shapeForms = ['Shape', 'Circle'];
var lever;
var scoreTxt;
// Create lane backgrounds for 4x5 grid
for (var col = 0; col < 4; col++) {
	for (var row = 0; row < 5; row++) {
		var assetType = row === 2 ? 'middleCell' : 'cell';
		var cellBack = LK.getAsset(assetType, {
			width: cellSize,
			height: cellSize,
			anchorX: 0.5,
			anchorY: 0.5,
			alpha: 0.3
		});
		cellBack.x = gridStartX + col * (cellSize + cellMargin) + cellSize / 2;
		cellBack.y = gridStartY + row * (cellSize + cellMargin) + cellSize / 2;
		game.addChild(cellBack);
	}
}
// Create lever
lever = game.addChild(new Lever());
lever.x = 1700; // Move to the left
lever.y = 1400;
// Create score display
scoreTxt = new Text2('Score: 0', {
	size: 80,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
function updateScore() {
	scoreTxt.setText('Score: ' + LK.getScore());
}
function getRandomShape() {
	var color = shapeTypes[Math.floor(Math.random() * shapeTypes.length)];
	var form = shapeForms[Math.floor(Math.random() * shapeForms.length)];
	return {
		color: color,
		form: form
	};
}
function spawnShapes() {
	spawnNewShapes();
}
function spawnNewShapes() {
	// Staggered spawning for authentic slot machine feel
	for (var i = 0; i < 4; i++) {
		(function (laneIndex) {
			LK.setTimeout(function () {
				var shapeData = getRandomShape();
				var shape = new DropShape(shapeData.color + shapeData.form, shapeData.color, shapeData.form);
				shape.x = gridStartX + laneIndex * (cellSize + cellMargin) + cellSize / 2;
				// Find the lowest available position in this lane
				var targetRow = 4; // Start from bottom row
				for (var row = 4; row >= 0; row--) {
					var occupied = false;
					for (var j = 0; j < dropShapes.length; j++) {
						if (dropShapes[j].lane === laneIndex && dropShapes[j].row === row && !dropShapes[j].isMoving) {
							occupied = true;
							break;
						}
					}
					if (!occupied) {
						targetRow = row;
						break;
					}
				}
				// If bottom row is occupied, find next available row going up
				if (targetRow === 4) {
					for (var row = 4; row >= 0; row--) {
						var occupied = false;
						for (var j = 0; j < dropShapes.length; j++) {
							if (dropShapes[j].lane === laneIndex && dropShapes[j].row === row && !dropShapes[j].isMoving) {
								occupied = true;
								break;
							}
						}
						if (!occupied) {
							targetRow = row;
							break;
						}
					}
				}
				var targetY = gridStartY + targetRow * (cellSize + cellMargin) + cellSize / 2;
				shape.startDrop(laneIndex, gridStartY - 100, targetY);
				// Add initial scale animation
				shape.scaleX = 0.5;
				shape.scaleY = 0.5;
				tween(shape, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 300,
					easing: tween.bounceOut
				});
				game.addChild(shape);
				dropShapes.push(shape);
			}, i * 150); // Stagger by 150ms per lane
		})(i);
	}
}
function checkMatches() {
	// Check middle row (row 2) for matches
	var middleRowShapes = [];
	for (var i = 0; i < dropShapes.length; i++) {
		if (dropShapes[i].row === 2) {
			middleRowShapes.push(dropShapes[i]);
		}
	}
	if (middleRowShapes.length < 3) return;
	// Count shapes by type and color
	var shapeCount = {};
	var colorCount = {};
	var shapeColorCount = {};
	for (var i = 0; i < middleRowShapes.length; i++) {
		var shape = middleRowShapes[i];
		shapeCount[shape.shapeForm] = (shapeCount[shape.shapeForm] || 0) + 1;
		colorCount[shape.color] = (colorCount[shape.color] || 0) + 1;
		shapeColorCount[shape.color + shape.shapeForm] = (shapeColorCount[shape.color + shape.shapeForm] || 0) + 1;
	}
	var points = 0;
	var matched = false;
	// Check for 4 same shapes + colors = 1000 points
	for (var key in shapeColorCount) {
		if (shapeColorCount[key] === 4) {
			points = 1000;
			matched = true;
			break;
		}
	}
	// Check for 4 same shapes = 100 points
	if (!matched) {
		for (var key in shapeCount) {
			if (shapeCount[key] === 4) {
				points = 100;
				matched = true;
				break;
			}
		}
	}
	// Check for 3 same shapes + colors = 300 points
	if (!matched) {
		for (var key in shapeColorCount) {
			if (shapeColorCount[key] === 3) {
				points = 300;
				matched = true;
				break;
			}
		}
	}
	// Check for 3 same shapes = 50 points
	if (!matched) {
		for (var key in shapeCount) {
			if (shapeCount[key] === 3) {
				points = 50;
				matched = true;
				break;
			}
		}
	}
	if (matched) {
		LK.setScore(LK.getScore() + points);
		updateScore();
		LK.getSound('scoreMatch').play();
		// Enhanced visual feedback for wins
		var flashColor = points >= 1000 ? 0xffd700 : points >= 300 ? 0xff6600 : 0xffffff;
		for (var i = 0; i < middleRowShapes.length; i++) {
			var shape = middleRowShapes[i];
			LK.effects.flashObject(shape, flashColor, 1000);
			// Add pulsing animation for winning shapes
			tween(shape, {
				scaleX: 1.3,
				scaleY: 1.3
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(shape, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 200
					});
				}
			});
		}
		// Animate score text on big wins
		if (points >= 300) {
			tween(scoreTxt, {
				scaleX: 1.2,
				scaleY: 1.2
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(scoreTxt, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 200
					});
				}
			});
		}
	}
}
function isGridFull() {
	for (var laneIndex = 0; laneIndex < 4; laneIndex++) {
		var occupiedRows = 0;
		for (var j = 0; j < dropShapes.length; j++) {
			if (dropShapes[j].lane === laneIndex && !dropShapes[j].isMoving) {
				occupiedRows++;
			}
		}
		if (occupiedRows >= 5) {
			return true;
		}
	}
	return false;
}
function shiftShapesDown() {
	isShifting = true;
	// Move all shapes down by one row
	var shapesToShift = 0;
	var shapesCompleted = 0;
	// Count shapes that need to be shifted
	for (var i = 0; i < dropShapes.length; i++) {
		if (!dropShapes[i].isMoving) {
			shapesToShift++;
		}
	}
	for (var i = 0; i < dropShapes.length; i++) {
		var shape = dropShapes[i];
		if (!shape.isMoving) {
			shape.row += 1;
			var newTargetY = gridStartY + shape.row * (cellSize + cellMargin) + cellSize / 2;
			// Animate the shift down
			tween(shape, {
				y: newTargetY
			}, {
				duration: 300,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					shapesCompleted++;
					if (shapesCompleted >= shapesToShift) {
						isShifting = false;
					}
				}
			});
		}
	}
	// Fallback to reset flag if no shapes to shift
	if (shapesToShift === 0) {
		isShifting = false;
	}
}
function cleanupOffscreenShapes() {
	for (var i = dropShapes.length - 1; i >= 0; i--) {
		var shape = dropShapes[i];
		// Clean up shapes that go beyond the bottom of the 4x5 grid (row 5 and beyond)
		if (shape.row >= 5) {
			// Add explosion effect before destroying
			tween(shape, {
				scaleX: 1.5,
				scaleY: 1.5,
				alpha: 0
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					shape.destroy();
				}
			});
			dropShapes.splice(i, 1);
		}
	}
}
var lastLeverPulled = false;
var isDragging = false;
var dragStartY = 0;
var dragThreshold = 200; // Minimum drag distance to trigger slot
var isShifting = false; // Flag to prevent lever pulling during animations
// Add touch/drag functionality to game
game.down = function (x, y, obj) {
	if (!isShifting) {
		isDragging = true;
		dragStartY = y;
	}
};
game.move = function (x, y, obj) {
	if (isDragging && !isShifting) {
		var dragDistance = y - dragStartY;
		// Show visual feedback during drag - animate all shapes moving down
		if (dragDistance > 0) {
			var animationOffset = Math.min(dragDistance * 0.5, 50); // Cap the offset
			for (var i = 0; i < dropShapes.length; i++) {
				var shape = dropShapes[i];
				if (!shape.isMoving) {
					var originalY = gridStartY + shape.row * (cellSize + cellMargin) + cellSize / 2;
					tween.stop(shape, {
						y: true
					}); // Stop any existing y tweens
					tween(shape, {
						y: originalY + animationOffset
					}, {
						duration: 100,
						easing: tween.easeOut
					});
				}
			}
			// Animate lever handle down simultaneously with drag
			var leverHandleOffset = Math.min(dragDistance * 2.5, 500); // Increased multiplier and cap for faster, longer movement
			var leverHandle = lever.children[1]; // Get the lever handle (second child)
			tween.stop(leverHandle, {
				y: true
			}); // Stop any existing y tweens on lever handle
			tween(leverHandle, {
				y: -700 + leverHandleOffset
			}, {
				duration: 50,
				easing: tween.easeOut
			});
		}
	}
};
game.up = function (x, y, obj) {
	if (isDragging && !isShifting) {
		var dragDistance = y - dragStartY;
		// If dragged down enough, trigger lever pull on release
		if (dragDistance > dragThreshold) {
			lever.pull();
		} else {
			// Reset shapes to original positions if drag wasn't enough
			for (var i = 0; i < dropShapes.length; i++) {
				var shape = dropShapes[i];
				if (!shape.isMoving) {
					var originalY = gridStartY + shape.row * (cellSize + cellMargin) + cellSize / 2;
					tween.stop(shape, {
						y: true
					}); // Stop any existing y tweens
					tween(shape, {
						y: originalY
					}, {
						duration: 200,
						easing: tween.bounceOut
					});
				}
			}
			// Reset lever handle to original position
			var leverHandle = lever.children[1]; // Get the lever handle (second child)
			tween.stop(leverHandle, {
				y: true
			}); // Stop any existing y tweens on lever handle
			tween(leverHandle, {
				y: -700
			}, {
				duration: 200,
				easing: tween.bounceOut
			});
		}
	}
	isDragging = false;
};
game.update = function () {
	// Check if lever was released (transition from pulled to not pulled)
	var currentLeverPulled = lever.isPulled;
	if (lastLeverPulled && !currentLeverPulled) {
		// Lever was just released - spawn shapes now
		// If grid is full when lever is released, shift shapes down first
		if (isGridFull()) {
			shiftShapesDown();
			cleanupOffscreenShapes();
			// Delay spawning to let shift animation complete
			LK.setTimeout(function () {
				spawnShapes();
			}, 350);
		} else {
			spawnShapes();
		}
	}
	lastLeverPulled = currentLeverPulled;
	// Check for completed drops and matches
	var allStopped = true;
	for (var i = 0; i < dropShapes.length; i++) {
		if (dropShapes[i].isMoving) {
			allStopped = false;
			break;
		}
	}
	if (allStopped && dropShapes.length > 0) {
		var hasNewlyStoppedShapes = false;
		for (var i = 0; i < dropShapes.length; i++) {
			if (dropShapes[i].row === 2 && !dropShapes[i].checked) {
				dropShapes[i].checked = true;
				hasNewlyStoppedShapes = true;
			}
		}
		if (hasNewlyStoppedShapes) {
			checkMatches();
		}
	}
	cleanupOffscreenShapes();
};
updateScore();

===================================================================
--- original.js
+++ change.js
@@ -444,17 +444,17 @@
 					});
 				}
 			}
 			// Animate lever handle down simultaneously with drag
-			var leverHandleOffset = Math.min(dragDistance * 1.5, 300); // Cap the lever movement
+			var leverHandleOffset = Math.min(dragDistance * 2.5, 500); // Increased multiplier and cap for faster, longer movement
 			var leverHandle = lever.children[1]; // Get the lever handle (second child)
 			tween.stop(leverHandle, {
 				y: true
 			}); // Stop any existing y tweens on lever handle
 			tween(leverHandle, {
 				y: -700 + leverHandleOffset
 			}, {
-				duration: 100,
+				duration: 50,
 				easing: tween.easeOut
 			});
 		}
 	}