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

/**** 
* Classes
****/ 
// CookArea: Cooks raw corn, can be tapped to cook, then send to order area
var CookArea = Container.expand(function () {
	var self = Container.call(this);
	self.rawCorn = 0;
	self.cookedCorn = 0;
	// Cooked corn icon
	var cookedAsset = self.attachAsset('cooked', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	cookedAsset.width = 120;
	cookedAsset.height = 120;
	// Texts
	var rawTxt = new Text2('0', {
		size: 60,
		fill: "#fff"
	});
	rawTxt.anchor.set(0.5, 0.2);
	self.addChild(rawTxt);
	// cookedTxt removed: cooked corn count text is not shown on 2nd screen
	self.addRawCorn = function (n) {
		self.rawCorn += n;
		rawTxt.setText(self.rawCorn);
	};
	self.removeRawCorn = function (n) {
		if (self.rawCorn >= n) {
			self.rawCorn -= n;
			rawTxt.setText(self.rawCorn);
			return true;
		}
		return false;
	};
	self.addCookedCorn = function (n) {
		self.cookedCorn += n;
		// cookedTxt.setText(self.cookedCorn); // removed
		cookedAsset.alpha = 1;
		LK.effects.flashObject(cookedAsset, 0xffb347, 200);
	};
	self.removeCookedCorn = function (n) {
		if (self.cookedCorn >= n) {
			self.cookedCorn -= n;
			// cookedTxt.setText(self.cookedCorn); // removed
			if (self.cookedCorn === 0) cookedAsset.alpha = 0;
			return true;
		}
		return false;
	};
	self.down = function (x, y, obj) {
		if (self.rawCorn > 0) {
			// Cook one corn (takes time)
			self.removeRawCorn(1);
			LK.setTimeout(function () {
				self.addCookedCorn(1);
			}, game.cookTime);
		} else if (self.cookedCorn > 0) {
			// Send cooked corn to order area
			var globalCook = self.toGlobal({
				x: 0,
				y: 0
			});
			var orderPos = game.cookArea.getGlobalCenter();
			var flyingCorn = LK.getAsset('cooked', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: globalCook.x,
				y: globalCook.y,
				width: 100,
				height: 100
			});
			game.addChild(flyingCorn);
			tween(flyingCorn, {
				x: orderPos.x,
				y: orderPos.y,
				alpha: 0.2
			}, {
				duration: 500,
				easing: tween.cubicOut,
				onFinish: function onFinish() {
					flyingCorn.destroy();
					if (self.removeCookedCorn(1)) {
						game.orderArea.addCorn(1);
					}
				}
			});
		}
	};
	self.getGlobalCenter = function () {
		var pos = self.toGlobal({
			x: 0,
			y: 0
		});
		return {
			x: pos.x,
			y: pos.y
		};
	};
	self.reset = function () {
		self.rawCorn = 0;
		self.cookedCorn = 0;
		rawTxt.setText('0');
		// cookedTxt.setText('0'); // removed
		cookedAsset.alpha = 0;
	};
	// Add containsPoint method to CookArea
	self.containsPoint = function (point) {
		// Convert global point to local coordinates of the CookArea
		var localX = point.x - self.x;
		var localY = point.y - self.y;
		// cookAsset is removed, so use cookedAsset for bounds
		var w = cookedAsset.width;
		var h = cookedAsset.height;
		// Check if localX, localY is inside cookedAsset bounds
		return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
	};
	return self;
});
// CornBox: Stores harvested corn, can be tapped to send to cook area
var CornBox = Container.expand(function () {
	var self = Container.call(this);
	var boxAsset = self.attachAsset('box', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	boxAsset.width = 220;
	boxAsset.height = 220;
	self.cornCount = 0;
	// Corn count text
	var cornTxt = new Text2('0', {
		size: 80,
		fill: 0xFFF700
	});
	cornTxt.anchor.set(0.5, 0.5);
	self.addChild(cornTxt);
	self.addCorn = function (n) {
		self.cornCount += n;
		cornTxt.setText(self.cornCount);
		LK.effects.flashObject(boxAsset, 0xffff00, 200);
	};
	self.removeCorn = function (n) {
		if (self.cornCount >= n) {
			self.cornCount -= n;
			cornTxt.setText(self.cornCount);
			return true;
		}
		return false;
	};
	self.down = function (x, y, obj) {
		if (self.cornCount > 0) {
			// Animate corn to cook area
			var globalBox = self.toGlobal({
				x: 0,
				y: 0
			});
			var cookPos = game.cookArea.getGlobalCenter();
			var flyingCorn = LK.getAsset('corn', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: globalBox.x,
				y: globalBox.y,
				width: 100,
				height: 100
			});
			game.addChild(flyingCorn);
			tween(flyingCorn, {
				x: cookPos.x,
				y: cookPos.y,
				alpha: 0.2
			}, {
				duration: 500,
				easing: tween.cubicOut,
				onFinish: function onFinish() {
					flyingCorn.destroy();
					if (self.removeCorn(1)) {
						game.cookArea.addRawCorn(1);
					}
				}
			});
		}
	};
	self.getGlobalCenter = function () {
		var pos = self.toGlobal({
			x: 0,
			y: 0
		});
		return {
			x: pos.x,
			y: pos.y
		};
	};
	self.reset = function () {
		self.cornCount = 0;
		cornTxt.setText('0');
	};
	// Add containsPoint method to CornBox
	self.containsPoint = function (point) {
		// Convert global point to local coordinates of the CornBox
		var localX = point.x - self.x;
		var localY = point.y - self.y;
		// boxAsset is centered at (0,0) with anchor 0.5,0.5
		var w = boxAsset.width;
		var h = boxAsset.height;
		// Check if localX, localY is inside boxAsset bounds
		return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
	};
	return self;
});
// CornField: Represents a single field where corn can be planted, grown, and harvested
var CornField = Container.expand(function () {
	var self = Container.call(this);
	// States: 'empty', 'growing', 'ready'
	self.state = 'empty';
	self.index = 0; // set by game
	self.cornType = null; // for future upgrades
	// Field asset
	var fieldAsset = self.attachAsset('field', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	fieldAsset.width = 320;
	fieldAsset.height = 320;
	// Corn asset (hidden unless growing/ready)
	var cornAsset = self.attachAsset('corn', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	cornAsset.width = 180;
	cornAsset.height = 180;
	// Grow time/ready text above corn
	var growTxt = new Text2('', {
		size: 60,
		fill: "#fff"
	});
	growTxt.anchor.set(0.5, 1);
	growTxt.x = 0;
	growTxt.y = -120;
	self.addChild(growTxt);
	// Cooldown text above field (for replant cooldown)
	var cooldownTxt = new Text2('', {
		size: 60,
		fill: 0xFF4444
	});
	cooldownTxt.anchor.set(0.5, 1);
	cooldownTxt.x = 0;
	cooldownTxt.y = -180;
	self.addChild(cooldownTxt);
	// Track grow start time for countdown
	self._growStart = null;
	self._growEnd = null;
	// Show field as locked if not unlocked
	var lockAsset = self.attachAsset('lock', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	lockAsset.width = 120;
	lockAsset.height = 120;
	// Track how many times this field has been planted
	self.plantCount = 0;
	// Plant corn if field is empty
	self.down = function (x, y, obj) {
		if (self.state === 'empty' && !self.locked) {
			if (self._replantCooldown) {
				// Show cooldown visually
				LK.effects.flashObject(fieldAsset, 0xff0000, 200);
				return;
			}
			// Only allow planting if there are seeds left
			if (typeof game.seeds === "undefined" || game.seeds <= 0) {
				LK.effects.flashObject(fieldAsset, 0xff0000, 300);
				return;
			}
			// Decrement seed count and update display
			game.seeds--;
			if (typeof game.updateSeeds === "function") game.updateSeeds();
			self.plant();
		} else if (self.locked) {
			// Try to unlock if enough coins
			if (game.coins >= game.unlockCost) {
				game.coins -= game.unlockCost;
				self.unlock();
				game.updateCoins();
			} else {
				LK.effects.flashObject(lockAsset, 0xff0000, 500);
			}
		} else if (self.state === 'ready') {
			self.harvest();
		}
	};
	self.plant = function () {
		self.state = 'growing';
		cornAsset.alpha = 1;
		cornAsset.scaleX = 0.5;
		cornAsset.scaleY = 0.5;
		tween(cornAsset, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 400,
			easing: tween.easeOut
		});
		// Calculate grow time: 5s for first, +1s for each subsequent plant
		if (typeof self.plantCount !== "number") self.plantCount = 0;
		var growTime = 5000 + self.plantCount * 1000;
		self.plantCount++;
		// Start grow timer
		self._growStart = Date.now();
		self._growEnd = self._growStart + growTime;
		growTxt.setText(Math.ceil(growTime / 1000));
		self.growTimeout = LK.setTimeout(function () {
			self.state = 'ready';
			self._growStart = null;
			self._growEnd = null;
			growTxt.setText('ready');
			LK.effects.flashObject(cornAsset, 0xffff00, 400);
		}, growTime);
	};
	self.harvest = function () {
		if (self.state !== 'ready') return;
		self.state = 'empty';
		cornAsset.alpha = 0;
		growTxt.setText('');
		self._growStart = null;
		self._growEnd = null;
		// Animate corn flying to box
		var globalCorn = self.toGlobal({
			x: 0,
			y: 0
		});
		var boxPos = game.cornBox.getGlobalCenter();
		var flyingCorn = LK.getAsset('corn', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: globalCorn.x,
			y: globalCorn.y,
			width: 120,
			height: 120
		});
		game.addChild(flyingCorn);
		tween(flyingCorn, {
			x: boxPos.x,
			y: boxPos.y,
			alpha: 0.2
		}, {
			duration: 600,
			easing: tween.cubicOut,
			onFinish: function onFinish() {
				flyingCorn.destroy();
				game.cornBox.addCorn(1);
				// Increase seeds by 2 for each harvested corn
				if (typeof game.seeds === "number") {
					game.seeds += 2;
					if (typeof game.updateSeeds === "function") game.updateSeeds();
				}
			}
		});
		// Start replant cooldown: prevent planting for 5 seconds
		self._replantCooldown = true;
		cooldownTxt.setText('5');
		var cooldownLeft = 5;
		self._replantCooldownTimer = LK.setInterval(function () {
			cooldownLeft--;
			if (cooldownLeft > 0) {
				cooldownTxt.setText('' + cooldownLeft);
			} else {
				LK.clearInterval(self._replantCooldownTimer);
				self._replantCooldown = false;
				cooldownTxt.setText('');
			}
		}, 1000);
	};
	self.locked = false;
	self.lock = function () {
		self.locked = true;
		lockAsset.alpha = 1;
		fieldAsset.alpha = 0.4;
		cornAsset.alpha = 0;
		self.state = 'empty';
	};
	self.unlock = function () {
		self.locked = false;
		lockAsset.alpha = 0;
		fieldAsset.alpha = 1;
	};
	self.setLocked = function (locked) {
		if (locked) {
			self.lock();
			fieldAsset.alpha = 0.4;
		} else {
			self.unlock();
			fieldAsset.alpha = 1;
		}
	};
	self.reset = function () {
		self.state = 'empty';
		cornAsset.alpha = 0;
		if (self.growTimeout) LK.clearTimeout(self.growTimeout);
		growTxt.setText('');
		self._growStart = null;
		self._growEnd = null;
		self.plantCount = 0;
		if (self._replantCooldownTimer) LK.clearInterval(self._replantCooldownTimer);
		self._replantCooldown = false;
		cooldownTxt.setText('');
	};
	// Update method for grow/ready text
	self.update = function () {
		if (self.state === 'growing' && self._growStart && self._growEnd) {
			var now = Date.now();
			var remain = Math.max(0, Math.ceil((self._growEnd - now) / 1000));
			if (remain > 0) {
				growTxt.setText(remain);
			} else {
				growTxt.setText('ready');
			}
		} else if (self.state === 'ready') {
			growTxt.setText('ready');
		} else {
			growTxt.setText('');
		}
		// Show/hide cooldown text depending on replant cooldown
		if (self._replantCooldown) {
			// cooldownTxt is already updated in the interval
			cooldownTxt.visible = true;
		} else {
			cooldownTxt.visible = false;
		}
	};
	// Add containsPoint method to CornField
	self.containsPoint = function (point) {
		// Convert global point to local coordinates of the field
		var localX = point.x - self.x;
		var localY = point.y - self.y;
		// fieldAsset is centered at (0,0) with anchor 0.5,0.5
		var w = fieldAsset.width;
		var h = fieldAsset.height;
		// Check if localX, localY is inside fieldAsset bounds
		return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
	};
	return self;
});
// Customer: Represents a customer standing in front of the tezgah (counter)
var Customer = Container.expand(function () {
	var self = Container.call(this);
	// Body (ellipse, new asset)
	var body = self.attachAsset('humanBody', {
		anchorX: 0.5,
		anchorY: 1,
		y: 0,
		width: 220,
		height: 320,
		alpha: 1
	});
	// Head (unique customer head)
	var head = self.attachAsset('customerHead', {
		anchorX: 0.5,
		anchorY: 1,
		y: -260,
		width: 180,
		height: 180,
		alpha: 1
	});
	// Left hand (ellipse, new asset)
	var leftHand = self.attachAsset('humanHand', {
		anchorX: 0.5,
		anchorY: 1,
		x: -90,
		y: -100,
		width: 80,
		height: 80,
		alpha: 1
	});
	// Right hand (ellipse, new asset)
	var rightHand = self.attachAsset('humanHand', {
		anchorX: 0.5,
		anchorY: 1,
		x: 90,
		y: -100,
		width: 80,
		height: 80,
		alpha: 1
	});
	// Optionally, randomize color or add more features for variety
	// For future: self.order = {...}
	return self;
});
// OrderArea: Handles customer orders, sauces, and delivery
var OrderArea = Container.expand(function () {
	var self = Container.call(this);
	var orderAsset = self.attachAsset('order', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	orderAsset.width = 260;
	orderAsset.height = 260;
	self.cornCount = 0;
	self.currentOrder = null;
	self.sauces = ['ketchup', 'mayonnaise', 'cheese'];
	self.selectedSauces = [];
	// Corn icon
	var cornAsset = self.attachAsset('cooked', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0
	});
	cornAsset.width = 120;
	cornAsset.height = 120;
	// Order text
	var orderTxt = new Text2('', {
		size: 50,
		fill: "#fff"
	});
	orderTxt.anchor.set(0.5, 0.1);
	self.addChild(orderTxt);
	// Sauce icons
	self.sauceIcons = [];
	for (var i = 0; i < self.sauces.length; i++) {
		var s = self.sauces[i];
		var icon = self.attachAsset(s, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -60 + i * 60,
			y: 80,
			alpha: 0.5
		});
		icon.width = 60;
		icon.height = 60;
		icon.sauce = s;
		// Add containsPoint method to each sauce icon
		icon.containsPoint = function (point) {
			// point is relative to OrderArea, icon.x/y is relative to OrderArea
			var localX = point.x - icon.x;
			var localY = point.y - icon.y;
			var w = icon.width,
				h = icon.height;
			return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
		};
		self.sauceIcons.push(icon);
	}
	// Delivery button
	var deliverBtn = self.attachAsset('deliver', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 0,
		y: 120,
		alpha: 0.7
	});
	deliverBtn.width = 100;
	deliverBtn.height = 60;
	// Add containsPoint method to deliverBtn for hit testing
	deliverBtn.containsPoint = function (point) {
		var localX = point.x - deliverBtn.x;
		var localY = point.y - deliverBtn.y;
		var w = deliverBtn.width;
		var h = deliverBtn.height;
		return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
	};
	// Add corn to order area
	self.addCorn = function (n) {
		self.cornCount += n;
		cornAsset.alpha = 1;
		LK.effects.flashObject(cornAsset, 0xffb347, 200);
		self.updateOrderText();
	};
	self.removeCorn = function (n) {
		if (self.cornCount >= n) {
			self.cornCount -= n;
			if (self.cornCount === 0) cornAsset.alpha = 0;
			self.updateOrderText();
			return true;
		}
		return false;
	};
	self.updateOrderText = function () {
		if (!self.currentOrder) {
			orderTxt.setText('');
			return;
		}
		var txt = 'Sipariş: ';
		for (var i = 0; i < self.currentOrder.sauces.length; i++) {
			txt += self.currentOrder.sauces[i];
			if (i < self.currentOrder.sauces.length - 1) txt += ', ';
		}
		orderTxt.setText(txt);
	};
	self.newOrder = function () {
		// Random sauces (1-3)
		var n = 1 + Math.floor(Math.random() * self.sauces.length);
		var sauces = [];
		var used = {};
		while (sauces.length < n) {
			var idx = Math.floor(Math.random() * self.sauces.length);
			var s = self.sauces[idx];
			if (!used[s]) {
				sauces.push(s);
				used[s] = true;
			}
		}
		self.currentOrder = {
			sauces: sauces
		};
		self.selectedSauces = [];
		self.updateOrderText();
		for (var i = 0; i < self.sauceIcons.length; i++) {
			self.sauceIcons[i].alpha = 0.5;
		}
	};
	// Sauce selection
	self.sauceDown = function (sauce) {
		if (!self.currentOrder) return;
		if (self.selectedSauces.length >= self.currentOrder.sauces.length) return;
		if (self.selectedSauces.indexOf(sauce) !== -1) return;
		self.selectedSauces.push(sauce);
		for (var i = 0; i < self.sauceIcons.length; i++) {
			if (self.sauceIcons[i].sauce === sauce) {
				self.sauceIcons[i].alpha = 1;
			}
		}
	};
	// Deliver order
	self.deliver = function () {
		if (!self.currentOrder) return;
		if (self.cornCount < 1) return;
		// Check sauces
		var ok = true;
		for (var i = 0; i < self.currentOrder.sauces.length; i++) {
			if (self.selectedSauces.indexOf(self.currentOrder.sauces[i]) === -1) {
				ok = false;
				break;
			}
		}
		if (ok && self.selectedSauces.length === self.currentOrder.sauces.length) {
			// Success
			self.removeCorn(1);
			LK.effects.flashObject(orderAsset, 0x00ff00, 400);
			game.coins += game.orderReward;
			game.updateCoins();
			self.currentOrder = null;
			self.selectedSauces = [];
			LK.setTimeout(function () {
				self.newOrder();
			}, 800);
		} else {
			// Wrong sauces
			LK.effects.flashObject(orderAsset, 0xff0000, 400);
			self.selectedSauces = [];
			for (var i = 0; i < self.sauceIcons.length; i++) {
				self.sauceIcons[i].alpha = 0.5;
			}
		}
	};
	// Event handling
	self.down = function (x, y, obj) {
		// Check if sauce icon tapped
		for (var i = 0; i < self.sauceIcons.length; i++) {
			var icon = self.sauceIcons[i];
			if (icon.containsPoint({
				x: x - self.x,
				y: y - self.y
			})) {
				self.sauceDown(icon.sauce);
				return;
			}
		}
		// Check if deliver button tapped
		if (deliverBtn.containsPoint({
			x: x - self.x,
			y: y - self.y
		})) {
			self.deliver();
			return;
		}
	};
	self.getGlobalCenter = function () {
		var pos = self.toGlobal({
			x: 0,
			y: 0
		});
		return {
			x: pos.x,
			y: pos.y
		};
	};
	self.reset = function () {
		self.cornCount = 0;
		self.currentOrder = null;
		self.selectedSauces = [];
		cornAsset.alpha = 0;
		self.updateOrderText();
		for (var i = 0; i < self.sauceIcons.length; i++) {
			self.sauceIcons[i].alpha = 0.5;
		}
	};
	// Add containsPoint method to OrderArea
	self.containsPoint = function (point) {
		// Convert global point to local coordinates of the OrderArea
		var localX = point.x - self.x;
		var localY = point.y - self.y;
		// orderAsset is centered at (0,0) with anchor 0.5,0.5
		var w = orderAsset.width;
		var h = orderAsset.height;
		// Check if localX, localY is inside orderAsset bounds
		return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
	};
	return self;
});
// unique plate asset for tezgah
// Plate: Represents a plate to be shown on tezgah when cooked corn box is tapped
var Plate = Container.expand(function () {
	var self = Container.call(this);
	var plateAsset = self.attachAsset('plate', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 700,
		height: 280,
		x: 0,
		y: 0,
		alpha: 1
	});
	// Optionally add more visuals or logic here
	return self;
});

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

