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

/**** 
* Classes
****/ 
var Chef = Container.expand(function () {
	var self = Container.call(this);
	var chefGraphics = self.attachAsset('chef', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.cooking = false;
	self.cookTime = 0;
	self.currentFoodType = -1; // Track which food type is being cooked
	self.targetTableIndex = -1; // Track which table the food is for
	self.update = function () {
		if (chefHasOrder && !self.cooking && !foodReady) {
			self.cooking = true;
			self.cookTime = 0;
			self.currentFoodType = currentOrderFoodType; // Remember which food to cook
			self.targetTableIndex = currentOrderTableIndex; // Remember which table it's for
			// Log which table number's order is being cooked
			if (self.targetTableIndex >= 0 && self.targetTableIndex < tables.length) {
				console.log('Chef cooking for table number: ' + tables[self.targetTableIndex].tableNumber);
			}
			chefHasOrder = false;
		}
		if (self.cooking) {
			self.cookTime++;
			if (self.cookTime > cookingSpeed) {
				self.cooking = false;
				foodReady = true;
				// Pass cooked food info back through globals
				currentOrderFoodType = self.currentFoodType;
				currentOrderTableIndex = self.targetTableIndex;
				// Reset order taken for the specific table
				if (self.targetTableIndex >= 0 && self.targetTableIndex < orderTaken.length) {
					orderTaken[self.targetTableIndex] = false;
				}
			}
		}
	};
	return self;
});
var Customer = Container.expand(function () {
	var self = Container.call(this);
	var customerGraphics = self.attachAsset('customer', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.targetTable = null;
	self.targetTableIndex = -1; // Track which table index is reserved
	self.state = 'entering'; // entering, seated, waiting, eating, paying, leaving
	self.eatingTime = 0;
	self.waitTime = 0;
	self.foodType = Math.floor(Math.random() * foodTypes.length); // Random food type
	self.update = function () {
		if (self.state === 'entering') {
			if (self.targetTable) {
				// Only allow sitting if table is not occupied and no customer is still at the table
				if (!self.targetTable.occupied && !self.targetTable.customer) {
					var dx = self.targetTable.x - self.x;
					var dy = self.targetTable.y - self.y;
					var dist = Math.sqrt(dx * dx + dy * dy);
					if (dist > 5) {
						self.x += dx / dist * customerSpeed;
						self.y += dy / dist * customerSpeed;
					} else {
						self.state = 'seated';
						self.targetTable.occupied = true;
						self.targetTable.customer = self;
					}
				} else {
					// Table is not available, clear assignment and wait
					self.targetTable = null;
					self.targetTableIndex = -1;
				}
			} else {
				// Wait in line near entrance if no table available
				if (self.y < 200) {
					self.y += customerSpeed;
				}
			}
		} else if (self.state === 'eating') {
			// Spawn food image above customer if not already present
			if (!self.foodOnHead) {
				self.foodOnHead = self.attachAsset(foodImageIds[self.foodType], {
					anchorX: 0.5,
					anchorY: 1.2,
					y: -60
				});
			}
			self.eatingTime++;
			if (self.eatingTime > 180) {
				// 3 seconds at 60fps
				self.state = 'paying';
				// Remove food from above customer
				if (self.foodOnHead) {
					self.foodOnHead.destroy();
					self.foodOnHead = null;
				}
				if (self.targetTable) {
					self.targetTable.foodDelivered = false;
					if (self.targetTable.food) {
						self.targetTable.food.destroy();
						self.targetTable.food = null;
					}
				}
			}
		} else if (self.state === 'paying') {
			var dx = registerX - self.x;
			var dy = registerY - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * customerSpeed;
				self.y += dy / dist * customerSpeed;
			} else {
				// Add money based on food type price
				money += foodPrices[self.foodType];
				// Update last sold food info
				lastSoldFoodName = foodNames[self.foodType];
				lastSoldFoodPrice = foodPrices[self.foodType];
				self.state = 'leaving';
				if (self.targetTable) {
					self.targetTable.occupied = false;
					self.targetTable.customer = null;
					self.targetTable.orderPlaced = false;
					self.targetTable.orderedFoodType = -1; // Reset food type
				}
				// Clear reservation
				if (self.targetTableIndex >= 0) {
					tableReservations[self.targetTableIndex] = false;
				}
			}
		} else if (self.state === 'leaving') {
			self.y += customerSpeed;
			if (self.y > 2800) {
				// Clear reservation before destroying
				if (self.targetTableIndex >= 0) {
					tableReservations[self.targetTableIndex] = false;
				}
				// Clean up food on table if still present
				if (self.targetTable && self.targetTable.food) {
					self.targetTable.food.destroy();
					self.targetTable.food = null;
					self.targetTable.foodDelivered = false;
					self.targetTable.orderPlaced = false;
					self.targetTable.orderedFoodType = -1;
				}
				self.destroy();
				var index = customers.indexOf(self);
				if (index > -1) customers.splice(index, 1);
			}
		} else if (self.state === 'seated') {
			self.waitTime++;
			if (self.waitTime > 120) {
				// 2 seconds
				self.targetTable.orderPlaced = true;
				self.targetTable.orderedFoodType = self.foodType; // Set the food type on table
				self.state = 'waiting';
			}
		}
	};
	return self;
});
var Table = Container.expand(function () {
	var self = Container.call(this);
	var tableGraphics = self.attachAsset('table', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var chairLeft = self.attachAsset('chair', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -80,
		y: 0
	});
	var chairRight = self.attachAsset('chair', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 80,
		y: 0
	});
	self.occupied = false;
	self.customer = null;
	self.food = null;
	self.orderPlaced = false;
	self.foodDelivered = false;
	self.orderedFoodType = -1; // Store which food type was ordered
	self.tableNumber = -1; // Table number for tracking
	// Create table number text
	self.numberText = new Text2('', {
		size: 50,
		fill: 0xFFFFFF
	});
	self.numberText.anchor.set(0.5, 0.5);
	self.addChild(self.numberText);
	// Method to set table number
	self.setTableNumber = function (number) {
		self.tableNumber = number;
		self.numberText.setText('' + number);
	};
	return self;
});
var Waiter = Container.expand(function () {
	var self = Container.call(this);
	var waiterGraphics = self.attachAsset('waiter', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Each waiter manages their own order/food state
	self.state = 'idle'; // idle, goingToTable, goingToKitchen, waitingForFood, deliveringFood
	self.targetTable = null;
	self.hasFood = false;
	self.food = null;
	self.carryingFoodType = -1; // Track which food type waiter is carrying
	self.targetTableIndex = -1; // Track which table the order/food is for
	self.servingTableIndex = -1; // Track which table is being served until order is complete
	// Per-waiter order/food state
	self.waiterHasOrder = false;
	self.waiterFoodReady = false;
	self.waiterFoodType = -1;
	self.waiterOrderTableIndex = -1;
	// Each waiter must have their own last state for defensive code
	self.lastState = '';
	self.update = function () {
		// IDLE: Look for a table to serve
		if (self.state === 'idle') {
			// Only take new orders when not serving any table
			for (var i = 0; i < tables.length; i++) {
				// Check if any other waiter is already serving this table
				var beingServed = false;
				// Check main waiter
				if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
				// Check all extra waiters
				if (typeof game !== "undefined" && game.extraWaiters) {
					for (var w = 0; w < game.extraWaiters.length; w++) {
						if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
							beingServed = true;
							break;
						}
					}
				}
				// Only serve table if not being served by any waiter, and not already assigned to another waiter
				if (tables[i].orderPlaced && !orderTaken[i] && !beingServed && (self.servingTableIndex === -1 || self.servingTableIndex !== i)) {
					self.state = 'goingToTable';
					self.targetTable = tables[i];
					self.targetTableIndex = i;
					self.servingTableIndex = i; // Start serving this table
					// Log which table number is being served
					console.log('Waiter serving table number: ' + tables[i].tableNumber);
					break;
				}
			}
		}
		// GOING TO TABLE: Move to table to take order
		else if (self.state === 'goingToTable') {
			var dx = self.targetTable.x - self.x;
			var dy = self.targetTable.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				orderTaken[self.targetTableIndex] = true;
				self.carryingFoodType = self.targetTable.orderedFoodType; // Remember the food type
				// Pass order details to chef via per-waiter state
				self.waiterHasOrder = true;
				self.waiterFoodType = self.carryingFoodType;
				self.waiterOrderTableIndex = self.targetTableIndex;
				// Instead of idling, go to kitchen to deliver order
				self.state = 'goingToKitchen';
			}
		}
		// GOING TO KITCHEN: Move to kitchen to deliver order
		else if (self.state === 'goingToKitchen') {
			var dx = kitchenX - self.x;
			var dy = kitchenY - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				// If just arrived at kitchen, submit order to chef if not already submitted
				if (self.waiterHasOrder && !self.waiterFoodReady) {
					// Only one waiter can submit to chef at a time
					if (!chefHasOrder && !foodReady) {
						chefHasOrder = true;
						currentOrderFoodType = self.waiterFoodType;
						currentOrderTableIndex = self.waiterOrderTableIndex;
						// Mark that this waiter is waiting for food
						self.waiterHasOrder = false;
						self.state = 'waitingForFood';
					}
				} else if (self.waiterFoodReady) {
					// Pick up food if ready
					if (!self.hasFood) {
						self.hasFood = true;
						self.food = self.attachAsset(foodImageIds[self.carryingFoodType], {
							anchorX: 0.5,
							anchorY: 0.5,
							y: -40
						});
						self.state = 'deliveringFood';
					}
				}
				// Stay at kitchen waiting for food
			}
		}
		// WAITING FOR FOOD: Wait at kitchen until chef finishes
		else if (self.state === 'waitingForFood') {
			// Move and stand next to the kitchen while waiting
			var waitOffsetX = 120 + 80 * (typeof game !== "undefined" && game.extraWaiters ? game.extraWaiters.indexOf(self) + 1 : 0);
			var targetX = kitchenX + waitOffsetX;
			var targetY = kitchenY + 60;
			var dx = targetX - self.x;
			var dy = targetY - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				self.x = targetX;
				self.y = targetY;
			}
			// Wait for chef to finish the order for this table
			if (foodReady && currentOrderTableIndex === self.servingTableIndex) {
				// Mark food as ready for this waiter
				self.waiterFoodReady = true;
				foodReady = false;
				foodBeingDelivered = true;
				self.carryingFoodType = currentOrderFoodType;
				self.targetTableIndex = currentOrderTableIndex;
				self.state = 'goingToKitchen'; // Will pick up food next update
			}
		}
		// DELIVERING FOOD: Move to table to deliver food
		else if (self.state === 'deliveringFood') {
			var dx = self.targetTable.x - self.x;
			var dy = self.targetTable.y - self.y;
			var dist = Math.sqrt(dx * dx + dy * dy);
			if (dist > 5) {
				self.x += dx / dist * waiterSpeed;
				self.y += dy / dist * waiterSpeed;
			} else {
				if (self.food) {
					self.food.destroy();
					self.food = null;
				}
				self.hasFood = false;
				foodBeingDelivered = false;
				// Mark food delivered and reset order state so waiter doesn't deliver again
				self.targetTable.foodDelivered = true;
				self.targetTable.food = self.targetTable.attachAsset(foodImageIds[self.carryingFoodType], {
					anchorX: 0.5,
					anchorY: 0.5,
					y: -20
				});
				self.targetTable.orderPlaced = false; // Reset orderPlaced so waiter doesn't deliver again
				orderTaken[self.targetTableIndex] = false; // Reset orderTaken for this table
				self.targetTable.orderedFoodType = -1; // Reset food type for this table
				if (self.targetTable.customer) {
					self.targetTable.customer.state = 'eating';
				}
				self.servingTableIndex = -1; // Order complete, can serve another table
				self.targetTable = null;
				self.waiterFoodReady = false;
				self.waiterFoodType = -1;
				self.waiterOrderTableIndex = -1;
				// Immediately check for next table to serve
				var foundNextTable = false;
				for (var i = 0; i < tables.length; i++) {
					var beingServed = false;
					if (typeof waiter !== "undefined" && waiter !== self && waiter.servingTableIndex === i) beingServed = true;
					if (typeof game !== "undefined" && game.extraWaiters) {
						for (var w = 0; w < game.extraWaiters.length; w++) {
							if (game.extraWaiters[w] !== self && game.extraWaiters[w].servingTableIndex === i) {
								beingServed = true;
								break;
							}
						}
					}
					if (tables[i].orderPlaced && !orderTaken[i] && !beingServed && (self.servingTableIndex === -1 || self.servingTableIndex !== i)) {
						self.state = 'goingToTable';
						self.targetTable = tables[i];
						self.targetTableIndex = i;
						self.servingTableIndex = i;
						console.log('Waiter immediately serving next table number: ' + tables[i].tableNumber);
						foundNextTable = true;
						break;
					}
				}
				if (!foundNextTable) {
					self.state = 'idle';
				}
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Food image assets (replace with your own images as needed)
// Game variables
var money = typeof storage.money !== "undefined" ? storage.money : 1000;
var restaurantLevel = storage.restaurantLevel || 1;
var tableCount = storage.tableCount || 2;
var tableReservations = []; // Track which tables are reserved by customers
// Food types
var foodTypes = ['pizza', 'burger', 'pasta', 'salad', 'soup', 'sushi', 'steak', 'curry', 'taco', 'dumpling'];
var foodNames = ['Pizza', 'Burger', 'Pasta', 'Salad', 'Soup', 'Sushi', 'Steak', 'Curry', 'Taco', 'Dumpling'];
var foodImageIds = ['food_pizza', 'food_burger', 'food_pasta', 'food_salad', 'food_soup', 'food_sushi', 'food_steak', 'food_curry', 'food_taco', 'food_dumpling'];
var foodColors = [0xff6347, 0x8b4513, 0xffa500, 0x32cd32, 0xffd700, 0x6ad1e3, 0x8b0000, 0xf7b32b, 0xf4a259, 0xf7e7ce];
// Food prices: multiples of 6, each next is 10% more (rounded to nearest integer)
var foodPrices = [6, 7, 8, 9, 10, 11, 12, 13, 14, 15]; // Will be set below
// Calculate food prices as 6, 6*1.1, 6*1.21, ... for all foodTypes (rounded)
foodPrices[0] = 6;
for (var i = 1; i < foodTypes.length; i++) {
	foodPrices[i] = Math.round(foodPrices[i - 1] * 1.1);
}
// Speed variables (lower is faster)
var customerSpeed = 3;
var waiterSpeed = 4;
var cookingSpeed = 180; // 3 seconds at 60fps
// Game state
var tables = [];
var customers = [];
var orderTaken = [];
var chefHasOrder = false;
var foodReady = false;
var foodBeingDelivered = false;
var currentOrderFoodType = -1; // Track current order food type
var currentOrderTableIndex = -1; // Track current order table index
// Positions
var kitchenX = 1024;
var kitchenY = 400;
var registerX = 1024;
var registerY = 2400;
// UI Elements
var moneyText = new Text2('Money: $0', {
	size: 60,
	fill: 0x000000
});
moneyText.anchor.set(0.5, 0);
LK.gui.top.addChild(moneyText);
// --- Reset Game Button (to the left of the coin) ---
var resetButton = new Text2('Reset', {
	size: 48,
	fill: 0xFFFFFF
});
resetButton.anchor.set(1, 0); // right-top anchor
resetButton.x = moneyText.x - 180; // Place to the left of moneyText (coin)
resetButton.y = moneyText.y + 8; // Align vertically with moneyText
resetButton.interactive = true;
resetButton.buttonMode = true;
resetButton.down = function () {
	// Reset all purchases to initial values before game over
	storage.money = 1000;
	storage.restaurantLevel = 1;
	storage.tableCount = 2;
	storage.advertisementLevel = 0;
	storage.extraWaiterCount = 0;
	LK.showGameOver(); // This will reset the game state
};
LK.gui.top.addChild(resetButton);
// --- Last sold food info (top right) ---
var lastSoldFoodName = '';
var lastSoldFoodPrice = 0;
var lastSoldText = new Text2('', {
	size: 48,
	fill: 0x000000
});
lastSoldText.anchor.set(1, 0); // right-top
LK.gui.topRight.addChild(lastSoldText);
// Create kitchen
var kitchen = game.addChild(LK.getAsset('kitchen', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: kitchenX,
	y: kitchenY
}));
// Create register
var register = game.addChild(LK.getAsset('register', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: registerX,
	y: registerY
}));
// Create chef
var chef = game.addChild(new Chef());
chef.x = kitchenX;
chef.y = kitchenY;
// Create waiter
var waiter = game.addChild(new Waiter());
// Spawn main waiter in front of the register (kasa)
waiter.x = registerX - 120;
waiter.y = registerY + 60;
// Always initialize extraWaiters as an array so new waiters can be added and updated
game.extraWaiters = [];
// If there are extra waiters from storage, spawn them in front of the register
if (typeof storage.extraWaiterCount !== "undefined" && storage.extraWaiterCount > 0) {
	for (var ew = 0; ew < storage.extraWaiterCount; ew++) {
		var extraWaiter = game.addChild(new Waiter());
		extraWaiter.x = registerX + 120 + 100 * ew;
		extraWaiter.y = registerY + 60;
		game.extraWaiters.push(extraWaiter);
	}
}
// Create initial tables
function createTable(index) {
	var table = game.addChild(new Table());
	var row = Math.floor(index / 2);
	var col = index % 2;
	table.x = 600 + col * 400;
	table.y = 800 + row * 300;
	table.setTableNumber(index + 1); // Set table number (1-based)
	tables.push(table);
	orderTaken.push(false);
	tableReservations.push(false); // Initialize reservation status
}
for (var i = 0; i < tableCount; i++) {
	createTable(i);
}
// Upgrade speed button
var upgradeButton = game.addChild(LK.getAsset('upgradeButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 500,
	y: 2200
}));
var upgradeText = new Text2('Upgrade Speed $50', {
	size: 40,
	fill: 0xFFFFFF
});
upgradeText.anchor.set(0.5, 0.5);
upgradeText.x = 500;
upgradeText.y = 2200;
game.addChild(upgradeText);
upgradeButton.down = function () {
	if (money >= 50) {
		money -= 50;
		restaurantLevel++;
		customerSpeed = Math.max(2, customerSpeed - 0.5);
		waiterSpeed = Math.max(2, waiterSpeed - 0.5);
		cookingSpeed = Math.max(60, cookingSpeed - 20);
		storage.restaurantLevel = restaurantLevel;
		storage.money = money;
		LK.effects.flashObject(upgradeButton, 0x00FF00, 500);
	}
};
// --- Advertisement Upgrade Button below Upgrade Speed ---
var advertisementLevel = typeof storage.advertisementLevel !== "undefined" ? storage.advertisementLevel : 0;
var advertisementButton = game.addChild(LK.getAsset('upgradeButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 500,
	y: 2280
}));
var advertisementText = new Text2('Advertisement $100', {
	size: 40,
	fill: 0xFFFFFF
});
advertisementText.anchor.set(0.5, 0.5);
advertisementText.x = 500;
advertisementText.y = 2280;
game.addChild(advertisementText);
advertisementButton.down = function () {
	if (money >= 100) {
		money -= 100;
		advertisementLevel++;
		storage.advertisementLevel = advertisementLevel;
		storage.money = money;
		LK.effects.flashObject(advertisementButton, 0x00FF00, 500);
	}
};
// Add table button
var addTableButton = game.addChild(LK.getAsset('addTableButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1500,
	y: 2200
}));
var addTableText = new Text2('Add Table $100', {
	size: 40,
	fill: 0xFFFFFF
});
addTableText.anchor.set(0.5, 0.5);
addTableText.x = 1500;
addTableText.y = 2200;
game.addChild(addTableText);
addTableButton.down = function () {
	if (money >= 100 && tables.length < 8) {
		money -= 100;
		createTable(tables.length);
		tableCount++;
		storage.tableCount = tableCount;
		storage.money = money;
		LK.effects.flashObject(addTableButton, 0x00FF00, 500);
	}
};
// --- Buy Waiter button below Add Table ---
var buyWaiterButton = game.addChild(LK.getAsset('addTableButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1500,
	y: 2300
}));
var buyWaiterText = new Text2('Buy Waiter $200', {
	size: 40,
	fill: 0xFFFFFF
});
buyWaiterText.anchor.set(0.5, 0.5);
buyWaiterText.x = 1500;
buyWaiterText.y = 2300;
game.addChild(buyWaiterText);
buyWaiterButton.down = function () {
	// Always ensure extraWaiters is an array
	if (!game.extraWaiters) {
		game.extraWaiters = [];
	}
	// Only allow buying if enough money and max 4 waiters total (1 main + 3 extra)
	if (money >= 200 && game.extraWaiters.length < 3) {
		money -= 200;
		// Find a table index that is not being served by any waiter
		var servingTableIndices = [];
		if (typeof waiter !== "undefined") {
			if (waiter.servingTableIndex >= 0) servingTableIndices.push(waiter.servingTableIndex);
		}
		for (var w = 0; w < game.extraWaiters.length; w++) {
			if (game.extraWaiters[w].servingTableIndex >= 0) servingTableIndices.push(game.extraWaiters[w].servingTableIndex);
		}
		// Create a new waiter and place in front of the register (kasa)
		var extraWaiter = game.addChild(new Waiter());
		extraWaiter.x = registerX + 120 + 100 * game.extraWaiters.length;
		extraWaiter.y = registerY + 60;
		// Ensure new waiter is not serving the same table as others (will be handled in Waiter logic)
		game.extraWaiters.push(extraWaiter);
		// Save extraWaiterCount for persistence
		storage.extraWaiterCount = game.extraWaiters.length;
		storage.money = money;
		LK.effects.flashObject(buyWaiterButton, 0x00FF00, 500);
	}
};
// Customer spawn timer
var customerSpawnTimer = 0;
// Game update
game.update = function () {
	// Update all waiters (main and extra)
	if (typeof waiter !== "undefined" && waiter.update) waiter.update();
	if (typeof game !== "undefined" && game.extraWaiters) {
		for (var w = 0; w < game.extraWaiters.length; w++) {
			if (game.extraWaiters[w] && game.extraWaiters[w].update) game.extraWaiters[w].update();
		}
	}
	// Update money display
	moneyText.setText('Money: $' + money);
	// Update last sold food info display
	if (lastSoldFoodName && lastSoldFoodPrice) {
		lastSoldText.setText('Son Satış: ' + lastSoldFoodName + ' ($' + lastSoldFoodPrice + ')');
	} else {
		lastSoldText.setText('');
	}
	// Spawn customers
	customerSpawnTimer++;
	if (customerSpawnTimer > 300) {
		// Every 5 seconds
		customerSpawnTimer = 0;
		// Check if there are waiting customers first
		var hasWaitingCustomer = false;
		for (var j = 0; j < customers.length; j++) {
			if (customers[j].state === 'entering' && !customers[j].targetTable) {
				hasWaitingCustomer = true;
				// Try to assign a table to waiting customer
				for (var k = 0; k < tables.length; k++) {
					if (!tables[k].occupied && !tables[k].customer && !tableReservations[k]) {
						customers[j].targetTable = tables[k];
						customers[j].targetTableIndex = k;
						tableReservations[k] = true; // Reserve the table
						break;
					}
				}
				break;
			}
		}
		// Only spawn new customer if no one is waiting
		if (!hasWaitingCustomer) {
			// Determine how many customers to spawn: 1 + 2 per advertisementLevel
			var advLevel = typeof advertisementLevel !== "undefined" ? advertisementLevel : typeof storage.advertisementLevel !== "undefined" ? storage.advertisementLevel : 0;
			var spawnCount = 1 + 2 * advLevel;
			for (var spawnIdx = 0; spawnIdx < spawnCount; spawnIdx++) {
				var customer = game.addChild(new Customer());
				customer.x = 1024;
				customer.y = -50;
				customers.push(customer);
				// Try to find available table
				for (var i = 0; i < tables.length; i++) {
					if (!tables[i].occupied && !tables[i].customer && !tableReservations[i]) {
						customer.targetTable = tables[i];
						customer.targetTableIndex = i;
						tableReservations[i] = true; // Reserve the table
						break;
					}
				}
				// If no table available, customer will wait
			}
		}
	}
	// Save periodically
	if (LK.ticks % 300 === 0) {
		storage.money = money;
	}
};