/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1", {
	battleRating: 0,
	money: 0,
	ownedMods: {},
	randomModPrice: 300,
	tutorialCompleted: false
});

/**** 
* Classes
****/ 
/**** 
* Bullet Class
****/ 
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.target = null;
	self.damage = 10;
	self.speed = 15.6;
	self.isPlayerCard = true;
	self.isSeekingLastPosition = false;
	self.targetLastX = 0;
	self.targetLastY = 0;
	self.level = 1;
	self.ricochetCount = 0;
	self.ricochetedFrom = [];
	var currentGraphic = null;
	var suitGraphics = {
		'hearts': self.attachAsset(ModSystem.getEquippedModAsset('hearts') || 'heartSuit', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		'diamonds': self.attachAsset(ModSystem.getEquippedModAsset('diamonds') || 'diamondSuit', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		'clubs': self.attachAsset(ModSystem.getEquippedModAsset('clubs') || 'clubSuit', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		'spades': self.attachAsset(ModSystem.getEquippedModAsset('spades') || 'spadeSuit', {
			anchorX: 0.5,
			anchorY: 0.5
		})
	};
	// Set scale and hide all suit graphics initially.
	for (var suit in suitGraphics) {
		var graphic = suitGraphics[suit];
		graphic.scale.set(0.3); // Small bullets
		graphic.visible = false;
	}
	self.activate = function (startX, startY, target, damage, suit, isPlayerCard, level) {
		self.active = true;
		self.visible = true;
		self.x = startX;
		self.y = startY;
		self.target = target;
		self.damage = damage;
		self.isPlayerCard = isPlayerCard;
		self.level = level || 1;
		self.suit = suit || 'hearts';
		self.isSeekingLastPosition = false;
		self.ricochetCount = 0;
		self.ricochetedFrom = [];
		if (suit === 'clubs' && ModSystem.getEquippedModAsset('clubs') === 'ricochetClubsMod') {
			// 2 bounces, +1 every 2 levels. Max 5.
			self.ricochetCount = Math.min(5, 2 + Math.floor((self.level - 1) / 2));
		}
		if (self.target) {
			self.targetLastX = self.target.x;
			self.targetLastY = self.target.y;
		}
		if (currentGraphic) {
			currentGraphic.visible = false;
		}
		if (suit && suitGraphics[suit]) {
			currentGraphic = suitGraphics[suit];
		} else {
			// Default to hearts if no suit specified
			currentGraphic = suitGraphics['hearts'];
		}
		currentGraphic.visible = true;
	};
	self.findNewTarget = function () {
		// Use the same targeting logic as cards, but from bullet's perspective
		var targets = self.isPlayerCard ? activePlayerChips : activeAIChips;
		var bestTarget = null;
		var shortestDistanceSq = Infinity;
		for (var i = 0; i < targets.length; i++) {
			if (targets[i].active) {
				var dx = targets[i].x - self.x;
				var dy = targets[i].y - self.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq < shortestDistanceSq) {
					shortestDistanceSq = distanceSq;
					bestTarget = targets[i];
				}
			}
		}
		return bestTarget;
	};
	self.findRicochetTarget = function () {
		// Use the same targeting logic as cards, but from bullet's perspective
		var targets = self.isPlayerCard ? activePlayerChips : activeAIChips;
		var bestTarget = null;
		var shortestDistanceSq = Infinity;
		for (var i = 0; i < targets.length; i++) {
			var potentialTarget = targets[i];
			if (potentialTarget.active && self.ricochetedFrom.indexOf(potentialTarget) === -1) {
				var dx = potentialTarget.x - self.x;
				var dy = potentialTarget.y - self.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq < shortestDistanceSq) {
					shortestDistanceSq = distanceSq;
					bestTarget = potentialTarget;
				}
			}
		}
		return bestTarget;
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// If target is destroyed, try to find a new target instead of seeking last position
		if (self.target && !self.target.active) {
			var newTarget = self.findNewTarget();
			if (newTarget) {
				self.target = newTarget;
				self.targetLastX = newTarget.x;
				self.targetLastY = newTarget.y;
				// Continue with normal targeting logic
			} else {
				// No new target available, seek last position
				self.isSeekingLastPosition = true;
				self.target = null;
			}
		}
		// If seeking, move towards the last position
		if (self.isSeekingLastPosition) {
			var dx = self.targetLastX - self.x;
			var dy = self.targetLastY - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			if (distance < self.speed) {
				// Arrived at destination, recycle bullet
				self.isSeekingLastPosition = false;
				if (currentGraphic) {
					currentGraphic.visible = false;
				}
				PoolManager.returnBullet(self);
			} else {
				// Move towards destination
				var angle = Math.atan2(dy, dx);
				self.x += Math.cos(angle) * self.speed;
				self.y += Math.sin(angle) * self.speed;
			}
		} else if (self.target) {
			// Store previous position for continuous collision detection
			var prevX = self.x;
			var prevY = self.y;
			// Update last known position
			self.targetLastX = self.target.x;
			self.targetLastY = self.target.y;
			var dx = self.target.x - self.x;
			var dy = self.target.y - self.y;
			var distance = Math.sqrt(dx * dx + dy * dy);
			// Calculate where bullet will be after this frame
			var angle = Math.atan2(dy, dx);
			var newX = self.x + Math.cos(angle) * self.speed;
			var newY = self.y + Math.sin(angle) * self.speed;
			// RELIABLE COLLISION DETECTION:
			// Check if the bullet's path for this frame intersects the target's radius.
			// This prevents "tunneling" where a fast bullet could pass through a target between frames.
			var hitRadius = 85; // Visual radius of the chip, matches chip graphics
			var collisionDistance = distancePointToLine(self.target.x, self.target.y, prevX, prevY, newX, newY);
			if (collisionDistance <= hitRadius) {
				// Hit detected
				// NEW: Check for Execute mod for Spades BEFORE dealing damage
				if (self.suit === 'spades' && ModSystem.getEquippedModAsset('spades') === 'deathSpadesMod') {
					// Execute threshold: starts at 15%, +1% per level. Max 40%.
					var executeThreshold = Math.min(0.40, 0.15 + (self.level - 1) * 0.01);
					// Execute chance: starts at 20%, +2% per level. Max 50%.
					var executeChance = Math.min(0.50, 0.20 + (self.level - 1) * 0.02);
					if (self.target.health / self.target.maxHealth <= executeThreshold) {
						if (Math.random() < executeChance) {
							// Execute!
							createFloatingText('EXECUTE!', self.target.x, self.target.y - 60, 0xaa00aa, 50);
							// Create the execution animation
							var executionEffect = LK.getAsset('deathSpadesMod', {
								anchorX: 0.5,
								anchorY: 0.5,
								x: self.target.x,
								y: self.target.y,
								scaleX: 0.1,
								scaleY: 0.1,
								alpha: 1
							});
							gameLayer.addChild(executionEffect);
							tween(executionEffect, {
								scaleX: 1.5,
								scaleY: 1.5,
								alpha: 0
							}, {
								duration: 500,
								easing: tween.quadOut,
								onFinish: function onFinish() {
									if (executionEffect.parent) {
										executionEffect.parent.removeChild(executionEffect);
									}
								}
							});
							self.target.takeDamage(self.target.health); // Deal fatal damage
							// Recycle bullet and stop further processing
							if (currentGraphic) {
								currentGraphic.visible = false;
							}
							PoolManager.returnBullet(self);
							return; // IMPORTANT: Exit update for this bullet
						}
					}
				}
				// If not executed, proceed with normal hit logic
				self.target.takeDamage(self.damage);
				// NEW: Check if this is a hearts bullet and flame mod is equipped
				if (self.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts') === 'burnHeartMod') {
					// Calculate burn damage (10% of hit damage per tick)
					var burnDamage = self.damage * 0.1;
					// Increase burn duration by 50% (from 5 to 7.5 ticks)
					var burnDuration = Math.round(5 * 1.5); // 7.5 → 8 ticks = ~4 seconds of burning
					// Apply burn effect
					self.target.applyBurn(burnDamage, burnDuration);
				}
				// NEW: Check if this is a spades bullet and freeze mod is equipped
				if (self.suit === 'spades' && ModSystem.getEquippedModAsset('spades') === 'freezeSpadeMod') {
					// Calculate freeze duration (3 seconds base)
					var freezeDuration = 180; // 180 ticks at 60fps = 3 seconds
					// Apply freeze effect
					self.target.applyFreeze(freezeDuration);
				}
				// NEW: Check if this is a clubs bullet and slow mod is equipped
				if (self.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs') === 'slowClubsMod') {
					// Slow amount: 20% base, +5% per level. Max 70%.
					var slowAmount = Math.min(0.7, 0.2 + (self.level - 1) * 0.05);
					// Slow duration: 2s base, +0.5s per level.
					var slowDuration = 120 + (self.level - 1) * 30; // 120 ticks = 2s
					self.target.applySlow(slowAmount, slowDuration);
				}
				// NEW: Check for ricochet mod for clubs
				if (self.ricochetCount > 0) {
					self.ricochetedFrom.push(self.target);
					var newTarget = self.findRicochetTarget();
					if (newTarget) {
						self.target = newTarget;
						self.targetLastX = newTarget.x;
						self.targetLastY = newTarget.y;
						self.ricochetCount--;
						self.damage = Math.floor(self.damage * 0.7); // 70% damage on next hit
						// Visual feedback for ricochet
						createExplosion(self.x, self.y, 0xcccccc);
						return; // Keep the bullet alive and moving to the new target
					}
				}
				if (currentGraphic) {
					currentGraphic.visible = false;
				}
				PoolManager.returnBullet(self);
			} else {
				// No hit, move bullet forward
				self.x = newX;
				self.y = newY;
			}
		} else {
			// No target and not seeking, recycle
			if (currentGraphic) {
				currentGraphic.visible = false;
			}
			PoolManager.returnBullet(self);
		}
	};
	return self;
});
// Helper function to calculate distance from point to line segment
/**** 
* Object Pool Manager
****/ 
/**** 
* Card Class
****/ 
var Card = Container.expand(function (cardData) {
	var self = Container.call(this);
	self.cardData = cardData;
	self.level = 1;
	self.isInPlay = false;
	self.isPlayerCard = true; // Track which player owns this card
	self.playSlotX = 0;
	self.playSlotY = 0;
	self.lastFired = 0;
	self.fireRate = 60; // Base fire rate (ticks between shots)
	self.damage = 35; // Increased base damage
	self.range = 200;
	self.handBonus = 1;
	self.timeOnBoard = 0;
	self.lastIncomeTick = 0;
	var redOutline = self.attachAsset('card', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	redOutline.scale.set(1.1);
	redOutline.alpha = 1.0;
	redOutline.tint = 0xff0000; // Red color
	redOutline.visible = false;
	self.redOutline = redOutline;
	var greenOutline = self.attachAsset('card', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	greenOutline.scale.set(1.1);
	greenOutline.alpha = 0.7;
	greenOutline.tint = 0x00ff00;
	greenOutline.visible = false;
	self.greenOutline = greenOutline;
	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
	if (cardData.suit !== 'joker') {
		var valueText = new Text2(cardData.value, {
			size: 56,
			fill: CardSystem.suitColors[cardData.suit] || 0x000000,
			weight: 800,
			stroke: 0x000000,
			strokeThickness: 0
		});
		valueText.anchor.set(0, 0);
		valueText.x = -95; // Top left
		valueText.y = -135;
		self.addChild(valueText);
	}
	// Large suit symbol in center
	var suitAssetId = null;
	var equippedMod = ModSystem.getEquippedModAsset(cardData.suit);
	if (equippedMod) {
		suitAssetId = equippedMod;
	} else {
		switch (cardData.suit) {
			case 'hearts':
				suitAssetId = 'heartSuit';
				break;
			case 'diamonds':
				suitAssetId = 'diamondSuit';
				break;
			case 'clubs':
				suitAssetId = 'clubSuit';
				break;
			case 'spades':
				suitAssetId = 'spadeSuit';
				break;
		}
	}
	if (suitAssetId) {
		var suitGraphics = self.attachAsset(suitAssetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		suitGraphics.y = -15;
		suitGraphics.scaleX = suitGraphics.scaleY = 0.8;
	} else if (cardData.suit === 'joker') {
		var jokerSuitGraphics = self.attachAsset('jokerSuit', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		jokerSuitGraphics.y = -15;
		jokerSuitGraphics.scale.set(1.5);
	}
	// Level text at bottom
	var levelText = new Text2('Lvl 1', {
		size: 45,
		fill: 0x000000,
		weight: 800,
		stroke: 0x000000,
		strokeThickness: 0
	});
	levelText.anchor.set(0.5, 1);
	levelText.y = 128; // Bottom of card
	self.addChild(levelText);
	self.activate = function (x, y, inPlay, isPlayerCard) {
		self.x = x;
		self.y = y;
		self.isInPlay = inPlay || false;
		self.isPlayerCard = isPlayerCard !== undefined ? isPlayerCard : true;
		self.visible = true;
		if (inPlay) {
			self.calculateStats();
		}
	};
	self.calculateStats = function () {
		// Stats based on level only, not card face value
		var baseDamage = 10; // Reduced base damage
		var baseFireRate = 60;
		// Level scaling - more dramatic improvements per level
		self.damage = Math.floor(baseDamage * Math.pow(1.6, self.level - 1)); // Further decreased scaling from 1.7 to 1.6
		self.fireRate = Math.max(15, Math.floor(baseFireRate / Math.pow(1.2, self.level - 1))); // Reduced from 1.25 to 1.2
		// Apply poker hand bonus
		self.damage = Math.floor(self.damage * self.handBonus);
		self.fireRate = Math.max(10, Math.floor(self.fireRate / self.handBonus));
		// NEW: Apply mod-specific stat changes
		if (self.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades') === 'mineSpadesMod') {
			// Mine mod significantly slows fire rate in exchange for higher damage per mine.
			self.fireRate *= 2.5;
		}
	};
	self.setLevel = function (newLevel) {
		if (self.cardData.suit === 'joker') {
			self.level = 1;
			levelText.visible = false;
			self.calculateStats();
			return;
		}
		self.level = newLevel;
		levelText.setText('Lvl ' + self.level);
		self.calculateStats();
		self.resetInvestment();
		// Visual feedback for higher levels
		if (self.level > 1) {
			// The glow effect was causing cards to become translucent.
			// Level up is already indicated by animation and floating text.
		}
	};
	self.resetInvestment = function () {
		self.timeOnBoard = 0;
		self.lastIncomeTick = LK.ticks;
	};
	self.canMergeWith = function (otherCard) {
		if (!otherCard || otherCard === self) {
			return false;
		}
		// If the card being dropped onto is a Joker, it cannot be leveled up.
		if (otherCard.cardData.suit === 'joker') {
			return false;
		}
		// If the card being dragged is a Joker, it can merge with any non-Joker card.
		if (self.cardData.suit === 'joker') {
			return true;
		}
		// 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;
		}
		// When merging, the new card levels up. The new level is one higher than the card on the board.
		var newLevel = otherCard.level + 1;
		// Special case: If the card being dragged is a Joker, the target card just increases its level
		if (self.cardData.suit === 'joker') {
			var mergedCard = new Card(otherCard.cardData);
			mergedCard.setLevel(newLevel);
			return mergedCard;
		}
		// The new card is of a random type, regardless of what was merged.
		var randomSuit = CardSystem.suits[Math.floor(Math.random() * CardSystem.suits.length)];
		var randomValue = CardSystem.values[Math.floor(Math.random() * CardSystem.values.length)];
		var newCardData = {
			suit: randomSuit,
			value: randomValue,
			id: randomSuit + '_' + randomValue
		};
		var mergedCard = new Card(newCardData);
		mergedCard.setLevel(newLevel);
		return mergedCard;
	};
	self.findTarget = function () {
		// Player cards target enemies attacking the player (activePlayerChips)
		// AI cards target enemies attacking the AI (activeAIChips)
		var targets = self.isPlayerCard ? activePlayerChips : activeAIChips;
		var bestTarget = null;
		var highestProgress = -1;
		for (var i = 0; i < targets.length; i++) {
			var chip = targets[i];
			// Add extra validation for alive targets
			if (chip.active && chip.health > 0 && chip.visible && chip.pathProgress > highestProgress) {
				highestProgress = chip.pathProgress;
				bestTarget = chip;
			}
		}
		return bestTarget;
	};
	self.fire = function () {
		var target = self.findTarget();
		if (!target) {
			return;
		}
		// NEW: Handle Mine Spades Mod
		if (self.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades') === 'mineSpadesMod') {
			var mine = PoolManager.getMine();
			if (mine) {
				var pathProgress = Math.random() * 70 + 15;
				var minePos = PathSystem.getPositionAlongPath(pathProgress, self.isPlayerCard);
				var mineDamage = Math.floor(self.damage * 2.5); // Mines deal 2.5x card damage
				mine.activate(minePos.x, minePos.y, mineDamage, self.isPlayerCard);
				gameLayer.addChild(mine);
				activeMines.push(mine);
			}
		} else {
			var damageToDeal = self.damage;
			// NEW: Calculate Unity Bonus for Hearts
			if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts') === 'unityHeartsMod') {
				var playArea = self.isPlayerCard ? gameState.playerPlayArea : gameState.aiPlayArea;
				var cardRow = -1,
					cardCol = -1;
				// Find card's position in the grid
				for (var r = 0; r < PLAY_AREA_ROWS; r++) {
					for (var c = 0; c < PLAY_AREA_COLS; c++) {
						if (playArea[r][c] === self) {
							cardRow = r;
							cardCol = c;
							break;
						}
					}
					if (cardRow !== -1) {
						break;
					}
				}
				if (cardRow !== -1) {
					var adjacentHearts = 0;
					var neighbors = [[cardRow - 1, cardCol], [cardRow + 1, cardCol], [cardRow, cardCol - 1], [cardRow, cardCol + 1]];
					for (var i = 0; i < neighbors.length; i++) {
						var nRow = neighbors[i][0];
						var nCol = neighbors[i][1];
						if (nRow >= 0 && nRow < PLAY_AREA_ROWS && nCol >= 0 && nCol < PLAY_AREA_COLS) {
							var neighborCard = playArea[nRow][nCol];
							if (neighborCard && neighborCard.cardData.suit === 'hearts') {
								adjacentHearts++;
							}
						}
					}
					// Each adjacent heart adds 25% bonus damage
					damageToDeal = Math.floor(damageToDeal * (1 + 0.25 * adjacentHearts));
				}
			}
			// NEW: Calculate Gambler Bonus for Diamonds
			if (self.cardData.suit === 'diamonds' && ModSystem.getEquippedModAsset('diamonds') === 'gamblerDiamondsMod') {
				// Base 50% chance of double damage, increases by 5% per level. Capped at 95%.
				var doubleDamageChance = Math.min(0.95, 0.5 + (self.level - 1) * 0.05);
				if (Math.random() < doubleDamageChance) {
					damageToDeal *= 2;
					createFloatingText('x2!', self.x, self.y - 70, 0xffd700, 30);
				} else {
					damageToDeal = 0;
					createFloatingText('Miss!', self.x, self.y - 70, 0xaaaaaa, 30);
				}
			}
			// NEW: Calculate Boost from adjacent Diamonds
			var playArea = self.isPlayerCard ? gameState.playerPlayArea : gameState.aiPlayArea;
			var cardRow = -1,
				cardCol = -1;
			// Find card's position in the grid
			for (var r = 0; r < PLAY_AREA_ROWS; r++) {
				for (var c = 0; c < PLAY_AREA_COLS; c++) {
					if (playArea[r][c] === self) {
						cardRow = r;
						cardCol = c;
						break;
					}
				}
				if (cardRow !== -1) {
					break;
				}
			}
			if (cardRow !== -1) {
				var totalBoostPercentage = 0;
				var neighbors = [[cardRow - 1, cardCol], [cardRow + 1, cardCol], [cardRow, cardCol - 1], [cardRow, cardCol + 1]];
				for (var i = 0; i < neighbors.length; i++) {
					var nRow = neighbors[i][0];
					var nCol = neighbors[i][1];
					if (nRow >= 0 && nRow < PLAY_AREA_ROWS && nCol >= 0 && nCol < PLAY_AREA_COLS) {
						var neighborCard = playArea[nRow][nCol];
						if (neighborCard && neighborCard.cardData.suit === 'diamonds' && ModSystem.getEquippedModAsset('diamonds') === 'boostDiamondsMod') {
							// Each level of the booster card adds 10% damage.
							totalBoostPercentage += neighborCard.level * 0.10;
						}
					}
				}
				if (totalBoostPercentage > 0) {
					damageToDeal = Math.floor(damageToDeal * (1 + totalBoostPercentage));
				}
			}
			// Check if this is a clubs card with spreadshot mod equipped
			var isSpreadshot = self.cardData.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs') === 'spreadClubMod';
			if (isSpreadshot) {
				// Spreadshot: reduced damage but hits multiple targets
				var spreadDamage = Math.floor(self.damage * 0.6); // 30% damage reduction
				var maxTargets = Math.min(1 + self.level, 5); // 1 + level targets, max 5
				var allTargets = self.isPlayerCard ? activePlayerChips : activeAIChips;
				var closestTargets = []; // This will store {chip, distanceSq} objects
				// Find multiple targets using an efficient selection method instead of sorting all targets
				for (var i = 0; i < allTargets.length; i++) {
					var chip = allTargets[i];
					if (chip.active && chip.health > 0 && chip.visible) {
						var dx = chip.x - self.x;
						var dy = chip.y - self.y;
						var distanceSq = dx * dx + dy * dy;
						if (closestTargets.length < maxTargets) {
							closestTargets.push({
								chip: chip,
								distanceSq: distanceSq
							});
						} else {
							var furthestDistSq = -1;
							var furthestIdx = -1;
							for (var j = 0; j < closestTargets.length; j++) {
								if (closestTargets[j].distanceSq > furthestDistSq) {
									furthestDistSq = closestTargets[j].distanceSq;
									furthestIdx = j;
								}
							}
							if (distanceSq < furthestDistSq) {
								closestTargets[furthestIdx] = {
									chip: chip,
									distanceSq: distanceSq
								};
							}
						}
					}
				}
				// Fire at the found targets
				for (var i = 0; i < closestTargets.length; i++) {
					var bullet = PoolManager.getBullet();
					if (bullet) {
						bullet.activate(self.x, self.y, closestTargets[i].chip, spreadDamage, self.cardData.suit, self.isPlayerCard, self.level);
						gameLayer.addChild(bullet);
						activeBullets.push(bullet);
					}
				}
			} else {
				// Normal single-target firing
				var bullet = PoolManager.getBullet();
				if (bullet) {
					bullet.activate(self.x, self.y, target, damageToDeal, self.cardData.suit, self.isPlayerCard, self.level);
					gameLayer.addChild(bullet);
					activeBullets.push(bullet);
				}
			}
		}
		// Play shoot sound for player cards
		if (self.isPlayerCard) {
			LK.getSound('shootSound').play();
		}
		self.lastFired = LK.ticks;
		// Visual feedback for firing (enhanced for spreadshot)
		tween.stop(self, {
			scaleX: true,
			scaleY: true
		});
		var isSpreadshot = self.cardData.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs') === 'spreadClubMod';
		var scaleAmount = isSpreadshot ? 0.8 : 0.9; // More dramatic scale for spreadshot
		tween(self, {
			scaleX: scaleAmount,
			scaleY: scaleAmount
		}, {
			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;
		}
		// NEW: Handle Investment Hearts Mod
		if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts') === 'investmentHeartsMod') {
			// Generate income every 5 seconds (300 ticks)
			var incomeInterval = 300;
			if (LK.ticks - self.lastIncomeTick >= incomeInterval) {
				self.lastIncomeTick = LK.ticks;
				// timeOnBoard is a counter of income ticks, not actual ticks on board
				self.timeOnBoard++;
				// Income formula: 1 chip base, +1 for every 2 intervals (10 seconds). Max 5.
				var income = 1 + Math.floor(self.timeOnBoard / 2);
				income = Math.min(income, 5); // Cap income
				if (self.isPlayerCard) {
					gameState.playerChips += income;
					createFloatingText('+' + income, self.x, self.y - 70, 0xffd700, 30);
					updateUI();
				} else {
					// AI gets income too
					gameState.aiChips += income;
				}
			}
		}
		if (LK.ticks - self.lastFired >= self.fireRate) {
			self.fire();
		}
	};
	// Initialize with level 1
	self.setLevel(1);
	return self;
});
var Mine = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.damage = 50;
	self.isPlayerMine = true;
	self.explosionRadiusSq = 150 * 150;
	var mineGraphics = self.attachAsset('mine', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	mineGraphics.scale.set(0.8);
	self.activate = function (x, y, damage, isPlayerMine) {
		self.active = true;
		self.visible = true;
		self.x = x;
		self.y = y;
		self.damage = damage;
		self.isPlayerMine = isPlayerMine;
		self.scale.set(0.1);
		tween(self, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 200,
			easing: tween.backOut
		});
	};
	self.explode = function () {
		if (!self.active) {
			return;
		}
		self.active = false;
		createExplosion(self.x, self.y, 0xffa500);
		var targets = self.isPlayerMine ? activePlayerChips : activeAIChips;
		for (var i = targets.length - 1; i >= 0; i--) {
			var chip = targets[i];
			if (chip.active) {
				var dx = chip.x - self.x;
				var dy = chip.y - self.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq < self.explosionRadiusSq) {
					chip.takeDamage(self.damage);
				}
			}
		}
		PoolManager.returnMine(self);
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		var targets = self.isPlayerMine ? activePlayerChips : activeAIChips;
		var collisionRadiusSq = 45 * 45;
		for (var i = 0; i < targets.length; i++) {
			var chip = targets[i];
			if (chip.active) {
				var dx = chip.x - self.x;
				var dy = chip.y - self.y;
				var distanceSq = dx * dx + dy * dy;
				if (distanceSq < collisionRadiusSq) {
					self.explode();
					break;
				}
			}
		}
	};
	return self;
});
/**** 
* Poker Chip Enemy Class
****/ 
var PokerChip = Container.expand(function () {
	var self = Container.call(this);
	self.active = false;
	self.health = 100; // Increased base health
	self.maxHealth = 100;
	self.value = 1;
	self.speed = 0.05;
	self.pathProgress = 0;
	self.isPlayerSide = true;
	self.damageFlashTimer = 0;
	self.burnDamage = 0;
	self.burnDuration = 0;
	self.burnTickTimer = 0;
	self.burnTickInterval = 30; // Burn ticks every 0.5 seconds (30 ticks at 60fps)
	self.slowDuration = 0;
	self.slowAmount = 0;
	self.freezeDuration = 0;
	self.originalSpeed = 0;
	self.iceCube = null; // Will hold the ice cube graphic
	self.freezeImmunityTimer = 0;
	self.slowEffectIcon = null;
	var chipGraphicsAssets = {
		1: self.attachAsset('yellowChip', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		5: self.attachAsset('redChip', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		10: self.attachAsset('greenChip', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		25: self.attachAsset('blueChip', {
			anchorX: 0.5,
			anchorY: 0.5
		}),
		100: self.attachAsset('purpleChip', {
			anchorX: 0.5,
			anchorY: 0.5
		})
	};
	var chipGraphics = null; // This will hold the current visible chip
	for (var val in chipGraphicsAssets) {
		chipGraphicsAssets[val].visible = false;
	}
	var healthText = new Text2('', {
		size: 80,
		fill: 0xffffff,
		weight: 800,
		stroke: 0x000000,
		strokeThickness: 8
	});
	healthText.anchor.set(0.5, 0.5);
	self.addChild(healthText);
	self.applyBurn = function (damage, duration) {
		// Stack burn damage but refresh duration
		self.burnDamage += damage;
		self.burnDuration = Math.max(self.burnDuration, duration);
		self.burnTickTimer = 0;
		// REMOVED: Visual tint feedback - only use particles now
		// if (chipGraphics) {
		//     chipGraphics.tint = 0xff4400; // Orange tint for burning
		// }
		// Create burn effect particles
		createBurnEffect(self.x, self.y);
	};
	self.applyFreeze = function (duration) {
		// Return if chip is immune to freeze
		if (self.freezeImmunityTimer > 0) {
			return;
		}
		// Don't freeze if already frozen - with special logic for bosses
		if (self.freezeDuration > 0) {
			if (!self.isBoss) {
				// Non-bosses can refresh duration
				self.freezeDuration = Math.max(self.freezeDuration, duration);
			}
			// Bosses simply ignore the new freeze request if they are already frozen.
			return;
		}
		self.freezeDuration = duration;
		// Store original speed and stop movement
		if (self.slowDuration <= 0) {
			self.originalSpeed = self.speed;
		}
		self.speed = 0;
		// Create ice cube encasement
		if (!self.iceCube) {
			self.iceCube = LK.getAsset('iceCube', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.iceCube.scale.set(1.2); // Slightly larger than chip
			self.iceCube.alpha = 0.8;
			self.addChild(self.iceCube);
		}
		self.iceCube.visible = true;
		// Ice formation animation
		self.iceCube.scale.set(0.1);
		self.iceCube.alpha = 0;
		tween(self.iceCube, {
			scaleX: 1.2,
			scaleY: 1.2,
			alpha: 0.8
		}, {
			duration: 300,
			easing: tween.backOut
		});
	};
	self.processFreeze = function () {
		// Process immunity first, which ticks down every frame.
		if (self.freezeImmunityTimer > 0) {
			self.freezeImmunityTimer--;
		}
		if (self.freezeDuration <= 0) {
			return;
		}
		self.freezeDuration--;
		// Create occasional ice sparkle effects
		if (Math.random() < 0.1) {
			createIceSparkles(self.x, self.y);
		}
		// When freeze expires, break the ice
		if (self.freezeDuration <= 0) {
			if (self.slowDuration > 0) {
				self.speed = self.originalSpeed * (1 - self.slowAmount);
			} else {
				self.speed = self.originalSpeed;
			}
			self.freezeImmunityTimer = 120; // Apply 2-second immunity (120 ticks)
			if (self.iceCube) {
				// Ice breaking animation
				tween(self.iceCube, {
					scaleX: 1.5,
					scaleY: 1.5,
					alpha: 0
				}, {
					duration: 200,
					easing: tween.quadOut,
					onFinish: function onFinish() {
						self.iceCube.visible = false;
					}
				});
				// Create ice shatter particles
				createIceShatterEffect(self.x, self.y);
			}
		}
	};
	self.processBurnDamage = function () {
		if (self.burnDuration <= 0) {
			// Ensure burn is completely cleared
			self.burnDamage = 0;
			self.burnTickTimer = 0;
			return;
		}
		self.burnTickTimer++;
		if (self.burnTickTimer >= self.burnTickInterval) {
			self.burnTickTimer = 0;
			self.burnDuration--;
			// Apply burn damage (10% of original hit damage)
			var actualBurnDamage = Math.ceil(self.burnDamage);
			self.health -= actualBurnDamage;
			self.updateHealthText();
			// Create floating burn damage text
			createFloatingText('-' + actualBurnDamage, self.x + (Math.random() - 0.5) * 40, self.y - 30, 0xff4400, 30);
			// Burn particles
			createBurnEffect(self.x, self.y);
			if (self.health <= 0) {
				self.active = false;
				self.die();
				return;
			}
			// Reduce burn damage over time (burn weakens)
			self.burnDamage *= 0.9;
			// Clear burn when duration expires - NO TINT MANAGEMENT
			if (self.burnDuration <= 0) {
				self.burnDamage = 0;
				self.burnTickTimer = 0; // Also reset tick timer
				// REMOVED: No tint reset needed
				// if (chipGraphics && self.damageFlashTimer <= 0) {
				//     chipGraphics.tint = 0xffffff;
				// }
			}
		}
	};
	self.applySlow = function (amount, duration) {
		// A new slow can be applied if it's stronger, or to refresh duration.
		// We won't let slow override freeze.
		if (self.freezeDuration > 0) {
			return;
		}
		if (self.slowDuration <= 0) {
			// Not currently slowed, so store the original speed
			self.originalSpeed = self.speed;
			// Apply visual effects
			if (chipGraphics) {
				chipGraphics.tint = 0xaaaaaa;
			}
			if (!self.slowEffectIcon) {
				self.slowEffectIcon = LK.getAsset('slowClubsMod', {
					anchorX: 0.5,
					anchorY: 0.5
				});
				self.slowEffectIcon.scale.set(0.7);
				self.addChild(self.slowEffectIcon);
			}
			self.slowEffectIcon.visible = true;
		}
		self.slowDuration = duration;
		self.slowAmount = amount;
		// Apply slow relative to the original speed before any slows were applied.
		self.speed = self.originalSpeed * (1 - self.slowAmount);
	};
	self.processSlow = function () {
		if (self.slowDuration > 0) {
			self.slowDuration--;
			if (self.slowDuration <= 0) {
				self.slowAmount = 0;
				// Slow has expired. If not frozen, restore speed.
				if (self.freezeDuration <= 0) {
					self.speed = self.originalSpeed;
				}
				// Remove visual effects
				if (chipGraphics && self.damageFlashTimer <= 0) {
					chipGraphics.tint = 0xffffff;
				}
				if (self.slowEffectIcon) {
					self.slowEffectIcon.visible = false;
				}
			}
		}
	};
	self.activate = function (value, isPlayerSide, startPos) {
		self.active = true;
		self.visible = true;
		self.value = value;
		self.isPlayerSide = isPlayerSide;
		// Mark boss chips (they have much higher values than normal chips)
		self.isBoss = value >= 100;
		// Health scales with chip value - more valuable chips are tankier
		self.maxHealth = value * 50;
		// Double health after every 10 waves
		var healthMultiplier = Math.pow(2, Math.floor(WaveSystem.waveNumber / 10));
		self.maxHealth = self.maxHealth * healthMultiplier;
		self.health = self.maxHealth;
		self.pathProgress = 0;
		// NEW: Reset burn status to ensure clean state
		self.burnDamage = 0;
		self.burnDuration = 0;
		self.burnTickTimer = 0;
		// NEW: Reset freeze status to ensure clean state
		self.slowDuration = 0;
		self.slowAmount = 0;
		self.freezeDuration = 0;
		self.originalSpeed = 0;
		if (self.iceCube) {
			self.iceCube.visible = false;
		}
		if (self.slowEffectIcon) {
			self.slowEffectIcon.visible = false;
		}
		self.freezeImmunityTimer = 0;
		// Set all chips to yellow chip speed
		self.speed = 0.03;
		// Reset damage flash timer
		self.damageFlashTimer = 0;
		// Recreate healthText to ensure proper styling
		if (healthText && healthText.parent) {
			healthText.parent.removeChild(healthText);
		}
		healthText = new Text2('', {
			size: 80,
			fill: 0xffffff,
			weight: 800,
			stroke: 0x000000,
			strokeThickness: 8
		});
		healthText.anchor.set(0.5, 0.5);
		self.addChild(healthText);
		self.setChipAppearance();
		self.x = startPos.x;
		self.y = startPos.y;
	};
	self.updateHealthText = function () {
		// Remove the old text object
		if (healthText && healthText.parent) {
			healthText.parent.removeChild(healthText);
		}
		// Create a new text object with all styling properties
		healthText = new Text2(formatNumberWithSuffix(Math.max(0, self.health)), {
			size: 80,
			fill: 0xffffff,
			weight: 800,
			stroke: 0x000000,
			strokeThickness: 8
		});
		healthText.anchor.set(0.5, 0.5);
		self.addChild(healthText);
	};
	self.setChipAppearance = function () {
		if (chipGraphics) {
			chipGraphics.visible = false;
		}
		chipGraphics = chipGraphicsAssets[self.value] || chipGraphicsAssets[1];
		if (chipGraphics) {
			chipGraphics.visible = true;
		}
		self.updateHealthText();
	};
	self.takeDamage = function (damage) {
		self.health -= damage;
		self.updateHealthText();
		self.damageFlashTimer = 10; // Flash for 10 ticks instead of setTimeout
		if (self.health <= 0) {
			// IMMEDIATELY mark as inactive to prevent further hits
			self.active = false;
			self.die();
		}
	};
	self.die = function () {
		// Sound effect removed - no longer play pokerChipDie sound
		var chipsEarned = Math.ceil(self.value * 1.5);
		if (self.isPlayerSide) {
			var greedBonus = calculateGreedBonus(true, chipsEarned);
			var totalEarned = chipsEarned + greedBonus;
			gameState.playerChips += totalEarned;
			if (greedBonus > 0) {
				createFloatingText('+' + formatNumberWithSuffix(totalEarned) + ' (+' + formatNumberWithSuffix(greedBonus) + ' greed)', self.x, self.y - 30, 0xffd700, 35);
			}
		} else {
			var greedBonus = calculateGreedBonus(false, chipsEarned);
			gameState.aiChips += chipsEarned + greedBonus;
		}
		PoolManager.returnChip(self);
	};
	self.update = function () {
		if (!self.active) {
			return;
		}
		// Handle damage flash (keep this for regular damage)
		if (self.damageFlashTimer > 0) {
			self.damageFlashTimer--;
			if (chipGraphics) {
				if (self.damageFlashTimer > 0) {
					chipGraphics.tint = 0xff0000;
				} else {
					// Flash is over, restore correct tint
					if (self.slowDuration > 0) {
						chipGraphics.tint = 0xaaaaaa;
					} else {
						chipGraphics.tint = 0xffffff;
					}
				}
			}
		}
		// NEW: Process burn damage
		self.processBurnDamage();
		// NEW: Process freeze effect
		self.processFreeze();
		// NEW: Process slow effect
		self.processSlow();
		if (!self.active) {
			return;
		}
		self.pathProgress += self.speed;
		var pathPos = PathSystem.getPositionAlongPath(self.pathProgress, self.isPlayerSide);
		if (pathPos.completed) {
			// Boss chips remove 2 hearts instead of 1
			var heartsToRemove = self.isBoss ? 2 : 1;
			if (self.isPlayerSide) {
				gameState.playerLives -= heartsToRemove;
			} else {
				gameState.aiLives -= heartsToRemove;
			}
			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
****/ 
/**** 
* Game Constants
****/ 
/**** 
* Poker Tower Defense - Complete Refactor
****/ 
// Helper function to calculate distance from point to line segment
function _toConsumableArray(r) {
	return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray2(r) || _nonIterableSpread();
}
function _nonIterableSpread() {
	throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _unsupportedIterableToArray2(r, a) {
	if (r) {
		if ("string" == typeof r) {
			return _arrayLikeToArray2(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) ? _arrayLikeToArray2(r, a) : void 0;
	}
}
function _iterableToArray(r) {
	if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) {
		return Array.from(r);
	}
}
function _arrayWithoutHoles(r) {
	if (Array.isArray(r)) {
		return _arrayLikeToArray2(r);
	}
}
function _arrayLikeToArray2(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;
}
function distancePointToLine(px, py, x1, y1, x2, y2) {
	var A = px - x1;
	var B = py - y1;
	var C = x2 - x1;
	var D = y2 - y1;
	var dot = A * C + B * D;
	var lenSq = C * C + D * D;
	if (lenSq === 0) {
		// Line segment is actually a point
		return Math.sqrt(A * A + B * B);
	}
	var param = dot / lenSq;
	var xx, yy;
	if (param < 0) {
		xx = x1;
		yy = y1;
	} else if (param > 1) {
		xx = x2;
		yy = y2;
	} else {
		xx = x1 + param * C;
		yy = y1 + param * D;
	}
	var dx = px - xx;
	var dy = py - yy;
	return Math.sqrt(dx * dx + dy * dy);
}
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 = 300;
var SLOT_HEIGHT = 420;
var DEAL_SLOT_WIDTH = 240;
var DEAL_SLOT_HEIGHT = 330;
// 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 - 1300; // Much higher up
// Player deal area (hand slots) - below play area
var PLAYER_DEAL_AREA_Y = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + 100;
/**** 
* 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.cardData.suit === 'joker') {
			return 14;
		} // Jokers are highest
		if (card.cardData.value === 'A') {
			return 14;
		} // Aces high
		if (card.cardData.value === 'K') {
			return 13;
		}
		if (card.cardData.value === 'Q') {
			return 12;
		}
		if (card.cardData.value === 'J') {
			return 11;
		}
		return parseInt(card.cardData.value);
	},
	evaluatePokerHand: function evaluatePokerHand(cards) {
		var _this = this;
		if (!cards || cards.length === 0) {
			return {
				type: 'none',
				strength: 0,
				multiplier: 1,
				contributingCards: []
			};
		}
		// 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.cardData.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;
		});
		// Only check for 5-card hands if we have 5 cards
		var isFlush = false;
		var isStraight = false;
		if (cards.length === 5) {
			isFlush = Object.keys(suitCounts).length === 1;
			isStraight = this.checkStraight(values);
		}
		// Royal Flush
		if (isFlush && isStraight && values[0] === 14 && values[4] === 10) {
			return {
				type: 'royal_flush',
				strength: 10,
				multiplier: 25,
				contributingCards: sortedCards
			};
		}
		// Straight Flush
		if (isFlush && isStraight) {
			return {
				type: 'straight_flush',
				strength: 9,
				multiplier: 12,
				contributingCards: sortedCards
			};
		}
		// Four of a Kind
		if (counts[0] >= 4) {
			var quadValue;
			for (var v in valueCounts) {
				if (valueCounts[v] >= 4) {
					quadValue = parseInt(v);
					break;
				}
			}
			return {
				type: 'four_of_a_kind',
				strength: 8,
				multiplier: 8,
				contributingCards: sortedCards.filter(function (c) {
					return _this.getCardValue(c) === quadValue;
				})
			};
		}
		// Full House
		if (counts[0] === 3 && counts[1] === 2) {
			return {
				type: 'full_house',
				strength: 7,
				multiplier: 5,
				contributingCards: sortedCards
			};
		}
		// Flush
		if (isFlush) {
			return {
				type: 'flush',
				strength: 6,
				multiplier: 3.5,
				contributingCards: sortedCards
			};
		}
		// Straight
		if (isStraight) {
			return {
				type: 'straight',
				strength: 5,
				multiplier: 2.5,
				contributingCards: sortedCards
			};
		}
		// Three of a Kind
		if (counts[0] === 3) {
			var tripValue;
			for (var v in valueCounts) {
				if (valueCounts[v] === 3) {
					tripValue = parseInt(v);
					break;
				}
			}
			return {
				type: 'three_of_a_kind',
				strength: 4,
				multiplier: 2,
				contributingCards: sortedCards.filter(function (c) {
					return _this.getCardValue(c) === tripValue;
				})
			};
		}
		// Two Pair
		if (counts[0] === 2 && counts[1] === 2) {
			var pairValues = [];
			for (var v in valueCounts) {
				if (valueCounts[v] === 2) {
					pairValues.push(parseInt(v));
				}
			}
			return {
				type: 'two_pair',
				strength: 3,
				multiplier: 1.5,
				contributingCards: sortedCards.filter(function (c) {
					return pairValues.indexOf(_this.getCardValue(c)) !== -1;
				})
			};
		}
		// One Pair
		if (counts[0] === 2) {
			var pairValue;
			for (var v in valueCounts) {
				if (valueCounts[v] === 2) {
					pairValue = parseInt(v);
					break;
				}
			}
			return {
				type: 'one_pair',
				strength: 2,
				multiplier: 1.2,
				contributingCards: sortedCards.filter(function (c) {
					return _this.getCardValue(c) === pairValue;
				})
			};
		}
		// High Card
		return {
			type: 'high_card',
			strength: 1,
			multiplier: 1,
			contributingCards: [sortedCards[0]]
		};
	},
	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: [],
	minePool: [],
	CHIP_POOL_SIZE: 50,
	BULLET_POOL_SIZE: 100,
	CARD_POOL_SIZE: 60,
	MINE_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);
		}
		for (var i = 0; i < this.MINE_POOL_SIZE; i++) {
			var mine = new Mine();
			mine.active = false;
			mine.visible = false;
			this.minePool.push(mine);
		}
	},
	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;
	},
	getMine: function getMine() {
		for (var i = 0; i < this.minePool.length; i++) {
			if (!this.minePool[i].active) {
				return this.minePool[i];
			}
		}
		return null;
	},
	returnChip: function returnChip(chip) {
		// Force-set inactive state
		chip.active = false;
		chip.visible = false;
		chip.health = 0; // Ensure health is 0
		// Reset tint on all visual components of the chip.
		// This is to ensure that chip graphics don't retain the red damage flash tint
		// when being reused from the pool.
		if (chip.children) {
			for (var i = 0; i < chip.children.length; i++) {
				var child = chip.children[i];
				if (child.tint !== undefined) {
					child.tint = 0xffffff;
				}
			}
		}
		// NEW: Clear burn status completely
		chip.burnDamage = 0;
		chip.burnDuration = 0;
		chip.burnTickTimer = 0;
		// Clear ownership flag
		var wasPlayerSide = chip.isPlayerSide;
		chip.isPlayerSide = null;
		// Remove from active arrays (check both arrays to be safe)
		var playerIndex = activePlayerChips.indexOf(chip);
		if (playerIndex !== -1) {
			activePlayerChips.splice(playerIndex, 1);
		}
		var aiIndex = activeAIChips.indexOf(chip);
		if (aiIndex !== -1) {
			activeAIChips.splice(aiIndex, 1);
		}
		// Remove from containers
		if (chip.parent) {
			chip.parent.removeChild(chip);
		}
		// Double-check removal from both containers
		if (activePlayerChipsContainer.children.indexOf(chip) !== -1) {
			activePlayerChipsContainer.removeChild(chip);
		}
		if (activeAIChipsContainer.children.indexOf(chip) !== -1) {
			activeAIChipsContainer.removeChild(chip);
		}
	},
	returnBullet: function returnBullet(bullet) {
		var explosionColor = 0x333333; // Dark Grey for clubs/spades
		if (bullet.suit === 'hearts' || bullet.suit === 'diamonds') {
			explosionColor = 0xff0000; // Red for hearts/diamonds
		}
		createExplosion(bullet.x, bullet.y, explosionColor);
		bullet.active = false;
		bullet.visible = false;
		bullet.target = null; // Add this line to clear the target reference
		var index = activeBullets.indexOf(bullet);
		if (index !== -1) {
			activeBullets.splice(index, 1);
		}
		gameLayer.removeChild(bullet);
	},
	returnMine: function returnMine(mine) {
		mine.active = false;
		mine.visible = false;
		var index = activeMines.indexOf(mine);
		if (index !== -1) {
			activeMines.splice(index, 1);
		}
		if (mine.parent) {
			mine.parent.removeChild(mine);
		}
	}
};
/**** 
* Path System
****/ 
var PathSystem = {
	playerPath: [],
	aiPath: [],
	init: function init() {
		// Create player path - rectangular loop around the play area
		var padding = 130; // Distance from play area - increased by 50 pixels
		var verticalPadding = padding - 25 - 30; // Reduced by 25 + 30 to decrease side length by 110px total
		var leftX = PLAYER_AREA_X - padding + 10;
		var rightX = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding - 20 - 10;
		var topY = PLAYER_AREA_Y - verticalPadding;
		var bottomY = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + verticalPadding;
		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 - UPSIDE DOWN mirror of player path
		var aiLeftX = AI_AREA_X - padding;
		var aiRightX = AI_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding;
		var aiVerticalPadding = verticalPadding - 40 + 15; // Additional 40px reduction on each side for AI (80px total), extended by 15px
		var aiTopY = AI_AREA_Y - aiVerticalPadding;
		var aiBottomY = AI_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + aiVerticalPadding;
		this.aiPath = [
		// Start at TOP left (opposite of player)
		{
			x: aiLeftX,
			y: aiTopY
		},
		// Go DOWN the left side (opposite of player)
		{
			x: aiLeftX,
			y: aiBottomY
		},
		// Go across the BOTTOM (opposite of player)
		{
			x: aiRightX,
			y: aiBottomY
		},
		// Go UP the right side (opposite of player)
		{
			x: aiRightX,
			y: aiTopY
		}];
	},
	// Alternative offset method that spreads chips along the path direction:
	getPathStart: function getPathStart(isPlayerSide) {
		var baseStart = isPlayerSide ? this.playerPath[0] : this.aiPath[0];
		var pathDirection = isPlayerSide ? this.playerPath[1] : this.aiPath[1];
		// Calculate direction vector from start to next point
		var dx = pathDirection.x - baseStart.x;
		var dy = pathDirection.y - baseStart.y;
		var length = Math.sqrt(dx * dx + dy * dy);
		// Normalize direction vector
		var normalizedX = dx / length;
		var normalizedY = dy / length;
		// Random offset along the path (backward from start point)
		var pathOffset = Math.random() * 80; // 0-80 pixels back along path
		var sideOffset = (Math.random() - 0.5) * 40; // -20 to +20 pixels to the side
		return {
			x: baseStart.x - normalizedX * pathOffset + normalizedY * sideOffset,
			y: baseStart.y - normalizedY * pathOffset - normalizedX * sideOffset
		};
	},
	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;
		}
		var activeChips = isPlayerSide ? activePlayerChips : activeAIChips;
		var minDistance = 85; // Half the chip diameter (170/2) to allow controlled overlap
		var minDistanceSq = minDistance * minDistance;
		var newPos;
		// If no other chips exist, we can place it anywhere.
		if (activeChips.length === 0) {
			newPos = PathSystem.getPathStart(isPlayerSide);
		} else {
			var maxAttempts = 25; // Try to find a free spot with random placement first. It's fast.
			var foundPosition = false;
			for (var attempt = 0; attempt < maxAttempts; attempt++) {
				var candidatePos = PathSystem.getPathStart(isPlayerSide);
				var isValid = true;
				for (var i = 0; i < activeChips.length; i++) {
					var otherChip = activeChips[i];
					var dx = candidatePos.x - otherChip.x;
					var dy = candidatePos.y - otherChip.y;
					var distanceSq = dx * dx + dy * dy;
					if (distanceSq < minDistanceSq) {
						isValid = false;
						break;
					}
				}
				if (isValid) {
					newPos = candidatePos;
					foundPosition = true;
					break;
				}
			}
			// If random placements failed, use a more deterministic spiral search.
			if (!foundPosition) {
				var baseStart = PathSystem.getPathStart(isPlayerSide);
				var searchRadius = minDistance; // Start searching just outside the minimum distance.
				var angleStep = Math.PI / 6; // Check 12 directions.
				var spiralAttempts = 30;
				for (var i = 0; i < spiralAttempts; i++) {
					for (var angle = 0; angle < Math.PI * 2; angle += angleStep) {
						var testX = baseStart.x + Math.cos(angle) * searchRadius;
						var testY = baseStart.y + Math.sin(angle) * searchRadius;
						var isCandidateValid = true;
						for (var j = 0; j < activeChips.length; j++) {
							var otherChip = activeChips[j];
							var dx = testX - otherChip.x;
							var dy = testY - otherChip.y;
							var distanceSq = dx * dx + dy * dy;
							if (distanceSq < minDistanceSq) {
								isCandidateValid = false;
								break;
							}
						}
						if (isCandidateValid) {
							newPos = {
								x: testX,
								y: testY
							};
							foundPosition = true;
							break;
						}
					}
					if (foundPosition) {
						break;
					}
					searchRadius += 20; // Spiral outwards.
				}
			}
			// Ultimate fallback if no position is found (should be very rare).
			if (!foundPosition) {
				newPos = PathSystem.getPathStart(isPlayerSide);
			}
		}
		chip.activate(value, isPlayerSide, newPos);
		// IMPORTANT: Add chip to active array BEFORE the container
		// This ensures that subsequent chips spawned in the same batch
		// will detect this chip when checking for overlaps
		if (isPlayerSide) {
			activePlayerChips.push(chip);
			activePlayerChipsContainer.addChildAt(chip, 0);
		} else {
			activeAIChips.push(chip);
			activeAIChipsContainer.addChildAt(chip, 0);
		}
	},
	spawnChipAtPosition: function spawnChipAtPosition(value, isPlayerSide, position) {
		var chip = PoolManager.getChip();
		if (!chip) {
			return;
		}
		chip.activate(value, isPlayerSide, position);
		// Add chip to active array and container
		if (isPlayerSide) {
			activePlayerChips.push(chip);
			activePlayerChipsContainer.addChildAt(chip, 0);
		} else {
			activeAIChips.push(chip);
			activeAIChipsContainer.addChildAt(chip, 0);
		}
	}
};
/**** 
* Mod System
****/ 
var ModSystem = {
	equippedMods: {
		hearts: null,
		diamonds: null,
		clubs: null,
		spades: null
	},
	modData: {
		burnHeartMod: {
			suit: 'hearts',
			name: 'Flame',
			description: 'Hearts bullets apply burning damage over time. Burn damage is 10% of hit damage per tick for 4 seconds. Burn effects stack.'
		},
		unityHeartsMod: {
			suit: 'hearts',
			name: 'Unity',
			description: 'Increases bullet damage by 25% for each adjacent Hearts card.'
		},
		chipsDiamondMod: {
			suit: 'diamonds',
			name: 'Greed',
			description: 'Earn bonus chips when enemies are defeated, based on diamonds on board. Bonus scales with card level.'
		},
		gamblerDiamondsMod: {
			suit: 'diamonds',
			name: 'Gambler',
			description: 'Diamonds have a chance to deal double damage or none at all. The chance for double damage increases with card level.'
		},
		boostDiamondsMod: {
			suit: 'diamonds',
			name: 'Boost',
			description: 'Diamonds boost the attack power of adjacent cards. The boost increases with the card\'s level.'
		},
		freezeSpadeMod: {
			suit: 'spades',
			name: 'Freeze',
			description: 'Spades have a chance to freeze enemies in place when dealing damage. Duration scales with card level.'
		},
		spreadClubMod: {
			suit: 'clubs',
			name: 'Spreadshot',
			description: 'Clubs deal reduced damage but hit multiple enemies. Extra targets scale with card level.'
		},
		slowClubsMod: {
			suit: 'clubs',
			name: 'Slow',
			description: 'Clubs bullets slow enemies on hit. Slow amount and duration scale with card level.'
		},
		ricochetClubsMod: {
			suit: 'clubs',
			name: 'Ricochet',
			description: 'Clubs bullets ricochet amongst enemies, with limited bounces, dealing less damage with each one.'
		},
		mineSpadesMod: {
			suit: 'spades',
			name: 'Mine',
			description: 'Spades cards place mines on the enemy path that explode on contact, dealing area damage.'
		},
		deathSpadesMod: {
			suit: 'spades',
			name: 'Execute',
			description: 'When equipped spades bullets have a chance to execute low health targets immediately.'
		},
		investmentHeartsMod: {
			suit: 'hearts',
			name: 'Investment',
			description: 'Hearts cards generate income while on board. Income increases the longer the card is on board and resets on level up.'
		}
	},
	currentlyDisplayedMod: null,
	modDisplayContainer: null,
	topSuitGraphics: [],
	ownedMods: {},
	// Store references to top suit graphics
	init: function init() {
		if (storage.equippedMods) {
			this.equippedMods = storage.equippedMods;
		}
		if (storage.ownedMods) {
			this.ownedMods = storage.ownedMods;
		}
	},
	saveToStorage: function saveToStorage() {
		storage.equippedMods = this.equippedMods;
		storage.ownedMods = this.ownedMods;
	},
	isModOwned: function isModOwned(modAssetId) {
		return !!this.ownedMods[modAssetId];
	},
	unlockMod: function unlockMod(modAssetId) {
		this.ownedMods[modAssetId] = true;
		this.saveToStorage();
	},
	getUnownedMods: function getUnownedMods() {
		var unowned = [];
		for (var modId in this.modData) {
			if (!this.isModOwned(modId)) {
				unowned.push(modId);
			}
		}
		return unowned;
	},
	equipMod: function equipMod(modAssetId) {
		var modData = this.modData[modAssetId];
		if (!modData) {
			return;
		}
		this.equippedMods[modData.suit] = modAssetId;
		this.saveToStorage();
		this.updateTopSuitDisplay();
		this.hideModDisplay();
	},
	updateTopSuitDisplay: function updateTopSuitDisplay() {
		var suitAssets = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit'];
		var suits = ['hearts', 'diamonds', 'clubs', 'spades'];
		for (var i = 0; i < this.topSuitGraphics.length; i++) {
			var container = this.topSuitGraphics[i];
			if (container) {
				// Make it an Ace card if it's not already
				var hasAceText = false;
				for (var k = 0; k < container.children.length; k++) {
					if (container.children[k].isAceText) {
						hasAceText = true;
						break;
					}
				}
				if (!hasAceText) {
					var suitForAce = suits[i];
					var suitColor = CardSystem.suitColors[suitForAce] || 0x000000;
					var valueText = new Text2('A', {
						size: 56 * 1.5,
						fill: suitColor,
						weight: 800,
						stroke: 0x000000,
						strokeThickness: 0
					});
					valueText.isAceText = true;
					valueText.anchor.set(0, 0);
					// The card background is scaled 1.5x, these coords are scaled to match.
					valueText.x = -95 * 1.5;
					valueText.y = -135 * 1.5;
					container.addChild(valueText);
				}
				// Remove the previous mod/suit icon if it exists
				for (var j = container.children.length - 1; j >= 0; j--) {
					if (container.children[j].isSuitIcon) {
						container.removeChildAt(j);
						break;
					}
				}
				// Add the appropriate icon (either mod or default suit)
				var suit = suits[i];
				var equippedMod = this.equippedMods[suit];
				var assetId = equippedMod || suitAssets[i];
				var suitIcon = LK.getAsset(assetId, {
					anchorX: 0.5,
					anchorY: 0.5
				});
				suitIcon.isSuitIcon = true;
				suitIcon.scale.set(1.2);
				// Center it in the background card
				suitIcon.x = 0;
				suitIcon.y = 0;
				container.addChild(suitIcon);
			}
		}
	},
	showModDisplay: function showModDisplay(modAssetId, sourceX, sourceY) {
		if (this.currentlyDisplayedMod) {
			return;
		}
		var modData = this.modData[modAssetId];
		if (!modData) {
			return;
		}
		this.currentlyDisplayedMod = modAssetId;
		this.modDisplayContainer = new Container();
		this.modDisplayContainer.interactive = true;
		uiLayer.addChild(this.modDisplayContainer);
		// Add a semi-transparent background to catch clicks outside the popup
		var bgBlocker = new Container();
		bgBlocker.interactive = true;
		bgBlocker.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
		this.modDisplayContainer.addChild(bgBlocker);
		var enlargedMod = LK.getAsset(modAssetId, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		enlargedMod.x = SCREEN_WIDTH / 2;
		enlargedMod.y = SCREEN_HEIGHT / 2 - 450;
		enlargedMod.scale.set(1);
		this.modDisplayContainer.addChild(enlargedMod);
		var overlayWidth = 600;
		var overlayHeight = 400;
		var descriptionOverlay = new Container();
		var overlayBg = LK.getAsset('card', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		overlayBg.scale.set(overlayWidth / 150, overlayHeight / 240);
		overlayBg.tint = 0x000000;
		overlayBg.alpha = 0.8;
		descriptionOverlay.addChild(overlayBg);
		var descText = new Text2(modData.description, {
			size: 50,
			fill: 0xffffff,
			weight: 600,
			stroke: 0x000000,
			strokeThickness: 2,
			align: 'center',
			wordWrap: true,
			wordWrapWidth: overlayWidth - 40
		});
		descText.anchor.set(0.5, 0);
		descText.y = -overlayHeight / 2 + 40;
		descriptionOverlay.addChild(descText);
		var equipButton = LK.getAsset('card', {
			anchorX: 0.5,
			anchorY: 0.5,
			interactive: true
		});
		equipButton.scale.set(1.5, 0.5);
		equipButton.tint = 0x000000;
		equipButton.alpha = 0.8;
		equipButton.y = overlayHeight / 2 + 150;
		descriptionOverlay.addChild(equipButton);
		var equipText = new Text2('Equip', {
			size: 50,
			fill: 0xffffff,
			weight: 800,
			stroke: 0x000000,
			strokeThickness: 3
		});
		equipText.anchor.set(0.5, 0.5);
		equipText.y = equipButton.y;
		descriptionOverlay.addChild(equipText);
		descriptionOverlay.x = SCREEN_WIDTH / 2;
		descriptionOverlay.y = SCREEN_HEIGHT / 2 + 250;
		descriptionOverlay.alpha = 0;
		this.modDisplayContainer.addChild(descriptionOverlay);
		var self = this;
		var isOwned = this.isModOwned(modAssetId);
		if (isOwned) {
			equipText.setText('Equip');
			equipButton.down = function () {
				self.equipMod(modAssetId);
			};
		} else {
			equipText.setText('Not Owned');
			equipButton.interactive = false;
			equipButton.tint = 0x333333;
			enlargedMod.tint = 0x808080;
		}
		tween(enlargedMod, {
			scaleX: 4,
			scaleY: 4
		}, {
			duration: 300,
			easing: tween.backOut
		});
		tween(descriptionOverlay, {
			alpha: 1
		}, {
			duration: 200,
			delay: 150
		});
		bgBlocker.down = function () {
			self.hideModDisplay();
		};
	},
	hideModDisplay: function hideModDisplay() {
		if (!this.modDisplayContainer) {
			return;
		}
		var self = this;
		tween(this.modDisplayContainer, {
			alpha: 0
		}, {
			duration: 200,
			onFinish: function onFinish() {
				if (self.modDisplayContainer && self.modDisplayContainer.parent) {
					self.modDisplayContainer.parent.removeChild(self.modDisplayContainer);
				}
				self.modDisplayContainer = null;
				self.currentlyDisplayedMod = null;
			}
		});
	},
	getEquippedModAsset: function getEquippedModAsset(suit) {
		return this.equippedMods[suit] || null;
	}
};
/**** 
* Wave Spawning System
****/ 
var WaveSystem = {
	playerSpawnTimer: 0,
	aiSpawnTimer: 0,
	waveNumber: 1,
	waveTimer: 0,
	waveDuration: 1800,
	// 30 seconds per wave (30 * 60 ticks)
	spawnInterval: 45,
	// Much faster: spawn every 0.75 seconds instead of 2 seconds
	bossSpawned: false,
	// Track if boss has been spawned this wave
	getChipValue: function getChipValue(waveNumber) {
		// Wave 1: Only 1-chips (easier)
		if (waveNumber === 1) {
			return 1;
		}
		// Wave 2-3: More 5s introduced earlier for increased difficulty
		else if (waveNumber <= 3) {
			return Math.random() < 0.2 ? 5 : 1; // 20% chance of 5-chip (increased from 10%)
		}
		// Wave 4-6: Even more 5s mixed in
		else if (waveNumber <= 6) {
			return Math.random() < 0.35 ? 5 : 1; // 35% chance of 5-chip (increased from 25%)
		}
		// Wave 7-9: More 5s than 1s for increased difficulty
		else if (waveNumber <= 9) {
			return Math.random() < 0.65 ? 5 : 1; // 65% chance of 5-chip (increased from 50%)
		}
		// Wave 11-15: Introduce 10-chips earlier and more frequently
		else if (waveNumber <= 15) {
			var rand = Math.random();
			if (rand < 0.15) {
				return 10;
			} else if (rand < 0.7) {
				return 5;
			} else {
				return 1;
			}
		}
		// Wave 16-19: More variety with higher values
		else if (waveNumber <= 19) {
			var rand = Math.random();
			if (rand < 0.3) {
				return 10;
			} else if (rand < 0.8) {
				return 5;
			} else {
				return 1;
			}
		}
		// Wave 21+: Keep scaling gradually with higher difficulty
		else if (!this.isBossWave(waveNumber)) {
			var rand = Math.random();
			if (rand < 0.08) {
				return 25;
			} else if (rand < 0.4) {
				return 10;
			} else if (rand < 0.85) {
				return 5;
			} else {
				return 1;
			}
		}
	},
	getBossChipValue: function getBossChipValue(waveNumber) {
		// The health of the first boss is based on the total health of the preceding wave.
		// Subsequent bosses have their health increased proportionally (doubling each time).
		var bossLevel = Math.floor(waveNumber / 10);
		// Base value derived from total health of wave 9 enemies (~10.5k health -> 210 value)
		var baseBossValue = 210;
		return baseBossValue * Math.pow(2, bossLevel - 1);
	},
	isBossWave: function isBossWave(waveNumber) {
		return waveNumber % 10 === 0;
	},
	spawnChip: function spawnChip(isPlayerSide) {
		if (this.isBossWave(this.waveNumber)) {
			// Boss wave: spawn ONE big enemy at the start, then nothing
			if (!this.bossSpawned) {
				var bossValue = this.getBossChipValue(this.waveNumber);
				ChipSpawner.spawnChip(bossValue, isPlayerSide);
				this.bossSpawned = true;
				console.log("BOSS spawned with value:", bossValue);
			}
			// Don't spawn anything else during boss wave
			return;
		}
		// Normal wave spawning - always single enemy
		var chipValue = this.getChipValue(this.waveNumber);
		ChipSpawner.spawnChip(chipValue, isPlayerSide);
	},
	playerBossDefeated: false,
	aiBossDefeated: false,
	update: function update() {
		this.waveTimer++;
		// Check if wave is complete
		if (this.waveTimer >= this.waveDuration) {
			// If it's a boss wave, only advance if both bosses are defeated.
			if (this.isBossWave(this.waveNumber) && (!this.playerBossDefeated || !this.aiBossDefeated)) {
				// Don't end the wave, just let it continue until bosses are defeated.
			} else {
				// For normal waves, or for boss waves where both bosses are defeated.
				// Check if both bosses were defeated in a boss wave
				if (this.isBossWave(this.waveNumber) && this.playerBossDefeated && this.aiBossDefeated) {
					console.log("Both bosses defeated! Moving to next round!");
					createFloatingText('ROUND COMPLETE!', SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0x00ff00);
					// Reset boss defeat flags
					this.playerBossDefeated = false;
					this.aiBossDefeated = false;
				}
				this.waveTimer = 0;
				this.waveNumber++;
				this.playerSpawnTimer = 0;
				this.aiSpawnTimer = 0;
				this.bossSpawned = false; // Reset boss spawn flag
				var waveType = this.isBossWave(this.waveNumber) ? "BOSS WAVE" : "Wave";
				console.log(waveType + " " + this.waveNumber + " starting!");
				return;
			}
		}
		// BOSS WAVE LOGIC - Spawn bosses immediately at start of wave
		if (this.isBossWave(this.waveNumber)) {
			if (!this.bossSpawned && this.waveTimer === 1) {
				// Only on first tick of boss wave
				console.log("=== BOSS WAVE " + this.waveNumber + " STARTING ===");
				// Spawn player boss
				var playerBossValue = this.getBossChipValue(this.waveNumber);
				ChipSpawner.spawnChip(playerBossValue, true);
				console.log("PLAYER BOSS spawned with value:", playerBossValue, "Active player chips:", activePlayerChips.length);
				// Spawn AI boss
				var aiBossValue = this.getBossChipValue(this.waveNumber);
				ChipSpawner.spawnChip(aiBossValue, false);
				console.log("AI BOSS spawned with value:", aiBossValue, "Active AI chips:", activeAIChips.length);
				this.bossSpawned = true;
			}
			// Boss defeat detection - only after bosses have had time to spawn
			if (this.bossSpawned && this.waveTimer > 120) {
				// 2 second delay
				console.log("Checking boss status - Player chips:", activePlayerChips.length, "AI chips:", activeAIChips.length);
				// Check if player side boss is defeated
				if (!this.playerBossDefeated && activePlayerChips.length === 0) {
					this.playerBossDefeated = true;
					console.log("Player defeated the boss!");
					createFloatingText('BOSS DEFEATED!', SCREEN_WIDTH / 2, PLAYER_AREA_Y + SLOT_HEIGHT, 0xffd700);
				}
				// Check if AI side boss is defeated
				if (!this.aiBossDefeated && activeAIChips.length === 0) {
					this.aiBossDefeated = true;
					console.log("AI defeated the boss!");
					createFloatingText('AI BOSS DEFEATED!', SCREEN_WIDTH / 2, AI_AREA_Y + SLOT_HEIGHT, 0xffd700);
				}
				// If both bosses defeated, immediately end the wave
				if (this.playerBossDefeated && this.aiBossDefeated) {
					this.waveTimer = this.waveDuration - 1; // Set to end on next tick
				}
			}
			return; // Don't do normal spawning during boss waves
		}
		// NORMAL WAVE LOGIC
		var currentSpawnInterval = this.spawnInterval;
		if (this.waveNumber === 1) {
			currentSpawnInterval = 90; // Slower spawning for wave 1 (1.5 seconds)
		} else if (this.waveNumber >= 2) {
			currentSpawnInterval = Math.max(45, this.spawnInterval - Math.floor((this.waveNumber - 2) * 2)); // Faster spawning for wave 2+
		}
		// Spawn on player side
		this.playerSpawnTimer++;
		if (this.playerSpawnTimer >= currentSpawnInterval) {
			this.playerSpawnTimer = 0;
			this.spawnChip(true);
		}
		// Spawn on AI side
		this.aiSpawnTimer++;
		if (this.aiSpawnTimer >= currentSpawnInterval) {
			this.aiSpawnTimer = 0;
			this.spawnChip(false);
		}
	}
};
/**** 
* Game State
****/ 
var gameState = {
	playerChips: 200,
	// Increased starting gold
	aiChips: 200,
	playerLives: 3,
	aiLives: 3,
	isPlayerTurn: true,
	dealCost: 25,
	// Initial deal cost
	dealCount: 0,
	playerDeck: [],
	playerHand: [],
	playerPlayArea: [],
	aiDeck: [],
	aiPlayArea: []
};
// Game state management
var currentGameState = 'start'; // 'start' or 'playing'
var startScreenElements = [];
var gameElements = [];
/**** 
* Game Variables
****/ 
var activePlayerChips = [];
var activeAIChips = [];
var activeBullets = [];
var activeMines = [];
var playerHandNameTexts = [];
var backgroundSuits = [];
var slotIndicators = [];
var selectedCard = null;
var isDragging = false;
var originalCardPosition = null;
var gameReady = false;
var activePlayerChipsContainer = new Container(); // Container for player chips
var activeAIChipsContainer = new Container(); // Container for AI chips
var playerLifeHearts = [];
var aiLifeHearts = [];
var opponentNameText = null;
var playerNameText = null;
var lastPlayerLives = 0;
var lastAiLives = 0;
var gameLayer = new Container();
var floorBackground = LK.getAsset('floorbackround', {
	anchorX: 0.5,
	anchorY: 0.5
});
floorBackground.x = SCREEN_WIDTH / 2;
floorBackground.y = SCREEN_HEIGHT / 2;
gameLayer.addChild(floorBackground);
var uiLayer = new Container();
game.addChild(gameLayer);
game.addChild(uiLayer);
/**** 
* UI Elements
****/ 
var playerChipsText = new Text2('Chips: 200', {
	size: 50,
	fill: 0xffd700,
	weight: 800,
	stroke: 0x000000,
	strokeThickness: 0
});
playerChipsText.x = 50;
playerChipsText.y = SCREEN_HEIGHT - 120;
playerChipsText.visible = false;
uiLayer.addChild(playerChipsText);
gameElements.push(playerChipsText);
// Add AI stats too for clarity
var waveText = new Text2('Wave: 1', {
	size: 40,
	fill: 0xffffff,
	weight: 800,
	stroke: 0x000000,
	strokeThickness: 0
});
waveText.x = SCREEN_WIDTH - 200;
waveText.y = 50;
waveText.visible = false;
uiLayer.addChild(waveText);
gameElements.push(waveText);
var discardAreaContainer = new Container();
var dealButtonGraphic = discardAreaContainer.attachAsset('dealButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
var refundButtonGraphic = discardAreaContainer.attachAsset('refundButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
refundButtonGraphic.visible = false;
var discardAreaGraphic = dealButtonGraphic;
var discardText = new Text2('-25', {
	size: 50,
	fill: 0xffffff,
	weight: 800,
	stroke: 0x000000,
	strokeThickness: 0
});
discardText.anchor.set(0.5, 0.5);
discardText.y = 110;
discardAreaContainer.addChild(discardText);
// Position it right of the hand
var handWidthForDiscard = 5 * DEAL_SLOT_WIDTH + 4 * 30;
var handStartXForDiscard = (SCREEN_WIDTH - handWidthForDiscard) / 2;
var discardX = handStartXForDiscard + handWidthForDiscard + 30 + DEAL_SLOT_WIDTH / 2;
// Make sure it doesn't go off screen
if (discardX + DEAL_SLOT_WIDTH / 2 > SCREEN_WIDTH) {
	discardX = SCREEN_WIDTH - DEAL_SLOT_WIDTH / 2 - 20;
}
discardAreaContainer.x = discardX + 10 + 10;
discardAreaContainer.y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2 + 10 - 10;
discardAreaContainer.visible = false;
uiLayer.addChild(discardAreaContainer);
gameElements.push(discardAreaContainer);
discardAreaContainer.down = function () {
	if (!isDragging && gameState.playerChips >= gameState.dealCost) {
		dealNewHand();
	}
};
/**** 
* Game Functions
****/ 
function createBurnEffect(x, y) {
	var numParticles = 4; // Slightly more particles
	for (var i = 0; i < numParticles; i++) {
		var particle = LK.getAsset('burnHeartMod', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		particle.x = x + (Math.random() - 0.5) * 80; // Wider spread
		particle.y = y + (Math.random() - 0.5) * 80;
		particle.scale.set(0.3 + Math.random() * 0.2); // Adjusted for new asset
		var angle = Math.random() * Math.PI * 2;
		var distance = Math.random() * 40 + 25; // Larger movement distance
		var duration = 400 + Math.random() * 500; // Slightly longer duration
		var targetX = x + Math.cos(angle) * distance;
		var targetY = y + Math.sin(angle) * distance - Math.random() * 50; // Float upward more
		gameLayer.addChild(particle);
		tween(particle, {
			x: targetX,
			y: targetY,
			alpha: 0,
			scaleX: 0.1,
			scaleY: 0.1
		}, {
			duration: duration,
			easing: tween.quadOut,
			onFinish: function (p) {
				return function () {
					if (p.parent) {
						p.parent.removeChild(p);
					}
				};
			}(particle)
		});
	}
}
function createIceSparkles(x, y) {
	var numSparkles = 2;
	for (var i = 0; i < numSparkles; i++) {
		var sparkle = LK.getAsset('iceCube', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		sparkle.x = x + (Math.random() - 0.5) * 60;
		sparkle.y = y + (Math.random() - 0.5) * 60;
		sparkle.scale.set(0.1 + Math.random() * 0.1);
		sparkle.alpha = 0.6;
		sparkle.tint = 0x88ddff; // Light blue tint
		gameLayer.addChild(sparkle);
		tween(sparkle, {
			y: sparkle.y - 20,
			alpha: 0,
			scaleX: 0.05,
			scaleY: 0.05
		}, {
			duration: 800,
			easing: tween.quadOut,
			onFinish: function (p) {
				return function () {
					if (p.parent) {
						p.parent.removeChild(p);
					}
				};
			}(sparkle)
		});
	}
}
function createIceShatterEffect(x, y) {
	var numShards = 6;
	for (var i = 0; i < numShards; i++) {
		var shard = LK.getAsset('iceCube', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		shard.x = x;
		shard.y = y;
		shard.scale.set(0.2 + Math.random() * 0.2);
		shard.tint = 0xaaeeff; // Ice blue tint
		var angle = Math.PI * 2 * i / numShards + (Math.random() - 0.5) * 0.5;
		var distance = 40 + Math.random() * 30;
		var targetX = x + Math.cos(angle) * distance;
		var targetY = y + Math.sin(angle) * distance;
		gameLayer.addChild(shard);
		tween(shard, {
			x: targetX,
			y: targetY,
			alpha: 0,
			rotation: Math.random() * Math.PI * 2,
			scaleX: 0.05,
			scaleY: 0.05
		}, {
			duration: 600,
			easing: tween.quadOut,
			onFinish: function (p) {
				return function () {
					if (p.parent) {
						p.parent.removeChild(p);
					}
				};
			}(shard)
		});
	}
}
function createModFloatAnimation(target, shadow) {
	var initialY = target.y;
	var floatDistance = 10;
	var baseDuration = 3000;
	var randomDurationOffset = 1500;
	var initialScale = shadow.scale.x;
	var minScale = initialScale * 0.7;
	var maxScale = initialScale * 1.0;
	function floatUp() {
		if (!target.parent || !target.parent.parent || !target.parent.parent.parent) {
			return;
		}
		var duration = baseDuration / 2 + Math.random() * randomDurationOffset;
		tween(target, {
			y: initialY - floatDistance
		}, {
			duration: duration,
			easing: tween.easeInOut,
			onFinish: floatDown
		});
		tween(shadow, {
			scaleX: minScale,
			scaleY: minScale
		}, {
			duration: duration,
			easing: tween.easeInOut
		});
	}
	function floatDown() {
		if (!target.parent || !target.parent.parent || !target.parent.parent.parent) {
			return;
		}
		var duration = baseDuration / 2 + Math.random() * randomDurationOffset;
		tween(target, {
			y: initialY + floatDistance
		}, {
			duration: duration,
			easing: tween.easeInOut,
			onFinish: floatUp
		});
		tween(shadow, {
			scaleX: maxScale,
			scaleY: maxScale
		}, {
			duration: duration,
			easing: tween.easeInOut
		});
	}
	LK.setTimeout(floatDown, Math.random() * baseDuration);
}
// Add this new function to calculate greed bonus
function calculateGreedBonus(isPlayerSide, baseChipsEarned) {
	// Only calculate bonus if greed mod is equipped
	if (ModSystem.getEquippedModAsset('diamonds') !== 'chipsDiamondMod') {
		return 0;
	}
	var playArea = isPlayerSide ? gameState.playerPlayArea : gameState.aiPlayArea;
	var totalBonusPercentage = 0;
	// Calculate bonus from each diamond card on the board
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var card = playArea[row][col];
			if (card && card.cardData.suit === 'diamonds') {
				// The "base gain" for this card is 5%
				var baseGain = 0.05;
				// Each level adds an additional 10% gain
				var levelGain = card.level * 0.1;
				totalBonusPercentage += baseGain + levelGain;
			}
		}
	}
	// Do not return fractional gains - round up
	return Math.ceil(baseChipsEarned * totalBonusPercentage);
}
function createStartScreen(fromMatch) {
	LK.playMusic('titleSong');
	ModSystem.init();
	// Clear any existing start screen elements
	startScreenElements.forEach(function (element) {
		if (element.parent) {
			element.parent.removeChild(element);
		}
	});
	startScreenElements = [];
	var battleScreenContainer;
	// Add background animation
	var startScreenAnimContainer = new Container();
	uiLayer.addChild(startScreenAnimContainer);
	startScreenElements.push(startScreenAnimContainer);
	var suitAssets = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit'];
	var spacing = 400;
	var numCols = Math.ceil(SCREEN_WIDTH / spacing) + 3;
	var numRows = Math.ceil(SCREEN_HEIGHT / spacing) + 3;
	var patternWidth = numCols * spacing;
	var patternHeight = numRows * spacing;
	backgroundSuits = [];
	for (var row = 0; row < numRows; row++) {
		for (var col = 0; col < numCols; col++) {
			var suitIndex = (row + col) % suitAssets.length;
			var suitId = suitAssets[suitIndex];
			var suit = LK.getAsset(suitId, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			suit.x = col * spacing - spacing;
			suit.y = row * spacing - spacing;
			suit.alpha = 0.8;
			suit.scale.set(1.5);
			suit.baseX = col * spacing;
			suit.baseY = row * spacing;
			startScreenAnimContainer.addChild(suit);
			backgroundSuits.push(suit);
		}
	}
	var gameLogo = LK.getAsset('titleLogo', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	gameLogo.x = SCREEN_WIDTH / 2;
	gameLogo.y = SCREEN_HEIGHT / 2 - 200;
	uiLayer.addChild(gameLogo);
	startScreenElements.push(gameLogo);
	var bottomBarContainer = new Container();
	uiLayer.addChild(bottomBarContainer);
	startScreenElements.push(bottomBarContainer);
	function showBattleSelection() {
		gameLogo.visible = false;
		bottomBarContainer.visible = true;
		battleScreenContainer = new Container();
		uiLayer.addChild(battleScreenContainer);
		startScreenElements.push(battleScreenContainer);
		var pvpIcon = LK.getAsset('pvpIcon', {
			anchorX: 0.5,
			anchorY: 0.5,
			interactive: true
		});
		pvpIcon.scale.set(3);
		pvpIcon.x = SCREEN_WIDTH * 0.25;
		pvpIcon.y = SCREEN_HEIGHT * 0.45;
		battleScreenContainer.addChild(pvpIcon);
		var pvpButton = LK.getAsset('pvpButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			interactive: true
		});
		pvpButton.scale.set(3);
		pvpButton.x = pvpIcon.x;
		pvpButton.y = pvpIcon.y + pvpIcon.height / 2 + pvpButton.height / 2 + 150;
		battleScreenContainer.addChild(pvpButton);
		var coopIcon = LK.getAsset('coopIcon', {
			anchorX: 0.5,
			anchorY: 0.5,
			interactive: false
		});
		coopIcon.scale.set(3);
		coopIcon.x = SCREEN_WIDTH * 0.75;
		coopIcon.y = pvpIcon.y;
		coopIcon.tint = 0x808080;
		coopIcon.alpha = 0.8;
		battleScreenContainer.addChild(coopIcon);
		var coopButton = LK.getAsset('coopButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			interactive: false
		});
		coopButton.scale.set(3);
		coopButton.x = coopIcon.x;
		coopButton.y = coopIcon.y + coopIcon.height / 2 + coopButton.height / 2 + 150;
		coopButton.tint = 0x808080;
		coopButton.alpha = 0.8;
		battleScreenContainer.addChild(coopButton);
		var comingSoonText = new Text2('Coming soon!', {
			size: 60,
			fill: 0xffffff,
			weight: 'bold',
			stroke: 0x000000,
			strokeThickness: 4
		});
		comingSoonText.anchor.set(0.5, 0.5);
		comingSoonText.x = coopIcon.x;
		comingSoonText.y = coopIcon.y + coopIcon.height / 2 + 250;
		battleScreenContainer.addChild(comingSoonText);
		function onPlay(isTutorial) {
			startGame(isTutorial);
		}
		if (!storage.tutorialCompleted && fromMatch !== true) {
			TutorialSystem.start();
			var items = TutorialSystem.startScreenItems;
			items.mods.button.interactive = false;
			items.mods.icon.interactive = false;
			items.shop.button.interactive = false;
			items.shop.icon.interactive = false;
			items.mods.button.alpha = 0.5;
			items.mods.icon.alpha = 0.5;
			items.shop.button.alpha = 0.5;
			items.shop.icon.alpha = 0.5;
			var overlay = new Container();
			overlay.interactive = true;
			overlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
			var bg = LK.getAsset('card', {
				width: SCREEN_WIDTH,
				height: SCREEN_HEIGHT,
				anchorX: 0,
				anchorY: 0
			});
			bg.tint = 0x000000;
			bg.alpha = 0.7;
			overlay.addChild(bg);
			battleScreenContainer.addChild(overlay);
			battleScreenContainer.removeChild(pvpIcon);
			battleScreenContainer.removeChild(pvpButton);
			overlay.addChild(pvpIcon);
			overlay.addChild(pvpButton);
			coopIcon.interactive = false;
			coopIcon.alpha = 0.3;
			coopButton.interactive = false;
			coopButton.alpha = 0.3;
			TutorialSystem.pulseAnimation(pvpIcon);
			TutorialSystem.pulseAnimation(pvpButton);
			var welcomeText = new Text2("Welcome to Double Down Defense! Let’s jump right into a game, tap on PvP to start!", {
				size: 70,
				fill: 0xffffff,
				weight: 'bold',
				stroke: 0x000000,
				strokeThickness: 5,
				align: 'center',
				wordWrap: true,
				wordWrapWidth: SCREEN_WIDTH - 200
			});
			welcomeText.anchor.set(0.5, 0.5);
			welcomeText.x = SCREEN_WIDTH / 2;
			welcomeText.y = SCREEN_HEIGHT * 0.25;
			overlay.addChild(welcomeText);
			pvpIcon.down = function () {
				onPlay(true);
			};
			pvpButton.down = function () {
				onPlay(true);
			};
		} else {
			pvpIcon.down = function () {
				onPlay(false);
			};
			pvpButton.down = function () {
				onPlay(false);
			};
		}
		var clearStorageButton = new Text2('DEBUG: Clear Storage', {
			size: 40,
			fill: 0xff0000,
			interactive: true
		});
		clearStorageButton.anchor.set(0, 1);
		clearStorageButton.x = 20;
		clearStorageButton.y = SCREEN_HEIGHT - 450;
		battleScreenContainer.addChild(clearStorageButton);
		clearStorageButton.down = function () {
			clearPlayerStorage();
			LK.setTimeout(function () {
				createStartScreen(true);
			}, 100);
		};
	}
	if (fromMatch) {
		showBattleSelection();
	} else {
		// Animate logo scaling in
		gameLogo.scale.set(0.01);
		bottomBarContainer.visible = false;
		tween(gameLogo, {
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 1200,
			easing: tween.elasticOut,
			onFinish: function onFinish() {
				var tapToStartText = new Text2('Tap anywhere to start', {
					size: 90,
					fill: 0xffffff,
					weight: 'bold',
					stroke: 0x000000,
					strokeThickness: 6
				});
				tapToStartText.anchor.set(0.5, 0.5);
				tapToStartText.x = SCREEN_WIDTH / 2;
				tapToStartText.y = gameLogo.y + gameLogo.height / 2 + 250;
				uiLayer.addChild(tapToStartText);
				startScreenElements.push(tapToStartText);
				function flashAnimation() {
					if (!tapToStartText.parent) {
						return;
					}
					tween(tapToStartText, {
						alpha: 0.2
					}, {
						duration: 1200,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (!tapToStartText.parent) {
								return;
							}
							tween(tapToStartText, {
								alpha: 1.0
							}, {
								duration: 1200,
								easing: tween.easeInOut,
								onFinish: flashAnimation
							});
						}
					});
				}
				flashAnimation();
				var screenTapArea = new Container();
				screenTapArea.interactive = true;
				screenTapArea.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
				uiLayer.addChild(screenTapArea);
				startScreenElements.push(screenTapArea);
				screenTapArea.down = function () {
					tween.stop(tapToStartText);
					uiLayer.removeChild(tapToStartText);
					uiLayer.removeChild(screenTapArea);
					showBattleSelection();
				};
			}
		});
	}
	var startBottomBar = LK.getAsset('bottomBar', {
		anchorX: 0.5,
		anchorY: 1
	});
	startBottomBar.x = SCREEN_WIDTH / 2;
	startBottomBar.y = SCREEN_HEIGHT;
	bottomBarContainer.addChild(startBottomBar);
	var topBar = LK.getAsset('bottomBar', {
		anchorX: 0.5,
		anchorY: 0
	});
	topBar.x = SCREEN_WIDTH / 2;
	topBar.y = 65;
	topBar.scale.y = 0.4;
	bottomBarContainer.addChild(topBar);
	var battleRatingText = new Text2('Battle rating: ' + storage.battleRating, {
		size: 70,
		fill: 0xffffff,
		weight: 800,
		stroke: 0x000000,
		strokeThickness: 4
	});
	battleRatingText.anchor.set(0.5, 0.5);
	battleRatingText.x = SCREEN_WIDTH / 2;
	battleRatingText.y = topBar.y + topBar.height * topBar.scale.y / 2;
	bottomBarContainer.addChild(battleRatingText);
	var moneyText = new Text2('$' + storage.money, {
		size: 70,
		fill: 0xffd700,
		weight: 800,
		stroke: 0x000000,
		strokeThickness: 4
	});
	moneyText.anchor.set(1, 0.5);
	moneyText.x = SCREEN_WIDTH - 150;
	moneyText.y = topBar.y + topBar.height * topBar.scale.y / 2;
	bottomBarContainer.addChild(moneyText);
	// --- Title screen selection highlight asset ---
	var titleScreenSelection = LK.getAsset('titleScreenSelection', {
		anchorX: 0.5,
		anchorY: 1
	});
	titleScreenSelection.alpha = 0.3;
	bottomBarContainer.addChild(titleScreenSelection);
	// --- Track current selection: "battle", "mods", or "shop" ---
	var currentTitleScreenSelection = "battle";
	// --- Calculate button positions for highlight ---
	var playButton = LK.getAsset('playButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		interactive: true
	});
	playButton.x = SCREEN_WIDTH / 2;
	playButton.y = SCREEN_HEIGHT - 100;
	// Add battleIcon directly above playButton
	var battleIcon = LK.getAsset('battleIcon', {
		anchorX: 0.5,
		anchorY: 1,
		interactive: true
	});
	battleIcon.x = playButton.x;
	battleIcon.y = playButton.y - playButton.height / 2 - 10; // 30px gap above playButton
	bottomBarContainer.addChild(battleIcon);
	bottomBarContainer.addChild(playButton);
	// --- Suit mod button and mods icon ---
	var suitModButton = LK.getAsset('suitModButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		interactive: true
	});
	suitModButton.x = playButton.x + playButton.width / 2 + 100 + suitModButton.width / 2;
	suitModButton.y = playButton.y;
	// Add modsIcon directly above suitModButton, same orientation as battleIcon
	var modsIcon = LK.getAsset('modsIcon', {
		anchorX: 0.5,
		anchorY: 1,
		interactive: true
	});
	modsIcon.x = suitModButton.x;
	modsIcon.y = suitModButton.y - suitModButton.height / 2 - 10; // 10px gap above suitModButton
	bottomBarContainer.addChild(modsIcon);
	bottomBarContainer.addChild(suitModButton);
	// --- Shop button and icon ---
	var shopButton = LK.getAsset('shopButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		interactive: true
	});
	shopButton.x = playButton.x - playButton.width / 2 - 100 - shopButton.width / 2;
	shopButton.y = playButton.y + 10;
	var shopIcon = LK.getAsset('shopIcon', {
		anchorX: 0.5,
		anchorY: 1,
		interactive: true
	});
	shopIcon.x = shopButton.x;
	shopIcon.y = shopButton.y - shopButton.height / 2 - 10;
	bottomBarContainer.addChild(shopIcon);
	bottomBarContainer.addChild(shopButton);
	// --- Mods container as before ---
	var modsContainer = new Container();
	modsContainer.visible = false;
	uiLayer.addChild(modsContainer);
	startScreenElements.push(modsContainer);
	// --- Shop Container ---
	var shopContainer = new Container();
	shopContainer.visible = false;
	uiLayer.addChild(shopContainer);
	startScreenElements.push(shopContainer);
	var shopTitle = new Text2('Shop', {
		size: 150,
		fill: 0xffffff,
		weight: 'bold'
	});
	shopTitle.anchor.set(0.5, 0.5);
	shopTitle.x = SCREEN_WIDTH / 2;
	shopTitle.y = 400;
	shopContainer.addChild(shopTitle);
	// Add black overlay behind the random mod shop item
	var shopOverlay = LK.getAsset('card', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var overlayWidth = 800;
	var overlayHeight = 1200; // 2:3 ratio
	shopOverlay.scale.set(overlayWidth / shopOverlay.width, overlayHeight / shopOverlay.height);
	shopOverlay.x = SCREEN_WIDTH / 2;
	shopOverlay.y = 1476 - 200;
	shopOverlay.tint = 0x000000;
	shopOverlay.alpha = 0.8;
	shopContainer.addChild(shopOverlay);
	// Add shopRandomMod asset in center
	var shopRandomModAsset = LK.getAsset('shopRandomMod', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	shopRandomModAsset.x = SCREEN_WIDTH / 2;
	shopRandomModAsset.y = SCREEN_HEIGHT / 2 - 200;
	shopRandomModAsset.scale.set(0.8);
	shopContainer.addChild(shopRandomModAsset);
	// Add descriptive text underneath
	var shopDescText = new Text2('Buy a random card mod', {
		size: 60,
		fill: 0xffffff,
		weight: 'bold',
		stroke: 0x000000,
		strokeThickness: 3
	});
	shopDescText.anchor.set(0.5, 0.5);
	shopDescText.x = SCREEN_WIDTH / 2;
	shopDescText.y = shopRandomModAsset.y + shopRandomModAsset.height / 2 + 100;
	shopContainer.addChild(shopDescText);
	// Add price text
	var shopPriceText = new Text2('$' + storage.randomModPrice, {
		size: 80,
		fill: 0xffd700,
		weight: 'bold',
		stroke: 0x000000,
		strokeThickness: 4
	});
	shopPriceText.anchor.set(0.5, 0.5);
	shopPriceText.x = SCREEN_WIDTH / 2;
	shopPriceText.y = shopDescText.y + 80;
	shopContainer.addChild(shopPriceText);
	function buyRandomMod() {
		if (storage.money < storage.randomModPrice) {
			createFloatingText("Not enough money!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 100);
			return;
		}
		var unownedMods = ModSystem.getUnownedMods();
		if (unownedMods.length === 0) {
			createFloatingText("All mods unlocked!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0x00ff00, 100);
			shopPriceText.setText('SOLD OUT');
			shopOverlay.interactive = false;
			shopRandomModAsset.interactive = false;
			return;
		}
		storage.money -= storage.randomModPrice;
		moneyText.setText('$' + storage.money);
		shopOverlay.interactive = false;
		shopRandomModAsset.interactive = false;
		// Hide the static shop random mod asset and its text
		shopRandomModAsset.visible = false;
		shopDescText.visible = false;
		shopPriceText.visible = false;
		var slotContainer = new Container();
		// Position it to replace the shopRandomModAsset
		slotContainer.x = shopRandomModAsset.x;
		slotContainer.y = shopRandomModAsset.y;
		shopContainer.addChild(slotContainer);
		var displayAsset = null;
		var spinDuration = 50;
		var spinsLeft = 20 + Math.floor(Math.random() * 15);
		var finalModId = unownedMods[Math.floor(Math.random() * unownedMods.length)];
		function spin() {
			spinsLeft--;
			if (displayAsset && displayAsset.parent) {
				displayAsset.parent.removeChild(displayAsset);
			}
			var modIdToShow = spinsLeft <= 0 ? finalModId : unownedMods[Math.floor(Math.random() * unownedMods.length)];
			// Scale to fill the space of the shopRandomModAsset
			var sizingAsset = LK.getAsset('shopRandomMod', {});
			var modAssetForSizing = LK.getAsset(modIdToShow, {});
			// Match the visible height of the random mod asset, with a small margin
			var scaleToFit = sizingAsset.height * shopRandomModAsset.scale.y / modAssetForSizing.height * 0.9;
			displayAsset = LK.getAsset(modIdToShow, {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: scaleToFit,
				scaleY: scaleToFit
			});
			slotContainer.addChild(displayAsset);
			if (spinsLeft <= 0) {
				// REVEAL SEQUENCE
				ModSystem.unlockMod(finalModId);
				if (!TutorialSystem.isActive) {
					storage.randomModPrice = Math.floor(storage.randomModPrice * 1.5) + 50;
				}
				shopPriceText.setText('$' + storage.randomModPrice);
				// Create grey-out overlay
				var revealOverlay = new Container();
				revealOverlay.interactive = true;
				revealOverlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
				uiLayer.addChild(revealOverlay);
				var bg = LK.getAsset('card', {
					width: SCREEN_WIDTH,
					height: SCREEN_HEIGHT,
					anchorX: 0,
					anchorY: 0
				});
				bg.tint = 0x000000;
				bg.alpha = 0.8;
				revealOverlay.addChild(bg);
				// Move the final mod asset to the reveal overlay
				var finalModAsset = displayAsset;
				finalModAsset.parent.removeChild(finalModAsset);
				revealOverlay.addChild(finalModAsset);
				finalModAsset.x = SCREEN_WIDTH / 2;
				finalModAsset.y = SCREEN_HEIGHT / 2;
				// The slot container is now empty, remove it.
				if (slotContainer.parent) {
					slotContainer.parent.removeChild(slotContainer);
				}
				// Grow larger animation
				tween(finalModAsset, {
					scaleX: finalModAsset.scale.x * 1.5,
					scaleY: finalModAsset.scale.y * 1.5
				}, {
					duration: 500,
					easing: tween.elasticOut
				});
				// "You received" message
				var modData = ModSystem.modData[finalModId];
				var receivedText = new Text2("You received:\n" + modData.name, {
					size: 90,
					fill: 0xffd700,
					weight: 'bold',
					stroke: 0x000000,
					strokeThickness: 6,
					align: 'center'
				});
				receivedText.anchor.set(0.5, 0.5);
				receivedText.x = SCREEN_WIDTH / 2;
				receivedText.y = finalModAsset.y + finalModAsset.height * finalModAsset.scale.y / 2 + 150;
				revealOverlay.addChild(receivedText);
				// Tap to continue message
				var tapToContinue = new Text2("Tap to continue", {
					size: 60,
					fill: 0xffffff,
					weight: 'bold'
				});
				tapToContinue.anchor.set(0.5, 0.5);
				tapToContinue.x = SCREEN_WIDTH / 2;
				tapToContinue.y = SCREEN_HEIGHT - 200;
				revealOverlay.addChild(tapToContinue);
				// Set up tap to continue
				revealOverlay.down = function () {
					revealOverlay.interactive = false; // Prevent multiple taps
					// Fade out and remove reveal screen
					tween(revealOverlay, {
						alpha: 0
					}, {
						duration: 300,
						onFinish: function onFinish() {
							if (revealOverlay.parent) {
								revealOverlay.parent.removeChild(revealOverlay);
							}
							// Show shop elements again
							shopRandomModAsset.visible = true;
							shopDescText.visible = true;
							shopPriceText.visible = true;
							// Re-enable shop interaction if there are mods left
							if (ModSystem.getUnownedMods().length > 0) {
								shopOverlay.interactive = true;
								shopRandomModAsset.interactive = true;
							} else {
								shopPriceText.setText('SOLD OUT');
							}
						}
					});
				};
			} else {
				if (spinsLeft < 10) spinDuration += 25;
				if (spinsLeft < 5) spinDuration += 40;
				LK.setTimeout(spin, spinDuration);
			}
		}
		spin();
	}
	shopOverlay.interactive = true;
	shopOverlay.down = buyRandomMod;
	shopRandomModAsset.interactive = true;
	shopRandomModAsset.down = buyRandomMod;
	// Add pulsing animation to shopRandomMod
	function createPulseAnimation() {
		if (!shopRandomModAsset.parent) {
			return;
		}
		tween(shopRandomModAsset, {
			scaleX: 0.9,
			scaleY: 0.9
		}, {
			duration: 1000,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (!shopRandomModAsset.parent) {
					return;
				}
				tween(shopRandomModAsset, {
					scaleX: 0.8,
					scaleY: 0.8
				}, {
					duration: 1000,
					easing: tween.easeInOut,
					onFinish: createPulseAnimation
				});
			}
		});
	}
	createPulseAnimation();
	// --- Selection highlight logic ---
	// Helper to move the highlight to the correct button
	function updateTitleScreenSelectionHighlight() {
		var targetX, targetY, targetW, targetH;
		if (currentTitleScreenSelection === "battle") {
			targetX = playButton.x;
			targetY = playButton.y + playButton.height / 2; // anchorY:1, so bottom edge
			targetW = playButton.width * 1.1;
			targetH = playButton.height + battleIcon.height + 20; // Cover button, icon, and gap with padding
		} else if (currentTitleScreenSelection === "mods") {
			targetX = suitModButton.x;
			targetY = suitModButton.y + suitModButton.height / 2;
			targetW = suitModButton.width * 1.1;
			targetH = suitModButton.height + modsIcon.height + 20; // Cover button, icon, and gap with padding
		} else if (currentTitleScreenSelection === "shop") {
			targetX = shopButton.x;
			targetY = shopButton.y + shopButton.height / 2;
			targetW = shopButton.width * 1.2;
			targetH = shopButton.height + shopIcon.height + 20;
		}
		// Animate movement and scaling for smoothness
		tween.stop(titleScreenSelection);
		tween(titleScreenSelection, {
			x: targetX,
			y: targetY,
			width: targetW,
			height: targetH
		}, {
			duration: 180,
			easing: tween.cubicOut
		});
	}
	// Set initial size and position for highlight (battle by default)
	titleScreenSelection.width = playButton.width * 1.2;
	titleScreenSelection.height = playButton.height + battleIcon.height + 20;
	titleScreenSelection.x = playButton.x;
	titleScreenSelection.y = playButton.y + playButton.height / 2;
	// --- Selection switching logic ---
	// Screens: "battle", "mods", "shop"
	playButton.down = function () {
		if (currentTitleScreenSelection !== "battle") {
			currentTitleScreenSelection = "battle";
			updateTitleScreenSelectionHighlight();
		}
		// Show battle screen, hide mods, shop and logo
		modsContainer.visible = false;
		shopContainer.visible = false;
		if (battleScreenContainer) {
			battleScreenContainer.visible = true;
		}
		gameLogo.visible = false;
	};
	suitModButton.down = function () {
		if (currentTitleScreenSelection === "mods") {
			return;
		}
		if (currentTitleScreenSelection !== "mods") {
			currentTitleScreenSelection = "mods";
			updateTitleScreenSelectionHighlight();
		}
		// Show mods, hide others
		modsContainer.visible = true;
		shopContainer.visible = false;
		if (battleScreenContainer) {
			battleScreenContainer.visible = false;
		}
		gameLogo.visible = false;
		if (modsContainer.visible) {
			ModSystem.updateTopSuitDisplay();
		}
	};
	shopButton.down = function () {
		if (currentTitleScreenSelection === "shop") {
			return;
		}
		if (currentTitleScreenSelection !== "shop") {
			currentTitleScreenSelection = "shop";
			updateTitleScreenSelectionHighlight();
		}
		// Show shop, hide others
		shopContainer.visible = true;
		modsContainer.visible = false;
		if (battleScreenContainer) {
			battleScreenContainer.visible = false;
		}
		gameLogo.visible = false;
	};
	battleIcon.down = playButton.down;
	modsIcon.down = suitModButton.down;
	var originalPlayDown = playButton.down;
	var originalModsDown = suitModButton.down;
	var originalShopDown = shopButton.down;
	playButton.down = originalPlayDown;
	suitModButton.down = originalModsDown;
	shopButton.down = originalShopDown;
	battleIcon.down = playButton.down;
	modsIcon.down = suitModButton.down;
	shopIcon.down = shopButton.down;
	var shopItemsForTutorial = {
		overlay: shopOverlay,
		asset: shopRandomModAsset,
		buyButtonDown: buyRandomMod,
		priceText: shopPriceText
	};
	TutorialSystem.registerStartScreenElements({
		battle: {
			button: playButton,
			icon: battleIcon,
			down: originalPlayDown
		},
		mods: {
			button: suitModButton,
			icon: modsIcon,
			down: originalModsDown
		},
		shop: {
			button: shopButton,
			icon: shopIcon,
			down: originalShopDown
		},
		modsContainer: modsContainer,
		shopContainer: shopContainer,
		shopItems: shopItemsForTutorial
	});
	if (TutorialSystem.isActive && fromMatch) {
		// A small delay to ensure the start screen elements are fully rendered
		LK.setTimeout(function () {
			TutorialSystem.advanceStep();
		}, 200);
	}
	var numCircles = suitAssets.length;
	var totalBarWidth = SCREEN_WIDTH - 200;
	var suitSpacing = totalBarWidth / numCircles;
	var startX = SCREEN_WIDTH / 2 - totalBarWidth / 2 + suitSpacing / 2;
	var yOffset = SCREEN_HEIGHT * 0.1;
	var circleY = 300 + yOffset;
	ModSystem.topSuitGraphics = []; // Reset the array
	for (var i = 0; i < numCircles; i++) {
		var circleX = startX + i * suitSpacing;
		var suitContainer = new Container();
		var circleBg = LK.getAsset('card', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		circleBg.scale.set(1.5);
		suitContainer.addChild(circleBg);
		suitContainer.x = circleX;
		suitContainer.y = circleY - SCREEN_HEIGHT * 0.05 + 100;
		modsContainer.addChild(suitContainer);
		ModSystem.topSuitGraphics.push(suitContainer);
	}
	// --- Dark overlay below the four cards and above the equipped mods text ---
	var overlayCard = LK.getAsset('card', {
		anchorX: 0.5,
		anchorY: 0
	});
	var overlayWidth = totalBarWidth + 120; // Wide enough for all four cards and some margin
	var overlayHeight = 650; // Tall enough to cover the cards and the equipped mods text
	overlayCard.scale.set(overlayWidth / overlayCard.width, overlayHeight / overlayCard.height);
	overlayCard.x = SCREEN_WIDTH / 2;
	overlayCard.y = circleY - SCREEN_HEIGHT * 0.05 - overlayCard.height * overlayCard.scale.y / 2 + 130; // Start just above the cards
	overlayCard.alpha = 0.6;
	overlayCard.tint = 0x000000;
	modsContainer.addChildAt(overlayCard, 0);
	var equippedModsText = new Text2('Currently equipped mods', {
		size: 45,
		fill: 0xffffff,
		weight: '600'
	});
	equippedModsText.anchor.set(0.5, 0);
	equippedModsText.x = SCREEN_WIDTH / 2;
	equippedModsText.y = circleY - SCREEN_HEIGHT * 0.05 + 350; // Position 25px below the mod icons
	modsContainer.addChild(equippedModsText);
	var gridContainer = new Container();
	gridContainer.x = SCREEN_WIDTH / 2;
	gridContainer.y = circleY + 450 - SCREEN_HEIGHT * 0.05;
	modsContainer.addChild(gridContainer);
	var cols = 4;
	var rows = 3;
	var cardForSizing = LK.getAsset('card', {});
	var cellWidth = cardForSizing.width;
	var cellHeight = cardForSizing.height;
	var colSpacing = 160;
	var rowSpacing = 140;
	var gridTotalWidth = cols * cellWidth + (cols - 1) * colSpacing;
	var gridStartX = -gridTotalWidth / 2;
	var gridStartY = 50;
	var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod'];
	for (var r = 0; r < rows; r++) {
		for (var c = 0; c < cols; c++) {
			var cell = LK.getAsset('card', {
				anchorX: 0,
				anchorY: 0
			});
			cell.scale.set(1.3);
			cell.x = gridStartX + c * (cellWidth + colSpacing);
			cell.y = gridStartY + r * (cellHeight + rowSpacing);
			gridContainer.addChild(cell);
			var modIndex = r * cols + c;
			if (modIndex < suitModAssets.length) {
				var modAssetId = suitModAssets[modIndex];
				if (modAssetId) {
					var shadow = LK.getAsset('suitShadow', {
						anchorX: 0.5,
						anchorY: 0.5
					});
					shadow.x = cell.x + cell.width * cell.scale.x / 2;
					shadow.y = cell.y + cell.height * cell.scale.y - cell.height * cell.scale.y / 5 + 15;
					shadow.alpha = 0.3;
					gridContainer.addChild(shadow);
					var modAsset = LK.getAsset(modAssetId, {
						anchorX: 0.5,
						anchorY: 0.5
					});
					modAsset.x = cell.x + cell.width * cell.scale.x / 2;
					modAsset.y = cell.y + cell.height * cell.scale.y / 2;
					var isOwned = ModSystem.isModOwned(modAssetId);
					if (!isOwned) {
						modAsset.tint = 0x555555;
						modAsset.alpha = 0.6;
						cell.tint = 0x888888;
					}
					gridContainer.addChild(modAsset);
					var modData = ModSystem.modData[modAssetId];
					if (modData) {
						var nameText = new Text2(modData.name.toUpperCase(), {
							size: 35,
							fill: 0x000000,
							weight: 'bold',
							strokeThickness: 0
						});
						nameText.anchor.set(0.5, 0);
						nameText.x = cell.x + cell.width * cell.scale.x / 2;
						nameText.y = cell.y + 20;
						gridContainer.addChild(nameText);
					}
					createModFloatAnimation(modAsset, shadow);
					// Add click handler for mod display to the entire cell card
					cell.interactive = true;
					(function (assetId, modAssetRef) {
						cell.down = function () {
							ModSystem.showModDisplay(assetId, modAssetRef.x, modAssetRef.y);
						};
					})(modAssetId, modAsset);
				}
			}
		}
	}
	currentGameState = 'start';
}
function startGame(isTutorial) {
	LK.stopMusic();
	// Clear start screen elements
	startScreenElements.forEach(function (element) {
		if (element.parent) {
			element.parent.removeChild(element);
		}
	});
	startScreenElements = [];
	backgroundSuits = [];
	// Show game elements
	gameElements.forEach(function (element) {
		element.visible = true;
	});
	currentGameState = 'playing';
	initializeGame(isTutorial || false);
}
function initializeGame(isTutorial) {
	ModSystem.init();
	PoolManager.init();
	PathSystem.init();
	// Initialize play areas
	gameState.playerPlayArea = [];
	gameState.aiPlayArea = [];
	playerHandNameTexts = [null, null];
	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();
	createLifeDisplays();
	lastPlayerLives = gameState.playerLives;
	lastAiLives = gameState.aiLives;
	// Initialize player's hand with empty slots
	gameState.playerHand = [null, null, null, null, null];
	// Center bar removed
	if (isTutorial) {
		LK.playMusic('pvpMusic');
		gameReady = false; // Don't start waves automatically
		AISystem.thinkDelay = 999999; // Effectively disable AI
		TutorialSystem.startInGameTutorial();
	} else {
		// Start the wave system with a "Get Ready" message
		var getReadyText = new Text2('Get ready…', {
			size: 150,
			fill: 0xffffff,
			weight: 'bold',
			stroke: 0x000000,
			strokeThickness: 10
		});
		getReadyText.anchor.set(0.5, 0.5);
		getReadyText.x = SCREEN_WIDTH / 2;
		getReadyText.y = SCREEN_HEIGHT / 2;
		getReadyText.alpha = 0;
		uiLayer.addChild(getReadyText);
		tween(getReadyText, {
			alpha: 1
		}, {
			duration: 500,
			onFinish: function onFinish() {
				LK.getSound('getReady').play();
			}
		});
		gameReady = false;
		// After three seconds, display "Game start!" and begin the first wave.
		LK.setTimeout(function () {
			if (!getReadyText.parent) {
				return;
			}
			getReadyText.setText('Deal \'em!');
			LK.getSound('gameStart').play();
			// Remove the message after it has been displayed for a short time
			LK.setTimeout(function () {
				if (getReadyText.parent) {
					tween(getReadyText, {
						alpha: 0
					}, {
						duration: 500,
						onFinish: function onFinish() {
							if (getReadyText.parent) {
								getReadyText.parent.removeChild(getReadyText);
							}
							gameReady = true;
							LK.playMusic('pvpMusic');
						}
					});
				}
			}, 1000);
		}, 3000);
	}
}
function createLifeDisplays() {
	// Clear any existing hearts and labels
	if (opponentNameText && opponentNameText.parent) {
		opponentNameText.parent.removeChild(opponentNameText);
	}
	if (playerNameText && playerNameText.parent) {
		playerNameText.parent.removeChild(playerNameText);
	}
	playerLifeHearts.forEach(function (h) {
		if (h.parent) {
			h.parent.removeChild(h);
		}
	});
	playerLifeHearts = [];
	aiLifeHearts.forEach(function (h) {
		if (h.parent) {
			h.parent.removeChild(h);
		}
	});
	aiLifeHearts = [];
	var heartSpacing = 110;
	var heartScale = 0.5;
	var startX_AI = 200 - 70;
	var startX_Player = SCREEN_WIDTH - 200 + 70;
	var yPos = SCREEN_HEIGHT / 2 - 137 + 10;
	var labelYPos = yPos - 60;
	// Opponent Name Text
	var totalAIHeartsWidth = (gameState.aiLives - 1) * heartSpacing;
	opponentNameText = new Text2('Opponent', {
		size: 40,
		fill: 0xffffff,
		weight: 800
	});
	opponentNameText.anchor.set(0.5, 1);
	opponentNameText.x = startX_AI + totalAIHeartsWidth / 2;
	opponentNameText.y = labelYPos;
	uiLayer.addChild(opponentNameText);
	// Player Name Text
	var totalPlayerHeartsWidth = (gameState.playerLives - 1) * heartSpacing;
	playerNameText = new Text2('Player', {
		size: 40,
		fill: 0xffffff,
		weight: 800
	});
	playerNameText.anchor.set(0.5, 1);
	playerNameText.x = startX_Player - totalPlayerHeartsWidth / 2;
	playerNameText.y = labelYPos;
	uiLayer.addChild(playerNameText);
	// AI Lives (left side)
	for (var i = 0; i < gameState.aiLives; i++) {
		var heart = LK.getAsset('heartSuit', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: heartScale,
			scaleY: heartScale
		});
		heart.x = startX_AI + i * heartSpacing;
		heart.y = yPos;
		uiLayer.addChild(heart);
		aiLifeHearts.push(heart);
	}
	// Player Lives (right side)
	for (var i = 0; i < gameState.playerLives; i++) {
		var heart = LK.getAsset('heartSuit', {
			anchorX: 0.5,
			anchorY: 0.5,
			scaleX: heartScale,
			scaleY: heartScale
		});
		heart.x = startX_Player - i * heartSpacing;
		heart.y = yPos;
		uiLayer.addChild(heart);
		playerLifeHearts.push(heart);
	}
}
function dealNewHand() {
	if (gameState.playerChips < gameState.dealCost) {
		return;
	}
	// Find an empty slot in the player's hand
	var emptySlotIndex = -1;
	for (var i = 0; i < gameState.playerHand.length; i++) {
		if (!gameState.playerHand[i]) {
			emptySlotIndex = i;
			break;
		}
	}
	// If hand is full, do nothing
	if (emptySlotIndex === -1) {
		return;
	}
	gameState.playerChips -= gameState.dealCost;
	gameState.dealCount++;
	gameState.dealCost = Math.floor(25 * Math.pow(1.05, gameState.dealCount)); // Lower base cost for single card
	if (gameState.playerDeck.length === 0) {
		gameState.playerDeck = CardSystem.createDeck();
	}
	var cardData = gameState.playerDeck.pop();
	var card = new Card(cardData);
	// After every 10 waves, new cards dealt start one level higher
	var startLevel = Math.floor((WaveSystem.waveNumber - 1) / 10) + 1;
	card.setLevel(startLevel);
	var i = emptySlotIndex;
	var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px
	var handStartX = (SCREEN_WIDTH - handWidth) / 2;
	var slotX = handStartX + i * DEAL_SLOT_WIDTH + i * 30 + DEAL_SLOT_WIDTH / 2;
	var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
	// Start position - off to the bottom
	var startX = slotX + (Math.random() - 0.5) * 50; // Slight horizontal variance
	var startY = SCREEN_HEIGHT + DEAL_SLOT_HEIGHT;
	card.activate(startX, startY, false, true);
	card.rotation = 0; // No spin
	card.scaleX = 1; // Normal width
	card.scaleY = 0.01; // Extremely thin/squished vertically - almost completely flat
	uiLayer.addChild(card);
	gameState.playerHand[i] = card;
	// Animate flying and expanding with more extreme squish and slower resolution
	tween(card, {
		x: slotX,
		y: slotY,
		scaleY: 1.2 // More extreme overshoot on Y-axis
	}, {
		duration: 250,
		easing: tween.cubicOut,
		delay: i * 80,
		onFinish: function onFinish() {
			LK.getSound('cardLand').play();
			// Settle back to normal size with longer duration
			tween(card, {
				scaleY: 1
			}, {
				duration: 150,
				easing: tween.quadIn
			});
		}
	});
	updateUI();
}
function updateUI() {
	playerChipsText.setText('Chips: ' + formatNumberWithSuffix(gameState.playerChips));
	// Update combined deal/discard button text and appearance when not dragging
	if (!isDragging) {
		discardText.setText('-' + formatNumberWithSuffix(gameState.dealCost));
		discardText.fill = 0xffffff;
		// Update button color based on affordability
		if (gameState.playerChips >= gameState.dealCost) {
			discardAreaGraphic.tint = 0xffffff; // No tint when affordable
			discardAreaGraphic.alpha = 1.0; // Full alpha when affordable
		} else {
			discardAreaGraphic.tint = 0x666666; // Grey tint when not affordable
			discardAreaGraphic.alpha = 1.0; // Keep full alpha even when not affordable
		}
	}
	waveText.setText('Wave: ' + WaveSystem.waveNumber);
}
function drawPlayAreas() {
	// Draw player play area slots
	var hand1Text = 'HAND1';
	var hand2Text = 'HAND2';
	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('card', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			slotGraphics.alpha = 0.5;
			var textToShow = row === 0 ? hand1Text : hand2Text;
			var text = new Text2(textToShow.charAt(col), {
				size: 180,
				fill: 0xffffff,
				weight: 'bold'
			});
			text.anchor.set(0.5);
			text.alpha = 0.3;
			slot.addChild(text);
			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);
			slotIndicators.push(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('card', {
				anchorX: 0.5,
				anchorY: 0.5
			});
			slotGraphics.alpha = 0.5;
			slotGraphics.tint = 0xff8888; // Red tint for AI area
			var textToShow = row === 0 ? hand1Text : hand2Text;
			var text = new Text2(textToShow.charAt(col), {
				size: 180,
				fill: 0xffffff,
				weight: 'bold'
			});
			text.anchor.set(0.5);
			text.alpha = 0.3;
			slot.addChild(text);
			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);
			slotIndicators.push(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.5;
		var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px
		var handStartX = (SCREEN_WIDTH - handWidth) / 2;
		dealSlot.x = handStartX + i * DEAL_SLOT_WIDTH + i * 30 + DEAL_SLOT_WIDTH / 2;
		dealSlot.y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
		gameLayer.addChild(dealSlot);
		slotIndicators.push(dealSlot);
	}
}
function drawPaths() {
	// Path lines removed - enemies still follow invisible paths
}
// drawPathSegment function removed - no longer needed since path lines are removed
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
			};
		}
	}
	// Check player hand area
	if (y >= PLAYER_DEAL_AREA_Y && y <= PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT) {
		var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px
		var handStartX = (SCREEN_WIDTH - handWidth) / 2;
		for (var i = 0; i < 5; i++) {
			var slotXStart = handStartX + i * (DEAL_SLOT_WIDTH + 30);
			var slotXEnd = slotXStart + DEAL_SLOT_WIDTH;
			if (x >= slotXStart && x <= slotXEnd) {
				return {
					area: 'hand',
					index: i
				};
			}
		}
	}
	// Check discard area
	if (discardAreaContainer && x >= discardAreaContainer.x - DEAL_SLOT_WIDTH / 2 && x <= discardAreaContainer.x + DEAL_SLOT_WIDTH / 2 && y >= discardAreaContainer.y - DEAL_SLOT_HEIGHT / 2 && y <= discardAreaContainer.y + DEAL_SLOT_HEIGHT / 2) {
		return {
			area: 'discard'
		};
	}
	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]);
		}
	}
	return CardSystem.evaluatePokerHand(cards);
}
function updateHandNameDisplay(row, handEval) {
	var existingText = playerHandNameTexts[row];
	var shouldShowText = handEval.strength > 1;
	if (shouldShowText) {
		var handName = handEval.type.replace(/_/g, ' ').toUpperCase();
		if (existingText) {
			if (existingText.text !== handName) {
				existingText.setText(handName);
			}
			existingText.visible = true;
		} else {
			var newText = new Text2(handName, {
				size: 50,
				fill: 0xffffff,
				weight: '800',
				stroke: 0x000000,
				strokeThickness: 0
			});
			newText.anchor.set(0.5, 0);
			newText.alpha = 0.8;
			newText.x = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH / 2;
			newText.y = PLAYER_AREA_Y + (row + 1) * SLOT_HEIGHT - 20;
			uiLayer.addChild(newText);
			playerHandNameTexts[row] = newText;
		}
	} else {
		if (existingText) {
			existingText.visible = false;
		}
	}
}
function applyHandBonuses() {
	// Apply bonuses to player cards
	for (var row = 0; row < PLAY_AREA_ROWS; row++) {
		var handEval = evaluateRowHand(row, true);
		updateHandNameDisplay(row, handEval);
		var contributingCards = handEval.contributingCards || [];
		for (var col = 0; col < PLAY_AREA_COLS; col++) {
			var card = gameState.playerPlayArea[row][col];
			if (card) {
				card.handBonus = handEval.multiplier;
				card.calculateStats();
				card.redOutline.visible = handEval.strength > 1 && contributingCards.indexOf(card) !== -1;
			}
		}
	}
	// Apply bonuses to AI cards
	AISystem.applyAIHandBonuses();
}
function getAIDifficultySettings(battleRating) {
	// Normalize rating from 0 to 1, clamped between 0 and a max rating (e.g., 2000)
	var maxRatingForScaling = 2000;
	var normalizedRating = Math.max(0, Math.min(battleRating || 0, maxRatingForScaling)) / maxRatingForScaling;
	// thinkDelay: from 360 (6s) at rating 0 down to 45 (0.75s) at max rating. Slower at low rating.
	var thinkDelay = 360 - normalizedRating * (360 - 45);
	// optimizationChance: from 0.05 (5%) at rating 0 up to 0.7 (70%) at max rating. Less optimal at low rating.
	var optimizationChance = 0.05 + normalizedRating * (0.7 - 0.05);
	// shouldOptimize: enable optimization logic after a certain rating threshold (e.g., 100)
	var shouldOptimize = (battleRating || 0) > 100;
	return {
		thinkDelay: Math.floor(thinkDelay),
		optimizationChance: optimizationChance,
		shouldOptimize: shouldOptimize,
		canLevelUp: (battleRating || 0) > 0
	};
}
/**** 
* AI System
****/ 
var AISystem = {
	thinkTimer: 0,
	update: function update() {
		var difficulty = getAIDifficultySettings(storage.battleRating);
		var currentThinkDelay = TutorialSystem.isActive ? 240 : difficulty.thinkDelay;
		this.thinkTimer++;
		if (this.thinkTimer >= currentThinkDelay) {
			this.thinkTimer = 0;
			this.makeMove();
		}
	},
	shouldDeal: function shouldDeal() {
		// Deal if we can afford it and have empty slots
		if (gameState.aiChips < gameState.dealCost) {
			return false;
		}
		var emptySlots = this.countEmptySlots();
		// Deal if there are any empty slots at all
		return emptySlots > 0;
	},
	countEmptySlots: function countEmptySlots() {
		var count = 0;
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				if (!gameState.aiPlayArea[row][col]) {
					count++;
				}
			}
		}
		return count;
	},
	countLowLevelCards: function countLowLevelCards() {
		var count = 0;
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				var card = gameState.aiPlayArea[row][col];
				if (card && card.level <= 2) {
					count++;
				}
			}
		}
		return count;
	},
	makeMove: function makeMove() {
		var difficulty = getAIDifficultySettings(storage.battleRating);
		// Priority order: Merge > Place > Optimize > Deal. Only one action per cycle.
		if (difficulty.canLevelUp && this.tryMergeCards()) {
			// Successfully merged, wait for next think cycle
			return;
		}
		if (this.tryPlaceCards()) {
			// Successfully placed cards
			return;
		}
		if (difficulty.shouldOptimize && this.optimizeCardPositions()) {
			// Successfully optimized, wait for next think cycle
			return;
		}
		// As a last resort, try to deal a new card if possible
		if (this.shouldDeal()) {
			this.dealAIHand();
		}
	},
	tryMergeCards: function tryMergeCards() {
		// Look for mergeable cards
		for (var row1 = 0; row1 < PLAY_AREA_ROWS; row1++) {
			for (var col1 = 0; col1 < PLAY_AREA_COLS; col1++) {
				var card1 = gameState.aiPlayArea[row1][col1];
				if (!card1) {
					continue;
				}
				// Look for a card to merge with
				for (var row2 = 0; row2 < PLAY_AREA_ROWS; row2++) {
					for (var col2 = 0; col2 < PLAY_AREA_COLS; col2++) {
						if (row1 === row2 && col1 === col2) {
							continue;
						}
						var card2 = gameState.aiPlayArea[row2][col2];
						if (!card2) {
							continue;
						}
						if (card1.canMergeWith(card2)) {
							this.mergeCards(card1, card2, row1, col1, row2, col2);
							return true;
						}
					}
				}
			}
		}
		return false;
	},
	mergeCards: function mergeCards(card1, card2, row1, col1, row2, col2) {
		var mergedCard = card1.mergeWith(card2);
		if (mergedCard) {
			// Remove old cards
			gameLayer.removeChild(card1);
			gameLayer.removeChild(card2);
			gameState.aiPlayArea[row1][col1] = null;
			gameState.aiPlayArea[row2][col2] = null;
			// Place merged card in the first position
			var pos = getSlotPosition(row1, col1, false);
			mergedCard.activate(pos.x, pos.y, true, false);
			gameLayer.addChild(mergedCard);
			gameState.aiPlayArea[row1][col1] = mergedCard;
			// Merge animation
			mergedCard.alpha = 0;
			mergedCard.scaleX = mergedCard.scaleY = 1.5;
			tween(mergedCard, {
				alpha: 1,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 200,
				easing: tween.elasticOut
			});
			createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00);
			this.applyAIHandBonuses();
		}
	},
	tryPlaceCards: function tryPlaceCards() {
		// AI doesn't have a "hand" like player, it deals directly to board
		// This function is for future expansion
		return false;
	},
	optimizeCardPositions: function optimizeCardPositions() {
		// Move stronger cards to better positions (like completing poker hands)
		// For now, just try to complete rows for hand bonuses
		return this.tryCompletePokerHands();
	},
	tryCompletePokerHands: function tryCompletePokerHands() {
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			var rowCards = [];
			var emptyPositions = [];
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				if (gameState.aiPlayArea[row][col]) {
					rowCards.push({
						card: gameState.aiPlayArea[row][col],
						col: col
					});
				} else {
					emptyPositions.push(col);
				}
			}
			// If row is almost complete, try to fill it strategically
			if (rowCards.length >= 3 && emptyPositions.length > 0) {
				// Look for cards in other rows that might complete a hand
				if (this.tryMoveCardToCompleteHand(row, rowCards, emptyPositions[0])) {
					return true; // A move was made, so we are done for this 'think' cycle
				}
			}
		}
		return false; // No move was made
	},
	tryMoveCardToCompleteHand: function tryMoveCardToCompleteHand(targetRow, existingCards, targetCol) {
		var difficulty = getAIDifficultySettings(storage.battleRating);
		// Look for cards in other positions that might help complete a hand
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			if (row === targetRow) {
				continue;
			}
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				var card = gameState.aiPlayArea[row][col];
				if (!card) {
					continue;
				}
				// Simple heuristic: move cards of same suit or sequential values
				var shouldMove = this.cardHelpsHand(card, existingCards);
				if (shouldMove && Math.random() < difficulty.optimizationChance) {
					// Dynamic chance to move
					// Move the card
					gameState.aiPlayArea[row][col] = null;
					gameState.aiPlayArea[targetRow][targetCol] = card;
					var newPos = getSlotPosition(targetRow, targetCol, false);
					tween(card, {
						x: newPos.x,
						y: newPos.y
					}, {
						duration: 300,
						easing: tween.quadOut
					});
					this.applyAIHandBonuses();
					return true;
				}
			}
		}
		return false;
	},
	cardHelpsHand: function cardHelpsHand(card, existingCards) {
		// Simple heuristic to see if a card might help complete a poker hand
		var suits = {};
		var values = {};
		existingCards.forEach(function (cardInfo) {
			var c = cardInfo.card.cardData;
			suits[c.suit] = (suits[c.suit] || 0) + 1;
			values[c.value] = (values[c.value] || 0) + 1;
		});
		// Check if card matches existing suits or values
		var cardSuit = card.cardData.suit;
		var cardValue = card.cardData.value;
		return suits[cardSuit] >= 2 || values[cardValue] >= 1;
	},
	dealAIHand: function dealAIHand() {
		if (gameState.aiChips < gameState.dealCost) {
			return;
		}
		gameState.aiChips -= gameState.dealCost;
		// Deal one card to an empty slot
		var cardData;
		// AI cannot play jokers, so re-deal if one is drawn.
		do {
			if (gameState.aiDeck.length === 0) {
				gameState.aiDeck = CardSystem.createDeck();
			}
			cardData = gameState.aiDeck.pop();
		} while (cardData.suit === 'joker');
		var card = new Card(cardData);
		// After every 10 waves, new cards dealt start one level higher
		var startLevel = Math.floor((WaveSystem.waveNumber - 1) / 10) + 1;
		card.setLevel(startLevel);
		// Find best empty slot (prefer completing rows)
		var bestSlot = this.findBestEmptySlot();
		if (bestSlot) {
			var pos = getSlotPosition(bestSlot.row, bestSlot.col, false);
			// Set initial off-screen position and properties for animation
			var startY = -SLOT_HEIGHT; // Come from top of the screen
			card.activate(pos.x, startY, true, false);
			card.rotation = Math.PI * 4; // Two full spins
			card.scale.set(0.1); // Start small
			gameLayer.addChild(card);
			gameState.aiPlayArea[bestSlot.row][bestSlot.col] = card;
			// Deal animation
			tween(card, {
				y: pos.y,
				rotation: 0,
				scaleX: 1,
				scaleY: 1
			}, {
				duration: 600,
				easing: tween.quadOut
			});
			this.applyAIHandBonuses();
		}
	},
	findBestEmptySlot: function findBestEmptySlot() {
		var emptySlots = [];
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				if (!gameState.aiPlayArea[row][col]) {
					var score = this.evaluateSlotScore(row, col);
					emptySlots.push({
						row: row,
						col: col,
						score: score
					});
				}
			}
		}
		if (emptySlots.length === 0) {
			return null;
		}
		// Sort by score (higher is better)
		emptySlots.sort(function (a, b) {
			return b.score - a.score;
		});
		return emptySlots[0];
	},
	evaluateSlotScore: function evaluateSlotScore(row, col) {
		var score = 0;
		var cardsInRow = 0;
		// Count cards in this row
		for (var c = 0; c < PLAY_AREA_COLS; c++) {
			if (gameState.aiPlayArea[row][c]) {
				cardsInRow++;
			}
		}
		// Prefer completing rows
		score += cardsInRow * 10;
		// Slight preference for middle positions
		score += (2 - Math.abs(col - 2)) * 2;
		return score;
	},
	applyAIHandBonuses: function applyAIHandBonuses() {
		// Apply poker hand bonuses to AI cards
		for (var row = 0; row < PLAY_AREA_ROWS; row++) {
			var handEval = evaluateRowHand(row, false);
			var contributingCards = handEval.contributingCards || [];
			for (var col = 0; col < PLAY_AREA_COLS; col++) {
				var card = gameState.aiPlayArea[row][col];
				if (card) {
					card.handBonus = handEval.multiplier;
					card.calculateStats();
					card.redOutline.visible = handEval.strength > 1 && contributingCards.indexOf(card) !== -1;
				}
			}
		}
	}
};
/**** 
* Input Handling
****/ 
game.down = function (x, y, obj) {
	// Only handle input during playing state
	if (currentGameState !== 'playing') {
		return;
	}
	// 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;
			originalCardPosition = {
				area: 'hand',
				index: i
			};
			uiLayer.addChild(selectedCard);
			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;
				originalCardPosition = {
					area: 'player',
					row: row,
					col: col
				};
				// Remove from current position
				gameState.playerPlayArea[row][col] = null;
				gameLayer.addChild(selectedCard);
				return;
			}
		}
	}
};
game.move = function (x, y, obj) {
	// Only handle input during playing state
	if (currentGameState !== 'playing') {
		return;
	}
	if (isDragging && selectedCard) {
		selectedCard.x = x;
		selectedCard.y = y;
		// Highlight mergeable cards
		// Player's 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) {
					card.greenOutline.visible = selectedCard.canMergeWith(card);
				}
			}
		}
		// Player's hand
		for (var i = 0; i < gameState.playerHand.length; i++) {
			var card = gameState.playerHand[i];
			if (card && card !== selectedCard) {
				card.greenOutline.visible = selectedCard.canMergeWith(card);
			}
		}
		// Switch to discard mode when dragging
		discardAreaGraphic.visible = false;
		refundButtonGraphic.visible = true;
		// Highlight discard area on hover
		var isOverDiscard = discardAreaContainer && x >= discardAreaContainer.x - DEAL_SLOT_WIDTH / 2 && x <= discardAreaContainer.x + DEAL_SLOT_WIDTH / 2 && y >= discardAreaContainer.y - DEAL_SLOT_HEIGHT / 2 && y <= discardAreaContainer.y + DEAL_SLOT_HEIGHT / 2;
		var chipRefund = Math.floor(gameState.dealCost / 2);
		discardText.setText('+' + formatNumberWithSuffix(chipRefund));
		if (isOverDiscard) {
			discardText.fill = 0xffd700; // Gold color
			refundButtonGraphic.alpha = 1.0;
		} else {
			refundButtonGraphic.alpha = 0.7;
			discardText.fill = 0x999999;
		}
	} else {
		// When not dragging, show as deal button
		discardAreaGraphic.visible = true;
		refundButtonGraphic.visible = false;
		updateUI();
	}
};
game.up = function (x, y, obj) {
	// Only handle input during playing state
	if (currentGameState !== 'playing') {
		return;
	}
	if (isDragging && selectedCard) {
		isDragging = false;
		discardAreaGraphic.visible = true;
		refundButtonGraphic.visible = false;
		// Clear all temporary green outlines
		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) {
					card.greenOutline.visible = false;
				}
			}
		}
		for (var i = 0; i < gameState.playerHand.length; i++) {
			var card = gameState.playerHand[i];
			if (card) {
				card.greenOutline.visible = false;
			}
		}
		// Reset to deal button mode
		updateUI();
		var targetSlot = getSlotFromPosition(x, y);
		if (targetSlot) {
			// Handle dropping card on discard area
			if (targetSlot.area === 'discard') {
				var chipRefund = Math.floor(gameState.dealCost / 2);
				gameState.playerChips += chipRefund;
				// Remove from original position data
				if (originalCardPosition.area === 'hand') {
					gameState.playerHand[originalCardPosition.index] = null;
				} else if (originalCardPosition.area === 'player') {
					// This is already null from game.down, so this is just for safety.
					gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = null;
				}
				// Remove card graphic from scene and memory
				if (selectedCard.parent) {
					selectedCard.parent.removeChild(selectedCard);
				}
				createFloatingText('+' + formatNumberWithSuffix(chipRefund) + ' Chips', selectedCard.x, selectedCard.y, 0xffd700);
				selectedCard = null;
				originalCardPosition = null;
				updateUI();
				// Recalculate bonuses if a card was removed from play area
				if (originalCardPosition && originalCardPosition.area === 'player') {
					applyHandBonuses();
				}
				return; // Exit early
			}
			if (targetSlot.area === 'player') {
				var existingCard = gameState.playerPlayArea[targetSlot.row][targetSlot.col];
				if (existingCard && selectedCard.canMergeWith(existingCard)) {
					// Merge in play area
					var mergedCard = selectedCard.mergeWith(existingCard);
					if (mergedCard) {
						gameLayer.removeChild(existingCard);
						var handIndex = gameState.playerHand.indexOf(selectedCard);
						if (handIndex !== -1) {
							uiLayer.removeChild(selectedCard);
							gameState.playerHand[handIndex] = null;
						} else {
							gameLayer.removeChild(selectedCard);
						}
						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;
						mergedCard.alpha = 0;
						mergedCard.scaleX = mergedCard.scaleY = 2;
						tween(mergedCard, {
							alpha: 1,
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 300,
							easing: tween.elasticOut
						});
						LK.getSound('levelUp').play();
						createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00);
					}
				} else if (!existingCard) {
					// Prevent Jokers from being played on the board directly. They can only merge.
					if (selectedCard.cardData.suit === 'joker') {
						createFloatingText('Jokers can only level up other cards.', selectedCard.x, selectedCard.y, 0xffcc00);
						returnCardToOriginalPosition();
					} else {
						// Place in empty slot
						var pos = getSlotPosition(targetSlot.row, targetSlot.col, true);
						selectedCard.activate(pos.x, pos.y, true);
						selectedCard.resetInvestment();
						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 {
					// Prevent Jokers from being swapped onto the board.
					if (selectedCard.cardData.suit === 'joker') {
						createFloatingText('Jokers can only level up other cards.', selectedCard.x, selectedCard.y, 0xffcc00);
						returnCardToOriginalPosition();
					} else {
						// Card exists, but cannot merge: swap them with animation
						var swappedCard = gameState.playerPlayArea[targetSlot.row][targetSlot.col];
						// Determine target positions for animation
						var pos1 = getSlotPosition(targetSlot.row, targetSlot.col, true);
						var pos2;
						tween(selectedCard, {
							x: pos1.x,
							y: pos1.y
						}, {
							duration: 200,
							easing: tween.quadOut
						});
						// Update selectedCard state
						selectedCard.isInPlay = true;
						if (originalCardPosition.area === 'hand') {
							selectedCard.resetInvestment(); // Card moved from hand to play area
							gameState.playerHand[originalCardPosition.index] = null;
							uiLayer.removeChild(selectedCard);
							gameLayer.addChild(selectedCard);
						}
						gameState.playerPlayArea[targetSlot.row][targetSlot.col] = selectedCard;
						// Determine target for swappedCard and animate
						if (originalCardPosition.area === 'player') {
							pos2 = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true);
							swappedCard.isInPlay = true;
							gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = swappedCard;
						} else {
							// original was hand, so swapped card goes to hand
							var origHandIndex = originalCardPosition.index;
							var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30;
							var handStartX = (SCREEN_WIDTH - handWidth) / 2;
							pos2 = {
								x: handStartX + origHandIndex * DEAL_SLOT_WIDTH + origHandIndex * 30 + DEAL_SLOT_WIDTH / 2,
								y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2
							};
							swappedCard.isInPlay = false;
							gameLayer.removeChild(swappedCard);
							uiLayer.addChild(swappedCard);
							gameState.playerHand[origHandIndex] = swappedCard;
						}
						tween(swappedCard, {
							x: pos2.x,
							y: pos2.y
						}, {
							duration: 200,
							easing: tween.quadOut
						});
						selectedCard.calculateStats();
						swappedCard.calculateStats();
					}
				}
			} else if (targetSlot.area === 'hand') {
				var existingCard = gameState.playerHand[targetSlot.index];
				if (existingCard && existingCard !== selectedCard && selectedCard.canMergeWith(existingCard)) {
					// Merge in hand
					var mergedCard = selectedCard.mergeWith(existingCard);
					if (mergedCard) {
						// Remove old cards
						var handIndex1 = gameState.playerHand.indexOf(selectedCard);
						if (handIndex1 !== -1) {
							uiLayer.removeChild(selectedCard);
							gameState.playerHand[handIndex1] = null;
						} else {
							gameLayer.removeChild(selectedCard);
						}
						var handIndex2 = gameState.playerHand.indexOf(existingCard);
						if (handIndex2 !== -1) {
							uiLayer.removeChild(existingCard);
							gameState.playerHand[handIndex2] = null;
						}
						// Place merged card in hand
						var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px
						var handStartX = (SCREEN_WIDTH - handWidth) / 2;
						var slotX = handStartX + targetSlot.index * DEAL_SLOT_WIDTH + targetSlot.index * 30 + DEAL_SLOT_WIDTH / 2;
						var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
						mergedCard.activate(slotX, slotY, false, true);
						uiLayer.addChild(mergedCard);
						gameState.playerHand[targetSlot.index] = mergedCard;
						// Merge animation
						mergedCard.alpha = 0;
						mergedCard.scaleX = mergedCard.scaleY = 2;
						tween(mergedCard, {
							alpha: 1,
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 300,
							easing: tween.elasticOut
						});
						LK.getSound('levelUp').play();
						createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00);
					} else {
						returnCardToOriginalPosition();
					}
				} else if (existingCard && existingCard !== selectedCard) {
					// Cannot merge, so swap with animation
					var swappedCard = gameState.playerHand[targetSlot.index];
					// Get target positions
					var targetHandIndex = targetSlot.index;
					var handWidth1 = 5 * DEAL_SLOT_WIDTH + 4 * 30;
					var handStartX1 = (SCREEN_WIDTH - handWidth1) / 2;
					var pos1 = {
						x: handStartX1 + targetHandIndex * DEAL_SLOT_WIDTH + targetHandIndex * 30 + DEAL_SLOT_WIDTH / 2,
						y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2
					};
					var pos2;
					// Animate selectedCard
					tween(selectedCard, {
						x: pos1.x,
						y: pos1.y
					}, {
						duration: 200,
						easing: tween.quadOut
					});
					// Update selectedCard state
					selectedCard.isInPlay = false; // It's going to a hand slot
					if (originalCardPosition.area === 'player') {
						selectedCard.resetInvestment(); // Card moved from play area to hand - should not happen here, but for safety. Investment stops due to isInPlay=false
						gameLayer.removeChild(selectedCard);
						uiLayer.addChild(selectedCard);
					} else {
						// This is a hand-to-hand swap, timer should not be reset.
						gameState.playerHand[originalCardPosition.index] = null;
					}
					gameState.playerHand[targetHandIndex] = selectedCard;
					// Update swappedCard state
					if (originalCardPosition.area === 'player') {
						pos2 = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true);
						swappedCard.isInPlay = true;
						uiLayer.removeChild(swappedCard);
						gameLayer.addChild(swappedCard);
						gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = swappedCard;
					} else {
						// original was hand
						var origHandIndex = originalCardPosition.index;
						var handWidth2 = 5 * DEAL_SLOT_WIDTH + 4 * 30;
						var handStartX2 = (SCREEN_WIDTH - handWidth2) / 2;
						pos2 = {
							x: handStartX2 + origHandIndex * DEAL_SLOT_WIDTH + origHandIndex * 30 + DEAL_SLOT_WIDTH / 2,
							y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2
						};
						swappedCard.isInPlay = false;
						gameState.playerHand[origHandIndex] = swappedCard;
					}
					tween(swappedCard, {
						x: pos2.x,
						y: pos2.y
					}, {
						duration: 200,
						easing: tween.quadOut
					});
					selectedCard.calculateStats();
					swappedCard.calculateStats();
				} else {
					returnCardToOriginalPosition();
				}
			}
		} else {
			returnCardToOriginalPosition();
		}
		selectedCard = null;
		originalCardPosition = null;
		applyHandBonuses();
	}
};
function returnCardToOriginalPosition() {
	if (!selectedCard || !originalCardPosition) {
		return;
	}
	if (originalCardPosition.area === 'hand') {
		// Return to hand slot
		var handIndex = originalCardPosition.index;
		var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px
		var handStartX = (SCREEN_WIDTH - handWidth) / 2;
		var slotX = handStartX + handIndex * DEAL_SLOT_WIDTH + handIndex * 30 + DEAL_SLOT_WIDTH / 2;
		var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
		selectedCard.x = slotX;
		selectedCard.y = slotY;
		gameState.playerHand[handIndex] = selectedCard;
	} else if (originalCardPosition.area === 'player') {
		// Return to play area slot
		var pos = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true);
		selectedCard.x = pos.x;
		selectedCard.y = pos.y;
		gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = selectedCard;
	}
}
function createFloatingText(text, x, y, color, size) {
	var textOptions = {
		size: size || 40,
		fill: color || 0xffffff,
		weight: 800,
		stroke: 0x000000,
		strokeThickness: 0
	};
	// Add black outline for green level up text
	if (color === 0x00ff00) {
		textOptions.strokeThickness = 6;
		textOptions.size = (size || 40) * 2; // Make it twice as big
	}
	var floatingText = new Text2(text, textOptions);
	floatingText.anchor.set(0.5, 0.5);
	floatingText.x = x;
	floatingText.y = y;
	floatingText.alpha = 1;
	uiLayer.addChild(floatingText);
	// Use larger animation for important messages
	var animationDistance = size && size > 40 ? 120 : 80;
	var animationDuration = size && size > 40 ? 2000 : 1500;
	tween(floatingText, {
		y: y - animationDistance,
		alpha: 0
	}, {
		duration: animationDuration,
		easing: tween.quadOut,
		onFinish: function onFinish() {
			uiLayer.removeChild(floatingText);
		}
	});
}
function createExplosion(x, y, color) {
	var numParticles = 5;
	for (var i = 0; i < numParticles; i++) {
		var particle = LK.getAsset('explosionParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		particle.x = x;
		particle.y = y;
		particle.tint = color;
		particle.scale.set(0.5 + Math.random() * 0.5);
		var angle = Math.random() * Math.PI * 2;
		var distance = Math.random() * 50 + 20;
		var duration = 500 + Math.random() * 500;
		var targetX = x + Math.cos(angle) * distance;
		var targetY = y + Math.sin(angle) * distance;
		gameLayer.addChild(particle);
		tween(particle, {
			x: targetX,
			y: targetY,
			alpha: 0
		}, {
			duration: duration,
			easing: tween.quadOut,
			onFinish: function (p) {
				return function () {
					if (p.parent) {
						p.parent.removeChild(p);
					}
				};
			}(particle)
		});
	}
}
/**** 
* Main Game Loop
****/ 
game.update = function () {
	// Update tutorial system
	if (TutorialSystem.isActive) {
		TutorialSystem.update();
	}
	// Only run game logic when in playing state
	if (currentGameState !== 'playing') {
		if (currentGameState === 'start' && backgroundSuits.length > 0) {
			var speed = 0.5;
			var spacing = 400;
			// Calculate pattern dimensions
			var numCols = Math.ceil(SCREEN_WIDTH / spacing) + 3;
			var numRows = Math.ceil(SCREEN_HEIGHT / spacing) + 3;
			var patternWidth = numCols * spacing;
			var patternHeight = numRows * spacing;
			for (var i = 0; i < backgroundSuits.length; i++) {
				var suit = backgroundSuits[i];
				// Move diagonally
				suit.x += speed;
				suit.y += speed;
				// Wrap horizontally
				if (suit.x > SCREEN_WIDTH + spacing * 1.5) {
					suit.x -= patternWidth;
				}
				// Wrap vertically
				if (suit.y > SCREEN_HEIGHT + spacing * 1.5) {
					suit.y -= patternHeight;
				}
			}
		}
		return;
	}
	if (!gameReady) {
		return;
	}
	// Update wave spawning system
	WaveSystem.update();
	// 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();
	}
	// Tutorial Assistance: If an enemy on the player's side gets halfway, destroy it.
	if (TutorialSystem.isActive) {
		var assistancePathThreshold = 50; // Halfway down the path
		for (var i = activePlayerChips.length - 1; i >= 0; i--) {
			var chip = activePlayerChips[i];
			if (chip.pathProgress > assistancePathThreshold) {
				if (!TutorialSystem.assistanceMessageShown) {
					TutorialSystem.assistanceMessageShown = true;
					var message = "It looks like you could use some help! I've taken care of that enemy for you.\n\nThis helping hand is only available in the tutorial. Try adding more cards, merging them, and aiming for better poker hands to get stronger!";
					TutorialSystem.showMessage(message, null, function () {
						TutorialSystem.clearMessage();
					});
				}
				// Instantly destroy the chip to assist the player, preventing them from losing in the tutorial.
				chip.takeDamage(chip.health * 2);
			}
		}
	}
	// Update active mines
	for (var i = activeMines.length - 1; i >= 0; i--) {
		if (activeMines[i]) {
			activeMines[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
	// Update life displays
	while (gameState.playerLives < lastPlayerLives) {
		lastPlayerLives--;
		var heartToFade = playerLifeHearts[lastPlayerLives];
		if (heartToFade) {
			tween(heartToFade, {
				alpha: 0.2
			}, {
				duration: 500
			});
		}
	}
	while (gameState.aiLives < lastAiLives) {
		lastAiLives--;
		var heartToFade = aiLifeHearts[lastAiLives];
		if (heartToFade) {
			tween(heartToFade, {
				alpha: 0.2
			}, {
				duration: 500
			});
		}
	}
	if (gameState.playerLives <= 0) {
		showGameOver(false);
	} else if (gameState.aiLives <= 0) {
		showGameOver(true);
	}
	updateUI();
};
/**** 
* Game Over
****/ 
function resetGameAndReturnToMenu() {
	// This function now encapsulates all the logic to reset the game to its initial state.
	// 1. Remove all dynamically created game objects from the stage.
	[].concat(_toConsumableArray(activePlayerChips), _toConsumableArray(activeAIChips), _toConsumableArray(activeBullets), _toConsumableArray(activeMines)).forEach(function (obj) {
		if (obj.parent) {
			obj.parent.removeChild(obj);
		}
	});
	for (var r = 0; r < PLAY_AREA_ROWS; r++) {
		for (var c = 0; c < PLAY_AREA_COLS; c++) {
			var pCard = gameState.playerPlayArea[r][c];
			if (pCard && pCard.parent) {
				pCard.parent.removeChild(pCard);
			}
			var aCard = gameState.aiPlayArea[r][c];
			if (aCard && aCard.parent) {
				aCard.parent.removeChild(aCard);
			}
		}
	}
	gameState.playerHand.forEach(function (card) {
		if (card && card.parent) {
			card.parent.removeChild(card);
		}
	});
	playerLifeHearts.forEach(function (h) {
		if (h.parent) {
			h.parent.removeChild(h);
		}
	});
	aiLifeHearts.forEach(function (h) {
		if (h.parent) {
			h.parent.removeChild(h);
		}
	});
	playerHandNameTexts.forEach(function (t) {
		if (t && t.parent) {
			t.parent.removeChild(t);
		}
	});
	if (opponentNameText && opponentNameText.parent) {
		opponentNameText.parent.removeChild(opponentNameText);
	}
	if (playerNameText && playerNameText.parent) {
		playerNameText.parent.removeChild(playerNameText);
	}
	slotIndicators.forEach(function (indicator) {
		if (indicator.parent) {
			indicator.parent.removeChild(indicator);
		}
	});
	slotIndicators = [];
	// 2. Clear all tracking arrays.
	activePlayerChips = [];
	activeAIChips = [];
	activeBullets = [];
	activeMines = [];
	playerLifeHearts = [];
	aiLifeHearts = [];
	playerHandNameTexts = [];
	opponentNameText = null;
	playerNameText = null;
	// 3. Reset game state variables.
	gameState.playerChips = 200;
	gameState.aiChips = 200;
	gameState.playerLives = 3;
	gameState.aiLives = 3;
	gameState.isPlayerTurn = true;
	gameState.dealCost = 25;
	gameState.dealCount = 0;
	gameState.playerDeck = [];
	gameState.playerHand = [];
	gameState.playerPlayArea = [];
	gameState.aiDeck = [];
	gameState.aiPlayArea = [];
	// 4. Reset game systems.
	WaveSystem.waveNumber = 1;
	WaveSystem.waveTimer = 0;
	WaveSystem.bossSpawned = false;
	WaveSystem.playerBossDefeated = false;
	WaveSystem.aiBossDefeated = false;
	AISystem.thinkTimer = 0;
	// 5. Reset other global variables.
	lastPlayerLives = 0;
	lastAiLives = 0;
	selectedCard = null;
	isDragging = false;
	originalCardPosition = null;
	// 6. Hide persistent UI.
	gameElements.forEach(function (el) {
		el.visible = false;
	});
	// 7. Return to the main menu.
	createStartScreen(true);
}
function showResultsScreen() {
	var resultsContainer = new Container();
	uiLayer.addChild(resultsContainer);
	// Dark overlay
	var bg = LK.getAsset('card', {
		width: SCREEN_WIDTH,
		height: SCREEN_HEIGHT,
		anchorX: 0,
		anchorY: 0
	});
	bg.tint = 0x000000;
	bg.alpha = 0.7;
	resultsContainer.addChild(bg);
	var title = new Text2('VICTORY!', {
		size: 180,
		fill: 0xffd700,
		weight: 'bold',
		stroke: 0x000000,
		strokeThickness: 10
	});
	title.anchor.set(0.5, 0.5);
	title.x = SCREEN_WIDTH / 2;
	title.y = 300;
	resultsContainer.addChild(title);
	// Calculate Battle Rating
	var oldRating = storage.battleRating;
	var waveBonus = (WaveSystem.waveNumber - 1) * 5;
	var livesBonus = (gameState.playerLives - gameState.aiLives) * 10;
	var winBonus = 25;
	var ratingChange = waveBonus + livesBonus + winBonus;
	ratingChange = Math.max(5, ratingChange); // Minimum 5 rating gain on win
	var newRating = oldRating + ratingChange;
	storage.battleRating = newRating;
	// Display Rating Calculation
	var yPos = 600;
	var yStep = 120;
	var ySubStep = 90;
	var oldRatingText = new Text2('Previous Rating: ' + oldRating, {
		size: 80,
		fill: 0xffffff,
		weight: 'bold'
	});
	oldRatingText.anchor.set(0.5, 0.5);
	oldRatingText.x = SCREEN_WIDTH / 2;
	oldRatingText.y = yPos;
	resultsContainer.addChild(oldRatingText);
	yPos += yStep;
	var waveBonusText = new Text2('Wave Bonus (Wave ' + WaveSystem.waveNumber + '): +' + waveBonus, {
		size: 70,
		fill: 0x88ff88,
		weight: 'normal'
	});
	waveBonusText.anchor.set(0.5, 0.5);
	waveBonusText.x = SCREEN_WIDTH / 2;
	waveBonusText.y = yPos;
	resultsContainer.addChild(waveBonusText);
	yPos += ySubStep;
	var livesBonusText;
	if (livesBonus >= 0) {
		livesBonusText = new Text2('Performance Bonus: +' + livesBonus, {
			size: 70,
			fill: 0x88ff88,
			weight: 'normal'
		});
	} else {
		livesBonusText = new Text2('Performance Bonus: ' + livesBonus, {
			size: 70,
			fill: 0xff8888,
			weight: 'normal'
		});
	}
	livesBonusText.anchor.set(0.5, 0.5);
	livesBonusText.x = SCREEN_WIDTH / 2;
	livesBonusText.y = yPos;
	resultsContainer.addChild(livesBonusText);
	yPos += ySubStep;
	var winBonusText = new Text2('Victory Bonus: +' + winBonus, {
		size: 70,
		fill: 0x88ff88,
		weight: 'normal'
	});
	winBonusText.anchor.set(0.5, 0.5);
	winBonusText.x = SCREEN_WIDTH / 2;
	winBonusText.y = yPos;
	resultsContainer.addChild(winBonusText);
	yPos += yStep + 20;
	var lineBreak = LK.getAsset('lineBreak', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	lineBreak.x = SCREEN_WIDTH / 2;
	lineBreak.y = yPos;
	lineBreak.scale.set(0.8);
	resultsContainer.addChild(lineBreak);
	yPos += yStep;
	var newRatingText = new Text2('New Rating: ' + newRating, {
		size: 100,
		fill: 0xffffff,
		weight: 'bold'
	});
	newRatingText.anchor.set(0.5, 0.5);
	newRatingText.x = SCREEN_WIDTH / 2;
	newRatingText.y = yPos;
	resultsContainer.addChild(newRatingText);
	// Create chest container
	var chestContainer = new Container();
	chestContainer.x = SCREEN_WIDTH / 2;
	chestContainer.y = 1600;
	resultsContainer.addChild(chestContainer);
	// Add small chest
	var chest = LK.getAsset('smallChest', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	chest.scale.set(0.01);
	chestContainer.addChild(chest);
	// Tap to open text
	var tapToOpenText = new Text2('Tap to open', {
		size: 60,
		fill: 0xffffff,
		weight: 'bold',
		stroke: 0x000000,
		strokeThickness: 4
	});
	tapToOpenText.anchor.set(0.5, 0.5);
	tapToOpenText.y = 120;
	tapToOpenText.visible = false;
	chestContainer.addChild(tapToOpenText);
	// Make chest interactive
	chestContainer.interactive = true;
	chestContainer.hitArea = new Rectangle(-150, -150, 300, 300);
	var chestOpened = false;
	var moneyReward = 0;
	// Animate chest in with bounce
	tween(chest, {
		scaleX: 1.5,
		scaleY: 1.5
	}, {
		duration: 800,
		easing: tween.elasticOut,
		onFinish: function onFinish() {
			tapToOpenText.visible = true;
			// Pulse animation for tap to open text
			function pulseText() {
				if (!tapToOpenText.parent || chestOpened) {
					return;
				}
				tween(tapToOpenText, {
					scaleX: 1.1,
					scaleY: 1.1
				}, {
					duration: 600,
					easing: tween.easeInOut,
					onFinish: function onFinish() {
						if (!tapToOpenText.parent || chestOpened) {
							return;
						}
						tween(tapToOpenText, {
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 600,
							easing: tween.easeInOut,
							onFinish: pulseText
						});
					}
				});
			}
			pulseText();
		}
	});
	chestContainer.down = function () {
		if (chestOpened) {
			return;
		}
		chestOpened = true;
		tapToOpenText.visible = false;
		// Wiggle animation
		tween(chest, {
			rotation: -0.1
		}, {
			duration: 100,
			easing: tween.linear,
			onFinish: function onFinish() {
				tween(chest, {
					rotation: 0.1
				}, {
					duration: 100,
					easing: tween.linear,
					onFinish: function onFinish() {
						tween(chest, {
							rotation: 0
						}, {
							duration: 100,
							easing: tween.linear,
							onFinish: function onFinish() {
								// Flash screen white
								LK.effects.flashScreen(0xffffff, 300);
								// Replace with open chest
								chestContainer.removeChild(chest);
								var openChest = LK.getAsset('smallChestOpen', {
									anchorX: 0.5,
									anchorY: 0.5
								});
								openChest.scale.set(1.5);
								chestContainer.addChild(openChest);
								// Generate random money reward
								moneyReward = Math.floor(Math.random() * 151) + 100; // 100-250
								var startMoney = storage.money;
								var targetMoney = startMoney + moneyReward;
								// Money text animation
								var moneyText = new Text2('$' + moneyReward, {
									size: 150,
									fill: 0xffffff,
									weight: 'bold',
									stroke: 0x000000,
									strokeThickness: 8
								});
								moneyText.anchor.set(0.5, 0.5);
								moneyText.y = -50;
								moneyText.scale.set(0.1);
								moneyText.alpha = 0;
								chestContainer.addChild(moneyText);
								// Animate scale property directly to avoid potential proxy issues with Text2 objects
								tween(moneyText.scale, {
									x: 1,
									y: 1
								}, {
									duration: 500,
									easing: tween.backOut
								});
								// Animate other properties on the text object itself
								tween(moneyText, {
									alpha: 1,
									y: -100
								}, {
									duration: 500,
									easing: tween.backOut,
									onFinish: function onFinish() {
										// Rolling number animation
										var rollDuration = 1000;
										var startTime = Date.now();
										var rollInterval = LK.setInterval(function () {
											var elapsed = Date.now() - startTime;
											var progress = Math.min(elapsed / rollDuration, 1);
											var easedProgress = 1 - Math.pow(1 - progress, 3); // Cubic ease out
											var currentValue = Math.floor(startMoney + moneyReward * easedProgress);
											storage.money = currentValue;
											if (progress >= 1) {
												LK.clearInterval(rollInterval);
												storage.money = targetMoney;
												// Show tap to continue
												var tapToContinueText = new Text2('Tap to continue', {
													size: 70,
													fill: 0x000000,
													weight: 'bold'
												});
												tapToContinueText.anchor.set(0.5, 0.5);
												tapToContinueText.y = 200;
												chestContainer.addChild(tapToContinueText);
												// Update chest interaction
												chestContainer.down = function () {
													tween(resultsContainer, {
														alpha: 0
													}, {
														duration: 300,
														onFinish: function onFinish() {
															if (resultsContainer.parent) {
																resultsContainer.parent.removeChild(resultsContainer);
															}
															resetGameAndReturnToMenu();
														}
													});
												};
											}
										}, 16); // ~60fps
									}
								});
							}
						});
					}
				});
			}
		});
	};
	// Animate the screen in
	resultsContainer.alpha = 0;
	tween(resultsContainer, {
		alpha: 1
	}, {
		duration: 500
	});
}
function showGameOver(playerWon) {
	// Stop all game action by changing the state. The main update loop will halt.
	LK.stopMusic();
	currentGameState = 'gameover_transition';
	// Animate the victory or defeat logo.
	var logoAssetId = playerWon ? 'victoryLogo' : 'defeatLogo';
	var endLogo = LK.getAsset(logoAssetId, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: SCREEN_WIDTH / 2,
		y: SCREEN_HEIGHT / 2
	});
	endLogo.scale.set(0.01);
	uiLayer.addChild(endLogo);
	tween(endLogo, {
		scaleX: 1,
		scaleY: 1
	}, {
		duration: 1200,
		easing: tween.elasticOut,
		onFinish: function onFinish() {
			// After the animation, wait a moment, then transition.
			LK.setTimeout(function () {
				if (endLogo.parent) {
					endLogo.parent.removeChild(endLogo);
				}
				if (playerWon) {
					if (TutorialSystem.isActive) {
						// In tutorial, we skip the normal results and go straight to reset/menu to continue tutorial
						resetGameAndReturnToMenu();
					} else {
						showResultsScreen();
					}
				} else {
					if (TutorialSystem.isActive) {
						// Player lost tutorial, let them retry from beginning
						storage.tutorialCompleted = false;
					}
					resetGameAndReturnToMenu();
				}
			}, 1500);
		}
	});
}
/**** 
* Utility Functions
****/ 
function formatNumberWithSuffix(number) {
	var num = Math.round(number);
	if (num < 1000) {
		return num.toString();
	}
	if (num < 1000000) {
		return (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K';
	}
	if (num < 1000000000) {
		return (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M';
	}
	if (num < 1000000000000) {
		return (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'B';
	}
	return (num / 1000000000000).toFixed(1).replace(/\.0$/, '') + 'T';
}
function clearPlayerStorage() {
	storage.battleRating = 0;
	storage.money = 0;
	storage.equippedMods = null;
	storage.ownedMods = null;
	storage.randomModPrice = 300;
	storage.tutorialCompleted = false; // Also reset tutorial progress
	// Also reset in-memory ModSystem if it's already initialized
	ModSystem.equippedMods = {
		hearts: null,
		diamonds: null,
		clubs: null,
		spades: null
	};
	ModSystem.ownedMods = {};
	createFloatingText("Player Storage Cleared!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 100);
}
var TutorialSystem = {
	isActive: false,
	step: 0,
	overlay: null,
	messageBox: null,
	pulsingElement: null,
	isWaitingForTap: false,
	isWaitingForDrag: false,
	isWaitingForMerge: false,
	isWaitingForChipKill: false,
	isWaitingForJokerMerge: false,
	nextStepCallback: null,
	assistanceMessageShown: false,
	startScreenItems: {},
	registerStartScreenElements: function registerStartScreenElements(items) {
		this.startScreenItems = items;
	},
	start: function start() {
		this.isActive = true;
		this.step = 0;
		this.assistanceMessageShown = false;
	},
	startInGameTutorial: function startInGameTutorial() {
		this.isActive = true;
		this.step = 1;
		this.assistanceMessageShown = false;
		this.advanceStep();
	},
	update: function update() {
		if (!this.isActive) return;
		if (this.isWaitingForDrag) {
			for (var r = 0; r < PLAY_AREA_ROWS; r++) {
				for (var c = 0; c < PLAY_AREA_COLS; c++) {
					if (gameState.playerPlayArea[r][c]) {
						this.isWaitingForDrag = false;
						this.advanceStep();
						return;
					}
				}
			}
		}
		if (this.isWaitingForMerge) {
			var mergeCompleted = false;
			// Check play area for a leveled-up card
			for (var r = 0; r < PLAY_AREA_ROWS; r++) {
				for (var c = 0; c < PLAY_AREA_COLS; c++) {
					if (gameState.playerPlayArea[r][c] && gameState.playerPlayArea[r][c].level >= 2) {
						mergeCompleted = true;
						break;
					}
				}
				if (mergeCompleted) break;
			}
			// If not found in play area, check the hand
			if (!mergeCompleted) {
				for (var i = 0; i < gameState.playerHand.length; i++) {
					if (gameState.playerHand[i] && gameState.playerHand[i].level >= 2) {
						mergeCompleted = true;
						break;
					}
				}
			}
			if (mergeCompleted) {
				this.isWaitingForMerge = false;
				this.advanceStep();
				return;
			}
		}
		if (this.isWaitingForJokerMerge) {
			var hasLevel3PlusCard = false;
			var level2PlusCardCount = 0;
			// Check play area for cards
			for (var r = 0; r < PLAY_AREA_ROWS; r++) {
				for (var c = 0; c < PLAY_AREA_COLS; c++) {
					var card = gameState.playerPlayArea[r][c];
					if (card) {
						if (card.level >= 3) {
							hasLevel3PlusCard = true;
						}
						if (card.level >= 2) {
							level2PlusCardCount++;
						}
					}
				}
			}
			// Also check player's hand
			for (var i = 0; i < gameState.playerHand.length; i++) {
				var card = gameState.playerHand[i];
				if (card) {
					if (card.level >= 3) {
						hasLevel3PlusCard = true;
					}
					if (card.level >= 2) {
						level2PlusCardCount++;
					}
				}
			}
			if (hasLevel3PlusCard || level2PlusCardCount >= 2) {
				this.isWaitingForJokerMerge = false;
				this.advanceStep();
				return;
			}
		}
		if (this.isWaitingForChipKill) {
			if (activePlayerChips.length === 0) {
				this.isWaitingForChipKill = false;
				this.advanceStep();
			}
		}
	},
	advanceStep: function advanceStep() {
		this.clearMessage();
		this.step++;
		switch (this.step) {
			case 2:
				this.explainDeal();
				break;
			case 3:
				this.waitForDeal();
				break;
			case 4:
				this.explainDrag();
				break;
			case 5:
				this.waitForDrag();
				break;
			case 6:
				this.spawnFirstEnemy();
				break;
			case 7:
				this.waitForKill();
				break;
			case 8:
				this.explainMerge();
				break;
			case 9:
				this.waitForMerge();
				break;
			case 10:
				this.explainJoker();
				break;
			case 11:
				this.instructJokerMerge();
				break;
			case 12:
				this.startWaves();
				break;
			case 13:
				this.explainPokerHands();
				break;
			case 14:
				this.explainDiscard();
				break;
			case 15:
				this.guaranteedWin();
				break;
			case 16:
				this.guideToShop();
				break;
			case 17:
				this.guideToRandomMod();
				break;
			case 18:
				this.guideToModsScreen();
				break;
			case 19:
				this.explainEquipMod();
				break;
			case 20:
				this.completeTutorial();
				break;
		}
	},
	showMessage: function showMessage(text, elementToPulse, waitForTapCallback, isPostGame) {
		this.clearMessage();
		this.overlay = new Container();
		if (!isPostGame) this.overlay.interactive = true;
		this.overlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
		var bg = LK.getAsset('card', {
			width: SCREEN_WIDTH,
			height: SCREEN_HEIGHT,
			anchorX: 0,
			anchorY: 0
		});
		bg.tint = 0x000000;
		bg.alpha = 0.7;
		this.overlay.addChild(bg);
		uiLayer.addChild(this.overlay);
		this.messageBox = new Text2(text, {
			size: 70,
			fill: 0xffffff,
			weight: 'bold',
			stroke: 0x000000,
			strokeThickness: 5,
			align: 'center',
			wordWrap: true,
			wordWrapWidth: SCREEN_WIDTH - 200
		});
		this.messageBox.anchor.set(0.5, 0.5);
		this.messageBox.x = SCREEN_WIDTH / 2;
		this.messageBox.y = isPostGame ? SCREEN_HEIGHT - 650 : SCREEN_HEIGHT / 2;
		this.overlay.addChild(this.messageBox);
		if (elementToPulse) {
			this.pulsingElement = elementToPulse;
			if (elementToPulse.parent) {
				this.pulsingElementOriginalParent = elementToPulse.parent;
				this.overlay.addChild(elementToPulse);
			}
			this.pulseAnimation(elementToPulse);
		}
		if (waitForTapCallback) {
			this.isWaitingForTap = true;
			this.nextStepCallback = waitForTapCallback;
			this.overlay.down = function () {
				if (TutorialSystem.isWaitingForTap) {
					TutorialSystem.isWaitingForTap = false;
					TutorialSystem.nextStepCallback();
				}
			};
		}
	},
	clearMessage: function clearMessage() {
		if (this.pulsingElement) {
			tween.stop(this.pulsingElement);
			if (this.pulsingElement.scale) tween.stop(this.pulsingElement.scale);
			if (this.pulsingElement.originalScaleX) {
				this.pulsingElement.scale.set(this.pulsingElement.originalScaleX, this.pulsingElement.originalScaleY);
			}
			if (this.pulsingElementOriginalParent) {
				this.pulsingElementOriginalParent.addChild(this.pulsingElement);
				this.pulsingElementOriginalParent = null;
			}
			this.pulsingElement = null;
		}
		if (this.overlay) {
			if (this.overlay.parent) {
				this.overlay.parent.removeChild(this.overlay);
			}
			this.overlay = null;
			this.messageBox = null;
		}
	},
	pulseAnimation: function pulseAnimation(element) {
		var self = this;
		var originalScaleX = element.originalScaleX || (element.scale ? element.scale.x : 1);
		var originalScaleY = element.originalScaleY || (element.scale ? element.scale.y : 1);
		element.originalScaleX = originalScaleX;
		element.originalScaleY = originalScaleY;
		tween(element.scale, {
			x: originalScaleX * 1.1,
			y: originalScaleY * 1.1
		}, {
			duration: 700,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				if (element.parent) {
					tween(element.scale, {
						x: originalScaleX,
						y: originalScaleY
					}, {
						duration: 700,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							if (element.parent) {
								self.pulseAnimation(element);
							}
						}
					});
				}
			}
		});
	},
	explainDeal: function explainDeal() {
		this.showMessage("This is the deal button. Tap it to get a card for a small price.", discardAreaContainer, this.advanceStep.bind(this));
	},
	waitForDeal: function waitForDeal() {
		var originalDown = discardAreaContainer.down;
		discardAreaContainer.down = function () {
			if (gameState.playerChips >= gameState.dealCost) {
				originalDown();
				TutorialSystem.advanceStep();
				discardAreaContainer.down = originalDown;
			}
		};
	},
	explainDrag: function explainDrag() {
		var self = this;
		// Wait for the card's deal animation to finish before pulsing it.
		// The animation is ~400ms, so we wait 500ms to be safe.
		LK.setTimeout(function () {
			var cardInHand = gameState.playerHand.find(function (c) {
				return c !== null;
			});
			if (cardInHand) {
				self.showMessage("Great! Now drag your card to one of the empty slots on your side of the board.", cardInHand, self.advanceStep.bind(self));
			}
		}, 500);
	},
	waitForDrag: function waitForDrag() {
		this.isWaitingForDrag = true;
	},
	explainDiscard: function explainDiscard() {
		this.showMessage("You can also drag cards to the deal button to sell them for a refund.\n\nTap to continue.", discardAreaContainer, this.advanceStep.bind(this));
	},
	spawnFirstEnemy: function spawnFirstEnemy() {
		this.showMessage("Excellent! A card on the board will automatically attack enemies. Let's see it in action!", null, function () {
			TutorialSystem.clearMessage();
			ChipSpawner.spawnChip(1, true);
			TutorialSystem.advanceStep();
		});
	},
	waitForKill: function waitForKill() {
		this.isWaitingForChipKill = true;
	},
	explainMerge: function explainMerge() {
		this.showMessage("Well done! You can level up cards by merging them. Drag a card onto another of the SAME SUIT or SAME VALUE to merge them.", null, function () {
			TutorialSystem.clearMessage();
			if (gameState.playerDeck.length < 2) gameState.playerDeck = CardSystem.createDeck();
			var cardData1 = {
				suit: 'hearts',
				value: '5',
				id: 'hearts_5'
			};
			var cardData2 = {
				suit: 'hearts',
				value: '8',
				id: 'hearts_8'
			};
			placeCardInHand(new Card(cardData1), 1);
			placeCardInHand(new Card(cardData2), 3);
			TutorialSystem.advanceStep();
		});
	},
	waitForMerge: function waitForMerge() {
		this.isWaitingForMerge = true;
	},
	explainJoker: function explainJoker() {
		this.showMessage("Fantastic! Jokers are special. They can merge with ANY card to raise its level.", null, function () {
			TutorialSystem.clearMessage();
			// Place a Joker in hand
			var jokerData = {
				suit: 'joker',
				value: 'black',
				id: 'joker_black'
			};
			placeCardInHand(new Card(jokerData), 2); // Place it in the middle of the hand
			TutorialSystem.advanceStep();
		});
	},
	instructJokerMerge: function instructJokerMerge() {
		var self = this;
		var jokerInHand = gameState.playerHand[2];
		if (jokerInHand) {
			var message = "Now drag the Joker from your hand onto a card on your board to level it up!";
			// We pulse the joker, as that's the one to drag.
			this.showMessage(message, jokerInHand, function () {
				self.clearMessage();
				self.isWaitingForJokerMerge = true;
			});
		} else {
			// Failsafe
			this.advanceStep();
		}
	},
	startWaves: function startWaves() {
		this.showMessage("Perfect! Merging is key to victory. Now, a real wave is coming. The AI will also start playing.", null, function () {
			TutorialSystem.clearMessage();
			gameReady = true;
			AISystem.thinkDelay = 240;
			TutorialSystem.advanceStep();
		});
	},
	explainPokerHands: function explainPokerHands() {
		LK.setTimeout(function () {
			TutorialSystem.showMessage("Placing cards in rows creates poker hands, like 'pairs' or 'straights', giving them a massive damage boost!", null, function () {
				TutorialSystem.clearMessage();
				TutorialSystem.advanceStep();
			});
		}, 8000);
	},
	guaranteedWin: function guaranteedWin() {},
	guideToShop: function guideToShop() {
		var items = this.startScreenItems;
		var message = "You won! As a reward, you get a FREE mod. Go to the shop to claim it.";
		this.setupPostGameGuide(message, items.shop.button, [items.battle.button, items.mods.button]);
		var shopClickHandler = function shopClickHandler() {
			items.shop.down();
			TutorialSystem.clearMessage();
			[items.battle.button, items.mods.button, items.shop.button].forEach(function (b) {
				b.interactive = true;
				b.alpha = 1;
			});
			TutorialSystem.advanceStep();
		};
		items.shop.button.down = shopClickHandler;
		items.shop.icon.down = shopClickHandler;
	},
	guideToRandomMod: function guideToRandomMod() {
		var items = this.startScreenItems.shopItems;
		var message = "Tap the glowing item to get your free random mod!";
		var originalPrice = storage.randomModPrice;
		storage.randomModPrice = 0;
		items.priceText.setText('$0');
		this.showMessage(message, null);
		if (this.overlay) {
			// Hide the dark background and make overlay non-interactive to allow clicks on shop
			this.overlay.getChildAt(0).visible = false;
			this.overlay.interactive = false;
		}
		items.overlay.interactive = items.asset.interactive = true;
		var originalBuy = items.buyButtonDown;
		items.overlay.down = items.asset.down = function () {
			items.overlay.down = items.asset.down = function () {}; // Prevent multi-click
			originalBuy();
			storage.randomModPrice = originalPrice;
			LK.setTimeout(function () {
				TutorialSystem.clearMessage();
				TutorialSystem.advanceStep();
			}, 3500);
		};
	},
	guideToModsScreen: function guideToModsScreen() {
		var items = this.startScreenItems;
		items.shopContainer.visible = false;
		var message = "Awesome! Now let's equip your new mod. Go to the mods screen.";
		this.setupPostGameGuide(message, items.mods.button, [items.battle.button, items.shop.button]);
		var modsClickHandler = function modsClickHandler() {
			items.mods.down();
			TutorialSystem.clearMessage();
			[items.battle.button, items.mods.button, items.shop.button].forEach(function (b) {
				b.interactive = true;
				b.alpha = 1;
			});
			TutorialSystem.advanceStep();
		};
		items.mods.button.down = modsClickHandler;
		items.mods.icon.down = modsClickHandler;
	},
	explainEquipMod: function explainEquipMod() {
		// First, manually refresh the visual state of all mods in the grid
		// because the grid was created before the player owned the new mod.
		var modsContainer = this.startScreenItems.modsContainer;
		// The gridContainer is the last major element added to the modsContainer.
		var gridContainer = modsContainer.children[modsContainer.children.length - 1];
		if (gridContainer && gridContainer.children.length > 0) {
			var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod'];
			var childrenPerMod = 4; // Assumes cell, shadow, mod asset, name text
			for (var modIndex = 0; modIndex < suitModAssets.length; modIndex++) {
				var assetId = suitModAssets[modIndex];
				var isOwned = ModSystem.isModOwned(assetId);
				var cellIndex = modIndex * childrenPerMod;
				var modAssetIndex = cellIndex + 2;
				if (gridContainer.children[cellIndex] && gridContainer.children[modAssetIndex]) {
					var cell = gridContainer.children[cellIndex];
					var modAsset = gridContainer.children[modAssetIndex];
					if (isOwned) {
						modAsset.tint = 0xffffff;
						modAsset.alpha = 1.0;
						cell.tint = 0xffffff;
					} else {
						modAsset.tint = 0x555555;
						modAsset.alpha = 0.6;
						cell.tint = 0x888888;
					}
				}
			}
		}
		var message = "This screen shows all mods. Tap your new mod, then tap 'Equip' to use it in battle!";
		this.showMessage(message, null, function () {
			TutorialSystem.clearMessage();
			var originalEquip = ModSystem.equipMod;
			ModSystem.equipMod = function (modAssetId) {
				originalEquip.call(ModSystem, modAssetId);
				TutorialSystem.advanceStep();
				ModSystem.equipMod = originalEquip;
			};
		});
		// Make the tutorial overlay transparent so the mods screen is fully visible.
		if (this.overlay) {
			this.overlay.getChildAt(0).visible = false;
		}
	},
	completeTutorial: function completeTutorial() {
		this.showMessage("Tutorial complete! You're ready for battle. Good luck!", null, function () {
			TutorialSystem.clearMessage();
			storage.tutorialCompleted = true;
			TutorialSystem.isActive = false;
			TutorialSystem.startScreenItems.modsContainer.visible = false;
			TutorialSystem.startScreenItems.battle.down();
		});
	},
	setupPostGameGuide: function setupPostGameGuide(message, elementToPulse, elementsToDisable) {
		this.clearMessage();
		this.showMessage(message, null, null, true); // isPostGame = true
		var items = this.startScreenItems;
		// Disable other buttons and their icons
		elementsToDisable.forEach(function (el) {
			el.interactive = false;
			el.alpha = 0.5;
			if (el === items.battle.button) {
				items.battle.icon.interactive = false;
				items.battle.icon.alpha = 0.5;
			} else if (el === items.mods.button) {
				items.mods.icon.interactive = false;
				items.mods.icon.alpha = 0.5;
			} else if (el === items.shop.button) {
				items.shop.icon.interactive = false;
				items.shop.icon.alpha = 0.5;
			}
		});
		// Enable the target button and its icon
		elementToPulse.interactive = true;
		elementToPulse.alpha = 1.0;
		var iconToPulse = null;
		if (elementToPulse === items.shop.button) {
			iconToPulse = items.shop.icon;
		} else if (elementToPulse === items.mods.button) {
			iconToPulse = items.mods.icon;
		}
		if (iconToPulse) {
			iconToPulse.interactive = true;
			iconToPulse.alpha = 1.0;
		}
		// Bring the container with all buttons on top of the overlay
		if (this.overlay && elementToPulse.parent && elementToPulse.parent.parent) {
			elementToPulse.parent.parent.addChild(elementToPulse.parent);
		}
		this.pulsingElement = elementToPulse;
		this.pulseAnimation(this.pulsingElement);
	}
};
function placeCardInHand(card, index) {
	var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30;
	var handStartX = (SCREEN_WIDTH - handWidth) / 2;
	var slotX = handStartX + index * DEAL_SLOT_WIDTH + index * 30 + DEAL_SLOT_WIDTH / 2;
	var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2;
	card.activate(slotX, slotY, false, true);
	uiLayer.addChild(card);
	gameState.playerHand[index] = card;
}
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);
	}
}
var background = LK.getAsset('background', {
	anchorX: 0.5,
	anchorY: 0
});
background.x = SCREEN_WIDTH / 2;
background.y = 50;
background.visible = false;
gameLayer.addChild(background);
gameElements.push(background);
// Place two chipracks side by side in the center at the top of the screen
var chipRack1 = LK.getAsset('chipRack', {
	anchorX: 0.5,
	anchorY: 0
});
var rackWidth = chipRack1.width;
var rackHeight = chipRack1.height;
chipRack1.x = SCREEN_WIDTH / 2 - rackWidth / 2;
chipRack1.y = 60 - rackHeight * 0.75 + 30;
chipRack1.visible = false;
gameLayer.addChild(chipRack1);
gameElements.push(chipRack1);
var chipRack2 = LK.getAsset('chipRack', {
	anchorX: 0.5,
	anchorY: 0
});
chipRack2.x = SCREEN_WIDTH / 2 + rackWidth / 2;
chipRack2.y = 60 - rackHeight * 0.75 + 30;
chipRack2.visible = false;
gameLayer.addChild(chipRack2);
gameElements.push(chipRack2);
var border = LK.getAsset('border', {
	anchorX: 0.5,
	anchorY: 0.5
});
border.x = SCREEN_WIDTH / 2;
border.y = SCREEN_HEIGHT / 2;
border.visible = false;
gameLayer.addChild(border);
gameElements.push(border);
var bottomBar = LK.getAsset('bottomBar', {
	anchorX: 0.5,
	anchorY: 1
});
bottomBar.x = SCREEN_WIDTH / 2;
bottomBar.y = SCREEN_HEIGHT;
bottomBar.visible = false;
gameLayer.addChild(bottomBar);
gameElements.push(bottomBar);
// Show start screen instead of initializing game immediately
createStartScreen();
// Add active chips container below the bottom bar
gameLayer.addChildAt(activePlayerChipsContainer, gameLayer.getChildIndex(bottomBar));
gameLayer.addChildAt(activeAIChipsContainer, gameLayer.getChildIndex(bottomBar));
// Add chipStack asset above chips display
var chipStack = LK.getAsset('chipStack', {
	anchorX: 0.5,
	anchorY: 1
});
chipStack.x = playerChipsText.x + playerChipsText.width / 2;
chipStack.y = playerChipsText.y - 10;
chipStack.visible = false;
uiLayer.addChild(chipStack);
gameElements.push(chipStack);
;
;