/**** 
* Game Code
****/ 
// cook asset re-added
// Unique assets for stove and pot
// --- Game constants ---
// New tezgah (counter) asset for 3rd screen
// New assets for human body and hands
game.cornGrowTime = 5000; // ms
game.cookTime = 2000; // ms
game.orderReward = 5;
game.unlockCost = 20;
game.maxFields = 8;
// --- Game state ---
game.coins = storage.coins || 20;
game.unlockedFields = 4;
game.seeds = 4; // Başlangıçta 4 tohumumuz var
// --- UI: Seeds display (always visible, top center, not in top left 100x100) ---
var seedsTxt = new Text2('Tohum: ' + game.seeds, {
	size: 80,
	fill: 0xFFF700
});
seedsTxt.anchor.set(0.5, 0);
// Move seedsTxt down to avoid the top menu (at least 100px from top), and center horizontally
seedsTxt.x = 2048 / 2;
seedsTxt.y = 140;
LK.gui.top.addChild(seedsTxt);
// Always show seeds count on all screens
seedsTxt.visible = true;
// --- Seed Box for 1st screen (shows number of plantable seeds) ---
game.seedBox = new Container();
var seedBoxAsset = LK.getAsset('box', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 220,
	height: 220,
	x: 0,
	y: 0,
	alpha: 1
});
game.seedBox.addChild(seedBoxAsset);
// Add English label above the seed box
game.seedBoxLabel = new Text2('Seeds left', {
	size: 40,
	fill: "#fff"
});
game.seedBoxLabel.anchor.set(0.5, 1);
game.seedBoxLabel.x = 0;
game.seedBoxLabel.y = -130;
game.seedBox.addChild(game.seedBoxLabel);
game.seedBoxTxt = new Text2(game.seeds + '', {
	size: 80,
	fill: 0xFFF700
});
game.seedBoxTxt.anchor.set(0.5, 0.5);
game.seedBoxTxt.x = 0;
game.seedBoxTxt.y = 0;
game.seedBox.addChild(game.seedBoxTxt);
// Place seed box at right side, below the seedsTxt, not in top right 100x100
game.seedBox.x = 2048 - 300;
game.seedBox.y = 320;
game.addChild(game.seedBox);
game.seedBox.visible = true; // Only show on field screen
// --- UI: Coins display ---
var coinsTxt = new Text2(game.coins + '₺', {
	size: 90,
	fill: 0xFFFDE7
});
coinsTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(coinsTxt);
// Bring seedsTxt and coinsTxt to the very front in the GUI overlay
if (typeof LK.gui.top.setChildIndex === "function") {
	LK.gui.top.setChildIndex(seedsTxt, LK.gui.top.children.length - 1);
	LK.gui.top.setChildIndex(coinsTxt, LK.gui.top.children.length - 1);
}
// Update seeds display
game.updateSeeds = function () {
	if (typeof seedsTxt !== "undefined") {
		seedsTxt.setText('Tohum: ' + game.seeds);
	}
	if (typeof game.seedBoxTxt !== "undefined") {
		game.seedBoxTxt.setText(game.seeds + '');
	}
};
game.updateCoins = function () {
	coinsTxt.setText(game.coins + '₺');
	storage.coins = game.coins;
	storage.unlockedFields = game.unlockedFields;
};
// --- Screen management ---
game.screens = ['field', 'boxcook', 'order'];
game.currentScreen = 0; // 0: field, 1: box/cook, 2: order
// --- Field grid ---
game.fields = [];
var fieldRows = 2;
var fieldCols = 2;
var fieldSpacing = 340;
var fieldStartX = 400;
var fieldStartY = 600;
function updateFieldGrid() {
	// Determine grid size based on unlocked fields
	var n = game.unlockedFields;
	if (n <= 4) {
		fieldRows = 2;
		fieldCols = 2;
	} else if (n <= 9) {
		fieldRows = 3;
		fieldCols = 3;
	} else {
		fieldRows = 4;
		fieldCols = 4;
	}
}
function layoutFields() {
	updateFieldGrid();
	// Calculate how many fields are visible per "page" vertically
	var maxVisibleRows = Math.floor((2048 - fieldStartY) / fieldSpacing); // fit as many as possible
	var maxVisibleCols = Math.floor((2048 - fieldStartX) / fieldSpacing);
	// For our game, let's allow 2 rows before scrolling horizontally
	var fieldsPerCol = 2;
	var fieldsPerRow = 4; // up to 4 columns before scrolling horizontally
	// Calculate how many "pages" horizontally
	var pageSize = fieldsPerCol * fieldsPerRow;
	var pageCount = Math.ceil(game.unlockedFields / pageSize);
	// Find which page is currently active (always show the last unlocked page)
	var currentPage = Math.floor((game.unlockedFields - 1) / pageSize);
	// Calculate horizontal offset for scrolling
	var scrollX = currentPage * (fieldsPerRow * fieldSpacing + 100); // 100px gap between pages
	for (var i = 0; i < game.maxFields; i++) {
		// Which page does this field belong to?
		var page = Math.floor(i / pageSize);
		var pageIndex = i % pageSize;
		var row = Math.floor(pageIndex / fieldsPerRow);
		var col = pageIndex % fieldsPerRow;
		// If not unlocked, keep offscreen
		if (i >= game.unlockedFields) {
			game.fields[i].x = -1000;
			game.fields[i].y = -1000;
			continue;
		}
		// Place fields in a grid, scrolling horizontally after 2 rows
		var x = fieldStartX + col * fieldSpacing - scrollX;
		var y = fieldStartY + row * fieldSpacing;
		game.fields[i].x = x;
		game.fields[i].y = y;
	}
}
// Create fields
for (var i = 0; i < game.maxFields; i++) {
	var field = new CornField();
	field.index = i;
	game.addChild(field);
	game.fields.push(field);
}
function updateFieldLocks() {
	for (var i = 0; i < game.maxFields; i++) {
		if (i < game.unlockedFields) {
			game.fields[i].setLocked(false);
			if (game.fields[i].fieldAsset) game.fields[i].fieldAsset.alpha = 1;
		} else {
			game.fields[i].setLocked(true);
			if (game.fields[i].fieldAsset) game.fields[i].fieldAsset.alpha = 0.4;
		}
	}
}
updateFieldLocks();
layoutFields();
// --- Corn Box ---
// Place corn box just above the pot on 2nd screen
game.cornBox = new CornBox();
// Pot is at y = 2732 (bottom), potAsset.y = -120, potAsset.height = 800, so top of pot = 2732 - 120 - 800 = 1812
// Place corn box about 120px above the pot
game.cornBox.x = 2048 / 2;
game.cornBox.y = 1812 - 120;
// Add English label above the corn box, and a count label below it
game.cornBoxLabel = new Text2('Corn in Box', {
	size: 48,
	fill: "#fff"
});
game.cornBoxLabel.anchor.set(0.5, 1);
game.cornBoxLabel.x = game.cornBox.x;
game.cornBoxLabel.y = game.cornBox.y - 140;
game.cornBoxLabel.visible = false; // Only show on boxcook screen
game.addChild(game.cornBoxLabel);
// Add a corn count label above the box (just below the "Corn in Box" label)
game.cornBoxCountLabel = new Text2('0', {
	size: 60,
	fill: 0xFFF700
});
game.cornBoxCountLabel.anchor.set(0.5, 1);
game.cornBoxCountLabel.x = game.cornBox.x;
game.cornBoxCountLabel.y = game.cornBox.y - 80;
game.cornBoxCountLabel.visible = false; // Only show on boxcook screen
game.addChild(game.cornBoxCountLabel);
game.addChild(game.cornBox);
// --- Stove & Pot for Cooking Screen ---
game.stove = new Container();
// Place stove at the very bottom of the screen, centered horizontally
game.stove.x = 2048 / 2;
game.stove.y = 2732; // y=2732 is the very bottom edge
game.addChild(game.stove);
// Stove asset (image) - use a new visual asset for the stove
var stoveAsset = LK.getAsset('stoveImage', {
	anchorX: 0.5,
	anchorY: 1,
	width: 2048,
	height: 420,
	y: 0
});
game.stove.addChild(stoveAsset);
// Pot asset (ellipse, centered on stove) - as large as possible but fits inside stove and is fully visible
var potAsset = LK.getAsset('pot', {
	anchorX: 0.5,
	anchorY: 1,
	width: 1400,
	// very wide, fills most of stove
	height: 800,
	// very tall, fills most of stove
	y: -120 // move pot lower so it sits further down on the stove
});
game.stove.addChild(potAsset);
// Place pot lower on the stove
potAsset.x = 0;
potAsset.y = -120;
// Pot "lid" (for visual effect) - now smaller than pot and sits directly on top of pot
var potLid = LK.getAsset('potLid', {
	anchorX: 0.5,
	anchorY: 1,
	width: 1000,
	// reduced width
	height: 220,
	// reduced height
	y: potAsset.y - potAsset.height + 300,
	// moved lid slightly up (less down)
	// adjust to match new height
	alpha: 1
});
game.stove.addChild(potLid);
// Place lid to visually close the pot
potLid.x = potAsset.x;
potLid.y = potAsset.y - potAsset.height + 300; // moved lid slightly up (less down)
// Corns in pot (array of {asset, startTime})
game.potCorns = [];
// Pot timer text
game.potTimerTxt = new Text2('', {
	size: 70,
	fill: "#fff"
});
game.potTimerTxt.anchor.set(0.5, 0.5);
// Center the timer in the middle of the pot, and move it lower to match new pot position
game.potTimerTxt.x = potAsset.x;
game.potTimerTxt.y = potAsset.y - 320 + 300; // Move timer lower to match new pot position
game.stove.addChild(game.potTimerTxt);
// --- Cook Area (for legacy, still used for quick cook) ---
game.cookArea = new CookArea();
game.cookArea.x = 2048 - 300;
game.cookArea.y = 1100;
game.addChild(game.cookArea);
// --- Order Area ---
// Order area removed as per request
// Minimal OrderArea to prevent undefined error for addCorn
game.orderArea = {
	addCorn: function addCorn(n) {
		// No-op: order area is removed, but prevent error
	}
};
// --- Tezgah (Counter) for Customer Screen ---
// Make the tezgah (counter) very large and at the very bottom of the screen, spanning almost the full width
game.counterAsset = LK.getAsset('tezgah', {
	anchorX: 0.5,
	anchorY: 1,
	width: 2048 - 20,
	// leave only 10px margin on each side for a bigger counter
	height: 420,
	// make it even taller
	alpha: 0.95
});
game.counterAsset.x = 2048 / 2;
game.counterAsset.y = 2732; // Place tezgah at the very bottom of the screen (old/original position)
game.addChild(game.counterAsset);
// --- Cooked Corn Count Box for 3rd Screen (Order Screen) ---
game.cookedCornBox = new Container();
var cookedCornBoxAsset = LK.getAsset('cooked', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 220,
	height: 220,
	x: 0,
	y: 0,
	alpha: 1
});
game.cookedCornBox.addChild(cookedCornBoxAsset);
game.cookedCornBoxTxt = new Text2('0', {
	size: 80,
	fill: "#fff"
});
game.cookedCornBoxTxt.anchor.set(0.5, 0.5);
game.cookedCornBoxTxt.x = 0;
game.cookedCornBoxTxt.y = 0;
game.cookedCornBox.addChild(game.cookedCornBoxTxt);
// Place cooked corn count box at the very left edge, centered vertically on top of the tezgah (counter) in 3rd screen
// Center the box horizontally at the left edge of the tezgah
game.cookedCornBox.x = game.counterAsset.x - game.counterAsset.width / 2 + game.cookedCornBox.width / 2 + 10; // 10px margin from left
game.cookedCornBox.y = game.counterAsset.y - game.counterAsset.height / 2; // center vertically on tezgah
game.addChild(game.cookedCornBox);
game.cookedCornBox.visible = false; // Only show on order screen
// --- Customers in front of tezgah (only on customer screen) ---
game.customers = [];
game.customerSpawnPositions = [2048 / 2 - 420,
// left
2048 / 2,
// center
2048 / 2 + 420 // right
];
game.customerY = 2732 - 420; // Stand just above the tezgah
// Helper to spawn a customer at a random position
game.spawnCustomer = function () {
	// Only spawn if on order screen
	if (game.currentScreen !== 2) return;
	// Find a free customer slot (max 3 customers at a time)
	var freeIndex = -1;
	for (var i = 0; i < 3; i++) {
		if (!game.customers[i] || game.customers[i].destroyed || !game.customers[i].visible) {
			freeIndex = i;
			break;
		}
	}
	if (freeIndex === -1) return; // All slots full
	// Pick a random position index (0, 1, 2)
	var posIdx = Math.floor(Math.random() * 3);
	// Make sure no other customer is at this position
	var taken = false;
	for (var i = 0; i < game.customers.length; i++) {
		if (game.customers[i] && game.customers[i].visible && game.customers[i].x === game.customerSpawnPositions[posIdx]) {
			taken = true;
			break;
		}
	}
	if (taken) {
		// Try other positions
		for (var j = 0; j < 3; j++) {
			if (j !== posIdx) {
				var found = false;
				for (var k = 0; k < game.customers.length; k++) {
					if (game.customers[k] && game.customers[k].visible && game.customers[k].x === game.customerSpawnPositions[j]) {
						found = true;
						break;
					}
				}
				if (!found) {
					posIdx = j;
					break;
				}
			}
		}
	}
	// Create or reuse customer
	var cust;
	if (game.customers[freeIndex] && !game.customers[freeIndex].destroyed) {
		cust = game.customers[freeIndex];
	} else {
		cust = new Customer();
		game.customers[freeIndex] = cust;
		game.addChild(cust);
	}
	// Set customer position and keep them stationary
	cust.x = game.customerSpawnPositions[posIdx];
	cust.y = game.customerY;
	cust.visible = game.currentScreen === 2;
	// Remove any movement or animation logic for customers here to keep them stationary
};
// Remove all pre-created customers
game.customers = [];
// Timer to spawn a customer: first after 40s, then every 30s (only on order screen)
game.customerSpawnTimer = null;
game._customerSpawnInterval = 30000; // 30s after first
game._customerFirstDelay = 40000; // 40s for first customer
function spawnCustomerOnOrderScreen() {
	if (game.currentScreen === 2) {
		// Remove all existing customers from the screen
		for (var i = 0; i < game.customers.length; i++) {
			if (game.customers[i] && !game.customers[i].destroyed) {
				game.customers[i].destroy();
			}
		}
		game.customers = [];
		// Spawn only 1 new customer at a random position
		var posIdx = Math.floor(Math.random() * 3);
		var cust = new Customer();
		cust.x = game.customerSpawnPositions[posIdx];
		cust.y = game.customerY;
		cust.visible = true;
		game.addChild(cust);
		game.customers.push(cust);
	}
	// After first call, switch to interval if not already set
	if (!game._customerSpawnIntervalStarted) {
		game._customerSpawnIntervalStarted = true;
		game.customerSpawnTimer = LK.setInterval(spawnCustomerOnOrderScreen, game._customerSpawnInterval);
	}
}
// Start the first customer spawn after 40s
if (game.customerSpawnTimer) {
	LK.clearInterval(game.customerSpawnTimer);
}
if (game._customerSpawnTimeout) {
	LK.clearTimeout(game._customerSpawnTimeout);
}
game._customerSpawnIntervalStarted = false;
game._customerSpawnTimeout = LK.setTimeout(function () {
	spawnCustomerOnOrderScreen();
}, game._customerFirstDelay);
// --- Unlock 4 Fields Button ---
// Place a new button below the 4 fields to unlock 4 more fields at once for 20 coins
var unlock4BtnContainer = new Container();
var unlock4Btn = LK.getAsset('unlock', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 320,
	height: 120,
	alpha: 0.9
});
unlock4BtnContainer.addChild(unlock4Btn);
game.addChild(unlock4BtnContainer);
var unlock4Txt = new Text2('4 Tarla Aç (20₺)', {
	size: 60,
	fill: "#fff"
});
unlock4Txt.anchor.set(0.5, 0.5);
game.addChild(unlock4Txt);
// Add containsPoint method to unlock4BtnContainer
unlock4BtnContainer.containsPoint = function (point) {
	var localX = point.x - unlock4BtnContainer.x;
	var localY = point.y - unlock4BtnContainer.y;
	var w = unlock4Btn.width;
	var h = unlock4Btn.height;
	return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
};
// Update unlock4 button position and text
function updateUnlockBtn() {
	// Only show if exactly 4 fields are unlocked and maxFields not reached and seeds > 0
	if (game.unlockedFields !== 4 || game.unlockedFields >= game.maxFields || game.seeds <= 0) {
		unlock4Btn.alpha = 0.3;
		unlock4BtnContainer.visible = false;
		unlock4Txt.visible = false;
		return;
	}
	// Place below the last unlocked field (index game.unlockedFields-1)
	var lastField = game.fields[game.unlockedFields - 1];
	unlock4BtnContainer.x = lastField.x;
	unlock4BtnContainer.y = lastField.y + 260;
	unlock4Txt.x = unlock4BtnContainer.x;
	unlock4Txt.y = unlock4BtnContainer.y;
	unlock4BtnContainer.visible = true;
	unlock4Txt.visible = true;
	unlock4Btn.alpha = 0.9;
	unlock4Txt.setText('4 Tarla Aç (20₺)');
}
updateUnlockBtn();
// --- Screen navigation buttons ---
var leftBtn = LK.getAsset('unlock', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 120,
	height: 120,
	x: 120,
	y: 2732 / 2,
	alpha: 0.7
});
var rightBtn = LK.getAsset('unlock', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 120,
	height: 120,
	x: 2048 - 120,
	y: 2732 / 2,
	alpha: 0.7
});
game.addChild(leftBtn);
game.addChild(rightBtn);
// Add containsPoint for nav buttons
leftBtn.containsPoint = function (point) {
	var localX = point.x - leftBtn.x;
	var localY = point.y - leftBtn.y;
	var w = leftBtn.width,
		h = leftBtn.height;
	return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
};
rightBtn.containsPoint = function (point) {
	var localX = point.x - rightBtn.x;
	var localY = point.y - rightBtn.y;
	var w = rightBtn.width,
		h = rightBtn.height;
	return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
};
// Nav button text
var leftTxt = new Text2('<', {
	size: 90,
	fill: "#fff"
});
leftTxt.anchor.set(0.5, 0.5);
leftTxt.x = leftBtn.x;
leftTxt.y = leftBtn.y;
game.addChild(leftTxt);
var rightTxt = new Text2('>', {
	size: 90,
	fill: "#fff"
});
rightTxt.anchor.set(0.5, 0.5);
rightTxt.x = rightBtn.x;
rightTxt.y = rightBtn.y;
game.addChild(rightTxt);
// --- Screen show/hide logic ---
function updateScreenVisibility() {
	// 0: field, 1: boxcook, 2: order
	var showField = game.currentScreen === 0;
	var showBoxCook = game.currentScreen === 1;
	var showOrder = game.currentScreen === 2;
	// Fields
	for (var i = 0; i < game.fields.length; i++) {
		game.fields[i].visible = showField;
	}
	// Show seedBox only on field screen
	if (game.seedBox) {
		game.seedBox.visible = showField;
	}
	// Only show unlock4BtnContainer and unlock4Txt if unlock4Btn should be available (unlockedFields==4, not maxed, seeds>0)
	if (showField && game.unlockedFields === 4 && game.unlockedFields < game.maxFields && game.seeds > 0) {
		unlock4BtnContainer.visible = true;
		unlock4Txt.visible = true;
		unlock4Btn.alpha = 0.9;
	} else {
		unlock4BtnContainer.visible = false;
		unlock4Txt.visible = false;
		unlock4Btn.alpha = 0.3;
	}
	// Show/hide corn box label and count only on 2nd screen (boxcook)
	if (typeof game.cornBoxLabel !== "undefined") {
		game.cornBoxLabel.visible = showBoxCook;
		if (showBoxCook) {
			game.cornBoxLabel.setText('Corn in Box');
			// Make sure label is above the box and added to the display list
			if (game.cornBox && game.children.indexOf(game.cornBoxLabel) === -1) {
				game.addChild(game.cornBoxLabel);
			}
			// Position label above the box
			game.cornBoxLabel.x = game.cornBox.x;
			game.cornBoxLabel.y = game.cornBox.y - 140;
		}
	}
	if (typeof game.cornBoxCountLabel !== "undefined") {
		game.cornBoxCountLabel.visible = showBoxCook;
		if (showBoxCook) {
			// Update count to match box
			if (game.cornBox && typeof game.cornBox.cornCount === "number") {
				game.cornBoxCountLabel.setText(game.cornBox.cornCount + '');
			} else {
				game.cornBoxCountLabel.setText('0');
			}
			// Position count label just below the main label
			game.cornBoxCountLabel.x = game.cornBox.x;
			game.cornBoxCountLabel.y = game.cornBox.y - 80;
			// Make sure label is added to display list
			if (game.cornBox && game.children.indexOf(game.cornBoxCountLabel) === -1) {
				game.addChild(game.cornBoxCountLabel);
			}
		}
	}
	// Hide all other elements except fields, unlock4Btn, and seedBox on 1st screen
	for (var i = 0; i < game.children.length; i++) {
		var ch = game.children[i];
		if (showField) {
			// Only show fields, unlock4BtnContainer, unlock4Txt, and seedBox
			if (game.fields.indexOf(ch) !== -1 || ch === unlock4BtnContainer || ch === unlock4Txt || ch === game.seedBox) {
				ch.visible = true;
			} else {
				ch.visible = false;
			}
		} else if (showBoxCook) {
			// Only show stove and cornBox on 2nd screen
			if (ch === game.stove || ch === game.cornBox) {
				ch.visible = true;
			} else {
				ch.visible = false;
			}
		} else {
			// On 3rd screen (order), only show tezgah, customers, cooked corn count box, and plate
			if (game.currentScreen === 2) {
				// Show tezgah plate if not present
				if (!game.tezgahPlate || game.tezgahPlate.destroyed) {
					game.tezgahPlate = new Plate();
					// Center the plate horizontally on the tezgah
					game.tezgahPlate.x = game.counterAsset.x;
					// Place the plate vertically so it sits visually on the tezgah
					game.tezgahPlate.y = game.counterAsset.y - game.counterAsset.height / 2;
					game.addChild(game.tezgahPlate);
					game.tezgahPlate.cornIcons = [];
				}
				if (ch === game.counterAsset || ch === game.cookedCornBox || ch === game.tezgahPlate) {
					ch.visible = true;
				} else if (game.customers && game.customers.indexOf(ch) !== -1) {
					ch.visible = true;
				} else {
					ch.visible = false;
				}
			} else {
				// On other screens, hide stove and cornBox, show others (handled by their own logic)
				if (ch === game.stove || ch === game.cornBox) {
					ch.visible = false;
				} else if (typeof ch.visible === "boolean") {
					ch.visible = true;
				}
			}
		}
	}
	// Order
	// game.orderArea.visible = showOrder; // Removed order area
	if (game.counterAsset) game.counterAsset.visible = showOrder;
	// Customers visible only on customer screen
	if (game.customers) {
		for (var i = 0; i < game.customers.length; i++) {
			if (showOrder && game.customers[i] && !game.customers[i].destroyed) {
				game.customers[i].visible = true;
			} else if (game.customers[i]) {
				game.customers[i].visible = false;
			}
		}
	}
	// Show cooked corn count box only on order screen
	if (game.cookedCornBox) {
		// Only show on order screen (screen 2)
		game.cookedCornBox.visible = showOrder;
		// Show tezgah plate if on order screen
		if (showOrder && game.tezgahPlate) {
			game.tezgahPlate.visible = true;
		}
		// Update value from cookArea only if visible
		if (showOrder && game.cookArea && typeof game.cookArea.cookedCorn === "number") {
			game.cookedCornBoxTxt.setText(game.cookArea.cookedCorn);
		} else {
			game.cookedCornBoxTxt.setText('');
			game.cookedCornBox.visible = false;
		}
	}
	// Nav buttons always visible
	leftBtn.visible = true;
	rightBtn.visible = true;
	leftTxt.visible = true;
	rightTxt.visible = true;
	// Hide tezgah plate if not on order screen
	if (game.tezgahPlate && game.currentScreen !== 2) {
		game.tezgahPlate.visible = false;
	}
	// Show seeds count always
	if (typeof seedsTxt !== "undefined") {
		seedsTxt.visible = true;
		if (typeof game.updateSeeds === "function") {
			game.updateSeeds();
		}
		if (typeof game.seedBoxTxt !== "undefined") {
			game.seedBoxTxt.setText(game.seeds + '');
		}
	}
}
updateScreenVisibility();
// --- Touch handling ---
game.down = function (x, y, obj) {
	// Navigation buttons
	if (leftBtn.containsPoint({
		x: x,
		y: y
	})) {
		game.currentScreen = (game.currentScreen + 2) % 3;
		updateScreenVisibility();
		return;
	}
	if (rightBtn.containsPoint({
		x: x,
		y: y
	})) {
		game.currentScreen = (game.currentScreen + 1) % 3;
		updateScreenVisibility();
		return;
	}
	// Per-screen input
	if (game.currentScreen === 0) {
		// Field screen
		if (unlock4BtnContainer.visible && unlock4BtnContainer.containsPoint({
			x: x,
			y: y
		})) {
			if (game.seeds <= 0) {
				LK.effects.flashObject(unlock4Btn, 0xff0000, 400);
				return;
			}
			if (game.coins >= 20 && game.unlockedFields === 4 && game.unlockedFields < game.maxFields) {
				game.coins -= 20;
				// Unlock 4 more fields, but do not exceed maxFields
				var toUnlock = Math.min(4, game.maxFields - game.unlockedFields);
				game.unlockedFields += toUnlock;
				game.updateCoins();
				updateFieldLocks();
				layoutFields();
				updateUnlockBtn();
				// Hide unlock4Btn and its label after unlocking the second set of fields
				unlock4BtnContainer.visible = false;
				unlock4Txt.visible = false;
			} else {
				LK.effects.flashObject(unlock4Btn, 0xff0000, 400);
			}
			return;
		}
		for (var i = 0; i < game.fields.length; i++) {
			var f = game.fields[i];
			if (f.visible && f.containsPoint({
				x: x,
				y: y
			})) {
				f.down(x - f.x, y - f.y, obj);
				return;
			}
		}
	} else if (game.currentScreen === 1) {
		// Box & Cook screen
		// Prevent interaction with cook asset
		if (game.cornBox.visible && game.cornBox.containsPoint({
			x: x,
			y: y
		})) {
			// When box is tapped, drop all corn into pot one by one, each at a different position
			var cornToMove = game.cornBox.cornCount;
			if (cornToMove > 0) {
				// Arrange corns in a circle or grid inside the pot
				var potRadius = 120;
				// Center corns visually in the pot asset (fix: use potAsset center, not offset)
				var centerX = potAsset.x;
				var centerY = potAsset.y - potAsset.height / 2 + 60; // center vertically in pot, adjust as needed
				var angleStep = Math.PI * 2 / Math.max(1, cornToMove);
				for (var i = 0; i < cornToMove; i++) {
					if (game.cornBox.removeCorn(1)) {
						// Calculate position for this corn
						var angle = i * angleStep;
						// For up to 8 corns, use a circle, for more, use a spiral
						var r = potRadius * (cornToMove > 8 ? 0.7 + 0.3 * (i / cornToMove) : 1);
						var px = centerX + Math.cos(angle) * r * 0.7;
						var py = centerY + Math.sin(angle) * r * 0.5;
						// Add a corn asset to pot at calculated position
						var cornInPot = LK.getAsset('corn', {
							anchorX: 0.5,
							anchorY: 0.5,
							width: 80,
							height: 80,
							x: px,
							y: py
						});
						game.stove.addChild(cornInPot);
						// Start cook timer (30s)
						var cookStart = Date.now();
						game.potCorns.push({
							asset: cornInPot,
							startTime: cookStart,
							done: false
						});
						// Flash pot for each corn
						LK.effects.flashObject(potAsset, 0xffff00, 100);
					}
				}
			}
			return;
		}
		// Prevent interaction with cook asset and cooked corn count box
		if (game.cookArea && game.cookArea.containsPoint && game.cookArea.containsPoint({
			x: x - game.cookArea.x,
			y: y - game.cookArea.y
		})) {
			// Do nothing, prevent interaction
			return;
		}
		// Collect all cooked corn from pot with a single tap on the pot
		var localPotX = x - game.stove.x;
		var localPotY = y - game.stove.y;
		var potW = potAsset.width,
			potH = potAsset.height;
		// Check if tap is inside the pot area
		if (localPotX >= -potW / 2 && localPotX <= potW / 2 && localPotY >= -potH / 2 && localPotY <= potH / 2) {
			var collected = 0;
			// Collect all cooked corns
			for (var i = game.potCorns.length - 1; i >= 0; i--) {
				var c = game.potCorns[i];
				if (c.done) {
					c.asset.destroy();
					game.potCorns.splice(i, 1);
					game.cookArea.addCookedCorn(1);
					collected++;
				}
			}
			if (collected > 0) {
				LK.effects.flashObject(potAsset, 0x05c49c, 200);
			}
			return;
		}
	} else if (game.currentScreen === 2) {
		// Order screen
		// Prevent interaction with cooked corn count box
		if (game.cookedCornBox && typeof game.cookedCornBox.x === "number" && typeof game.cookedCornBox.y === "number") {
			var localX = x - game.cookedCornBox.x;
			var localY = y - game.cookedCornBox.y;
			var w = 220,
				h = 220;
			if (localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2) {
				// When cooked corn box is tapped, show a plate on tezgah (if not already present)
				if (!game.tezgahPlate || game.tezgahPlate.destroyed) {
					game.tezgahPlate = new Plate();
					// Center the plate horizontally on the tezgah
					game.tezgahPlate.x = game.counterAsset.x;
					// Place the plate vertically so it sits visually on the tezgah
					game.tezgahPlate.y = game.counterAsset.y - game.counterAsset.height / 2;
					game.addChild(game.tezgahPlate);
					game.tezgahPlate.cornIcons = [];
				}
				// Only move one cooked corn per tap, and use 'corn' asset for the plate
				var cookedCount = game.cookArea && typeof game.cookArea.cookedCorn === "number" ? game.cookArea.cookedCorn : 0;
				if (cookedCount > 0) {
					// Remove one cooked corn from cookArea
					if (game.cookArea.removeCookedCorn(1)) {
						// Place a single corn icon (asset: 'corn') on the plate
						var iconW = 80,
							iconH = 80;
						// Find how many corns are already on the plate (count existing icons)
						var plateCornCount = 0;
						if (game.tezgahPlate.cornIcons) plateCornCount = game.tezgahPlate.cornIcons.length;
						// Place new corn icon at next position in row, centered on plate
						var xOnPlate = game.tezgahPlate.x - 120 + plateCornCount * (iconW + 10);
						var yOnPlate = game.tezgahPlate.y - 10;
						var cornIcon = LK.getAsset('corn', {
							anchorX: 0.5,
							anchorY: 0.5,
							width: iconW,
							height: iconH,
							x: xOnPlate,
							y: yOnPlate
						});
						game.addChild(cornIcon);
						if (!game.tezgahPlate.cornIcons) game.tezgahPlate.cornIcons = [];
						game.tezgahPlate.cornIcons.push(cornIcon);
						// Update cooked corn box text to match new cooked corn count
						if (game.cookedCornBoxTxt) {
							game.cookedCornBoxTxt.setText(game.cookArea.cookedCorn);
						}
					}
				}
				return;
			}
		}
		// Order area removed
	}
};
// --- Game update ---
game.update = function () {
	// Update all fields for grow/ready text
	for (var i = 0; i < game.fields.length; i++) {
		if (game.fields[i].visible) {
			if (typeof game.fields[i].update === "function") {
				game.fields[i].update();
			}
		}
	}
	// Update corn box count label live on 2nd screen
	if (game.currentScreen === 1 && typeof game.cornBoxCountLabel !== "undefined" && game.cornBox && typeof game.cornBox.cornCount === "number") {
		game.cornBoxCountLabel.setText(game.cornBox.cornCount + '');
	}
	// No automatic planting: Corn only grows when planted by the player
	// --- Pot cooking logic ---
	if (game.stove && game.potCorns) {
		var minTimeLeft = null;
		for (var i = 0; i < game.potCorns.length; i++) {
			var c = game.potCorns[i];
			// --- Add timer label above each corn in the pot ---
			if (!c.timerLabel) {
				c.timerLabel = new Text2('', {
					size: 40,
					fill: "#fff"
				});
				c.timerLabel.anchor.set(0.5, 1);
				c.timerLabel.x = c.asset.x;
				c.timerLabel.y = c.asset.y - 50;
				game.stove.addChild(c.timerLabel);
			}
			// Always update label position to follow corn
			c.timerLabel.x = c.asset.x;
			c.timerLabel.y = c.asset.y - 50;
			if (!c.done) {
				var elapsed = Date.now() - c.startTime;
				var left = 30000 - elapsed;
				if (left <= 0) {
					// Done cooking
					c.done = true;
					c.asset.alpha = 1;
					c.asset.tint = 0x05c49c; // cooked color
					LK.effects.flashObject(c.asset, 0x05c49c, 300);
					left = 0;
				} else {
					c.asset.alpha = 0.7;
					c.asset.tint = 0xb8b031; // raw color
				}
				// Show remaining time above corn
				var secLeft = Math.ceil(left / 1000);
				c.timerLabel.setText(secLeft + "s");
				c.timerLabel.visible = true;
				if (minTimeLeft === null || left < minTimeLeft) minTimeLeft = left;
			} else {
				// Hide label above cooked corn (no 'Done' text)
				c.timerLabel.setText('');
				c.timerLabel.visible = false;
			}
			// If the corn asset is destroyed (collected), also destroy the label
			if (c.asset.destroyed && c.timerLabel) {
				c.timerLabel.destroy();
				c.timerLabel = null;
			}
			// Hide "Done" label if corn is not in potCorns anymore (collected)
			if ((!c.asset || c.asset.destroyed) && c.timerLabel) {
				c.timerLabel.visible = false;
			}
			// Remove global pot timer text (game.potTimerTxt) so only per-corn timers are shown
			game.potTimerTxt.setText('');
			game.potTimerTxt.visible = false;
		}
		// Remove all other pot timer text except per-corn timers on 2nd screen
		// (No global pot timer text on 2nd screen)
		// Remove timer labels for any corns that have been removed from potCorns
		for (var i = game.potCorns.length - 1; i >= 0; i--) {
			var c = game.potCorns[i];
			if (c.asset.destroyed && c.timerLabel) {
				c.timerLabel.destroy();
				c.timerLabel = null;
			}
		}
	}
	// Show pot lid only if there are corns in the pot
	if (typeof potLid !== "undefined" && typeof game.potCorns !== "undefined") {
		if (game.potCorns.length > 0) {
			potLid.visible = true;
		} else {
			potLid.visible = false;
		}
	}
	// Update cooked corn count box value live on order screen
	if (game.currentScreen === 2 && game.cookedCornBox && game.cookArea && typeof game.cookArea.cookedCorn === "number") {
		game.cookedCornBoxTxt.setText(game.cookArea.cookedCorn);
		game.cookedCornBox.visible = true;
	} else if (game.cookedCornBox) {
		// Hide or clear cooked corn count on other screens
		game.cookedCornBoxTxt.setText('');
		game.cookedCornBox.visible = false;
	}
};
// --- Reset function for new game ---
game.resetGame = function () {
	game.coins = 20;
	game.unlockedFields = 4;
	game.seeds = 4;
	if (typeof game.updateSeeds === "function") game.updateSeeds();
	game.updateCoins();
	updateFieldLocks();
	layoutFields();
	updateUnlockBtn();
	for (var i = 0; i < game.fields.length; i++) {
		game.fields[i].reset();
	}
	game.cornBox.reset();
	game.cookArea.reset();
	// Reset stove/pot
	if (game.potCorns) {
		for (var i = 0; i < game.potCorns.length; i++) {
			if (game.potCorns[i].asset) game.potCorns[i].asset.destroy();
		}
		game.potCorns = [];
	}
	if (game.potTimerTxt) game.potTimerTxt.setText('');
	// game.orderArea.reset();
	// game.orderArea.newOrder();
	// Reset to first screen and update visibility
	game.currentScreen = 0;
	// Remove all customers on reset (they will be spawned by timer on 3rd screen)
	if (game.customers) {
		for (var i = 0; i < game.customers.length; i++) {
			if (game.customers[i] && !game.customers[i].destroyed) {
				game.customers[i].destroy();
			}
		}
		game.customers = [];
	}
	updateScreenVisibility();
};
// --- Asset definitions (for static analysis) ---
// These are not real code, but LK will auto-create these assets as used above:
// field: green box, corn: yellow ellipse, lock: gray lock, box: brown box, cook: pot, cooked: orange ellipse, order: tray, ketchup/mayonnaise/cheese: colored circles, deliver: blue button, unlock: green button
// --- End of code ---

