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

/**** 
* Classes
****/ 
// --- Blackjack Game Logic ---
var BlackjackGame = Container.expand(function () {
	var self = Container.call(this);
	// State
	self.currentSeat = 0; // Track which seat is currently active
	self.deck = [];
	self.playerHand = [];
	self.dealerHand = [];
	self.playerCards = [];
	self.dealerCards = [];
	self.state = 'bet'; // 'bet', 'player', 'dealer', 'result', 'betBehind'
	self.resultText = null;
	self.buttons = [];
	self.bet = betAmount;
	self.betBehind = 0; // Amount bet behind
	self.betBehindWin = 0; // Track bet behind win for this round
	// Table background
	var table = self.attachAsset('bjTable', {
		width: 1400,
		height: 900,
		color: 0x2e8b57,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 1200
	});
	// Deal new deck
	self.newDeck = function () {
		var suits = ['♠', '♥', '♦', '♣'];
		var ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'];
		var deck = [];
		for (var s = 0; s < 4; s++) {
			for (var r = 0; r < 13; r++) {
				deck.push({
					rank: ranks[r],
					suit: suits[s]
				});
			}
		}
		// Shuffle
		for (var i = deck.length - 1; i > 0; i--) {
			var j = Math.floor(Math.random() * (i + 1));
			var t = deck[i];
			deck[i] = deck[j];
			deck[j] = t;
		}
		self.deck = deck;
	};
	// Draw a card
	self.drawCard = function () {
		if (self.deck.length === 0) self.newDeck();
		return self.deck.pop();
	};
	// Calculate hand value
	self.handValue = function (hand) {
		var value = 0;
		var aces = 0;
		for (var i = 0; i < hand.length; i++) {
			var r = hand[i].rank;
			if (r === 'A') {
				value += 11;
				aces++;
			} else if (r === 'K' || r === 'Q' || r === 'J') {
				value += 10;
			} else {
				value += parseInt(r);
			}
		}
		while (value > 21 && aces > 0) {
			value -= 10;
			aces--;
		}
		return value;
	};
	// Start a new round
	self.startRound = function () {
		self.state = 'player';
		self.playerHand = [];
		self.dealerHand = [];
		self.clearCards();
		self.resultText && self.resultText.destroy();
		self.resultText = null;
		// Bet
		self.bet = betAmount;
		self.betBehindWin = 0;
		self.perfectPairWin = false; // Track perfect pair win for this round
		if (playerBalance < self.bet) {
			self.showResult('Not enough balance!', true);
			return;
		}
		playerBalance -= self.bet;
		updateBalance();
		// Deal
		// Deal cards with animation
		self.playerHand.push(self.drawCard());
		self.dealerHand.push(self.drawCard());
		self.playerHand.push(self.drawCard());
		self.dealerHand.push(self.drawCard());
		self.clearCards();
		// --- Perfect Pair Side Bet Logic ---
		// If first two player cards are same rank and same suit, pay 25:1
		self.perfectPairWin = false;
		self.perfectPairPayout = 0;
		if (self.playerHand.length === 2 && self.playerHand[0].rank === self.playerHand[1].rank && self.playerHand[0].suit === self.playerHand[1].suit) {
			self.perfectPairWin = true;
			self.perfectPairPayout = self.bet * 25;
			playerBalance += self.perfectPairPayout;
			updateBalance();
			// Show a quick popup for perfect pair win
			var pairText = new Text2('Perfect Pair! +$' + self.perfectPairPayout, {
				size: 80,
				fill: 0xFFE066
			});
			pairText.anchor.set(0.5, 0.5);
			pairText.x = 2048 / 2;
			pairText.y = 1550;
			self.addChild(pairText);
			tween(pairText, {
				y: pairText.y - 120,
				alpha: 0
			}, {
				duration: 1200,
				onFinish: function onFinish() {
					pairText.destroy();
				}
			});
		}
		// Card distribution animation
		var px = 2048 / 2 - 200;
		var py = 1700;
		var dx = 2048 / 2 - 200;
		var dy = 900;
		var dealDelay = 200;
		var dealDuration = 350;
		var dealStartX = 2048 / 2;
		var dealStartY = 1200;
		self.playerCards = [];
		self.dealerCards = [];
		// Helper to animate a card to its position
		function animateCard(card, toX, toY, delay, isPlayer) {
			card.x = dealStartX;
			card.y = dealStartY;
			card.visible = true;
			self.addChild(card);
			tween(card, {
				x: toX,
				y: toY
			}, {
				duration: dealDuration,
				easing: tween.cubicOut,
				delay: delay
			});
			if (isPlayer) {
				self.playerCards.push(card);
			} else {
				self.dealerCards.push(card);
			}
		}
		// Create and animate cards in order: player1, dealer1, player2, dealer2
		var playerCard1 = new Card();
		playerCard1.setCard(self.playerHand[0].rank, self.playerHand[0].suit, true);
		playerCard1.visible = false;
		var dealerCard1 = new Card();
		dealerCard1.setCard(self.dealerHand[0].rank, self.dealerHand[0].suit, true);
		dealerCard1.visible = false;
		var playerCard2 = new Card();
		playerCard2.setCard(self.playerHand[1].rank, self.playerHand[1].suit, true);
		playerCard2.visible = false;
		var dealerCard2 = new Card();
		dealerCard2.setCard(self.dealerHand[1].rank, self.dealerHand[1].suit, false);
		dealerCard2.visible = false;
		LK.setTimeout(function () {
			animateCard(playerCard1, px, py, 0, true);
			playerCard1.visible = true;
			LK.setTimeout(function () {
				animateCard(dealerCard1, dx, dy, 0, false);
				dealerCard1.visible = true;
				LK.setTimeout(function () {
					animateCard(playerCard2, px + 120, py, 0, true);
					playerCard2.visible = true;
					LK.setTimeout(function () {
						animateCard(dealerCard2, dx + 120, dy, 0, false);
						dealerCard2.visible = true;
						// After all cards are dealt, show buttons
						LK.setTimeout(function () {
							self.showButtons(['Hit', 'Stand']);
						}, dealDuration);
					}, dealDelay);
				}, dealDelay);
			}, dealDelay);
		}, 0);
	};
	// Show cards on table
	self.showHands = function (revealDealer) {
		self.clearCards();
		// Player
		var px = 2048 / 2 - 200;
		var py = 1700;
		for (var i = 0; i < self.playerHand.length; i++) {
			var c = new Card();
			c.setCard(self.playerHand[i].rank, self.playerHand[i].suit, true);
			c.x = px + i * 120;
			c.y = py;
			c.visible = true; // Player cards are visible
			self.addChild(c);
			self.playerCards.push(c);
		}
		// Dealer
		var dx = 2048 / 2 - 200;
		var dy = 900;
		for (var i = 0; i < self.dealerHand.length; i++) {
			var c = new Card();
			var faceUp = i === 0 || revealDealer;
			c.setCard(self.dealerHand[i].rank, self.dealerHand[i].suit, faceUp);
			c.x = dx + i * 120;
			c.y = dy;
			c.visible = revealDealer ? true : false; // Show dealer cards only if revealDealer is true
			self.addChild(c);
			self.dealerCards.push(c);
		}
	};
	// Remove card objects
	self.clearCards = function () {
		for (var i = 0; i < self.playerCards.length; i++) {
			self.playerCards[i].destroy();
		}
		for (var i = 0; i < self.dealerCards.length; i++) {
			self.dealerCards[i].destroy();
		}
		self.playerCards = [];
		self.dealerCards = [];
	};
	// Show action buttons
	self.showButtons = function (labels) {
		for (var i = 0; i < self.buttons.length; i++) {
			self.buttons[i].destroy();
		}
		self.buttons = [];
		// If in player state, add Double if allowed (first move, enough balance, only 2 cards)
		var showDouble = false;
		if (self.state === 'player' && self.playerHand.length === 2 && playerBalance >= self.bet) {
			showDouble = true;
			if (labels.indexOf('Double') === -1) labels.push('Double');
		}
		// Add Bet Behind button if in 'bet' state and player has enough balance
		if (self.state === 'bet' && playerBalance >= betAmount) {
			labels.push('Bet Behind');
		}
		var startX = 2048 / 2 - (labels.length - 1) * 220;
		for (var i = 0; i < labels.length; i++) {
			var btn = new GameButton();
			btn.setText(labels[i]);
			btn.x = startX + i * 440;
			btn.y = 2100;
			btn.action = labels[i];
			btn.down = function () {
				this.flash();
				if (this.action === 'Bet Behind') {
					// Place bet behind
					if (playerBalance >= betAmount) {
						self.betBehind += betAmount;
						playerBalance -= betAmount;
						updateBalance();
						// Show quick popup for bet behind placed
						var bbText = new Text2('Bet Behind: $' + self.betBehind, {
							size: 70,
							fill: 0x66ffcc
						});
						bbText.anchor.set(0.5, 0.5);
						bbText.x = 2048 / 2;
						bbText.y = 2000;
						self.addChild(bbText);
						tween(bbText, {
							y: bbText.y - 80,
							alpha: 0
						}, {
							duration: 900,
							onFinish: function onFinish() {
								bbText.destroy();
							}
						});
					}
				} else {
					self.handleAction(this.action);
				}
			};
			self.addChild(btn);
			self.buttons.push(btn);
		}
	};
	// Handle player actions
	self.handleAction = function (action) {
		if (self.state !== 'player') return;
		if (action === 'Hit') {
			self.playerHand.push(self.drawCard());
			self.showHands();
			var val = self.handValue(self.playerHand);
			if (val > 21) {
				self.state = 'result';
				self.showHands(true);
				self.showResult('Bust! You lose.');
			}
		} else if (action === 'Stand') {
			self.state = 'dealer';
			self.showHands(true);
			self.showButtons([]);
			self.dealerTurn();
		} else if (action === 'Double') {
			// Double the bet, draw one card, then stand
			if (playerBalance >= self.bet && self.playerHand.length === 2) {
				playerBalance -= self.bet;
				self.bet *= 2;
				updateBalance();
				self.playerHand.push(self.drawCard());
				self.showHands();
				var val = self.handValue(self.playerHand);
				if (val > 21) {
					self.state = 'result';
					self.showHands(true);
					self.showResult('Bust! You lose.');
				} else {
					self.state = 'dealer';
					self.showHands(true);
					self.showButtons([]);
					self.dealerTurn();
				}
			}
		}
	};
	// Dealer logic
	self.dealerTurn = function () {
		var self_ = self;
		var dealerVal = self.handValue(self.dealerHand);
		var playerVal = self.handValue(self.playerHand);
		function dealerStep() {
			dealerVal = self_.handValue(self_.dealerHand);
			if (dealerVal < 17) {
				self_.dealerHand.push(self_.drawCard());
				self_.showHands(true);
				LK.setTimeout(dealerStep, 700);
			} else {
				self_.state = 'result';
				self_.showHands(true);
				self_.showResult(self_.getResultText());
			}
		}
		LK.setTimeout(dealerStep, 700);
	};
	// Determine result
	self.getResultText = function () {
		var playerVal = self.handValue(self.playerHand);
		var dealerVal = self.handValue(self.dealerHand);
		if (playerVal > 21) return 'Bust! You lose.';
		// Dealer busts
		if (dealerVal > 21) {
			playerBalance += self.bet * 2;
			// Bet behind wins if player hand not bust
			if (self.betBehind > 0 && playerVal <= 21) {
				self.betBehindWin = self.betBehind * 2;
				playerBalance += self.betBehindWin;
			}
			updateBalance();
			return 'Dealer busts! You win!' + (self.betBehindWin > 0 ? '\nBet Behind Win: $' + self.betBehindWin : '');
		}
		// Player wins
		if (playerVal > dealerVal) {
			playerBalance += self.bet * 2;
			// Bet behind wins if player hand not bust
			if (self.betBehind > 0 && playerVal <= 21) {
				self.betBehindWin = self.betBehind * 2;
				playerBalance += self.betBehindWin;
			}
			updateBalance();
			return 'You win!' + (self.betBehindWin > 0 ? '\nBet Behind Win: $' + self.betBehindWin : '');
		}
		// Player loses
		if (playerVal < dealerVal) {
			// Bet behind lost
			return 'You lose.' + (self.betBehind > 0 ? '\nBet Behind Lost: $' + self.betBehind : '');
		}
		// Push
		playerBalance += self.bet;
		if (self.betBehind > 0) {
			playerBalance += self.betBehind; // Return bet behind on push
			self.betBehindWin = self.betBehind;
		}
		updateBalance();
		return 'Push!' + (self.betBehind > 0 ? '\nBet Behind Push: $' + self.betBehind : '');
	};
	// Show result and next round
	self.showResult = function (txt, noNext) {
		self.resultText && self.resultText.destroy();
		// If perfect pair win, append to result text
		if (self.perfectPairWin && txt && txt.indexOf('Perfect Pair!') === -1) {
			txt = 'Perfect Pair! +$' + self.perfectPairPayout + '\n' + txt;
		}
		self.resultText = new Text2(txt, {
			size: 90,
			fill: "#fff"
		});
		self.resultText.anchor.set(0.5, 0.5);
		self.resultText.x = 2048 / 2;
		self.resultText.y = 1450;
		self.addChild(self.resultText);
		self.showButtons(['New Round', 'Back']);
		self.buttons[0].down = function () {
			this.flash();
			self.startRound();
		};
		self.buttons[1].down = function () {
			this.flash();
			self.destroy();
			blackjack = null;
			showModeSelect();
		};
		if (noNext) {
			self.buttons[0].visible = false;
		}
	};
	// Destroy
	self.destroy = function () {
		self.clearCards();
		for (var i = 0; i < self.buttons.length; i++) {
			self.buttons[i].destroy();
		}
		self.buttons = [];
		self.resultText && self.resultText.destroy();
		self.resultText = null;
		self.perfectPairWin = false;
		self.perfectPairPayout = 0;
		self.betBehind = 0;
		self.betBehindWin = 0;
		if (self.parent) self.parent.removeChild(self);
	};
	// Start
	self.newDeck();
	self.startRound();
	return self;
});
// Card class for Blackjack
var Card = Container.expand(function () {
	var self = Container.call(this);
	// Card properties
	self.rank = null; // 2-10, J, Q, K, A
	self.suit = null; // '♠', '♥', '♦', '♣'
	self.faceUp = true;
	// Card background
	var cardBg = self.attachAsset('cardBg', {
		width: 180,
		height: 260,
		color: 0xffffff,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Card text
	var cardText = new Text2('', {
		size: 80,
		fill: 0x222222
	});
	cardText.anchor.set(0.5, 0.5);
	self.addChild(cardText);
	// Set card value
	self.setCard = function (rank, suit, faceUp) {
		self.rank = rank;
		self.suit = suit;
		self.faceUp = faceUp !== false;
		if (self.faceUp) {
			cardText.setText(rank + suit);
			cardText.visible = true;
			cardBg.color = suit === '♥' || suit === '♦' ? 0xffeaea : 0xffffff;
		} else {
			cardText.setText('');
			cardText.visible = false;
			cardBg.color = 0x8888aa;
		}
	};
	// Flip card
	self.flip = function (up) {
		self.faceUp = up;
		self.setCard(self.rank, self.suit, up);
	};
	return self;
});
// Simple Button class
var GameButton = Container.expand(function () {
	var self = Container.call(this);
	var btnBg = self.attachAsset('btnBg', {
		width: 420,
		height: 120,
		color: 0x333366,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.btnBg = btnBg; // <-- Fix: assign btnBg as a property for external access
	var btnText = new Text2('', {
		size: 60,
		fill: 0xFFFFFF
	});
	btnText.anchor.set(0.5, 0.5);
	self.addChild(btnText);
	self.setText = function (txt) {
		btnText.setText(txt);
	};
	// For touch feedback
	self.flash = function () {
		tween(btnBg, {
			color: 0x6666cc
		}, {
			duration: 100,
			onFinish: function onFinish() {
				tween(btnBg, {
					color: 0x333366
				}, {
					duration: 200
				});
			}
		});
	};
	return self;
});
// --- Roulette Game Logic ---
var RouletteGame = Container.expand(function () {
	var self = Container.call(this);
	// State
	self.state = 'bet'; // 'bet', 'spin', 'result'
	self.betType = null; // 'red', 'black', 'even', 'odd', 'number'
	self.betValue = null; // For number bet
	self.resultText = null;
	self.buttons = [];
	self.rouletteWheel = null;
	self.ball = null;
	self.spinBtn = null;
	self.backBtn = null;
	self.betOptions = [];
	self.selectedBetBtn = null;
	// Table background
	var table = self.attachAsset('bjTable', {
		width: 1200,
		height: 900,
		color: 0x2e8b57,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 1200
	});
	// Draw roulette wheel (simple circle with numbers)
	var wheelRadius = 320;
	var wheelCenterX = 2048 / 2;
	var wheelCenterY = 1200;
	var numbers = [];
	for (var i = 0; i < 37; i++) numbers.push(i);
	// Red/Black numbers (European roulette)
	var reds = [1, 3, 5, 7, 9, 12, 14, 16, 18, 19, 21, 23, 25, 27, 30, 32, 34, 36];
	var blacks = [2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35];
	// Draw wheel
	self.rouletteWheel = new Container();
	self.rouletteWheel.x = wheelCenterX;
	self.rouletteWheel.y = wheelCenterY;
	self.addChild(self.rouletteWheel);
	// Draw wheel numbers
	for (var i = 0; i < 37; i++) {
		var angle = i / 37 * Math.PI * 2 - Math.PI / 2;
		var num = numbers[i];
		// European roulette: 0 is green, reds as defined, rest are black
		var color = 0x222222; // default black
		if (num === 0) {
			color = 0x1abc2c; // vivid green for 0
		} else if (reds.indexOf(num) !== -1) {
			color = 0xff0000; // red
		}
		var slot = self.rouletteWheel.attachAsset('cardBg', {
			width: 60,
			height: 60,
			color: color,
			shape: 'box',
			anchorX: 0.5,
			anchorY: 0.5,
			x: Math.cos(angle) * wheelRadius,
			y: Math.sin(angle) * wheelRadius
		});
		var txt = new Text2(num + '', {
			size: 32,
			fill: "#fff"
		});
		txt.anchor.set(0.5, 0.5);
		slot.addChild(txt);
	}
	// Ball
	self.ball = self.rouletteWheel.attachAsset('centerCircle', {
		width: 30,
		height: 30,
		color: 0xffffff,
		shape: 'ellipse',
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.cos(-Math.PI / 2) * (wheelRadius - 40),
		y: Math.sin(-Math.PI / 2) * (wheelRadius - 40)
	});
	// Bet options
	// Allow number bets (0-36) and split bets (adjacent numbers) in a compact grid below the wheel
	var betGridCols = 10;
	var betGridRows = 4; // 37 numbers, so 4 rows (last row has 7)
	var betBtnW = 120;
	var betBtnH = 120;
	var betGridStartX = 2048 / 2 - betGridCols * betBtnW / 2 + betBtnW / 2;
	var betGridStartY = 1550;
	self.betOptions = [];
	self.splitBetOptions = []; // Store split bet buttons
	// Helper to get grid position for a number
	function getGridPos(num) {
		return {
			col: num % betGridCols,
			row: Math.floor(num / betGridCols)
		};
	}
	// Create number bet buttons
	for (var i = 0; i < 37; i++) {
		var btn = new GameButton();
		btn.setText(i + '');
		var col = i % betGridCols;
		var row = Math.floor(i / betGridCols);
		btn.x = betGridStartX + col * betBtnW;
		btn.y = betGridStartY + row * betBtnH;
		btn.betType = 'number';
		btn.betValue = i;
		btn.down = function (numBtn) {
			return function () {
				this.flash();
				// Unhighlight all bet buttons
				for (var j = 0; j < self.betOptions.length; j++) {
					if (self.betOptions[j].btnBg) self.betOptions[j].btnBg.color = 0x333366;
				}
				for (var j = 0; j < self.splitBetOptions.length; j++) {
					if (self.splitBetOptions[j].btnBg) self.splitBetOptions[j].btnBg.color = 0x333366;
				}
				// Set bet type and value
				self.betType = 'number';
				self.betValue = numBtn.betValue;
				self.selectedBetBtn = this;
				self.showResult('Number bet: ' + self.betValue + ' ($' + Math.max(betAmount, 50) + ')', true);
				// Highlight selected bet button
				if (this.btnBg) this.btnBg.color = 0x6666cc;
				// Show spin button when a bet is selected
				if (self.state === 'bet') {
					self.spinBtn.visible = true;
				}
			};
		}(btn);
		self.addChild(btn);
		self.betOptions.push(btn);
	}
	// --- Add Red/Black bet buttons ---
	var colorBetY = betGridStartY + betGridRows * betBtnH + 10;
	var redBtn = new GameButton();
	redBtn.setText('Red');
	redBtn.x = 2048 / 2 - 120;
	redBtn.y = colorBetY;
	redBtn.betType = 'red';
	redBtn.down = function () {
		this.flash();
		// Unhighlight all bet buttons
		for (var j = 0; j < self.betOptions.length; j++) {
			if (self.betOptions[j].btnBg) self.betOptions[j].btnBg.color = 0x333366;
		}
		for (var j = 0; j < self.splitBetOptions.length; j++) {
			if (self.splitBetOptions[j].btnBg) self.splitBetOptions[j].btnBg.color = 0x333366;
		}
		if (self.blackBtn && self.blackBtn.btnBg) self.blackBtn.btnBg.color = 0x333366;
		if (self.redBtn && self.redBtn.btnBg) self.redBtn.btnBg.color = 0x333366;
		self.betType = 'red';
		self.betValue = null;
		self.selectedBetBtn = this;
		self.showResult('Red bet ($' + Math.max(betAmount, 50) + ')', true);
		if (this.btnBg) this.btnBg.color = 0xff0000;
		if (self.state === 'bet') {
			self.spinBtn.visible = true;
		}
	};
	self.addChild(redBtn);
	self.betOptions.push(redBtn);
	self.redBtn = redBtn;
	var blackBtn = new GameButton();
	blackBtn.setText('Black');
	blackBtn.x = 2048 / 2 + 120;
	blackBtn.y = colorBetY;
	blackBtn.betType = 'black';
	blackBtn.down = function () {
		this.flash();
		// Unhighlight all bet buttons
		for (var j = 0; j < self.betOptions.length; j++) {
			if (self.betOptions[j].btnBg) self.betOptions[j].btnBg.color = 0x333366;
		}
		for (var j = 0; j < self.splitBetOptions.length; j++) {
			if (self.splitBetOptions[j].btnBg) self.splitBetOptions[j].btnBg.color = 0x333366;
		}
		if (self.redBtn && self.redBtn.btnBg) self.redBtn.btnBg.color = 0x333366;
		if (self.blackBtn && self.blackBtn.btnBg) self.blackBtn.btnBg.color = 0x333366;
		self.betType = 'black';
		self.betValue = null;
		self.selectedBetBtn = this;
		self.showResult('Black bet ($' + Math.max(betAmount, 50) + ')', true);
		if (this.btnBg) this.btnBg.color = 0x222222;
		if (self.state === 'bet') {
			self.spinBtn.visible = true;
		}
	};
	self.addChild(blackBtn);
	self.betOptions.push(blackBtn);
	self.blackBtn = blackBtn;
	// Create split bet buttons (between adjacent numbers: right and below)
	for (var i = 0; i < 37; i++) {
		var pos = getGridPos(i);
		// Split right (horizontal)
		if (pos.col < betGridCols - 1 && i + 1 < 37) {
			var splitBtn = new GameButton();
			splitBtn.setText(i + '|' + (i + 1));
			splitBtn.x = betGridStartX + pos.col * betBtnW + betBtnW / 2;
			splitBtn.y = betGridStartY + pos.row * betBtnH;
			splitBtn.width = 60;
			splitBtn.height = 60;
			splitBtn.betType = 'split';
			splitBtn.betValue = [i, i + 1];
			splitBtn.down = function (splitBtn) {
				return function () {
					this.flash();
					// Unhighlight all bet buttons
					for (var j = 0; j < self.betOptions.length; j++) {
						if (self.betOptions[j].btnBg) self.betOptions[j].btnBg.color = 0x333366;
					}
					for (var j = 0; j < self.splitBetOptions.length; j++) {
						if (self.splitBetOptions[j].btnBg) self.splitBetOptions[j].btnBg.color = 0x333366;
					}
					self.betType = 'split';
					self.betValue = splitBtn.betValue;
					self.selectedBetBtn = this;
					self.showResult('Split bet: ' + splitBtn.betValue[0] + ' & ' + splitBtn.betValue[1] + ' ($' + Math.max(betAmount, 50) + ')', true);
					if (this.btnBg) this.btnBg.color = 0x6666cc;
					if (self.state === 'bet') {
						self.spinBtn.visible = true;
					}
				};
			}(splitBtn);
			self.addChild(splitBtn);
			self.splitBetOptions.push(splitBtn);
		}
		// Split below (vertical)
		if (pos.row < betGridRows - 1 && i + betGridCols < 37) {
			var splitBtn2 = new GameButton();
			splitBtn2.setText(i + '\\' + (i + betGridCols));
			splitBtn2.x = betGridStartX + pos.col * betBtnW;
			splitBtn2.y = betGridStartY + pos.row * betBtnH + betBtnH / 2;
			splitBtn2.width = 60;
			splitBtn2.height = 60;
			splitBtn2.betType = 'split';
			splitBtn2.betValue = [i, i + betGridCols];
			splitBtn2.down = function (splitBtn2) {
				return function () {
					this.flash();
					// Unhighlight all bet buttons
					for (var j = 0; j < self.betOptions.length; j++) {
						if (self.betOptions[j].btnBg) self.betOptions[j].btnBg.color = 0x333366;
					}
					for (var j = 0; j < self.splitBetOptions.length; j++) {
						if (self.splitBetOptions[j].btnBg) self.splitBetOptions[j].btnBg.color = 0x333366;
					}
					self.betType = 'split';
					self.betValue = splitBtn2.betValue;
					self.selectedBetBtn = this;
					self.showResult('Split bet: ' + splitBtn2.betValue[0] + ' & ' + splitBtn2.betValue[1] + ' ($' + Math.max(betAmount, 50) + ')', true);
					if (this.btnBg) this.btnBg.color = 0x6666cc;
					if (self.state === 'bet') {
						self.spinBtn.visible = true;
					}
				};
			}(splitBtn2);
			self.addChild(splitBtn2);
			self.splitBetOptions.push(splitBtn2);
		}
	}
	// Spin button
	// Calculate betY for button positioning
	var betY = betGridStartY + betGridRows * betBtnH + 40;
	self.spinBtn = new GameButton();
	self.spinBtn.setText('Spin');
	self.spinBtn.x = 2048 / 2;
	self.spinBtn.y = betY + 200;
	self.spinBtn.visible = false; // Only show after bet selected
	self.spinBtn.down = function () {
		this.flash();
		self.handleSpin();
	};
	self.addChild(self.spinBtn);
	// Back button
	self.backBtn = new GameButton();
	self.backBtn.setText('Back');
	self.backBtn.x = 2048 / 2;
	self.backBtn.y = betY + 350;
	self.backBtn.down = function () {
		self.destroy();
		roulette = null;
		showModeSelect();
	};
	self.addChild(self.backBtn);
	// Show result text
	self.showResult = function (txt, noNext) {
		self.resultText && self.resultText.destroy();
		self.resultText = new Text2(txt, {
			size: 90,
			fill: "#fff"
		});
		self.resultText.anchor.set(0.5, 0.5);
		self.resultText.x = 2048 / 2;
		self.resultText.y = 1550;
		self.addChild(self.resultText);
		if (!noNext) {
			// Show "New Round" button
			var nextBtn = new GameButton();
			nextBtn.setText('New Round');
			nextBtn.x = 2048 / 2;
			nextBtn.y = betY + 500;
			nextBtn.down = function () {
				this.flash();
				self.reset();
			};
			self.addChild(nextBtn);
			self.buttons.push(nextBtn);
		}
	};
	// Handle spin
	self.handleSpin = function () {
		// Only allow spin if a bet is selected
		if (!self.betType || self.betType === 'number' && (typeof self.betValue !== "number" || self.betValue < 0 || self.betValue > 36)) {
			self.showResult('Select a bet first!', true);
			return;
		}
		if (betAmount < 50) {
			self.showResult('Minimum bet is $50!', true);
			return;
		}
		if (self.state !== 'bet') {
			self.showResult('You can only place one bet per round!', true);
			return;
		}
		self.state = 'spin';
		if (playerBalance < betAmount) {
			self.showResult('Not enough balance!', true);
			return;
		}
		playerBalance -= betAmount;
		updateBalance();
		self.state = 'spin';
		self.spinBtn.visible = false;
		for (var i = 0; i < self.betOptions.length; i++) self.betOptions[i].visible = false;
		self.resultText && self.resultText.destroy();
		// Animate ball spin
		var winningNumber = Math.floor(Math.random() * 37);
		var totalSpins = 3 + Math.floor(Math.random() * 2);
		var frames = 60 * totalSpins;
		var startAngle = -Math.PI / 2;
		var endAngle = winningNumber / 37 * Math.PI * 2 - Math.PI / 2;
		var currentFrame = 0;
		function animateBall() {
			var t = currentFrame / frames;
			var angle = startAngle + (endAngle - startAngle) * t + Math.PI * 2 * (1 - t) * totalSpins;
			self.ball.x = Math.cos(angle) * (wheelRadius - 40);
			self.ball.y = Math.sin(angle) * (wheelRadius - 40);
			currentFrame++;
			if (currentFrame <= frames) {
				LK.setTimeout(animateBall, 1000 / 60);
			} else {
				self.showSpinResult(winningNumber);
				// After result, allow new bet
				self.betType = null;
				self.betValue = null;
				if (self.selectedBetBtn && self.selectedBetBtn.btnBg) {
					self.selectedBetBtn.btnBg.color = 0x333366;
				}
				self.selectedBetBtn = null;
				// Show bet options for next round, but keep spin button hidden until bet is selected
				self.spinBtn.visible = false;
				for (var i = 0; i < self.betOptions.length; i++) self.betOptions[i].visible = true;
			}
		}
		animateBall();
	};
	// Show spin result and payout
	self.showSpinResult = function (winningNumber) {
		var win = false;
		var payout = 0;
		var msg = '';
		if (self.betType === 'red' && reds.indexOf(winningNumber) !== -1) {
			win = true;
			payout = betAmount * 2;
			msg = 'Red wins!';
		} else if (self.betType === 'black' && blacks.indexOf(winningNumber) !== -1) {
			win = true;
			payout = betAmount * 2;
			msg = 'Black wins!';
		} else if (self.betType === 'even' && winningNumber !== 0 && winningNumber % 2 === 0) {
			win = true;
			payout = betAmount * 2;
			msg = 'Even wins!';
		} else if (self.betType === 'odd' && winningNumber % 2 === 1) {
			win = true;
			payout = betAmount * 2;
			msg = 'Odd wins!';
		} else if (self.betType === 'number' && self.betValue === winningNumber) {
			win = true;
			payout = betAmount * 36;
			msg = 'Number ' + winningNumber + ' wins!';
		} else if (self.betType === 'split' && self.betValue && self.betValue.indexOf(winningNumber) !== -1) {
			win = true;
			payout = betAmount * 18; // Standard split bet payout is 17:1, so bet*18
			msg = 'Split bet wins! Number ' + winningNumber + '!';
		} else {
			msg = 'Number ' + winningNumber + '. You lose.';
		}
		if (win) {
			playerBalance += payout;
			updateBalance();
			msg += ' You win $' + payout + '!';
		}
		self.state = 'result';
		self.showResult(msg);
	};
	// Reset for new round
	self.reset = function () {
		self.betType = null;
		self.betValue = null;
		self.state = 'bet';
		self.resultText && self.resultText.destroy();
		for (var i = 0; i < self.buttons.length; i++) self.buttons[i].destroy();
		self.buttons = [];
		self.spinBtn.visible = false;
		for (var i = 0; i < self.betOptions.length; i++) {
			self.betOptions[i].visible = true;
			if (self.betOptions[i].btnBg) self.betOptions[i].btnBg.color = 0x333366;
		}
		for (var i = 0; i < (self.splitBetOptions ? self.splitBetOptions.length : 0); i++) {
			self.splitBetOptions[i].visible = true;
			if (self.splitBetOptions[i].btnBg) self.splitBetOptions[i].btnBg.color = 0x333366;
		}
		self.selectedBetBtn = null;
	};
	// Destroy
	self.destroy = function () {
		self.resultText && self.resultText.destroy();
		for (var i = 0; i < self.betOptions.length; i++) self.betOptions[i].destroy();
		self.betOptions = [];
		if (self.splitBetOptions) {
			for (var i = 0; i < self.splitBetOptions.length; i++) self.splitBetOptions[i].destroy();
			self.splitBetOptions = [];
		}
		self.spinBtn && self.spinBtn.destroy();
		self.backBtn && self.backBtn.destroy();
		for (var i = 0; i < self.buttons.length; i++) self.buttons[i].destroy();
		self.buttons = [];
		self.rouletteWheel && self.rouletteWheel.destroy();
		self.state = 'bet';
		if (self.parent) self.parent.removeChild(self);
	};
	return self;
});
// --- Sweet Bonanza Game Logic ---
var SweetBonanzaGame = Container.expand(function () {
	var self = Container.call(this);
	// Slot config
	var ROWS = 5;
	var COLS = 6;
	var SYMBOLS = [{
		id: 'red',
		color: 0xff4b5c,
		payout: 10
	}, {
		id: 'blue',
		color: 0x4b7bff,
		payout: 8
	}, {
		id: 'green',
		color: 0x4bff7b,
		payout: 6
	}, {
		id: 'yellow',
		color: 0xffe066,
		payout: 4
	}, {
		id: 'purple',
		color: 0xb266ff,
		payout: 12
	}, {
		id: 'bomb',
		color: 0xffffff,
		payout: 0,
		isBomb: true
	}];
	var symbolSize = 180;
	var gridOffsetX = 2048 / 2 - COLS * symbolSize / 2;
	var gridOffsetY = 900;
	var grid = [];
	var symbolNodes = [];
	var spinBtn = null;
	var resultText = null;
	var canSpin = true;
	// Draw slot background
	var slotBg = self.attachAsset('bjTable', {
		width: COLS * symbolSize + 40,
		height: ROWS * symbolSize + 40,
		color: 0xf7e6ff,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: gridOffsetY + ROWS * symbolSize / 2
	});
	// Draw grid
	function drawGrid() {
		// Remove old
		for (var i = 0; i < symbolNodes.length; i++) {
			for (var j = 0; j < symbolNodes[i].length; j++) {
				symbolNodes[i][j].destroy();
			}
		}
		symbolNodes = [];
		for (var row = 0; row < ROWS; row++) {
			symbolNodes[row] = [];
			for (var col = 0; col < COLS; col++) {
				var sym = grid[row][col];
				var node = self.attachAsset('cardBg', {
					width: symbolSize - 10,
					height: symbolSize - 10,
					color: sym.color,
					shape: 'box',
					anchorX: 0.5,
					anchorY: 0.5,
					x: gridOffsetX + col * symbolSize + symbolSize / 2,
					y: gridOffsetY + row * symbolSize + symbolSize / 2
				});
				// Add symbol text
				var txt = new Text2(sym.isBomb ? '💣' : '', {
					size: 80,
					fill: "#222"
				});
				txt.anchor.set(0.5, 0.5);
				node.addChild(txt);
				symbolNodes[row][col] = node;
			}
		}
	}
	// Generate random grid
	function randomGrid() {
		grid = [];
		for (var row = 0; row < ROWS; row++) {
			grid[row] = [];
			for (var col = 0; col < COLS; col++) {
				var sym = SYMBOLS[Math.floor(Math.random() * SYMBOLS.length)];
				grid[row][col] = sym;
			}
		}
	}
	// Find clusters of 8+ matching symbols (Sweet Bonanza style)
	function findClusters() {
		var visited = [];
		for (var i = 0; i < ROWS; i++) visited[i] = [];
		var clusters = [];
		function dfs(r, c, id, cluster) {
			if (r < 0 || r >= ROWS || c < 0 || c >= COLS) return;
			if (visited[r][c]) return;
			if (grid[r][c].id !== id) return;
			visited[r][c] = true;
			cluster.push({
				row: r,
				col: c
			});
			dfs(r - 1, c, id, cluster);
			dfs(r + 1, c, id, cluster);
			dfs(r, c - 1, id, cluster);
			dfs(r, c + 1, id, cluster);
		}
		for (var row = 0; row < ROWS; row++) {
			for (var col = 0; col < COLS; col++) {
				if (!visited[row][col] && !grid[row][col].isBomb) {
					var cluster = [];
					dfs(row, col, grid[row][col].id, cluster);
					if (cluster.length >= 8) {
						clusters.push({
							id: grid[row][col].id,
							cells: cluster,
							payout: grid[row][col].payout
						});
					}
				}
			}
		}
		return clusters;
	}
	// Remove clusters and drop new symbols
	function removeClusters(clusters) {
		for (var i = 0; i < clusters.length; i++) {
			var cells = clusters[i].cells;
			for (var j = 0; j < cells.length; j++) {
				var r = cells[j].row;
				var c = cells[j].col;
				grid[r][c] = null;
			}
		}
		// Drop down
		for (var col = 0; col < COLS; col++) {
			var empty = [];
			for (var row = ROWS - 1; row >= 0; row--) {
				if (grid[row][col] === null) {
					empty.push(row);
				} else if (empty.length > 0) {
					var target = empty.shift();
					grid[target][col] = grid[row][col];
					grid[row][col] = null;
					empty.push(row);
				}
			}
			// Fill empty with new
			for (var k = 0; k < empty.length; k++) {
				var r = empty[k];
				var sym = SYMBOLS[Math.floor(Math.random() * SYMBOLS.length)];
				grid[r][col] = sym;
			}
		}
	}
	// Check for bombs
	function hasBomb() {
		for (var row = 0; row < ROWS; row++) {
			for (var col = 0; col < COLS; col++) {
				if (grid[row][col].isBomb) return true;
			}
		}
		return false;
	}
	// Spin logic
	function spin() {
		if (!canSpin) return;
		if (playerBalance < betAmount) {
			showResult('Not enough balance!');
			return;
		}
		canSpin = false;
		playerBalance -= betAmount;
		updateBalance();
		resultText && resultText.destroy();
		resultText = null;
		randomGrid();
		drawGrid();
		// Animate spin (simple delay)
		LK.setTimeout(function () {
			var clusters = findClusters();
			var win = 0;
			for (var i = 0; i < clusters.length; i++) {
				win += clusters[i].payout * betAmount;
			}
			if (win > 0) {
				playerBalance += win;
				updateBalance();
				showResult('Win! $' + win);
			} else if (hasBomb()) {
				showResult('💣 Bomb! Lose!');
			} else {
				showResult('No win');
			}
			// Remove clusters and drop new
			if (clusters.length > 0) {
				removeClusters(clusters);
				drawGrid();
			}
			canSpin = true;
		}, 700);
	}
	// Show result text
	function showResult(txt) {
		resultText && resultText.destroy();
		resultText = new Text2(txt, {
			size: 90,
			fill: "#fff"
		});
		resultText.anchor.set(0.5, 0.5);
		resultText.x = 2048 / 2;
		resultText.y = gridOffsetY + ROWS * symbolSize + 120;
		self.addChild(resultText);
	}
	// Spin button
	spinBtn = new GameButton();
	spinBtn.setText('Spin');
	spinBtn.x = 2048 / 2;
	spinBtn.y = gridOffsetY + ROWS * symbolSize + 250;
	spinBtn.down = function () {
		this.flash();
		spin();
	};
	self.addChild(spinBtn);
	// Back button
	var backBtn = new GameButton();
	backBtn.setText('Back');
	backBtn.x = 2048 / 2;
	backBtn.y = gridOffsetY + ROWS * symbolSize + 400;
	backBtn.down = function () {
		self.destroy();
		sweetBonanza = null;
		showModeSelect();
	};
	self.addChild(backBtn);
	// Destroy
	self.destroy = function () {
		for (var i = 0; i < symbolNodes.length; i++) {
			for (var j = 0; j < symbolNodes[i].length; j++) {
				symbolNodes[i][j].destroy();
			}
		}
		symbolNodes = [];
		spinBtn && spinBtn.destroy();
		backBtn && backBtn.destroy();
		resultText && resultText.destroy();
		if (self.parent) self.parent.removeChild(self);
	};
	// Init
	randomGrid();
	drawGrid();
	return self;
});

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

/**** 
* Game Code
****/ 
// --- Global State ---
// --- Top Left Back Button ---
var topLeftBackBtn = null;
function showTopLeftBackBtn(onBack) {
	// Remove if already present
	if (topLeftBackBtn && topLeftBackBtn.parent) {
		topLeftBackBtn.parent.removeChild(topLeftBackBtn);
		topLeftBackBtn.destroy();
		topLeftBackBtn = null;
	}
	topLeftBackBtn = new GameButton();
	topLeftBackBtn.setText('Back');
	// Place at (100,220) to avoid the reserved 100x100px area and move a little further down
	topLeftBackBtn.x = 100 + 80; // 80px right of reserved area
	topLeftBackBtn.y = 100 + 160; // 160px below reserved area (moved a little further down)
	topLeftBackBtn.btnBg.width = 180;
	topLeftBackBtn.btnBg.height = 80;
	topLeftBackBtn.down = function () {
		this.flash();
		if (typeof onBack === "function") onBack();
	};
	game.addChild(topLeftBackBtn);
}
function hideTopLeftBackBtn() {
	if (topLeftBackBtn && topLeftBackBtn.parent) {
		topLeftBackBtn.parent.removeChild(topLeftBackBtn);
		topLeftBackBtn.destroy();
		topLeftBackBtn = null;
	}
}
/**** 
* Casino Carnival - MVP
* Four-in-one casino game: Blackjack, Sweet Bonanza, Gates of Olympus, Sugar Rush
* MVP: Game selection, basic betting, and one playable mode (Blackjack)
****/ 
var MODES = [{
	id: 'blackjack',
	name: 'Blackjack'
}, {
	id: 'roulette',
	name: 'Roulette'
}];
var currentMode = null; // 'blackjack', etc.
var playerBalance = storage.balance || 1000;
var betAmount = 100;
var minBet = 50;
var maxBet = 1000;
// --- Single Seat State ---
var blackjack = null;
// UI elements
var modeButtons = [];
var betText = null;
var balanceText = null;
var playArea = null;
var blackjack = null;
// --- GUI: Balance and Bet ---
balanceText = new Text2('Balance: $' + playerBalance, {
	size: 60,
	fill: "#fff"
});
balanceText.anchor.set(0.5, 0);
LK.gui.top.addChild(balanceText);
betText = new Text2('Bet: $' + betAmount, {
	size: 50,
	fill: "#fff"
});
betText.anchor.set(0.5, 0);
LK.gui.top.addChild(betText);
// Position GUI elements
balanceText.y = 10;
betText.y = 80;
// --- Game Selection Screen ---
function showModeSelect() {
	hideTopLeftBackBtn();
	// Clear play area
	if (playArea) {
		playArea.destroy();
		playArea = null;
	}
	if (blackjack) {
		blackjack.destroy();
		blackjack = null;
	}
	// Destroy blackjack instance if present
	if (blackjack && blackjack.destroy) {
		blackjack.destroy();
		blackjack = null;
	}
	// Remove old mode buttons
	for (var i = 0; i < modeButtons.length; i++) {
		if (modeButtons[i].parent) modeButtons[i].parent.removeChild(modeButtons[i]);
	}
	modeButtons = [];
	// Title
	var title = new Text2('Casino Carnival', {
		size: 120,
		fill: 0xFFE066
	});
	title.anchor.set(0.5, 0.5);
	title.x = 2048 / 2;
	title.y = 350;
	game.addChild(title);
	// Mode buttons
	var startY = 700;
	var gapY = 200;
	for (var i = 0; i < MODES.length; i++) {
		var btn = new GameButton();
		btn.setText(MODES[i].name);
		btn.x = 2048 / 2;
		btn.y = startY + i * gapY;
		btn.modeId = MODES[i].id;
		btn.down = function (x, y, obj) {
			this.flash();
			selectMode(this.modeId);
		};
		game.addChild(btn);
		modeButtons.push(btn);
	}
	// Bet controls
	var betMinus = new GameButton();
	betMinus.setText('-');
	betMinus.x = 2048 / 2 - 250;
	betMinus.y = startY + MODES.length * gapY + 60;
	betMinus.down = function () {
		if (betAmount > minBet) {
			betAmount -= 50;
			betText.setText('Bet: $' + betAmount);
		}
	};
	game.addChild(betMinus);
	var betPlus = new GameButton();
	betPlus.setText('+');
	betPlus.x = 2048 / 2 + 250;
	betPlus.y = startY + MODES.length * gapY + 60;
	betPlus.down = function () {
		if (betAmount < maxBet) {
			betAmount += 50;
			betText.setText('Bet: $' + betAmount);
		}
	};
	game.addChild(betPlus);
	// Store for later removal
	modeButtons.push(title, betMinus, betPlus);
}
// --- Mode Selection Handler ---
// Password UI state
var roulettePasswordPrompt = null;
var roulettePasswordInput = null;
var roulettePasswordError = null;
function showRoulettePasswordPrompt() {
	showTopLeftBackBtn(function () {
		if (roulettePasswordPrompt) {
			roulettePasswordPrompt.destroy();
			roulettePasswordPrompt = null;
		}
		showModeSelect();
	});
	// Remove any previous prompt
	if (roulettePasswordPrompt) {
		roulettePasswordPrompt.destroy();
		roulettePasswordPrompt = null;
	}
	roulettePasswordPrompt = new Container();
	game.addChild(roulettePasswordPrompt);
	// Background overlay
	var overlay = roulettePasswordPrompt.attachAsset('cardBg', {
		width: 900,
		height: 500,
		color: 0x222244,
		shape: 'box',
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048 / 2,
		y: 1200
	});
	// Title
	var promptTitle = new Text2('Enter Roulette Password', {
		size: 80,
		fill: "#fff"
	});
	promptTitle.anchor.set(0.5, 0.5);
	promptTitle.x = 2048 / 2;
	promptTitle.y = 1050;
	roulettePasswordPrompt.addChild(promptTitle);
	// Password input (show as ****)
	var passwordValue = '';
	roulettePasswordInput = new Text2('Password: ', {
		size: 60,
		fill: "#fff"
	});
	roulettePasswordInput.anchor.set(0.5, 0.5);
	roulettePasswordInput.x = 2048 / 2;
	roulettePasswordInput.y = 1200;
	roulettePasswordPrompt.addChild(roulettePasswordInput);
	// Error text
	roulettePasswordError = new Text2('', {
		size: 48,
		fill: 0xFF4444
	});
	roulettePasswordError.anchor.set(0.5, 0.5);
	roulettePasswordError.x = 2048 / 2;
	roulettePasswordError.y = 1270;
	roulettePasswordPrompt.addChild(roulettePasswordError);
	// Number pad
	var padStartX = 2048 / 2 - 180;
	var padStartY = 1320;
	var padBtns = [];
	function updateInputDisplay() {
		var stars = '';
		for (var i = 0; i < passwordValue.length; i++) stars += '*';
		roulettePasswordInput.setText('Password: ' + stars);
		if (roulettePasswordError) roulettePasswordError.setText('');
	}
	function clearInput() {
		passwordValue = '';
		updateInputDisplay();
	}
	function trySubmit() {
		if (passwordValue === '1334') {
			// Success
			if (roulettePasswordPrompt) {
				roulettePasswordPrompt.destroy();
				roulettePasswordPrompt = null;
			}
			startRoulette();
		} else {
			// Error
			if (roulettePasswordError) roulettePasswordError.setText('Incorrect password!');
			clearInput();
		}
	}
	// Password keypad layout: numbers in phone order
	var keypadLabels = [['1', '2', '3'], ['4', '5', '6'], ['7', '8', '9'], ['C', '0', 'OK']];
	for (var row = 0; row < 4; row++) {
		for (var col = 0; col < 3; col++) {
			var label = keypadLabels[row][col];
			var btn = new GameButton();
			btn.setText(label);
			// Make sure the button text is visible and large enough
			btn.setText(label);
			btn.x = padStartX + col * 120;
			btn.y = padStartY + row * 100;
			// Make the button background lighter for better contrast
			if (!isNaN(parseInt(label))) {
				if (label === '0') {
					btn.btnBg.color = 0xeeeeee;
					btn.setText(label);
				} else {
					btn.btnBg.color = 0xffffff;
					btn.setText(label);
				}
			} else if (label === 'C') {
				btn.btnBg.color = 0xffcccc;
			} else if (label === 'OK') {
				btn.btnBg.color = 0xccffcc;
			}
			btn.down = function (lbl) {
				return function () {
					this.flash();
					if (lbl === 'C') {
						clearInput();
					} else if (lbl === 'OK') {
						trySubmit();
					} else if (lbl.length === 1 && passwordValue.length < 8) {
						passwordValue += lbl;
						updateInputDisplay();
					}
				};
			}(label);
			roulettePasswordPrompt.addChild(btn);
			padBtns.push(btn);
		}
	}
	updateInputDisplay();
}
function selectMode(modeId) {
	currentMode = modeId;
	// Remove mode select UI
	for (var i = 0; i < modeButtons.length; i++) {
		if (modeButtons[i].parent) modeButtons[i].parent.removeChild(modeButtons[i]);
	}
	modeButtons = [];
	// Start selected mode
	if (modeId === 'blackjack') {
		startBlackjack();
	} else if (modeId === 'roulette') {
		showRoulettePasswordPrompt();
	} else {
		showComingSoon(modeId);
	}
}
// --- Coming Soon Placeholder ---
function showComingSoon(modeId) {
	showTopLeftBackBtn(function () {
		if (playArea) playArea.destroy();
		playArea = null;
		showModeSelect();
	});
	if (playArea) playArea.destroy();
	playArea = new Container();
	game.addChild(playArea);
	var txt = new Text2(MODES.filter(function (m) {
		return m.id === modeId;
	})[0].name + '\nComing Soon!', {
		size: 100,
		fill: "#fff"
	});
	txt.anchor.set(0.5, 0.5);
	txt.x = 2048 / 2;
	txt.y = 1200;
	playArea.addChild(txt);
	// Back button
	var backBtn = new GameButton();
	backBtn.setText('Back');
	backBtn.x = 2048 / 2;
	backBtn.y = 1800;
	backBtn.down = function () {
		playArea.destroy();
		playArea = null;
		showModeSelect();
	};
	playArea.addChild(backBtn);
}
// --- Start Blackjack ---
function startBlackjack() {
	showTopLeftBackBtn(function () {
		if (playArea) playArea.destroy();
		playArea = null;
		if (blackjack) {
			blackjack.destroy();
			blackjack = null;
		}
		showModeSelect();
	});
	if (playArea) playArea.destroy();
	playArea = new Container();
	game.addChild(playArea);
	// Destroy old blackjack if any
	if (blackjack && blackjack.destroy) {
		blackjack.destroy();
		blackjack = null;
	}
	blackjack = new BlackjackGame();
	playArea.addChild(blackjack);
}
// (removed selectBlackjackSeat, not needed for single seat)
// --- Start Sweet Bonanza ---
function startSweetBonanza() {
	if (playArea) playArea.destroy();
	playArea = new Container();
	game.addChild(playArea);
	if (typeof sweetBonanza !== "undefined" && sweetBonanza && sweetBonanza.destroy) {
		sweetBonanza.destroy();
	}
	sweetBonanza = new SweetBonanzaGame();
	playArea.addChild(sweetBonanza);
}
// --- Start Roulette ---
function startRoulette() {
	showTopLeftBackBtn(function () {
		if (playArea) playArea.destroy();
		playArea = null;
		if (roulette) {
			roulette.destroy();
			roulette = null;
		}
		showModeSelect();
	});
	if (playArea) playArea.destroy();
	playArea = new Container();
	game.addChild(playArea);
	if (typeof roulette !== "undefined" && roulette && roulette.destroy) {
		roulette.destroy();
	}
	roulette = new RouletteGame();
	playArea.addChild(roulette);
}
// --- Update Balance ---
function updateBalance() {
	balanceText.setText('Balance: $' + playerBalance);
	storage.balance = playerBalance;
}
// --- Auto Reward System ---
// Give +2000 every 10 minutes (600,000 ms)
var AUTO_REWARD_AMOUNT = 2000;
var AUTO_REWARD_INTERVAL = 600000; // 10 minutes in ms
var lastRewardTime = storage.lastRewardTime || Date.now();
// --- Auto Reward Counter UI ---
var autoRewardCounterText = new Text2('', {
	size: 40,
	fill: 0x66FFCC
});
autoRewardCounterText.anchor.set(0.5, 0);
// Place original counter in the center top (for legacy/compat)
autoRewardCounterText.x = 2048 / 2;
autoRewardCounterText.y = 160;
LK.gui.top.addChild(autoRewardCounterText);
// Add countdown timer to the top left
var autoRewardCounterTextLeft = new Text2('', {
	size: 40,
	fill: 0x66FFCC
});
autoRewardCounterTextLeft.anchor.set(0, 0); // left aligned, top
autoRewardCounterTextLeft.x = 120; // 20px right of reserved area (100px reserved)
autoRewardCounterTextLeft.y = 20; // 20px from top
LK.gui.topLeft.addChild(autoRewardCounterTextLeft);
function updateAutoRewardCounter() {
	var now = Date.now();
	var msLeft = AUTO_REWARD_INTERVAL - (now - lastRewardTime) % AUTO_REWARD_INTERVAL;
	if (msLeft < 0) msLeft = 0;
	var sec = Math.floor(msLeft / 1000) % 60;
	var min = Math.floor(msLeft / 60000);
	var timeStr = (min < 10 ? '0' : '') + min + ':' + (sec < 10 ? '0' : '') + sec;
	autoRewardCounterText.setText('Next Reward: +' + AUTO_REWARD_AMOUNT + ' in ' + timeStr);
	autoRewardCounterTextLeft.setText('Next reward: ' + timeStr);
}
function checkAutoReward() {
	var now = Date.now();
	// If more than interval has passed, give reward (handle multiple missed intervals)
	var intervals = Math.floor((now - lastRewardTime) / AUTO_REWARD_INTERVAL);
	if (intervals > 0) {
		var totalReward = intervals * AUTO_REWARD_AMOUNT;
		playerBalance += totalReward;
		updateBalance();
		lastRewardTime += intervals * AUTO_REWARD_INTERVAL;
		storage.lastRewardTime = lastRewardTime;
		// Optionally show a quick popup for reward
		var rewardText = new Text2('Auto Reward: +$' + totalReward, {
			size: 70,
			fill: 0x66ffcc
		});
		rewardText.anchor.set(0.5, 0.5);
		rewardText.x = 2048 / 2;
		rewardText.y = 400;
		game.addChild(rewardText);
		tween(rewardText, {
			y: rewardText.y - 80,
			alpha: 0
		}, {
			duration: 1200,
			onFinish: function onFinish() {
				rewardText.destroy();
			}
		});
	}
	updateAutoRewardCounter();
}
// Check auto reward every 10 seconds, and update counter every second
LK.setInterval(checkAutoReward, 10000);
LK.setInterval(updateAutoRewardCounter, 1000);
updateAutoRewardCounter();
// --- Start Game ---
showModeSelect();
updateBalance();
// --- Touch Handling (for mobile) ---
game.move = function (x, y, obj) {
	// No drag in this game
};
game.down = function (x, y, obj) {
	// No drag in this game
};
game.up = function (x, y, obj) {
	// No drag in this game
};
// --- Game Tick ---
game.update = function () {
	// No per-frame logic needed for MVP
	// Win/Lose system for all casino modes (except Blackjack, which already has it)
	// Placeholder for future slot/other games:
	if (currentMode === 'sweet') {
		// Example: If playerBalance <= 0, show lose popup
		if (playerBalance <= 0) {
			LK.showGameOver();
		}
		// Example: If playerBalance >= 10000, show win popup
		if (playerBalance >= 10000) {
			LK.showYouWin();
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -1659,9 +1659,9 @@
 	var sec = Math.floor(msLeft / 1000) % 60;
 	var min = Math.floor(msLeft / 60000);
 	var timeStr = (min < 10 ? '0' : '') + min + ':' + (sec < 10 ? '0' : '') + sec;
 	autoRewardCounterText.setText('Next Reward: +' + AUTO_REWARD_AMOUNT + ' in ' + timeStr);
-	autoRewardCounterTextLeft.setText('+' + AUTO_REWARD_AMOUNT + ' in ' + timeStr);
+	autoRewardCounterTextLeft.setText('Next reward: ' + timeStr);
 }
 function checkAutoReward() {
 	var now = Date.now();
 	// If more than interval has passed, give reward (handle multiple missed intervals)