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

/**** 
* Classes
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	self.value = cardData.value || 0;
	self.color = cardData.color || 'red';
	self.isSelected = false;
	var assetName = 'card' + self.value;
	var cardGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var cardText = new Text2(self.value.toString(), {
		size: 180,
		fill: 0xFFFFFF
	});
	cardText.anchor.set(0.5, 0.5);
	self.addChild(cardText);
	self.setSelected = function (selected) {
		self.isSelected = selected;
		if (selected) {
			cardGraphics.tint = 0xf1c40f;
			self.y -= 20;
		} else {
			cardGraphics.tint = 0xffffff;
			self.y += 20;
		}
	};
	self.down = function (x, y, obj) {
		if (currentGameState === 'playing' && currentPlayer === 0) {
			self.setSelected(!self.isSelected);
			// Auto-play cards when selection changes
			LK.setTimeout(function () {
				playSelectedCards();
			}, 100);
		}
	};
	return self;
});
var LimitButton = Container.expand(function (limit) {
	var self = Container.call(this);
	self.limit = limit;
	self.isSelected = false;
	var buttonGraphics = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2(limit.toString(), {
		size: 100,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.setSelected = function (selected) {
		self.isSelected = selected;
		buttonGraphics.removeChild(buttonGraphics.children[0]);
		if (selected) {
			buttonGraphics.addChild(LK.getAsset('selectedButton', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
		} else {
			buttonGraphics.addChild(LK.getAsset('button', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
		}
	};
	self.down = function (x, y, obj) {
		if (currentGameState === 'setup') {
			selectLimit(self.limit);
		}
	};
	return self;
});
var RoundButton = Container.expand(function (rounds) {
	var self = Container.call(this);
	self.rounds = rounds;
	self.isSelected = false;
	var buttonGraphics = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2(rounds + ' Round' + (rounds > 1 ? 's' : ''), {
		size: 85,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.setSelected = function (selected) {
		self.isSelected = selected;
		buttonGraphics.removeChild(buttonGraphics.children[0]);
		if (selected) {
			buttonGraphics.addChild(LK.getAsset('selectedButton', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
		} else {
			buttonGraphics.addChild(LK.getAsset('button', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
		}
	};
	self.down = function (x, y, obj) {
		if (currentGameState === 'setup') {
			selectRounds(self.rounds);
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentGameState = 'setup'; // 'setup', 'playing', 'gameOver'
var selectedLimit = 0;
var selectedRounds = 0;
var maxRounds = 0;
var currentTotal = 0;
var currentPlayer = 0; // 0 = player, 1 = AI
var playerHand = [];
var aiHand = [];
var deck = [];
var playerScore = 0;
var aiScore = 0;
var aiThinkingTimeout = null;
var aiCardPositions = [{
	x: -675,
	y: -20,
	rotation: 0.12
}, {
	x: -225,
	y: 10,
	rotation: 0.05
}, {
	x: 225,
	y: -15,
	rotation: -0.08
}, {
	x: 675,
	y: 5,
	rotation: -0.12
}];
// UI elements
var limitButtons = [];
var roundButtons = [];
var playAreaGraphics;
var totalText;
var limitText;
var playerHandContainer;
var aiHandContainer;
var playButton;
var statusText;
var scoreText;
var centerCardContainer;
var turnArrow;
// Initialize deck
function initializeDeck() {
	deck = [];
	// Add 5 color groups of cards 1-10 (red, blue, yellow, green, purple)
	var colors = ['red', 'blue', 'yellow', 'green', 'purple'];
	for (var colorIndex = 0; colorIndex < colors.length; colorIndex++) {
		for (var value = 1; value <= 10; value++) {
			deck.push({
				value: value,
				color: colors[colorIndex]
			});
		}
	}
	// Add 2 black zero cards
	deck.push({
		value: 0,
		color: 'black'
	});
	deck.push({
		value: 0,
		color: 'black'
	});
	shuffleDeck();
}
function shuffleDeck() {
	for (var i = deck.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = deck[i];
		deck[i] = deck[j];
		deck[j] = temp;
	}
}
function dealCard() {
	if (deck.length === 0) {
		initializeDeck();
	}
	return deck.pop();
}
function dealInitialHands() {
	playerHand = [];
	aiHand = [];
	for (var i = 0; i < 4; i++) {
		playerHand.push(dealCard());
		aiHand.push(dealCard());
	}
}
function createLimitSelection() {
	var limits = [30, 50, 80];
	for (var i = 0; i < limits.length; i++) {
		var button = new LimitButton(limits[i]);
		button.x = 1024 + (i - 1) * 400;
		button.y = 1000;
		limitButtons.push(button);
		game.addChild(button);
	}
	var rounds = [1, 3, 5];
	for (var i = 0; i < rounds.length; i++) {
		var roundButton = new RoundButton(rounds[i]);
		roundButton.x = 1024 + (i - 1) * 400;
		roundButton.y = 1300;
		roundButtons.push(roundButton);
		game.addChild(roundButton);
	}
	// Instruction texts removed - not visible at game start
}
function selectRounds(rounds) {
	selectedRounds = rounds;
	maxRounds = rounds;
	for (var i = 0; i < roundButtons.length; i++) {
		roundButtons[i].setSelected(roundButtons[i].rounds === rounds);
	}
	checkStartGameReady();
}
function selectLimit(limit) {
	selectedLimit = limit;
	for (var i = 0; i < limitButtons.length; i++) {
		limitButtons[i].setSelected(limitButtons[i].limit === limit);
	}
	checkStartGameReady();
}
function checkStartGameReady() {
	if (selectedLimit > 0 && selectedRounds > 0) {
		if (!playButton) {
			playButton = new Container();
			var playGraphics = playButton.attachAsset('button', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			var playText = new Text2('Start Game', {
				size: 55,
				fill: 0xFFFFFF
			});
			playText.anchor.set(0.5, 0.5);
			playButton.addChild(playText);
			playButton.x = 1024;
			playButton.y = 1500;
			playButton.down = function (x, y, obj) {
				startGame();
			};
			game.addChild(playButton);
		}
	}
}
function determineStartingPlayer() {
	// Find highest card value for each player
	var playerHighest = 0;
	var aiHighest = 0;
	var playerHasZero = false;
	var aiHasZero = false;
	// Check player hand
	for (var i = 0; i < playerHand.length; i++) {
		if (playerHand[i].value === 0) {
			playerHasZero = true;
		}
		if (playerHand[i].value > playerHighest) {
			playerHighest = playerHand[i].value;
		}
	}
	// Check AI hand
	for (var i = 0; i < aiHand.length; i++) {
		if (aiHand[i].value === 0) {
			aiHasZero = true;
		}
		if (aiHand[i].value > aiHighest) {
			aiHighest = aiHand[i].value;
		}
	}
	// Determine starting player
	// If player has highest card but also has a 0, they cannot start
	if (playerHighest > aiHighest && !playerHasZero) {
		return 0; // Player starts
	}
	// If AI has highest card but also has a 0, they cannot start
	else if (aiHighest > playerHighest && !aiHasZero) {
		return 1; // AI starts
	}
	// If both have same highest card or both have 0s, prefer the one without 0
	else if (playerHighest === aiHighest) {
		if (!playerHasZero && aiHasZero) {
			return 0; // Player starts
		} else if (!aiHasZero && playerHasZero) {
			return 1; // AI starts
		} else {
			return 0; // Default to player if both have/don't have 0s
		}
	}
	// If player has 0 but AI doesn't, AI starts regardless of card values
	else if (playerHasZero && !aiHasZero) {
		return 1;
	}
	// If AI has 0 but player doesn't, player starts regardless of card values
	else if (aiHasZero && !playerHasZero) {
		return 0;
	}
	return 0; // Default to player
}
function startGame() {
	currentGameState = 'playing';
	currentTotal = 0;
	// Initialize deck and deal hands first
	initializeDeck();
	dealInitialHands();
	// Determine starting player based on cards
	currentPlayer = determineStartingPlayer();
	// Clear setup UI
	for (var i = 0; i < limitButtons.length; i++) {
		limitButtons[i].destroy();
	}
	limitButtons = [];
	for (var i = 0; i < roundButtons.length; i++) {
		roundButtons[i].destroy();
	}
	roundButtons = [];
	if (playButton) {
		playButton.destroy();
		playButton = null;
	}
	// Hide instruction texts
	for (var i = game.children.length - 1; i >= 0; i--) {
		var child = game.children[i];
		if (child instanceof Text2 && (child.text === 'Choose Target Limit' || child.text === 'Choose Number of Rounds')) {
			child.destroy();
		}
	}
	// Initialize game
	createGameUI();
	updateDisplay();
	// If AI starts first, trigger AI turn after a short delay
	if (currentPlayer === 1) {
		LK.setTimeout(function () {
			aiTurn();
		}, 1500);
	}
}
function createGameUI() {
	// Play area removed - no gray stripe needed
	// Center card container for animations
	centerCardContainer = new Container();
	centerCardContainer.x = 1024;
	centerCardContainer.y = 1366;
	game.addChild(centerCardContainer);
	// Total label (positioned further to the right of center)
	var totalLabel = new Text2('Total: ', {
		size: 60,
		fill: 0xFFFFFF
	});
	totalLabel.anchor.set(0, 0.5);
	totalLabel.x = 1350;
	totalLabel.y = 1366;
	game.addChild(totalLabel);
	// Total value display (larger font, positioned after label)
	totalText = new Text2('0', {
		size: 80,
		fill: 0x2ecc71
	});
	totalText.anchor.set(0, 0.5);
	totalText.x = 1520;
	totalText.y = 1366;
	game.addChild(totalText);
	// Limit display (positioned below total text)
	limitText = new Text2('Limit: ' + selectedLimit, {
		size: 40,
		fill: 0xFFFFFF
	});
	limitText.anchor.set(0, 0.5);
	limitText.x = 1350;
	limitText.y = 1420;
	game.addChild(limitText);
	// Turn arrow
	turnArrow = new Text2('▼', {
		size: 80,
		fill: 0xf1c40f
	});
	turnArrow.anchor.set(0.5, 0.5);
	game.addChild(turnArrow);
	// Player hand container
	playerHandContainer = new Container();
	playerHandContainer.x = 1024;
	playerHandContainer.y = 2200;
	game.addChild(playerHandContainer);
	// AI hand container
	aiHandContainer = new Container();
	aiHandContainer.x = 1024;
	aiHandContainer.y = 500;
	game.addChild(aiHandContainer);
	// Status text
	statusText = new Text2('Your Turn - Select cards and tap Play', {
		size: 40,
		fill: 0xFFFFFF
	});
	statusText.anchor.set(0.5, 0.5);
	statusText.x = 1024;
	statusText.y = 1800;
	game.addChild(statusText);
	// Score display
	scoreText = new Text2('You: ' + playerScore + ' - AI: ' + aiScore, {
		size: 40,
		fill: 0xFFFFFF
	});
	scoreText.anchor.set(0.5, 0.5);
	scoreText.x = 1024;
	scoreText.y = 200;
	game.addChild(scoreText);
	// No play button needed - cards auto-play when selected
}
function updateDisplay() {
	totalText.setText(currentTotal.toString());
	// Update total text color based on proximity to limit
	var ratio = currentTotal / selectedLimit;
	if (ratio <= 0.6) {
		totalText.tint = 0x2ecc71; // Green
	} else if (ratio <= 0.8) {
		totalText.tint = 0xf1c40f; // Yellow
	} else {
		totalText.tint = 0xe74c3c; // Red
	}
	scoreText.setText('You: ' + playerScore + ' - AI: ' + aiScore);
	// Update player hand
	playerHandContainer.removeChildren();
	var cardPositions = [{
		x: -675,
		y: 20,
		rotation: -0.15
	}, {
		x: -225,
		y: -10,
		rotation: -0.05
	}, {
		x: 225,
		y: 15,
		rotation: 0.08
	}, {
		x: 675,
		y: -5,
		rotation: 0.12
	}];
	for (var i = 0; i < playerHand.length; i++) {
		var card = new Card(playerHand[i]);
		if (i < cardPositions.length) {
			card.x = cardPositions[i].x;
			card.y = cardPositions[i].y;
			card.rotation = cardPositions[i].rotation;
		} else {
			card.x = (i - 1.5) * 450;
		}
		playerHandContainer.addChild(card);
	}
	// Update AI hand (show card backs)
	aiHandContainer.removeChildren();
	for (var i = 0; i < aiHand.length; i++) {
		var cardBackAsset = 'cardBack' + aiHand[i].value;
		var cardBack = aiHandContainer.attachAsset(cardBackAsset, {
			anchorX: 0.5,
			anchorY: 0.5,
			x: aiCardPositions[i] ? aiCardPositions[i].x : (i - 1.5) * 450,
			y: aiCardPositions[i] ? aiCardPositions[i].y : 0
		});
		if (aiCardPositions[i]) {
			cardBack.rotation = aiCardPositions[i].rotation;
		}
	}
	// Update turn arrow position
	if (currentPlayer === 0) {
		turnArrow.x = 1024;
		turnArrow.y = 1950;
		turnArrow.rotation = 0;
		statusText.setText('Your Turn - Select cards to play');
	} else {
		turnArrow.x = 1024;
		turnArrow.y = 850;
		turnArrow.rotation = Math.PI;
		statusText.setText('AI is thinking...');
	}
}
function playSelectedCards() {
	var selectedCards = [];
	var selectedIndices = [];
	for (var i = 0; i < playerHandContainer.children.length; i++) {
		var card = playerHandContainer.children[i];
		if (card.isSelected) {
			selectedCards.push(card.value);
			selectedIndices.push(i);
		}
	}
	if (selectedCards.length === 0) {
		return;
	}
	// Calculate total of selected cards
	var cardTotal = 0;
	for (var i = 0; i < selectedCards.length; i++) {
		cardTotal += selectedCards[i];
	}
	currentTotal += cardTotal;
	LK.getSound('cardPlay').play();
	// Animate played cards to center
	var playedCardData = {
		value: selectedCards[0],
		color: playerHand[selectedIndices[0]].color
	};
	var animatedCard = new Card(playedCardData);
	var sourceCard = playerHandContainer.children[selectedIndices[0]];
	var startPos = playerHandContainer.toGlobal(sourceCard.position);
	var gamePos = game.toLocal(startPos);
	animatedCard.x = gamePos.x;
	animatedCard.y = gamePos.y;
	animatedCard.rotation = sourceCard.rotation;
	game.addChild(animatedCard);
	// Random scattered position and rotation for thrown card effect
	var scatterX = 1024 + (Math.random() - 0.5) * 300;
	var scatterY = 1366 + (Math.random() - 0.5) * 200;
	var scatterRotation = (Math.random() - 0.5) * 0.8;
	tween(animatedCard, {
		x: scatterX,
		y: scatterY,
		rotation: scatterRotation
	}, {
		duration: 500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			animatedCard.destroy();
			var centerCard = new Card(playedCardData);
			centerCard.x = scatterX - 1024;
			centerCard.y = scatterY - 1366;
			centerCard.rotation = scatterRotation;
			centerCardContainer.addChild(centerCard);
		}
	});
	// Remove played cards from hand
	for (var i = selectedIndices.length - 1; i >= 0; i--) {
		playerHand.splice(selectedIndices[i], 1);
	}
	// Replenish hand
	while (playerHand.length < 4 && deck.length > 0) {
		playerHand.push(dealCard());
	}
	// Check if player exceeded limit
	if (currentTotal > selectedLimit) {
		endRound(false);
		return;
	}
	currentPlayer = 1;
	updateDisplay();
	// AI turn after delay
	LK.setTimeout(function () {
		aiTurn();
	}, 1500);
}
function aiTimeoutHandler() {
	// Clear the timeout since we're handling it now
	if (aiThinkingTimeout) {
		LK.clearTimeout(aiThinkingTimeout);
		aiThinkingTimeout = null;
	}
	// Play a random card
	var randomIndex = Math.floor(Math.random() * aiHand.length);
	var playedCard = aiHand[randomIndex];
	currentTotal += playedCard.value;
	// Animate AI played card to center
	var animatedCard = new Card(playedCard);
	animatedCard.x = 1024 + aiCardPositions[randomIndex].x;
	animatedCard.y = 500 + aiCardPositions[randomIndex].y;
	animatedCard.rotation = aiCardPositions[randomIndex].rotation;
	game.addChild(animatedCard);
	// Random scattered position and rotation for thrown card effect
	var scatterX = 1024 + (Math.random() - 0.5) * 300;
	var scatterY = 1366 + (Math.random() - 0.5) * 200;
	var scatterRotation = (Math.random() - 0.5) * 0.8;
	tween(animatedCard, {
		x: scatterX,
		y: scatterY,
		rotation: scatterRotation
	}, {
		duration: 500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			animatedCard.destroy();
			var centerCard = new Card(playedCard);
			centerCard.x = scatterX - 1024;
			centerCard.y = scatterY - 1366;
			centerCard.rotation = scatterRotation;
			centerCardContainer.addChild(centerCard);
			// Check if AI exceeded limit
			if (currentTotal > selectedLimit) {
				endRound(true);
				return;
			}
		}
	});
	aiHand.splice(randomIndex, 1);
	// Replenish AI hand
	while (aiHand.length < 4 && deck.length > 0) {
		aiHand.push(dealCard());
	}
	LK.getSound('cardPlay').play();
	currentPlayer = 0;
	updateDisplay();
}
function aiTurn() {
	// Set up 5-second timeout for AI thinking
	aiThinkingTimeout = LK.setTimeout(function () {
		aiTimeoutHandler();
	}, 5000);
	// Simple AI strategy: play lowest safe card(s)
	var safeCards = [];
	var safeIndices = [];
	for (var i = 0; i < aiHand.length; i++) {
		if (currentTotal + aiHand[i].value <= selectedLimit) {
			safeCards.push(aiHand[i].value);
			safeIndices.push(i);
		}
	}
	if (safeCards.length === 0) {
		// Clear timeout since AI is making a play
		if (aiThinkingTimeout) {
			LK.clearTimeout(aiThinkingTimeout);
			aiThinkingTimeout = null;
		}
		// AI must play and will lose
		var minCard = Math.min.apply(Math, aiHand.map(function (card) {
			return card.value;
		}));
		var minIndex = -1;
		for (var i = 0; i < aiHand.length; i++) {
			if (aiHand[i].value === minCard) {
				minIndex = i;
				break;
			}
		}
		currentTotal += minCard;
		// Animate AI played card to center for loss case
		var playedCardData = aiHand[minIndex];
		var animatedCard = new Card(playedCardData);
		animatedCard.x = 1024 + aiCardPositions[minIndex].x;
		animatedCard.y = 500 + aiCardPositions[minIndex].y;
		animatedCard.rotation = aiCardPositions[minIndex].rotation;
		game.addChild(animatedCard);
		// Random scattered position and rotation for thrown card effect
		var scatterX = 1024 + (Math.random() - 0.5) * 300;
		var scatterY = 1366 + (Math.random() - 0.5) * 200;
		var scatterRotation = (Math.random() - 0.5) * 0.8;
		tween(animatedCard, {
			x: scatterX,
			y: scatterY,
			rotation: scatterRotation
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				animatedCard.destroy();
				var centerCard = new Card(playedCardData);
				centerCard.x = scatterX - 1024;
				centerCard.y = scatterY - 1366;
				centerCard.rotation = scatterRotation;
				centerCardContainer.addChild(centerCard);
				endRound(true);
			}
		});
		aiHand.splice(minIndex, 1);
		return;
	}
	// Clear timeout since AI is making a play
	if (aiThinkingTimeout) {
		LK.clearTimeout(aiThinkingTimeout);
		aiThinkingTimeout = null;
	}
	// Play the lowest safe card
	var minSafe = Math.min.apply(Math, safeCards);
	var playIndex = -1;
	for (var i = 0; i < aiHand.length; i++) {
		if (aiHand[i].value === minSafe) {
			playIndex = i;
			break;
		}
	}
	currentTotal += minSafe;
	// Animate AI played card to center
	var playedCardData = aiHand[playIndex];
	var animatedCard = new Card(playedCardData);
	animatedCard.x = 1024 + aiCardPositions[playIndex].x;
	animatedCard.y = 500 + aiCardPositions[playIndex].y;
	animatedCard.rotation = aiCardPositions[playIndex].rotation;
	game.addChild(animatedCard);
	// Random scattered position and rotation for thrown card effect
	var scatterX = 1024 + (Math.random() - 0.5) * 300;
	var scatterY = 1366 + (Math.random() - 0.5) * 200;
	var scatterRotation = (Math.random() - 0.5) * 0.8;
	tween(animatedCard, {
		x: scatterX,
		y: scatterY,
		rotation: scatterRotation
	}, {
		duration: 500,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			animatedCard.destroy();
			var centerCard = new Card(playedCardData);
			centerCard.x = scatterX - 1024;
			centerCard.y = scatterY - 1366;
			centerCard.rotation = scatterRotation;
			centerCardContainer.addChild(centerCard);
		}
	});
	aiHand.splice(playIndex, 1);
	// Replenish AI hand
	while (aiHand.length < 4 && deck.length > 0) {
		aiHand.push(dealCard());
	}
	LK.getSound('cardPlay').play();
	currentPlayer = 0;
	updateDisplay();
}
function endRound(playerWon) {
	LK.getSound('gameOver').play();
	if (playerWon) {
		playerScore++;
		statusText.setText('You Won! AI went over the limit.');
	} else {
		aiScore++;
		statusText.setText('You Lost! You went over the limit.');
	}
	updateDisplay();
	// Check for game end
	var winThreshold = Math.ceil(maxRounds / 2);
	if (playerScore >= winThreshold) {
		statusText.setText('Game Over! You Win!');
		LK.showYouWin();
		return;
	} else if (aiScore >= winThreshold) {
		statusText.setText('Game Over! AI Wins!');
		LK.showGameOver();
		return;
	}
	// Start new round after delay
	LK.setTimeout(function () {
		currentTotal = 0;
		currentPlayer = 0;
		centerCardContainer.removeChildren();
		dealInitialHands();
		updateDisplay();
	}, 3000);
}
// Initialize game
createLimitSelection();
game.update = function () {
	// Game loop updates
};

===================================================================
--- original.js
+++ change.js
@@ -218,17 +218,17 @@
 function createLimitSelection() {
 	var limits = [30, 50, 80];
 	for (var i = 0; i < limits.length; i++) {
 		var button = new LimitButton(limits[i]);
-		button.x = 1024 + (i - 1) * 300;
+		button.x = 1024 + (i - 1) * 400;
 		button.y = 1000;
 		limitButtons.push(button);
 		game.addChild(button);
 	}
 	var rounds = [1, 3, 5];
 	for (var i = 0; i < rounds.length; i++) {
 		var roundButton = new RoundButton(rounds[i]);
-		roundButton.x = 1024 + (i - 1) * 300;
+		roundButton.x = 1024 + (i - 1) * 400;
 		roundButton.y = 1300;
 		roundButtons.push(roundButton);
 		game.addChild(roundButton);
 	}