===================================================================
--- original.js
+++ change.js
@@ -740,14 +740,13 @@
 
 /**** 
 * Game Code
 ****/ 
-// new asset for open/close button
-// New assets for human body and hands
-// New tezgah (counter) asset for 3rd screen
-// --- Game constants ---
-// Unique assets for stove and pot
 // cook asset re-added
+// Unique assets for stove and pot
+// --- Game constants ---
+// New tezgah (counter) asset for 3rd screen
+// New assets for human body and hands
 game.cornGrowTime = 5000; // ms
 game.cookTime = 2000; // ms
 game.orderReward = 5;
 game.unlockCost = 20;
@@ -1053,75 +1052,8 @@
 // center
 2048 / 2 + 420 // right
 ];
 game.customerY = 2732 - 420; // Stand just above the tezgah
-// --- Open/Close Toggle Button for 3rd Screen (Order Screen) ---
-game.openCloseState = false; // false = closed, true = open
-game.openCloseBtn = LK.getAsset('openCloseBtn', {
-	anchorX: 0.5,
-	anchorY: 0.5,
-	width: 220,
-	height: 100,
-	x: 2048 - 220,
-	y: 2732 - 420 - 80,
-	// above tezgah, right side
-	alpha: 0.9
-});
-game.addChild(game.openCloseBtn);
-game.openCloseBtnTxt = new Text2('close', {
-	size: 60,
-	fill: "#fff"
-});
-game.openCloseBtnTxt.anchor.set(0.5, 0.5);
-game.openCloseBtnTxt.x = game.openCloseBtn.x;
-game.openCloseBtnTxt.y = game.openCloseBtn.y;
-game.addChild(game.openCloseBtnTxt);
-// Add containsPoint method to openCloseBtn
-game.openCloseBtn.containsPoint = function (point) {
-	var localX = point.x - game.openCloseBtn.x;
-	var localY = point.y - game.openCloseBtn.y;
-	var w = game.openCloseBtn.width;
-	var h = game.openCloseBtn.height;
-	return localX >= -w / 2 && localX <= w / 2 && localY >= -h / 2 && localY <= h / 2;
-};
-// Helper to update open/close button text
-game.updateOpenCloseBtn = function () {
-	if (game.openCloseBtnTxt) {
-		game.openCloseBtnTxt.setText(game.openCloseState ? 'close' : 'open');
-		// Set text color: green for open, white for close
-		if (!game.openCloseState) {
-			// Open: green
-			if (typeof game.openCloseBtnTxt.setTextStyle === "function") {
-				game.openCloseBtnTxt.setTextStyle({
-					fill: 0x00C853
-				});
-			}
-		} else {
-			// Close: white
-			if (typeof game.openCloseBtnTxt.setTextStyle === "function") {
-				game.openCloseBtnTxt.setTextStyle({
-					fill: "#fff"
-				});
-			}
-		}
-	}
-	if (game.openCloseBtn) {
-		// Yellow for open, red for close
-		game.openCloseBtn.color = game.openCloseState ? 0xffd600 : 0xd32f2f;
-		// If LK.getAsset does not update color after creation, set .tint as fallback
-		if (typeof game.openCloseBtn.tint !== "undefined") {
-			game.openCloseBtn.tint = game.openCloseState ? 0xffd600 : 0xd32f2f;
-		}
-	}
-};
-game.updateOpenCloseBtn();
-// Helper to show/hide openCloseBtn only on 3rd screen
-function updateOpenCloseBtnVisibility() {
-	var showOrder = game.currentScreen === 2;
-	if (game.openCloseBtn) game.openCloseBtn.visible = showOrder;
-	if (game.openCloseBtnTxt) game.openCloseBtnTxt.visible = showOrder;
-}
-updateOpenCloseBtnVisibility();
 // Helper to spawn a customer at a random position
 game.spawnCustomer = function () {
 	// Only spawn if on order screen
 	if (game.currentScreen !== 2) return;
@@ -1178,31 +1110,47 @@
 	// Remove any movement or animation logic for customers here to keep them stationary
 };
 // Remove all pre-created customers
 game.customers = [];
