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

/**** 
* Classes
****/ 
/**** 
* Bullet Class
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.target = null;
	self.damage = 10;
	self.speed = 8;
	var bulletGraphics = self.attachAsset('bullet', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.activate = function (startX, startY, target, damage) {
		self.active = true;
		self.visible = true;
		self.x = startX;
		self.y = startY;
		self.target = target;
		self.damage = damage;
	};
	self.update = function () {
		if (!self.active || !self.target || !self.target.active) {
			PoolManager.returnBullet(self);
			return;
		}
		var dx = self.target.x - self.x;
		var dy = self.target.y - self.y;
		var distance = Math.sqrt(dx * dx + dy * dy);
		if (distance < self.speed) {
			// Hit target
			self.target.takeDamage(self.damage);
			PoolManager.returnBullet(self);
		} else {
			var angle = Math.atan2(dy, dx);
			self.x += Math.cos(angle) * self.speed;
			self.y += Math.sin(angle) * self.speed;
		}
	};
	return self;
});
/**** 
* Object Pool Manager
****/ 
/**** 
* Card Class
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	self.cardData = cardData;
	self.level = 1; // All cards start at level 1
	self.isInPlay = false;
	self.playSlotX = 0;
	self.playSlotY = 0;
	self.lastFired = 0;
	self.fireRate = 60; // Base fire rate
	self.damage = 10; // Base damage
	self.range = 200; // Can hit anywhere on path
	self.handBonus = 1; // Multiplier from poker hand
	var cardGraphics = self.attachAsset('card', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Define getSuitSymbol method before using it
	self.getSuitSymbol = function (suit) {
		switch (suit) {
			case 'hearts':
				return '♥';
			case 'diamonds':
				return '♦';
			case 'clubs':
				return '♣';
			case 'spades':
				return '♠';
			case 'joker':
				return '🃏';
			default:
				return '?';
		}
	};
	// Card value in top left corner
	var valueText = new Text2(cardData.value, {
		size: 30,
		fill: CardSystem.suitColors[cardData.suit] || 0x000000,
		weight: 800
	});
	valueText.anchor.set(0, 0);
	valueText.x = -60; // Top left
	valueText.y = -85;
	self.addChild(valueText);
	// Large suit symbol in center
	var suitText = new Text2(self.getSuitSymbol(cardData.suit), {
		size: 80,
		fill: CardSystem.suitColors[cardData.suit] || 0x000000,
		weight: 800
	});
	suitText.anchor.set(0.5, 0.5);
	suitText.y = -10; // Slightly above center
	self.addChild(suitText);
	// Level text at bottom
	var levelText = new Text2('Lvl 1', {
		size: 25,
		fill: 0x000000,
		weight: 800
	});
	levelText.anchor.set(0.5, 1);
	levelText.y = 85; // Bottom of card
	self.addChild(levelText);
	self.activate = function (x, y, inPlay) {
		self.x = x;
		self.y = y;
		self.isInPlay = inPlay || false;
		self.visible = true;
		if (inPlay) {
			self.calculateStats();
		}
	};
	self.calculateStats = function () {
		// Stats based on level only, not card face value
		var baseDamage = 10;
		var baseFireRate = 60;
		// Level scaling
		self.damage = Math.floor(baseDamage * Math.pow(1.5, self.level - 1));
		self.fireRate = Math.max(10, Math.floor(baseFireRate / Math.pow(1.2, self.level - 1)));
		// Apply poker hand bonus
		self.damage = Math.floor(self.damage * self.handBonus);
		self.fireRate = Math.max(5, Math.floor(self.fireRate / self.handBonus));
	};
	self.setLevel = function (newLevel) {
		self.level = newLevel;
		levelText.setText('Lvl ' + self.level);
		self.calculateStats();
		// Visual feedback for higher levels
		if (self.level > 1) {
			var glowIntensity = Math.min(0.3, self.level * 0.05);
			cardGraphics.alpha = 1 + glowIntensity;
		}
	};
	self.canMergeWith = function (otherCard) {
		if (!otherCard || otherCard === self) {
			return false;
		}
		// Must be same level AND (same suit OR same value)
		var sameLevel = self.level === otherCard.level;
		var sameSuit = self.cardData.suit === otherCard.cardData.suit;
		var sameValue = self.cardData.value === otherCard.cardData.value;
		return sameLevel && (sameSuit || sameValue);
	};
	self.mergeWith = function (otherCard) {
		if (!self.canMergeWith(otherCard)) {
			return null;
		}
		var newCardData;
		var newLevel = self.level + 1; // Increase level by 1
		if (self.cardData.suit === otherCard.cardData.suit) {
			// Same suit: random value, keep suit
			var randomValue = CardSystem.values[Math.floor(Math.random() * CardSystem.values.length)];
			newCardData = {
				suit: self.cardData.suit,
				value: randomValue,
				id: self.cardData.suit + '_' + randomValue
			};
		} else {
			// Same value: increase value by 1, random suit
			var currentValueIndex = CardSystem.values.indexOf(self.cardData.value);
			var nextValueIndex = (currentValueIndex + 1) % CardSystem.values.length;
			var randomSuit = CardSystem.suits[Math.floor(Math.random() * CardSystem.suits.length)];
			newCardData = {
				suit: randomSuit,
				value: CardSystem.values[nextValueIndex],
				id: randomSuit + '_' + CardSystem.values[nextValueIndex]
			};
		}
		var mergedCard = new Card(newCardData);
		mergedCard.setLevel(newLevel);
		return mergedCard;
	};
	self.findTarget = function () {
		var targets = gameState.isPlayerTurn ? activeAIChips : activePlayerChips;
		for (var i = 0; i < targets.length; i++) {
			if (targets[i].active) {
				return targets[i]; // For now, just target first available
			}
		}
		return null;
	};
	self.fire = function () {
		var target = self.findTarget();
		if (!target) {
			return;
		}
		var bullet = PoolManager.getBullet();
		if (bullet) {
			bullet.activate(self.x, self.y, target, self.damage);
			gameLayer.addChild(bullet);
			activeBullets.push(bullet);
			self.lastFired = LK.ticks;
			// Visual feedback for firing
			tween.stop(self, {
				scaleX: true,
				scaleY: true
			});
			tween(self, {
				scaleX: 0.9,
				scaleY: 0.9
			}, {
				duration: 100,
				easing: tween.quadOut,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 150,
						easing: tween.elasticOut
					});
				}
			});
		}
	};
	self.update = function () {
		if (!self.isInPlay) {
			return;
		}
		if (LK.ticks - self.lastFired >= self.fireRate) {
			self.fire();
		}
	};
	// Initialize with level 1
	self.setLevel(1);
	return self;
});
/**** 
* Poker Chip Enemy Class
****/ 
var PokerChip = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.health = 10;
	self.maxHealth = 10;
	self.value = 1; // Chip value (1, 5, 10, 25, 100)
	self.speed = 2;
	self.pathProgress = 0;
	self.isPlayerSide = true; // true for player side, false for AI side
	var chipGraphics = self.attachAsset('pokerChip', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var valueText = new Text2('1', {
		size: 30,
		fill: 0xffffff,
		weight: 800
	});
	valueText.anchor.set(0.5, 0.5);
	self.addChild(valueText);
	self.activate = function (value, isPlayerSide) {
		self.active = true;
		self.visible = true;
		self.value = value;
		self.isPlayerSide = isPlayerSide;
		self.health = self.maxHealth = value;
		self.pathProgress = 0;
		// Set chip color based on value
		self.setChipAppearance();
		// Position at start of path
		var startPos = PathSystem.getPathStart(isPlayerSide);
		self.x = startPos.x;
		self.y = startPos.y;
	};
	self.setChipAppearance = function () {
		var colors = {
			1: 0xffffff,
			// White
			5: 0xff0000,
			// Red
			10: 0x00ff00,
			// Green
			25: 0x000000,
			// Black
			100: 0x800080 // Purple
		};
		chipGraphics.tint = colors[self.value] || 0xffffff;
		valueText.setText(self.value.toString());
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		if (self.health <= 0) {
			self.die();
		}
	};
	self.die = function () {
		// Award money based on chip value
		var goldEarned = self.value;
		if (self.isPlayerSide) {
			gameState.playerGold += goldEarned;
		} else {
			gameState.aiGold += goldEarned;
		}
		// Spawn new chips on opposite side
		self.spawnCounterChips();
		PoolManager.returnChip(self);
	};
	self.spawnCounterChips = function () {
		// When player defeats AI chip, spawn chips on AI side
		// When AI defeats player chip, spawn chips on player side
		var targetSide = !self.isPlayerSide;
		var spawnCount = Math.max(1, Math.floor(self.value / 5));
		for (var i = 0; i < spawnCount; i++) {
			LK.setTimeout(function () {
				ChipSpawner.spawnChip(1, targetSide); // Spawn basic chips
			}, i * 500);
		}
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		self.pathProgress += self.speed;
		var pathPos = PathSystem.getPositionAlongPath(self.pathProgress, self.isPlayerSide);
		if (pathPos.completed) {
			// Chip reached the end
			if (self.isPlayerSide) {
				gameState.playerLives--;
			} else {
				gameState.aiLives--;
			}
			PoolManager.returnChip(self);
			return;
		}
		self.x = pathPos.x;
		self.y = pathPos.y;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
/**** 
* Poker Tower Defense - Complete Refactor
****/ 
/**** 
* Game Constants
****/ 
function _createForOfIteratorHelper(r, e) {
	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
	if (!t) {
		if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
			t && (r = t);
			var _n = 0,
				F = function F() {};
			return {
				s: F,
				n: function n() {
					return _n >= r.length ? {
						done: !0
					} : {
						done: !1,
						value: r[_n++]
					};
				},
				e: function e(r) {
					throw r;
				},
				f: F
			};
		}
		throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
	}
	var o,
		a = !0,
		u = !1;
	return {
		s: function s() {
			t = t.call(r);
		},
		n: function n() {
			var r = t.next();
			return a = r.done, r;
		},
		e: function e(r) {
			u = !0, o = r;
		},
		f: function f() {
			try {
				a || null == t["return"] || t["return"]();
			} finally {
				if (u) {
					throw o;
				}
			}
		}
	};
}
function _unsupportedIterableToArray(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray(r, a);
		}
		var t = {}.toString.call(r).slice(8, -1);
		return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
	}
}
function _arrayLikeToArray(r, a) {
	(null == a || a > r.length) && (a = r.length);
	for (var e = 0, n = Array(a); e < a; e++) {
		n[e] = r[e];
	}
	return n;
}
var SCREEN_WIDTH = 2048;
var SCREEN_HEIGHT = 2732;
var PLAY_AREA_COLS = 5;
var PLAY_AREA_ROWS = 2;
var SLOT_WIDTH = 200;
var SLOT_HEIGHT = 280;
var DEAL_SLOT_WIDTH = 160;
var DEAL_SLOT_HEIGHT = 220;
// AI area positioning (top)
var AI_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2;
var AI_AREA_Y = 150;
// Player area positioning (middle, with plenty of room below)
var PLAYER_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2;
var PLAYER_AREA_Y = SCREEN_HEIGHT - 1200; // Much higher up
// Player deal area (hand slots) - below play area
var PLAYER_DEAL_AREA_Y = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + 40;
// Deal button position - below hand slots with plenty of room
var DEAL_BUTTON_Y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT + 60;
/**** 
* Card System
****/ 
var CardSystem = {
	suits: ['hearts', 'diamonds', 'clubs', 'spades'],
	values: ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'],
	suitColors: {
		'hearts': 0xff0000,
		'diamonds': 0xff0000,
		'clubs': 0x000000,
		'spades': 0x000000
	},
	createDeck: function createDeck() {
		var deck = [];
		var _iterator = _createForOfIteratorHelper(this.suits),
			_step;
		try {
			for (_iterator.s(); !(_step = _iterator.n()).done;) {
				var suit = _step.value;
				var _iterator2 = _createForOfIteratorHelper(this.values),
					_step2;
				try {
					for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
						var value = _step2.value;
						deck.push({
							suit: suit,
							value: value,
							id: suit + '_' + value
						});
					}
				} catch (err) {
					_iterator2.e(err);
				} finally {
					_iterator2.f();
				}
			}
			// Add jokers
		} catch (err) {
			_iterator.e(err);
		} finally {
			_iterator.f();
		}
		deck.push({
			suit: 'joker',
			value: 'red',
			id: 'joker_red'
		});
		deck.push({
			suit: 'joker',
			value: 'black',
			id: 'joker_black'
		});
		return this.shuffleDeck(deck);
	},
	shuffleDeck: function shuffleDeck(deck) {
		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;
		}
		return deck;
	},
	getCardValue: function getCardValue(card) {
		if (card.suit === 'joker') {
			return 14;
		} // Jokers are highest
		if (card.value === 'A') {
			return 14;
		} // Aces high
		if (card.value === 'K') {
			return 13;
		}
		if (card.value === 'Q') {
			return 12;
		}
		if (card.value === 'J') {
			return 11;
		}
		return parseInt(card.value);
	},
	evaluatePokerHand: function evaluatePokerHand(cards) {
		var _this = this;
		if (!cards || cards.length !== 5) {
			return {
				type: 'none',
				strength: 0
			};
		}
		// Sort cards by value for easier analysis
		var sortedCards = cards.slice().sort(function (a, b) {
			return _this.getCardValue(b) - _this.getCardValue(a);
		});
		var values = sortedCards.map(function (card) {
			return _this.getCardValue(card);
		});
		var suits = sortedCards.map(function (card) {
			return card.suit;
		});
		// Count values and suits
		var valueCounts = {};
		var suitCounts = {};
		values.forEach(function (value) {
			return valueCounts[value] = (valueCounts[value] || 0) + 1;
		});
		suits.forEach(function (suit) {
			return suitCounts[suit] = (suitCounts[suit] || 0) + 1;
		});
		var counts = Object.values(valueCounts).sort(function (a, b) {
			return b - a;
		});
		var isFlush = Object.keys(suitCounts).length === 1;
		var isStraight = this.checkStraight(values);
		// Royal Flush
		if (isFlush && isStraight && values[0] === 14 && values[4] === 10) {
			return {
				type: 'royal_flush',
				strength: 10,
				multiplier: 50
			};
		}
		// Straight Flush
		if (isFlush && isStraight) {
			return {
				type: 'straight_flush',
				strength: 9,
				multiplier: 25
			};
		}
		// Four of a Kind
		if (counts[0] === 4) {
			return {
				type: 'four_of_a_kind',
				strength: 8,
				multiplier: 15
			};
		}
		// Full House
		if (counts[0] === 3 && counts[1] === 2) {
			return {
				type: 'full_house',
				strength: 7,
				multiplier: 8
			};
		}
		// Flush
		if (isFlush) {
			return {
				type: 'flush',
				strength: 6,
				multiplier: 5
			};
		}
		// Straight
		if (isStraight) {
			return {
				type: 'straight',
				strength: 5,
				multiplier: 4
			};
		}
		// Three of a Kind
		if (counts[0] === 3) {
			return {
				type: 'three_of_a_kind',
				strength: 4,
				multiplier: 3
			};
		}
		// Two Pair
		if (counts[0] === 2 && counts[1] === 2) {
			return {
				type: 'two_pair',
				strength: 3,
				multiplier: 2.5
			};
		}
		// One Pair
		if (counts[0] === 2) {
			return {
				type: 'one_pair',
				strength: 2,
				multiplier: 1.5
			};
		}
		// High Card
		return {
			type: 'high_card',
			strength: 1,
			multiplier: 1
		};
	},
	checkStraight: function checkStraight(values) {
		if (values.length !== 5) {
			return false;
		}
		// Check for ace-low straight (A, 2, 3, 4, 5)
		if (values[0] === 14 && values[1] === 5 && values[2] === 4 && values[3] === 3 && values[4] === 2) {
			return true;
		}
		// Check normal straight
		for (var i = 0; i < 4; i++) {
			if (values[i] - values[i + 1] !== 1) {
				return false;
			}
		}
		return true;
	}
};
/**** 
* Object Pool Manager
****/ 
var PoolManager = {
	chipPool: [],
	bulletPool: [],
	cardPool: [],
	CHIP_POOL_SIZE: 50,
	BULLET_POOL_SIZE: 100,
	CARD_POOL_SIZE: 60,
	init: function init() {
		// Initialize pools
		for (var i = 0; i < this.CHIP_POOL_SIZE; i++) {
			var chip = new PokerChip();
			chip.active = false;
			chip.visible = false;
			this.chipPool.push(chip);
		}
		for (var i = 0; i < this.BULLET_POOL_SIZE; i++) {
			var bullet = new Bullet();
			bullet.active = false;
			bullet.visible = false;
			this.bulletPool.push(bullet);
		}
	},
	getChip: function getChip() {
		for (var i = 0; i < this.chipPool.length; i++) {
			if (!this.chipPool[i].active) {
				return this.chipPool[i];
			}
		}
		return null;
	},
	getBullet: function getBullet() {
		for (var i = 0; i < this.bulletPool.length; i++) {
			if (!this.bulletPool[i].active) {
				return this.bulletPool[i];
			}
		}
		return null;
	},
	returnChip: function returnChip(chip) {
		chip.active = false;
		chip.visible = false;
		// Remove from active arrays
		var playerIndex = activePlayerChips.indexOf(chip);
		if (playerIndex !== -1) {
			activePlayerChips.splice(playerIndex, 1);
		}
		var aiIndex = activeAIChips.indexOf(chip);
		if (aiIndex !== -1) {
			activeAIChips.splice(aiIndex, 1);
		}
		gameLayer.removeChild(chip);
	},
	returnBullet: function returnBullet(bullet) {
		bullet.active = false;
		bullet.visible = false;
		var index = activeBullets.indexOf(bullet);
		if (index !== -1) {
			activeBullets.splice(index, 1);
		}
		gameLayer.removeChild(bullet);
	}
};
/**** 
* Path System
****/ 
var PathSystem = {
	playerPath: [],
	aiPath: [],
	init: function init() {
		// Create player path - rectangular loop around the play area
		var padding = 80; // Distance from play area
		var leftX = PLAYER_AREA_X - padding;
		var rightX = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding;
		var topY = PLAYER_AREA_Y - padding;
		var bottomY = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + padding;
		this.playerPath = [
		// Start at bottom left
		{
			x: leftX,
			y: bottomY
		},
		// Go up the left side
		{
			x: leftX,
			y: topY
		},
		// Go across the top
		{
			x: rightX,
			y: topY
		},
		// Go down the right side
		{
			x: rightX,
			y: bottomY
		}];
		// Create AI path - rectangular loop around the AI play area
		var aiLeftX = AI_AREA_X - padding;
		var aiRightX = AI_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding;
		var aiTopY = AI_AREA_Y - padding;
		var aiBottomY = AI_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + padding;
		this.aiPath = [
		// Start at bottom left
		{
			x: aiLeftX,
			y: aiBottomY
		},
		// Go up the left side
		{
			x: aiLeftX,
			y: aiTopY
		},
		// Go across the top
		{
			x: aiRightX,
			y: aiTopY
		},
		// Go down the right side
		{
			x: aiRightX,
			y: aiBottomY
		}];
	},
	getPathStart: function getPathStart(isPlayerSide) {
		return isPlayerSide ? this.playerPath[0] : this.aiPath[0];
	},
	getPositionAlongPath: function getPositionAlongPath(progress, isPlayerSide) {
		var path = isPlayerSide ? this.playerPath : this.aiPath;
		var pathLength = this.calculatePathLength(path);
		var targetDistance = progress / 100 * pathLength;
		if (targetDistance >= pathLength) {
			return {
				x: path[path.length - 1].x,
				y: path[path.length - 1].y,
				completed: true
			};
		}
		var currentDistance = 0;
		for (var i = 0; i < path.length - 1; i++) {
			var segmentLength = this.getDistance(path[i], path[i + 1]);
			if (currentDistance + segmentLength >= targetDistance) {
				var segmentProgress = (targetDistance - currentDistance) / segmentLength;
				return {
					x: path[i].x + (path[i + 1].x - path[i].x) * segmentProgress,
					y: path[i].y + (path[i + 1].y - path[i].y) * segmentProgress,
					completed: false
				};
			}
			currentDistance += segmentLength;
		}
		return {
			x: path[path.length - 1].x,
			y: path[path.length - 1].y,
			completed: true
		};
	},
	calculatePathLength: function calculatePathLength(path) {
		var total = 0;
		for (var i = 0; i < path.length - 1; i++) {
			total += this.getDistance(path[i], path[i + 1]);
		}
		return total;
	},
	getDistance: function getDistance(p1, p2) {
		var dx = p2.x - p1.x;
		var dy = p2.y - p1.y;
		return Math.sqrt(dx * dx + dy * dy);
	}
};
/**** 
* Chip Spawner
****/ 
var ChipSpawner = {
	spawnChip: function spawnChip(value, isPlayerSide) {
		var chip = PoolManager.getChip();
		if (!chip) {
			return;
		}
		chip.activate(value, isPlayerSide);
		gameLayer.addChild(chip);
		if (isPlayerSide) {
			activePlayerChips.push(chip);
		} else {
			activeAIChips.push(chip);
		}
	}
};
/**** 
* Game State
****/ 
var gameState = {
	playerGold: 100,
	aiGold: 100,
	playerLives: 3,
	aiLives: 3,
	isPlayerTurn: true,
	dealCost: 50,
	dealCount: 0,
	playerDeck: [],
	playerHand: [],
	playerPlayArea: [],
	// 2D array [row][col]
	aiDeck: [],
	aiPlayArea: []
};
/**** 
* Game Variables
****/ 
var activePlayerChips = [];
var activeAIChips = [];
var activeBullets = [];
var selectedCard = null;
var isDragging = false;
var gameLayer = new Container();
var uiLayer = new Container();
game.addChild(gameLayer);
game.addChild(uiLayer);
/**** 
* UI Elements
****/ 
var playerGoldText = new Text2('Gold: 100', {
	size: 50,
	fill: 0xffd700,
	weight: 800
});
playerGoldText.x = 50;
playerGoldText.y = SCREEN_HEIGHT - 120;
uiLayer.addChild(playerGoldText);
var playerLivesText = new Text2('Lives: 3', {
	size: 50,
	fill: 0xff0000,
	weight: 800
});
playerLivesText.x = 50;
playerLivesText.y = SCREEN_HEIGHT - 180;
uiLayer.addChild(playerLivesText);
// Add AI stats too for clarity
var aiGoldText = new Text2('AI Gold: 100', {
	size: 40,
	fill: 0xffd700,
	weight: 800
});
aiGoldText.x = 50;
aiGoldText.y = 50;
uiLayer.addChild(aiGoldText);
var aiLivesText = new Text2('AI Lives: 3', {
	size: 40,
	fill: 0xff0000,
	weight: 800
});
aiLivesText.x = 50;
aiLivesText.y = 100;
uiLayer.addChild(aiLivesText);
var dealButton = new Container();
var dealButtonGraphics = dealButton.attachAsset('dealButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var dealButtonText = new Text2('Deal (50)', {
	size: 40,
	fill: 0xffffff,
	weight: 800
});
dealButtonText.anchor.set(0.5, 0.5);
dealButton.addChild(dealButtonText);
dealButton.x = SCREEN_WIDTH / 2;
dealButton.y = DEAL_BUTTON_Y;
uiLayer.addChild(dealButton);
dealButton.down = function () {
	if (gameState.playerGold >= gameState.dealCost) {
		dealNewHand();
	}
};
/**** 
* Game Functions
****/ 
function initializeGame() {
	PoolManager.init();
	PathSystem.init();
	// Initialize play areas
	gameState.playerPlayArea = [];
	gameState.aiPlayArea = [];
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		gameState.playerPlayArea[row] = [];
		gameState.aiPlayArea[row] = [];
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			gameState.playerPlayArea[row][col] = null;
			gameState.aiPlayArea[row][col] = null;
		}
	}
	// Create initial decks
	gameState.playerDeck = CardSystem.createDeck();
	gameState.aiDeck = CardSystem.createDeck();
	// Draw grid lines
	drawPlayAreas();
	drawPaths();
	// Deal initial hand
	dealNewHand();
	// Start spawning chips
	LK.setTimeout(function () {
		ChipSpawner.spawnChip(5, false); // Spawn on AI side
	}, 2000);
}
function dealNewHand() {
	if (gameState.playerGold < gameState.dealCost) {
		return;
	}
	gameState.playerGold -= gameState.dealCost;
	gameState.dealCount++;
	gameState.dealCost = Math.floor(50 * Math.pow(1.2, gameState.dealCount));
	// Clear current hand
	gameState.playerHand.forEach(function (card) {
		if (card) {
			uiLayer.removeChild(card);
		}
	});
	gameState.playerHand = [];
	// Deal 5 new cards
	for (var i = 0; i < 5; i++) {
		if (gameState.playerDeck.length === 0) {
			gameState.playerDeck = CardSystem.createDeck();
		}
		var cardData = gameState.playerDeck.pop();
		var card = new Card(cardData);
		var slotX = PLAYER_AREA_X + i * DEAL_SLOT_WIDTH + i * 20 + DEAL_SLOT_WIDTH / 2;
		var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
		card.activate(slotX, slotY, false);
		uiLayer.addChild(card);
		gameState.playerHand[i] = card;
	}
	updateUI();
}
function updateUI() {
	playerGoldText.setText('Gold: ' + gameState.playerGold);
	playerLivesText.setText('Lives: ' + gameState.playerLives);
	aiGoldText.setText('AI Gold: ' + gameState.aiGold);
	aiLivesText.setText('AI Lives: ' + gameState.aiLives);
	dealButtonText.setText('Deal (' + gameState.dealCost + ')');
	// Update button color based on affordability
	if (gameState.playerGold >= gameState.dealCost) {
		dealButtonGraphics.tint = 0x00aa00;
	} else {
		dealButtonGraphics.tint = 0x666666;
	}
}
function drawPlayAreas() {
	// Draw player play area slots
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var slot = new Container();
			var slotGraphics = slot.attachAsset('playSlot', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			slotGraphics.alpha = 0.3;
			slot.x = PLAYER_AREA_X + col * SLOT_WIDTH + SLOT_WIDTH / 2;
			slot.y = PLAYER_AREA_Y + row * SLOT_HEIGHT + SLOT_HEIGHT / 2;
			gameLayer.addChild(slot);
		}
	}
	// Draw AI play area slots
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var slot = new Container();
			var slotGraphics = slot.attachAsset('playSlot', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			slotGraphics.alpha = 0.3;
			slotGraphics.tint = 0x440000; // Red tint for AI area
			slot.x = AI_AREA_X + col * SLOT_WIDTH + SLOT_WIDTH / 2;
			slot.y = AI_AREA_Y + row * SLOT_HEIGHT + SLOT_HEIGHT / 2;
			gameLayer.addChild(slot);
		}
	}
	// Draw player deal area slots (hand)
	for (var i = 0; i < 5; i++) {
		var dealSlot = new Container();
		var dealSlotGraphics = dealSlot.attachAsset('dealSlot', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		dealSlotGraphics.alpha = 0.2;
		dealSlot.x = PLAYER_AREA_X + i * DEAL_SLOT_WIDTH + i * 20 + DEAL_SLOT_WIDTH / 2;
		dealSlot.y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
		gameLayer.addChild(dealSlot);
	}
}
function drawPaths() {
	// Draw player path
	for (var i = 0; i < PathSystem.playerPath.length - 1; i++) {
		var start = PathSystem.playerPath[i];
		var end = PathSystem.playerPath[i + 1];
		drawPathSegment(start, end, 0x666666);
	}
	// Draw AI path
	for (var i = 0; i < PathSystem.aiPath.length - 1; i++) {
		var start = PathSystem.aiPath[i];
		var end = PathSystem.aiPath[i + 1];
		drawPathSegment(start, end, 0x664444);
	}
}
function drawPathSegment(start, end, color) {
	var dx = end.x - start.x;
	var dy = end.y - start.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	var segments = Math.floor(distance / 20);
	for (var i = 0; i <= segments; i++) {
		var progress = i / segments;
		var x = start.x + dx * progress;
		var y = start.y + dy * progress;
		var pathDot = new Container();
		var dotGraphics = pathDot.attachAsset('pathSegment', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		dotGraphics.width = dotGraphics.height = 8;
		dotGraphics.tint = color;
		dotGraphics.alpha = 0.6;
		pathDot.x = x;
		pathDot.y = y;
		gameLayer.addChild(pathDot);
	}
}
function getSlotPosition(row, col, isPlayerArea) {
	var baseX = isPlayerArea ? PLAYER_AREA_X : AI_AREA_X;
	var baseY = isPlayerArea ? PLAYER_AREA_Y : AI_AREA_Y;
	return {
		x: baseX + col * SLOT_WIDTH + SLOT_WIDTH / 2,
		y: baseY + row * SLOT_HEIGHT + SLOT_HEIGHT / 2
	};
}
function getSlotFromPosition(x, y) {
	// Check player play area
	if (x >= PLAYER_AREA_X && x <= PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH && y >= PLAYER_AREA_Y && y <= PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT) {
		var col = Math.floor((x - PLAYER_AREA_X) / SLOT_WIDTH);
		var row = Math.floor((y - PLAYER_AREA_Y) / SLOT_HEIGHT);
		if (col >= 0 && col < PLAY_AREA_COLS && row >= 0 && row < PLAY_AREA_ROWS) {
			return {
				area: 'player',
				row: row,
				col: col
			};
		}
	}
	return null;
}
function evaluateRowHand(row, isPlayerArea) {
	var playArea = isPlayerArea ? gameState.playerPlayArea : gameState.aiPlayArea;
	var cards = [];
	for (var col = 0; col < PLAY_AREA_COLS; col++) {
		if (playArea[row][col]) {
			cards.push(playArea[row][col].cardData);
		}
	}
	if (cards.length === 5) {
		return CardSystem.evaluatePokerHand(cards);
	}
	return {
		type: 'none',
		strength: 0,
		multiplier: 1
	};
}
function applyHandBonuses() {
	// Apply bonuses to player cards
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		var handEval = evaluateRowHand(row, true);
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var card = gameState.playerPlayArea[row][col];
			if (card) {
				card.handBonus = handEval.multiplier;
				card.calculateStats();
			}
		}
	}
	// Apply bonuses to AI cards
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		var handEval = evaluateRowHand(row, false);
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var card = gameState.aiPlayArea[row][col];
			if (card) {
				card.handBonus = handEval.multiplier;
				card.calculateStats();
			}
		}
	}
}
/**** 
* AI System
****/ 
var AISystem = {
	thinkTimer: 0,
	thinkDelay: 120,
	// 2 seconds
	update: function update() {
		if (gameState.isPlayerTurn) {
			return;
		}
		this.thinkTimer++;
		if (this.thinkTimer >= this.thinkDelay) {
			this.thinkTimer = 0;
			this.makeMove();
		}
	},
	makeMove: function makeMove() {
		// Simple AI: deal new hand if can afford it
		if (gameState.aiGold >= gameState.dealCost) {
			this.dealAIHand();
		}
		// Try to place cards from AI hand to play area
		this.tryPlaceCards();
		// Spawn some chips on player side
		if (Math.random() < 0.3) {
			ChipSpawner.spawnChip(Math.floor(Math.random() * 3) + 1, true);
		}
		gameState.isPlayerTurn = true;
	},
	dealAIHand: function dealAIHand() {
		gameState.aiGold -= gameState.dealCost;
		// Deal cards directly to AI play area
		for (var attempt = 0; attempt < 5; attempt++) {
			if (gameState.aiDeck.length === 0) {
				gameState.aiDeck = CardSystem.createDeck();
			}
			var cardData = gameState.aiDeck.pop();
			var card = new Card(cardData);
			// Find empty slot
			var placed = false;
			for (var row = 0; row < PLAY_AREA_ROWS && !placed; row++) {
				for (var col = 0; col < PLAY_AREA_COLS && !placed; col++) {
					if (!gameState.aiPlayArea[row][col]) {
						var pos = getSlotPosition(row, col, false);
						card.activate(pos.x, pos.y, true);
						gameLayer.addChild(card);
						gameState.aiPlayArea[row][col] = card;
						placed = true;
					}
				}
			}
			if (!placed) {
				break;
			} // No more space
		}
	},
	tryPlaceCards: function tryPlaceCards() {
		// AI logic for placing cards (simplified)
		// In a full implementation, this would be more sophisticated
	}
};
/**** 
* Input Handling
****/ 
game.down = function (x, y, obj) {
	// Check if clicking on a card in hand
	for (var i = 0; i < gameState.playerHand.length; i++) {
		var card = gameState.playerHand[i];
		if (card && Math.abs(x - card.x) < DEAL_SLOT_WIDTH / 2 && Math.abs(y - card.y) < DEAL_SLOT_HEIGHT / 2) {
			selectedCard = card;
			isDragging = true;
			return;
		}
	}
	// Check if clicking on a card in play area
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var card = gameState.playerPlayArea[row][col];
			if (card && Math.abs(x - card.x) < SLOT_WIDTH / 2 && Math.abs(y - card.y) < SLOT_HEIGHT / 2) {
				selectedCard = card;
				isDragging = true;
				// Remove from current position
				gameState.playerPlayArea[row][col] = null;
				return;
			}
		}
	}
};
game.move = function (x, y, obj) {
	if (isDragging && selectedCard) {
		selectedCard.x = x;
		selectedCard.y = y;
	}
};
game.up = function (x, y, obj) {
	if (isDragging && selectedCard) {
		isDragging = false;
		var targetSlot = getSlotFromPosition(x, y);
		if (targetSlot && targetSlot.area === 'player') {
			var existingCard = gameState.playerPlayArea[targetSlot.row][targetSlot.col];
			if (existingCard && selectedCard.canMergeWith(existingCard)) {
				// Merge cards - both must be same level!
				var mergedCard = selectedCard.mergeWith(existingCard);
				if (mergedCard) {
					// Remove old cards
					gameLayer.removeChild(existingCard);
					var handIndex = gameState.playerHand.indexOf(selectedCard);
					if (handIndex !== -1) {
						uiLayer.removeChild(selectedCard);
						gameState.playerHand[handIndex] = null;
					}
					// Place merged card
					var pos = getSlotPosition(targetSlot.row, targetSlot.col, true);
					mergedCard.activate(pos.x, pos.y, true);
					gameLayer.addChild(mergedCard);
					gameState.playerPlayArea[targetSlot.row][targetSlot.col] = mergedCard;
					// Merge animation
					mergedCard.alpha = 0;
					mergedCard.scaleX = mergedCard.scaleY = 2;
					tween(mergedCard, {
						alpha: 1,
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 300,
						easing: tween.elasticOut
					});
					// Show level up notification
					createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00);
				}
			} else if (!existingCard) {
				// Place card in empty slot
				var pos = getSlotPosition(targetSlot.row, targetSlot.col, true);
				selectedCard.activate(pos.x, pos.y, true);
				// Remove from hand if it was in hand
				var handIndex = gameState.playerHand.indexOf(selectedCard);
				if (handIndex !== -1) {
					uiLayer.removeChild(selectedCard);
					gameLayer.addChild(selectedCard);
					gameState.playerHand[handIndex] = null;
				}
				gameState.playerPlayArea[targetSlot.row][targetSlot.col] = selectedCard;
			} else {
				// Can't merge or place - return to original position
				returnCardToOriginalPosition();
			}
		} else {
			// Return to original position
			returnCardToOriginalPosition();
		}
		selectedCard = null;
		applyHandBonuses();
	}
};
function returnCardToOriginalPosition() {
	var handIndex = gameState.playerHand.indexOf(selectedCard);
	if (handIndex !== -1) {
		// Return to hand
		var slotX = PLAYER_AREA_X + handIndex * DEAL_SLOT_WIDTH + handIndex * 20 + DEAL_SLOT_WIDTH / 2;
		var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
		selectedCard.x = slotX;
		selectedCard.y = slotY;
	}
}
function createFloatingText(text, x, y, color) {
	var floatingText = new Text2(text, {
		size: 40,
		fill: color || 0xffffff,
		weight: 800
	});
	floatingText.anchor.set(0.5, 0.5);
	floatingText.x = x;
	floatingText.y = y;
	floatingText.alpha = 1;
	uiLayer.addChild(floatingText);
	tween(floatingText, {
		y: y - 80,
		alpha: 0
	}, {
		duration: 1500,
		easing: tween.quadOut,
		onFinish: function onFinish() {
			uiLayer.removeChild(floatingText);
		}
	});
}
/**** 
* Main Game Loop
****/ 
game.update = function () {
	// Update active chips
	for (var i = activePlayerChips.length - 1; i >= 0; i--) {
		activePlayerChips[i].update();
	}
	for (var i = activeAIChips.length - 1; i >= 0; i--) {
		activeAIChips[i].update();
	}
	// Update active bullets
	for (var i = activeBullets.length - 1; i >= 0; i--) {
		activeBullets[i].update();
	}
	// Update cards in play
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			if (gameState.playerPlayArea[row][col]) {
				gameState.playerPlayArea[row][col].update();
			}
			if (gameState.aiPlayArea[row][col]) {
				gameState.aiPlayArea[row][col].update();
			}
		}
	}
	// Update AI
	AISystem.update();
	// Check win/lose conditions
	if (gameState.playerLives <= 0) {
		showGameOver(false);
	} else if (gameState.aiLives <= 0) {
		showGameOver(true);
	}
	updateUI();
};
/**** 
* Game Over
****/ 
function showGameOver(playerWon) {
	var overlay = new Container();
	var bg = overlay.attachAsset('playSlot', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bg.width = SCREEN_WIDTH;
	bg.height = SCREEN_HEIGHT;
	bg.tint = 0x000000;
	bg.alpha = 0.8;
	var resultText = new Text2(playerWon ? 'YOU WIN!' : 'YOU LOSE!', {
		size: 100,
		fill: playerWon ? 0x00ff00 : 0xff0000,
		weight: 800
	});
	resultText.anchor.set(0.5, 0.5);
	overlay.addChild(resultText);
	var restartText = new Text2('Tap to Restart', {
		size: 60,
		fill: 0xffffff,
		weight: 600
	});
	restartText.anchor.set(0.5, 0.5);
	restartText.y = 100;
	overlay.addChild(restartText);
	overlay.x = SCREEN_WIDTH / 2;
	overlay.y = SCREEN_HEIGHT / 2;
	game.addChild(overlay);
	overlay.down = function () {
		location.reload();
	};
}
/**** 
* Utility Functions
****/ 
function displayHandInfo() {
	// Show current poker hand evaluations for debugging
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		var handEval = evaluateRowHand(row, true);
		console.log('Player Row ' + row + ':', handEval.type, 'Multiplier:', handEval.multiplier);
	}
}
initializeGame();

