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

/**** 
* Classes
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	// Add null check for cardData parameter
	if (!cardData) {
		cardData = {
			value: 0,
			color: 'red'
		};
	}
	self.value = cardData.value || 0;
	self.color = cardData.color || 'red';
	self.isSelected = false;
	var assetName = selectedPlayerCount === 4 ? 'smallCard' + self.value : 'card' + self.value;
	var cardGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var cardText = new Text2(self.value.toString(), {
		size: selectedPlayerCount === 4 ? 90 : 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') {
			if (selectedPlayerCount === 2 && currentPlayer === 0) {
				self.setSelected(!self.isSelected);
				// Auto-play cards when selection changes
				LK.setTimeout(function () {
					playSelectedCards();
				}, 100);
			} else if (selectedPlayerCount === 4 && fourPlayerTypes[currentPlayer] === 0) {
				self.setSelected(!self.isSelected);
				// Auto-play cards when selection changes
				LK.setTimeout(function () {
					playSelectedCardsFourPlayer();
				}, 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 PlayerCountButton = Container.expand(function (playerCount) {
	var self = Container.call(this);
	self.playerCount = playerCount;
	self.isSelected = false;
	var buttonGraphics = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2(playerCount + ' Players', {
		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') {
			selectPlayerCount(self.playerCount);
		}
	};
	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;
});
var RulesButton = Container.expand(function () {
	var self = Container.call(this);
	var buttonGraphics = self.attachAsset('rulesButton', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2('Rules', {
		size: 60,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.down = function (x, y, obj) {
		showRules();
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state variables
var currentGameState = 'setup'; // 'setup', 'playing', 'gameOver'
var selectedPlayerCount = 0;
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;
// 4-player game variables
var fourPlayerHands = []; // Array of 4 hands
var fourPlayerScores = []; // Array of 4 scores
var fourPlayerTypes = []; // Array indicating human(0) or AI(1-3)
var fourPlayerHandContainers = []; // Array of hand containers
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 playerCountButtons = [];
var limitButtons = [];
var roundButtons = [];
var playAreaGraphics;
var totalText;
var limitText;
var playerHandContainer;
var aiHandContainer;
var playButton;
var statusText;
var scoreText;
var centerCardContainer;
var turnArrow;
var rulesButton;
var rulesContainer;
// 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() {
	// Player count selection
	var playerCounts = [2, 4];
	for (var i = 0; i < playerCounts.length; i++) {
		var playerButton = new PlayerCountButton(playerCounts[i]);
		playerButton.x = 1024 + (i - 0.5) * 400;
		playerButton.y = 800;
		playerCountButtons.push(playerButton);
		game.addChild(playerButton);
	}
	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);
	}
	// Add rules button
	rulesButton = new RulesButton();
	rulesButton.x = 1850;
	rulesButton.y = 150;
	game.addChild(rulesButton);
	// Instruction texts removed - not visible at game start
}
function selectPlayerCount(playerCount) {
	selectedPlayerCount = playerCount;
	for (var i = 0; i < playerCountButtons.length; i++) {
		playerCountButtons[i].setSelected(playerCountButtons[i].playerCount === playerCount);
	}
	checkStartGameReady();
}
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 showRules() {
	if (rulesContainer) {
		return; // Rules already showing
	}
	rulesContainer = new Container();
	rulesContainer.x = 1024;
	rulesContainer.y = 1366;
	game.addChild(rulesContainer);
	// Semi-transparent background - larger to better match text boundaries
	var rulesBackground = rulesContainer.attachAsset('playArea', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.3,
		scaleY: 6
	});
	rulesBackground.alpha = 0.9;
	rulesBackground.tint = 0x2c3e50;
	// Rules title
	var rulesTitle = new Text2('Game Rules', {
		size: 60,
		fill: 0xf1c40f
	});
	rulesTitle.anchor.set(0.5, 0.5);
	rulesTitle.x = 0;
	rulesTitle.y = -500;
	rulesContainer.addChild(rulesTitle);
	// Rules text - reduced size to fit on single screen
	var rulesText = new Text2('• Players take turns playing cards\n• The total of all played cards is tracked\n• If you exceed the chosen limit, you lose the round\n• Zero cards reset the total to zero\n• Win by reaching the target number of rounds\n• Player with highest card starts (unless they have a zero)', {
		size: 45,
		fill: 0xFFFFFF
	});
	rulesText.anchor.set(0.5, 0.5);
	rulesText.x = 0;
	rulesText.y = -200;
	rulesContainer.addChild(rulesText);
	// Close button
	var closeButton = new Container();
	var closeGraphics = closeButton.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	closeGraphics.tint = 0xe74c3c;
	var closeText = new Text2('Close', {
		size: 40,
		fill: 0xFFFFFF
	});
	closeText.anchor.set(0.5, 0.5);
	closeButton.addChild(closeText);
	closeButton.x = 0;
	closeButton.y = 400;
	closeButton.down = function (x, y, obj) {
		rulesContainer.destroy();
		rulesContainer = null;
	};
	rulesContainer.addChild(closeButton);
}
function checkStartGameReady() {
	if (selectedPlayerCount > 0 && 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;
	// Auto-set parameters for 4-player games
	if (selectedPlayerCount === 4) {
		selectedLimit = 71;
		selectedRounds = 9;
		maxRounds = 9;
	}
	// Initialize deck and deal hands first
	initializeDeck();
	if (selectedPlayerCount === 2) {
		dealInitialHands();
		// Determine starting player based on cards
		currentPlayer = determineStartingPlayer();
	} else if (selectedPlayerCount === 4) {
		initializeFourPlayerGame();
	}
	// Clear setup UI
	for (var i = 0; i < playerCountButtons.length; i++) {
		playerCountButtons[i].destroy();
	}
	playerCountButtons = [];
	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;
	}
	// Keep rules button active during gameplay
	if (!rulesButton) {
		rulesButton = new RulesButton();
		rulesButton.x = 1850;
		rulesButton.y = 150;
		game.addChild(rulesButton);
	}
	if (rulesContainer) {
		rulesContainer.destroy();
		rulesContainer = 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 (selectedPlayerCount === 2 && currentPlayer === 1) {
		LK.setTimeout(function () {
			aiTurn();
		}, 1500);
	} else if (selectedPlayerCount === 4 && fourPlayerTypes[currentPlayer] === 1) {
		LK.setTimeout(function () {
			fourPlayerAITurn();
		}, 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 value display (three times larger font, centered)
	totalText = new Text2('0', {
		size: 240,
		fill: 0x2ecc71
	});
	totalText.anchor.set(0.5, 0.5);
	totalText.x = 1536;
	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.5, 0.5);
	limitText.x = 1536;
	limitText.y = 1500;
	game.addChild(limitText);
	// Turn arrow
	turnArrow = new Text2('▼', {
		size: 80,
		fill: 0xf1c40f
	});
	turnArrow.anchor.set(0.5, 0.5);
	game.addChild(turnArrow);
	if (selectedPlayerCount === 2) {
		// 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);
		// 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);
	} else if (selectedPlayerCount === 4) {
		// Create 4 hand containers for 4-player layout
		// Bottom (Player 0 - Human)
		fourPlayerHandContainers[0] = new Container();
		fourPlayerHandContainers[0].x = 1024;
		fourPlayerHandContainers[0].y = 2500;
		game.addChild(fourPlayerHandContainers[0]);
		// Top (Player 1 - AI)
		fourPlayerHandContainers[1] = new Container();
		fourPlayerHandContainers[1].x = 1024;
		fourPlayerHandContainers[1].y = 200;
		game.addChild(fourPlayerHandContainers[1]);
		// Left (Player 2 - AI)
		fourPlayerHandContainers[2] = new Container();
		fourPlayerHandContainers[2].x = 250;
		fourPlayerHandContainers[2].y = 1366;
		game.addChild(fourPlayerHandContainers[2]);
		// Right (Player 3 - AI)
		fourPlayerHandContainers[3] = new Container();
		fourPlayerHandContainers[3].x = 1800;
		fourPlayerHandContainers[3].y = 1366;
		game.addChild(fourPlayerHandContainers[3]);
		// Score display for 4 players
		scoreText = new Text2('P1: 0 - P2: 0 - P3: 0 - P4: 0', {
			size: 30,
			fill: 0xFFFFFF
		});
		scoreText.anchor.set(0.5, 0.5);
		scoreText.x = 1024;
		scoreText.y = 100;
		game.addChild(scoreText);
	}
	// 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);
	// 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
	}
	if (selectedPlayerCount === 2) {
		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...');
		}
	} else if (selectedPlayerCount === 4) {
		updateFourPlayerDisplay();
	}
}
function updateFourPlayerDisplay() {
	// Update score display for 4 players
	scoreText.setText('P1: ' + fourPlayerScores[0] + ' - P2: ' + fourPlayerScores[1] + ' - P3: ' + fourPlayerScores[2] + ' - P4: ' + fourPlayerScores[3]);
	// Card positions for each player position
	var playerCardPositions = [
	// Bottom player (0) - horizontal layout
	[{
		x: -300,
		y: 0,
		rotation: -0.1
	}, {
		x: -100,
		y: 10,
		rotation: -0.05
	}, {
		x: 100,
		y: -5,
		rotation: 0.05
	}, {
		x: 300,
		y: 5,
		rotation: 0.1
	}],
	// Top player (1) - horizontal layout (upside down)
	[{
		x: -300,
		y: 0,
		rotation: 3.24
	}, {
		x: -100,
		y: -10,
		rotation: 3.19
	}, {
		x: 100,
		y: 5,
		rotation: 3.09
	}, {
		x: 300,
		y: -5,
		rotation: 3.04
	}],
	// Left player (2) - vertical layout
	[{
		x: 0,
		y: -150,
		rotation: 1.47
	}, {
		x: 10,
		y: -50,
		rotation: 1.52
	}, {
		x: -5,
		y: 50,
		rotation: 1.62
	}, {
		x: 5,
		y: 150,
		rotation: 1.67
	}],
	// Right player (3) - vertical layout
	[{
		x: 0,
		y: -150,
		rotation: -1.67
	}, {
		x: -10,
		y: -50,
		rotation: -1.62
	}, {
		x: 5,
		y: 50,
		rotation: -1.52
	}, {
		x: -5,
		y: 150,
		rotation: -1.47
	}]];
	// Update each player's hand
	for (var player = 0; player < 4; player++) {
		fourPlayerHandContainers[player].removeChildren();
		for (var i = 0; i < fourPlayerHands[player].length; i++) {
			if (fourPlayerTypes[player] === 0) {
				// Human player - show face-up cards
				var card = new Card(fourPlayerHands[player][i]);
				card.x = playerCardPositions[player][i].x;
				card.y = playerCardPositions[player][i].y;
				card.rotation = playerCardPositions[player][i].rotation;
				fourPlayerHandContainers[player].addChild(card);
			} else {
				// AI player - show card backs
				var cardBackAsset = 'smallCardBack' + fourPlayerHands[player][i].value;
				var cardBack = fourPlayerHandContainers[player].attachAsset(cardBackAsset, {
					anchorX: 0.5,
					anchorY: 0.5,
					x: playerCardPositions[player][i].x,
					y: playerCardPositions[player][i].y
				});
				cardBack.rotation = playerCardPositions[player][i].rotation;
			}
		}
	}
	// Update turn arrow and status based on current player
	var arrowPositions = [{
		x: 1024,
		y: 2150,
		rotation: 0
	},
	// Bottom
	{
		x: 1024,
		y: 550,
		rotation: Math.PI
	},
	// Top
	{
		x: 600,
		y: 1366,
		rotation: Math.PI / 2
	},
	// Left
	{
		x: 1450,
		y: 1366,
		rotation: -Math.PI / 2
	} // Right
	];
	turnArrow.x = arrowPositions[currentPlayer].x;
	turnArrow.y = arrowPositions[currentPlayer].y;
	turnArrow.rotation = arrowPositions[currentPlayer].rotation;
	if (fourPlayerTypes[currentPlayer] === 0) {
		statusText.setText('Your Turn - Select cards to play');
	} else {
		statusText.setText('Player ' + (currentPlayer + 1) + ' is thinking...');
	}
}
function playSelectedCardsFourPlayer() {
	var selectedCards = [];
	var selectedIndices = [];
	for (var i = 0; i < fourPlayerHandContainers[currentPlayer].children.length; i++) {
		var card = fourPlayerHandContainers[currentPlayer].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 card to center
	var playedCardData = {
		value: selectedCards[0],
		color: fourPlayerHands[currentPlayer][selectedIndices[0]].color
	};
	var animatedCard = new Card(playedCardData);
	var sourceCard = fourPlayerHandContainers[currentPlayer].children[selectedIndices[0]];
	var startPos = fourPlayerHandContainers[currentPlayer].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--) {
		fourPlayerHands[currentPlayer].splice(selectedIndices[i], 1);
	}
	// Replenish hand
	while (fourPlayerHands[currentPlayer].length < 4 && deck.length > 0) {
		fourPlayerHands[currentPlayer].push(dealCard());
	}
	// Check if player exceeded limit
	if (currentTotal > selectedLimit) {
		endFourPlayerRound();
		return;
	}
	// Move to next player clockwise
	currentPlayer = (currentPlayer + 1) % 4;
	updateDisplay();
	// If next player is AI, trigger AI turn
	if (fourPlayerTypes[currentPlayer] === 1) {
		LK.setTimeout(function () {
			fourPlayerAITurn();
		}, 1500);
	}
}
function fourPlayerAITurn() {
	// Simple AI: play lowest safe card
	var safeCards = [];
	var safeIndices = [];
	for (var i = 0; i < fourPlayerHands[currentPlayer].length; i++) {
		if (currentTotal + fourPlayerHands[currentPlayer][i].value <= selectedLimit) {
			safeCards.push(fourPlayerHands[currentPlayer][i].value);
			safeIndices.push(i);
		}
	}
	var playIndex = 0;
	var cardValue = 0;
	if (safeCards.length === 0) {
		// Must play and will lose - play smallest card
		cardValue = Math.min.apply(Math, fourPlayerHands[currentPlayer].map(function (card) {
			return card.value;
		}));
		for (var i = 0; i < fourPlayerHands[currentPlayer].length; i++) {
			if (fourPlayerHands[currentPlayer][i].value === cardValue) {
				playIndex = i;
				break;
			}
		}
	} else {
		// Play smallest safe card
		cardValue = Math.min.apply(Math, safeCards);
		for (var i = 0; i < fourPlayerHands[currentPlayer].length; i++) {
			if (fourPlayerHands[currentPlayer][i].value === cardValue) {
				playIndex = i;
				break;
			}
		}
	}
	currentTotal += cardValue;
	// Animate AI played card to center
	var playedCardData = fourPlayerHands[currentPlayer][playIndex];
	var animatedCard = new Card(playedCardData);
	animatedCard.x = fourPlayerHandContainers[currentPlayer].x;
	animatedCard.y = fourPlayerHandContainers[currentPlayer].y;
	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);
			// Check if AI exceeded limit
			if (currentTotal > selectedLimit) {
				endFourPlayerRound();
				return;
			}
		}
	});
	fourPlayerHands[currentPlayer].splice(playIndex, 1);
	// Replenish AI hand
	while (fourPlayerHands[currentPlayer].length < 4 && deck.length > 0) {
		fourPlayerHands[currentPlayer].push(dealCard());
	}
	LK.getSound('cardPlay').play();
	// Move to next player clockwise
	currentPlayer = (currentPlayer + 1) % 4;
	updateDisplay();
	// If next player is also AI, continue AI turns
	if (fourPlayerTypes[currentPlayer] === 1) {
		LK.setTimeout(function () {
			fourPlayerAITurn();
		}, 1500);
	}
}
function endFourPlayerRound() {
	LK.getSound('gameOver').play();
	// Give -1 point to the player who went over
	fourPlayerScores[currentPlayer]--;
	if (fourPlayerTypes[currentPlayer] === 0) {
		statusText.setText('You Lost! You went over the limit.');
	} else {
		statusText.setText('Player ' + (currentPlayer + 1) + ' lost! They went over the limit.');
	}
	updateDisplay();
	// Check for game end after 9 rounds
	var roundsPlayed = 0;
	for (var i = 0; i < 4; i++) {
		roundsPlayed += Math.abs(fourPlayerScores[i]);
	}
	if (roundsPlayed >= maxRounds) {
		// Find player closest to zero (highest score since we're using negative points)
		var winner = 0;
		var bestScore = fourPlayerScores[0];
		for (var i = 1; i < 4; i++) {
			if (fourPlayerScores[i] > bestScore) {
				bestScore = fourPlayerScores[i];
				winner = i;
			}
		}
		if (fourPlayerTypes[winner] === 0) {
			statusText.setText('Game Over! You Win!');
			LK.showYouWin();
		} else {
			statusText.setText('Game Over! Player ' + (winner + 1) + ' Wins!');
			LK.showGameOver();
		}
		return;
	}
	// Start new round after delay
	LK.setTimeout(function () {
		currentTotal = 0;
		currentPlayer = determineFourPlayerStartingPlayer();
		centerCardContainer.removeChildren();
		// Re-deal hands
		for (var player = 0; player < 4; player++) {
			fourPlayerHands[player] = [];
			for (var card = 0; card < 4; card++) {
				fourPlayerHands[player].push(dealCard());
			}
		}
		updateDisplay();
	}, 3000);
}
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 initializeFourPlayerGame() {
	// Initialize 4 players: human at position 0, AI at positions 1,2,3
	fourPlayerTypes = [0, 1, 1, 1]; // 0 = human, 1 = AI
	fourPlayerHands = [[], [], [], []];
	fourPlayerScores = [0, 0, 0, 0];
	fourPlayerHandContainers = [];
	// Deal 4 cards to each player
	for (var player = 0; player < 4; player++) {
		for (var card = 0; card < 4; card++) {
			fourPlayerHands[player].push(dealCard());
		}
	}
	// Determine starting player (0-3)
	currentPlayer = determineFourPlayerStartingPlayer();
}
function determineFourPlayerStartingPlayer() {
	var highestValues = [0, 0, 0, 0];
	var hasZero = [false, false, false, false];
	// Check each player's hand
	for (var player = 0; player < 4; player++) {
		for (var i = 0; i < fourPlayerHands[player].length; i++) {
			var card = fourPlayerHands[player][i];
			if (card.value === 0) {
				hasZero[player] = true;
			}
			if (card.value > highestValues[player]) {
				highestValues[player] = card.value;
			}
		}
	}
	// Find player with highest card who doesn't have zero
	var maxValue = -1;
	var startingPlayer = 0;
	for (var player = 0; player < 4; player++) {
		if (!hasZero[player] && highestValues[player] > maxValue) {
			maxValue = highestValues[player];
			startingPlayer = player;
		}
	}
	return startingPlayer;
}
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
@@ -481,8 +481,14 @@
 }
 function startGame() {
 	currentGameState = 'playing';
 	currentTotal = 0;
+	// Auto-set parameters for 4-player games
+	if (selectedPlayerCount === 4) {
+		selectedLimit = 71;
+		selectedRounds = 9;
+		maxRounds = 9;
+	}
 	// Initialize deck and deal hands first
 	initializeDeck();
 	if (selectedPlayerCount === 2) {
 		dealInitialHands();
@@ -1001,30 +1007,31 @@
 	}
 }
 function endFourPlayerRound() {
 	LK.getSound('gameOver').play();
-	// Award point to all players except the one who went over
-	for (var i = 0; i < 4; i++) {
-		if (i !== currentPlayer) {
-			fourPlayerScores[i]++;
-		}
-	}
+	// Give -1 point to the player who went over
+	fourPlayerScores[currentPlayer]--;
 	if (fourPlayerTypes[currentPlayer] === 0) {
 		statusText.setText('You Lost! You went over the limit.');
 	} else {
 		statusText.setText('Player ' + (currentPlayer + 1) + ' lost! They went over the limit.');
 	}
 	updateDisplay();
-	// Check for game end - first to reach threshold wins
-	var winThreshold = Math.ceil(maxRounds / 2);
-	var winner = -1;
+	// Check for game end after 9 rounds
+	var roundsPlayed = 0;
 	for (var i = 0; i < 4; i++) {
-		if (fourPlayerScores[i] >= winThreshold) {
-			winner = i;
-			break;
-		}
+		roundsPlayed += Math.abs(fourPlayerScores[i]);
 	}
-	if (winner !== -1) {
+	if (roundsPlayed >= maxRounds) {
+		// Find player closest to zero (highest score since we're using negative points)
+		var winner = 0;
+		var bestScore = fourPlayerScores[0];
+		for (var i = 1; i < 4; i++) {
+			if (fourPlayerScores[i] > bestScore) {
+				bestScore = fourPlayerScores[i];
+				winner = i;
+			}
+		}
 		if (fourPlayerTypes[winner] === 0) {
 			statusText.setText('Game Over! You Win!');
 			LK.showYouWin();
 		} else {
@@ -1035,9 +1042,9 @@
 	}
 	// Start new round after delay
 	LK.setTimeout(function () {
 		currentTotal = 0;
-		currentPlayer = 0;
+		currentPlayer = determineFourPlayerStartingPlayer();
 		centerCardContainer.removeChildren();
 		// Re-deal hands
 		for (var player = 0; player < 4; player++) {
 			fourPlayerHands[player] = [];