/**** 
* 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
	});
	self.state = 'idle'; // idle, goingToTable, goingToKitchen, 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
	self.update = function () {
		if (self.state === 'idle') {
			// If currently serving a table, check for ready food for that table
			if (self.servingTableIndex >= 0 && foodReady && !foodBeingDelivered && currentOrderTableIndex === self.servingTableIndex) {
				self.state = 'goingToKitchen';
			} else if (self.servingTableIndex < 0) {
				// Only take new orders when not serving any table
				// Check for tables with orders
				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 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 && (
					// Make sure this waiter is not already serving this table
					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;
					}
				}
			}
		} 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 through global variables
				currentOrderFoodType = self.carryingFoodType;
				currentOrderTableIndex = self.targetTableIndex;
				chefHasOrder = true;
				self.state = 'goingToKitchen';
			}
		} 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 {
				// Check if food is ready for pickup
				if (foodReady && !self.hasFood && currentOrderTableIndex === self.servingTableIndex) {
					self.hasFood = true;
					foodReady = false;
					foodBeingDelivered = true;
					self.carryingFoodType = currentOrderFoodType; // Remember which food type
					self.targetTableIndex = currentOrderTableIndex; // Remember target table
					self.food = self.attachAsset(foodImageIds[self.carryingFoodType], {
						anchorX: 0.5,
						anchorY: 0.5,
						y: -40
					});
					// Deliver to the specific table that ordered this food
					if (self.targetTableIndex >= 0 && self.targetTableIndex < tables.length) {
						self.targetTable = tables[self.targetTableIndex];
						self.state = 'deliveringFood';
					}
				}
				// Stay at kitchen waiting for food - don't go back to idle
			}
		} 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;
				// Immediately check for next table to serve
				var foundNextTable = false;
				for (var i = 0; i < tables.length; i++) {
					// Check if any other waiter is already serving this table
					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;
							}
						}
					}
					// 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
						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
****/ 
// Game variables
// Food image assets (replace with your own images as needed)
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;
	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 = [];
// 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);
		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;
	}
};

===================================================================
--- original.js
+++ change.js
@@ -508,8 +508,33 @@
 		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,
@@ -617,22 +642,27 @@
 			}
 		}
 		// Only spawn new customer if no one is waiting
 		if (!hasWaitingCustomer) {
-			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;
+			// 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
 			}
-			// If no table available, customer will wait
 		}
 	}
 	// Save periodically
 	if (LK.ticks % 300 === 0) {