===================================================================
--- original.js
+++ change.js
@@ -351,12 +351,12 @@
 /**** 
 * Game Code
 ****/ 
 /**** 
-* Game Constants
+* Poker Tower Defense - Complete Refactor
 ****/ 
 /**** 
-* Poker Tower Defense - Complete Refactor
+* Game Constants
 ****/ 
 function _createForOfIteratorHelper(r, e) {
 	var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
 	if (!t) {
@@ -432,16 +432,16 @@
 var DEAL_SLOT_WIDTH = 160;
 var DEAL_SLOT_HEIGHT = 220;
 // AI area positioning (top)
 var AI_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2;
-var AI_AREA_Y = 100; // Moved up a bit
-// Player area positioning (middle-bottom, with room for hand below)
+var AI_AREA_Y = 150;
+// Player area positioning (middle, with plenty of room below)
 var PLAYER_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2;
-var PLAYER_AREA_Y = SCREEN_HEIGHT - 800; // Much higher up to leave room
+var PLAYER_AREA_Y = SCREEN_HEIGHT - 1200; // Much higher up
 // Player deal area (hand slots) - below play area
-var PLAYER_DEAL_AREA_Y = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + 20; // 20px gap
-// Deal button position - below hand slots
-var DEAL_BUTTON_Y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT + 30; // 30px gap below hand
+var PLAYER_DEAL_AREA_Y = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + 40;
+// Deal button position - below hand slots with plenty of room
+var DEAL_BUTTON_Y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT + 60;
 /**** 
 * Card System
 ****/ 
 var CardSystem = {
@@ -721,43 +721,60 @@
 var PathSystem = {
 	playerPath: [],
 	aiPath: [],
 	init: function init() {
-		// Create player path (bottom area)
-		var playerStartX = PLAYER_AREA_X - 100;
-		var playerStartY = PLAYER_AREA_Y + SLOT_HEIGHT;
-		var playerEndX = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + 100;
-		var playerEndY = playerStartY;
-		this.playerPath = [{
-			x: playerStartX,
-			y: playerStartY
-		}, {
-			x: playerStartX + 50,
-			y: playerStartY - 100
-		}, {
-			x: playerEndX - 50,
-			y: playerStartY - 100
-		}, {
-			x: playerEndX,
-			y: playerStartY
+		// Create player path - rectangular loop around the play area
+		var padding = 80; // Distance from play area
+		var leftX = PLAYER_AREA_X - padding;
+		var rightX = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding;
+		var topY = PLAYER_AREA_Y - padding;
+		var bottomY = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + padding;
+		this.playerPath = [
+		// Start at bottom left
+		{
+			x: leftX,
+			y: bottomY
+		},
+		// Go up the left side
+		{
+			x: leftX,
+			y: topY
+		},
+		// Go across the top
+		{
+			x: rightX,
+			y: topY
+		},
+		// Go down the right side
+		{
+			x: rightX,
+			y: bottomY
 		}];
-		// Create AI path (top area) - mirrored
-		var aiStartX = AI_AREA_X - 100;
-		var aiStartY = AI_AREA_Y + SLOT_HEIGHT;
-		var aiEndX = AI_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + 100;
-		var aiEndY = aiStartY;
-		this.aiPath = [{
-			x: aiStartX,
-			y: aiStartY
-		}, {
-			x: aiStartX + 50,
-			y: aiStartY - 100
-		}, {
-			x: aiEndX - 50,
-			y: aiStartY - 100
-		}, {
-			x: aiEndX,
-			y: aiEndY
+		// Create AI path - rectangular loop around the AI play area
+		var aiLeftX = AI_AREA_X - padding;
+		var aiRightX = AI_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding;
+		var aiTopY = AI_AREA_Y - padding;
+		var aiBottomY = AI_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + padding;
+		this.aiPath = [
+		// Start at bottom left
+		{
+			x: aiLeftX,
+			y: aiBottomY
+		},
+		// Go up the left side
+		{
+			x: aiLeftX,
+			y: aiTopY
+		},
+		// Go across the top
+		{
+			x: aiRightX,
+			y: aiTopY
+		},
+		// Go down the right side
+		{
+			x: aiRightX,
+			y: aiBottomY
 		}];
 	},
 	getPathStart: function getPathStart(isPlayerSide) {
 		return isPlayerSide ? this.playerPath[0] : this.aiPath[0];
@@ -861,18 +878,35 @@
 	fill: 0xffd700,
 	weight: 800
 });
 playerGoldText.x = 50;
-playerGoldText.y = SCREEN_HEIGHT - 80; // Moved up from bottom
+playerGoldText.y = SCREEN_HEIGHT - 120;
 uiLayer.addChild(playerGoldText);
 var playerLivesText = new Text2('Lives: 3', {
 	size: 50,
 	fill: 0xff0000,
 	weight: 800
 });
 playerLivesText.x = 50;
-playerLivesText.y = SCREEN_HEIGHT - 140; // Moved up from bottom
+playerLivesText.y = SCREEN_HEIGHT - 180;
 uiLayer.addChild(playerLivesText);
+// Add AI stats too for clarity
+var aiGoldText = new Text2('AI Gold: 100', {
+	size: 40,
+	fill: 0xffd700,
+	weight: 800
+});
+aiGoldText.x = 50;
+aiGoldText.y = 50;
+uiLayer.addChild(aiGoldText);
+var aiLivesText = new Text2('AI Lives: 3', {
+	size: 40,
+	fill: 0xff0000,
+	weight: 800
+});
+aiLivesText.x = 50;
+aiLivesText.y = 100;
+uiLayer.addChild(aiLivesText);
 var dealButton = new Container();
 var dealButtonGraphics = dealButton.attachAsset('dealButton', {
 	anchorX: 0.5,
 	anchorY: 0.5
@@ -884,9 +918,9 @@
 });
 dealButtonText.anchor.set(0.5, 0.5);
 dealButton.addChild(dealButtonText);
 dealButton.x = SCREEN_WIDTH / 2;
-dealButton.y = DEAL_BUTTON_Y; // Use the new constant
+dealButton.y = DEAL_BUTTON_Y;
 uiLayer.addChild(dealButton);
 dealButton.down = function () {
 	if (gameState.playerGold >= gameState.dealCost) {
 		dealNewHand();
@@ -953,8 +987,10 @@
 }
 function updateUI() {
 	playerGoldText.setText('Gold: ' + gameState.playerGold);
 	playerLivesText.setText('Lives: ' + gameState.playerLives);
+	aiGoldText.setText('AI Gold: ' + gameState.aiGold);
+	aiLivesText.setText('AI Lives: ' + gameState.aiLives);
 	dealButtonText.setText('Deal (' + gameState.dealCost + ')');
 	// Update button color based on affordability
 	if (gameState.playerGold >= gameState.dealCost) {
 		dealButtonGraphics.tint = 0x00aa00;