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

/**** 
* Classes
****/ 
var Animal = Container.expand(function () {
	var self = Container.call(this);
	self.animalAsset = null;
	self.setAnimalImage = function (imageId) {
		if (self.animalAsset) {
			self.animalAsset.destroy();
		}
		self.animalAsset = self.attachAsset(imageId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
	};
	return self;
});
// CarrotSlot class for area 2
var CarrotSlot = Container.expand(function () {
	var self = Container.call(this);
	self.slotAsset = self.attachAsset('carrot', {
		anchorX: 0.5,
		anchorY: 1
	});
	var sproutAsset = self.attachAsset('sprout', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.harvested = false;
	self.regrowTime = 1800; // 30 seconds at 60fps
	self.regrowCounter = 0;
	self.fieldIndex = 1; // Area 2
	self.regrowing = false;
	// Show/hide carrot and handle regrow animation
	self.setHarvested = function (harvested) {
		self.harvested = harvested;
		if (harvested) {
			// Hide carrot with animation
			tween(self.slotAsset, {
				alpha: 0,
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			// Show sprout with animation
			sproutAsset.alpha = 1;
			sproutAsset.scaleX = 0.1;
			sproutAsset.scaleY = 0.1;
			// Animate sprout appearing
			tween(sproutAsset, {
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			self.regrowCounter = self.regrowTime;
			self.regrowing = true;
		} else {
			// Show carrot with animation
			tween(self.slotAsset, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			// Hide sprout with animation
			tween(sproutAsset, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			self.regrowing = false;
		}
	};
	// Regrow logic
	self.update = function () {
		if (self.harvested && self.regrowing) {
			if (self.regrowCounter > 0) {
				// Animate sprout growing to carrot size
				var t = 1 - self.regrowCounter / self.regrowTime;
				sproutAsset.scaleX = 0.5 + 0.5 * t;
				sproutAsset.scaleY = 0.5 + 0.5 * t;
				self.regrowCounter--;
			}
			if (self.regrowCounter <= 0) {
				// Sprout is now full size, switch back to carrot and allow harvest again
				sproutAsset.scaleX = 1;
				sproutAsset.scaleY = 1;
				self.setHarvested(false);
			}
		}
	};
	// For hit detection
	self.isHarvestable = function () {
		return !self.harvested;
	};
	return self;
});
// EggplantSlot class for area 4
var EggplantSlot = Container.expand(function () {
	var self = Container.call(this);
	self.slotAsset = self.attachAsset('eggplant', {
		anchorX: 0.5,
		anchorY: 1
	});
	var sproutAsset = self.attachAsset('sprout', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.harvested = false;
	self.regrowTime = 1800; // 30 seconds at 60fps
	self.regrowCounter = 0;
	self.fieldIndex = 3; // Area 4
	self.regrowing = false;
	// Show/hide eggplant and handle regrow animation
	self.setHarvested = function (harvested) {
		self.harvested = harvested;
		if (harvested) {
			// Hide eggplant with animation
			tween(self.slotAsset, {
				alpha: 0,
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			// Show sprout with animation
			sproutAsset.alpha = 1;
			sproutAsset.scaleX = 0.1;
			sproutAsset.scaleY = 0.1;
			// Animate sprout appearing
			tween(sproutAsset, {
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			self.regrowCounter = self.regrowTime;
			self.regrowing = true;
		} else {
			// Show eggplant with animation
			tween(self.slotAsset, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			// Hide sprout with animation
			tween(sproutAsset, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			self.regrowing = false;
		}
	};
	// Regrow logic
	self.update = function () {
		if (self.harvested && self.regrowing) {
			if (self.regrowCounter > 0) {
				// Animate sprout growing to eggplant size
				var t = 1 - self.regrowCounter / self.regrowTime;
				sproutAsset.scaleX = 0.5 + 0.5 * t;
				sproutAsset.scaleY = 0.5 + 0.5 * t;
				self.regrowCounter--;
			}
			if (self.regrowCounter <= 0) {
				// Sprout is now full size, switch back to eggplant and allow harvest again
				sproutAsset.scaleX = 1;
				sproutAsset.scaleY = 1;
				self.setHarvested(false);
			}
		}
	};
	// For hit detection
	self.isHarvestable = function () {
		return !self.harvested;
	};
	return self;
});
// Farmer class
var Farmer = Container.expand(function () {
	var self = Container.call(this);
	// Create animation frames
	var idleFrame = self.attachAsset('farmer', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 1
	});
	// Frame 2 (running)
	var runningFrame = self.attachAsset('farmer_walk', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	// Frame 3 (right step)
	var rightStepFrame = self.attachAsset('farmer_walk', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0,
		rotation: 0.1
	});
	self.speed = 18; // px per move
	self.targetX = self.x;
	self.targetY = self.y;
	self.moving = false;
	self.lastMoving = false;
	self.animationTimer = 0;
	self.animationFrame = 0;
	self.frameTime = 18; // 0.3 seconds at 60fps
	// Animation frame switching
	self.switchToFrame = function (frameNum) {
		idleFrame.alpha = 0;
		runningFrame.alpha = 0;
		rightStepFrame.alpha = 0;
		if (frameNum === 0) {
			// Idle
			idleFrame.alpha = 1;
		} else if (frameNum === 1) {
			// Running
			runningFrame.alpha = 1;
		} else if (frameNum === 2) {
			// Right step
			rightStepFrame.alpha = 1;
		}
	};
	// Move farmer towards target
	self.update = function () {
		// Track movement direction and update image
		if (self.moving) {
			var dx = self.targetX - self.x;
			// Check if moving right or left
			if (dx > 0) {
				// Moving right - use player_right asset
				idleFrame.scaleX = 1;
				runningFrame.scaleX = 1;
				rightStepFrame.scaleX = 1;
				// Switch to player_right image
				if (self.currentAsset !== idleFrame || idleFrame.texture !== LK.getAsset('player_right', {}).texture) {
					if (self.currentAsset) {
						self.currentAsset.alpha = 0;
					}
					var rightAsset = LK.getAsset('player_right', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					rightAsset.alpha = 1;
					self.addChild(rightAsset);
					self.currentAsset = rightAsset;
				}
			} else if (dx < 0) {
				// Moving left - use player_left asset
				idleFrame.scaleX = -1;
				runningFrame.scaleX = -1;
				rightStepFrame.scaleX = -1;
				// Switch to player_left image
				if (self.currentAsset !== idleFrame || idleFrame.texture !== LK.getAsset('player_left', {}).texture) {
					if (self.currentAsset) {
						self.currentAsset.alpha = 0;
					}
					var leftAsset = LK.getAsset('player_left', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					leftAsset.alpha = 1;
					self.addChild(leftAsset);
					self.currentAsset = leftAsset;
				}
			}
			// Animation handling
			self.animationTimer++;
			if (self.animationTimer >= self.frameTime) {
				self.animationTimer = 0;
				self.animationFrame = self.animationFrame === 1 ? 2 : 1; // Toggle between frames 1 and 2
				self.switchToFrame(self.animationFrame);
			}
		} else if (!self.moving && self.lastMoving) {
			// Just stopped moving - switch to idle
			self.switchToFrame(0);
		}
		self.lastMoving = self.moving;
		if (!self.moving) return;
		var dx = self.targetX - self.x;
		var dy = self.targetY - self.y;
		var dist = Math.sqrt(dx * dx + dy * dy);
		if (dist < self.speed) {
			self.x = self.targetX;
			self.y = self.targetY;
			self.moving = false;
			// Switch to idle frame when stopping
			self.switchToFrame(0);
		} else {
			self.x += self.speed * dx / dist;
			self.y += self.speed * dy / dist;
		}
	};
	// Set movement target
	self.moveTo = function (x, y) {
		self.targetX = x;
		self.targetY = y;
		// Start movement
		if (!self.moving) {
			self.moving = true;
			self.animationFrame = 1;
			self.animationTimer = 0;
			self.switchToFrame(self.animationFrame);
		}
	};
	return self;
});
// Field class
var Field = Container.expand(function () {
	var self = Container.call(this);
	self.index = 0; // 0-3
	self.locked = false;
	self.lockCost = 0;
	self.lockNode = null;
	self.fenceNodes = [];
	self.wheats = [];
	self.unlockBtn = null;
	// Draw fences - Empty implementation to eliminate fences
	self.drawFences = function (x, y, w, h) {
		self.fenceNodes = [];
		// No fences or gates are created
	};
	// Place wheat
	self.placeWheats = function (x, y, w, h, count) {
		self.wheats = [];
		// Define grid size
		var rows = 5;
		var cols = 10;
		// Choose vegetable asset per area
		var vegAssetId = 'wheat';
		if (self.index === 1) vegAssetId = 'carrot';
		if (self.index === 2) vegAssetId = 'tomato';
		if (self.index === 3) vegAssetId = 'eggplant';
		// Fallback if asset not found, use wheat
		if (!LK.assets || !LK.assets[vegAssetId]) vegAssetId = 'wheat';
		// Calculate asset size for spacing (use wheat size as reference for all)
		var vegAsset = LK.getAsset('wheat', {
			anchorX: 0.5,
			anchorY: 1
		});
		var wheatW = vegAsset.width;
		var wheatH = vegAsset.height;
		// Padding from fences
		var padX = 60;
		var padY = 60;
		// Compute available area for wheat grid
		var gridW = w - 2 * padX;
		var gridH = h - 2 * padY;
		// Compute spacing between wheat plants
		var spacingX = (gridW - wheatW) / (cols - 1);
		var spacingY = (gridH - wheatH) / (rows - 1);
		// Place appropriate vegetable in grid based on field index
		for (var row = 0; row < rows; ++row) {
			for (var col = 0; col < cols; ++col) {
				var wx = x + padX + col * spacingX + wheatW / 2;
				var wy = y + padY + row * spacingY + wheatH;
				var veg;
				// Create appropriate vegetable based on area/field index
				if (self.index === 1) {
					veg = new CarrotSlot();
				} else if (self.index === 2) {
					veg = new TomatoSlot();
				} else if (self.index === 3) {
					veg = new EggplantSlot();
				} else {
					veg = new Wheat();
					veg.fieldIndex = self.index;
					veg.vegAssetId = vegAssetId;
					veg.setVegAsset && veg.setVegAsset(vegAssetId);
				}
				veg.x = wx;
				veg.y = wy;
				self.addChild(veg);
				self.wheats.push(veg);
			}
		}
	};
	// Lock overlay
	self.showLock = function (centerX, centerY) {
		if (self.lockNode) return;
		self.lockNode = LK.getAsset('lock', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: centerX,
			y: centerY
		});
		self.addChild(self.lockNode);
		// Unlock text
		var unlockTxt = new Text2('Unlock\n$' + self.lockCost, {
			size: 60,
			fill: "#fff"
		});
		unlockTxt.anchor.set(0.5, 0.5);
		unlockTxt.x = centerX;
		unlockTxt.y = centerY + 70;
		self.unlockBtn = unlockTxt;
		self.addChild(unlockTxt);
	};
	self.hideLock = function () {
		if (self.lockNode) {
			self.lockNode.destroy();
			self.lockNode = null;
		}
		if (self.unlockBtn) {
			self.unlockBtn.destroy();
			self.unlockBtn = null;
		}
	};
	return self;
});
// ShopButton class for shop functionality
var ShopButton = Container.expand(function () {
	var self = Container.call(this);
	// Create shop button with larger text for better visibility
	var shopBtn = new Text2('Shop', {
		size: 120,
		// Increased text size for mobile
		fill: 0xFFFFFF
	});
	shopBtn.anchor.set(0.5, 0.5);
	self.addChild(shopBtn);
	// Create larger background for shop button (better touch target)
	var btnBg = LK.getAsset('rect', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 280,
		// Wider button for easier mobile tapping
		height: 140,
		// Taller button for easier mobile tapping
		tint: 0x3e8a2e
	});
	self.addChildAt(btnBg, 0);
	// Panel elements
	self.panel = new Container();
	self.panel.visible = false;
	self.panel.x = 1024; // Center horizontally on screen
	self.panel.y = 1366; // Center vertically on screen
	game.addChild(self.panel);
	// Panel background - made larger for mobile
	var panelBg = LK.getAsset('rect', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 1600,
		// Wider panel for mobile
		height: 1800,
		// Taller panel for better mobile spacing
		tint: 0x3e8a2e
	});
	self.panel.addChild(panelBg);
	// Panel title - larger text
	var title = new Text2('Sickle Shop', {
		size: 100,
		// Larger title text for mobile
		fill: 0xFFFFFF
	});
	title.anchor.set(0.5, 0);
	title.y = -800; // Moved up to accommodate larger panel
	self.panel.addChild(title);
	// Close button - larger and more prominent
	var closeBtn = new Text2('X', {
		size: 120,
		// Larger text for mobile visibility
		fill: 0xFFFFFF
	});
	closeBtn.anchor.set(0.5, 0.5);
	closeBtn.x = 700; // Positioned further to the right
	closeBtn.y = -800; // Aligned with title
	self.panel.addChild(closeBtn);
	// Close button background - larger for better touch target
	var closeBtnBg = LK.getAsset('rect', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 140,
		// Larger background for mobile
		height: 140,
		// Larger background for mobile
		tint: 0xff5555,
		// Red color to stand out as close button
		x: 700,
		// Match X position
		y: -800 // Match Y position
	});
	self.panel.addChildAt(closeBtnBg, self.panel.children.indexOf(closeBtn));
	// Sickle items
	var sickleTypes = [{
		name: "Basic Sickle",
		price: 0,
		imageId: 'sickle',
		tint: 0xB8A677
	}, {
		name: "Stone Sickle",
		price: 1000,
		imageId: 'sickle',
		tint: 0x777777
	}, {
		name: "Iron Sickle",
		price: 5000,
		imageId: 'sickle',
		tint: 0xCCCCCC
	}, {
		name: "Gold Sickle",
		price: 20000,
		imageId: 'sickle',
		tint: 0xFFD700
	}, {
		name: "Diamond Sickle",
		price: 50000,
		imageId: 'sickle',
		tint: 0x89CFF0
	}];
	// Create sickle items with more spacing and larger UI elements for mobile
	for (var i = 0; i < sickleTypes.length; i++) {
		var item = sickleTypes[i];
		var y = -500 + i * 220; // Much more vertical spacing for better mobile touch targets
		// Sickle image with tint - larger image
		var sickleImg = LK.getAsset('sickle', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -400,
			// Moved further left for wider panel
			y: y,
			scaleX: 2.0,
			// Much larger for mobile visibility
			scaleY: 2.0,
			// Much larger for mobile visibility
			tint: item.tint || 0xFFFFFF
		});
		self.panel.addChild(sickleImg);
		// Sickle name - larger text
		var nameText = new Text2(item.name, {
			size: 70,
			// Larger text size for mobile
			fill: 0xFFFFFF
		});
		nameText.anchor.set(0, 0.5);
		nameText.x = -280; // Adjusted position
		nameText.y = y;
		self.panel.addChild(nameText);
		// Buy button - larger text
		var buyText = item.price === 0 ? "Owned" : "Buy $" + item.price;
		var buyBtn = new Text2(buyText, {
			size: 70,
			// Larger text size for mobile
			fill: 0xFFFFFF
		});
		buyBtn.anchor.set(0.5, 0.5);
		buyBtn.x = 450; // Moved further right for wider panel
		buyBtn.y = y;
		buyBtn.interactive = true;
		buyBtn.sickleIndex = i;
		buyBtn.price = item.price;
		self.panel.addChild(buyBtn);
		// Buy button background - larger for better touch target on mobile
		var buyBtnBg = LK.getAsset('rect', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 300,
			// Much wider button for mobile
			height: 120,
			// Much taller button for mobile
			tint: item.price === 0 ? 0x888888 : 0x326b23,
			x: 450,
			// Match position with text
			y: y
		});
		self.panel.addChildAt(buyBtnBg, self.panel.children.indexOf(buyBtn));
	}
	// Toggle panel visibility
	self.togglePanel = function () {
		self.panel.visible = !self.panel.visible;
	};
	// Event handlers
	self.down = function (x, y, obj) {
		// Convert event coordinates to local position relative to button
		var localPos = self.toLocal({
			x: x,
			y: y
		});
		// Check if clicking the shop button itself (before the panel is visible)
		if (!self.panel.visible) {
			// If panel is not visible, show it
			self.panel.visible = true;
			return;
		}
		// Get the game coordinates for the panel
		var panelPos = self.panel.toGlobal({
			x: 0,
			y: 0
		});
		// The close button is at (550, -400) relative to panel center
		var closeX = panelPos.x + 550;
		var closeY = panelPos.y - 400;
		// Increase hit area for close button to make it more mobile-friendly
		var closeButtonHitRadius = 80; // Larger hit area for easier tapping
		// Check if clicking close button (X) with appropriate hit area
		if (Math.abs(x - closeX) < closeButtonHitRadius && Math.abs(y - closeY) < closeButtonHitRadius) {
			self.panel.visible = false; // Close the panel
			return;
		}
		// Check if clicking on sickle items or buy buttons
		for (var i = 0; i < sickleTypes.length; i++) {
			var yBtn = -250 + i * 130; // Match the new vertical spacing in the panel
			var itemY = panelPos.y + yBtn;
			// Increase hit area height for better touch target
			var rowHitHeight = 60; // Bigger hit area height for touch
			// Check entire row (sickle + name + buy button) area
			if (y >= itemY - rowHitHeight && y <= itemY + rowHitHeight) {
				// If the item is owned (price is 0), select and use it
				if (sickleTypes[i].price === 0) {
					self.displaySickle(i);
					// Show green flash to indicate selection
					LK.effects.flashScreen(0x00ff00, 200);
					self.panel.visible = false; // Close panel after selection
				} else if (Math.abs(x - (panelPos.x + 350)) < 100) {
					// Updated buy button position and hit area
					// Wider hit area for buy button
					// Otherwise, if clicking on buy button, try to buy it
					self.onBuy(i, sickleTypes[i].price);
				}
				return;
			}
		}
	};
	// Display current sickle
	self.displaySickle = function (index) {
		if (index >= 0 && index < sickleTypes.length) {
			// Apply sickle customization to player's sickle
			if (sickle) {
				// Remove old sickle
				farmer.removeChild(sickle);
				// Create new sickle with custom tint
				sickle = LK.getAsset(sickleTypes[index].imageId, {
					anchorX: 0.2,
					anchorY: 0.7,
					x: 0,
					y: 30,
					tint: sickleTypes[index].tint
				});
				farmer.addChild(sickle);
			}
		}
	};
	// Buy sickle handler
	self.onBuy = function (index, price) {
		// Skip if already owned (price 0)
		if (price === 0) return;
		// Check if player has enough money
		if (money >= price) {
			// Subtract money
			money -= price;
			updateMoneyDisplay();
			// Update button to "Owned"
			var btnCount = 0;
			for (var c = 0; c < self.panel.children.length; c++) {
				var child = self.panel.children[c];
				if (child && child.setText && child.text && (child.text.indexOf("Buy") === 0 || child.text === "Owned")) {
					if (btnCount === index) {
						child.setText("Owned");
						// Update button background
						// The background is always just before the button in children
						if (c > 0 && self.panel.children[c - 1] && self.panel.children[c - 1].tint !== undefined) {
							self.panel.children[c - 1].tint = 0x888888;
						}
						break;
					}
					btnCount++;
				}
			}
			// Set price to 0 (owned)
			sickleTypes[index].price = 0;
			// Apply sickle customization to player's sickle
			if (sickle) {
				// Remove old sickle
				farmer.removeChild(sickle);
				// Create new sickle with custom tint
				sickle = LK.getAsset(sickleTypes[index].imageId, {
					anchorX: 0.2,
					anchorY: 0.7,
					x: 0,
					y: 30,
					tint: sickleTypes[index].tint
				});
				farmer.addChild(sickle);
			}
			// Flash screen green for successful purchase
			LK.effects.flashScreen(0x00ff00, 300);
			// Close shop panel immediately after purchase
			self.panel.visible = false;
		} else {
			// Not enough money, flash red
			LK.effects.flashScreen(0xff0000, 300);
		}
	};
	return self;
});
// TomatoSlot class for area 3
var TomatoSlot = Container.expand(function () {
	var self = Container.call(this);
	self.slotAsset = self.attachAsset('tomato', {
		anchorX: 0.5,
		anchorY: 1
	});
	var sproutAsset = self.attachAsset('sprout', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.harvested = false;
	self.regrowTime = 1800; // 30 seconds at 60fps
	self.regrowCounter = 0;
	self.fieldIndex = 2; // Area 3
	self.regrowing = false;
	// Show/hide tomato and handle regrow animation
	self.setHarvested = function (harvested) {
		self.harvested = harvested;
		if (harvested) {
			// Hide tomato with animation
			tween(self.slotAsset, {
				alpha: 0,
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			// Show sprout with animation
			sproutAsset.alpha = 1;
			sproutAsset.scaleX = 0.1;
			sproutAsset.scaleY = 0.1;
			// Animate sprout appearing
			tween(sproutAsset, {
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			self.regrowCounter = self.regrowTime;
			self.regrowing = true;
		} else {
			// Show tomato with animation
			tween(self.slotAsset, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			// Hide sprout with animation
			tween(sproutAsset, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			self.regrowing = false;
		}
	};
	// Regrow logic
	self.update = function () {
		if (self.harvested && self.regrowing) {
			if (self.regrowCounter > 0) {
				// Animate sprout growing to tomato size
				var t = 1 - self.regrowCounter / self.regrowTime;
				sproutAsset.scaleX = 0.5 + 0.5 * t;
				sproutAsset.scaleY = 0.5 + 0.5 * t;
				self.regrowCounter--;
			}
			if (self.regrowCounter <= 0) {
				// Sprout is now full size, switch back to tomato and allow harvest again
				sproutAsset.scaleX = 1;
				sproutAsset.scaleY = 1;
				self.setHarvested(false);
			}
		}
	};
	// For hit detection
	self.isHarvestable = function () {
		return !self.harvested;
	};
	return self;
});
// Wheat class
var Wheat = Container.expand(function () {
	var self = Container.call(this);
	self.vegAssetId = 'wheat';
	self.wheatAsset = self.attachAsset('wheat', {
		anchorX: 0.5,
		anchorY: 1
	});
	var sproutAsset = self.attachAsset('sprout', {
		anchorX: 0.5,
		anchorY: 1,
		alpha: 0,
		scaleX: 0.5,
		scaleY: 0.5
	});
	self.harvested = false;
	self.regrowTime = 1800; // 30 seconds at 60fps
	self.regrowCounter = 0;
	self.fieldIndex = 0; // which field this wheat belongs to
	self.regrowing = false;
	self.removeAfter = 0;
	// Change vegetable asset if needed
	self.setVegAsset = function (assetId) {
		if (self.wheatAsset) {
			self.wheatAsset.destroy();
		}
		self.vegAssetId = assetId || 'wheat';
		// Only allow wheat, carrot, tomato, eggplant
		var validAssets = {
			wheat: 1,
			carrot: 1,
			tomato: 1,
			eggplant: 1
		};
		if (!validAssets[self.vegAssetId]) self.vegAssetId = 'wheat';
		self.wheatAsset = self.attachAsset(self.vegAssetId, {
			anchorX: 0.5,
			anchorY: 1
		});
		// Make sure sprout is on top
		self.removeChild(sproutAsset);
		self.addChild(sproutAsset);
	};
	// Show/hide wheat and handle regrow animation
	self.setHarvested = function (harvested) {
		self.harvested = harvested;
		if (harvested) {
			// Hide wheat, show sprout
			if (self.wheatAsset) {
				// Animate wheat harvesting with tween
				tween(self.wheatAsset, {
					alpha: 0,
					scaleX: 0.5,
					scaleY: 0.5
				}, {
					duration: 300,
					easing: tween.easeOut
				});
			}
			// Show and animate sprout growing from nothing
			sproutAsset.alpha = 1;
			sproutAsset.scaleX = 0.1;
			sproutAsset.scaleY = 0.1;
			// Animate sprout appearing
			tween(sproutAsset, {
				scaleX: 0.5,
				scaleY: 0.5
			}, {
				duration: 300,
				easing: tween.easeOut
			});
			self.regrowCounter = self.regrowTime;
			self.regrowing = true;
		} else {
			// Show wheat/veg, hide sprout with animation
			if (self.wheatAsset) {
				tween(self.wheatAsset, {
					alpha: 1,
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 300,
					easing: tween.easeIn
				});
			}
			// Fade out sprout
			tween(sproutAsset, {
				alpha: 0
			}, {
				duration: 300,
				easing: tween.easeIn
			});
			self.regrowing = false;
		}
	};
	// Regrow logic and removal after 5 seconds
	self.update = function () {
		if (self.harvested && self.regrowing) {
			if (self.regrowCounter > 0) {
				// Animate sprout growing to wheat/veg size
				var t = 1 - self.regrowCounter / self.regrowTime;
				sproutAsset.scaleX = 0.5 + 0.5 * t;
				sproutAsset.scaleY = 0.5 + 0.5 * t;
				self.regrowCounter--;
			}
			if (self.regrowCounter <= 0) {
				// Sprout is now full size, switch back to wheat/veg and allow harvest again
				sproutAsset.scaleX = 1;
				sproutAsset.scaleY = 1;
				self.setHarvested(false);
			}
		}
	};
	// For hit detection
	self.isHarvestable = function () {
		return !self.harvested;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Area 4
// Area 3
// Area 2
// Lock icon (ellipse, gray)
// Sickle (ellipse, yellow)
// House (box)
// Farmer (box)
// Wheat (ellipse)
// Field fence (rectangle)
// --- Game constants ---
var FIELD_W = 900;
var FIELD_H = 900;
var FIELD_GAP = 120; // Increased gap to move fences further from center
var FIELD_COUNT = 4;
var WHEAT_PER_FIELD = 10;
// Area unlock prices and reward multipliers
var FIELD_LOCK_COSTS = [0, 20000, 40000, 60000]; // Area 1 open, others locked
var FIELD_REWARD_MULT = [1, 2, 3, 4]; // Area 1=1x, 2=2x, 3=3x, 4=4x
// --- Area constants ---
// Define the distance from center for all areas (equal distance)
var AREA_DISTANCE = 600;
// Create an array to hold the areas
var areas = [];
var animals = [];
// --- Game state ---
var fields = [];
var farmer = null;
var money = 0;
var moneyTxt = null;
var sickle = null;
var dragging = false;
var dragOffsetX = 0;
var dragOffsetY = 0;
var unlockFieldIndex = -1;
// --- Layout calculation ---
// Fields: 2x2 grid, with house in center
// [0][1]
// [2][3]
var fieldPositions = [{
	x: 0,
	y: 0
},
// top-left
{
	x: FIELD_W + FIELD_GAP,
	y: 0
},
// top-right
{
	x: 0,
	y: FIELD_H + FIELD_GAP
},
// bottom-left
{
	x: FIELD_W + FIELD_GAP,
	y: FIELD_H + FIELD_GAP
} // bottom-right
];
// Center everything in game area
var totalW = FIELD_W * 2 + FIELD_GAP;
var totalH = FIELD_H * 2 + FIELD_GAP;
var offsetX = Math.floor((2048 - totalW) / 2);
var offsetY = Math.floor((2732 - totalH) / 2);
// --- Create fields ---
for (var i = 0; i < FIELD_COUNT; ++i) {
	var f = new Field();
	f.index = i;
	f.locked = FIELD_LOCK_COSTS[i] > 0;
	f.lockCost = FIELD_LOCK_COSTS[i];
	var pos = fieldPositions[i];
	var fx = offsetX + pos.x;
	var fy = offsetY + pos.y;
	// Skip drawing fences
	f.placeWheats(fx, fy, FIELD_W, FIELD_H, WHEAT_PER_FIELD);
	if (f.locked) {
		// Center of field
		f.showLock(fx + FIELD_W / 2, fy + FIELD_H / 2);
	}
	game.addChild(f);
	fields.push(f);
}
// Center reference point for positions
var centerX = offsetX + FIELD_W;
var centerY = offsetY + FIELD_H - 250;
// --- Create farmer ---
farmer = new Farmer();
farmer.x = centerX;
farmer.y = centerY - 120; // Start at center area
game.addChild(farmer);
// --- Create sickle (attached to farmer's hand) ---
sickle = LK.getAsset('sickle', {
	anchorX: 0.2,
	// hand position, left side of ellipse
	anchorY: 0.7,
	// slightly below center
	x: 0,
	y: 30
});
sickle.alpha = 1;
farmer.addChild(sickle);
// --- Money display ---
moneyTxt = new Text2('$0', {
	size: 100,
	fill: "#fff"
});
moneyTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(moneyTxt);
// --- Helper: update money display ---
function updateMoneyDisplay() {
	moneyTxt.setText('$' + money);
}
// --- Helper: unlock field if enough money ---
function tryUnlockField(fieldIdx) {
	var f = fields[fieldIdx];
	if (!f.locked) return;
	if (money >= f.lockCost) {
		money -= f.lockCost;
		updateMoneyDisplay();
		f.locked = false;
		f.hideLock();
		// Flash field green
		for (var i = 0; i < f.fenceNodes.length; ++i) {
			LK.effects.flashObject(f.fenceNodes[i], 0x00ff00, 600);
		}
	} else {
		// Not enough money, flash red
		LK.effects.flashScreen(0xff0000, 400);
	}
}
// --- Touch/mouse handling ---
var lastDownX = 0,
	lastDownY = 0;
var harvestMode = false;
var harvestWheat = null;
// Helper: find harvestable vegetable under (x, y) in unlocked fields
function findHarvestableWheat(x, y) {
	for (var i = 0; i < fields.length; ++i) {
		var f = fields[i];
		if (f.locked) continue;
		for (var j = 0; j < f.wheats.length; ++j) {
			var w = f.wheats[j];
			if (w.isHarvestable()) {
				// Use bounding box for hit
				var wx = w.x,
					wy = w.y;
				var ww = 60,
					wh = 80;
				if (x >= wx - ww / 2 && x <= wx + ww / 2 && y >= wy - wh && y <= wy) {
					return w;
				}
			}
		}
	}
	return null;
}
// Helper: find locked field under (x, y)
function findLockedField(x, y) {
	for (var i = 0; i < fields.length; ++i) {
		var f = fields[i];
		if (!f.locked) continue;
		// Use field area
		var pos = fieldPositions[i];
		var fx = offsetX + pos.x;
		var fy = offsetY + pos.y;
		if (x >= fx && x <= fx + FIELD_W && y >= fy && y <= fy + FIELD_H) {
			return i;
		}
	}
	return -1;
}
// --- Game event handlers ---
// Move farmer or harvest wheat
game.down = function (x, y, obj) {
	lastDownX = x;
	lastDownY = y;
	// Check if tapping on locked field unlock button
	var lockedIdx = findLockedField(x, y);
	if (lockedIdx >= 0) {
		var f = fields[lockedIdx];
		// If tap is near lock icon or unlock text
		var centerX = offsetX + fieldPositions[lockedIdx].x + FIELD_W / 2;
		var centerY = offsetY + fieldPositions[lockedIdx].y + FIELD_H / 2;
		var dist = Math.sqrt((x - centerX) * (x - centerX) + (y - centerY) * (y - centerY));
		if (dist < 120) {
			tryUnlockField(lockedIdx);
			return;
		}
	}
	// Check for wheat
	var w = findHarvestableWheat(x, y);
	if (w) {
		harvestMode = true;
		harvestWheat = w;
		// Change player to face forward during harvest
		// Switch to player_down for harvesting
		if (farmer.currentAsset) {
			farmer.currentAsset.alpha = 0;
		}
		var playerDown = LK.getAsset('player_down', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		playerDown.alpha = 1;
		farmer.addChild(playerDown);
		farmer.currentAsset = playerDown;
		// Animate sickle (in farmer's hand)
		tween(sickle, {
			rotation: Math.PI * 2
		}, {
			duration: 300,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				sickle.rotation = 0;
				// Show harvest animation effect
				var harvestEffect = LK.getAsset('sprout', {
					anchorX: 0.5,
					anchorY: 0.5,
					x: w.x,
					y: w.y - 50,
					alpha: 0.8,
					scaleX: 2,
					scaleY: 2
				});
				game.addChild(harvestEffect);
				// Animate the harvest effect
				tween(harvestEffect, {
					alpha: 0,
					y: harvestEffect.y - 100
				}, {
					duration: 500,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						harvestEffect.destroy();
					}
				});
			}
		});
		// Harvest
		w.setHarvested(true);
		var reward = 100 * (FIELD_REWARD_MULT[w.fieldIndex] || 1);
		money += reward;
		updateMoneyDisplay();
		// Flash wheat
		LK.effects.flashObject(w, 0xffff00, 300);
		// No setHarvested(false) here; regrow/removal handled in Wheat.update
		harvestMode = false;
		harvestWheat = null;
		return;
	}
	// Move farmer with animation
	farmer.moveTo(x, y);
	dragging = true;
	dragOffsetX = x - farmer.x;
	dragOffsetY = y - farmer.y;
};
// Drag farmer
game.move = function (x, y, obj) {
	if (dragging) {
		farmer.moveTo(x - dragOffsetX, y - dragOffsetY);
	}
	if (harvestMode && harvestWheat) {
		sickle.x = x;
		sickle.y = y;
	}
};
// End drag/harvest
game.up = function (x, y, obj) {
	dragging = false;
	harvestMode = false;
	harvestWheat = null;
};
// --- Main update loop ---
game.update = function () {
	// Update farmer
	farmer.update();
	// Update wheat regrow
	for (var i = 0; i < fields.length; ++i) {
		var f = fields[i];
		for (var j = 0; j < f.wheats.length; ++j) {
			f.wheats[j].update();
		}
	}
};
// --- Create areas and place animals ---
// Calculate center of game screen
var gameWidth = 2048;
var gameHeight = 2732;
var gameCenterX = gameWidth / 2;
var gameCenterY = gameHeight / 2;
// Create the four areas at equal distances from center
// Area_Left
var areaLeft = new Container();
areaLeft.x = gameCenterX - AREA_DISTANCE;
areaLeft.y = gameCenterY;
areaLeft.name = "Area_Left";
game.addChild(areaLeft);
areas.push(areaLeft);
// Area_Right
var areaRight = new Container();
areaRight.x = gameCenterX + AREA_DISTANCE;
areaRight.y = gameCenterY;
areaRight.name = "Area_Right";
game.addChild(areaRight);
areas.push(areaRight);
// Area_Top
var areaTop = new Container();
areaTop.x = gameCenterX;
areaTop.y = gameCenterY - AREA_DISTANCE;
areaTop.name = "Area_Top";
game.addChild(areaTop);
areas.push(areaTop);
// Area_Bottom
var areaBottom = new Container();
areaBottom.x = gameCenterX;
areaBottom.y = gameCenterY + AREA_DISTANCE;
areaBottom.name = "Area_Bottom";
game.addChild(areaBottom);
areas.push(areaBottom);
// Place animals in the areas
// Animal_Right at right edge of screen, centered vertically
var animalRight = new Animal();
animalRight.setAnimalImage('animal_right');
animalRight.name = "Animal_Right";
animalRight.x = gameWidth; // Position at right edge
animalRight.y = gameCenterY; // Center vertically
game.addChild(animalRight); // Add directly to game instead of areaRight
animals.push(animalRight);
// Area_Bottom has no animal
// --- Create shop button ---
var shopButton = new ShopButton();
shopButton.x = 2048 - 150; // Position on right side of screen with spacing from edge
shopButton.y = gameCenterY; // Position at vertical center
game.addChild(shopButton);
// --- Initial money display ---
updateMoneyDisplay();
// --- Place trees at corners ---
// Tree size
var treeWidth = 400;
var treeHeight = 532;
// Top left corner tree
var topLeftTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: offsetX / 2,
	y: offsetY / 2
});
game.addChild(topLeftTree);
// Top right corner tree
var topRightTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 - offsetX / 2,
	y: offsetY / 2
});
game.addChild(topRightTree);
// Bottom left corner tree
var bottomLeftTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: offsetX / 2,
	y: 2732 - offsetY / 2
});
game.addChild(bottomLeftTree);
// Bottom right corner tree
var bottomRightTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 - offsetX / 2,
	y: 2732 - offsetY / 2
});
game.addChild(bottomRightTree);
// --- Place trees at middle sides aligned with corner trees ---
// Tree to the left of center
var leftCenterTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: offsetX / 2,
	y: topRightTree.y
});
game.addChild(leftCenterTree);
// Tree to the right of center
var rightCenterTree = LK.getAsset('tree', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 2048 - offsetX / 2,
	y: topRightTree.y
});
game.addChild(rightCenterTree);

===================================================================
--- original.js
+++ change.js
@@ -437,22 +437,22 @@
 var ShopButton = Container.expand(function () {
 	var self = Container.call(this);
 	// Create shop button with larger text for better visibility
 	var shopBtn = new Text2('Shop', {
-		size: 90,
-		// Increased text size
+		size: 120,
+		// Increased text size for mobile
 		fill: 0xFFFFFF
 	});
 	shopBtn.anchor.set(0.5, 0.5);
 	self.addChild(shopBtn);
 	// Create larger background for shop button (better touch target)
 	var btnBg = LK.getAsset('rect', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		width: 240,
-		// Wider button
-		height: 120,
-		// Taller button
+		width: 280,
+		// Wider button for easier mobile tapping
+		height: 140,
+		// Taller button for easier mobile tapping
 		tint: 0x3e8a2e
 	});
 	self.addChildAt(btnBg, 0);
 	// Panel elements
@@ -460,51 +460,51 @@
 	self.panel.visible = false;
 	self.panel.x = 1024; // Center horizontally on screen
 	self.panel.y = 1366; // Center vertically on screen
 	game.addChild(self.panel);
-	// Panel background - made slightly larger for mobile
+	// Panel background - made larger for mobile
 	var panelBg = LK.getAsset('rect', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		width: 1200,
-		// Wider panel
-		height: 1000,
-		// Taller panel for better spacing
+		width: 1600,
+		// Wider panel for mobile
+		height: 1800,
+		// Taller panel for better mobile spacing
 		tint: 0x3e8a2e
 	});
 	self.panel.addChild(panelBg);
 	// Panel title - larger text
 	var title = new Text2('Sickle Shop', {
-		size: 80,
-		// Larger title text
+		size: 100,
+		// Larger title text for mobile
 		fill: 0xFFFFFF
 	});
 	title.anchor.set(0.5, 0);
-	title.y = -400; // Moved up to accommodate larger panel
+	title.y = -800; // Moved up to accommodate larger panel
 	self.panel.addChild(title);
 	// Close button - larger and more prominent
 	var closeBtn = new Text2('X', {
-		size: 80,
-		// Larger text for visibility
+		size: 120,
+		// Larger text for mobile visibility
 		fill: 0xFFFFFF
 	});
 	closeBtn.anchor.set(0.5, 0.5);
-	closeBtn.x = 550; // Positioned further to the right
-	closeBtn.y = -400; // Aligned with title
+	closeBtn.x = 700; // Positioned further to the right
+	closeBtn.y = -800; // Aligned with title
 	self.panel.addChild(closeBtn);
 	// Close button background - larger for better touch target
 	var closeBtnBg = LK.getAsset('rect', {
 		anchorX: 0.5,
 		anchorY: 0.5,
-		width: 80,
-		// Larger background
-		height: 80,
-		// Larger background
-		tint: 0x326b23,
-		// Darker green to stand out
-		x: 550,
+		width: 140,
+		// Larger background for mobile
+		height: 140,
+		// Larger background for mobile
+		tint: 0xff5555,
+		// Red color to stand out as close button
+		x: 700,
 		// Match X position
-		y: -400 // Match Y position
+		y: -800 // Match Y position
 	});
 	self.panel.addChildAt(closeBtnBg, self.panel.children.indexOf(closeBtn));
 	// Sickle items
 	var sickleTypes = [{
@@ -532,60 +532,60 @@
 		price: 50000,
 		imageId: 'sickle',
 		tint: 0x89CFF0
 	}];
-	// Create sickle items with more spacing and larger UI elements
+	// Create sickle items with more spacing and larger UI elements for mobile
 	for (var i = 0; i < sickleTypes.length; i++) {
 		var item = sickleTypes[i];
-		var y = -250 + i * 130; // Increased vertical spacing for better touch targets
+		var y = -500 + i * 220; // Much more vertical spacing for better mobile touch targets
 		// Sickle image with tint - larger image
 		var sickleImg = LK.getAsset('sickle', {
 			anchorX: 0.5,
 			anchorY: 0.5,
-			x: -300,
-			// Moved further left
+			x: -400,
+			// Moved further left for wider panel
 			y: y,
-			scaleX: 1.2,
-			// Slightly larger
-			scaleY: 1.2,
-			// Slightly larger
+			scaleX: 2.0,
+			// Much larger for mobile visibility
+			scaleY: 2.0,
+			// Much larger for mobile visibility
 			tint: item.tint || 0xFFFFFF
 		});
 		self.panel.addChild(sickleImg);
 		// Sickle name - larger text
 		var nameText = new Text2(item.name, {
-			size: 50,
-			// Larger text size
+			size: 70,
+			// Larger text size for mobile
 			fill: 0xFFFFFF
 		});
 		nameText.anchor.set(0, 0.5);
-		nameText.x = -230; // Adjusted position
+		nameText.x = -280; // Adjusted position
 		nameText.y = y;
 		self.panel.addChild(nameText);
 		// Buy button - larger text
 		var buyText = item.price === 0 ? "Owned" : "Buy $" + item.price;
 		var buyBtn = new Text2(buyText, {
-			size: 50,
-			// Larger text size
+			size: 70,
+			// Larger text size for mobile
 			fill: 0xFFFFFF
 		});
 		buyBtn.anchor.set(0.5, 0.5);
-		buyBtn.x = 350; // Moved further right
+		buyBtn.x = 450; // Moved further right for wider panel
 		buyBtn.y = y;
 		buyBtn.interactive = true;
 		buyBtn.sickleIndex = i;
 		buyBtn.price = item.price;
 		self.panel.addChild(buyBtn);
-		// Buy button background - larger for better touch target
+		// Buy button background - larger for better touch target on mobile
 		var buyBtnBg = LK.getAsset('rect', {
 			anchorX: 0.5,
 			anchorY: 0.5,
-			width: 200,
-			// Wider button
-			height: 80,
-			// Taller button
+			width: 300,
+			// Much wider button for mobile
+			height: 120,
+			// Much taller button for mobile
 			tint: item.price === 0 ? 0x888888 : 0x326b23,
-			x: 350,
+			x: 450,
 			// Match position with text
 			y: y
 		});
 		self.panel.addChildAt(buyBtnBg, self.panel.children.indexOf(buyBtn));
@@ -611,33 +611,34 @@
 		var panelPos = self.panel.toGlobal({
 			x: 0,
 			y: 0
 		});
-		// The close button is at (450, -300) relative to panel center
-		var closeX = panelPos.x + 450;
-		var closeY = panelPos.y - 300;
+		// The close button is at (550, -400) relative to panel center
+		var closeX = panelPos.x + 550;
+		var closeY = panelPos.y - 400;
 		// Increase hit area for close button to make it more mobile-friendly
-		var closeButtonHitRadius = 40; // Larger hit area for easier tapping
+		var closeButtonHitRadius = 80; // Larger hit area for easier tapping
 		// Check if clicking close button (X) with appropriate hit area
 		if (Math.abs(x - closeX) < closeButtonHitRadius && Math.abs(y - closeY) < closeButtonHitRadius) {
 			self.panel.visible = false; // Close the panel
 			return;
 		}
 		// Check if clicking on sickle items or buy buttons
 		for (var i = 0; i < sickleTypes.length; i++) {
-			var yBtn = -200 + i * 100;
+			var yBtn = -250 + i * 130; // Match the new vertical spacing in the panel
 			var itemY = panelPos.y + yBtn;
 			// Increase hit area height for better touch target
-			var rowHitHeight = 40; // Bigger hit area height for touch
+			var rowHitHeight = 60; // Bigger hit area height for touch
 			// Check entire row (sickle + name + buy button) area
 			if (y >= itemY - rowHitHeight && y <= itemY + rowHitHeight) {
 				// If the item is owned (price is 0), select and use it
 				if (sickleTypes[i].price === 0) {
 					self.displaySickle(i);
 					// Show green flash to indicate selection
 					LK.effects.flashScreen(0x00ff00, 200);
 					self.panel.visible = false; // Close panel after selection
-				} else if (Math.abs(x - (panelPos.x + 250)) < 90) {
+				} else if (Math.abs(x - (panelPos.x + 350)) < 100) {
+					// Updated buy button position and hit area
 					// Wider hit area for buy button
 					// Otherwise, if clicking on buy button, try to buy it
 					self.onBuy(i, sickleTypes[i].price);
 				}
@@ -707,9 +708,9 @@
 				farmer.addChild(sickle);
 			}
 			// Flash screen green for successful purchase
 			LK.effects.flashScreen(0x00ff00, 300);
-			// Close shop panel after purchase - this ensures the panel closes automatically
+			// Close shop panel immediately after purchase
 			self.panel.visible = false;
 		} else {
 			// Not enough money, flash red
 			LK.effects.flashScreen(0xff0000, 300);