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

/**** 
* Classes
****/ 
var AchievementSystem = Container.expand(function () {
	var self = Container.call(this);
	// Achievement definitions
	self.achievements = {
		firstBlackjackWin: {
			unlocked: false,
			title: "First Victory",
			description: "Win your first hand of Blackjack",
			reward: 100
		},
		cascade5x: {
			unlocked: false,
			title: "Cascade Master",
			description: "Get a 5x cascade in slots",
			reward: 250
		},
		reach10k: {
			unlocked: false,
			title: "High Roller",
			description: "Reach $10,000",
			reward: 500
		},
		bigSpender: {
			unlocked: false,
			title: "Big Spender",
			description: "Bet $500 in one hand",
			reward: 200
		},
		luckyStreak: {
			unlocked: false,
			title: "Lucky Streak",
			description: "Win 3 hands in a row",
			reward: 300
		}
	};
	// Load achievements from storage
	var savedAchievements = storage.achievements || {};
	for (var key in savedAchievements) {
		if (self.achievements[key]) {
			self.achievements[key].unlocked = savedAchievements[key];
		}
	}
	self.checkAchievement = function (type, value) {
		var achievement = self.achievements[type];
		if (!achievement || achievement.unlocked) return;
		var shouldUnlock = false;
		switch (type) {
			case 'firstBlackjackWin':
				shouldUnlock = value === true;
				break;
			case 'cascade5x':
				shouldUnlock = value >= 5;
				break;
			case 'reach10k':
				shouldUnlock = value >= 10000;
				break;
			case 'bigSpender':
				shouldUnlock = value >= 500;
				break;
			case 'luckyStreak':
				shouldUnlock = value >= 3;
				break;
		}
		if (shouldUnlock) {
			self.unlockAchievement(type);
		}
	};
	self.unlockAchievement = function (type) {
		var achievement = self.achievements[type];
		if (achievement.unlocked) return;
		achievement.unlocked = true;
		// Save to storage - only save the unlocked status as literals
		var achievementsToSave = {};
		for (var key in self.achievements) {
			achievementsToSave[key] = self.achievements[key].unlocked;
		}
		storage.achievements = achievementsToSave;
		// Show achievement notification
		self.showAchievementNotification(achievement);
		// Award money
		playerMoney += achievement.reward;
		updateMoneyDisplay();
	};
	self.showAchievementNotification = function (achievement) {
		var notification = new Text2('🏆 ACHIEVEMENT UNLOCKED! 🏆', {
			size: 48,
			fill: '#FFD700',
			font: "'Arial Black', Arial, sans-serif"
		});
		notification.anchor.set(0.5, 0.5);
		notification.x = 1024;
		notification.y = 400;
		notification.alpha = 0;
		notification.scaleX = 0.5;
		notification.scaleY = 0.5;
		game.addChild(notification);
		var titleText = new Text2(achievement.title, {
			size: 36,
			fill: '#FFFFFF',
			font: "'Arial Black', Arial, sans-serif"
		});
		titleText.anchor.set(0.5, 0.5);
		titleText.x = 1024;
		titleText.y = 480;
		titleText.alpha = 0;
		titleText.scaleX = 0.5;
		titleText.scaleY = 0.5;
		game.addChild(titleText);
		var rewardText = new Text2('+$' + achievement.reward, {
			size: 32,
			fill: '#00FF00',
			font: "'Arial Black', Arial, sans-serif"
		});
		rewardText.anchor.set(0.5, 0.5);
		rewardText.x = 1024;
		rewardText.y = 540;
		rewardText.alpha = 0;
		rewardText.scaleX = 0.5;
		rewardText.scaleY = 0.5;
		game.addChild(rewardText);
		// Animate in
		tween(notification, {
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 500,
			easing: tween.bounceOut
		});
		tween(titleText, {
			alpha: 1,
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 500,
			delay: 200,
			easing: tween.bounceOut
		});
		tween(rewardText, {
			alpha: 1,
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 500,
			delay: 400,
			easing: tween.bounceOut
		});
		// Animate out after 3 seconds
		LK.setTimeout(function () {
			tween(notification, {
				alpha: 0,
				scaleX: 0.8,
				scaleY: 0.8,
				y: notification.y - 100
			}, {
				duration: 800,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					notification.destroy();
				}
			});
			tween(titleText, {
				alpha: 0,
				scaleX: 0.8,
				scaleY: 0.8,
				y: titleText.y - 100
			}, {
				duration: 800,
				delay: 100,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					titleText.destroy();
				}
			});
			tween(rewardText, {
				alpha: 0,
				scaleX: 0.8,
				scaleY: 0.8,
				y: rewardText.y - 100
			}, {
				duration: 800,
				delay: 200,
				easing: tween.easeIn,
				onFinish: function onFinish() {
					rewardText.destroy();
				}
			});
		}, 3000);
	};
	return self;
});
var AnimatedHand = Container.expand(function (isDealer) {
	var self = Container.call(this);
	self.isDealer = isDealer || false;
	var handGraphic = self.attachAsset(isDealer ? 'dealerHand' : 'playerHand', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: isDealer ? 216 : 285.66,
		height: isDealer ? 324 : 428.49,
		alpha: 0.8
	});
	// Deal card animation (player - face up)
	self.dealCardToPlayer = function (targetX, targetY, onComplete) {
		var movingCard = LK.getAsset('movingCard', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		movingCard.x = self.x;
		movingCard.y = self.y;
		game.addChild(movingCard);
		// Animate hand dealing
		tween(handGraphic, {
			scaleX: 1.1,
			scaleY: 1.1,
			rotation: 0.1
		}, {
			duration: 200
		});
		// Play card dealing sound
		LK.getSound('Carta_1').play();
		// Move card to target
		tween(movingCard, {
			x: targetX,
			y: targetY,
			rotation: (Math.random() - 0.5) * 0.2
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				movingCard.destroy();
				// Reset hand
				tween(handGraphic, {
					scaleX: 1.0,
					scaleY: 1.0,
					rotation: 0
				}, {
					duration: 200
				});
				if (onComplete) onComplete();
			}
		});
	};
	// Deal card face down (dealer)
	self.dealCardFaceDown = function (targetX, targetY, onComplete) {
		var movingCard = LK.getAsset('movingCard', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		movingCard.x = self.x;
		movingCard.y = self.y;
		game.addChild(movingCard);
		// Animate hand dealing
		tween(handGraphic, {
			scaleX: 1.1,
			scaleY: 1.1,
			rotation: -0.1
		}, {
			duration: 200
		});
		// Play card dealing sound
		LK.getSound('Carta_1').play();
		// Move card to target
		tween(movingCard, {
			x: targetX,
			y: targetY,
			rotation: (Math.random() - 0.5) * 0.2
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				movingCard.destroy();
				// Reset hand
				tween(handGraphic, {
					scaleX: 1.0,
					scaleY: 1.0,
					rotation: 0
				}, {
					duration: 200
				});
				if (onComplete) onComplete();
			}
		});
	};
	// Hit gesture animation
	self.hitGesture = function (targetX, targetY, onComplete) {
		var movingCard = LK.getAsset('movingCard', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		movingCard.x = self.x;
		movingCard.y = self.y;
		game.addChild(movingCard);
		// Quick dealing animation
		tween(handGraphic, {
			scaleX: 1.05,
			scaleY: 1.05
		}, {
			duration: 150
		});
		// Quick card movement
		tween(movingCard, {
			x: targetX,
			y: targetY
		}, {
			duration: 250,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				movingCard.destroy();
				tween(handGraphic, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 150
				});
				if (onComplete) onComplete();
			}
		});
	};
	// Stand gesture animation
	self.standGesture = function () {
		tween(handGraphic, {
			rotation: 0.3,
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 300,
			onFinish: function onFinish() {
				tween(handGraphic, {
					rotation: 0,
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 300
				});
			}
		});
	};
	// Double down gesture with chips and card
	self.doubleDownGesture = function (targetX, targetY, onComplete) {
		// Animate placing chips first
		var chip = LK.getAsset('chipBet', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		chip.x = self.x;
		chip.y = self.y;
		chip.alpha = 0;
		game.addChild(chip);
		tween(chip, {
			x: targetX - 100,
			y: targetY + 100,
			alpha: 1
		}, {
			duration: 500,
			onFinish: function onFinish() {
				// Then deal final card face down
				var movingCard = LK.getAsset('movingCard', {
					anchorX: 0.5,
					anchorY: 0.5,
					width: 240,
					height: 360
				});
				movingCard.x = self.x;
				movingCard.y = self.y;
				game.addChild(movingCard);
				tween(movingCard, {
					x: targetX,
					y: targetY
				}, {
					duration: 400,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						movingCard.destroy();
						chip.destroy();
						if (onComplete) onComplete();
					}
				});
			}
		});
	};
	// Card flip animation
	self.flipCard = function (cardX, cardY, onComplete) {
		// Create card back for flip animation
		var flippingCardBack = LK.getAsset('casinoCardBack', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 200,
			height: 300
		});
		flippingCardBack.x = cardX;
		flippingCardBack.y = cardY;
		game.addChild(flippingCardBack);
		// Create card front for flip animation (hidden initially)
		var flippingCardFront = LK.getAsset('casinoCardBack', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 200,
			height: 300,
			scaleX: 0,
			alpha: 0
		});
		flippingCardFront.x = cardX;
		flippingCardFront.y = cardY;
		game.addChild(flippingCardFront);
		// Animate hand moving to card with dramatic gesture
		tween(handGraphic, {
			x: cardX - self.x,
			y: cardY - self.y,
			scaleX: 1.2,
			scaleY: 1.2,
			rotation: 0.3
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// First half of flip - shrink card back horizontally
				tween(flippingCardBack, {
					scaleX: 0,
					rotation: 0.1
				}, {
					duration: 250,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						// Play card flip sound when revealing
						LK.getSound('Carta_2').play();
						// Hide card back, show card front
						flippingCardBack.alpha = 0;
						flippingCardFront.alpha = 1;
						// Second half of flip - expand card front horizontally
						tween(flippingCardFront, {
							scaleX: 1,
							rotation: 0
						}, {
							duration: 250,
							easing: tween.easeOut,
							onFinish: function onFinish() {
								// Add subtle bounce effect
								tween(flippingCardFront, {
									scaleX: 1.05,
									scaleY: 1.05
								}, {
									duration: 150,
									easing: tween.easeOut,
									onFinish: function onFinish() {
										tween(flippingCardFront, {
											scaleX: 1.0,
											scaleY: 1.0
										}, {
											duration: 150,
											easing: tween.easeIn,
											onFinish: function onFinish() {
												// Clean up animation cards
												flippingCardBack.destroy();
												flippingCardFront.destroy();
												// Return hand to original position with flourish
												tween(handGraphic, {
													x: 0,
													y: 0,
													scaleX: 1.0,
													scaleY: 1.0,
													rotation: 0
												}, {
													duration: 400,
													easing: tween.easeOut
												});
												if (onComplete) onComplete();
											}
										});
									}
								});
							}
						});
					}
				});
			}
		});
	};
	// Collect cards animation
	self.collectCards = function (cardPositions, actualCards, onComplete) {
		var collectCount = 0;
		var totalCards = cardPositions.length;
		for (var i = 0; i < cardPositions.length; i++) {
			var pos = cardPositions[i];
			var actualCard = actualCards ? actualCards[i] : null;
			var collectingCard = LK.getAsset('movingCard', {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 240,
				height: 360
			});
			collectingCard.x = pos.x;
			collectingCard.y = pos.y;
			game.addChild(collectingCard);
			// Create closure to capture current card index
			(function (cardIndex, actualCardRef) {
				// Play card collection sound for each card
				LK.getSound('Carta_3').play();
				tween(collectingCard, {
					x: self.x,
					y: self.y,
					scaleX: 0.5,
					scaleY: 0.5,
					alpha: 0
				}, {
					duration: 400,
					delay: cardIndex * 0,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						collectingCard.destroy();
						// Make actual card disappear when collected
						if (actualCardRef) {
							actualCardRef.alpha = 0;
						}
						collectCount++;
						if (collectCount >= totalCards && onComplete) {
							onComplete();
						}
					}
				});
			})(i, actualCard);
		}
		// Animate hand collecting
		tween(handGraphic, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(handGraphic, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 200
				});
			}
		});
	};
	// Shuffle animation
	self.shuffleAnimation = function () {
		var shuffleDuration = 1200;
		var shuffleSteps = 8;
		var stepDuration = shuffleDuration / shuffleSteps;
		// First, move hand to deck position
		var deckPosition = {
			x: 200,
			y: 1366
		}; // Deck position from gamecode
		var handStartX = self.x;
		var handStartY = self.y;
		// Move hand to deck pile
		tween(self, {
			x: deckPosition.x,
			y: deckPosition.y
		}, {
			duration: 300,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Play shuffle sound when hand reaches deck
				LK.getSound('Baraja').play();
				// Now perform shuffle animation at deck position
				for (var i = 0; i < shuffleSteps; i++) {
					LK.setTimeout(function () {
						tween(handGraphic, {
							rotation: (Math.random() - 0.5) * 0.4,
							scaleX: 0.9 + Math.random() * 0.2,
							scaleY: 0.9 + Math.random() * 0.2
						}, {
							duration: stepDuration / 2,
							onFinish: function onFinish() {
								tween(handGraphic, {
									rotation: 0,
									scaleX: 1.0,
									scaleY: 1.0
								}, {
									duration: stepDuration / 2
								});
							}
						});
					}, i * stepDuration);
				}
				// After shuffle animation completes, return hand to original position
				LK.setTimeout(function () {
					tween(self, {
						x: handStartX,
						y: handStartY
					}, {
						duration: 300,
						easing: tween.easeOut
					});
				}, shuffleDuration + 300);
			}
		});
	};
	return self;
});
var Card = Container.expand(function (suit, value) {
	var self = Container.call(this);
	self.suit = suit || 'hearts';
	self.value = value || 1;
	self.faceUp = false;
	self.getDisplayValue = function () {
		if (self.value === 1) return 'A';
		if (self.value === 11) return 'J';
		if (self.value === 12) return 'Q';
		if (self.value === 13) return 'K';
		return self.value.toString();
	};
	self.getSuitSymbol = function () {
		switch (self.suit) {
			case 'hearts':
				return '♥';
			case 'diamonds':
				return '♦';
			case 'clubs':
				return '♣';
			case 'spades':
				return '♠';
			default:
				return '♥';
		}
	};
	self.getColor = function () {
		return self.suit === 'hearts' || self.suit === 'diamonds' ? '#FF0000' : '#000000';
	};
	var cardShadow = self.attachAsset('cardShadow', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 260,
		height: 380,
		alpha: 0.3
	});
	cardShadow.x = 5;
	cardShadow.y = 5;
	var cardBack = self.attachAsset('casinoCardBack', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 240,
		height: 360
	});
	// Get the specific card face asset based on suit and value
	var cardFaceAsset = 'card_' + self.suit + '_' + (self.value === 1 ? 'A' : self.value === 11 ? 'J' : self.value === 12 ? 'Q' : self.value === 13 ? 'K' : self.value.toString());
	var cardFront = self.attachAsset(cardFaceAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0,
		width: 240,
		height: 360
	});
	// Top left corner value
	var topLeftValue = new Text2(self.getDisplayValue(), {
		size: 40,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	topLeftValue.anchor.set(0, 0);
	topLeftValue.x = -115;
	topLeftValue.y = -170;
	topLeftValue.alpha = 0;
	cardFront.addChild(topLeftValue);
	// Bottom right corner value (rotated 180 degrees)
	var bottomRightValue = new Text2(self.getDisplayValue(), {
		size: 40,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	bottomRightValue.anchor.set(1, 1);
	bottomRightValue.x = 75;
	bottomRightValue.y = 120;
	bottomRightValue.rotation = Math.PI;
	bottomRightValue.alpha = 0;
	cardFront.addChild(bottomRightValue);
	// Center symbols for numbered cards (2-10)
	var centerSymbols = [];
	if (self.value >= 2 && self.value <= 10) {
		for (var i = 0; i < self.value; i++) {
			var centerSymbol = new Text2(self.getSuitSymbol(), {
				size: 60,
				fill: self.getColor(),
				font: "'Arial Black', Arial, sans-serif"
			});
			centerSymbol.anchor.set(0.5, 0.5);
			// Aesthetic positioning based on card number
			var positions = [];
			if (self.value === 2) {
				positions = [{
					x: 0,
					y: -60
				}, {
					x: 0,
					y: 60
				}];
			} else if (self.value === 3) {
				positions = [{
					x: 0,
					y: -80
				}, {
					x: 0,
					y: 0
				}, {
					x: 0,
					y: 80
				}];
			} else if (self.value === 4) {
				positions = [{
					x: -40,
					y: -60
				}, {
					x: 40,
					y: -60
				}, {
					x: -40,
					y: 60
				}, {
					x: 40,
					y: 60
				}];
			} else if (self.value === 5) {
				positions = [{
					x: -40,
					y: -60
				}, {
					x: 40,
					y: -60
				}, {
					x: 0,
					y: 0
				}, {
					x: -40,
					y: 60
				}, {
					x: 40,
					y: 60
				}];
			} else if (self.value === 6) {
				positions = [{
					x: -40,
					y: -80
				}, {
					x: 40,
					y: -80
				}, {
					x: -40,
					y: 0
				}, {
					x: 40,
					y: 0
				}, {
					x: -40,
					y: 80
				}, {
					x: 40,
					y: 80
				}];
			} else if (self.value === 7) {
				positions = [{
					x: -40,
					y: -80
				}, {
					x: 40,
					y: -80
				}, {
					x: 0,
					y: -40
				}, {
					x: -40,
					y: 0
				}, {
					x: 40,
					y: 0
				}, {
					x: -40,
					y: 80
				}, {
					x: 40,
					y: 80
				}];
			} else if (self.value === 8) {
				positions = [{
					x: -40,
					y: -80
				}, {
					x: 40,
					y: -80
				}, {
					x: -40,
					y: -30
				}, {
					x: 40,
					y: -30
				}, {
					x: -40,
					y: 30
				}, {
					x: 40,
					y: 30
				}, {
					x: -40,
					y: 80
				}, {
					x: 40,
					y: 80
				}];
			} else if (self.value === 9) {
				positions = [{
					x: -40,
					y: -80
				}, {
					x: 40,
					y: -80
				}, {
					x: -40,
					y: -40
				}, {
					x: 40,
					y: -40
				}, {
					x: 0,
					y: 0
				}, {
					x: -40,
					y: 40
				}, {
					x: 40,
					y: 40
				}, {
					x: -40,
					y: 80
				}, {
					x: 40,
					y: 80
				}];
			} else if (self.value === 10) {
				positions = [{
					x: -40,
					y: -80
				}, {
					x: 40,
					y: -80
				}, {
					x: -40,
					y: -50
				}, {
					x: 40,
					y: -50
				}, {
					x: -40,
					y: -20
				}, {
					x: 40,
					y: -20
				}, {
					x: -40,
					y: 20
				}, {
					x: 40,
					y: 20
				}, {
					x: -40,
					y: 80
				}, {
					x: 40,
					y: 80
				}];
			}
			centerSymbol.x = positions[i].x;
			centerSymbol.y = positions[i].y;
			centerSymbol.alpha = 0;
			cardFront.addChild(centerSymbol);
			centerSymbols.push(centerSymbol);
		}
	}
	// Main suit symbol for face cards
	var suitText = new Text2(self.getSuitSymbol(), {
		size: 60,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	suitText.anchor.set(0.5, 0.5);
	suitText.y = 0;
	suitText.alpha = 0;
	// Special center symbol for Jack - create a servant/knave figure
	if (self.value === 11) {
		// Create a simple servant figure using text symbols
		var servantFigure = new Text2('⚜', {
			size: 180,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		servantFigure.anchor.set(0.5, 0.5);
		servantFigure.y = 0;
		servantFigure.alpha = 0;
		cardFront.addChild(servantFigure);
		// Store references for flip animation
		centerSymbols.push(servantFigure);
	} else if (self.value === 12) {
		// Special center symbol for Queen - create a queen figure
		var queenFigure = new Text2('♛', {
			size: 180,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		queenFigure.anchor.set(0.5, 0.5);
		queenFigure.y = 0;
		queenFigure.alpha = 0;
		cardFront.addChild(queenFigure);
		// Store references for flip animation
		centerSymbols.push(queenFigure);
	} else if (self.value === 13) {
		// Special center symbol for King - create a king figure
		var kingFigure = new Text2('♔', {
			size: 180,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		kingFigure.anchor.set(0.5, 0.5);
		kingFigure.y = 0;
		kingFigure.alpha = 0;
		cardFront.addChild(kingFigure);
		// Store references for flip animation
		centerSymbols.push(kingFigure);
	} else if (self.value < 2 || self.value > 9 && self.value !== 11 && self.value !== 12 && self.value !== 13) {
		cardFront.addChild(suitText);
	}
	self.getBlackjackValue = function () {
		if (self.value === 1) return 11; // Ace high initially
		if (self.value > 10) return 10; // Face cards
		return self.value;
	};
	self.flip = function () {
		self.faceUp = !self.faceUp;
		LK.getSound('cardFlip').play();
		if (self.faceUp) {
			tween(cardBack, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(cardFront, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(topLeftValue, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(bottomRightValue, {
				alpha: 1
			}, {
				duration: 200
			});
			for (var i = 0; i < centerSymbols.length; i++) {
				tween(centerSymbols[i], {
					alpha: 1
				}, {
					duration: 200
				});
			}
			if (self.value < 2 || self.value > 9) {
				tween(suitText, {
					alpha: 1
				}, {
					duration: 200
				});
			}
		} else {
			tween(cardBack, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(cardFront, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(topLeftValue, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(bottomRightValue, {
				alpha: 0
			}, {
				duration: 200
			});
			for (var i = 0; i < centerSymbols.length; i++) {
				tween(centerSymbols[i], {
					alpha: 0
				}, {
					duration: 200
				});
			}
			if (self.value < 2 || self.value > 9) {
				tween(suitText, {
					alpha: 0
				}, {
					duration: 200
				});
			}
		}
	};
	return self;
});
var Chip = Container.expand(function (value) {
	var self = Container.call(this);
	self.value = value || 1;
	// Get appropriate chip asset based on value
	var chipAsset;
	switch (self.value) {
		case 1:
			chipAsset = 'chip1';
			break;
		case 5:
			chipAsset = 'chip5';
			break;
		case 10:
			chipAsset = 'chip10';
			break;
		case 25:
			chipAsset = 'chip25';
			break;
		case 100:
			chipAsset = 'chip100';
			break;
		case 500:
			chipAsset = 'chip500';
			break;
		default:
			chipAsset = 'chip1';
	}
	var chipGraphic = self.attachAsset(chipAsset, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add value text on chip
	var valueText = new Text2('$' + self.value, {
		size: 18,
		fill: '#FFFFFF',
		font: "'Arial Black', Arial, sans-serif"
	});
	valueText.anchor.set(0.5, 0.5);
	chipGraphic.addChild(valueText);
	self.enabled = true;
	// Make chip interactive
	self.interactive = true;
	self.buttonMode = true;
	self.setEnabled = function (enabled) {
		self.enabled = enabled;
		chipGraphic.alpha = enabled ? 1.0 : 0.5;
	};
	self.down = function (x, y, obj) {
		if (!self.enabled) return;
		if (gameMode !== 'blackjack') return;
		if (gamePhase !== 'betting') return;
		// Check if player has enough money for this chip value when added to current bet
		if (playerMoney >= currentBet + self.value) {
			currentBet += self.value;
			updateChipSelection();
			LK.getSound('Ficha_1').play();
			// Create animated chip that moves to Apuesta center
			var animatedChip = LK.getAsset(chipAsset, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			// Get chip's global position
			var chipGlobalPos = self.parent.toGlobal(self.position);
			var gameLocalPos = game.toLocal(chipGlobalPos);
			animatedChip.x = gameLocalPos.x;
			animatedChip.y = gameLocalPos.y;
			animatedChip.alpha = 0.8;
			game.addChild(animatedChip);
			// Animate chip moving to center of Apuesta asset
			tween(animatedChip, {
				x: apuestaAsset.x,
				y: apuestaAsset.y,
				scaleX: 0.7,
				scaleY: 0.7,
				alpha: 1.0
			}, {
				duration: 600,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					// Fade out and destroy the animated chip
					tween(animatedChip, {
						alpha: 0,
						scaleX: 0.5,
						scaleY: 0.5
					}, {
						duration: 300,
						onFinish: function onFinish() {
							animatedChip.destroy();
						}
					});
				}
			});
			// Visual feedback on original chip
			tween(chipGraphic, {
				scaleX: 0.9,
				scaleY: 0.9
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(chipGraphic, {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 100
					});
				}
			});
		}
	};
	return self;
});
var DealerCard = Container.expand(function (suit, value) {
	var self = Container.call(this);
	self.suit = suit || 'hearts';
	self.value = value || 1;
	self.faceUp = false;
	self.getDisplayValue = function () {
		if (self.value === 1) return 'A';
		if (self.value === 11) return 'J';
		if (self.value === 12) return 'Q';
		if (self.value === 13) return 'K';
		return self.value.toString();
	};
	self.getSuitSymbol = function () {
		switch (self.suit) {
			case 'hearts':
				return '♥';
			case 'diamonds':
				return '♦';
			case 'clubs':
				return '♣';
			case 'spades':
				return '♠';
			default:
				return '♥';
		}
	};
	self.getColor = function () {
		return self.suit === 'hearts' || self.suit === 'diamonds' ? '#FF0000' : '#000000';
	};
	var cardShadow = self.attachAsset('dealerCardShadow', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 220,
		height: 320,
		alpha: 0.3
	});
	cardShadow.x = 4;
	cardShadow.y = 4;
	var cardBack = self.attachAsset('casinoCardBack', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 200,
		height: 300
	});
	// Get the specific card face asset based on suit and value for dealer cards
	var dealerCardFaceAsset = 'card_' + self.suit + '_' + (self.value === 1 ? 'A' : self.value === 11 ? 'J' : self.value === 12 ? 'Q' : self.value === 13 ? 'K' : self.value.toString());
	var cardFront = self.attachAsset(dealerCardFaceAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0,
		width: 200,
		height: 300
	});
	// Top left corner value
	var topLeftValue = new Text2(self.getDisplayValue(), {
		size: 32,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	topLeftValue.anchor.set(0, 0);
	topLeftValue.x = -95;
	topLeftValue.y = -140;
	topLeftValue.alpha = 0;
	cardFront.addChild(topLeftValue);
	// Bottom right corner value (rotated 180 degrees)
	var bottomRightValue = new Text2(self.getDisplayValue(), {
		size: 32,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	bottomRightValue.anchor.set(1, 1);
	bottomRightValue.x = 55;
	bottomRightValue.y = 90;
	bottomRightValue.rotation = Math.PI;
	bottomRightValue.alpha = 0;
	cardFront.addChild(bottomRightValue);
	// Center symbols for numbered cards (2-10)
	var centerSymbols = [];
	if (self.value >= 2 && self.value <= 10) {
		for (var i = 0; i < self.value; i++) {
			var centerSymbol = new Text2(self.getSuitSymbol(), {
				size: 48,
				fill: self.getColor(),
				font: "'Arial Black', Arial, sans-serif"
			});
			centerSymbol.anchor.set(0.5, 0.5);
			// Aesthetic positioning based on card number
			var positions = [];
			if (self.value === 2) {
				positions = [{
					x: 0,
					y: -45
				}, {
					x: 0,
					y: 45
				}];
			} else if (self.value === 3) {
				positions = [{
					x: 0,
					y: -60
				}, {
					x: 0,
					y: 0
				}, {
					x: 0,
					y: 60
				}];
			} else if (self.value === 4) {
				positions = [{
					x: -30,
					y: -45
				}, {
					x: 30,
					y: -45
				}, {
					x: -30,
					y: 45
				}, {
					x: 30,
					y: 45
				}];
			} else if (self.value === 5) {
				positions = [{
					x: -30,
					y: -45
				}, {
					x: 30,
					y: -45
				}, {
					x: 0,
					y: 0
				}, {
					x: -30,
					y: 45
				}, {
					x: 30,
					y: 45
				}];
			} else if (self.value === 6) {
				positions = [{
					x: -30,
					y: -60
				}, {
					x: 30,
					y: -60
				}, {
					x: -30,
					y: 0
				}, {
					x: 30,
					y: 0
				}, {
					x: -30,
					y: 60
				}, {
					x: 30,
					y: 60
				}];
			} else if (self.value === 7) {
				positions = [{
					x: -30,
					y: -60
				}, {
					x: 30,
					y: -60
				}, {
					x: 0,
					y: -30
				}, {
					x: -30,
					y: 0
				}, {
					x: 30,
					y: 0
				}, {
					x: -30,
					y: 60
				}, {
					x: 30,
					y: 60
				}];
			} else if (self.value === 8) {
				positions = [{
					x: -30,
					y: -60
				}, {
					x: 30,
					y: -60
				}, {
					x: -30,
					y: -20
				}, {
					x: 30,
					y: -20
				}, {
					x: -30,
					y: 20
				}, {
					x: 30,
					y: 20
				}, {
					x: -30,
					y: 60
				}, {
					x: 30,
					y: 60
				}];
			} else if (self.value === 9) {
				positions = [{
					x: -30,
					y: -60
				}, {
					x: 30,
					y: -60
				}, {
					x: -30,
					y: -30
				}, {
					x: 30,
					y: -30
				}, {
					x: 0,
					y: 0
				}, {
					x: -30,
					y: 30
				}, {
					x: 30,
					y: 30
				}, {
					x: -30,
					y: 60
				}, {
					x: 30,
					y: 60
				}];
			} else if (self.value === 10) {
				positions = [{
					x: -30,
					y: -60
				}, {
					x: 30,
					y: -60
				}, {
					x: -30,
					y: -40
				}, {
					x: 30,
					y: -40
				}, {
					x: -30,
					y: -15
				}, {
					x: 30,
					y: -15
				}, {
					x: -30,
					y: 15
				}, {
					x: 30,
					y: 15
				}, {
					x: -30,
					y: 60
				}, {
					x: 30,
					y: 60
				}];
			}
			centerSymbol.x = positions[i].x;
			centerSymbol.y = positions[i].y;
			centerSymbol.alpha = 0;
			cardFront.addChild(centerSymbol);
			centerSymbols.push(centerSymbol);
		}
	}
	// Main suit symbol for face cards
	var suitText = new Text2(self.getSuitSymbol(), {
		size: 48,
		fill: self.getColor(),
		font: "'Arial Black', Arial, sans-serif"
	});
	suitText.anchor.set(0.5, 0.5);
	suitText.y = 0;
	suitText.alpha = 0;
	// Special center symbol for Jack - create a servant/knave figure
	if (self.value === 11) {
		// Create a simple servant figure using text symbols
		var servantFigure = new Text2('⚜', {
			size: 144,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		servantFigure.anchor.set(0.5, 0.5);
		servantFigure.y = 0;
		servantFigure.alpha = 0;
		cardFront.addChild(servantFigure);
		// Store references for flip animation
		centerSymbols.push(servantFigure);
	} else if (self.value === 12) {
		// Special center symbol for Queen - create a queen figure
		var queenFigure = new Text2('♛', {
			size: 144,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		queenFigure.anchor.set(0.5, 0.5);
		queenFigure.y = 0;
		queenFigure.alpha = 0;
		cardFront.addChild(queenFigure);
		// Store references for flip animation
		centerSymbols.push(queenFigure);
	} else if (self.value === 13) {
		// Special center symbol for King - create a king figure
		var kingFigure = new Text2('♔', {
			size: 144,
			fill: self.getColor(),
			font: "'Arial Black', Arial, sans-serif"
		});
		kingFigure.anchor.set(0.5, 0.5);
		kingFigure.y = 0;
		kingFigure.alpha = 0;
		cardFront.addChild(kingFigure);
		// Store references for flip animation
		centerSymbols.push(kingFigure);
	} else if (self.value < 2 || self.value > 9 && self.value !== 11 && self.value !== 12 && self.value !== 13) {
		cardFront.addChild(suitText);
	}
	self.getBlackjackValue = function () {
		if (self.value === 1) return 11; // Ace high initially
		if (self.value > 10) return 10; // Face cards
		return self.value;
	};
	self.flip = function () {
		self.faceUp = !self.faceUp;
		LK.getSound('cardFlip').play();
		if (self.faceUp) {
			tween(cardBack, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(cardFront, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(topLeftValue, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(bottomRightValue, {
				alpha: 1
			}, {
				duration: 200
			});
			for (var i = 0; i < centerSymbols.length; i++) {
				tween(centerSymbols[i], {
					alpha: 1
				}, {
					duration: 200
				});
			}
			if (self.value < 2 || self.value > 9) {
				tween(suitText, {
					alpha: 1
				}, {
					duration: 200
				});
			}
		} else {
			tween(cardBack, {
				alpha: 1
			}, {
				duration: 200
			});
			tween(cardFront, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(topLeftValue, {
				alpha: 0
			}, {
				duration: 200
			});
			tween(bottomRightValue, {
				alpha: 0
			}, {
				duration: 200
			});
			for (var i = 0; i < centerSymbols.length; i++) {
				tween(centerSymbols[i], {
					alpha: 0
				}, {
					duration: 200
				});
			}
			if (self.value < 2 || self.value > 9) {
				tween(suitText, {
					alpha: 0
				}, {
					duration: 200
				});
			}
		}
	};
	return self;
});
var Deck = Container.expand(function () {
	var self = Container.call(this);
	// Create multiple stacked cards for deck appearance
	var stackedCards = [];
	for (var i = 0; i < 5; i++) {
		var cardLayer = self.attachAsset('casinoCardBack', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		cardLayer.x = i * 3; // Slight offset for stacking effect
		cardLayer.y = i * -2; // Vertical stacking
		cardLayer.alpha = 0.9 - i * 0.1; // Fade slightly for depth
		stackedCards.push(cardLayer);
	}
	self.cardCount = 52;
	var countText = new Text2('52', {
		size: 24,
		fill: '#FFFFFF'
	});
	countText.anchor.set(0.5, 0.5);
	countText.y = -200;
	self.addChild(countText);
	// Start deck breathing animation
	self.startDeckAnimation = function () {
		// Create a subtle breathing animation for the entire deck
		function breatheAnimation() {
			tween(self, {
				scaleX: 1.02,
				scaleY: 1.02,
				y: self.y - 2
			}, {
				duration: 2000,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					tween(self, {
						scaleX: 1.0,
						scaleY: 1.0,
						y: self.y + 2
					}, {
						duration: 2000,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							breatheAnimation(); // Loop the animation
						}
					});
				}
			});
		}
		breatheAnimation();
		// Add subtle rotation animation to individual cards for depth
		for (var i = 0; i < stackedCards.length; i++) {
			(function (cardLayer, index) {
				function cardFloatAnimation() {
					var randomOffset = (Math.random() - 0.5) * 0.02; // Small random rotation
					tween(cardLayer, {
						rotation: randomOffset,
						y: cardLayer.y + (Math.random() - 0.5) * 1
					}, {
						duration: 3000 + index * 200,
						easing: tween.easeInOut,
						onFinish: function onFinish() {
							tween(cardLayer, {
								rotation: -randomOffset * 0.5,
								y: cardLayer.y - (Math.random() - 0.5) * 1
							}, {
								duration: 3000 + index * 200,
								easing: tween.easeInOut,
								onFinish: function onFinish() {
									cardFloatAnimation(); // Loop the animation
								}
							});
						}
					});
				}
				cardFloatAnimation();
			})(stackedCards[i], i);
		}
	};
	// Stop deck animation
	self.stopDeckAnimation = function () {
		tween.stop(self, {
			scaleX: true,
			scaleY: true,
			y: true
		});
		for (var i = 0; i < stackedCards.length; i++) {
			tween.stop(stackedCards[i], {
				rotation: true,
				y: true
			});
		}
	};
	self.updateCount = function (count) {
		self.cardCount = count;
		countText.setText(count.toString());
		if (count <= 0) {
			for (var i = 0; i < stackedCards.length; i++) {
				stackedCards[i].alpha = 0.1;
			}
		} else {
			for (var i = 0; i < stackedCards.length; i++) {
				stackedCards[i].alpha = 0.9 - i * 0.1;
			}
		}
	};
	self.dealAnimation = function (targetX, targetY, onComplete) {
		if (self.cardCount <= 0) {
			if (onComplete) onComplete();
			return;
		}
		self.cardCount--;
		self.updateCount(self.cardCount);
		var dealingCard = LK.getAsset('casinoCardBack', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		dealingCard.x = self.x;
		dealingCard.y = self.y;
		game.addChild(dealingCard);
		tween(dealingCard, {
			x: targetX,
			y: targetY,
			rotation: (Math.random() - 0.5) * 0.2
		}, {
			duration: 600,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				dealingCard.destroy();
				if (onComplete) onComplete();
			}
		});
		// Animate the entire stack slightly when dealing
		for (var i = 0; i < stackedCards.length; i++) {
			tween(stackedCards[i], {
				scaleX: 0.95,
				scaleY: 0.95
			}, {
				duration: 100,
				onFinish: function onFinish() {
					tween(stackedCards[i], {
						scaleX: 1.0,
						scaleY: 1.0
					}, {
						duration: 100
					});
				}
			});
		}
	};
	return self;
});
var GameButton = Container.expand(function (text, width, height) {
	var self = Container.call(this);
	var buttonShadow = self.attachAsset('buttonShadow', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: (width || 200) * 2 + 20,
		height: (height || 80) * 2 + 20,
		alpha: 0.4
	});
	buttonShadow.x = 6;
	buttonShadow.y = 6;
	var buttonBg = self.attachAsset('button', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: (width || 200) * 2,
		height: (height || 80) * 2
	});
	var buttonText = new Text2(text || 'Button', {
		size: 48,
		fill: '#000000',
		font: "'Arial Black', Arial, sans-serif"
	});
	buttonText.anchor.set(0.5, 0.5);
	buttonBg.addChild(buttonText);
	self.enabled = true;
	self.setText = function (newText) {
		buttonText.setText(newText);
	};
	self.setEnabled = function (enabled) {
		self.enabled = enabled;
		buttonBg.alpha = enabled ? 1.0 : 0.5;
	};
	self.down = function (x, y, obj) {
		if (!self.enabled) return;
		LK.getSound('buttonClick').play();
		tween(buttonBg, {
			scaleX: 0.85,
			scaleY: 0.85
		}, {
			duration: 100,
			easing: tween.easeOut
		});
	};
	self.up = function (x, y, obj) {
		if (!self.enabled) return;
		tween(buttonBg, {
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 150,
			easing: tween.bounceOut,
			onFinish: function onFinish() {
				tween(buttonBg, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 100,
					easing: tween.easeOut
				});
			}
		});
	};
	return self;
});
var MegawaysReel = Container.expand(function (reelIndex) {
	var self = Container.call(this);
	self.reelIndex = reelIndex || 0;
	self.symbols = [];
	self.symbolTypes = ['megawaysSymbolA', 'megawaysSymbolB', 'megawaysSymbolC', 'megawaysSymbolD', 'megawaysSymbolE', 'megawaysSymbolF', 'megawaysWild', 'megawaysScatter'];
	self.spinning = false;
	self.currentSymbolCount = 4; // Start with 4 symbols
	self.maxSymbols = 4; // Maximum symbols per reel  
	self.minSymbols = 4; // Minimum symbols per reel
	self.isSpinning = false;
	self.spinEndCallback = null;
	// Reel container background
	var reelBorder = self.attachAsset('megawaysReelBorder', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var reelContainer = self.attachAsset('megawaysReelContainer', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Initialize reel with random symbol count
	self.generateRandomSymbolCount = function () {
		self.currentSymbolCount = self.minSymbols + Math.floor(Math.random() * (self.maxSymbols - self.minSymbols + 1));
		return self.currentSymbolCount;
	};
	// Create symbols for this reel
	self.createSymbols = function () {
		// Clear existing symbols
		for (var i = 0; i < self.symbols.length; i++) {
			if (self.symbols[i] && self.symbols[i].destroy) {
				self.symbols[i].destroy();
			}
		}
		self.symbols = [];
		// Create new symbols based on current count
		for (var i = 0; i < self.currentSymbolCount; i++) {
			var symbolType = self.symbolTypes[Math.floor(Math.random() * (self.symbolTypes.length - 2))]; // Exclude wild and scatter for now
			var symbol = new MegawaysSymbol(symbolType, self.symbolTypes.indexOf(symbolType));
			// Position symbols vertically within reel with no spacing between them
			var symbolHeight = 105; // Height of each symbol (60 * 1.4 scale + padding to fill 420px height completely)
			symbol.y = (i - (self.currentSymbolCount - 1) / 2) * symbolHeight;
			// Scale symbols to fill available space better
			symbol.scaleX = 1.4;
			symbol.scaleY = 1.4;
			self.addChild(symbol);
			self.symbols.push(symbol);
		}
	};
	// Calculate total ways to win based on symbol counts
	self.calculateWays = function (reelSymbolCounts) {
		var totalWays = 1;
		for (var i = 0; i < reelSymbolCounts.length; i++) {
			totalWays *= reelSymbolCounts[i];
		}
		return totalWays;
	};
	// Spin reel with enhanced Megaways animations
	self.spin = function (duration, onComplete) {
		if (self.isSpinning) return;
		self.isSpinning = true;
		self.spinEndCallback = onComplete;
		// Generate new symbol count for this spin
		self.generateRandomSymbolCount();
		// Store old symbols for cascading animation
		var oldSymbols = self.symbols.slice();
		// Start spin animation with reel shake and blur
		tween(reelContainer, {
			scaleY: 0.6,
			scaleX: 1.1,
			alpha: 0.7
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Animate old symbols falling out
		for (var i = 0; i < oldSymbols.length; i++) {
			(function (symbol, index) {
				tween(symbol, {
					y: symbol.y + 500,
					alpha: 0,
					rotation: (Math.random() - 0.5) * Math.PI
				}, {
					duration: 400 + index * 50,
					easing: tween.easeIn,
					onFinish: function onFinish() {
						if (symbol && symbol.destroy) {
							symbol.destroy();
						}
					}
				});
			})(oldSymbols[i], i);
		}
		// Clear symbols array after starting fall animation
		self.symbols = [];
		var spinInterval;
		var spinCount = 0;
		var maxSpins = Math.floor(duration / 120);
		var tempSymbols = [];
		spinInterval = LK.setInterval(function () {
			spinCount++;
			// Create temporary spinning symbols for visual effect
			if (spinCount % 2 === 0) {
				// Clear temp symbols
				for (var i = 0; i < tempSymbols.length; i++) {
					if (tempSymbols[i] && tempSymbols[i].destroy) {
						tempSymbols[i].destroy();
					}
				}
				tempSymbols = [];
				// Create new temp symbols
				for (var i = 0; i < self.currentSymbolCount; i++) {
					var symbolType = self.symbolTypes[Math.floor(Math.random() * self.symbolTypes.length)];
					var tempSymbol = new MegawaysSymbol(symbolType, self.symbolTypes.indexOf(symbolType));
					// Position temp symbols with no spacing between them
					var symbolHeight = 105; // Height of each symbol with no gaps
					tempSymbol.y = (i - (self.currentSymbolCount - 1) / 2) * symbolHeight;
					tempSymbol.alpha = 0.6;
					// Scale temp symbols to match final ones
					tempSymbol.scaleX = 1.4;
					tempSymbol.scaleY = 1.4;
					self.addChild(tempSymbol);
					tempSymbols.push(tempSymbol);
				}
			}
			// Add intense shake effect during spin
			reelContainer.x = (Math.random() - 0.5) * 12;
			reelContainer.y = (Math.random() - 0.5) * 8;
			if (spinCount >= maxSpins) {
				LK.clearInterval(spinInterval);
				// Clear temp symbols
				for (var i = 0; i < tempSymbols.length; i++) {
					if (tempSymbols[i] && tempSymbols[i].destroy) {
						tempSymbols[i].destroy();
					}
				}
				tempSymbols = [];
				// Create final symbols with drop-in animation
				self.createFinalSymbols();
			}
		}, 120);
	};
	// Create final symbols with drop-in animation
	self.createFinalSymbols = function () {
		// Create new symbols above the reel
		for (var i = 0; i < self.currentSymbolCount; i++) {
			var symbolType = self.symbolTypes[Math.floor(Math.random() * (self.symbolTypes.length - 2))];
			var symbol = new MegawaysSymbol(symbolType, self.symbolTypes.indexOf(symbolType));
			// Position symbols with no spacing between them
			var symbolHeight = 105; // Height of each symbol with no gaps
			var finalY = (i - (self.currentSymbolCount - 1) / 2) * symbolHeight;
			// Place symbols directly at final position instead of starting above
			symbol.y = finalY;
			symbol.alpha = 1;
			// Scale symbols to fill available space better
			symbol.scaleX = 1.4;
			symbol.scaleY = 1.4;
			self.addChild(symbol);
			self.symbols.push(symbol);
		}
		// Wait for the same duration as the original animation to maintain timing
		LK.setTimeout(function () {
			self.finalizeSpin();
		}, 600 + (self.currentSymbolCount - 1) * 100);
	};
	// Finalize spin animation
	self.finalizeSpin = function () {
		// Reset reel container position and scale
		tween(reelContainer, {
			x: 0,
			y: 0,
			scaleY: 1.0,
			scaleX: 1.0,
			alpha: 1.0
		}, {
			duration: 400,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				self.isSpinning = false;
				if (self.spinEndCallback) {
					self.spinEndCallback();
					self.spinEndCallback = null;
				}
			}
		});
	};
	// Get all symbols in this reel
	self.getSymbols = function () {
		return self.symbols;
	};
	// Get symbol count for ways calculation
	self.getSymbolCount = function () {
		return self.currentSymbolCount;
	};
	// Check for winning combinations in this reel
	self.checkForWins = function (targetSymbol, position) {
		var winningSymbols = [];
		for (var i = 0; i < self.symbols.length; i++) {
			var symbol = self.symbols[i];
			if (symbol.getSymbolValue() === targetSymbol || symbol.isWild) {
				winningSymbols.push(symbol);
			}
		}
		return winningSymbols;
	};
	// Mark symbols for cascade removal
	self.markSymbolsForRemoval = function (symbolsToRemove) {
		for (var i = 0; i < symbolsToRemove.length; i++) {
			var symbol = symbolsToRemove[i];
			symbol.markForWin();
		}
	};
	// Initialize with symbols
	self.generateRandomSymbolCount();
	self.createSymbols();
	return self;
});
var MegawaysSlotMachine = Container.expand(function () {
	var self = Container.call(this);
	self.reels = [];
	self.isSpinning = false;
	self.currentWays = 0;
	self.cascadeCount = 0;
	self.totalWinAmount = 0;
	// Create 6 reels for Megaways
	self.createReels = function () {
		for (var i = 0; i < 6; i++) {
			var reel = new MegawaysReel(i);
			// Position reels horizontally with proper spacing
			reel.x = (i - 2.5) * 200; // Center 6 reels
			reel.y = 0;
			self.addChild(reel);
			self.reels.push(reel);
		}
	};
	// Calculate total ways to win
	self.calculateTotalWays = function () {
		var symbolCounts = [];
		for (var i = 0; i < self.reels.length; i++) {
			symbolCounts.push(self.reels[i].getSymbolCount());
		}
		var ways = 1;
		for (var i = 0; i < symbolCounts.length; i++) {
			ways *= symbolCounts[i];
		}
		self.currentWays = ways;
		return ways;
	};
	// Spin all reels with staggered timing
	self.spinAllReels = function (onComplete) {
		if (self.isSpinning) return;
		self.isSpinning = true;
		self.cascadeCount = 0;
		self.totalWinAmount = 0;
		var completedReels = 0;
		var totalReels = self.reels.length;
		// Calculate when each reel will stop spinning
		var reelStopTimes = [];
		for (var i = 0; i < self.reels.length; i++) {
			var startDelay = i * 150; // When this reel starts spinning
			var spinDuration = 1200 + i * 200; // How long this reel spins
			var stopTime = startDelay + spinDuration; // When this reel stops
			reelStopTimes.push(stopTime);
		}
		// Schedule Detencion sound for each reel when it stops
		for (var i = 0; i < reelStopTimes.length; i++) {
			(function (reelIndex, stopTime) {
				LK.setTimeout(function () {
					// Play Detencion sound when this specific reel stops
					LK.getSound('Detencion').play();
				}, stopTime);
			})(i, reelStopTimes[i]);
		}
		// Spin each reel with increasing delay for realistic effect
		for (var i = 0; i < self.reels.length; i++) {
			(function (reelIndex) {
				LK.setTimeout(function () {
					// Play Rodillos sound only once when first reel starts spinning
					if (reelIndex === 0) {
						LK.getSound('Rodillos').play();
					}
					self.reels[reelIndex].spin(1200 + reelIndex * 200, function () {
						completedReels++;
						if (completedReels === totalReels) {
							self.isSpinning = false;
							self.calculateTotalWays();
							if (onComplete) onComplete();
						}
					});
				}, reelIndex * 150);
			})(i);
		}
	};
	// Check for winning combinations across all reels
	self.checkForWins = function () {
		var winningCombinations = [];
		var symbolTypes = ['megawaysSymbolA', 'megawaysSymbolB', 'megawaysSymbolC', 'megawaysSymbolD', 'megawaysSymbolE', 'megawaysSymbolF'];
		// Check each symbol type for consecutive matches from left
		for (var s = 0; s < symbolTypes.length; s++) {
			var symbolType = symbolTypes[s];
			var consecutiveReels = 0;
			var winningSymbols = [];
			// Check from leftmost reel
			for (var r = 0; r < self.reels.length; r++) {
				var reelMatches = self.reels[r].checkForWins(symbolType, r);
				if (reelMatches.length > 0) {
					consecutiveReels++;
					winningSymbols = winningSymbols.concat(reelMatches);
				} else {
					break; // Must be consecutive from left
				}
			}
			// Need at least 3 consecutive reels for a win
			if (consecutiveReels >= 3) {
				winningCombinations.push({
					symbolType: symbolType,
					reelCount: consecutiveReels,
					symbols: winningSymbols,
					multiplier: self.getSymbolMultiplier(symbolType, consecutiveReels)
				});
			}
		}
		return winningCombinations;
	};
	// Get multiplier for symbol and reel count
	self.getSymbolMultiplier = function (symbolType, reelCount) {
		var baseMultipliers = {
			'megawaysSymbolA': 50,
			'megawaysSymbolB': 40,
			'megawaysSymbolC': 30,
			'megawaysSymbolD': 25,
			'megawaysSymbolE': 20,
			'megawaysSymbolF': 15
		};
		var reelMultiplier = reelCount - 2; // 3 reels = 1x, 4 reels = 2x, etc.
		var betFactor = currentBet / 25; // Scale rewards based on bet amount (25 is base bet)
		return (baseMultipliers[symbolType] || 10) * reelMultiplier * betFactor;
	};
	// Process winning combinations
	self.processWins = function (winningCombinations, onComplete) {
		if (winningCombinations.length === 0) {
			if (onComplete) onComplete(0);
			return;
		}
		var totalWin = 0;
		// Calculate total win amount
		for (var i = 0; i < winningCombinations.length; i++) {
			var combo = winningCombinations[i];
			totalWin += combo.multiplier;
			// Mark symbols for removal
			for (var j = 0; j < combo.symbols.length; j++) {
				combo.symbols[j].markForWin();
			}
		}
		self.totalWinAmount += totalWin;
		// Animate win highlighting
		LK.setTimeout(function () {
			self.cascadeWinningSymbols(winningCombinations, function () {
				if (onComplete) onComplete(totalWin);
			});
		}, 1000);
		return totalWin;
	};
	// Cascade (remove) winning symbols and drop remaining ones
	self.cascadeWinningSymbols = function (winningCombinations, onComplete) {
		self.cascadeCount++;
		var symbolsToRemove = [];
		// Collect all winning symbols
		for (var i = 0; i < winningCombinations.length; i++) {
			symbolsToRemove = symbolsToRemove.concat(winningCombinations[i].symbols);
		}
		// Animate symbol removal
		var removedCount = 0;
		for (var i = 0; i < symbolsToRemove.length; i++) {
			(function (symbol) {
				symbol.explode(function () {
					removedCount++;
					if (removedCount === symbolsToRemove.length) {
						// All symbols removed, now cascade remaining symbols down
						self.cascadeRemainingSymbols(function () {
							// Check for new wins after cascade
							LK.setTimeout(function () {
								var newWins = self.checkForWins();
								if (newWins.length > 0) {
									// More wins found, process them
									self.processWins(newWins, onComplete);
								} else {
									// No more wins, cascade complete
									if (onComplete) onComplete();
								}
							}, 300);
						});
					}
				});
			})(symbolsToRemove[i]);
		}
	};
	// Drop remaining symbols and fill gaps
	self.cascadeRemainingSymbols = function (onComplete) {
		var cascadeComplete = 0;
		var totalReels = self.reels.length;
		for (var r = 0; r < self.reels.length; r++) {
			(function (reelIndex) {
				var reel = self.reels[reelIndex];
				var remainingSymbols = [];
				// Collect non-destroyed symbols
				for (var i = 0; i < reel.symbols.length; i++) {
					if (reel.symbols[i] && !reel.symbols[i].marked) {
						remainingSymbols.push(reel.symbols[i]);
					}
				}
				// Fill reel back to current symbol count
				var newSymbolsNeeded = reel.currentSymbolCount - remainingSymbols.length;
				for (var n = 0; n < newSymbolsNeeded; n++) {
					var symbolType = reel.symbolTypes[Math.floor(Math.random() * (reel.symbolTypes.length - 2))];
					var newSymbol = new MegawaysSymbol(symbolType, reel.symbolTypes.indexOf(symbolType));
					newSymbol.y = -400 - n * 70; // Start above screen
					reel.addChild(newSymbol);
					remainingSymbols.unshift(newSymbol); // Add to beginning
				}
				// Update reel's symbols array
				reel.symbols = remainingSymbols;
				// Animate all symbols to their final positions
				var symbolHeight = 105; // Height of each symbol with no gaps
				for (var i = 0; i < remainingSymbols.length; i++) {
					(function (symbol, index, finalReel) {
						var targetY = (index - (reel.currentSymbolCount - 1) / 2) * symbolHeight;
						// Scale new symbols to match existing ones
						symbol.scaleX = 1.4;
						symbol.scaleY = 1.4;
						symbol.startFalling(targetY, function () {
							if (index === remainingSymbols.length - 1) {
								cascadeComplete++;
								if (cascadeComplete === totalReels) {
									if (onComplete) onComplete();
								}
							}
						});
					})(remainingSymbols[i], i, reelIndex);
				}
			})(r);
		}
	};
	// Get current ways display text
	self.getWaysText = function () {
		return self.currentWays + ' WAYS';
	};
	// Initialize reels
	self.createReels();
	return self;
});
var MegawaysSymbol = Container.expand(function (symbolType, symbolIndex) {
	var self = Container.call(this);
	self.symbolType = symbolType || 'megawaysSymbolA';
	self.symbolIndex = symbolIndex || 0;
	self.isWild = symbolType === 'megawaysWild';
	self.isScatter = symbolType === 'megawaysScatter';
	self.marked = false;
	self.falling = false;
	// Symbol graphics
	var symbolGraphic = self.attachAsset(self.symbolType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Ensure clean state - no tinting
	symbolGraphic.tint = 0xFFFFFF;
	// Symbol assets for identification instead of text
	var symbolAssetNames = ['A', 'B', 'C', 'D', 'E', 'F', 'Wild', 'Scatter'];
	var symbolAsset = LK.getAsset(self.isWild ? 'Wild' : self.isScatter ? 'Scatter' : symbolAssetNames[self.symbolIndex], {
		anchorX: 0.5,
		anchorY: 0.5
	});
	symbolGraphic.addChild(symbolAsset);
	// Mark symbol for win combination
	self.markForWin = function () {
		if (self.marked) return;
		if (self.falling) return; // Don't mark while falling during cascade
		self.marked = true;
		// Play Simbolo sound when marking winning symbol
		LK.getSound('Simbolo').play();
		tween(symbolGraphic, {
			tint: 0xffff00,
			scaleX: 1.1,
			scaleY: 1.1
		}, {
			duration: 300,
			easing: tween.bounceOut
		});
	};
	// Start falling animation for cascade
	self.startFalling = function (targetY, onComplete) {
		if (self.falling) return;
		self.falling = true;
		// Reset any win markings and tint when falling
		self.marked = false;
		tween.stop(symbolGraphic, {
			tint: true,
			scaleX: true,
			scaleY: true
		});
		symbolGraphic.tint = 0xFFFFFF; // Reset to white
		// Keep original scale instead of forcing 1.4 to prevent growth during cascade
		symbolGraphic.scaleX = 1.0;
		symbolGraphic.scaleY = 1.0;
		tween(self, {
			y: targetY
		}, {
			duration: 400,
			easing: tween.bounceOut,
			onFinish: function onFinish() {
				self.falling = false;
				if (onComplete) onComplete();
			}
		});
	};
	// Explode and remove symbol
	self.explode = function (onComplete) {
		// Play Explosion sound when symbol explodes
		LK.getSound('Explosion').play();
		tween(symbolGraphic, {
			scaleX: 0,
			scaleY: 0,
			alpha: 0,
			rotation: Math.PI * 2
		}, {
			duration: 300,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				self.destroy();
				if (onComplete) onComplete();
			}
		});
	};
	// Get symbol value for matching
	self.getSymbolValue = function () {
		if (self.isWild) return 'WILD';
		if (self.isScatter) return 'SCATTER';
		return self.symbolType;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Hide blinking text when leaving menu
if (spinHereText) {
	spinHereText.destroy();
	spinHereText = null;
}
if (spinHereTextTimer) {
	LK.clearTimeout(spinHereTextTimer);
	spinHereTextTimer = null;
}
if (spinHereBlinkTimer) {
	LK.clearInterval(spinHereBlinkTimer);
	spinHereBlinkTimer = null;
}
// Card display removed from menu
// Spades (Black Suit) - 13 cards
// Clubs (Black Suit) - 13 cards
// Diamonds (Red Suit) - 13 cards
// Hearts (Red Suit) - 13 cards
// Add background
// Luxury slot machine frame assets - "La Tentación Dorada" styling
// Dark wood main frame
// Gold inner border
// Dark inlay
// Dark blue/black reels background
// Gold border around reels
// Luxury SPIN button
// Button border
// Luxury MENU button
// Corner decorations
var fondoM = LK.getAsset('FondoM', {
	anchorX: 0.5,
	anchorY: 0.5
});
fondoM.x = 1024;
fondoM.y = 1366;
game.addChild(fondoM);
// Add table background
var tableBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
tableBackground.x = 1024;
tableBackground.y = 1366;
tableBackground.alpha = 0;
game.addChild(tableBackground);
// Add blackjack background
var blackjackBackground = LK.getAsset('fondo', {
	anchorX: 0.5,
	anchorY: 0.5
});
blackjackBackground.x = 1024;
blackjackBackground.y = 1366;
blackjackBackground.alpha = 0;
game.addChild(blackjackBackground);
// Add slots background
var slotsBackground = LK.getAsset('FondoS', {
	anchorX: 0.5,
	anchorY: 0.5
});
slotsBackground.x = 1024;
slotsBackground.y = 1366;
slotsBackground.alpha = 0;
game.addChild(slotsBackground);
// Add tragamonedas asset first (lower z-index)
var tragamonedasAsset = LK.getAsset('tragamonedas', {
	anchorX: 0.5,
	anchorY: 0.5
});
tragamonedasAsset.x = 1024;
tragamonedasAsset.y = 1200; // Moved higher up to overlap with slot machine
tragamonedasAsset.alpha = 0; // Start hidden
game.addChild(tragamonedasAsset);
// Add Monedero asset in bottom left corner below tragamonedas
var monederoAsset = LK.getAsset('Monedero', {
	anchorX: 0.5,
	anchorY: 0.5
});
monederoAsset.x = 280; // Left side position (270 + 10 pixels to the right)
monederoAsset.y = 2590; // Below tragamonedas asset (2600 - 10 pixels up)
monederoAsset.alpha = 0; // Start hidden
game.addChild(monederoAsset);
// Add Monedero2 asset in bottom right corner at same height as Monedero
var monedero2Asset = LK.getAsset('Monedero2', {
	anchorX: 0.5,
	anchorY: 0.5
});
monedero2Asset.x = 1648; // Right side position moved 60 pixels left (1708 - 60)
monedero2Asset.y = 2590; // Same height as Monedero
monedero2Asset.alpha = 0; // Start hidden
game.addChild(monedero2Asset);
// Add mas asset to top right of Monedero
var masAsset = LK.getAsset('mas', {
	anchorX: 0.5,
	anchorY: 0.5
});
masAsset.x = 570; // Right side of Monedero moved 20 pixels right (550 + 20)
masAsset.y = 2510; // Above Monedero moved 60 pixels down (2450 + 60) 
masAsset.alpha = 0; // Start hidden
game.addChild(masAsset);
// Add click handler for mas asset
masAsset.down = function (x, y, obj) {
	if (gameMode !== 'slots') return;
	if (currentBet * 2 <= playerMoney) {
		currentBet *= 2;
		totalBetDisplay.setText('$' + currentBet);
		spinButton.setText('SPIN $' + currentBet);
	}
};
// Add menos asset to bottom right of Monedero
var menosAsset = LK.getAsset('menos', {
	anchorX: 0.5,
	anchorY: 0.5
});
menosAsset.x = 570; // Right side of Monedero moved 20 pixels right (550 + 20)
menosAsset.y = 2680; // Below Monedero moved 10 pixels up (2690 - 10) 
menosAsset.alpha = 0; // Start hidden
game.addChild(menosAsset);
// Add click handler for menos asset
menosAsset.down = function (x, y, obj) {
	if (gameMode !== 'slots') return;
	if (currentBet / 2 >= 25) {
		currentBet = currentBet / 2;
		totalBetDisplay.setText('$' + currentBet);
		spinButton.setText('SPIN $' + currentBet);
	}
};
// Add Megaways slot machine above tragamonedas (higher z-index)
var megawaysSlotMachine = game.addChild(new MegawaysSlotMachine());
megawaysSlotMachine.x = 954; // Moved right by 60 pixels (894 + 60)
megawaysSlotMachine.y = 1250; // Moved down by 200 pixels total (1050 + 200)
megawaysSlotMachine.scaleX = 1.6; // Scale by 1.6 times larger
megawaysSlotMachine.scaleY = 2.73; // Scale by 2.73 times larger (2.53 + 0.20 for additional 50px stretch)
megawaysSlotMachine.alpha = 0;
// Megaways display (hidden by default)
var waysDisplay = new Text2('117,649 WAYS', {
	size: 48,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
waysDisplay.anchor.set(0.5, 0.5);
waysDisplay.x = 1024;
waysDisplay.y = 900;
waysDisplay.alpha = 0;
game.addChild(waysDisplay);
// Win amount display
var winAmountDisplay = new Text2('WIN: $0', {
	size: 56,
	fill: '#00FF00',
	font: "'Arial Black', Arial, sans-serif"
});
winAmountDisplay.anchor.set(0.5, 0.5);
winAmountDisplay.x = 1648;
winAmountDisplay.y = 2590;
winAmountDisplay.alpha = 0;
game.addChild(winAmountDisplay);
// Disclaimer UI elements
// Use black background instead of warning asset
game.setBackgroundColor(0x000000);
var disclaimerTitle = new Text2('⚠️ IMPORTANT WARNING ⚠️', {
	size: 126,
	fill: '#FF0000',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerTitle.anchor.set(0.5, 0.5);
disclaimerTitle.x = 1024;
disclaimerTitle.y = 650;
disclaimerTitle.alpha = 1;
game.addChild(disclaimerTitle);
var disclaimerText1 = new Text2('• This game features a save system', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText1.anchor.set(0.5, 0.5);
disclaimerText1.x = 1024;
disclaimerText1.y = 950;
disclaimerText1.alpha = 1;
game.addChild(disclaimerText1);
var disclaimerText2 = new Text2('• If you run out of virtual money,', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText2.anchor.set(0.5, 0.5);
disclaimerText2.x = 1024;
disclaimerText2.y = 1060;
disclaimerText2.alpha = 1;
game.addChild(disclaimerText2);
var disclaimerText3 = new Text2('the only way to earn more is with the wheel', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText3.anchor.set(0.5, 0.5);
disclaimerText3.x = 1024;
disclaimerText3.y = 1170;
disclaimerText3.alpha = 1;
game.addChild(disclaimerText3);
var disclaimerText4 = new Text2('• This game is for entertainment only', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText4.anchor.set(0.5, 0.5);
disclaimerText4.x = 1024;
disclaimerText4.y = 1280;
disclaimerText4.alpha = 1;
game.addChild(disclaimerText4);
var disclaimerText5 = new Text2('• NO real money is involved', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText5.anchor.set(0.5, 0.5);
disclaimerText5.x = 1024;
disclaimerText5.y = 1390;
disclaimerText5.alpha = 1;
game.addChild(disclaimerText5);
var disclaimerText6 = new Text2('• Gambling can be addictive', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText6.anchor.set(0.5, 0.5);
disclaimerText6.x = 1024;
disclaimerText6.y = 1500;
disclaimerText6.alpha = 1;
game.addChild(disclaimerText6);
var disclaimerText7 = new Text2('• Real gambling can be harmful', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText7.anchor.set(0.5, 0.5);
disclaimerText7.x = 1024;
disclaimerText7.y = 1610;
disclaimerText7.alpha = 1;
game.addChild(disclaimerText7);
var disclaimerText8 = new Text2('• Please seek help if needed', {
	size: 62,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
disclaimerText8.anchor.set(0.5, 0.5);
disclaimerText8.x = 1024;
disclaimerText8.y = 1720;
disclaimerText8.alpha = 1;
game.addChild(disclaimerText8);
var continueButton = game.addChild(new GameButton('I UNDERSTAND - CONTINUE', 400, 100));
continueButton.x = 1024;
continueButton.y = 2140;
continueButton.alpha = 1;
// Create larger invisible hit area for better touch responsiveness
var continueButtonHitArea = LK.getAsset('button', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 600,
	// 50% wider than original
	height: 150,
	// 50% taller than original
	alpha: 0 // Invisible
});
continueButtonHitArea.x = 0;
continueButtonHitArea.y = 0;
continueButton.addChild(continueButtonHitArea);
// Make the hit area interactive and forward events to the button
continueButtonHitArea.interactive = true;
continueButtonHitArea.buttonMode = true;
continueButtonHitArea.down = function (x, y, obj) {
	if (continueButton.down) continueButton.down(x, y, obj);
};
continueButtonHitArea.up = function (x, y, obj) {
	if (continueButton.up) continueButton.up(x, y, obj);
};
// Cascade counter (hidden by default)
var cascadeDisplay = new Text2('', {
	size: 84,
	fill: '#FF6347',
	font: "'Arial Black', Arial, sans-serif"
});
cascadeDisplay.anchor.set(0.5, 0.5);
cascadeDisplay.x = 1024;
cascadeDisplay.y = 1366;
cascadeDisplay.alpha = 0;
game.addChild(cascadeDisplay);
// Cascade animation variables
var lastCascadeCount = 0;
var cascadeAnimationDisplay = null;
// Game state
var playerMoney = storage.playerMoney || 1000;
var currentBet = 0;
var gameMode = 'disclaimer'; // 'disclaimer', 'menu', 'blackjack', 'slots'
var wheelScreenOpen = false; // Track if wheel screen is currently open
var freeSpins = storage.freeSpins || 0; // Track free spins available
// Blinking text variables
var spinHereText = null;
var spinHereTextTimer = null;
var spinHereBlinkTimer = null;
// SpinI blinking variables
var spinITimer = null;
var spinIBlinkTimer = null;
var spinIRecurringTimer = null;
var spinISoundToggle = false; // Track when to play sound (alternating)
// Initialize achievement system
var achievementSystem = new AchievementSystem();
// Achievement tracking variables
var consecutiveWins = storage.consecutiveWins || 0;
var confirmedHighBet = false;
// Chip system
var chips = [];
var chipContainer = game.addChild(new Container());
chipContainer.x = 1004; // Move 20 pixels left (1024 - 20)
chipContainer.y = 2300; // Position below player cards
chipContainer.alpha = 0;
var moneyAfterBet = 0;
var moneyAfterSpin = 0;
var deck = [];
var playerCards = [];
var dealerCards = [];
var gamePhase = 'betting'; // 'betting', 'dealing', 'playing', 'dealer', 'finished'
var handInProgress = false; // Track if a hand is currently in progress
var lastWaysCount = 0;
var waysAnimationDisplay = null;
// Total bet display for slots (positioned in center of Monedero)
var totalBetDisplay = new Text2('$' + currentBet, {
	size: 108,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
totalBetDisplay.anchor.set(0.5, 0.5);
totalBetDisplay.x = 280; // Same x position as Monedero
totalBetDisplay.y = 2590; // Same y position as Monedero
totalBetDisplay.alpha = 0; // Start hidden
game.addChild(totalBetDisplay);
// UI Elements
var moneyDisplay = new Text2('$1000', {
	size: 112,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
moneyDisplay.anchor.set(0.5, 0.5);
moneyDisplay.x = 974;
moneyDisplay.y = 2596; // Position to overlap BalanceB asset (moved 30 pixels down)
moneyDisplay.alpha = 0;
game.addChild(moneyDisplay);
// Add Remove asset positioned above TotalA asset
var removeAsset = LK.getAsset('Remove', {
	anchorX: 0.5,
	anchorY: 0.5
});
removeAsset.x = 1724; // Same x position as totalA asset
removeAsset.y = 2375; // Positioned above totalA asset (2475 - 100)
removeAsset.alpha = 0;
game.addChild(removeAsset);
// Add click handler for Remove button
removeAsset.down = function (x, y, obj) {
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'betting') return;
	// Reset bet to 0
	currentBet = 0;
	updateChipSelection();
	LK.getSound('Ficha_2').play();
};
// Add TotalA asset at same horizontal height as chips and same vertical height as Home
var totalAAsset = LK.getAsset('TotalA', {
	anchorX: 0.5,
	anchorY: 0.5
});
totalAAsset.x = 1724; // Move 200 pixels right from previous position (1524 + 200)
totalAAsset.y = 2550; // Move 150 pixels down from previous position (2400 + 150)
totalAAsset.alpha = 0;
game.addChild(totalAAsset);
// Add bet value display positioned at center of TotalA asset
var betValueDisplay = new Text2('$' + currentBet, {
	size: 83,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
betValueDisplay.anchor.set(0.5, 0.5);
betValueDisplay.x = 1814; // Move 10 pixels left (1824 - 10)
betValueDisplay.y = 2545; // Move 5 pixels down (2540 + 5)
betValueDisplay.alpha = 0;
game.addChild(betValueDisplay);
// Add BalanceB asset positioned in the middle of money display
var balanceBAsset = LK.getAsset('BalanceB', {
	anchorX: 0.5,
	anchorY: 0.5
});
balanceBAsset.x = 974; // Same x position as money display
balanceBAsset.y = 2566; // Moved 20 pixels down (2546 + 20)
balanceBAsset.alpha = 0;
game.addChild(balanceBAsset);
// Add BalanceBJ asset positioned at same height as TotalA but on left side
var balanceBJAsset = LK.getAsset('BalanceBJ', {
	anchorX: 0.5,
	anchorY: 0.5
});
balanceBJAsset.x = 324; // Left side position (mirroring TotalA position)
balanceBJAsset.y = 2500; // Moved 30 pixels up (2530 - 30)
balanceBJAsset.alpha = 0;
game.addChild(balanceBJAsset);
// Add Apuesta asset below deal button in blackjack mode
var apuestaAsset = LK.getAsset('Apuesta', {
	anchorX: 0.5,
	anchorY: 0.5
});
apuestaAsset.x = 1024; // Same x position as deal button
apuestaAsset.y = 1650; // Position below deal button (1450 + 200)
apuestaAsset.alpha = 0;
game.addChild(apuestaAsset);
// Add player money display in center of BalanceBJ asset
var playerMoneyDisplay = new Text2('$' + playerMoney, {
	size: 75,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
playerMoneyDisplay.anchor.set(0.5, 0.5);
playerMoneyDisplay.x = 324; // Same x position as BalanceBJ asset
playerMoneyDisplay.y = 2530; // Moved 10 pixels up (2540 - 10)
playerMoneyDisplay.alpha = 0;
game.addChild(playerMoneyDisplay);
// Move money display after BalanceB so it renders on top
game.removeChild(moneyDisplay);
game.addChild(moneyDisplay);
// Create message display for game feedback
var messageDisplay = new Text2('', {
	size: 56,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
messageDisplay.anchor.set(0.5, 0.5);
messageDisplay.x = 1024;
messageDisplay.y = 800;
messageDisplay.alpha = 0;
game.addChild(messageDisplay);
// Add welcome asset to main menu
var welcomeAsset = LK.getAsset('Welcome', {
	anchorX: 0.5,
	anchorY: 0.5
});
welcomeAsset.x = 1024;
welcomeAsset.y = 400; // 700 pixels above blackjack button (1100 - 700)
game.addChild(welcomeAsset);
// Menu buttons
var blackjackButton = game.addChild(new GameButton('BLACKJACK', 300, 100));
blackjackButton.x = 1024;
blackjackButton.y = 1100;
// Replace the default button background with BlackJ asset
var blackjackAsset = LK.getAsset('BlackJ', {
	anchorX: 0.5,
	anchorY: 0.5
});
blackjackButton.removeChild(blackjackButton.children[1]); // Remove default background
blackjackButton.addChildAt(blackjackAsset, 1); // Add new asset as background
var slotsButton = game.addChild(new GameButton('SLOT MACHINE', 300, 100));
slotsButton.x = 1004;
slotsButton.y = 1750;
// Replace the default button background with MaquinaB asset
var slotAsset = LK.getAsset('MaquinaB', {
	anchorX: 0.5,
	anchorY: 0.5,
	width: 550,
	height: 550
});
slotsButton.removeChild(slotsButton.children[1]); // Remove default background
slotsButton.addChildAt(slotAsset, 1); // Add new asset as background
// Blackjack UI
var hitButton = LK.getAsset('hit', {
	anchorX: 0.5,
	anchorY: 0.5
});
hitButton.x = 770; // Move 100 pixels right (670 + 100)
hitButton.y = 2400;
hitButton.alpha = 0;
game.addChild(hitButton);
var standButton = LK.getAsset('stand', {
	anchorX: 0.5,
	anchorY: 0.5
});
standButton.x = 1000; // Move 100 pixels right (900 + 100)
standButton.y = 2400;
standButton.alpha = 0;
standButton.interactive = true;
standButton.buttonMode = true;
game.addChild(standButton);
var doubleButton = LK.getAsset('double', {
	anchorX: 0.5,
	anchorY: 0.5
});
doubleButton.x = 1230; // Move 100 pixels right (1130 + 100)
doubleButton.y = 2400;
doubleButton.alpha = 0;
game.addChild(doubleButton);
// Deal button for blackjack
var dealButton = LK.getAsset('DealB', {
	anchorX: 0.5,
	anchorY: 0.5
});
dealButton.x = 1024; // Center of table
dealButton.y = 1300; // Move 500 pixels up from previous position (1800 - 500)
dealButton.alpha = 0;
game.addChild(dealButton);
// Slots UI (classic slots removed - using Megaways only)
var spinButton = game.addChild(new GameButton('SPIN $25', 200, 80));
spinButton.x = 974;
spinButton.y = 2230;
spinButton.alpha = 0;
// Replace the default button background with circular assets
spinButton.removeChild(spinButton.children[0]); // Remove shadow
spinButton.removeChild(spinButton.children[0]); // Remove background (index shifts after first removal)
var circularButton = LK.getAsset('circularSpinButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
spinButton.addChildAt(circularButton, 0);
// Create money difference display in center of Monedero2 asset
var moneyDifferenceDisplay = new Text2('$0', {
	size: 79,
	fill: '#00FF00',
	font: "'Arial Black', Arial, sans-serif"
});
moneyDifferenceDisplay.anchor.set(0.5, 0.5);
moneyDifferenceDisplay.x = 1648; // Same x position as Monedero2 asset
moneyDifferenceDisplay.y = 2590; // Same y position as Monedero2 asset
moneyDifferenceDisplay.alpha = 0;
// Add to game to position in center of Monedero2
game.addChild(moneyDifferenceDisplay);
// Create new Home button with Home asset in upper right corner
var homeButton = game.addChild(new GameButton('', 100, 100));
homeButton.x = 1850; // Upper right corner position (2048 - 198 to avoid top left menu area)
homeButton.y = 200; // Near top of screen but below status bar
homeButton.alpha = 0;
// Replace the default button background with Home asset
homeButton.removeChild(homeButton.children[0]); // Remove shadow
homeButton.removeChild(homeButton.children[0]); // Remove background (index shifts after first removal)
var homeAsset = LK.getAsset('Home', {
	anchorX: 0.5,
	anchorY: 0.5
});
homeButton.addChildAt(homeAsset, 0);
// Create Logros button in bottom left of main menu
var logrosButton = game.addChild(new GameButton('', 100, 100));
logrosButton.x = 200; // Bottom left corner position
logrosButton.y = 2500; // Bottom of screen
logrosButton.alpha = 0;
// Replace the default button background with Logros asset
logrosButton.removeChild(logrosButton.children[0]); // Remove shadow
logrosButton.removeChild(logrosButton.children[0]); // Remove background (index shifts after first removal)
var logrosAsset = LK.getAsset('Logros', {
	anchorX: 0.5,
	anchorY: 0.5
});
logrosButton.addChildAt(logrosAsset, 0);
// Create RuedaP button at Sugerencia position
var ruedaPButton = game.addChild(new GameButton('', 100, 100));
ruedaPButton.x = 1848; // Same position as Sugerencia asset
ruedaPButton.y = 2500; // Same position as Sugerencia asset
ruedaPButton.alpha = 0;
// Replace the default button background with RuedaP asset
ruedaPButton.removeChild(ruedaPButton.children[0]); // Remove shadow
ruedaPButton.removeChild(ruedaPButton.children[0]); // Remove background (index shifts after first removal)
var ruedaPAsset = LK.getAsset('RuedaP', {
	anchorX: 0.5,
	anchorY: 0.5
});
ruedaPButton.addChildAt(ruedaPAsset, 0);
// Create SpinI button to the left of RuedaP
var spinIButton = game.addChild(new GameButton('', 100, 100));
spinIButton.x = 1488; // Moved 40 pixels to the right (1448 + 40)
spinIButton.y = 2500; // Same height as RuedaP
spinIButton.alpha = 0;
// Replace the default button background with SpinI asset
spinIButton.removeChild(spinIButton.children[0]); // Remove shadow
spinIButton.removeChild(spinIButton.children[0]); // Remove background (index shifts after first removal)
var spinIAsset = LK.getAsset('SpinI', {
	anchorX: 0.5,
	anchorY: 0.5
});
spinIButton.addChildAt(spinIAsset, 0);
// Add deck and hands
var gameDeck = game.addChild(new Deck());
gameDeck.x = 200;
gameDeck.y = 1366;
gameDeck.alpha = 0;
// Add animated hands for dealing animations
var dealerAnimatedHand = game.addChild(new AnimatedHand(true));
dealerAnimatedHand.x = 300;
dealerAnimatedHand.y = 600;
dealerAnimatedHand.alpha = 0;
var playerAnimatedHand = game.addChild(new AnimatedHand(false));
playerAnimatedHand.x = 300;
playerAnimatedHand.y = 2000;
playerAnimatedHand.alpha = 0;
// Score displays
var playerScoreText = new Text2('Player: 0', {
	size: 36,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
playerScoreText.anchor.set(0.5, 0.5);
playerScoreText.x = 1024;
playerScoreText.y = 1850;
playerScoreText.alpha = 0;
game.addChild(playerScoreText);
var dealerScoreText = new Text2('Dealer: 0', {
	size: 36,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
dealerScoreText.anchor.set(0.5, 0.5);
dealerScoreText.x = 1024;
dealerScoreText.y = 750;
dealerScoreText.alpha = 0;
game.addChild(dealerScoreText);
// Create betting chips
function createChips() {
	// Clear existing chips
	for (var i = 0; i < chips.length; i++) {
		chips[i].destroy();
	}
	chips = [];
	var chipValues = [1, 5, 10, 25, 100, 500];
	for (var i = 0; i < chipValues.length; i++) {
		var chip = new Chip(chipValues[i]);
		chip.x = (i - 2.5) * 120; // Spread chips horizontally with 20 more pixels separation
		chip.y = 300; // Move chips 300 pixels down
		chipContainer.addChild(chip);
		chips.push(chip);
	}
	updateChipSelection();
}
function updateChipSelection() {
	// Update chip availability based on player money
	for (var i = 0; i < chips.length; i++) {
		chips[i].setEnabled(playerMoney >= chips[i].value);
	}
	// Update bet value display at center of TotalA asset
	betValueDisplay.setText('$' + currentBet);
	// Update deal button state based on bet amount - only show once per hand
	if (gameMode === 'blackjack' && !handInProgress) {
		if (currentBet === 0) {
			// Hide deal button when bet is zero
			tween(dealButton, {
				alpha: 0
			}, {
				duration: 200
			});
			// Hide remove button when bet is zero
			tween(removeAsset, {
				alpha: 0
			}, {
				duration: 200
			});
		} else {
			// Show deal button when bet is greater than zero and no hand in progress
			tween(dealButton, {
				alpha: 1
			}, {
				duration: 200
			});
			// Show remove button when bet is greater than zero and no hand in progress
			tween(removeAsset, {
				alpha: 1
			}, {
				duration: 200
			});
		}
	}
}
// Button event handlers
blackjackButton.up = function () {
	if (gameMode !== 'menu') return;
	if (!blackjackButton.enabled) return;
	switchToBlackjack();
};
slotsButton.up = function () {
	if (gameMode !== 'menu') return;
	if (!slotsButton.enabled) return;
	switchToSlots();
};
hitButton.down = function (x, y, obj) {
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'playing') return;
	playerHit();
};
standButton.down = function (x, y, obj) {
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'playing') return;
	// Don't call playerStand() on down event to prevent double calls
	LK.getSound('buttonClick').play();
};
standButton.up = function (x, y, obj) {
	// Stand button up handler - only call playerStand here
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'playing') return;
	// Only trigger if we haven't already processed this action
	if (gamePhase === 'playing') {
		playerStand();
	}
};
doubleButton.down = function (x, y, obj) {
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'playing') return;
	if (playerMoney < currentBet) return;
	playerDouble();
};
homeButton.up = function () {
	if (!homeButton.enabled) return;
	// Prevent leaving blackjack if hand is in progress
	if (gameMode === 'blackjack' && handInProgress) return;
	// Prevent leaving slots if spin is in progress
	if (gameMode === 'slots' && slotsSpinInProgress) return;
	switchToMenu();
};
logrosButton.up = function () {
	if (gameMode !== 'menu') return;
	if (!logrosButton.enabled) return;
	showAchievementsScreen();
};
ruedaPButton.up = function () {
	if (gameMode !== 'menu') return;
	if (!ruedaPButton.enabled) return;
	if (wheelScreenOpen) return; // Prevent re-entry if wheel is already open
	showWheelScreen();
};
// SpinI button has no functionality - purely aesthetic
continueButton.up = function () {
	if (gameMode !== 'disclaimer') return;
	if (!continueButton.enabled) return;
	switchToMenu();
};
dealButton.down = function (x, y, obj) {
	if (gameMode !== 'blackjack') return;
	if (gamePhase !== 'betting') return;
	if (currentBet === 0) return; // Can't deal with zero bet
	// Hide deal button immediately when pressed
	dealButton.alpha = 0;
	startNewBlackjackHand();
};
spinButton.up = function () {
	if (gameMode !== 'slots') return;
	if (!spinButton.enabled) return;
	spinSlots();
};
// Game functions
function updateMoneyDisplay() {
	moneyDisplay.setText('$' + playerMoney);
	playerMoneyDisplay.setText('$' + playerMoney);
	storage.playerMoney = playerMoney;
	updateMoneyDifferenceDisplay();
	achievementSystem.checkAchievement('reach10k', playerMoney);
	// Update chip availability if in blackjack mode
	if (gameMode === 'blackjack' && chips.length > 0) {
		updateChipSelection();
	}
	// Reset bet to 25 if current bet exceeds player money and we're in slots mode
	if (gameMode === 'slots' && currentBet > playerMoney) {
		currentBet = 25;
		totalBetDisplay.setText('$' + currentBet);
		spinButton.setText('SPIN $' + currentBet);
		spinButton.setEnabled(playerMoney >= currentBet);
	}
	// Reset bet in blackjack if current bet exceeds player money
	if (gameMode === 'blackjack' && currentBet > playerMoney) {
		// Find highest affordable chip value
		var affordableChips = [1, 5, 10, 25, 100, 500].filter(function (value) {
			return value <= playerMoney;
		});
		if (affordableChips.length > 0) {
			currentBet = affordableChips[affordableChips.length - 1];
		} else {
			currentBet = 1;
		}
		updateChipSelection();
	}
	if (playerMoney >= 1000000) {
		LK.showYouWin();
	} else if (playerMoney <= 0) {
		LK.showGameOver();
	}
}
function updateMoneyDifferenceDisplay() {
	var difference = moneyAfterSpin - moneyAfterBet;
	moneyDifferenceDisplay.setText('$' + difference);
	// Clear any existing spin here text
	if (spinHereText) {
		spinHereText.destroy();
		spinHereText = null;
	}
	if (spinHereTextTimer) {
		LK.clearTimeout(spinHereTextTimer);
		spinHereTextTimer = null;
	}
	if (spinHereBlinkTimer) {
		LK.clearInterval(spinHereBlinkTimer);
		spinHereBlinkTimer = null;
	}
	// Create blinking "spin here" text after 2 seconds in main menu
	spinHereTextTimer = LK.setTimeout(function () {
		if (gameMode !== 'menu') return; // Only show if still in menu
		// Create "spin here" text
		spinHereText = new Text2('SPIN HERE', {
			size: 48,
			fill: '#FFD700',
			font: "'Arial Black', Arial, sans-serif"
		});
		spinHereText.anchor.set(0.5, 0.5);
		spinHereText.x = 1848;
		spinHereText.y = 2350; // Position above RuedaP button at new location (2500 - 150)
		spinHereText.alpha = 1;
		game.addChild(spinHereText);
		// Make it blink
		var blinkVisible = true;
		spinHereBlinkTimer = LK.setInterval(function () {
			if (!spinHereText) return;
			blinkVisible = !blinkVisible;
			tween(spinHereText, {
				alpha: blinkVisible ? 1 : 0.3
			}, {
				duration: 500,
				easing: tween.easeInOut
			});
		}, 600);
	}, 2000);
	// Clear any existing SpinI timers when entering menu
	if (spinITimer) {
		LK.clearTimeout(spinITimer);
		spinITimer = null;
	}
	if (spinIBlinkTimer) {
		LK.clearInterval(spinIBlinkTimer);
		spinIBlinkTimer = null;
	}
	// Card display removed from menu
}
function createDeck() {
	deck = [];
	var suits = ['hearts', 'diamonds', 'clubs', 'spades'];
	for (var s = 0; s < suits.length; s++) {
		for (var v = 1; v <= 13; v++) {
			deck.push({
				suit: suits[s],
				value: v
			});
		}
	}
	// Shuffle 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;
	}
}
function dealCard(isDealer, callback) {
	if (deck.length === 0) createDeck();
	var cardData = deck.pop();
	var card = isDealer ? new DealerCard(cardData.suit, cardData.value) : new Card(cardData.suit, cardData.value);
	var targetX, targetY;
	if (isDealer) {
		dealerCards.push(card);
		targetX = 930 + (dealerCards.length - 1) * 240; // Move dealer cards 20 pixels left (950 - 20)
		targetY = 500;
	} else {
		playerCards.push(card);
		targetX = 850 + (playerCards.length - 1) * 280; // Move player cards 50 pixels right (800 + 50)
		targetY = 2100;
	}
	card.x = targetX;
	card.y = targetY;
	card.alpha = 0;
	game.addChild(card);
	// Use animated hand for dealing
	var animatedHand = isDealer ? dealerAnimatedHand : playerAnimatedHand;
	if (isDealer) {
		animatedHand.dealCardFaceDown(targetX, targetY, function () {
			tween(card, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {
					card.flip();
					if (callback) callback();
				}
			});
		});
	} else {
		animatedHand.dealCardToPlayer(targetX, targetY, function () {
			tween(card, {
				alpha: 1
			}, {
				duration: 200,
				onFinish: function onFinish() {
					card.flip();
					if (callback) callback();
				}
			});
		});
	}
	return card;
}
function calculateHandValue(cards) {
	var value = 0;
	var aces = 0;
	for (var i = 0; i < cards.length; i++) {
		var cardValue = cards[i].getBlackjackValue();
		if (cardValue === 11) aces++;
		value += cardValue;
	}
	// Adjust for aces
	while (value > 21 && aces > 0) {
		value -= 10;
		aces--;
	}
	return value;
}
function updateScoreDisplays() {
	var playerScore = calculateHandValue(playerCards);
	var dealerScore = calculateHandValue(dealerCards);
	playerScoreText.setText('Player: ' + playerScore);
	if (dealerCards.length > 0 && dealerCards[0].faceUp) {
		dealerScoreText.setText('Dealer: ' + dealerScore);
	} else if (dealerCards.length > 1) {
		var visibleScore = dealerCards[1].getBlackjackValue();
		dealerScoreText.setText('Dealer: ' + visibleScore + ' + ?');
	}
}
function crossFadeTransition(hideElements, showElements, callback) {
	var fadeOutComplete = 0;
	var totalFadeOut = hideElements.length;
	// Fade out old elements
	for (var i = 0; i < hideElements.length; i++) {
		tween(hideElements[i], {
			alpha: 0
		}, {
			duration: 400,
			easing: tween.easeInOut,
			onFinish: function onFinish() {
				fadeOutComplete++;
				if (fadeOutComplete === totalFadeOut) {
					// Start fading in new elements
					for (var j = 0; j < showElements.length; j++) {
						tween(showElements[j], {
							alpha: showElements[j].targetAlpha || 1
						}, {
							duration: 400,
							delay: j * 50,
							easing: tween.easeInOut
						});
					}
					if (callback) callback();
				}
			}
		});
	}
}
function switchToMenu() {
	gameMode = 'menu';
	// Set background to match fondoM to prevent green strip
	game.setBackgroundColor(0x000000);
	// Play random crupier menu sound on first entry to menu
	if (isFirstMenuEntry) {
		var menuSounds = ['Cuprier_Menu_1', 'Cuprier_Menu_2', 'Cuprier_Menu_3'];
		var randomSound = menuSounds[Math.floor(Math.random() * menuSounds.length)];
		LK.getSound(randomSound).play();
		isFirstMenuEntry = false; // Set to false after first play
	}
	// Re-enable buttons when entering menu (they were disabled during disclaimer)
	blackjackButton.setEnabled(true);
	slotsButton.setEnabled(true);
	logrosButton.setEnabled(true);
	ruedaPButton.setEnabled(true);
	spinIButton.setEnabled(true);
	// Clear SpinI timers when switching modes
	if (spinITimer) {
		LK.clearTimeout(spinITimer);
		spinITimer = null;
	}
	if (spinIBlinkTimer) {
		LK.clearInterval(spinIBlinkTimer);
		spinIBlinkTimer = null;
	}
	// Start SpinI visibility timer - show SpinI after 3 seconds in menu
	spinITimer = LK.setTimeout(function () {
		if (gameMode !== 'menu') return; // Only show if still in menu
		// Show SpinI button first
		spinIButton.alpha = 1; // Make button visible immediately
		// Reset sound toggle when starting new animation sequence
		spinISoundToggle = false;
		// Start continuous alpha alternation between 1 and 0 every second
		function alternateAlpha() {
			tween(spinIAsset, {
				alpha: 0
			}, {
				duration: 1000,
				onFinish: function onFinish() {
					tween(spinIAsset, {
						alpha: 1
					}, {
						duration: 1000,
						onFinish: function onFinish() {
							// Toggle sound - play only every other time
							spinISoundToggle = !spinISoundToggle;
							if (spinISoundToggle && gameMode === 'menu') {
								LK.getSound('SpinHere').play();
							}
							alternateAlpha();
						}
					});
				}
			});
		}
		alternateAlpha();
	}, 3000);
	// Add recurring check every 3 seconds to ensure SpinI is visible in menu
	spinIRecurringTimer = LK.setInterval(function () {
		if (gameMode !== 'menu') return; // Only check if in menu
		if (spinIButton.alpha === 0 || spinIAsset.alpha === 0) {
			// Restart the blinking animation
			var _alternateAlpha = function alternateAlpha() {
				tween(spinIAsset, {
					alpha: 0
				}, {
					duration: 1000,
					onFinish: function onFinish() {
						tween(spinIAsset, {
							alpha: 1
						}, {
							duration: 1000,
							onFinish: function onFinish() {
								// Toggle sound - play only every other time
								spinISoundToggle = !spinISoundToggle;
								if (spinISoundToggle && gameMode === 'menu') {
									LK.getSound('SpinHere').play();
								}
								_alternateAlpha();
							}
						});
					}
				});
			};
			// SpinI is not visible, make it visible and restart animation
			spinIButton.alpha = 1;
			spinIAsset.alpha = 1;
			// Reset sound toggle when restarting animation
			spinISoundToggle = false;
			_alternateAlpha();
		} else {
			// SpinI is visible, stop the recurring timer
			LK.clearInterval(spinIRecurringTimer);
			spinIRecurringTimer = null;
		}
	}, 3000);
	// Disable buttons from other game modes
	hitButton.interactive = false;
	hitButton.buttonMode = false;
	standButton.interactive = false;
	standButton.buttonMode = false;
	doubleButton.interactive = false;
	doubleButton.buttonMode = false;
	dealButton.interactive = false;
	dealButton.buttonMode = false;
	spinButton.setEnabled(false);
	for (var i = 0; i < chips.length; i++) {
		if (chips[i] && chips[i].setEnabled) {
			chips[i].setEnabled(false);
		}
	}
	masAsset.interactive = false;
	masAsset.buttonMode = false;
	menosAsset.interactive = false;
	menosAsset.buttonMode = false;
	removeAsset.interactive = false;
	removeAsset.buttonMode = false;
	// Stop any currently playing music and play Menu music
	LK.stopMusic();
	LK.playMusic('Menu');
	tween(disclaimerTitle, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText1, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText2, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText3, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText4, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText5, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText6, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText7, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(disclaimerText8, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(continueButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide all game elements
	tween(hitButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(standButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(doubleButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(playerScoreText, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(dealerScoreText, {
		alpha: 0
	}, {
		duration: 300
	});
	// Classic slot reels removed (using Megaways only)
	tween(spinButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(gameDeck, {
		alpha: 0
	}, {
		duration: 300,
		onFinish: function onFinish() {
			// Stop deck animation when leaving blackjack mode
			if (gameDeck.stopDeckAnimation) {
				gameDeck.stopDeckAnimation();
			}
		}
	});
	tween(dealerAnimatedHand, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(playerAnimatedHand, {
		alpha: 0
	}, {
		duration: 300
	});
	// Show main menu background
	tween(fondoM, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show menu buttons
	tween(blackjackButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(slotsButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(welcomeAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show new menu buttons
	tween(logrosButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(ruedaPButton, {
		alpha: 1
	}, {
		duration: 300
	});
	// SpinI button will be shown after 3 seconds via timer
	spinIButton.alpha = 0; // Keep hidden initially
	// Card display removed from menu
	// Hide blackjack background
	tween(blackjackBackground, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide table background
	tween(tableBackground, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide slots background
	tween(slotsBackground, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide tragamonedas asset in menu mode
	tween(tragamonedasAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Monedero asset in menu mode
	tween(monederoAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Monedero2 asset in menu mode
	tween(monedero2Asset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide total bet display in menu mode
	tween(totalBetDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide mas asset in menu mode
	tween(masAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide menos asset in menu mode
	tween(menosAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Megaways slot machine
	// Show Home button in blackjack mode
	tween(homeButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(megawaysSlotMachine, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Megaways displays
	tween(waysDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(winAmountDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(cascadeDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide win amount display in menu mode
	tween(winAmountDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide ways animation if showing
	if (waysAnimationDisplay) {
		tween(waysAnimationDisplay, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				if (waysAnimationDisplay) {
					waysAnimationDisplay.destroy();
					waysAnimationDisplay = null;
				}
			}
		});
	}
	// Hide cascade animation if showing
	if (cascadeAnimationDisplay) {
		tween(cascadeAnimationDisplay, {
			alpha: 0
		}, {
			duration: 300,
			onFinish: function onFinish() {
				if (cascadeAnimationDisplay) {
					cascadeAnimationDisplay.destroy();
					cascadeAnimationDisplay = null;
				}
			}
		});
	}
	// Hide money display in menu mode
	tween(moneyDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide BalanceB asset in menu mode
	tween(balanceBAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Clear cards
	// Hide money difference display in menu mode
	tween(moneyDifferenceDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide chips in menu mode
	tween(chipContainer, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Home button in menu mode
	tween(homeButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide deal button in menu mode
	tween(dealButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Remove asset in menu mode
	tween(removeAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide TotalA asset in menu mode
	tween(totalAAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide bet value display in menu mode
	tween(betValueDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide BalanceBJ asset in menu mode
	tween(balanceBJAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide player money display in menu mode
	tween(playerMoneyDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Apuesta asset in menu mode
	tween(apuestaAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	clearTable();
}
function switchToBlackjack() {
	gameMode = 'blackjack';
	gamePhase = 'betting';
	// Reset bet to 0 when switching to blackjack
	currentBet = 0;
	// Stop any currently playing music and play BJ music
	LK.stopMusic();
	LK.playMusic('BJ');
	// Play random croupier BlackJack greeting sound
	var bjSounds = ['Cuprier_BJ_1', 'Cuprier_BJ_2', 'Cuprier_BJ_3'];
	var randomBJSound = bjSounds[Math.floor(Math.random() * bjSounds.length)];
	LK.getSound(randomBJSound).play();
	// Hide menu buttons
	tween(blackjackButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(slotsButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(welcomeAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide new menu buttons
	tween(logrosButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(ruedaPButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(spinIButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Disable menu buttons functionality in blackjack mode
	blackjackButton.setEnabled(false);
	slotsButton.setEnabled(false);
	logrosButton.setEnabled(false);
	ruedaPButton.setEnabled(false);
	spinIButton.setEnabled(false);
	// Enable blackjack buttons
	hitButton.interactive = true;
	hitButton.buttonMode = true;
	standButton.interactive = true;
	standButton.buttonMode = true;
	doubleButton.interactive = true;
	doubleButton.buttonMode = true;
	dealButton.interactive = true;
	dealButton.buttonMode = true;
	removeAsset.interactive = true;
	removeAsset.buttonMode = true;
	// Disable slots buttons functionality in blackjack mode
	spinButton.setEnabled(false);
	masAsset.interactive = false;
	masAsset.buttonMode = false;
	menosAsset.interactive = false;
	menosAsset.buttonMode = false;
	// Hide blinking text when leaving menu
	if (spinHereText) {
		spinHereText.destroy();
		spinHereText = null;
	}
	if (spinHereTextTimer) {
		LK.clearTimeout(spinHereTextTimer);
		spinHereTextTimer = null;
	}
	if (spinHereBlinkTimer) {
		LK.clearInterval(spinHereBlinkTimer);
		spinHereBlinkTimer = null;
	}
	// Clear SpinI timers when switching modes
	if (spinITimer) {
		LK.clearTimeout(spinITimer);
		spinITimer = null;
	}
	if (spinIBlinkTimer) {
		LK.clearInterval(spinIBlinkTimer);
		spinIBlinkTimer = null;
	}
	if (spinIRecurringTimer) {
		LK.clearInterval(spinIRecurringTimer);
		spinIRecurringTimer = null;
	}
	// Create blinking "spin here" text after 2 seconds in main menu
	spinHereTextTimer = LK.setTimeout(function () {
		if (gameMode !== 'menu') return; // Only show if still in menu
		// Create "spin here" text
		spinHereText = new Text2('SPIN HERE', {
			size: 48,
			fill: '#FFD700',
			font: "'Arial Black', Arial, sans-serif"
		});
		spinHereText.anchor.set(0.5, 0.5);
		spinHereText.x = 1848;
		spinHereText.y = 2350; // Position above RuedaP button at new location (2500 - 150)
		spinHereText.alpha = 1;
		game.addChild(spinHereText);
		// Make it blink
		var blinkVisible = true;
		spinHereBlinkTimer = LK.setInterval(function () {
			if (!spinHereText) return;
			blinkVisible = !blinkVisible;
			tween(spinHereText, {
				alpha: blinkVisible ? 1 : 0.3
			}, {
				duration: 500,
				easing: tween.easeInOut
			});
		}, 600);
	}, 2000);
	// Card display removed from menu
	// Hide main menu background
	tween(fondoM, {
		alpha: 0
	}, {
		duration: 300
	});
	// Show blackjack background
	tween(blackjackBackground, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show table background
	tween(tableBackground, {
		alpha: 0.8
	}, {
		duration: 300
	});
	// Ensure no unwanted coloring
	tableBackground.tint = 0xffffff;
	// Show blackjack UI
	tween(playerScoreText, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(dealerScoreText, {
		alpha: 1
	}, {
		duration: 300
	});
	// Ensure stand button is properly interactive
	standButton.interactive = true;
	standButton.buttonMode = true;
	tween(gameDeck, {
		alpha: 1
	}, {
		duration: 300,
		onFinish: function onFinish() {
			// Start deck animation when it becomes visible
			if (gameDeck.startDeckAnimation) {
				gameDeck.startDeckAnimation();
			}
		}
	});
	tween(dealerAnimatedHand, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(playerAnimatedHand, {
		alpha: 1
	}, {
		duration: 300
	});
	// Hide total bet display in blackjack mode
	tween(totalBetDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Monedero2 asset in blackjack mode
	tween(monedero2Asset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide mas asset in blackjack mode
	tween(masAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide menos asset in blackjack mode
	tween(menosAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide money display in blackjack mode
	tween(moneyDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide money difference display in blackjack mode
	tween(moneyDifferenceDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide BalanceB asset in blackjack mode
	tween(balanceBAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Show Home button in blackjack mode
	tween(homeButton, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Remove asset in blackjack mode
	tween(removeAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show TotalA asset in blackjack mode
	tween(totalAAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show bet value display in blackjack mode
	tween(betValueDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show BalanceBJ asset in blackjack mode
	tween(balanceBJAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show player money display in blackjack mode
	tween(playerMoneyDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Apuesta asset in blackjack mode
	tween(apuestaAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show deal button in blackjack mode only if bet is greater than zero
	if (currentBet > 0) {
		tween(dealButton, {
			alpha: 1
		}, {
			duration: 300
		});
	} else {
		dealButton.alpha = 0; // Keep hidden if no bet
	}
	// Show chips and bet display
	tween(chipContainer, {
		alpha: 1
	}, {
		duration: 300
	});
	// Create chips if not already created
	if (chips.length === 0) {
		createChips();
	} else {
		updateChipSelection();
	}
}
function switchToSlots() {
	gameMode = 'slots';
	// Stop any currently playing music and play SpinM music
	LK.stopMusic();
	LK.playMusic('SpinM');
	// Hide menu buttons
	tween(blackjackButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(slotsButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(welcomeAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide new menu buttons
	tween(logrosButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(ruedaPButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(spinIButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Disable menu buttons functionality in slots mode
	blackjackButton.setEnabled(false);
	slotsButton.setEnabled(false);
	logrosButton.setEnabled(false);
	ruedaPButton.setEnabled(false);
	spinIButton.setEnabled(false);
	// Disable blackjack buttons functionality in slots mode
	hitButton.interactive = false;
	hitButton.buttonMode = false;
	standButton.interactive = false;
	standButton.buttonMode = false;
	doubleButton.interactive = false;
	doubleButton.buttonMode = false;
	dealButton.interactive = false;
	dealButton.buttonMode = false;
	removeAsset.interactive = false;
	removeAsset.buttonMode = false;
	for (var i = 0; i < chips.length; i++) {
		if (chips[i] && chips[i].setEnabled) {
			chips[i].setEnabled(false);
		}
	}
	// Enable slots buttons
	masAsset.interactive = true;
	masAsset.buttonMode = true;
	menosAsset.interactive = true;
	menosAsset.buttonMode = true;
	// Card display removed from menu
	// Hide main menu background
	tween(fondoM, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide blackjack background
	tween(blackjackBackground, {
		alpha: 0
	}, {
		duration: 300
	});
	// Show slots background (same as main menu)
	tween(fondoM, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show tragamonedas asset in slots mode
	tween(tragamonedasAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Monedero asset in slots mode
	tween(monederoAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Monedero2 asset in slots mode
	tween(monedero2Asset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show total bet display in slots mode
	tween(totalBetDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show mas asset in slots mode
	tween(masAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show menos asset in slots mode
	tween(menosAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Megaways slot machine
	tween(megawaysSlotMachine, {
		alpha: 1
	}, {
		duration: 300
	});
	// Hide win amount display in slots mode
	tween(winAmountDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Keep cascade display hidden (will show via animation when needed)
	// Show slots UI (classic reels removed - using Megaways only)
	tween(spinButton, {
		alpha: 1
	}, {
		duration: 300
	});
	// Set minimum bet to 25 when switching to slots
	if (currentBet < 25) {
		currentBet = 25;
	}
	// Reset bet to 25 if current bet exceeds player money when switching to slots
	if (currentBet > playerMoney) {
		currentBet = 25;
	}
	// Set bet to 25 when entering slots, but display FREE if free spins available
	currentBet = 25;
	if (freeSpins > 0) {
		totalBetDisplay.setText('FREE');
		spinButton.setText('SPIN FREE');
	} else {
		totalBetDisplay.setText('$' + currentBet);
		spinButton.setText('SPIN $' + currentBet);
	}
	console.log('Setting spin button enabled - playerMoney:', playerMoney, 'currentBet:', currentBet, 'enabled:', playerMoney >= currentBet);
	spinButton.setEnabled(playerMoney >= currentBet);
	// Show money difference display in slots mode
	tween(moneyDifferenceDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Home button in slots mode
	tween(homeButton, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show money display in slots mode
	tween(moneyDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show BalanceB asset in slots mode
	tween(balanceBAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Hide deal button in slots mode
	tween(dealButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Stop deck animation when in slots mode
	if (gameDeck.stopDeckAnimation) {
		gameDeck.stopDeckAnimation();
	}
	// Hide Remove asset in slots mode
	tween(removeAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide TotalA asset in slots mode
	tween(totalAAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide bet value display in slots mode
	tween(betValueDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide BalanceBJ asset in slots mode
	tween(balanceBJAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide player money display in slots mode
	tween(playerMoneyDisplay, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide Apuesta asset in slots mode
	tween(apuestaAsset, {
		alpha: 0
	}, {
		duration: 300
	});
	// Update ways display
	// Hide chips and bet display
	tween(chipContainer, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide chips and bet display
	tween(chipContainer, {
		alpha: 0
	}, {
		duration: 300
	});
	waysDisplay.setText(megawaysSlotMachine.getWaysText());
	cascadeDisplay.setText('');
}
function clearTable() {
	// Remove all cards
	for (var i = 0; i < playerCards.length; i++) {
		playerCards[i].destroy();
	}
	for (var i = 0; i < dealerCards.length; i++) {
		dealerCards[i].destroy();
	}
	playerCards = [];
	dealerCards = [];
}
function showBetConfirmation(callback) {
	var betPercentage = currentBet / playerMoney * 100;
	// Create confirmation overlay
	var confirmationOverlay = LK.getAsset('warning', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.9
	});
	confirmationOverlay.x = 1024;
	confirmationOverlay.y = 1366;
	confirmationOverlay.alpha = 0;
	game.addChild(confirmationOverlay);
	var warningText = new Text2('⚠️ HIGH BET WARNING ⚠️', {
		size: 48,
		fill: '#FF0000',
		font: "'Arial Black', Arial, sans-serif"
	});
	warningText.anchor.set(0.5, 0.5);
	warningText.x = 1024;
	warningText.y = 1200;
	warningText.alpha = 0;
	game.addChild(warningText);
	var percentageText = new Text2('You are betting ' + Math.round(betPercentage) + '% of your money!', {
		size: 36,
		fill: '#FFFFFF',
		font: "'Arial Black', Arial, sans-serif"
	});
	percentageText.anchor.set(0.5, 0.5);
	percentageText.x = 1024;
	percentageText.y = 1300;
	percentageText.alpha = 0;
	game.addChild(percentageText);
	var confirmButton = new GameButton('CONFIRM BET', 200, 80);
	confirmButton.x = 824;
	confirmButton.y = 1450;
	confirmButton.alpha = 0;
	game.addChild(confirmButton);
	var cancelButton = new GameButton('CANCEL', 200, 80);
	cancelButton.x = 1224;
	cancelButton.y = 1450;
	cancelButton.alpha = 0;
	game.addChild(cancelButton);
	// Animate in
	tween(confirmationOverlay, {
		alpha: 0.9
	}, {
		duration: 300
	});
	tween(warningText, {
		alpha: 1
	}, {
		duration: 300,
		delay: 100
	});
	tween(percentageText, {
		alpha: 1
	}, {
		duration: 300,
		delay: 200
	});
	tween(confirmButton, {
		alpha: 1
	}, {
		duration: 300,
		delay: 300
	});
	tween(cancelButton, {
		alpha: 1
	}, {
		duration: 300,
		delay: 300
	});
	function cleanup() {
		confirmationOverlay.destroy();
		warningText.destroy();
		percentageText.destroy();
		confirmButton.destroy();
		cancelButton.destroy();
	}
	confirmButton.up = function () {
		confirmedHighBet = true;
		cleanup();
		if (callback) callback(true);
	};
	cancelButton.up = function () {
		cleanup();
		if (callback) callback(false);
	};
}
function startNewBlackjackHand() {
	if (playerMoney < currentBet) return;
	// Check for high bet confirmation (50% or more of money)
	if (!confirmedHighBet && currentBet >= playerMoney * 0.5) {
		showBetConfirmation(function (confirmed) {
			if (confirmed) {
				confirmedHighBet = true;
				achievementSystem.checkAchievement('bigSpender', currentBet);
				proceedWithDeal();
			} else {
				// Reset bet to a safer amount
				currentBet = Math.min(currentBet, Math.floor(playerMoney * 0.25));
				updateChipSelection();
			}
			confirmedHighBet = false;
		});
		return;
	}
	achievementSystem.checkAchievement('bigSpender', currentBet);
	proceedWithDeal();
}
function proceedWithDeal() {
	// Set hand in progress flag to prevent deal button from reappearing
	handInProgress = true;
	// Hide deal button immediately when pressed
	tween(dealButton, {
		alpha: 0
	}, {
		duration: 200
	});
	// Hide Remove button when cards are dealt
	tween(removeAsset, {
		alpha: 0
	}, {
		duration: 200
	});
	playerMoney -= currentBet;
	updateMoneyDisplay();
	clearTable();
	createDeck();
	gameDeck.updateCount(52);
	gamePhase = 'dealing';
	// Deal initial cards with animation sequence
	dealCard(false, function () {
		dealCard(true, function () {
			dealCard(false, function () {
				dealCard(true, function () {
					// Dealer's first card stays face down
					if (dealerCards.length > 0) {
						dealerCards[0].faceUp = true;
						dealerCards[0].flip();
					}
					updateScoreDisplays();
					finishDealingPhase();
				});
			});
		});
	});
	function finishDealingPhase() {
		var playerScore = calculateHandValue(playerCards);
		if (playerScore === 21) {
			endHand();
		} else {
			gamePhase = 'playing';
			// Show action buttons
			tween(hitButton, {
				alpha: 1
			}, {
				duration: 300
			});
			tween(standButton, {
				alpha: 1
			}, {
				duration: 300,
				onFinish: function onFinish() {
					// Ensure stand button is interactive when shown
					standButton.interactive = true;
					standButton.buttonMode = true;
				}
			});
			if (playerMoney >= currentBet) {
				tween(doubleButton, {
					alpha: 1
				}, {
					duration: 300
				});
			} else {
				// Keep double button hidden if insufficient funds
				doubleButton.alpha = 0;
			}
			// Hide deal button during hand
			tween(dealButton, {
				alpha: 0
			}, {
				duration: 300
			});
		}
	}
}
function playerHit() {
	var targetX = 850 + playerCards.length * 280; // Update to match new player card position (800 + 50)
	var targetY = 2100;
	// Play card dealing sound when player requests a card
	LK.getSound('Carta_1').play();
	// Animate table tapping gesture first
	tween(playerAnimatedHand, {
		y: playerAnimatedHand.y + 50,
		scaleX: 1.1,
		scaleY: 1.1
	}, {
		duration: 150,
		onFinish: function onFinish() {
			tween(playerAnimatedHand, {
				y: playerAnimatedHand.y - 50,
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 150,
				onFinish: function onFinish() {
					// Now just deal the card without additional animation
					dealCard(false, function () {
						updateScoreDisplays();
						var playerScore = calculateHandValue(playerCards);
						if (playerScore > 21) {
							endHand();
						} else if (playerScore === 21) {
							playerStand();
						}
					});
				}
			});
		}
	});
	// Hide double button after hit since it's no longer available
	doubleButton.alpha = 0;
}
function playerStand() {
	gamePhase = 'dealer';
	// Animate negation gesture (wave hand side to side)
	tween(playerAnimatedHand, {
		x: playerAnimatedHand.x - 30,
		rotation: -0.2
	}, {
		duration: 200,
		onFinish: function onFinish() {
			tween(playerAnimatedHand, {
				x: playerAnimatedHand.x + 60,
				rotation: 0.2
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(playerAnimatedHand, {
						x: playerAnimatedHand.x - 30,
						rotation: 0
					}, {
						duration: 200,
						onFinish: function onFinish() {
							// Continue with original stand gesture
							playerAnimatedHand.standGesture();
						}
					});
				}
			});
		}
	});
	// Hide action buttons
	tween(hitButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(standButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(doubleButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Reveal dealer's face-down card with flip animation
	if (dealerCards.length > 0) {
		dealerAnimatedHand.flipCard(dealerCards[0].x, dealerCards[0].y, function () {
			dealerCards[0].flip();
			updateScoreDisplays();
			// Dealer plays
			LK.setTimeout(function () {
				playDealerTurn();
			}, 1000);
		});
	} else {
		updateScoreDisplays();
		// Dealer plays
		LK.setTimeout(function () {
			playDealerTurn();
		}, 1000);
	}
}
function playerDouble() {
	if (playerMoney < currentBet) return;
	playerMoney -= currentBet;
	currentBet *= 2;
	updateMoneyDisplay();
	var targetX = 850 + playerCards.length * 280; // Update to match new player card position (800 + 50)
	var targetY = 2100;
	// Animate two fingers gesture first
	tween(playerAnimatedHand, {
		scaleX: 1.2,
		scaleY: 1.2,
		rotation: 0.1
	}, {
		duration: 300,
		onFinish: function onFinish() {
			tween(playerAnimatedHand, {
				scaleX: 1.0,
				scaleY: 1.0,
				rotation: 0
			}, {
				duration: 300,
				onFinish: function onFinish() {
					// Now animate double down gesture with chips and card
					playerAnimatedHand.doubleDownGesture(targetX, targetY, function () {
						dealCard(false, function () {
							updateScoreDisplays();
							var playerScore = calculateHandValue(playerCards);
							if (playerScore > 21) {
								endHand();
							} else {
								playerStand();
							}
						});
					});
				}
			});
		}
	});
}
function playDealerTurn() {
	var dealerScore = calculateHandValue(dealerCards);
	if (dealerScore < 17) {
		dealCard(true, function () {
			updateScoreDisplays();
			LK.setTimeout(function () {
				playDealerTurn();
			}, 1000);
		});
	} else {
		endHand();
	}
}
function endHand() {
	gamePhase = 'finished';
	var playerScore = calculateHandValue(playerCards);
	var dealerScore = calculateHandValue(dealerCards);
	var winnings = 0;
	var playerWon = false;
	if (playerScore > 21) {
		// Player busts
		consecutiveWins = 0;
	} else if (dealerScore > 21) {
		winnings = currentBet * 2;
		playerWon = true;
	} else if (playerScore > dealerScore) {
		winnings = currentBet * 2;
		playerWon = true;
	} else if (playerScore < dealerScore) {
		// Dealer wins
		consecutiveWins = 0;
	} else {
		winnings = currentBet;
		playerWon = true;
	}
	if (playerWon) {
		consecutiveWins++;
		achievementSystem.checkAchievement('firstBlackjackWin', true);
		achievementSystem.checkAchievement('luckyStreak', consecutiveWins);
		storage.consecutiveWins = consecutiveWins;
	}
	if (winnings > 0) {
		playerMoney += winnings;
		LK.getSound('coinWin').play();
		createCoinAnimation(1024, 1366);
	}
	currentBet = 0;
	updateMoneyDisplay();
	// Collect cards animation after 2 seconds
	LK.setTimeout(function () {
		var cardPositions = [];
		var allCards = [];
		// Collect player cards positions
		for (var i = 0; i < playerCards.length; i++) {
			cardPositions.push({
				x: playerCards[i].x,
				y: playerCards[i].y
			});
			allCards.push(playerCards[i]);
		}
		// Collect dealer cards positions
		for (var i = 0; i < dealerCards.length; i++) {
			cardPositions.push({
				x: dealerCards[i].x,
				y: dealerCards[i].y
			});
			allCards.push(dealerCards[i]);
		}
		// Animate collecting cards
		dealerAnimatedHand.collectCards(cardPositions, allCards, function () {
			// Clear actual cards from game after collection animation
			clearTable();
			// Shuffle animation
			dealerAnimatedHand.shuffleAnimation();
		});
	}, 1500);
	// Reset game phase after dealing sequence
	LK.setTimeout(function () {
		gamePhase = 'betting';
		handInProgress = false; // Reset hand in progress flag
		// Re-enable deal button only if still in blackjack mode and bet is greater than zero
		if (gameMode === 'blackjack' && currentBet > 0) {
			tween(dealButton, {
				alpha: 1
			}, {
				duration: 300
			});
		}
	}, 2000);
}
function spinSlots() {
	// Debug logging to identify the exact issue
	console.log('spinSlots called - playerMoney:', playerMoney, 'currentBet:', currentBet, 'isSpinning:', megawaysSlotMachine.isSpinning);
	// Reset bet to 25 immediately if current bet exceeds player money
	if (currentBet > playerMoney) {
		currentBet = 25;
		totalBetDisplay.setText('$' + currentBet);
		spinButton.setText('SPIN $' + currentBet);
		console.log('Bet reset to 25 - new currentBet:', currentBet);
	}
	// Check if using free spins or player money
	var usingFreeSpin = freeSpins > 0;
	if (!usingFreeSpin && playerMoney < currentBet) {
		console.log('Insufficient funds - playerMoney:', playerMoney, 'currentBet:', currentBet);
		return;
	}
	if (megawaysSlotMachine.isSpinning) {
		console.log('Already spinning - isSpinning:', megawaysSlotMachine.isSpinning);
		return;
	}
	// Set slots spin in progress flag
	slotsSpinInProgress = true;
	// Reset money difference values to 0 at start of new spin
	moneyAfterBet = 0;
	moneyAfterSpin = 0;
	updateMoneyDifferenceDisplay();
	// Deduct cost - either free spin or player money
	if (usingFreeSpin) {
		freeSpins--;
		storage.freeSpins = freeSpins;
		moneyAfterBet = playerMoney; // No money deducted for free spins
		// Set effective bet to 100 for free spins calculations
		currentBet = 100;
	} else {
		playerMoney -= currentBet;
		moneyAfterBet = playerMoney; // Track money after betting
	}
	moneyAfterSpin = moneyAfterBet; // Keep at same value until spin results are processed
	updateMoneyDisplay();
	// Update display based on remaining free spins
	if (freeSpins > 0) {
		totalBetDisplay.setText('FREE'); // Update total bet display for slots
	} else {
		totalBetDisplay.setText('$' + currentBet); // Update total bet display for slots
	}
	spinButton.setEnabled(false);
	messageDisplay.setText('Spinning...');
	// Hide cascade display
	cascadeDisplay.alpha = 0;
	megawaysSlotMachine.totalWinAmount = 0;
	megawaysSlotMachine.cascadeCount = 0;
	lastCascadeCount = 0;
	// Animate spin button
	tween(spinButton, {
		scaleX: 0.9,
		scaleY: 0.9
	}, {
		duration: 100,
		onFinish: function onFinish() {
			tween(spinButton, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 100
			});
		}
	});
	LK.getSound('slotSpin').play();
	// Start Megaways spin
	megawaysSlotMachine.spinAllReels(function () {
		// Show ways animation if significantly increased
		showWaysAnimation(megawaysSlotMachine.currentWays);
		// Check for wins and start cascade sequence
		var winningCombos = megawaysSlotMachine.checkForWins();
		if (winningCombos.length > 0) {
			messageDisplay.setText('WINNING SPIN!');
			processInitialWins(winningCombos);
		} else {
			messageDisplay.setText('No win. Try again!');
			console.log('No wins - playerMoney:', playerMoney, 'currentBet:', currentBet, 'enabling button:', playerMoney >= currentBet || freeSpins > 0);
			spinButton.setEnabled(playerMoney >= currentBet || freeSpins > 0);
			// Update button text based on free spins availability
			if (freeSpins > 0) {
				totalBetDisplay.setText('FREE');
				spinButton.setText('SPIN FREE');
			} else {
				// Reset bet to 25 if current bet exceeds player money after spin
				if (currentBet > playerMoney) {
					currentBet = 25;
				}
				totalBetDisplay.setText('$' + currentBet);
				spinButton.setText('SPIN $' + currentBet);
			}
			// Clear slots spin in progress flag when no wins
			slotsSpinInProgress = false;
		}
	});
}
function processInitialWins(winningCombinations) {
	megawaysSlotMachine.processWins(winningCombinations, function (winAmount) {
		if (winAmount > 0) {
			// Show cascade animation when significantly increased
			showCascadeAnimation(megawaysSlotMachine.cascadeCount);
			// Check cascade achievement
			achievementSystem.checkAchievement('cascade5x', megawaysSlotMachine.cascadeCount);
			// Add winnings to player money
			playerMoney += winAmount;
			moneyAfterSpin = playerMoney; // Track money after spin results
			updateMoneyDisplay();
			// Play win sound and create coin animation
			LK.getSound('coinWin').play();
			createCoinAnimation(1024, 1366);
		}
		// Re-enable spin button after all cascades complete
		LK.setTimeout(function () {
			// Update displays based on free spins availability
			if (freeSpins > 0) {
				totalBetDisplay.setText('FREE');
				spinButton.setText('SPIN FREE');
			} else {
				// Reset bet to 25 if current bet exceeds player money after all cascades
				if (currentBet > playerMoney) {
					currentBet = 25;
				}
				totalBetDisplay.setText('$' + currentBet);
				spinButton.setText('SPIN $' + currentBet);
			}
			console.log('After cascades - playerMoney:', playerMoney, 'currentBet:', currentBet, 'enabling button:', playerMoney >= currentBet || freeSpins > 0);
			spinButton.setEnabled(playerMoney >= currentBet || freeSpins > 0);
			// Clear slots spin in progress flag when all cascades complete
			slotsSpinInProgress = false;
			if (megawaysSlotMachine.totalWinAmount > 0) {
				if (megawaysSlotMachine.totalWinAmount >= 1000) {
					messageDisplay.setText('🎊 MEGA WIN! $' + megawaysSlotMachine.totalWinAmount + ' 🎊');
				} else if (megawaysSlotMachine.totalWinAmount >= 500) {
					messageDisplay.setText('💰 BIG WIN! $' + megawaysSlotMachine.totalWinAmount + ' 💰');
				} else {
					messageDisplay.setText('✨ WIN! $' + megawaysSlotMachine.totalWinAmount + ' ✨');
				}
			} else {
				messageDisplay.setText('');
			}
		}, 1000);
	});
}
function checkSlotWin(s1, s2, s3) {
	var symbols = ['cherry', 'lemon', 'grape', 'seven', 'bell', 'diamond', 'bar', 'dollar'];
	var symbolNames = ['🍒', '🍋', '🍇', '7', '🔔', '💎', 'BAR', '$'];
	var winnings = 0;
	var isWin = false;
	// Check for wins
	if (s1 === s2 && s2 === s3) {
		// Three of a kind
		isWin = true;
		if (symbols[s1] === 'seven') {
			winnings = 500;
			messageDisplay.setText('🎰 JACKPOT! Triple 7s! 🎰');
		} else if (symbols[s1] === 'dollar') {
			winnings = 300;
			messageDisplay.setText('💰 Big Win! Triple $$$ 💰');
		} else if (symbols[s1] === 'diamond') {
			winnings = 250;
			messageDisplay.setText('💎 Diamond Jackpot! 💎');
		} else if (symbols[s1] === 'bell') {
			winnings = 200;
			messageDisplay.setText('🔔 Triple Bells! 🔔');
		} else {
			winnings = 100;
			messageDisplay.setText('🎉 Three of a kind! 🎉');
		}
	} else if (s1 === s2 || s2 === s3 || s1 === s3) {
		// Pair
		isWin = true;
		winnings = 50;
		messageDisplay.setText('✨ Pair! Small win! ✨');
	} else {
		messageDisplay.setText('No win. Try again!');
	}
	if (isWin) {
		// Flash message display
		tween(messageDisplay, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(messageDisplay, {
					scaleX: 1.0,
					scaleY: 1.0
				}, {
					duration: 200
				});
			}
		});
	}
	if (winnings > 0) {
		playerMoney += winnings;
		LK.getSound('coinWin').play();
		createCoinAnimation(1024, 1366);
		updateMoneyDisplay();
	}
}
function showWaysAnimation(currentWays) {
	// Only show animation if ways increased significantly (by at least 10,000)
	if (currentWays > lastWaysCount + 10000) {
		// Destroy existing animation if any
		if (waysAnimationDisplay) {
			waysAnimationDisplay.destroy();
			waysAnimationDisplay = null;
		}
		// Create animated ways display
		waysAnimationDisplay = new Text2(currentWays + ' WAYS!', {
			size: 72,
			fill: '#FFD700',
			font: "'Arial Black', Arial, sans-serif"
		});
		waysAnimationDisplay.anchor.set(0.5, 0.5);
		waysAnimationDisplay.x = 1024;
		waysAnimationDisplay.y = 900;
		waysAnimationDisplay.alpha = 0;
		waysAnimationDisplay.scaleX = 0.5;
		waysAnimationDisplay.scaleY = 0.5;
		game.addChild(waysAnimationDisplay);
		// Animate popup entrance
		tween(waysAnimationDisplay, {
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.bounceOut,
			onFinish: function onFinish() {
				// Hold for 1 second
				LK.setTimeout(function () {
					// Animate fadeout
					tween(waysAnimationDisplay, {
						alpha: 0,
						scaleX: 0.8,
						scaleY: 0.8
					}, {
						duration: 500,
						onFinish: function onFinish() {
							if (waysAnimationDisplay) {
								waysAnimationDisplay.destroy();
								waysAnimationDisplay = null;
							}
						}
					});
				}, 1000);
			}
		});
	}
	lastWaysCount = currentWays;
}
function showCascadeAnimation(currentCascadeCount) {
	// Only show animation if cascade count increased AND is 5 or higher
	if (currentCascadeCount > lastCascadeCount && currentCascadeCount >= 5) {
		// Destroy existing cascade animation if any
		if (cascadeAnimationDisplay) {
			cascadeAnimationDisplay.destroy();
			cascadeAnimationDisplay = null;
		}
		// Create animated cascade display
		cascadeAnimationDisplay = new Text2('CASCADE x' + currentCascadeCount + '!', {
			size: 168,
			fill: '#FF6347',
			font: "'Arial Black', Arial, sans-serif"
		});
		cascadeAnimationDisplay.anchor.set(0.5, 0.5);
		cascadeAnimationDisplay.x = 1024;
		cascadeAnimationDisplay.y = 800;
		cascadeAnimationDisplay.alpha = 0;
		cascadeAnimationDisplay.scaleX = 0.5;
		cascadeAnimationDisplay.scaleY = 0.5;
		game.addChild(cascadeAnimationDisplay);
		// Animate popup entrance
		tween(cascadeAnimationDisplay, {
			alpha: 1,
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 300,
			easing: tween.bounceOut,
			onFinish: function onFinish() {
				// Hold for 1 second
				LK.setTimeout(function () {
					// Animate fadeout
					tween(cascadeAnimationDisplay, {
						alpha: 0,
						scaleX: 0.8,
						scaleY: 0.8
					}, {
						duration: 500,
						onFinish: function onFinish() {
							if (cascadeAnimationDisplay) {
								cascadeAnimationDisplay.destroy();
								cascadeAnimationDisplay = null;
							}
						}
					});
				}, 1000);
			}
		});
	}
	lastCascadeCount = currentCascadeCount;
}
function createCoinAnimation(x, y) {
	for (var i = 0; i < 5; i++) {
		var coin = LK.getAsset('coin', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		coin.x = x + (Math.random() - 0.5) * 200;
		coin.y = y + (Math.random() - 0.5) * 200;
		game.addChild(coin);
		tween(coin, {
			y: coin.y - 100,
			alpha: 0,
			scaleX: 2,
			scaleY: 2
		}, {
			duration: 1000,
			onFinish: function onFinish() {
				coin.destroy();
			}
		});
	}
}
function createConfettiCelebration() {
	var confettiAssets = ['confetti1', 'confetti2', 'confetti3', 'confetti4', 'confetti5', 'confetti6'];
	// Create 50 confetti pieces for spectacular effect
	for (var i = 0; i < 50; i++) {
		var confettiType = confettiAssets[Math.floor(Math.random() * confettiAssets.length)];
		var confetti = LK.getAsset(confettiType, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Start confetti at top of screen with random horizontal positions
		confetti.x = Math.random() * 2048;
		confetti.y = -50;
		confetti.rotation = Math.random() * Math.PI * 2;
		game.addChild(confetti);
		// Animate confetti falling with random movement
		tween(confetti, {
			x: confetti.x + (Math.random() - 0.5) * 400,
			y: 2732 + 100,
			rotation: confetti.rotation + (Math.random() - 0.5) * Math.PI * 4,
			alpha: 0
		}, {
			duration: 3000 + Math.random() * 2000,
			easing: tween.easeIn,
			onFinish: function onFinish() {
				confetti.destroy();
			}
		});
	}
}
// Card display removed from menu
// Track if this is the first time entering the menu
var isFirstMenuEntry = true;
// Initialize game state
updateMoneyDisplay();
// Add global click handler for disclaimer screen
game.down = function (x, y, obj) {
	if (gameMode === 'disclaimer') {
		switchToMenu();
	}
};
// Start with disclaimer screen
if (gameMode === 'disclaimer') {
	// Hide all menu elements initially
	blackjackButton.alpha = 0;
	slotsButton.alpha = 0;
	welcomeAsset.alpha = 0;
	fondoM.alpha = 0;
	logrosButton.alpha = 0;
	ruedaPButton.alpha = 0;
	spinIButton.alpha = 0;
	// Disable buttons during disclaimer screen
	blackjackButton.setEnabled(false);
	slotsButton.setEnabled(false);
	logrosButton.setEnabled(false);
	ruedaPButton.setEnabled(false);
	spinIButton.setEnabled(false);
} else {
	switchToMenu();
}
// Menu music will be played when entering main menu via switchToMenu function
game.update = function () {
	updateMoneyDisplay();
};
// Wheel prize definitions
var wheelPrizes = [{
	type: 'credits',
	amount: 200,
	name: '+200 Credits',
	probability: 40,
	color: 0x4CAF50
}, {
	type: 'credits',
	amount: 500,
	name: '+500 Credits',
	probability: 25,
	color: 0x2196F3
}, {
	type: 'credits',
	amount: 1000,
	name: '+1,000 Credits',
	probability: 10,
	color: 0x9C27B0
}, {
	type: 'credits',
	amount: 2500,
	name: '+2,500 Credits',
	probability: 5,
	color: 0xFF5722
}, {
	type: 'freespins',
	amount: 3,
	name: '+3 Free Spins',
	probability: 10,
	color: 0xFFC107
}, {
	type: 'freespins',
	amount: 10,
	name: '+10 Free Spins',
	probability: 5,
	color: 0xE91E63
}, {
	type: 'blackjackchips',
	amount: 250,
	name: '+250 chips',
	probability: 4,
	color: 0x795548
}, {
	type: 'credits',
	amount: 10000,
	name: 'JACKPOT',
	probability: 1,
	color: 0xFFD700
}];
// Wheel spinning state variables
var wheelIsSpinning = false;
var preSelectedPrize = null;
var wheelContainer = null;
var ruedaVerificador = null;
var wheelSegments = [];
var targetCheckInterval = null;
var wheelSpinButton = null;
var giroSoundInterval = null; // Track Giro sound interval
var slotsSpinInProgress = false; // Track if slots spin is active
function showWheelScreen() {
	// Set wheel screen as open to prevent re-entry
	wheelScreenOpen = true;
	// Disable blackjack and slots buttons when wheel opens
	blackjackButton.setEnabled(false);
	slotsButton.setEnabled(false);
	// Create dark overlay background
	var wheelOverlay = LK.getAsset('warning', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.95
	});
	wheelOverlay.x = 1024;
	wheelOverlay.y = 1366;
	wheelOverlay.alpha = 0;
	game.addChild(wheelOverlay);
	// Create title
	var wheelTitle = new Text2('🎡 FORTUNE WHEEL 🎡', {
		size: 72,
		fill: '#FFD700',
		font: "'Arial Black', Arial, sans-serif"
	});
	wheelTitle.anchor.set(0.5, 0.5);
	wheelTitle.x = 1024;
	wheelTitle.y = 400;
	wheelTitle.alpha = 0;
	game.addChild(wheelTitle);
	// Create wheel container
	wheelContainer = new Container();
	wheelContainer.x = 1024;
	wheelContainer.y = 1000;
	wheelContainer.alpha = 0;
	game.addChild(wheelContainer);
	// Create wheel base
	var wheelBase = LK.getAsset('circularSpinButtonShadow', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 1800,
		height: 1836
	});
	wheelContainer.addChild(wheelBase);
	// Create wheel pointer using Flecha asset outside the wheel container so it doesn't rotate
	var wheelPointer = LK.getAsset('Flecha', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	wheelPointer.x = 1024; // Position at center of screen
	wheelPointer.y = 250; // 750 pixels above wheel center (1000 - 750)
	wheelPointer.alpha = 0;
	game.addChild(wheelPointer); // Add to game instead of wheelContainer
	// Create RuedaVerificador asset at same position as Flecha
	ruedaVerificador = LK.getAsset('RuedaVerificador', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	ruedaVerificador.x = 1024; // Same position as wheelPointer
	ruedaVerificador.y = 450; // Moved down 200 pixels from wheelPointer position
	ruedaVerificador.alpha = 0;
	game.addChild(ruedaVerificador);
	// Create wheel segments
	var segmentAngle = Math.PI * 2 / wheelPrizes.length;
	wheelSegments = [];
	for (var i = 0; i < wheelPrizes.length; i++) {
		var angle = i * segmentAngle;
		var radius = 600;
		// Add prize text (horizontal - make invisible)
		var fontSize = 60;
		// Adjust font size for specific prizes
		if (wheelPrizes[i].name === '+3 Free Spins') {
			fontSize = 60 * 1.03; // Make 1.03 times larger
		} else if (wheelPrizes[i].name === '+10 Free Spins') {
			fontSize = 60 / 1.05; // Make 1.05 times smaller
		} else if (wheelPrizes[i].name === '+1,000 Credits') {
			fontSize = 60 / 1.15; // Make 1.15 times smaller
		} else if (wheelPrizes[i].name === '+2,500 Credits') {
			fontSize = 60 / 1.15; // Make 1.15 times smaller
		} else if (wheelPrizes[i].name === '+250 chips') {
			fontSize = 60 * 1.2; // Make 1.2 times larger
		} else if (wheelPrizes[i].name === 'JACKPOT') {
			fontSize = 60 * 1.15; // Make 1.15 times larger
		}
		var prizeText = new Text2(wheelPrizes[i].name, {
			size: fontSize,
			fill: '#FFFFFF',
			font: "'Arial Black', Arial, sans-serif"
		});
		prizeText.anchor.set(0.5, 0.5);
		prizeText.x = Math.cos(angle) * radius;
		prizeText.y = Math.sin(angle) * radius;
		prizeText.rotation = angle + Math.PI / 2;
		prizeText.alpha = 0; // Make horizontal text invisible
		wheelContainer.addChild(prizeText);
		wheelSegments.push(prizeText);
		// Add vertical prize text
		var verticalPrizeText = new Text2(wheelPrizes[i].name, {
			size: fontSize,
			fill: '#FFFFFF',
			font: "'Arial Black', Arial, sans-serif"
		});
		verticalPrizeText.anchor.set(0.5, 0.5);
		verticalPrizeText.x = Math.cos(angle) * radius;
		verticalPrizeText.y = Math.sin(angle) * radius;
		verticalPrizeText.rotation = angle + Math.PI / 2 + Math.PI / 2; // Add 90 degrees for vertical orientation
		wheelContainer.addChild(verticalPrizeText);
	}
	// Create spin button
	wheelSpinButton = new GameButton('SPIN WHEEL', 300, 100);
	wheelSpinButton.x = 1024;
	wheelSpinButton.y = 1000; // Moved to center of wheel asset
	wheelSpinButton.alpha = 0;
	// Replace the default button background with circular assets (500x500)
	wheelSpinButton.removeChild(wheelSpinButton.children[0]); // Remove shadow
	wheelSpinButton.removeChild(wheelSpinButton.children[0]); // Remove background (index shifts after first removal)
	// Add circular border
	var circularBorder = LK.getAsset('circularSpinButtonBorder', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 500,
		height: 500
	});
	wheelSpinButton.addChildAt(circularBorder, 0);
	// Add circular button
	var circularButton = LK.getAsset('circularSpinButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 450,
		height: 295
	});
	wheelSpinButton.addChildAt(circularButton, 1);
	game.addChild(wheelSpinButton);
	// Move SpinI button to overlapping position above the wheel (only if it exists)
	if (spinIButton && spinIAsset) {
		tween(spinIButton, {
			x: wheelSpinButton.x - 400,
			// Position 400 pixels to the left of wheel center for overlap (320 + 80)
			y: wheelSpinButton.y - 100 // Position above the wheel spin button to overlay on wheel
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Ensure SpinI renders above wheel by removing and re-adding to game
				game.removeChild(spinIButton);
				game.addChild(spinIButton);
			}
		});
	}
	// Create close button
	var wheelCloseButton = new GameButton('CLOSE', 200, 80);
	wheelCloseButton.x = 1024;
	wheelCloseButton.y = 2000;
	wheelCloseButton.alpha = 0;
	game.addChild(wheelCloseButton);
	// Animate in
	tween(wheelOverlay, {
		alpha: 0.95
	}, {
		duration: 300
	});
	tween(wheelTitle, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 400,
		delay: 100,
		easing: tween.bounceOut,
		onFinish: function onFinish() {
			tween(wheelTitle, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 200
			});
		}
	});
	tween(wheelContainer, {
		alpha: 1
	}, {
		duration: 400,
		delay: 200
	});
	tween(wheelPointer, {
		alpha: 1
	}, {
		duration: 400,
		delay: 250
	});
	ruedaVerificador.alpha = 0;
	tween(wheelSpinButton, {
		alpha: 0
	}, {
		duration: 300,
		delay: 400
	});
	tween(wheelCloseButton, {
		alpha: 1
	}, {
		duration: 300,
		delay: 500
	});
	// Spin wheel handler
	wheelSpinButton.up = function () {
		if (!wheelSpinButton.enabled) return;
		if (wheelIsSpinning) return;
		wheelSpinButton.setEnabled(false);
		wheelIsSpinning = true;
		// Stop any currently playing music and start RuedaMusic when wheel begins spinning
		LK.stopMusic();
		LK.playMusic('RuedaMusic');
		// Hide SpinI asset when wheel is spun and stop all blinking
		tween.stop(spinIAsset, {
			alpha: true
		}); // Stop any ongoing alpha tween
		spinIAsset.alpha = 0; // Set to fully transparent
		tween(spinIButton, {
			alpha: 0
		}, {
			duration: 300,
			easing: tween.easeOut
		});
		// Clear SpinI timers when player spins wheel
		if (spinITimer) {
			LK.clearTimeout(spinITimer);
			spinITimer = null;
		}
		if (spinIBlinkTimer) {
			LK.clearInterval(spinIBlinkTimer);
			spinIBlinkTimer = null;
		}
		if (spinIRecurringTimer) {
			LK.clearInterval(spinIRecurringTimer);
			spinIRecurringTimer = null;
		}
		// Disable SpinI asset verificador functionality after wheel spin
		spinIButton.setEnabled(false);
		spinIAsset.interactive = false;
		spinIAsset.buttonMode = false;
		// Immediately calculate which prize to award
		preSelectedPrize = selectRandomPrize();
		console.log('Pre-selected prize:', preSelectedPrize.prize.name, 'at index:', preSelectedPrize.index);
		// Start spinning the wheel immediately
		var continuousSpinRotation = wheelContainer.rotation + Math.PI * 2 * 10; // Spin 10 full rotations over 5 seconds
		// Start Giro sound interval - play every 1 second during spin
		var giroSoundInterval = LK.setInterval(function () {
			if (wheelIsSpinning) {
				LK.getSound('Giro').play();
			}
		}, 1000);
		// Play first Giro sound immediately
		LK.getSound('Giro').play();
		// Phase 1: Spin continuously for 5 seconds
		tween(wheelContainer, {
			rotation: continuousSpinRotation
		}, {
			duration: 5000,
			easing: tween.linear
		});
		// Phase 2: After 5 seconds, start target detection and transition to target
		LK.setTimeout(function () {
			// Check if wheel is still open and spinning before proceeding
			if (!wheelIsSpinning || !wheelContainer) return;
			// Continue Giro sound interval during final phase (already playing every 1 second)
			// Calculate target rotation to align pre-selected prize with RuedaVerificador
			var segmentAngle = Math.PI * 2 / wheelPrizes.length;
			var targetAngle = preSelectedPrize.index * segmentAngle;
			// Stop current spin and calculate final rotation
			tween.stop(wheelContainer, {
				rotation: true
			});
			// Add additional rotations to reach target smoothly
			var currentRotation = wheelContainer.rotation;
			var finalRotation = currentRotation + Math.PI * 2 * 2 + targetAngle; // Add 2 more full spins to target
			console.log('Transitioning to target prize. Final rotation:', finalRotation * 180 / Math.PI, 'degrees');
			// Start monitoring for collision during final approach
			startTargetDetection();
			// Animate wheel to target position with deceleration
			tween(wheelContainer, {
				rotation: finalRotation
			}, {
				duration: 3000,
				easing: tween.easeOut
			});
		}, 5000);
	};
	// Close handler
	function closeWheelScreen() {
		// Prevent closing wheel if spin is in progress
		if (wheelIsSpinning) return;
		// Make close button disappear immediately
		wheelCloseButton.alpha = 0;
		// Reset wheel screen state to allow re-entry
		wheelScreenOpen = false;
		// Re-enable blackjack and slots buttons when wheel closes
		blackjackButton.setEnabled(true);
		slotsButton.setEnabled(true);
		// Move SpinI button back to original position with 50px left offset and restore visibility
		tween(spinIButton, {
			x: 1488 - 50,
			// Original position minus 50 pixels to the left
			y: 2500,
			// Original vertical position
			alpha: 1 // Restore visibility when returning to original position
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				// Reset sound toggle when returning from wheel
				spinISoundToggle = false;
			}
		});
		// Clear any ongoing wheel detection
		if (targetCheckInterval) {
			LK.clearInterval(targetCheckInterval);
			targetCheckInterval = null;
		}
		// Clear Giro sound interval when closing wheel
		if (giroSoundInterval) {
			LK.clearInterval(giroSoundInterval);
			giroSoundInterval = null;
		}
		// Reset wheel variables
		wheelIsSpinning = false;
		preSelectedPrize = null;
		// Store references before nullifying
		var elementsToDestroy = [];
		if (wheelContainer) elementsToDestroy.push(wheelContainer);
		if (ruedaVerificador) elementsToDestroy.push(ruedaVerificador);
		if (wheelSpinButton) elementsToDestroy.push(wheelSpinButton);
		// Find and destroy all wheel-related elements by checking all game children
		var gameChildren = game.children.slice(); // Create a copy to avoid modification during iteration
		for (var i = 0; i < gameChildren.length; i++) {
			var child = gameChildren[i];
			// Check if this is a wheel-related element by examining its properties or position
			// Exclude fondoM background by checking if it's the main menu background
			if (child && child !== fondoM && (child.x === 1024 && child.y === 1366 && child.width && child.height ||
			// wheelOverlay (exclude fondoM)
			child.x === 1024 && child.y === 400 && child.setText ||
			// wheelTitle
			child.x === 1024 && child.y === 250 ||
			// wheelPointer
			child.x === 1024 && child.y === 450 ||
			// ruedaVerificador
			child.x === 1024 && child.y === 1600 && child.setText ||
			// wheelSpinButton
			child.x === 1024 && child.y === 2000 && child.setText ||
			// wheelCloseButton (updated position)
			child.x === 1024 && child.y === 1000 ||
			// wheelContainer
			child.x === 1024 && child.y === 1400 && child.setText // resultText
			)) {
				elementsToDestroy.push(child);
			}
		}
		// Immediately hide and destroy all elements
		for (var i = 0; i < elementsToDestroy.length; i++) {
			var element = elementsToDestroy[i];
			if (element) {
				element.alpha = 0;
				if (element.destroy) {
					element.destroy();
				}
			}
		}
		// Reset wheel variables to null
		wheelContainer = null;
		ruedaVerificador = null;
		wheelSegments = [];
		wheelSpinButton = null;
	}
	wheelCloseButton.up = closeWheelScreen;
}
function selectRandomPrize() {
	// Select a random prize for initial spin calculation (still used for rotation)
	var random = Math.random() * 100;
	var cumulativeProbability = 0;
	var selectedPrizeIndex = 0;
	for (var i = 0; i < wheelPrizes.length; i++) {
		cumulativeProbability += wheelPrizes[i].probability;
		if (random <= cumulativeProbability) {
			selectedPrizeIndex = i;
			break;
		}
	}
	return {
		prize: wheelPrizes[selectedPrizeIndex],
		index: selectedPrizeIndex
	};
}
function startTargetDetection() {
	// Clear any existing interval
	if (targetCheckInterval) {
		LK.clearInterval(targetCheckInterval);
		targetCheckInterval = null;
	}
	// Check every 50ms during spin for collision with target prize
	targetCheckInterval = LK.setInterval(function () {
		if (!wheelIsSpinning || !preSelectedPrize) return;
		// Check if RuedaVerificador intersects with the target prize text
		var targetSegment = wheelSegments[preSelectedPrize.index];
		if (targetSegment && ruedaVerificador) {
			// Get global positions for collision detection
			var segmentGlobalPos = wheelContainer.toGlobal(targetSegment.position);
			var verificadorGlobalPos = game.toGlobal(ruedaVerificador.position);
			// Check distance between centers (simple collision detection)
			var distance = Math.sqrt(Math.pow(segmentGlobalPos.x - verificadorGlobalPos.x, 2) + Math.pow(segmentGlobalPos.y - verificadorGlobalPos.y, 2));
			// If close enough (within 100 pixels), consider it a hit
			if (distance < 100) {
				console.log('Target prize detected under RuedaVerificador! Stopping wheel.');
				stopWheelAtTarget();
			}
		}
	}, 50);
}
function stopWheelAtTarget() {
	// Stop all wheel animations immediately
	tween.stop(wheelContainer, {
		rotation: true
	});
	// Stop Giro sound interval when wheel stops
	if (giroSoundInterval) {
		LK.clearInterval(giroSoundInterval);
		giroSoundInterval = null;
	}
	// Stop RuedaMusic when wheel stops and restart menu music
	LK.stopMusic();
	LK.setTimeout(function () {
		LK.playMusic('Menu');
	}, 100);
	// Reset all statistics: money, achievements and spins
	playerMoney = storage.playerMoney = 1000;
	storage.achievements = {};
	storage.consecutiveWins = 0;
	consecutiveWins = 0;
	// Reset achievement system to starting state
	for (var key in achievementSystem.achievements) {
		achievementSystem.achievements[key].unlocked = false;
	}
	updateMoneyDisplay();
	// Clear the detection interval
	if (targetCheckInterval) {
		LK.clearInterval(targetCheckInterval);
		targetCheckInterval = null;
	}
	// Award the pre-selected prize
	console.log('Awarding pre-selected prize:', preSelectedPrize.prize.name);
	awardWheelPrize(preSelectedPrize.prize);
	// Play premio sound when prize is won
	LK.getSound('premio').play();
	// Create confetti celebration effect
	createConfettiCelebration();
	// Show result with "You won:" on first line and prize on second line
	var youWonText = new Text2('You won:', {
		size: 192,
		fill: '#FFD700',
		font: "'Arial Black', Arial, sans-serif"
	});
	youWonText.anchor.set(0.5, 0.5);
	youWonText.x = 1024;
	youWonText.y = 1300;
	youWonText.alpha = 0;
	game.addChild(youWonText);
	var prizeText = new Text2(preSelectedPrize.prize.name, {
		size: 192,
		fill: '#FFD700',
		font: "'Arial Black', Arial, sans-serif"
	});
	prizeText.anchor.set(0.5, 0.5);
	prizeText.x = 1024;
	prizeText.y = 1500;
	prizeText.alpha = 0;
	game.addChild(prizeText);
	tween(youWonText, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 500,
		easing: tween.bounceOut
	});
	tween(prizeText, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 500,
		delay: 200,
		easing: tween.bounceOut,
		onFinish: function onFinish() {
			LK.setTimeout(function () {
				tween(youWonText, {
					alpha: 0
				}, {
					duration: 300,
					onFinish: function onFinish() {
						youWonText.destroy();
					}
				});
				tween(prizeText, {
					alpha: 0
				}, {
					duration: 300,
					onFinish: function onFinish() {
						prizeText.destroy();
					}
				});
			}, 2000);
		}
	});
	// Reset wheel state
	wheelIsSpinning = false;
	preSelectedPrize = null;
	// Re-enable spin button if it exists and wheel screen is still open
	if (wheelSpinButton && wheelSpinButton.setEnabled) {
		wheelSpinButton.setEnabled(true);
	}
}
function detectPrizeUnderVerificador(wheelContainer, ruedaVerificador, wheelSegments) {
	// Find which text segment intersects with RuedaVerificador using actual collision detection
	var closestSegment = null;
	var minDistance = Infinity;
	var winningIndex = 0;
	for (var i = 0; i < wheelSegments.length; i++) {
		var segment = wheelSegments[i];
		// Check if the text segment intersects with RuedaVerificador
		if (segment.intersects && segment.intersects(ruedaVerificador)) {
			// Direct collision detected - this is our winner
			return {
				prize: wheelPrizes[i],
				index: i
			};
		}
		// Fallback: calculate distance to RuedaVerificador as backup
		var segmentGlobalPos = wheelContainer.toGlobal(segment.position);
		var verificadorGlobalPos = ruedaVerificador.position;
		var distance = Math.sqrt(Math.pow(segmentGlobalPos.x - verificadorGlobalPos.x, 2) + Math.pow(segmentGlobalPos.y - verificadorGlobalPos.y, 2));
		if (distance < minDistance) {
			minDistance = distance;
			closestSegment = i;
			winningIndex = i;
		}
	}
	// If no direct collision found, use closest segment
	return {
		prize: wheelPrizes[winningIndex],
		index: winningIndex
	};
}
function awardWheelPrize(prize) {
	switch (prize.type) {
		case 'credits':
			playerMoney += prize.amount;
			updateMoneyDisplay();
			LK.getSound('coinWin').play();
			createCoinAnimation(1024, 1366);
			break;
		case 'freespins':
			freeSpins += prize.amount;
			storage.freeSpins = freeSpins;
			console.log('Awarded ' + prize.amount + ' free spins - total:', freeSpins);
			break;
		case 'blackjackchips':
			playerMoney += prize.amount;
			updateMoneyDisplay();
			LK.getSound('coinWin').play();
			createCoinAnimation(1024, 1366);
			break;
	}
}
function showAchievementsScreen() {
	// Create dark overlay background
	var achievementOverlay = LK.getAsset('warning', {
		anchorX: 0.5,
		anchorY: 0.5,
		alpha: 0.95
	});
	achievementOverlay.x = 1024;
	achievementOverlay.y = 1366;
	achievementOverlay.alpha = 0;
	game.addChild(achievementOverlay);
	// Create title
	var achievementTitle = new Text2('🏆 ACHIEVEMENTS 🏆', {
		size: 72,
		fill: '#FFD700',
		font: "'Arial Black', Arial, sans-serif"
	});
	achievementTitle.anchor.set(0.5, 0.5);
	achievementTitle.x = 1024;
	achievementTitle.y = 500;
	achievementTitle.alpha = 0;
	game.addChild(achievementTitle);
	// Create achievement displays
	var yPosition = 750;
	var achievementDisplays = [];
	for (var key in achievementSystem.achievements) {
		var achievement = achievementSystem.achievements[key];
		// Achievement container
		var achievementBg = LK.getAsset('button', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 1400,
			height: 200,
			alpha: achievement.unlocked ? 1.0 : 0.4
		});
		achievementBg.x = 1024;
		achievementBg.y = yPosition;
		achievementBg.alpha = 0;
		game.addChild(achievementBg);
		achievementDisplays.push(achievementBg);
		// Achievement icon/status
		var statusIcon = new Text2(achievement.unlocked ? '✅' : '🔒', {
			size: 48,
			fill: achievement.unlocked ? '#00FF00' : '#888888',
			font: "'Arial Black', Arial, sans-serif"
		});
		statusIcon.anchor.set(0.5, 0.5);
		statusIcon.x = 400;
		statusIcon.y = yPosition - 30;
		statusIcon.alpha = 0;
		game.addChild(statusIcon);
		achievementDisplays.push(statusIcon);
		// Achievement title
		var titleText = new Text2(achievement.title, {
			size: 42,
			fill: achievement.unlocked ? '#FFD700' : '#CCCCCC',
			font: "'Arial Black', Arial, sans-serif"
		});
		titleText.anchor.set(0.5, 0.5);
		titleText.x = 1024;
		titleText.y = yPosition - 30;
		titleText.alpha = 0;
		game.addChild(titleText);
		achievementDisplays.push(titleText);
		// Achievement description
		var descText = new Text2(achievement.description, {
			size: 32,
			fill: achievement.unlocked ? '#FFFFFF' : '#999999',
			font: "'Arial Black', Arial, sans-serif"
		});
		descText.anchor.set(0.5, 0.5);
		descText.x = 1024;
		descText.y = yPosition + 20;
		descText.alpha = 0;
		game.addChild(descText);
		achievementDisplays.push(descText);
		// Achievement reward
		var rewardText = new Text2('Reward: +$' + achievement.reward, {
			size: 28,
			fill: achievement.unlocked ? '#00FF00' : '#666666',
			font: "'Arial Black', Arial, sans-serif"
		});
		rewardText.anchor.set(0.5, 0.5);
		rewardText.x = 1648;
		rewardText.y = yPosition;
		rewardText.alpha = 0;
		game.addChild(rewardText);
		achievementDisplays.push(rewardText);
		yPosition += 250;
	}
	// Close button
	var closeButton = new GameButton('CLOSE', 200, 80);
	closeButton.x = 1024;
	closeButton.y = 2200;
	closeButton.alpha = 0;
	game.addChild(closeButton);
	// Animate all elements in with staggered timing
	tween(achievementOverlay, {
		alpha: 0.95
	}, {
		duration: 300
	});
	tween(achievementTitle, {
		alpha: 1,
		scaleX: 1.2,
		scaleY: 1.2
	}, {
		duration: 400,
		delay: 100,
		easing: tween.bounceOut,
		onFinish: function onFinish() {
			tween(achievementTitle, {
				scaleX: 1.0,
				scaleY: 1.0
			}, {
				duration: 200
			});
		}
	});
	// Animate achievement displays
	for (var i = 0; i < achievementDisplays.length; i++) {
		(function (display, index) {
			tween(display, {
				alpha: 1
			}, {
				duration: 300,
				delay: 200 + index * 50,
				easing: tween.easeOut
			});
		})(achievementDisplays[i], i);
	}
	tween(closeButton, {
		alpha: 1
	}, {
		duration: 300,
		delay: 600
	});
	// Close button handler
	closeButton.up = function () {
		// Animate out
		var allElements = [achievementOverlay, achievementTitle, closeButton].concat(achievementDisplays);
		var elementsToDestroy = 0;
		var totalElements = allElements.length;
		for (var i = 0; i < allElements.length; i++) {
			tween(allElements[i], {
				alpha: 0
			}, {
				duration: 300,
				delay: i * 20,
				onFinish: function onFinish() {
					elementsToDestroy++;
					if (elementsToDestroy === totalElements) {
						// Destroy all elements
						for (var j = 0; j < allElements.length; j++) {
							if (allElements[j] && allElements[j].destroy) {
								allElements[j].destroy();
							}
						}
					}
				}
			});
		}
	};
}

===================================================================
--- original.js
+++ change.js
@@ -2309,23 +2309,8 @@
 /**** 
 * Game Code
 ****/ 
 // Hide blinking text when leaving menu
-LK.init.voice('Jugador_Pedir_1', {
-	text: "I'll take a hit, please.",
-	voice: 'masculine_young_calm_meditation_american',
-	volume: 0.8
-});
-LK.init.voice('Jugador_Pedir_2', {
-	text: "One more card, if you would.",
-	voice: 'masculine_young_calm_meditation_american',
-	volume: 0.8
-});
-LK.init.voice('Jugador_Pedir_3', {
-	text: "Kindly deal me another.",
-	voice: 'masculine_young_calm_meditation_american',
-	volume: 0.8
-});
 if (spinHereText) {
 	spinHereText.destroy();
 	spinHereText = null;
 }
@@ -4458,12 +4443,10 @@
 }
 function playerHit() {
 	var targetX = 850 + playerCards.length * 280; // Update to match new player card position (800 + 50)
 	var targetY = 2100;
-	// Play random player voice when requesting a card
-	var playerVoices = ['Jugador_Pedir_1', 'Jugador_Pedir_2', 'Jugador_Pedir_3'];
-	var randomVoice = playerVoices[Math.floor(Math.random() * playerVoices.length)];
-	LK.getSound(randomVoice).play();
+	// Play card dealing sound when player requests a card
+	LK.getSound('Carta_1').play();
 	// Animate table tapping gesture first
 	tween(playerAnimatedHand, {
 		y: playerAnimatedHand.y + 50,
 		scaleX: 1.1,