-// Timer to spawn a customer every 10 seconds (only on order screen and only if openCloseState is true and user has toggled at least once)
-game._hasUserToggledOpenClose = false; // Track if user has ever toggled open/close
-game.customerSpawnTimer = LK.setInterval(function () {
-	// Only spawn customer if on order screen, openCloseState is true, and user has toggled at least once
-	if (game.currentScreen !== 2) return;
-	if (!game.openCloseState) return;
-	if (!game._hasUserToggledOpenClose) return;
-	// Remove all existing customers from the screen
-	for (var i = 0; i < game.customers.length; i++) {
-		if (game.customers[i] && !game.customers[i].destroyed) {
-			game.customers[i].destroy();
+// Timer to spawn a customer: first after 40s, then every 30s (only on order screen)
+game.customerSpawnTimer = null;
+game._customerSpawnInterval = 30000; // 30s after first
+game._customerFirstDelay = 40000; // 40s for first customer
+function spawnCustomerOnOrderScreen() {
+	if (game.currentScreen === 2) {
+		// Remove all existing customers from the screen
+		for (var i = 0; i < game.customers.length; i++) {
+			if (game.customers[i] && !game.customers[i].destroyed) {
+				game.customers[i].destroy();
+			}
 		}
+		game.customers = [];
+		// Spawn only 1 new customer at a random position
+		var posIdx = Math.floor(Math.random() * 3);
+		var cust = new Customer();
+		cust.x = game.customerSpawnPositions[posIdx];
+		cust.y = game.customerY;
+		cust.visible = true;
+		game.addChild(cust);
+		game.customers.push(cust);
 	}
-	game.customers = [];
-	// Spawn only 1 new customer at a random position
-	var posIdx = Math.floor(Math.random() * 3);
-	var cust = new Customer();
-	cust.x = game.customerSpawnPositions[posIdx];
-	cust.y = game.customerY;
-	cust.visible = true;
-	game.addChild(cust);
-	game.customers.push(cust);
-}, 10000);
+	// After first call, switch to interval if not already set
+	if (!game._customerSpawnIntervalStarted) {
+		game._customerSpawnIntervalStarted = true;
+		game.customerSpawnTimer = LK.setInterval(spawnCustomerOnOrderScreen, game._customerSpawnInterval);
+	}
+}
+// Start the first customer spawn after 40s
+if (game.customerSpawnTimer) {
+	LK.clearInterval(game.customerSpawnTimer);
+}
+if (game._customerSpawnTimeout) {
+	LK.clearTimeout(game._customerSpawnTimeout);
+}
+game._customerSpawnIntervalStarted = false;
+game._customerSpawnTimeout = LK.setTimeout(function () {
+	spawnCustomerOnOrderScreen();
+}, game._customerFirstDelay);
 // --- Unlock 4 Fields Button ---
 // Place a new button below the 4 fields to unlock 4 more fields at once for 20 coins
 var unlock4BtnContainer = new Container();
 var unlock4Btn = LK.getAsset('unlock', {
@@ -1438,12 +1386,8 @@
 	leftBtn.visible = true;
 	rightBtn.visible = true;
 	leftTxt.visible = true;
 	rightTxt.visible = true;
-	// Show/hide openCloseBtn only on 3rd screen
-	if (typeof updateOpenCloseBtnVisibility === "function") {
-		updateOpenCloseBtnVisibility();
-	}
 	// Hide tezgah plate if not on order screen
 	if (game.tezgahPlate && game.currentScreen !== 2) {
 		game.tezgahPlate.visible = false;
 	}
@@ -1596,18 +1540,8 @@
 			return;
 		}
 	} else if (game.currentScreen === 2) {
 		// Order screen
-		// Handle open/close button tap
-		if (game.openCloseBtn && game.openCloseBtn.visible && game.openCloseBtn.containsPoint({
-			x: x,
-			y: y
-		})) {
-			game.openCloseState = !game.openCloseState;
-			game._hasUserToggledOpenClose = true; // Mark that user has toggled at least once
-			if (typeof game.updateOpenCloseBtn === "function") game.updateOpenCloseBtn();
-			return;
-		}
 		// Prevent interaction with cooked corn count box
 		if (game.cookedCornBox && typeof game.cookedCornBox.x === "number" && typeof game.cookedCornBox.y === "number") {
 			var localX = x - game.cookedCornBox.x;
 			var localY = y - game.cookedCornBox.y;
@@ -1796,12 +1730,8 @@
 			}
 		}
 		game.customers = [];
 	}
-	// Reset open/close state to closed and update button
-	game.openCloseState = false;
-	game._hasUserToggledOpenClose = false; // Reset user toggle tracker
-	if (typeof game.updateOpenCloseBtn === "function") game.updateOpenCloseBtn();
 	updateScreenVisibility();
 };
 // --- Asset definitions (for static analysis) ---
 // These are not real code, but LK will auto-create these assets as used above: