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

/**** 
* Classes
****/ 
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 : 238.05,
		height: isDealer ? 324 : 357.075,
		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
		});
		// Move card to target
		tween(movingCard, {
			x: targetX,
			y: targetY,
			rotation: (Math.random() - 0.5) * 0.2
		}, {
			duration: 800,
			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
		});
		// Move card to target
		tween(movingCard, {
			x: targetX,
			y: targetY,
			rotation: (Math.random() - 0.5) * 0.2
		}, {
			duration: 800,
			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: 400,
			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: 600,
					easing: tween.easeOut,
					onFinish: function onFinish() {
						movingCard.destroy();
						chip.destroy();
						if (onComplete) onComplete();
					}
				});
			}
		});
	};
	// Card flip animation
	self.flipCard = function (cardX, cardY, onComplete) {
		var flippingCard = LK.getAsset('flippingCard', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: 240,
			height: 360
		});
		flippingCard.x = cardX;
		flippingCard.y = cardY;
		game.addChild(flippingCard);
		// Animate hand moving to card
		tween(handGraphic, {
			x: cardX - self.x,
			y: cardY - self.y,
			scaleX: 0.8,
			scaleY: 0.8
		}, {
			duration: 300,
			onFinish: function onFinish() {
				// Flip animation
				tween(flippingCard, {
					scaleX: 0,
					rotation: Math.PI
				}, {
					duration: 200,
					onFinish: function onFinish() {
						tween(flippingCard, {
							scaleX: 1,
							rotation: 0
						}, {
							duration: 200,
							onFinish: function onFinish() {
								flippingCard.destroy();
								// Return hand to original position
								tween(handGraphic, {
									x: 0,
									y: 0,
									scaleX: 1.0,
									scaleY: 1.0
								}, {
									duration: 300
								});
								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) {
				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 = 2000;
		var shuffleSteps = 8;
		var stepDuration = shuffleDuration / shuffleSteps;
		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);
		}
	};
	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 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);
	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.95,
			scaleY: 0.95
		}, {
			duration: 100
		});
	};
	self.up = function (x, y, obj) {
		if (!self.enabled) return;
		tween(buttonBg, {
			scaleX: 1.0,
			scaleY: 1.0
		}, {
			duration: 100
		});
	};
	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 = 2; // Start with minimum symbols
	self.maxSymbols = 7; // Maximum symbols per reel
	self.minSymbols = 2; // 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
			var symbolSpacing = Math.min(70, 350 / self.currentSymbolCount);
			symbol.y = (i - (self.currentSymbolCount - 1) / 2) * symbolSpacing;
			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));
					var symbolSpacing = Math.min(70, 350 / self.currentSymbolCount);
					tempSymbol.y = (i - (self.currentSymbolCount - 1) / 2) * symbolSpacing;
					tempSymbol.alpha = 0.6;
					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));
			var symbolSpacing = Math.min(70, 350 / self.currentSymbolCount);
			var finalY = (i - (self.currentSymbolCount - 1) / 2) * symbolSpacing;
			// Start symbols above the reel area
			symbol.y = finalY - 500;
			symbol.alpha = 0;
			self.addChild(symbol);
			self.symbols.push(symbol);
			// Animate drop-in with staggered timing
			(function (sym, targetY, index) {
				tween(sym, {
					y: targetY,
					alpha: 1
				}, {
					duration: 600,
					delay: index * 100,
					easing: tween.bounceOut,
					onFinish: function onFinish() {
						// Check if this is the last symbol to finish
						if (index === self.currentSymbolCount - 1) {
							self.finalizeSpin();
						}
					}
				});
			})(symbol, finalY, i);
		}
	};
	// 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;
		// Spin each reel with increasing delay for realistic effect
		for (var i = 0; i < self.reels.length; i++) {
			(function (reelIndex) {
				LK.setTimeout(function () {
					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.
		return (baseMultipliers[symbolType] || 10) * reelMultiplier;
	};
	// 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 symbolSpacing = Math.min(70, 350 / reel.currentSymbolCount);
				for (var i = 0; i < remainingSymbols.length; i++) {
					(function (symbol, index, finalReel) {
						var targetY = (index - (reel.currentSymbolCount - 1) / 2) * symbolSpacing;
						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
	});
	// Symbol text for identification
	var symbolNames = ['A', 'B', 'C', 'D', 'E', 'F', 'W', 'S'];
	var symbolText = new Text2(self.isWild ? 'W' : self.isScatter ? 'S' : symbolNames[self.symbolIndex], {
		size: 24,
		fill: '#000000',
		font: "'Arial Black', Arial, sans-serif"
	});
	symbolText.anchor.set(0.5, 0.5);
	symbolGraphic.addChild(symbolText);
	// Mark symbol for win combination
	self.markForWin = function () {
		if (self.marked) return;
		self.marked = true;
		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;
		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) {
		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
****/ 
// Card Back (Single design for all cards)
// 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 casino 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 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 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 = 1200; // Position to overlap with tragamonedas
megawaysSlotMachine.scaleX = 1.6; // Scale by 1.6 times larger
megawaysSlotMachine.scaleY = 1.6; // Scale by 1.6 times larger
megawaysSlotMachine.alpha = 0;
// Megaways display
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 = 1024;
winAmountDisplay.y = 1800;
winAmountDisplay.alpha = 0;
game.addChild(winAmountDisplay);
// Cascade counter
var cascadeDisplay = new Text2('', {
	size: 42,
	fill: '#FF6347',
	font: "'Arial Black', Arial, sans-serif"
});
cascadeDisplay.anchor.set(0.5, 0.5);
cascadeDisplay.x = 1024;
cascadeDisplay.y = 850;
cascadeDisplay.alpha = 0;
game.addChild(cascadeDisplay);
// Game state
var playerMoney = 1000;
var currentBet = 50;
var gameMode = 'menu'; // 'menu', 'blackjack', 'slots'
var deck = [];
var playerCards = [];
var dealerCards = [];
var gamePhase = 'betting'; // 'betting', 'dealing', 'playing', 'dealer', 'finished'
// UI Elements
var moneyDisplay = new Text2('$1000', {
	size: 56,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
moneyDisplay.anchor.set(0.5, 0);
moneyDisplay.y = 20;
LK.gui.top.addChild(moneyDisplay);
var betDisplay = new Text2('Bet: $50', {
	size: 42,
	fill: '#FFFFFF',
	font: "'Arial Black', Arial, sans-serif"
});
betDisplay.anchor.set(0.5, 0);
betDisplay.y = 90;
LK.gui.top.addChild(betDisplay);
var messageDisplay = new Text2('Welcome to La Tentación Dorada!', {
	size: 40,
	fill: '#FFD700',
	font: "'Arial Black', Arial, sans-serif"
});
messageDisplay.anchor.set(0.5, 0.5);
messageDisplay.x = 1024;
messageDisplay.y = 250;
game.addChild(messageDisplay);
// Menu buttons
var blackjackButton = game.addChild(new GameButton('BLACKJACK', 300, 100));
blackjackButton.x = 1024;
blackjackButton.y = 1400;
// 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 = 1024;
slotsButton.y = 2000;
// Replace the default button background with MaquinaB asset
var slotAsset = LK.getAsset('MaquinaB', {
	anchorX: 0.5,
	anchorY: 0.5
});
slotsButton.removeChild(slotsButton.children[1]); // Remove default background
slotsButton.addChildAt(slotAsset, 1); // Add new asset as background
// Blackjack UI
var hitButton = game.addChild(new GameButton('HIT', 150, 60));
hitButton.x = 700;
hitButton.y = 2200;
hitButton.alpha = 0;
var standButton = game.addChild(new GameButton('STAND', 150, 60));
standButton.x = 900;
standButton.y = 2200;
standButton.alpha = 0;
var doubleButton = game.addChild(new GameButton('DOUBLE', 150, 60));
doubleButton.x = 1100;
doubleButton.y = 2200;
doubleButton.alpha = 0;
var dealButton = game.addChild(new GameButton('DEAL', 200, 80));
dealButton.x = 1024;
dealButton.y = 2300;
dealButton.alpha = 0;
var backToMenuButton = game.addChild(new GameButton('MENU', 120, 50));
backToMenuButton.x = 1024;
backToMenuButton.y = 2500;
backToMenuButton.alpha = 0;
// Slots UI (classic slots removed - using Megaways only)
var spinButton = game.addChild(new GameButton('SPIN $25', 200, 80));
spinButton.x = 1024;
spinButton.y = 2700;
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 circularShadow = LK.getAsset('circularSpinButtonShadow', {
	anchorX: 0.5,
	anchorY: 0.5
});
circularShadow.x = 6;
circularShadow.y = 6;
circularShadow.alpha = 0.4;
spinButton.addChildAt(circularShadow, 0);
var circularButton = LK.getAsset('circularSpinButton', {
	anchorX: 0.5,
	anchorY: 0.5
});
spinButton.addChildAt(circularButton, 1);
var slotBackButton = game.addChild(new GameButton('MENU', 120, 50));
slotBackButton.x = 1024;
slotBackButton.y = 2500;
slotBackButton.alpha = 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 = 1800;
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 = 1750;
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 = 650;
dealerScoreText.alpha = 0;
game.addChild(dealerScoreText);
// Button event handlers
blackjackButton.up = function () {
	if (!blackjackButton.enabled) return;
	switchToBlackjack();
};
slotsButton.up = function () {
	if (!slotsButton.enabled) return;
	switchToSlots();
};
hitButton.up = function () {
	if (!hitButton.enabled) return;
	playerHit();
};
standButton.up = function () {
	if (!standButton.enabled) return;
	playerStand();
};
doubleButton.up = function () {
	if (!doubleButton.enabled) return;
	playerDouble();
};
dealButton.up = function () {
	if (!dealButton.enabled) return;
	startNewBlackjackHand();
};
backToMenuButton.up = function () {
	if (!backToMenuButton.enabled) return;
	switchToMenu();
};
spinButton.up = function () {
	if (!spinButton.enabled) return;
	spinSlots();
};
slotBackButton.up = function () {
	if (!slotBackButton.enabled) return;
	switchToMenu();
};
// Game functions
function updateMoneyDisplay() {
	moneyDisplay.setText('$' + playerMoney);
	betDisplay.setText('Bet: $' + currentBet);
	if (playerMoney >= 5000) {
		LK.showYouWin();
	} else if (playerMoney <= 0) {
		LK.showGameOver();
	}
}
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 = 800 + (dealerCards.length - 1) * 240;
		targetY = 500;
	} else {
		playerCards.push(card);
		targetX = 800 + (playerCards.length - 1) * 280;
		targetY = 1900;
	}
	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 switchToMenu() {
	gameMode = 'menu';
	messageDisplay.setText('Choose your game!');
	// Hide all game elements
	tween(hitButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(standButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(doubleButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(dealButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(backToMenuButton, {
		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(slotBackButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(gameDeck, {
		alpha: 0
	}, {
		duration: 300
	});
	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
	});
	// Show card display
	tween(cardDisplayContainer, {
		alpha: 1
	}, {
		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 Megaways slot machine
	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
	});
	// Clear cards
	clearTable();
}
function switchToBlackjack() {
	gameMode = 'blackjack';
	gamePhase = 'betting';
	messageDisplay.setText('Place your bet and deal!');
	// Hide menu buttons
	tween(blackjackButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(slotsButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide card display
	tween(cardDisplayContainer, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide main menu background
	tween(fondoM, {
		alpha: 0
	}, {
		duration: 300
	});
	// Show table background
	tween(tableBackground, {
		alpha: 0.8
	}, {
		duration: 300
	});
	// Ensure no unwanted coloring
	tableBackground.tint = 0xffffff;
	// Show blackjack UI
	tween(dealButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(backToMenuButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(playerScoreText, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(dealerScoreText, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(gameDeck, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(dealerAnimatedHand, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(playerAnimatedHand, {
		alpha: 1
	}, {
		duration: 300
	});
	dealButton.setEnabled(playerMoney >= currentBet);
}
function switchToSlots() {
	gameMode = 'slots';
	messageDisplay.setText('Spin to win!');
	// Hide menu buttons
	tween(blackjackButton, {
		alpha: 0
	}, {
		duration: 300
	});
	tween(slotsButton, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide card display
	tween(cardDisplayContainer, {
		alpha: 0
	}, {
		duration: 300
	});
	// Hide main menu background
	tween(fondoM, {
		alpha: 0
	}, {
		duration: 300
	});
	// Slots background removed - no background shown
	// Show tragamonedas asset in slots mode
	tween(tragamonedasAsset, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Megaways slot machine
	tween(megawaysSlotMachine, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show Megaways displays
	tween(waysDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(winAmountDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(cascadeDisplay, {
		alpha: 1
	}, {
		duration: 300
	});
	// Show slots UI (classic reels removed - using Megaways only)
	tween(spinButton, {
		alpha: 1
	}, {
		duration: 300
	});
	tween(slotBackButton, {
		alpha: 1
	}, {
		duration: 300
	});
	spinButton.setEnabled(playerMoney >= 25);
	// Update ways display
	waysDisplay.setText(megawaysSlotMachine.getWaysText());
	winAmountDisplay.setText('WIN: $0');
	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 startNewBlackjackHand() {
	if (playerMoney < currentBet) return;
	playerMoney -= currentBet;
	updateMoneyDisplay();
	clearTable();
	createDeck();
	gameDeck.updateCount(52);
	gamePhase = 'dealing';
	messageDisplay.setText('Dealing cards...');
	// 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) {
			messageDisplay.setText('Blackjack!');
			endHand();
		} else {
			gamePhase = 'playing';
			messageDisplay.setText('Hit or Stand?');
			// Show action buttons
			tween(hitButton, {
				alpha: 1
			}, {
				duration: 300
			});
			tween(standButton, {
				alpha: 1
			}, {
				duration: 300
			});
			if (playerMoney >= currentBet) {
				tween(doubleButton, {
					alpha: 1
				}, {
					duration: 300
				});
			}
			dealButton.setEnabled(false);
		}
	}
}
function playerHit() {
	var targetX = 800 + playerCards.length * 280;
	var targetY = 1900;
	// 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) {
							messageDisplay.setText('Bust! You lose.');
							endHand();
						} else if (playerScore === 21) {
							playerStand();
						}
					});
				}
			});
		}
	});
	// Disable double after hit
	doubleButton.setEnabled(false);
}
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 = 800 + playerCards.length * 280;
	var targetY = 1900;
	// 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) {
								messageDisplay.setText('Bust! You lose.');
								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;
	if (playerScore > 21) {
		messageDisplay.setText('Bust! You lose.');
	} else if (dealerScore > 21) {
		messageDisplay.setText('Dealer busts! You win!');
		winnings = currentBet * 2;
	} else if (playerScore > dealerScore) {
		messageDisplay.setText('You win!');
		winnings = currentBet * 2;
	} else if (playerScore < dealerScore) {
		messageDisplay.setText('Dealer wins.');
	} else {
		messageDisplay.setText('Push! It\'s a tie.');
		winnings = currentBet;
	}
	if (winnings > 0) {
		playerMoney += winnings;
		LK.getSound('coinWin').play();
		createCoinAnimation(1024, 1366);
	}
	currentBet = 50;
	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);
	// Show deal button again
	LK.setTimeout(function () {
		dealButton.setEnabled(playerMoney >= currentBet);
		gamePhase = 'betting';
		messageDisplay.setText('Place your bet and deal!');
	}, 2000);
}
function spinSlots() {
	if (playerMoney < 25) return;
	if (megawaysSlotMachine.isSpinning) return;
	playerMoney -= 25;
	updateMoneyDisplay();
	spinButton.setEnabled(false);
	messageDisplay.setText('Spinning...');
	// Reset displays
	winAmountDisplay.setText('WIN: $0');
	cascadeDisplay.setText('');
	megawaysSlotMachine.totalWinAmount = 0;
	megawaysSlotMachine.cascadeCount = 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 () {
		// Update ways display after spin completes
		waysDisplay.setText(megawaysSlotMachine.getWaysText());
		// 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!');
			spinButton.setEnabled(playerMoney >= 25);
		}
	});
}
function processInitialWins(winningCombinations) {
	megawaysSlotMachine.processWins(winningCombinations, function (winAmount) {
		if (winAmount > 0) {
			// Update displays
			winAmountDisplay.setText('WIN: $' + megawaysSlotMachine.totalWinAmount);
			cascadeDisplay.setText('CASCADE x' + megawaysSlotMachine.cascadeCount);
			// Add winnings to player money
			playerMoney += winAmount;
			updateMoneyDisplay();
			// Play win sound and create coin animation
			LK.getSound('coinWin').play();
			createCoinAnimation(1024, 1366);
			// Flash win amount display
			tween(winAmountDisplay, {
				scaleX: 1.3,
				scaleY: 1.3,
				tint: 0x00FF00
			}, {
				duration: 200,
				onFinish: function onFinish() {
					tween(winAmountDisplay, {
						scaleX: 1.0,
						scaleY: 1.0,
						tint: 0xFFFFFF
					}, {
						duration: 200
					});
				}
			});
		}
		// Re-enable spin button after all cascades complete
		LK.setTimeout(function () {
			spinButton.setEnabled(playerMoney >= 25);
			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('Spin to win!');
			}
		}, 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 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();
			}
		});
	}
}
// Card display area for showing all card types
var cardDisplay = [];
var cardDisplayContainer = game.addChild(new Container());
cardDisplayContainer.x = 1024;
cardDisplayContainer.y = 700;
cardDisplayContainer.alpha = 1;
// Create all cards for display - all values from all suits
var suits = ['hearts', 'diamonds', 'clubs', 'spades'];
var values = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]; // All card values
var cardIndex = 0;
for (var s = 0; s < suits.length; s++) {
	for (var v = 0; v < values.length; v++) {
		var displayCard = new Card(suits[s], values[v]);
		displayCard.scaleX = 0.6;
		displayCard.scaleY = 0.6;
		// Arrange cards in a grid - 13 cards per row (one per value), 4 rows (one per suit)
		var row = s;
		var col = v;
		displayCard.x = (col - 6) * 150; // Center the 13 cards horizontally with tighter spacing
		displayCard.y = (row - 1.5) * 200; // Center the 4 rows vertically
		displayCard.flip(); // Show face up
		cardDisplayContainer.addChild(displayCard);
		cardDisplay.push(displayCard);
		cardIndex++;
	}
}
// Start music
LK.playMusic('casinoMusic');
// Initialize game state
updateMoneyDisplay();
switchToMenu();
game.update = function () {
	updateMoneyDisplay();
};

===================================================================
--- original.js
+++ change.js
@@ -1855,9 +1855,9 @@
 tragamonedasAsset.alpha = 0; // Start hidden
 game.addChild(tragamonedasAsset);
 // Add Megaways slot machine above tragamonedas (higher z-index)
 var megawaysSlotMachine = game.addChild(new MegawaysSlotMachine());
-megawaysSlotMachine.x = 894; // Moved left by 130 pixels total (100 + 30)
+megawaysSlotMachine.x = 954; // Moved right by 60 pixels (894 + 60)
 megawaysSlotMachine.y = 1200; // Position to overlap with tragamonedas
 megawaysSlotMachine.scaleX = 1.6; // Scale by 1.6 times larger
 megawaysSlotMachine.scaleY = 1.6; // Scale by 1.6 times larger
 megawaysSlotMachine.alpha = 0;