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

/**** 
* Classes
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	self.cardData = cardData;
	self.isSelected = false;
	var cardBg = self.attachAsset(cardData.element.toLowerCase() + 'CardBase', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 1.2,
		scaleY: 1.15
	});
	var elementGraphic = self.attachAsset(cardData.name.toLowerCase() + 'Card', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -20
	});
	var textBg = self.attachAsset('textBackground', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 95,
		alpha: 0.7
	});
	var nameText = new Text2(cardData.name, {
		size: 24,
		fill: 0x000000
	});
	nameText.anchor.set(0.5, 0.5);
	nameText.x = 0;
	nameText.y = 70;
	self.addChild(nameText);
	var attackText = new Text2('ATK: ' + cardData.attack, {
		size: 20,
		fill: 0xcc1010,
		stroke: 0xFFFFFF,
		strokeThickness: 2
	});
	attackText.anchor.set(0.5, 0.5);
	attackText.y = 95;
	self.addChild(attackText);
	var defenseText = new Text2('DEF: ' + cardData.defense, {
		size: 20,
		fill: 0x2795c4,
		stroke: 0xFFFFFF,
		strokeThickness: 2
	});
	defenseText.anchor.set(0.5, 0.5);
	defenseText.y = 120;
	self.addChild(defenseText);
	self.setSelected = function (selected) {
		self.isSelected = selected;
		if (selected) {
			self.scaleX = 1.3; // 1.2 * 1.1 to maintain size increase with selection effect
			self.scaleY = 1.3; // 1.2 * 1.1 to maintain size increase with selection effect
		} else {
			self.scaleX = 1.2; // Return to the 20% increased base size
			self.scaleY = 1.2; // Return to the 20% increased base size
		}
	};
	self.down = function (x, y, obj) {
		if (gameState === 'selectCard' && !self.isSelected || gameState === 'selectMode' && !self.isSelected) {
			selectCard(self);
			LK.getSound('cardSelect').play();
		}
	};
	return self;
});
var ModeButton = Container.expand(function (mode, color) {
	var self = Container.call(this);
	self.mode = mode;
	var buttonBg = self.attachAsset(mode.toLowerCase() + 'Button', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var buttonText = new Text2(mode.toUpperCase(), {
		size: 45,
		fill: 0xFFFFFF
	});
	buttonText.anchor.set(0.5, 0.5);
	self.addChild(buttonText);
	self.down = function (x, y, obj) {
		if (gameState === 'selectMode' && selectedCard) {
			playerMode = mode.toLowerCase();
			startBattle();
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Individual card element graphics
// Individual card base assets
// Card database
var cardDatabase = [{
	name: 'Sea',
	element: 'Water',
	attack: 100,
	defense: 90
}, {
	name: 'Rain',
	element: 'Water',
	attack: 80,
	defense: 90
}, {
	name: 'Tsunami',
	element: 'Water',
	attack: 90,
	defense: 100
}, {
	name: 'River',
	element: 'Water',
	attack: 90,
	defense: 80
}, {
	name: 'Ice',
	element: 'Water',
	attack: 90,
	defense: 90
}, {
	name: 'Inferno',
	element: 'Fire',
	attack: 100,
	defense: 90
}, {
	name: 'Ember',
	element: 'Fire',
	attack: 90,
	defense: 80
}, {
	name: 'Lightning',
	element: 'Fire',
	attack: 90,
	defense: 100
}, {
	name: 'Flame',
	element: 'Fire',
	attack: 90,
	defense: 90
}, {
	name: 'Spark',
	element: 'Fire',
	attack: 80,
	defense: 90
}, {
	name: 'Mountain',
	element: 'Earth',
	attack: 100,
	defense: 90
}, {
	name: 'Stone',
	element: 'Earth',
	attack: 90,
	defense: 80
}, {
	name: 'Boulder',
	element: 'Earth',
	attack: 90,
	defense: 100
}, {
	name: 'Sand',
	element: 'Earth',
	attack: 80,
	defense: 90
}, {
	name: 'Crystal',
	element: 'Earth',
	attack: 90,
	defense: 90
}, {
	name: 'Tornado',
	element: 'Air',
	attack: 100,
	defense: 90
}, {
	name: 'Breeze',
	element: 'Air',
	attack: 80,
	defense: 90
}, {
	name: 'Gale',
	element: 'Air',
	attack: 90,
	defense: 90
}, {
	name: 'Wind',
	element: 'Air',
	attack: 90,
	defense: 80
}, {
	name: 'Storm',
	element: 'Air',
	attack: 90,
	defense: 100
}, {
	name: 'Metal',
	element: 'Earth',
	attack: 100,
	defense: 80
}, {
	name: 'Cave',
	element: 'Earth',
	attack: 80,
	defense: 100
}, {
	name: 'Glacier',
	element: 'Water',
	attack: 100,
	defense: 80
}, {
	name: 'Mist',
	element: 'Water',
	attack: 80,
	defense: 100
}, {
	name: 'Volcano',
	element: 'Fire',
	attack: 100,
	defense: 80
}, {
	name: 'Ashes',
	element: 'Fire',
	attack: 80,
	defense: 100
}, {
	name: 'Cloud',
	element: 'Air',
	attack: 80,
	defense: 100
}, {
	name: 'Whirlwind',
	element: 'Air',
	attack: 100,
	defense: 80
}];
// Game state variables
var gameState = 'selectCard'; // 'selectCard', 'selectMode', 'battle', 'result'
var playerHand = [];
var enemyHand = [];
var selectedCard = null;
var enemySelectedCard = null;
var playerMode = null;
var enemyMode = null;
var battleResult = null;
var playerWins = 0;
var enemyWins = 0;
// UI elements
var handContainer = new Container();
var modeButtons = new Container();
var battleArea = null;
var battleSquares = [];
var battleSquareContainer = new Container();
var statusText = null;
var playerModeText = null;
var enemyModeText = null;
var enlargedCardContainer = new Container();
var enlargedCard = null;
var enemyCardContainer = new Container();
var enemyCard = null;
var playerWinsText = null;
var enemyWinsText = null;
var enemyHandContainer = new Container();
var enemyCardBacks = [];
// Initialize game
function initializeGame() {
	// Deal 5 random cards to each player
	var shuffledDeck = shuffleArray([].concat(cardDatabase));
	for (var i = 0; i < 5; i++) {
		playerHand.push(shuffledDeck[i]);
		enemyHand.push(shuffledDeck[i + 5]);
	}
	setupUI();
	displayPlayerHand();
	displayEnemyHand();
	LK.playMusic('backgroundMusic');
}
function shuffleArray(array) {
	for (var i = array.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}
	return array;
}
function setupUI() {
	// Hand container for player cards
	handContainer.x = 1024;
	handContainer.y = 2400;
	game.addChild(handContainer);
	// Mode selection buttons
	var attackButton = new ModeButton('Attack', 0xFF4444);
	attackButton.x = 800;
	attackButton.y = 1800;
	var defenseButton = new ModeButton('Defense', 0x4444FF);
	defenseButton.x = 1250;
	defenseButton.y = 1800;
	modeButtons.addChild(attackButton);
	modeButtons.addChild(defenseButton);
	game.addChild(modeButtons);
	modeButtons.visible = false;
	// Battle area with 4 rotating squares
	battleSquareContainer.x = 1024;
	battleSquareContainer.y = 1200;
	game.addChild(battleSquareContainer);
	// Create 4 squares in circular formation around screen center
	var radius = 200;
	var squareAssets = ['battleSquare1', 'battleSquare2', 'battleSquare3', 'battleSquare4'];
	for (var i = 0; i < 4; i++) {
		var square = LK.getAsset(squareAssets[i], {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Initial position in circle around screen center (1024, 1200)
		var angle = i * Math.PI * 2 / 4; // 90 degrees apart
		square.x = 1024 + Math.cos(angle) * radius;
		square.y = 1200 + Math.sin(angle) * radius;
		square.startAngle = angle; // Store initial angle for parametric motion
		game.addChild(square);
		battleSquares.push(square);
	}
	// Status text
	statusText = new Text2('Select a card from your hand', {
		size: 100,
		fill: 0xFFFFFF
	});
	statusText.anchor.set(0.5, 0.5);
	statusText.x = 1024;
	statusText.y = 2100;
	game.addChild(statusText);
	// Mode display texts
	playerModeText = new Text2('', {
		size: 72,
		fill: 0xFFFF00
	});
	playerModeText.anchor.set(0.5, 0.5);
	playerModeText.x = 800;
	playerModeText.y = 1700;
	game.addChild(playerModeText);
	enemyModeText = new Text2('', {
		size: 72,
		fill: 0xFF8800
	});
	enemyModeText.anchor.set(0.5, 0.5);
	enemyModeText.x = 1248;
	enemyModeText.y = 700;
	game.addChild(enemyModeText);
	// Enlarged card display area
	enlargedCardContainer.x = 350;
	enlargedCardContainer.y = 1200;
	game.addChild(enlargedCardContainer);
	// Enemy card display area
	enemyCardContainer.x = 1700;
	enemyCardContainer.y = 1200;
	game.addChild(enemyCardContainer);
	// Player wins counter
	playerWinsText = new Text2('Player Wins: 0', {
		size: 60,
		fill: 0x00FF00
	});
	playerWinsText.anchor.set(0.5, 0.5);
	playerWinsText.x = 400;
	playerWinsText.y = 150;
	game.addChild(playerWinsText);
	// Enemy wins counter
	enemyWinsText = new Text2('Enemy Wins: 0', {
		size: 60,
		fill: 0xFF0000
	});
	enemyWinsText.anchor.set(0.5, 0.5);
	enemyWinsText.x = 1648;
	enemyWinsText.y = 150;
	game.addChild(enemyWinsText);
	// Enemy hand container for card backs
	enemyHandContainer.x = 1024;
	enemyHandContainer.y = 400;
	game.addChild(enemyHandContainer);
}
function displayPlayerHand() {
	// Clear existing cards
	for (var i = handContainer.children.length - 1; i >= 0; i--) {
		handContainer.removeChild(handContainer.children[i]);
	}
	// Display current hand
	for (var i = 0; i < playerHand.length; i++) {
		var card = new Card(playerHand[i]);
		card.scaleX = 1.2; // Increase size by 20%
		card.scaleY = 1.2; // Increase size by 20%
		card.x = (i - 2) * 280; // Increase spacing from 240 to 280
		card.handIndex = i;
		handContainer.addChild(card);
	}
}
function displayEnemyHand() {
	// Clear existing card backs
	for (var i = enemyHandContainer.children.length - 1; i >= 0; i--) {
		enemyHandContainer.removeChild(enemyHandContainer.children[i]);
	}
	enemyCardBacks = [];
	// Display individual card backs for each card in enemy hand
	for (var i = 0; i < enemyHand.length; i++) {
		var cardBack = LK.getAsset(enemyHand[i].element.toLowerCase() + 'CardBack', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: 1.2,
			scaleY: 1.2
		});
		cardBack.x = (i - 2) * 280; // Same spacing as player cards
		cardBack.element = enemyHand[i].element;
		enemyHandContainer.addChild(cardBack);
		enemyCardBacks.push(cardBack);
	}
}
function selectCard(cardObj) {
	// If this card is already selected and we're in selectMode, don't do anything
	if (selectedCard === cardObj && gameState === 'selectMode') {
		return;
	}
	// Deselect all cards
	for (var i = 0; i < handContainer.children.length; i++) {
		handContainer.children[i].setSelected(false);
	}
	// Select this card
	cardObj.setSelected(true);
	selectedCard = cardObj;
	// Clear previous enlarged card with animation if it exists
	if (enlargedCard) {
		tween.stop(enlargedCard);
		tween(enlargedCard, {
			alpha: 0,
			scaleX: 0.5,
			scaleY: 0.5
		}, {
			duration: 150,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				enlargedCardContainer.removeChild(enlargedCard);
				enlargedCard = null;
				// Create new enlarged card after old one is removed
				createEnlargedCard(cardObj);
			}
		});
	} else {
		// No previous enlarged card, create new one immediately
		createEnlargedCard(cardObj);
	}
	// Move to mode selection only if not already there
	if (gameState !== 'selectMode') {
		gameState = 'selectMode';
		statusText.setText('Choose Attack or Defense mode');
		modeButtons.visible = true;
	}
}
function createEnlargedCard(cardObj) {
	// Create enlarged version of selected card
	enlargedCard = new Card(cardObj.cardData);
	enlargedCard.scaleX = 2.75;
	enlargedCard.scaleY = 2.75;
	enlargedCard.x = 0;
	enlargedCard.y = 0;
	// Start with enlarged card invisible and tween it in
	enlargedCard.alpha = 0;
	enlargedCard.scaleX = 0.5;
	enlargedCard.scaleY = 0.5;
	enlargedCardContainer.addChild(enlargedCard);
	// Animate enlarged card appearing
	tween(enlargedCard, {
		alpha: 1,
		scaleX: 2.75,
		scaleY: 2.75
	}, {
		duration: 300,
		easing: tween.easeOut
	});
}
function createEnemyCardPreview(cardData) {
	// Clear previous enemy card if it exists
	if (enemyCard) {
		tween.stop(enemyCard);
		tween(enemyCard, {
			alpha: 0,
			scaleX: 0.5,
			scaleY: 0.5
		}, {
			duration: 150,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				enemyCardContainer.removeChild(enemyCard);
				enemyCard = null;
				// Create new enemy card after old one is removed
				createNewEnemyCard(cardData);
			}
		});
	} else {
		// No previous enemy card, create new one immediately
		createNewEnemyCard(cardData);
	}
}
function createNewEnemyCard(cardData) {
	// Create enlarged version of enemy's selected card
	enemyCard = new Card(cardData);
	enemyCard.scaleX = 2.75;
	enemyCard.scaleY = 2.75;
	enemyCard.x = 0;
	enemyCard.y = 0;
	// Start with enemy card invisible and tween it in
	enemyCard.alpha = 0;
	enemyCard.scaleX = 0.5;
	enemyCard.scaleY = 0.5;
	enemyCardContainer.addChild(enemyCard);
	// Animate enemy card appearing
	tween(enemyCard, {
		alpha: 1,
		scaleX: 2.75,
		scaleY: 2.75
	}, {
		duration: 300,
		easing: tween.easeOut
	});
}
function startBattle() {
	gameState = 'battle';
	modeButtons.visible = false;
	// Enemy AI selects card and mode
	var enemyCardIndex = Math.floor(Math.random() * enemyHand.length);
	enemySelectedCard = enemyHand[enemyCardIndex];
	enemyMode = Math.random() < 0.5 ? 'attack' : 'defense';
	// Display selected cards and modes
	statusText.setText('Battle in progress...');
	playerModeText.setText('Player: ' + playerMode.toUpperCase());
	enemyModeText.setText('Enemy: ' + enemyMode.toUpperCase());
	// Show enemy card preview
	createEnemyCardPreview(enemySelectedCard);
	// Resolve battle after a delay
	LK.setTimeout(function () {
		resolveBattle();
	}, 2000);
	LK.getSound('cardBattle').play();
}
function resolveBattle() {
	var playerValue, enemyValue;
	var playerCard = selectedCard.cardData;
	var enemyCard = enemySelectedCard;
	// Determine values based on modes
	if (playerMode === 'attack') {
		playerValue = playerCard.attack;
	} else {
		playerValue = playerCard.defense;
	}
	if (enemyMode === 'attack') {
		enemyValue = enemyCard.attack;
	} else {
		enemyValue = enemyCard.defense;
	}
	// Resolve battle outcome
	var resultText = '';
	if (playerMode === 'defense' && enemyMode === 'defense') {
		// Both defense - both cards return to hand
		resultText = 'Both defended - cards returned to hand';
		battleResult = 'tie';
	} else if (playerValue > enemyValue) {
		// Player wins
		resultText = 'You win this round!';
		battleResult = 'playerWin';
		playerWins++;
		playerWinsText.setText('Player Wins: ' + playerWins);
		// Remove enemy card
		var enemyIndex = enemyHand.indexOf(enemySelectedCard);
		enemyHand.splice(enemyIndex, 1);
		displayEnemyHand();
		LK.getSound('cardWin').play();
	} else if (enemyValue > playerValue) {
		// Enemy wins
		resultText = 'Enemy wins this round!';
		battleResult = 'enemyWin';
		enemyWins++;
		enemyWinsText.setText('Enemy Wins: ' + enemyWins);
		// Remove player card
		var playerIndex = selectedCard.handIndex;
		playerHand.splice(playerIndex, 1);
	} else {
		// Tie - both cards return to hand
		resultText = 'Tie - both cards returned to hand';
		battleResult = 'tie';
	}
	statusText.setText(resultText);
	// Check win conditions
	LK.setTimeout(function () {
		checkWinCondition();
	}, 2000);
}
function checkWinCondition() {
	if (playerWins >= 3) {
		statusText.setText('Victory - You won 3 rounds!');
		LK.setScore(playerWins * 100);
		LK.showYouWin();
		return;
	} else if (enemyWins >= 3) {
		statusText.setText('Game Over - Enemy won 3 rounds!');
		LK.showGameOver();
		return;
	}
	// Continue to next round
	resetForNextRound();
}
function resetForNextRound() {
	selectedCard = null;
	enemySelectedCard = null;
	playerMode = null;
	enemyMode = null;
	battleResult = null;
	playerModeText.setText('');
	enemyModeText.setText('');
	gameState = 'selectCard';
	statusText.setText('Select a card from your hand');
	// Clear enlarged card display
	if (enlargedCard) {
		tween(enlargedCard, {
			alpha: 0,
			scaleX: 0.5,
			scaleY: 0.5
		}, {
			duration: 200,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				enlargedCardContainer.removeChild(enlargedCard);
				enlargedCard = null;
			}
		});
	}
	// Clear enemy card display
	if (enemyCard) {
		tween(enemyCard, {
			alpha: 0,
			scaleX: 0.5,
			scaleY: 0.5
		}, {
			duration: 200,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				enemyCardContainer.removeChild(enemyCard);
				enemyCard = null;
			}
		});
	}
	displayPlayerHand();
}
// Initialize the game
initializeGame();
game.update = function () {
	// Update battle squares using parametric circle equations
	var time = LK.ticks * 0.02; // Control animation speed
	var radius = 200;
	var centerX = 1024;
	var centerY = 1200;
	for (var i = 0; i < battleSquares.length; i++) {
		var square = battleSquares[i];
		if (square && square.startAngle !== undefined) {
			// Parametric circle: x = centerX + radius * cos(angle + time), y = centerY + radius * sin(angle + time)
			var angle = square.startAngle + time;
			square.x = centerX + radius * Math.cos(angle);
			square.y = centerY + radius * Math.sin(angle);
		}
	}
	// Update game logic if needed
};

===================================================================
--- original.js
+++ change.js
@@ -102,11 +102,11 @@
 
 /**** 
 * Game Code
 ****/ 
-// Card database
-// Individual card base assets
 // Individual card element graphics
+// Individual card base assets
+// Card database
 var cardDatabase = [{
 	name: 'Sea',
 	element: 'Water',
 	attack: 100,
@@ -285,8 +285,9 @@
 	}
 	setupUI();
 	displayPlayerHand();
 	displayEnemyHand();
+	LK.playMusic('backgroundMusic');
 }
 function shuffleArray(array) {
 	for (var i = array.length - 1; i > 0; i--) {
 		var j = Math.floor(Math.random() * (i + 1));