/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1", { battleRating: 0, money: 0, ownedMods: {}, randomModPrice: 300, tutorialCompleted: false, coopHighestWave: 0 }); /**** * Classes ****/ /**** * Bullet Class ****/ var Bullet = Container.expand(function () { var self = Container.call(this); self.active = false; self.target = null; self.damage = 10; self.speed = 11.5; self.isPlayerCard = true; self.isSeekingLastPosition = false; self.targetLastX = 0; self.targetLastY = 0; self.level = 1; self.ricochetCount = 0; self.ricochetedFrom = []; var currentGraphic = null; // Add suitCircle backgrounds for each suit var suitCircleGraphics = { 'hearts': self.attachAsset('suitCircle', { anchorX: 0.5, anchorY: 0.5 }), 'diamonds': self.attachAsset('suitCircle', { anchorX: 0.5, anchorY: 0.5 }), 'clubs': self.attachAsset('suitCircle', { anchorX: 0.5, anchorY: 0.5 }), 'spades': self.attachAsset('suitCircle', { anchorX: 0.5, anchorY: 0.5 }) }; var baseSuitGraphics = { 'hearts': self.attachAsset('heartSuit', { anchorX: 0.5, anchorY: 0.5 }), 'diamonds': self.attachAsset('diamondSuit', { anchorX: 0.5, anchorY: 0.5 }), 'clubs': self.attachAsset('clubSuit', { anchorX: 0.5, anchorY: 0.5 }), 'spades': self.attachAsset('spadeSuit', { anchorX: 0.5, anchorY: 0.5 }) }; var modGraphicsCache = {}; // Set scale and hide all suit graphics and suit circles initially. for (var suit in baseSuitGraphics) { var graphic = baseSuitGraphics[suit]; var circle = suitCircleGraphics[suit]; graphic.scale.set(0.3); // Small bullets graphic.visible = false; if (circle) { circle.scale.set(0.45); // Slightly larger than suit icon circle.visible = false; // Ensure circle is rendered below the suit icon self.setChildIndex(circle, Math.max(0, self.getChildIndex(graphic) - 1)); } } self.activate = function (startX, startY, target, damage, suit, isPlayerCard, level) { self.active = true; self.visible = true; self.x = startX; self.y = startY; self.target = target; self.damage = damage; self.isPlayerCard = isPlayerCard; self.level = level || 1; self.suit = suit || 'hearts'; self.isSeekingLastPosition = false; self.ricochetCount = 0; self.ricochetedFrom = []; self.hasRetargeted = false; if (suit === 'clubs' && ModSystem.getEquippedModAsset('clubs', isPlayerCard) === 'ricochetClubsMod') { // 3 bounces, +1 every 2 levels. Max 6. (Increased by 1) self.ricochetCount = Math.min(6, 3 + Math.floor((self.level - 1) / 2)); } if (self.target) { self.targetLastX = self.target.x; self.targetLastY = self.target.y; } // Hide previous suitCircle if any if (currentGraphic) { currentGraphic.visible = false; // Hide all suit circles for (var suitKey in suitCircleGraphics) { if (suitCircleGraphics[suitKey]) { suitCircleGraphics[suitKey].visible = false; } } } suit = suit || 'hearts'; var equippedMod = ModSystem.getEquippedModAsset(suit, self.isPlayerCard); if (equippedMod) { if (!modGraphicsCache[equippedMod]) { modGraphicsCache[equippedMod] = self.attachAsset(equippedMod, { anchorX: 0.5, anchorY: 0.5 }); modGraphicsCache[equippedMod].scale.set(0.3); modGraphicsCache[equippedMod].visible = false; } currentGraphic = modGraphicsCache[equippedMod]; } else { currentGraphic = baseSuitGraphics[suit]; } currentGraphic.visible = true; // Show and position the suitCircle under the current suit asset if (suitCircleGraphics[suit]) { suitCircleGraphics[suit].visible = true; // Ensure suitCircle is rendered below the suit icon if (self.getChildIndex(suitCircleGraphics[suit]) > self.getChildIndex(currentGraphic)) { self.setChildIndex(suitCircleGraphics[suit], Math.max(0, self.getChildIndex(currentGraphic) - 1)); } // Center the circle (should already be, but for safety) suitCircleGraphics[suit].x = 0; suitCircleGraphics[suit].y = 0; } }; self.findNewTarget = function () { // Use the same targeting logic as cards, but from bullet's perspective var targets; if (gameMode === 'coop') { targets = activePlayerChips.concat(activeAIChips); } else { targets = self.isPlayerCard ? activePlayerChips : activeAIChips; } var bestTarget = null; var shortestDistanceSq = Infinity; var turningPointY = SCREEN_HEIGHT / 2 - 200; for (var i = 0; i < targets.length; i++) { var chip = targets[i]; if (chip.active) { if (gameMode === 'coop') { var isPlayerChip = chip.isPlayerSide; var isPlayerBullet = self.isPlayerCard; var onHorizontalPath = isPlayerChip ? chip.y <= turningPointY : chip.y >= turningPointY; if (!onHorizontalPath) { if (isPlayerBullet !== isPlayerChip) { continue; } } } var dx = chip.x - self.x; var dy = chip.y - self.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < shortestDistanceSq) { shortestDistanceSq = distanceSq; bestTarget = chip; } } } return bestTarget; }; self.findRicochetTarget = function () { // Use the same targeting logic as cards, but from bullet's perspective var targets; if (gameMode === 'coop') { targets = activePlayerChips.concat(activeAIChips); } else { targets = self.isPlayerCard ? activePlayerChips : activeAIChips; } var bestTarget = null; var shortestDistanceSq = Infinity; var turningPointY = SCREEN_HEIGHT / 2 - 200; for (var i = 0; i < targets.length; i++) { var potentialTarget = targets[i]; if (potentialTarget.active && self.ricochetedFrom.indexOf(potentialTarget) === -1) { if (gameMode === 'coop') { var isPlayerChip = potentialTarget.isPlayerSide; var isPlayerBullet = self.isPlayerCard; var onHorizontalPath = isPlayerChip ? potentialTarget.y <= turningPointY : potentialTarget.y >= turningPointY; if (!onHorizontalPath) { if (isPlayerBullet !== isPlayerChip) { continue; } } } var dx = potentialTarget.x - self.x; var dy = potentialTarget.y - self.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < shortestDistanceSq) { shortestDistanceSq = distanceSq; bestTarget = potentialTarget; } } } return bestTarget; }; self.update = function () { if (!self.active) { return; } // If target is destroyed, try to find a new target instead of seeking last position if (self.target && !self.target.active) { var newTarget = null; if (!self.hasRetargeted) { newTarget = self.findNewTarget(); } if (newTarget) { self.target = newTarget; self.targetLastX = newTarget.x; self.targetLastY = newTarget.y; self.hasRetargeted = true; } else { // No new target available, or already retargeted. Seek last position. self.isSeekingLastPosition = true; self.target = null; } } // If seeking, move towards the last position if (self.isSeekingLastPosition) { var dx = self.targetLastX - self.x; var dy = self.targetLastY - self.y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < self.speed) { // Arrived at destination, recycle bullet self.isSeekingLastPosition = false; if (currentGraphic) { currentGraphic.visible = false; } PoolManager.returnBullet(self); } else { // Move towards destination var angle = Math.atan2(dy, dx); self.x += Math.cos(angle) * self.speed; self.y += Math.sin(angle) * self.speed; } } else if (self.target) { // Store previous position for continuous collision detection var prevX = self.x; var prevY = self.y; // Update last known position self.targetLastX = self.target.x; self.targetLastY = self.target.y; var dx = self.target.x - self.x; var dy = self.target.y - self.y; var distance = Math.sqrt(dx * dx + dy * dy); // Calculate where bullet will be after this frame var angle = Math.atan2(dy, dx); var newX = self.x + Math.cos(angle) * self.speed; var newY = self.y + Math.sin(angle) * self.speed; // RELIABLE COLLISION DETECTION: // Check if the bullet's path for this frame intersects the target's radius. // This prevents "tunneling" where a fast bullet could pass through a target between frames. var hitRadius = 85; // Visual radius of the chip, matches chip graphics var collisionDistance = distancePointToLine(self.target.x, self.target.y, prevX, prevY, newX, newY); if (collisionDistance <= hitRadius) { // Hit detected // NEW: Check for Execute mod for Spades BEFORE dealing damage if (self.suit === 'spades' && ModSystem.getEquippedModAsset('spades', self.isPlayerCard) === 'deathSpadesMod') { // Execute threshold: starts at 15%, +1% per level. Max 40%. var executeThreshold = Math.min(0.60, 0.25 + (self.level - 1) * 0.01); // Execute chance: starts at 20%, +2% per level. Max 50%. var executeChance = Math.min(0.50, 0.20 + (self.level - 1) * 0.02); if (self.target.health / self.target.maxHealth <= executeThreshold) { if (Math.random() < executeChance) { // Execute! createFloatingText('EXECUTE!', self.target.x, self.target.y - 60, 0xaa00aa, 50); // Create the execution animation var executionEffect = LK.getAsset('deathSpadesMod', { anchorX: 0.5, anchorY: 0.5, x: self.target.x, y: self.target.y, scaleX: 0.1, scaleY: 0.1, alpha: 1 }); gameLayer.addChild(executionEffect); tween(executionEffect, { scaleX: 2, scaleY: 2, alpha: 0 }, { duration: 500, easing: tween.quadOut, onFinish: function onFinish() { if (executionEffect.parent) { executionEffect.parent.removeChild(executionEffect); } } }); self.target.takeDamage(self.target.health, self.isPlayerCard); // Deal fatal damage // Recycle bullet and stop further processing if (currentGraphic) { currentGraphic.visible = false; } PoolManager.returnBullet(self); return; // IMPORTANT: Exit update for this bullet } } } // If not executed, proceed with normal hit logic self.target.takeDamage(self.damage, self.isPlayerCard, self.suit); // NEW: Check if this is a hearts bullet and flame mod is equipped if (self.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', self.isPlayerCard) === 'burnHeartMod') { // Calculate burn damage (10% of hit damage per tick) var burnDamage = self.damage * 0.1; // Increase burn duration by 50% (from 5 to 7.5 ticks) var burnDuration = Math.round(5 * 1.5); // 7.5 → 8 ticks = ~4 seconds of burning // Apply burn effect self.target.applyBurn(burnDamage, burnDuration, self.isPlayerCard); } // NEW: Check if this is a spades bullet and freeze mod is equipped if (self.suit === 'spades' && ModSystem.getEquippedModAsset('spades', self.isPlayerCard) === 'freezeSpadeMod') { // Calculate freeze duration (3 seconds base) var freezeDuration = 180; // 180 ticks at 60fps = 3 seconds // Apply freeze effect self.target.applyFreeze(freezeDuration); } // NEW: Check if this is a clubs bullet and slow mod is equipped if (self.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs', self.isPlayerCard) === 'slowClubsMod') { // Slow amount: 20% base, +5% per level. Max 70%. var slowAmount = Math.min(0.7, 0.2 + (self.level - 1) * 0.05); // Slow duration: 2s base, +0.5s per level. var slowDuration = 120 + (self.level - 1) * 30; // 120 ticks = 2s self.target.applySlow(slowAmount, slowDuration); } // NEW: Check if this is a clubs bullet and toxin mod is equipped if (self.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs', self.isPlayerCard) === 'toxinClubMod') { // Calculate poison damage (5% of hit damage per tick) var poisonDamage = self.damage * 0.05; var poisonDuration = 10; // 10 ticks // Apply poison effect if (self.target && typeof self.target.applyPoison === "function") { self.target.applyPoison(poisonDamage, poisonDuration, self.isPlayerCard); } } // NEW: Check for ricochet mod for clubs if (self.ricochetCount > 0) { self.ricochetedFrom.push(self.target); var newTarget = self.findRicochetTarget(); if (newTarget) { self.target = newTarget; self.targetLastX = newTarget.x; self.targetLastY = newTarget.y; self.ricochetCount--; self.damage = Math.floor(self.damage * 0.7); // 70% damage on next hit // Visual feedback for ricochet createExplosion(self.x, self.y, 0xcccccc); return; // Keep the bullet alive and moving to the new target } } if (currentGraphic) { currentGraphic.visible = false; } PoolManager.returnBullet(self); } else { // No hit, move bullet forward self.x = newX; self.y = newY; } } else { // No target and not seeking, recycle if (currentGraphic) { currentGraphic.visible = false; } PoolManager.returnBullet(self); } }; return self; }); // Helper function to calculate distance from point to line segment /**** * Object Pool Manager ****/ /**** * Card Class ****/ var Card = Container.expand(function (cardData) { var self = Container.call(this); self.cardData = cardData; self.level = 1; self.isInPlay = false; self.isPlayerCard = true; // Track which player owns this card self.playSlotX = 0; self.playSlotY = 0; self.lastFired = 0; self.fireRate = 60; // Base fire rate (ticks between shots) self.damage = 35; // Increased base damage self.range = 200; self.handBonus = 1; self.timeOnBoard = 0; self.lastIncomeTick = 0; var redOutline = self.attachAsset('card', { anchorX: 0.5, anchorY: 0.5 }); redOutline.scale.set(1.1); redOutline.alpha = 1.0; redOutline.tint = 0xff0000; // Red color redOutline.visible = false; self.redOutline = redOutline; var greenOutline = self.attachAsset('card', { anchorX: 0.5, anchorY: 0.5 }); greenOutline.scale.set(1.1); greenOutline.alpha = 0.7; greenOutline.tint = 0x00ff00; greenOutline.visible = false; self.greenOutline = greenOutline; var cardGraphics = self.attachAsset('card', { anchorX: 0.5, anchorY: 0.5 }); // Define getSuitSymbol method before using it self.getSuitSymbol = function (suit) { switch (suit) { case 'hearts': return '♥'; case 'diamonds': return '♦'; case 'clubs': return '♣'; case 'spades': return '♠'; case 'joker': return '🃏'; default: return '?'; } }; // Card value in top left corner if (cardData.suit !== 'joker') { var valueText = new Text2(cardData.value, { size: 56, fill: CardSystem.suitColors[cardData.suit] || 0x000000, weight: 800, stroke: 0x000000, strokeThickness: 0 }); valueText.anchor.set(0, 0); valueText.x = -95; // Top left valueText.y = -135; self.addChild(valueText); } // Large suit symbol in center, deferred to activate() var suitGraphics = null; var jokerSuitGraphics = null; // Level text at bottom var levelText = new Text2('Lvl 1', { size: 45, fill: 0x000000, weight: 800, stroke: 0x000000, strokeThickness: 0 }); levelText.anchor.set(0.5, 1); levelText.y = 128; // Bottom of card self.addChild(levelText); self.activate = function (x, y, inPlay, isPlayerCard) { self.x = x; self.y = y; self.isInPlay = inPlay || false; self.isPlayerCard = isPlayerCard !== undefined ? isPlayerCard : true; self.visible = true; // Remove old graphics if they exist if (suitGraphics && suitGraphics.parent) { suitGraphics.parent.removeChild(suitGraphics); suitGraphics = null; } if (jokerSuitGraphics && jokerSuitGraphics.parent) { jokerSuitGraphics.parent.removeChild(jokerSuitGraphics); jokerSuitGraphics = null; } // Create new suit graphic based on player/AI context var suitAssetId = null; var equippedMod = ModSystem.getEquippedModAsset(self.cardData.suit, self.isPlayerCard); if (equippedMod) { suitAssetId = equippedMod; } else { switch (self.cardData.suit) { case 'hearts': suitAssetId = 'heartSuit'; break; case 'diamonds': suitAssetId = 'diamondSuit'; break; case 'clubs': suitAssetId = 'clubSuit'; break; case 'spades': suitAssetId = 'spadeSuit'; break; } } if (suitAssetId) { suitGraphics = self.attachAsset(suitAssetId, { anchorX: 0.5, anchorY: 0.5 }); suitGraphics.y = -15; suitGraphics.scaleX = suitGraphics.scaleY = 0.8; } else if (self.cardData.suit === 'joker') { jokerSuitGraphics = self.attachAsset('jokerSuit', { anchorX: 0.5, anchorY: 0.5 }); jokerSuitGraphics.y = -15; jokerSuitGraphics.scale.set(1.5); } if (inPlay) { self.calculateStats(); } }; self.calculateStats = function () { // Stats based on level only, not card face value var baseDamage = 10; // Reduced base damage var baseFireRate = 60; // Level scaling - more dramatic improvements per level self.damage = Math.floor(baseDamage * Math.pow(1.6, self.level - 1)); // Further decreased scaling from 1.7 to 1.6 self.fireRate = Math.max(15, Math.floor(baseFireRate / Math.pow(1.2, self.level - 1))); // Reduced from 1.25 to 1.2 // Apply poker hand bonus self.damage = Math.floor(self.damage * self.handBonus); self.fireRate = Math.max(10, Math.floor(self.fireRate / self.handBonus)); // NEW: Apply Wildcard penalty if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', self.isPlayerCard) === 'wildcardHeartMod') { self.damage = Math.floor(self.damage * 0.6); // 40% damage reduction } // NEW: Apply Gambit Diamond Mod bonuses if (self.cardData.suit === 'diamonds' && ModSystem.getEquippedModAsset('diamonds', self.isPlayerCard) === 'gambitDiamondMod') { var cardValue = CardSystem.getCardValue(self); var isOdd = false; // Check if card value is odd (A=14, K=13, Q=12, J=11) if (cardValue === 14 || cardValue === 13 || cardValue === 11 || // A, K, J cardValue === 9 || cardValue === 7 || cardValue === 5 || cardValue === 3) { isOdd = true; } if (isOdd) { // Odd cards: +30% attack speed (reduce fire rate) self.fireRate = Math.max(10, Math.floor(self.fireRate * 0.7)); // 30% faster = 70% of original time } else { // Even cards: +40% attack power self.damage = Math.floor(self.damage * 1.4); // 40% more damage } } // NEW: Apply mod-specific stat changes if (self.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades', self.isPlayerCard) === 'mineSpadesMod') { // Mine mod significantly slows fire rate in exchange for higher damage per mine. self.fireRate *= 2.5; } }; self.setLevel = function (newLevel) { if (self.cardData.suit === 'joker') { self.level = 1; levelText.visible = false; self.calculateStats(); return; } self.level = newLevel; levelText.setText('Lvl ' + self.level); self.calculateStats(); self.resetInvestment(); // Visual feedback for higher levels if (self.level > 1) { // The glow effect was causing cards to become translucent. // Level up is already indicated by animation and floating text. } }; self.resetInvestment = function () { self.timeOnBoard = 0; self.lastIncomeTick = LK.ticks; }; self.canMergeWith = function (otherCard) { if (!otherCard || otherCard === self) { return false; } // If the card being dropped onto is a Joker, it cannot be leveled up. if (otherCard.cardData && otherCard.cardData.suit === 'joker') { return false; } // If the card being dragged is a Joker, it can merge with any non-Joker card. if (self.cardData.suit === 'joker') { return true; } // NEW: If dragged card is Hearts with Wildcard mod, can merge with any same-level card if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', self.isPlayerCard) === 'wildcardHeartMod' && self.level === otherCard.level) { return true; } // Must be same level AND (same suit OR same value) var sameLevel = self.level === otherCard.level; var sameSuit = self.cardData.suit === otherCard.cardData.suit; var sameValue = self.cardData.value === otherCard.cardData.value; return sameLevel && (sameSuit || sameValue); }; self.mergeWith = function (otherCard) { if (!self.canMergeWith(otherCard)) { return null; } // ... existing merge logic ... // When merging, the new card levels up. The new level is one higher than the card on the board. var newLevel = otherCard.level + 1; // Special case: If the card being dragged is a Joker, the target card just increases its level if (self.cardData.suit === 'joker') { var mergedCard = new Card(otherCard.cardData); mergedCard.setLevel(newLevel); return mergedCard; } // NEW: Trigger sabotage effect if either card involved in the merge is a sabotage mod card var isSabotageInvolved = self.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades', self.isPlayerCard) === 'sabotageSpadesMod' || otherCard.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades', otherCard.isPlayerCard) === 'sabotageSpadesMod'; if (isSabotageInvolved) { if (typeof self.performSabotage === "function") { self.performSabotage(); } } // The new card is of a random type, regardless of what was merged. var randomSuit = CardSystem.suits[Math.floor(Math.random() * CardSystem.suits.length)]; var randomValue = CardSystem.values[Math.floor(Math.random() * CardSystem.values.length)]; var newCardData = { suit: randomSuit, value: randomValue, id: randomSuit + '_' + randomValue }; var mergedCard = new Card(newCardData); mergedCard.setLevel(newLevel); return mergedCard; }; self.findTarget = function () { // Player cards target enemies attacking the player (activePlayerChips) // AI cards target enemies attacking the AI (activeAIChips) var targets; if (gameMode === 'coop') { // In coop, start with all targets and filter based on position targets = activePlayerChips.concat(activeAIChips); } else { targets = self.isPlayerCard ? activePlayerChips : activeAIChips; } var bestTarget = null; var highestProgress = -1; var turningPointY = SCREEN_HEIGHT / 2 - 200; for (var i = 0; i < targets.length; i++) { var chip = targets[i]; // Add extra validation for alive targets if (chip.active && chip.health > 0 && chip.visible && chip.pathProgress > highestProgress) { if (gameMode === 'coop') { var isPlayerChip = chip.isPlayerSide; var isPlayerCard = self.isPlayerCard; // Player chips move up (y decreases), AI chips move down (y increases). var onHorizontalPath = isPlayerChip ? chip.y <= turningPointY : chip.y >= turningPointY; if (!onHorizontalPath) { // Not on the shared horizontal path yet, so cards can only target their own side's enemies. if (isPlayerCard !== isPlayerChip) { continue; } } // If onHorizontalPath is true, any card can target the chip, so no 'continue' needed. } highestProgress = chip.pathProgress; bestTarget = chip; } } return bestTarget; }; self.fire = function () { // Add this check at the beginning of Card.fire function: if (self.isLocked) { return; // Locked cards cannot fire } var target = self.findTarget(); if (!target) { return; } // NEW: Handle Mine Spades Mod if (self.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades', self.isPlayerCard) === 'mineSpadesMod') { var mine = PoolManager.getMine(self.isPlayerCard); if (mine) { var pathProgress = Math.random() * 70 + 15; var minePos = PathSystem.getPositionAlongPath(pathProgress, self.isPlayerCard); var mineDamage = Math.floor(self.damage * 2); // Mines deal 2.5x card damage mine.activate(minePos.x, minePos.y, mineDamage, self.isPlayerCard); gameLayer.addChild(mine); activeMines.push(mine); } } else { var damageToDeal = self.damage; // NEW: Calculate Unity Bonus for Hearts if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', self.isPlayerCard) === 'unityHeartsMod') { var playArea = self.isPlayerCard ? gameState.playerPlayArea : gameState.aiPlayArea; var cardRow = -1, cardCol = -1; // Find card's position in the grid for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (playArea[r][c] === self) { cardRow = r; cardCol = c; break; } } if (cardRow !== -1) { break; } } if (cardRow !== -1) { var adjacentHearts = 0; var neighbors = [[cardRow - 1, cardCol], [cardRow + 1, cardCol], [cardRow, cardCol - 1], [cardRow, cardCol + 1]]; for (var i = 0; i < neighbors.length; i++) { var nRow = neighbors[i][0]; var nCol = neighbors[i][1]; // ADD BOUNDS CHECKING HERE if (nRow >= 0 && nRow < PLAY_AREA_ROWS && nCol >= 0 && nCol < PLAY_AREA_COLS) { var neighborCard = playArea[nRow][nCol]; if (neighborCard && neighborCard.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', neighborCard.isPlayerCard) === 'unityHeartsMod') { adjacentHearts++; } } } // Each adjacent heart adds 25% bonus damage damageToDeal = Math.floor(damageToDeal * (1 + 0.20 * adjacentHearts)); } } // NEW: Calculate Gambler Bonus for Diamonds if (self.cardData.suit === 'diamonds' && ModSystem.getEquippedModAsset('diamonds', self.isPlayerCard) === 'gamblerDiamondsMod') { // Base 50% chance of double damage, increases by 5% per level. Capped at 95%. var doubleDamageChance = Math.min(0.95, 0.5 + (self.level - 1) * 0.05); if (Math.random() < doubleDamageChance) { damageToDeal *= 2; createFloatingText('x2!', self.x, self.y - 70, 0xffd700, 30); } else { damageToDeal = Math.max(1, Math.floor(damageToDeal * 0.75)); // Changed from 0 to 10% damage createFloatingText('Weak!', self.x, self.y - 70, 0xaaaaaa, 30); // Changed text } } // NEW: Calculate Boost from adjacent Diamonds var playArea = self.isPlayerCard ? gameState.playerPlayArea : gameState.aiPlayArea; var cardRow = -1, cardCol = -1; // Find card's position in the grid for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (playArea[r][c] === self) { cardRow = r; cardCol = c; break; } } if (cardRow !== -1) { break; } } if (cardRow !== -1) { var totalBoostPercentage = 0; var neighbors = [[cardRow - 1, cardCol], [cardRow + 1, cardCol], [cardRow, cardCol - 1], [cardRow, cardCol + 1]]; for (var i = 0; i < neighbors.length; i++) { var nRow = neighbors[i][0]; var nCol = neighbors[i][1]; if (nRow >= 0 && nRow < PLAY_AREA_ROWS && nCol >= 0 && nCol < PLAY_AREA_COLS) { var neighborCard = playArea[nRow][nCol]; if (neighborCard && neighborCard.cardData.suit === 'diamonds' && ModSystem.getEquippedModAsset('diamonds', neighborCard.isPlayerCard) === 'boostDiamondsMod') { // Each level of the booster card adds 8% damage. totalBoostPercentage += neighborCard.level * 0.08; } } } if (totalBoostPercentage > 0) { damageToDeal = Math.floor(damageToDeal * (1 + totalBoostPercentage)); } } // Check if this is a clubs card with spreadshot mod equipped var isSpreadshot = self.cardData.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs', self.isPlayerCard) === 'spreadClubMod'; if (isSpreadshot) { // Spreadshot: reduced damage but hits multiple targets var spreadDamage = Math.floor(self.damage * 0.5); var maxTargets = Math.min(1 + self.level, 5); var allTargets; if (gameMode === 'coop') { allTargets = activePlayerChips.concat(activeAIChips); } else { allTargets = self.isPlayerCard ? activePlayerChips : activeAIChips; } var closestTargets = []; // This will store {chip, distanceSq} objects var turningPointY = SCREEN_HEIGHT / 2 - 200; // Find multiple targets using an efficient selection method instead of sorting all targets for (var i = 0; i < allTargets.length; i++) { var chip = allTargets[i]; if (chip.active && chip.health > 0 && chip.visible) { if (gameMode === 'coop') { var isPlayerChip = chip.isPlayerSide; var isPlayerCard = self.isPlayerCard; var onHorizontalPath = isPlayerChip ? chip.y <= turningPointY : chip.y >= turningPointY; if (!onHorizontalPath) { if (isPlayerCard !== isPlayerChip) { continue; } } } var dx = chip.x - self.x; var dy = chip.y - self.y; var distanceSq = dx * dx + dy * dy; if (closestTargets.length < maxTargets) { closestTargets.push({ chip: chip, distanceSq: distanceSq }); } else { var furthestDistSq = -1; var furthestIdx = -1; for (var j = 0; j < closestTargets.length; j++) { if (closestTargets[j].distanceSq > furthestDistSq) { furthestDistSq = closestTargets[j].distanceSq; furthestIdx = j; } } if (distanceSq < furthestDistSq) { closestTargets[furthestIdx] = { chip: chip, distanceSq: distanceSq }; } } } } // Fire at the found targets for (var i = 0; i < closestTargets.length; i++) { var bullet = PoolManager.getBullet(); if (bullet) { bullet.activate(self.x, self.y, closestTargets[i].chip, spreadDamage, self.cardData.suit, self.isPlayerCard, self.level); gameLayer.addChild(bullet); activeBullets.push(bullet); } } } else { // Normal single-target firing var bullet = PoolManager.getBullet(); if (bullet) { bullet.activate(self.x, self.y, target, damageToDeal, self.cardData.suit, self.isPlayerCard, self.level); gameLayer.addChild(bullet); activeBullets.push(bullet); } } } // Play shoot sound for player cards if (self.isPlayerCard) { LK.getSound('shootSound').play(); } self.lastFired = LK.ticks; // Visual feedback for firing (enhanced for spreadshot) tween.stop(self, { scaleX: true, scaleY: true }); var isSpreadshot = self.cardData.suit === 'clubs' && ModSystem.getEquippedModAsset('clubs', self.isPlayerCard) === 'spreadClubMod'; var scaleAmount = isSpreadshot ? 0.8 : 0.9; // More dramatic scale for spreadshot tween(self, { scaleX: scaleAmount, scaleY: scaleAmount }, { duration: 100, easing: tween.quadOut, onFinish: function onFinish() { tween(self, { scaleX: 1, scaleY: 1 }, { duration: 150, easing: tween.elasticOut }); } }); }; self.update = function () { if (!self.isInPlay) { return; } // NEW: Handle Investment Hearts Mod if (self.cardData.suit === 'hearts' && ModSystem.getEquippedModAsset('hearts', self.isPlayerCard) === 'investmentHeartsMod') { // Generate income every 5 seconds (300 ticks) var incomeInterval = 300; if (LK.ticks - self.lastIncomeTick >= incomeInterval) { self.lastIncomeTick = LK.ticks; // timeOnBoard is a counter of income ticks, not actual ticks on board self.timeOnBoard++; // Income formula: 1 chip base, +1 for every 2 intervals (10 seconds). Max 3. var income = 1 + Math.floor(self.timeOnBoard / 2); income = Math.min(income, 3); // Cap income (CHANGED from 5 to 3) if (self.isPlayerCard) { gameState.playerChips += income; createFloatingText('+' + income, self.x, self.y - 70, 0xffd700, 30); updateUI(); } else { // AI gets income too gameState.aiChips += income; } } } if (LK.ticks - self.lastFired >= self.fireRate) { self.fire(); } }; self.performSabotage = function () { if (gameMode === 'coop') { // Co-op: boost random ally card (player boosts AI, AI boosts player) var allyPlayArea = self.isPlayerCard ? gameState.aiPlayArea : gameState.playerPlayArea; var allyCandidates = []; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = allyPlayArea[row][col]; if (card && card !== self) { allyCandidates.push(card); } } } if (allyCandidates.length > 0) { var targetCard = allyCandidates[Math.floor(Math.random() * allyCandidates.length)]; targetCard.setLevel(targetCard.level + 1); createFloatingText('BOOSTED!', targetCard.x, targetCard.y - 50, 0x00ff00, 40); } } else { // PvP: sabotage random enemy card (existing logic stays the same) var enemyPlayArea = self.isPlayerCard ? gameState.aiPlayArea : gameState.playerPlayArea; var enemyCandidates = []; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = enemyPlayArea[row][col]; if (card && card.level > 1) { // Only target cards that can be reduced enemyCandidates.push(card); } } } if (enemyCandidates.length > 0) { var targetCard = enemyCandidates[Math.floor(Math.random() * enemyCandidates.length)]; targetCard.setLevel(targetCard.level - 1); createFloatingText('SABOTAGED!', targetCard.x, targetCard.y - 50, 0xff0000, 40); } } }; self.setLevel(1); return self; }); var Mine = Container.expand(function () { var self = Container.call(this); self.active = false; self.damage = 50; self.isPlayerMine = true; self.explosionRadiusSq = 150 * 150; var mineGraphics = self.attachAsset('mine', { anchorX: 0.5, anchorY: 0.5 }); mineGraphics.scale.set(0.8); self.activate = function (x, y, damage, isPlayerMine) { self.active = true; self.visible = true; self.x = x; self.y = y; self.damage = damage; self.isPlayerMine = isPlayerMine; self.scale.set(0.1); tween(self, { scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.backOut }); }; self.explode = function () { if (!self.active) { return; } self.active = false; createExplosion(self.x, self.y, 0xffa500); var targets; if (gameMode === 'coop') { targets = activePlayerChips.concat(activeAIChips); } else { targets = self.isPlayerMine ? activePlayerChips : activeAIChips; } var turningPointY = SCREEN_HEIGHT / 2 - 200; for (var i = targets.length - 1; i >= 0; i--) { var chip = targets[i]; if (chip.active) { if (gameMode === 'coop') { var isPlayerChip = chip.isPlayerSide; var onHorizontalPath = isPlayerChip ? chip.y <= turningPointY : chip.y >= turningPointY; if (!onHorizontalPath) { if (self.isPlayerMine !== isPlayerChip) { continue; } } } var dx = chip.x - self.x; var dy = chip.y - self.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < self.explosionRadiusSq) { // Mines deal 'spades' damage since they're from the spades mod chip.takeDamage(self.damage, self.isPlayerMine, 'spades'); } } } PoolManager.returnMine(self); }; self.update = function () { if (!self.active) { return; } var targets; if (gameMode === 'coop') { targets = activePlayerChips.concat(activeAIChips); } else { targets = self.isPlayerMine ? activePlayerChips : activeAIChips; } var collisionRadiusSq = 45 * 45; var turningPointY = SCREEN_HEIGHT / 2 - 200; for (var i = 0; i < targets.length; i++) { var chip = targets[i]; if (chip.active) { if (gameMode === 'coop') { var isPlayerChip = chip.isPlayerSide; var onHorizontalPath = isPlayerChip ? chip.y <= turningPointY : chip.y >= turningPointY; if (!onHorizontalPath) { if (self.isPlayerMine !== isPlayerChip) { continue; } } } var dx = chip.x - self.x; var dy = chip.y - self.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < collisionRadiusSq) { self.explode(); break; } } } }; return self; }); /**** * Poker Chip Enemy Class ****/ var PokerChip = Container.expand(function () { var self = Container.call(this); self.active = false; self.health = 100; // Increased base health self.maxHealth = 100; self.value = 1; self.speed = 0.05; self.pathProgress = 0; self.isPlayerSide = true; self.damageFlashTimer = 0; self.burnDamage = 0; self.burnDuration = 0; self.burnTickTimer = 0; self.burnSourceIsPlayer = null; self.burnTickInterval = 30; // Burn ticks every 0.5 seconds (30 ticks at 60fps) self.slowDuration = 0; self.slowAmount = 0; self.freezeDuration = 0; self.originalSpeed = 0; self.iceCube = null; // Will hold the ice cube graphic self.freezeImmunityTimer = 0; self.slowEffectIcon = null; var chipGraphicsAssets = { 1: self.attachAsset('yellowChip', { anchorX: 0.5, anchorY: 0.5 }), 5: self.attachAsset('redChip', { anchorX: 0.5, anchorY: 0.5 }), 10: self.attachAsset('greenChip', { anchorX: 0.5, anchorY: 0.5 }), 25: self.attachAsset('blueChip', { anchorX: 0.5, anchorY: 0.5 }), 100: self.attachAsset('purpleChip', { anchorX: 0.5, anchorY: 0.5 }) }; var chipGraphics = null; // This will hold the current visible chip for (var val in chipGraphicsAssets) { chipGraphicsAssets[val].visible = false; } var healthText = new Text2('', { size: 80, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 8 }); healthText.anchor.set(0.5, 0.5); self.addChild(healthText); self.applyBurn = function (damage, duration, isPlayerSource) { // Stack burn damage but refresh duration self.burnDamage += damage; self.burnDuration = Math.max(self.burnDuration, duration); self.burnTickTimer = 0; if (isPlayerSource !== undefined) { self.burnSourceIsPlayer = isPlayerSource; } createBurnEffect(self.x, self.y); }; self.applyFreeze = function (duration) { // Return if chip is immune to freeze if (self.freezeImmunityTimer > 0) { return; } // Don't freeze if already frozen - with special logic for bosses if (self.freezeDuration > 0) { if (!self.isBoss) { // Non-bosses can refresh duration self.freezeDuration = Math.max(self.freezeDuration, duration); } // Bosses simply ignore the new freeze request if they are already frozen. return; } self.freezeDuration = duration; // Store original speed and stop movement if (self.slowDuration <= 0) { self.originalSpeed = self.speed; } self.speed = 0; // Create ice cube encasement if (!self.iceCube) { self.iceCube = LK.getAsset('iceCube', { anchorX: 0.5, anchorY: 0.5 }); self.iceCube.scale.set(1.2); // Slightly larger than chip self.iceCube.alpha = 0.8; self.addChild(self.iceCube); } self.iceCube.visible = true; // Ice formation animation self.iceCube.scale.set(0.1); self.iceCube.alpha = 0; tween(self.iceCube, { scaleX: 1.2, scaleY: 1.2, alpha: 0.8 }, { duration: 300, easing: tween.backOut }); }; self.processFreeze = function () { // Process immunity first, which ticks down every frame. if (self.freezeImmunityTimer > 0) { self.freezeImmunityTimer--; } if (self.freezeDuration <= 0) { return; } self.freezeDuration--; // Create occasional ice sparkle effects if (Math.random() < 0.1) { createIceSparkles(self.x, self.y); } // When freeze expires, break the ice if (self.freezeDuration <= 0) { if (self.slowDuration > 0) { self.speed = self.originalSpeed * (1 - self.slowAmount); } else { self.speed = self.originalSpeed; } self.freezeImmunityTimer = 120; // Apply 2-second immunity (120 ticks) if (self.iceCube) { // Ice breaking animation tween(self.iceCube, { scaleX: 1.5, scaleY: 1.5, alpha: 0 }, { duration: 200, easing: tween.quadOut, onFinish: function onFinish() { self.iceCube.visible = false; } }); // Create ice shatter particles createIceShatterEffect(self.x, self.y); } } }; self.processBurnDamage = function () { if (self.burnDuration <= 0) { // Ensure burn is completely cleared self.burnDamage = 0; self.burnTickTimer = 0; return; } self.burnTickTimer++; if (self.burnTickTimer >= self.burnTickInterval) { self.burnTickTimer = 0; self.burnDuration--; // Apply burn damage (10% of original hit damage) var actualBurnDamage = Math.ceil(self.burnDamage); if (gameMode === 'coop' && self.burnSourceIsPlayer !== null) { var damageAmount = Math.min(actualBurnDamage, self.health); if (self.burnSourceIsPlayer) { playerTotalDamage += damageAmount; } else { aiTotalDamage += damageAmount; } } self.health -= actualBurnDamage; self.updateHealthText(); // Create floating burn damage text createFloatingText('-' + actualBurnDamage, self.x + (Math.random() - 0.5) * 40, self.y - 30, 0xff4400, 30); // Burn particles createBurnEffect(self.x, self.y); if (self.health <= 0) { self.active = false; self.die(); return; } // Reduce burn damage over time (burn weakens) self.burnDamage *= 0.9; // Clear burn when duration expires - NO TINT MANAGEMENT if (self.burnDuration <= 0) { self.burnDamage = 0; self.burnTickTimer = 0; // Also reset tick timer } } }; self.applyPoison = function (damage, duration, sourceIsPlayer) { // Don't stack poison with itself, but can exist alongside burn if (self.poisonDuration > 0) { return; // Already poisoned, don't stack } self.poisonDamage = damage; self.poisonDuration = duration; self.poisonTickTimer = 0; self.poisonTickInterval = 60; // 1 second intervals self.poisonSourceIsPlayer = sourceIsPlayer; // Visual feedback createFloatingText('POISONED!', self.x, self.y - 40, 0x00ff00, 30); }; self.processPoisonDamage = function () { if (self.poisonDuration <= 0) { self.poisonDamage = 0; self.poisonTickTimer = 0; return; } self.poisonTickTimer++; if (self.poisonTickTimer >= self.poisonTickInterval) { self.poisonTickTimer = 0; self.poisonDuration--; // Apply poison damage var actualPoisonDamage = Math.ceil(self.poisonDamage); if (gameMode === 'coop' && self.poisonSourceIsPlayer !== null) { var damageAmount = Math.min(actualPoisonDamage, self.health); if (self.poisonSourceIsPlayer) { playerTotalDamage += damageAmount; } else { aiTotalDamage += damageAmount; } } self.health -= actualPoisonDamage; self.updateHealthText(); // Create floating poison damage text createFloatingText('-' + actualPoisonDamage, self.x + (Math.random() - 0.5) * 40, self.y - 30, 0x00ff00, 30); // Poison particles createPoisonEffect(self.x, self.y); if (self.health <= 0) { self.active = false; self.die(); return; } // Clear poison when duration expires if (self.poisonDuration <= 0) { self.poisonDamage = 0; self.poisonTickTimer = 0; } } }; self.applySlow = function (amount, duration) { // A new slow can be applied if it's stronger, or to refresh duration. // We won't let slow override freeze. if (self.freezeDuration > 0) { return; } if (self.slowDuration <= 0) { // Not currently slowed, so store the original speed self.originalSpeed = self.speed; // Apply visual effects if (chipGraphics) { chipGraphics.tint = 0xaaaaaa; } if (!self.slowEffectIcon) { self.slowEffectIcon = LK.getAsset('slowClubsMod', { anchorX: 0.5, anchorY: 0.5 }); self.slowEffectIcon.scale.set(0.7); self.addChild(self.slowEffectIcon); } self.slowEffectIcon.visible = true; } self.slowDuration = duration; self.slowAmount = amount; // Apply slow relative to the original speed before any slows were applied. self.speed = self.originalSpeed * (1 - self.slowAmount); }; self.processSlow = function () { if (self.slowDuration > 0) { self.slowDuration--; if (self.slowDuration <= 0) { self.slowAmount = 0; // Slow has expired. If not frozen, restore speed. if (self.freezeDuration <= 0) { self.speed = self.originalSpeed; } // Remove visual effects if (chipGraphics && self.damageFlashTimer <= 0) { chipGraphics.tint = 0xffffff; } if (self.slowEffectIcon) { self.slowEffectIcon.visible = false; } } } }; self.activate = function (value, isPlayerSide, startPos) { self.active = true; self.visible = true; self.value = value; self.isPlayerSide = isPlayerSide; // Snake boss segment properties self.isSnakeHead = false; self.isSnakeSegment = false; self.snakeParent = null; self.snakeChildren = []; self.snakeSpawnTimer = 0; self.snakeSpawnInterval = 60; // 3 seconds between segments // In PokerChip activate method, for snake boss: if (self.bossType === 'snake') { self.isSnakeHead = true; self.snakeChildren = []; self.snakeSpawnTimer = 0; self.snakeSpawnInterval = 60; // 3 seconds between segments } // Mark boss chips (they have much higher values than normal chips) self.isBoss = value >= 100; // Initialize boss properties self.bossType = null; self.bossAbilityTimer = 0; self.bossImmuneToSuit = null; self.bossImmuneTimer = 0; self.bossScrambleCount = 0; self.bossRainTimer = 0; self.bossLockedCard = null; self.bossLockGraphic = null; self.bossSpeedStartTime = 0; self.bossOriginalSpeed = 0; // Health calculations self.maxHealth = value * 50; var healthMultiplier = Math.pow(1.5, Math.floor((WaveSystem.waveNumber - 1) / 5)); self.maxHealth = self.maxHealth * healthMultiplier; if (self.isBoss) { self.maxHealth *= 0.7; if (typeof gameMode !== 'undefined' && gameMode === 'pvp') { self.maxHealth *= 1.2; } } self.health = self.maxHealth; self.pathProgress = 0; // Reset status effects self.burnDamage = 0; self.burnDuration = 0; self.burnTickTimer = 0; self.burnSourceIsPlayer = null; self.poisonDamage = 0; self.poisonDuration = 0; self.poisonTickTimer = 0; self.poisonSourceIsPlayer = null; self.slowDuration = 0; self.slowAmount = 0; self.freezeDuration = 0; self.originalSpeed = 0; if (self.iceCube) { self.iceCube.visible = false; } if (self.slowEffectIcon) { self.slowEffectIcon.visible = false; } self.freezeImmunityTimer = 0; // Set speed self.speed = 0.03; self.damageFlashTimer = 0; // Recreate healthText if (healthText && healthText.parent) { healthText.parent.removeChild(healthText); } healthText = new Text2('', { size: 80, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 8 }); healthText.anchor.set(0.5, 0.5); self.addChild(healthText); // NOW handle boss-specific setup BEFORE setChipAppearance if (self.isBoss && typeof gameMode !== 'undefined' && (gameMode === 'pvp' || gameMode === 'coop') && typeof BossSystem !== 'undefined' && BossSystem.currentBossType) { self.bossType = BossSystem.currentBossType.id; self.bossAbilityTimer = 0; self.bossSpeedStartTime = LK.ticks; self.bossOriginalSpeed = self.speed; console.log("Boss activated with type:", self.bossType, "Wave:", WaveSystem.waveNumber); // Apply boss abilities for both mini-bosses and main bosses // Speed boss starts slower if (self.bossType === 'speed') { self.speed = self.speed * 0.5; } // Immune boss starts with random suit immunity if (self.bossType === 'immune') { self.bossImmuneToSuit = null; // Will be set after spawn self.bossImmuneTimer = 0; self.immunityChanges = 0; var suits = ['hearts', 'diamonds', 'clubs', 'spades']; self.bossImmuneToSuit = suits[Math.floor(Math.random() * suits.length)]; self.bossImmuneTimer = 0; } // Lock boss locks a random card if (self.bossType === 'lock') { self.lockedCards = []; self.lockAttempts = 0; if (typeof self.lockRandomCard === 'function') { self.lockRandomCard(); } } } // Set appearance AFTER boss properties are set self.setChipAppearance(); self.x = startPos.x; self.y = startPos.y; }; self.updateHealthText = function () { // Remove the old text object if (healthText && healthText.parent) { healthText.parent.removeChild(healthText); } // Create a new text object with all styling properties healthText = new Text2(formatNumberWithSuffix(Math.max(0, self.health)), { size: 80, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 8 }); healthText.anchor.set(0.5, 0.5); self.addChild(healthText); }; self.setChipAppearance = function () { // Hide previous graphic and reset its scale to default if it exists if (chipGraphics) { chipGraphics.visible = false; chipGraphics.scale.set(1); } // Hide previous graphic and reset its scale to default if it exists if (chipGraphics) { chipGraphics.visible = false; chipGraphics.scale.set(1); } // In setChipAppearance method, modify the boss asset selection: if (self.isBoss && typeof gameMode !== 'undefined' && (gameMode === 'pvp' || gameMode === 'coop') && self.bossType) { console.log("Setting boss appearance for type:", self.bossType); // Find the boss type data to get the correct asset var bossTypeData = typeof BossSystem !== 'undefined' && BossSystem.bossTypes && BossSystem.bossTypes.find(function (type) { return type.id === self.bossType; }); if (bossTypeData) { // Create the boss chip graphic if it doesn't exist in our assets collection if (!chipGraphicsAssets[bossTypeData.chipAsset]) { chipGraphicsAssets[bossTypeData.chipAsset] = self.attachAsset(bossTypeData.chipAsset, { anchorX: 0.5, anchorY: 0.5 }); chipGraphicsAssets[bossTypeData.chipAsset].visible = false; } chipGraphics = chipGraphicsAssets[bossTypeData.chipAsset]; console.log("Using boss asset:", bossTypeData.chipAsset); } else { console.log("Boss type data not found, using fallback"); chipGraphics = chipGraphicsAssets[self.value] || chipGraphicsAssets[1]; } } else { // Regular chip logic chipGraphics = chipGraphicsAssets[self.value] || chipGraphicsAssets[1]; } if (chipGraphics) { chipGraphics.visible = true; // Apply boss scaling if (self.isBoss) { var bossScale = 1.25; // Apply segment size reduction if this is a snake segment if (self.isSnakeSegment && self.segmentSize) { bossScale *= self.segmentSize; } chipGraphics.scale.set(bossScale); } } self.updateHealthText(); }; self.takeDamage = function (damage, isPlayerSource, damageSuit) { // ADD VALIDATION if (typeof damage !== 'number' || isNaN(damage) || damage < 0) { console.warn("Invalid damage value:", damage); return; } if (typeof self.health !== 'number' || isNaN(self.health)) { console.warn("Invalid health value:", self.health); self.health = 1; // Emergency fix } // Check immunity for immune boss if (self.bossType === 'immune' && isPlayerSource !== undefined && self.bossImmuneToSuit && damageSuit) { if (damageSuit === self.bossImmuneToSuit) { createFloatingText('IMMUNE!', self.x, self.y - 30, 0xffff00, 40); return; // No damage taken } } if (damage > 0) { createFloatingText('-' + Math.round(damage), self.x + (Math.random() - 0.5) * 40, self.y - 60, 0xff0000, 50); } if (gameMode === 'coop' && isPlayerSource !== undefined) { var damageAmount = Math.min(damage, self.health); // ADD VALIDATION if (typeof damageAmount === 'number' && !isNaN(damageAmount) && damageAmount > 0) { if (isPlayerSource) { playerTotalDamage += damageAmount; } else { aiTotalDamage += damageAmount; } } } self.health -= damage; self.updateHealthText(); self.damageFlashTimer = 10; // Flash for 10 ticks instead of setTimeout if (self.health <= 0) { // IMMEDIATELY mark as inactive to prevent further hits self.active = false; // Call kill counter handler before die() removes chip handleChipKill(self.isPlayerSide); self.die(); } }; self.die = function () { // Sound effect removed - no longer play pokerChipDie sound var chipsEarned = Math.ceil(self.value * 1.5); // REDUCE CHIPS FOR SNAKE SEGMENTS if (self.isSnakeSegment) { chipsEarned = Math.ceil(chipsEarned * 0.2); // Give only 20% of normal chips } if (self.isPlayerSide) { var greedBonus = calculateGreedBonus(true, chipsEarned); var totalEarned = chipsEarned + greedBonus; gameState.playerChips += totalEarned; if (greedBonus > 0) { createFloatingText('+' + formatNumberWithSuffix(totalEarned) + ' (+' + formatNumberWithSuffix(greedBonus) + ' greed)', self.x, self.y - 30, 0xffd700, 35); } } else { var greedBonus = calculateGreedBonus(false, chipsEarned); gameState.aiChips += chipsEarned + greedBonus; } if (self.isSnakeHead) { console.log("Snake head dying, making segments independent..."); if (self.snakeChildren && self.snakeChildren.length) { for (var i = 0; i < self.snakeChildren.length; i++) { var segment = self.snakeChildren[i]; if (segment && segment.active) { // Keep as segment but remove following behavior // segment.isSnakeSegment stays true for reduced rewards segment.snakeFollowTarget = null; segment.snakeHead = null; segment.speed = 0.03; // Resume normal independent movement console.log("Segment", i, "is now independent but still a segment"); } } } self.snakeChildren = []; // Clear the array since segments are now independent } else if (self.isSnakeSegment && self.snakeHead && self.snakeHead.snakeChildren) { // Remove this segment from head's children array var index = self.snakeHead.snakeChildren.indexOf(self); if (index !== -1) { self.snakeHead.snakeChildren.splice(index, 1); } } if (self.bossType === 'lock') { self.unlockAllCards(); } PoolManager.returnChip(self); }; self.update = function () { if (!self.active) { return; } // Handle damage flash (keep this for regular damage) if (self.damageFlashTimer > 0) { self.damageFlashTimer--; if (chipGraphics) { if (self.damageFlashTimer > 0) { chipGraphics.tint = 0xff0000; } else { // Flash is over, restore correct tint if (self.slowDuration > 0) { chipGraphics.tint = 0xaaaaaa; } else { chipGraphics.tint = 0xffffff; } } } } // NEW: Process burn damage self.processBurnDamage(); // NEW: Process poison damage if (typeof self.processPoisonDamage === "function") { self.processPoisonDamage(); } // NEW: Process freeze effect self.processFreeze(); // NEW: Process slow effect self.processSlow(); // Boss ability update if (self.isBoss) { self.updateBossAbilities(); } if (!self.active) { return; } self.pathProgress += self.speed; var pathPos = PathSystem.getPositionAlongPath(self.pathProgress, self.isPlayerSide); var isDefeated = pathPos.completed; if (!isDefeated && gameMode === 'coop') { // In coop mode, enemies are also defeated if they pass the right edge of the background. var rightEdge = coopBackground.x + coopBackground.width / 2; if (pathPos.x > rightEdge) { isDefeated = true; } } if (isDefeated) { // Boss chips remove 2 hearts instead of 1 var heartsToRemove = self.isBoss ? 2 : 1; // Unlock cards if this is a lock boss that escaped if (self.bossType === 'lock') { self.unlockAllCards(); } if (gameMode === 'coop') { gameState.playerLives -= heartsToRemove; gameState.aiLives = gameState.playerLives; } else { if (self.isPlayerSide) { gameState.playerLives -= heartsToRemove; } else { gameState.aiLives -= heartsToRemove; } } LK.effects.flashScreen(0xff0000, 300); PoolManager.returnChip(self); return; } self.x = pathPos.x; self.y = pathPos.y; // --- SNAKE SEGMENT FOLLOWING LOGIC --- if (self.isSnakeSegment && self.snakeFollowTarget && self.snakeFollowTarget.active) { // Follow target much closer - only 3% behind on path var targetPathProgress = self.snakeFollowTarget.pathProgress - 3; // Tighter following with faster interpolation var currentDiff = self.pathProgress - targetPathProgress; if (Math.abs(currentDiff) > 0.2) { // More sensitive adjustment self.pathProgress += (targetPathProgress - self.pathProgress) * 0.4; // Faster following } // Update position based on path progress var pathPos = PathSystem.getPositionAlongPath(self.pathProgress, self.isPlayerSide); self.x = pathPos.x; self.y = pathPos.y; // Don't do normal speed-based movement for segments return; // Skip normal pathProgress += self.speed } }; // Boss ability: Lock a random card in the play area self.lockRandomCard = function () { var playArea = self.isPlayerSide ? gameState.playerPlayArea : gameState.aiPlayArea; var availableCards = []; for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (playArea[r][c] && !playArea[r][c].isLocked) { availableCards.push(playArea[r][c]); } } } if (availableCards.length > 0) { var cardToLock = availableCards[Math.floor(Math.random() * availableCards.length)]; cardToLock.isLocked = true; // Apply grey tint to the card cardToLock.tint = 0x666666; cardToLock.alpha = 0.7; // Create lock graphic using boss asset if (!cardToLock.lockGraphic) { cardToLock.lockGraphic = LK.getAsset('bossChipLock', { anchorX: 0.5, anchorY: 0.5 }); cardToLock.lockGraphic.scale.set(0.01); // Start very small cardToLock.lockGraphic.alpha = 0.9; cardToLock.addChild(cardToLock.lockGraphic); // Scale in animation tween(cardToLock.lockGraphic, { scaleX: 0.8, scaleY: 0.8 }, { duration: 400, easing: tween.backOut }); } // Track locked cards on the boss if (!self.lockedCards) { self.lockedCards = []; } self.lockedCards.push(cardToLock); createFloatingText('CARD LOCKED!', cardToLock.x, cardToLock.y - 50, 0xff0000, 50); } }; // Boss ability: Scramble all cards in the play area self.scrambleCards = function () { var playArea = self.isPlayerSide ? gameState.playerPlayArea : gameState.aiPlayArea; var cardsToScramble = []; for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (playArea[r][c]) { cardsToScramble.push(playArea[r][c]); } } } cardsToScramble.forEach(function (card) { var randomSuit = CardSystem.suits[Math.floor(Math.random() * CardSystem.suits.length)]; var randomValue = CardSystem.values[Math.floor(Math.random() * CardSystem.values.length)]; card.cardData.suit = randomSuit; card.cardData.value = randomValue; card.cardData.id = randomSuit + '_' + randomValue; // Visual effect createFloatingText('SCRAMBLED!', card.x, card.y, 0xff00ff, 40); // Re-render the card card.activate(card.x, card.y, card.isInPlay, card.isPlayerCard); }); if (cardsToScramble.length > 0) { applyHandBonuses(); // Recalculate poker hands } }; // Boss ability: Update boss-specific abilities each tick self.updateBossAbilities = function () { if (!self.bossType) { return; } self.bossAbilityTimer++; switch (self.bossType) { case 'lock': // Lock cards at 25%, 50%, and 75% progress var progress = self.pathProgress; if (!self.lockAttempts) { self.lockAttempts = 0; } if (progress >= 25 && self.lockAttempts === 0) { self.lockRandomCard(); self.lockAttempts++; } else if (progress >= 50 && self.lockAttempts === 1) { self.lockRandomCard(); self.lockAttempts++; } else if (progress >= 75 && self.lockAttempts === 2) { self.lockRandomCard(); self.lockAttempts++; } break; case 'scramble': var progress = self.pathProgress; if (progress >= 33 && self.bossScrambleCount === 0 || progress >= 66 && self.bossScrambleCount === 1) { self.scrambleCards(); self.bossScrambleCount++; } break; case 'snake': // Only initialize once per boss if (!self.hasInitializedSnake) { self.isSnakeHead = true; self.snakeChildren = []; self.snakeSpawnTimer = 0; self.maxSnakeSegments = 4; // Add explicit limit self.hasInitializedSnake = true; } // Only spawn if we're still active and under limit if (self.isSnakeHead && self.active && self.snakeChildren.length < self.maxSnakeSegments) { self.snakeSpawnTimer++; if (self.snakeSpawnTimer >= self.snakeSpawnInterval) { self.spawnSnakeSegment(); self.snakeSpawnTimer = 0; // Reset timer after spawning } } break; case 'immune': // Set initial immunity shortly after spawning if (self.bossAbilityTimer === 60) { // 1 second after spawn var suits = ['hearts', 'diamonds', 'clubs', 'spades']; self.bossImmuneToSuit = suits[Math.floor(Math.random() * suits.length)]; self.bossImmuneTimer = 0; createFloatingText('IMMUNE TO ' + self.bossImmuneToSuit.toUpperCase(), self.x, self.y - 50, 0xffff00, 40); } // Change immunity at intervals similar to lock boss (25%, 50%, 75% progress) var progress = self.pathProgress; if (!self.immunityChanges) { self.immunityChanges = 0; } if (progress >= 25 && self.immunityChanges === 0) { self.changeImmunity(); self.immunityChanges++; } else if (progress >= 50 && self.immunityChanges === 1) { self.changeImmunity(); self.immunityChanges++; } else if (progress >= 75 && self.immunityChanges === 2) { self.changeImmunity(); self.immunityChanges++; } break; case 'speed': var timeElapsed = LK.ticks - self.bossSpeedStartTime; var maxTime = 900; // Reduced from 1800 to 900 (15 seconds instead of 30) var speedProgress = Math.min(timeElapsed / maxTime, 1); // Exponential acceleration instead of linear var exponentialProgress = speedProgress * speedProgress; // Quadratic curve var speedMultiplier = 0.5 + exponentialProgress * 2.5; // 0.5x to 3.0x (increased max speed) self.speed = self.bossOriginalSpeed * speedMultiplier; break; } }; self.spawnSnakeSegment = function () { // Safety checks if (!self.isSnakeHead || !self.active || self.snakeChildren.length >= (self.maxSnakeSegments || 4)) { return; } var segment = PoolManager.getChip(); if (!segment) { return; } var segmentNumber = self.snakeChildren.length + 1; var sizeReduction = 0.9; var segmentSize = Math.pow(sizeReduction, segmentNumber); // Calculate health distribution with minimum health var totalSegments = segmentNumber + 1; var headHealthRatio = 0.4; var segmentHealthRatio = 0.6 / segmentNumber; var originalHeadHealth = self.maxHealth; var newHeadHealth = Math.max(50, Math.floor(originalHeadHealth * headHealthRatio)); var segmentHealth = Math.max(25, Math.floor(originalHeadHealth * segmentHealthRatio)); // Update head health (only on first segment spawn) if (segmentNumber === 1) { self.maxHealth = newHeadHealth; self.health = Math.min(self.health, newHeadHealth); self.updateHealthText(); } var followTarget = self.snakeChildren.length > 0 ? self.snakeChildren[self.snakeChildren.length - 1] : self; var segmentPathProgress = Math.max(0, followTarget.pathProgress - 3); var segmentPos = PathSystem.getPositionAlongPath(segmentPathProgress, self.isPlayerSide); // Set up segment properties directly (don't use activate() as it resets everything) segment.active = true; segment.visible = true; segment.value = self.value; segment.isPlayerSide = self.isPlayerSide; // CRITICAL FIX: Snake segments are NOT bosses segment.isBoss = false; // Don't make it a boss segment.bossType = null; // Remove boss type segment.isSnakeSegment = true; // Mark as segment segment.isSnakeHead = false; // Not a head segment.snakeHead = self; // Reference to head segment.snakeFollowTarget = followTarget; segment.x = segmentPos.x; segment.y = segmentPos.y; segment.pathProgress = segmentPathProgress; segment.segmentSize = segmentSize; segment.speed = self.speed; segment.damageFlashTimer = 0; // Set health segment.maxHealth = segmentHealth; segment.health = segmentHealth; // Reset status effects segment.burnDamage = 0; segment.burnDuration = 0; segment.burnTickTimer = 0; segment.burnSourceIsPlayer = null; segment.slowDuration = 0; segment.slowAmount = 0; segment.freezeDuration = 0; segment.originalSpeed = 0; if (segment.iceCube) { segment.iceCube.visible = false; } if (segment.slowEffectIcon) { segment.slowEffectIcon.visible = false; } segment.freezeImmunityTimer = 0; // Set appearance segment.setChipAppearance(); // Validate health if (segment.health <= 0) { console.error("Segment created with 0 health! Fixing..."); segment.health = 25; segment.maxHealth = 25; segment.updateHealthText(); } // Add to tracking arrays AFTER setting up all properties self.snakeChildren.push(segment); if (segment.isPlayerSide) { activePlayerChips.push(segment); activePlayerChipsContainer.addChild(segment); } else { activeAIChips.push(segment); activeAIChipsContainer.addChild(segment); } console.log("Snake segment created:", segmentNumber, "Health:", segment.health, "Active:", segment.active); }; // Add this function to the PokerChip class self.unlockAllCards = function () { if (self.lockedCards && self.lockedCards.length > 0) { for (var i = 0; i < self.lockedCards.length; i++) { var card = self.lockedCards[i]; if (card && card.isLocked) { card.isLocked = false; // Restore card appearance card.tint = 0xffffff; card.alpha = 1.0; // Remove lock graphic with animation if (card.lockGraphic) { (function (cardRef) { tween(cardRef.lockGraphic, { scaleX: 0.01, scaleY: 0.01, alpha: 0 }, { duration: 300, easing: tween.backIn, onFinish: function onFinish() { if (cardRef.lockGraphic && cardRef.lockGraphic.parent) { cardRef.lockGraphic.parent.removeChild(cardRef.lockGraphic); cardRef.lockGraphic = null; } } }); })(card); } createFloatingText('UNLOCKED!', card.x, card.y - 30, 0x00ff00, 40); } } self.lockedCards = []; } }; // Add this function to the PokerChip class self.changeImmunity = function () { var suits = ['hearts', 'diamonds', 'clubs', 'spades']; var oldSuit = self.bossImmuneToSuit; // Pick a different suit than the current one var availableSuits = suits.filter(function (suit) { return suit !== oldSuit; }); self.bossImmuneToSuit = availableSuits[Math.floor(Math.random() * availableSuits.length)]; self.bossImmuneTimer = 0; createFloatingText('NOW IMMUNE TO ' + self.bossImmuneToSuit.toUpperCase(), self.x, self.y - 50, 0xffff00, 40); }; return self; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x0f3d0f }); /**** * Game Code ****/ // Helper function to calculate distance from point to line segment /**** * Poker Tower Defense - Complete Refactor ****/ /**** * Game Constants ****/ function _typeof2(o) { "@babel/helpers - typeof"; return _typeof2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof2(o); } function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray2(r) || _nonIterableSpread(); } function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } function _unsupportedIterableToArray2(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray2(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0; } } function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) { return Array.from(r); } } function _arrayWithoutHoles(r) { if (Array.isArray(r)) { return _arrayLikeToArray2(r); } } function _arrayLikeToArray2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } function distancePointToLine(px, py, x1, y1, x2, y2) { var A = px - x1; var B = py - y1; var C = x2 - x1; var D = y2 - y1; var dot = A * C + B * D; var lenSq = C * C + D * D; if (lenSq === 0) { // Line segment is actually a point return Math.sqrt(A * A + B * B); } var param = dot / lenSq; var xx, yy; if (param < 0) { xx = x1; yy = y1; } else if (param > 1) { xx = x2; yy = y2; } else { xx = x1 + param * C; yy = y1 + param * D; } var dx = px - xx; var dy = py - yy; return Math.sqrt(dx * dx + dy * dy); } function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) { throw o; } } } }; } function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) { return _arrayLikeToArray(r, a); } var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } } function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; } var SCREEN_WIDTH = 2048; var SCREEN_HEIGHT = 2732; var PLAY_AREA_COLS = 5; var PLAY_AREA_ROWS = 2; var SLOT_WIDTH = 300; var SLOT_HEIGHT = 420; var DEAL_SLOT_WIDTH = 240; var DEAL_SLOT_HEIGHT = 330; // AI area positioning (top) var AI_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2; var AI_AREA_Y = 150; // Player area positioning (middle, with plenty of room below) var PLAYER_AREA_X = (SCREEN_WIDTH - PLAY_AREA_COLS * SLOT_WIDTH) / 2; var PLAYER_AREA_Y = SCREEN_HEIGHT - 1300; // Much higher up // Player deal area (hand slots) - below play area var PLAYER_DEAL_AREA_Y = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + 100; /**** * Card System ****/ var CardSystem = { suits: ['hearts', 'diamonds', 'clubs', 'spades'], values: ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'], suitColors: { 'hearts': 0xff0000, 'diamonds': 0xff0000, 'clubs': 0x000000, 'spades': 0x000000 }, createDeck: function createDeck() { var deck = []; var _iterator = _createForOfIteratorHelper(this.suits), _step; try { for (_iterator.s(); !(_step = _iterator.n()).done;) { var suit = _step.value; var _iterator2 = _createForOfIteratorHelper(this.values), _step2; try { for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) { var value = _step2.value; deck.push({ suit: suit, value: value, id: suit + '_' + value }); } } catch (err) { _iterator2.e(err); } finally { _iterator2.f(); } } // Add jokers } catch (err) { _iterator.e(err); } finally { _iterator.f(); } deck.push({ suit: 'joker', value: 'red', id: 'joker_red' }); deck.push({ suit: 'joker', value: 'black', id: 'joker_black' }); return this.shuffleDeck(deck); }, shuffleDeck: function shuffleDeck(deck) { for (var i = deck.length - 1; i > 0; i--) { var j = Math.floor(Math.random() * (i + 1)); var temp = deck[i]; deck[i] = deck[j]; deck[j] = temp; } return deck; }, getCardValue: function getCardValue(card) { if (card.cardData.suit === 'joker') { return 14; } // Jokers are highest if (card.cardData.value === 'A') { return 14; } // Aces high if (card.cardData.value === 'K') { return 13; } if (card.cardData.value === 'Q') { return 12; } if (card.cardData.value === 'J') { return 11; } return parseInt(card.cardData.value); }, evaluatePokerHand: function evaluatePokerHand(cards) { var _this = this; if (!cards || cards.length === 0) { return { type: 'none', strength: 0, multiplier: 1, contributingCards: [] }; } // Sort cards by value for easier analysis var sortedCards = cards.slice().sort(function (a, b) { return _this.getCardValue(b) - _this.getCardValue(a); }); var values = sortedCards.map(function (card) { return _this.getCardValue(card); }); var suits = sortedCards.map(function (card) { return card.cardData.suit; }); // Count values and suits var valueCounts = {}; var suitCounts = {}; values.forEach(function (value) { return valueCounts[value] = (valueCounts[value] || 0) + 1; }); suits.forEach(function (suit) { return suitCounts[suit] = (suitCounts[suit] || 0) + 1; }); var counts = Object.values(valueCounts).sort(function (a, b) { return b - a; }); // Only check for 5-card hands if we have 5 cards var isFlush = false; var isStraight = false; if (cards.length === 5) { isFlush = Object.keys(suitCounts).length === 1; isStraight = this.checkStraight(values); } // Royal Flush if (isFlush && isStraight && values[0] === 14 && values[4] === 10) { return { type: 'royal_flush', strength: 10, multiplier: 25, contributingCards: sortedCards }; } // Straight Flush if (isFlush && isStraight) { return { type: 'straight_flush', strength: 9, multiplier: 12, contributingCards: sortedCards }; } // Four of a Kind if (counts[0] >= 4) { var quadValue; for (var v in valueCounts) { if (valueCounts[v] >= 4) { quadValue = parseInt(v); break; } } return { type: 'four_of_a_kind', strength: 8, multiplier: 8, contributingCards: sortedCards.filter(function (c) { return _this.getCardValue(c) === quadValue; }) }; } // Full House if (counts[0] === 3 && counts[1] === 2) { return { type: 'full_house', strength: 7, multiplier: 5, contributingCards: sortedCards }; } // Flush if (isFlush) { return { type: 'flush', strength: 6, multiplier: 3.5, contributingCards: sortedCards }; } // Straight if (isStraight) { return { type: 'straight', strength: 5, multiplier: 2.5, contributingCards: sortedCards }; } // Three of a Kind if (counts[0] === 3) { var tripValue; for (var v in valueCounts) { if (valueCounts[v] === 3) { tripValue = parseInt(v); break; } } return { type: 'three_of_a_kind', strength: 4, multiplier: 2, contributingCards: sortedCards.filter(function (c) { return _this.getCardValue(c) === tripValue; }) }; } // Two Pair if (counts[0] === 2 && counts[1] === 2) { var pairValues = []; for (var v in valueCounts) { if (valueCounts[v] === 2) { pairValues.push(parseInt(v)); } } return { type: 'two_pair', strength: 3, multiplier: 1.5, contributingCards: sortedCards.filter(function (c) { return pairValues.indexOf(_this.getCardValue(c)) !== -1; }) }; } // One Pair if (counts[0] === 2) { var pairValue; for (var v in valueCounts) { if (valueCounts[v] === 2) { pairValue = parseInt(v); break; } } return { type: 'one_pair', strength: 2, multiplier: 1.2, contributingCards: sortedCards.filter(function (c) { return _this.getCardValue(c) === pairValue; }) }; } // High Card return { type: 'high_card', strength: 1, multiplier: 1, contributingCards: [sortedCards[0]] }; }, checkStraight: function checkStraight(values) { if (values.length !== 5) { return false; } // Check for ace-low straight (A, 2, 3, 4, 5) if (values[0] === 14 && values[1] === 5 && values[2] === 4 && values[3] === 3 && values[4] === 2) { return true; } // Check normal straight for (var i = 0; i < 4; i++) { if (values[i] - values[i + 1] !== 1) { return false; } } return true; } }; /**** * Object Pool Manager ****/ var PoolManager = { chipPool: [], bulletPool: [], cardPool: [], playerMinePool: [], aiMinePool: [], CHIP_POOL_SIZE: 50, BULLET_POOL_SIZE: 100, CARD_POOL_SIZE: 60, MINE_POOL_SIZE: 30, // 30 per side init: function init() { // Initialize pools for (var i = 0; i < this.CHIP_POOL_SIZE; i++) { var chip = new PokerChip(); chip.active = false; chip.visible = false; this.chipPool.push(chip); } for (var i = 0; i < this.BULLET_POOL_SIZE; i++) { var bullet = new Bullet(); bullet.active = false; bullet.visible = false; this.bulletPool.push(bullet); } for (var i = 0; i < this.MINE_POOL_SIZE; i++) { var playerMine = new Mine(); playerMine.active = false; playerMine.visible = false; this.playerMinePool.push(playerMine); var aiMine = new Mine(); aiMine.active = false; aiMine.visible = false; this.aiMinePool.push(aiMine); } }, getChip: function getChip() { for (var i = 0; i < this.chipPool.length; i++) { if (!this.chipPool[i].active) { return this.chipPool[i]; } } return null; }, getBullet: function getBullet() { for (var i = 0; i < this.bulletPool.length; i++) { if (!this.bulletPool[i].active) { return this.bulletPool[i]; } } return null; }, getMine: function getMine(isPlayerMine) { var pool = isPlayerMine ? this.playerMinePool : this.aiMinePool; for (var i = 0; i < pool.length; i++) { if (!pool[i].active) { return pool[i]; } } return null; }, returnChip: function returnChip(chip) { // Force-set inactive state chip.active = false; chip.visible = false; chip.health = 0; // Ensure health is 0 // Reset tint on all visual components of the chip. // This is to ensure that chip graphics don't retain the red damage flash tint // when being reused from the pool. if (chip.children) { for (var i = 0; i < chip.children.length; i++) { var child = chip.children[i]; if (child.tint !== undefined) { child.tint = 0xffffff; } } } // NEW: Clear burn status completely chip.burnDamage = 0; chip.burnDuration = 0; chip.burnTickTimer = 0; // Clear poison status completely chip.poisonDamage = 0; chip.poisonDuration = 0; chip.poisonTickTimer = 0; chip.poisonSourceIsPlayer = null; // Clear ownership flag var wasPlayerSide = chip.isPlayerSide; chip.isPlayerSide = null; // Remove from active arrays (check both arrays to be safe) var playerIndex = activePlayerChips.indexOf(chip); if (playerIndex !== -1) { activePlayerChips.splice(playerIndex, 1); } var aiIndex = activeAIChips.indexOf(chip); if (aiIndex !== -1) { activeAIChips.splice(aiIndex, 1); } // Remove from containers if (chip.parent) { chip.parent.removeChild(chip); } // Reset ALL boss and snake properties chip.isBoss = false; chip.bossType = null; chip.isSnakeHead = false; chip.isSnakeSegment = false; chip.snakeHead = null; chip.snakeChildren = []; chip.hasInitializedSnake = false; // Double-check removal from both containers if (activePlayerChipsContainer.children.indexOf(chip) !== -1) { activePlayerChipsContainer.removeChild(chip); } if (activeAIChipsContainer.children.indexOf(chip) !== -1) { activeAIChipsContainer.removeChild(chip); } }, returnBullet: function returnBullet(bullet) { var explosionColor = 0x333333; // Dark Grey for clubs/spades if (bullet.suit === 'hearts' || bullet.suit === 'diamonds') { explosionColor = 0xff0000; // Red for hearts/diamonds } createExplosion(bullet.x, bullet.y, explosionColor); bullet.active = false; bullet.visible = false; bullet.target = null; // Add this line to clear the target reference var index = activeBullets.indexOf(bullet); if (index !== -1) { activeBullets.splice(index, 1); } gameLayer.removeChild(bullet); }, returnMine: function returnMine(mine) { mine.active = false; mine.visible = false; var index = activeMines.indexOf(mine); if (index !== -1) { activeMines.splice(index, 1); } if (mine.parent) { mine.parent.removeChild(mine); } } }; /**** * Path System ****/ var PathSystem = { playerPath: [], aiPath: [], init: function init() { // Create player path - rectangular loop around the play area var padding = 130; // Distance from play area - increased by 50 pixels var verticalPadding = padding - 25 - 30; // Reduced by 25 + 30 to decrease side length by 110px total var leftX = PLAYER_AREA_X - padding + 10; var rightX = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding - 20 - 10; var topY = PLAYER_AREA_Y - verticalPadding; var bottomY = PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + verticalPadding; this.playerPath = [ // Start at bottom left { x: leftX, y: bottomY }, // Go up the left side { x: leftX, y: topY }, // Go across the top { x: rightX, y: topY }, // Go down the right side { x: rightX, y: bottomY }]; // Create AI path - UPSIDE DOWN mirror of player path var aiLeftX = AI_AREA_X - padding; var aiRightX = AI_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH + padding; var aiVerticalPadding = verticalPadding - 40 + 15; // Additional 40px reduction on each side for AI (80px total), extended by 15px var aiTopY = AI_AREA_Y - aiVerticalPadding; var aiBottomY = AI_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT + aiVerticalPadding; this.aiPath = [ // Start at TOP left (opposite of player) { x: aiLeftX, y: aiTopY }, // Go DOWN the left side (opposite of player) { x: aiLeftX, y: aiBottomY }, // Go across the BOTTOM (opposite of player) { x: aiRightX, y: aiBottomY }, // Go UP the right side (opposite of player) { x: aiRightX, y: aiTopY }]; if (gameMode === 'coop') { var centerX = SCREEN_WIDTH / 2; var centerY = SCREEN_HEIGHT / 2; var turningPointY = centerY - 200; // 200 pixels up from center var goalX = SCREEN_WIDTH + 200; this.playerPath = [{ x: leftX, y: bottomY }, { x: leftX, y: turningPointY }, { x: goalX, y: turningPointY }]; this.aiPath = [{ x: leftX, y: aiTopY }, { x: leftX, y: turningPointY }, { x: goalX, y: turningPointY }]; } }, // Alternative offset method that spreads chips along the path direction: getPathStart: function getPathStart(isPlayerSide) { var baseStart = isPlayerSide ? this.playerPath[0] : this.aiPath[0]; var pathDirection = isPlayerSide ? this.playerPath[1] : this.aiPath[1]; // Calculate direction vector from start to next point var dx = pathDirection.x - baseStart.x; var dy = pathDirection.y - baseStart.y; var length = Math.sqrt(dx * dx + dy * dy); // Normalize direction vector var normalizedX = dx / length; var normalizedY = dy / length; // Random offset along the path (backward from start point) var pathOffset = Math.random() * 80; // 0-80 pixels back along path var sideOffset = (Math.random() - 0.5) * 40; // -20 to +20 pixels to the side return { x: baseStart.x - normalizedX * pathOffset + normalizedY * sideOffset, y: baseStart.y - normalizedY * pathOffset - normalizedX * sideOffset }; }, getPositionAlongPath: function getPositionAlongPath(progress, isPlayerSide) { var path = isPlayerSide ? this.playerPath : this.aiPath; var pathLength = this.calculatePathLength(path); var targetDistance = progress / 100 * pathLength; if (targetDistance >= pathLength) { return { x: path[path.length - 1].x, y: path[path.length - 1].y, completed: true }; } var currentDistance = 0; for (var i = 0; i < path.length - 1; i++) { var segmentLength = this.getDistance(path[i], path[i + 1]); if (currentDistance + segmentLength >= targetDistance) { var segmentProgress = (targetDistance - currentDistance) / segmentLength; return { x: path[i].x + (path[i + 1].x - path[i].x) * segmentProgress, y: path[i].y + (path[i + 1].y - path[i].y) * segmentProgress, completed: false }; } currentDistance += segmentLength; } return { x: path[path.length - 1].x, y: path[path.length - 1].y, completed: true }; }, calculatePathLength: function calculatePathLength(path) { var total = 0; for (var i = 0; i < path.length - 1; i++) { total += this.getDistance(path[i], path[i + 1]); } return total; }, getDistance: function getDistance(p1, p2) { var dx = p2.x - p1.x; var dy = p2.y - p1.y; return Math.sqrt(dx * dx + dy * dy); } }; /**** * Chip Spawner ****/ var ChipSpawner = { spawnChip: function spawnChip(value, isPlayerSide) { var chip = PoolManager.getChip(); if (!chip) { return; } var activeChips = isPlayerSide ? activePlayerChips : activeAIChips; var minDistance = 85; // Half the chip diameter (170/2) to allow controlled overlap var minDistanceSq = minDistance * minDistance; var newPos; // If no other chips exist, we can place it anywhere. if (activeChips.length === 0) { newPos = PathSystem.getPathStart(isPlayerSide); } else { var maxAttempts = 25; // Try to find a free spot with random placement first. It's fast. var foundPosition = false; for (var attempt = 0; attempt < maxAttempts; attempt++) { var candidatePos = PathSystem.getPathStart(isPlayerSide); var isValid = true; for (var i = 0; i < activeChips.length; i++) { var otherChip = activeChips[i]; var dx = candidatePos.x - otherChip.x; var dy = candidatePos.y - otherChip.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < minDistanceSq) { isValid = false; break; } } if (isValid) { newPos = candidatePos; foundPosition = true; break; } } // If random placements failed, use a more deterministic spiral search. if (!foundPosition) { var baseStart = PathSystem.getPathStart(isPlayerSide); var searchRadius = minDistance; // Start searching just outside the minimum distance. var angleStep = Math.PI / 6; // Check 12 directions. var spiralAttempts = 30; for (var i = 0; i < spiralAttempts; i++) { for (var angle = 0; angle < Math.PI * 2; angle += angleStep) { var testX = baseStart.x + Math.cos(angle) * searchRadius; var testY = baseStart.y + Math.sin(angle) * searchRadius; var isCandidateValid = true; for (var j = 0; j < activeChips.length; j++) { var otherChip = activeChips[j]; var dx = testX - otherChip.x; var dy = testY - otherChip.y; var distanceSq = dx * dx + dy * dy; if (distanceSq < minDistanceSq) { isCandidateValid = false; break; } } if (isCandidateValid) { newPos = { x: testX, y: testY }; foundPosition = true; break; } } if (foundPosition) { break; } searchRadius += 20; // Spiral outwards. } } // Ultimate fallback if no position is found (should be very rare). if (!foundPosition) { newPos = PathSystem.getPathStart(isPlayerSide); } } chip.activate(value, isPlayerSide, newPos); // IMPORTANT: Add chip to active array BEFORE the container // This ensures that subsequent chips spawned in the same batch // will detect this chip when checking for overlaps if (isPlayerSide) { activePlayerChips.push(chip); activePlayerChipsContainer.addChildAt(chip, 0); } else { activeAIChips.push(chip); activeAIChipsContainer.addChildAt(chip, 0); } }, spawnChipAtPosition: function spawnChipAtPosition(value, isPlayerSide, position) { var chip = PoolManager.getChip(); if (!chip) { return; } chip.activate(value, isPlayerSide, position); // Add chip to active array and container if (isPlayerSide) { activePlayerChips.push(chip); activePlayerChipsContainer.addChildAt(chip, 0); } else { activeAIChips.push(chip); activeAIChipsContainer.addChildAt(chip, 0); } } }; /**** * Mod System ****/ var ModSystem = { equippedMods: { hearts: null, diamonds: null, clubs: null, spades: null }, aiEquippedMods: { hearts: null, diamonds: null, clubs: null, spades: null }, modData: { burnHeartMod: { suit: 'hearts', name: 'Flame', description: 'Hearts bullets apply burning damage over time. Burn damage is 10% of hit damage per tick for 4 seconds. Burn effects stack.' }, unityHeartsMod: { suit: 'hearts', name: 'Unity', description: 'Increases bullet damage by 25% for each adjacent Hearts card.' }, wildcardHeartMod: { suit: 'hearts', name: 'Wildcard', description: 'Hearts cards can merge with any suit or value of the same level, but deal 40% less damage.' }, chipsDiamondMod: { suit: 'diamonds', name: 'Greed', description: 'Earn bonus chips when enemies are defeated, based on diamonds on board. Bonus scales with card level.' }, gamblerDiamondsMod: { suit: 'diamonds', name: 'Gambler', description: 'Diamonds have a chance to deal double damage or none at all. The chance for double damage increases with card level.' }, boostDiamondsMod: { suit: 'diamonds', name: 'Boost', description: 'Diamonds boost the attack power of adjacent cards. The boost increases with the card\'s level.' }, // Add to ModSystem.modData: gambitDiamondMod: { suit: 'diamonds', name: 'Gambit', description: 'Odd cards (A,3,5,7,9,J,K) get +30% attack speed. Even cards (2,4,6,8,10,Q) get +40% attack power.' }, freezeSpadeMod: { suit: 'spades', name: 'Freeze', description: 'Spades have a chance to freeze enemies in place when dealing damage. Duration scales with card level.' }, sabotageSpadesMod: { suit: 'spades', name: 'Sabotage', description: 'When merged, reduces a random enemy card level by 1 (PvP) or boosts ally by 1 (Co-op).' }, spreadClubMod: { suit: 'clubs', name: 'Spreadshot', description: 'Clubs deal reduced damage but hit multiple enemies. Extra targets scale with card level.' }, slowClubsMod: { suit: 'clubs', name: 'Slow', description: 'Clubs bullets slow enemies on hit. Slow amount and duration scale with card level.' }, ricochetClubsMod: { suit: 'clubs', name: 'Ricochet', description: 'Clubs bullets ricochet amongst enemies, with limited bounces, dealing less damage with each one.' }, toxinClubMod: { suit: 'clubs', name: 'Toxin', description: 'Clubs bullets apply poison: 5% of hit damage per tick for 10 ticks. Does not stack with itself.' }, mineSpadesMod: { suit: 'spades', name: 'Mine', description: 'Spades cards place mines on the enemy path that explode on contact, dealing area damage.' }, deathSpadesMod: { suit: 'spades', name: 'Execute', description: 'When equipped spades bullets have a chance to execute low health targets immediately.' }, investmentHeartsMod: { suit: 'hearts', name: 'Investment', description: 'Hearts cards generate income while on board. Income increases the longer the card is on board and resets on level up.' } }, currentlyDisplayedMod: null, modDisplayContainer: null, topSuitGraphics: [], ownedMods: {}, // Store references to top suit graphics init: function init() { if (storage.equippedMods) { this.equippedMods = storage.equippedMods; } if (storage.ownedMods) { this.ownedMods = storage.ownedMods; } }, saveToStorage: function saveToStorage() { storage.equippedMods = this.equippedMods; storage.ownedMods = this.ownedMods; }, isModOwned: function isModOwned(modAssetId) { return !!this.ownedMods[modAssetId]; }, unlockMod: function unlockMod(modAssetId) { this.ownedMods[modAssetId] = true; this.saveToStorage(); }, getUnownedMods: function getUnownedMods() { var unowned = []; for (var modId in this.modData) { if (!this.isModOwned(modId)) { unowned.push(modId); } } return unowned; }, equipMod: function equipMod(modAssetId) { var modData = this.modData[modAssetId]; if (!modData) { return; } this.equippedMods[modData.suit] = modAssetId; this.saveToStorage(); this.updateTopSuitDisplay(); this.hideModDisplay(); }, updateTopSuitDisplay: function updateTopSuitDisplay() { var suitAssets = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit']; var suits = ['hearts', 'diamonds', 'clubs', 'spades']; for (var i = 0; i < this.topSuitGraphics.length; i++) { var container = this.topSuitGraphics[i]; if (container) { // Make it an Ace card if it's not already var hasAceText = false; for (var k = 0; k < container.children.length; k++) { if (container.children[k].isAceText) { hasAceText = true; break; } } if (!hasAceText) { var suitForAce = suits[i]; var suitColor = CardSystem.suitColors[suitForAce] || 0x000000; var valueText = new Text2('A', { size: 56 * 1.5, fill: suitColor, weight: 800, stroke: 0x000000, strokeThickness: 0 }); valueText.isAceText = true; valueText.anchor.set(0, 0); // The card background is scaled 1.5x, these coords are scaled to match. valueText.x = -95 * 1.5; valueText.y = -135 * 1.5; container.addChild(valueText); } // Remove the previous mod/suit icon if it exists for (var j = container.children.length - 1; j >= 0; j--) { if (container.children[j].isSuitIcon) { container.removeChildAt(j); break; } } // Add the appropriate icon (either mod or default suit) var suit = suits[i]; var equippedMod = this.equippedMods[suit]; var assetId = equippedMod || suitAssets[i]; var suitIcon = LK.getAsset(assetId, { anchorX: 0.5, anchorY: 0.5 }); suitIcon.isSuitIcon = true; suitIcon.scale.set(1.2); // Center it in the background card suitIcon.x = 0; suitIcon.y = 0; container.addChild(suitIcon); } } }, showModDisplay: function showModDisplay(modAssetId, sourceX, sourceY) { if (this.currentlyDisplayedMod) { return; } var modData = this.modData[modAssetId]; if (!modData) { return; } this.currentlyDisplayedMod = modAssetId; this.modDisplayContainer = new Container(); this.modDisplayContainer.interactive = true; uiLayer.addChild(this.modDisplayContainer); // Add a semi-transparent background to catch clicks outside the popup var bgBlocker = new Container(); bgBlocker.interactive = true; bgBlocker.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); this.modDisplayContainer.addChild(bgBlocker); var enlargedMod = LK.getAsset(modAssetId, { anchorX: 0.5, anchorY: 0.5 }); enlargedMod.x = SCREEN_WIDTH / 2; enlargedMod.y = SCREEN_HEIGHT / 2 - 450; enlargedMod.scale.set(1); this.modDisplayContainer.addChild(enlargedMod); var overlayWidth = 600; var overlayHeight = 400; var descriptionOverlay = new Container(); var overlayBg = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5 }); overlayBg.scale.set(overlayWidth / 150, overlayHeight / 240); overlayBg.tint = 0x000000; overlayBg.alpha = 0.8; descriptionOverlay.addChild(overlayBg); var descText = new Text2(modData.description, { size: 50, fill: 0xffffff, weight: 600, stroke: 0x000000, strokeThickness: 2, align: 'center', wordWrap: true, wordWrapWidth: overlayWidth - 40 }); descText.anchor.set(0.5, 0); descText.y = -overlayHeight / 2 + 40; descriptionOverlay.addChild(descText); var equipButton = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5, interactive: true }); equipButton.scale.set(1.5, 0.5); equipButton.tint = 0x000000; equipButton.alpha = 0.8; equipButton.y = overlayHeight / 2 + 150; descriptionOverlay.addChild(equipButton); var equipText = new Text2('Equip', { size: 50, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 3 }); equipText.anchor.set(0.5, 0.5); equipText.y = equipButton.y; descriptionOverlay.addChild(equipText); descriptionOverlay.x = SCREEN_WIDTH / 2; descriptionOverlay.y = SCREEN_HEIGHT / 2 + 250; descriptionOverlay.alpha = 0; this.modDisplayContainer.addChild(descriptionOverlay); var self = this; var isOwned = this.isModOwned(modAssetId); if (isOwned) { equipText.setText('Equip'); equipButton.down = function () { self.equipMod(modAssetId); }; } else { equipText.setText('Not Owned'); equipButton.interactive = false; equipButton.tint = 0x333333; enlargedMod.tint = 0x808080; } tween(enlargedMod, { scaleX: 4, scaleY: 4 }, { duration: 300, easing: tween.backOut }); tween(descriptionOverlay, { alpha: 1 }, { duration: 200, delay: 150 }); bgBlocker.down = function () { self.hideModDisplay(); }; }, hideModDisplay: function hideModDisplay() { if (!this.modDisplayContainer) { return; } var self = this; tween(this.modDisplayContainer, { alpha: 0 }, { duration: 200, onFinish: function onFinish() { if (self.modDisplayContainer && self.modDisplayContainer.parent) { self.modDisplayContainer.parent.removeChild(self.modDisplayContainer); } self.modDisplayContainer = null; self.currentlyDisplayedMod = null; } }); }, getEquippedModAsset: function getEquippedModAsset(suit, isPlayerCard) { if (isPlayerCard === undefined) { isPlayerCard = true; } var mods = isPlayerCard ? this.equippedMods : this.aiEquippedMods; return mods[suit] || null; } }; /**** * Wave Spawning System ****/ var WaveSystem = { playerSpawnTimer: 0, aiSpawnTimer: 0, waveNumber: 1, waveTimer: 0, waveDuration: 1800, // 30 seconds per wave (30 * 60 ticks) spawnInterval: 45, // Much faster: spawn every 0.75 seconds instead of 2 seconds bossSpawned: false, // Track if boss has been spawned this wave getChipValue: function getChipValue(waveNumber) { // Wave 1: Only 1-chips (easier) if (waveNumber === 1) { return 1; } // Wave 2-3: More 5s introduced earlier for increased difficulty else if (waveNumber <= 3) { return Math.random() < 0.2 ? 5 : 1; // 20% chance of 5-chip (increased from 10%) } // Wave 4-6: Even more 5s mixed in else if (waveNumber <= 6) { return Math.random() < 0.35 ? 5 : 1; // 35% chance of 5-chip (increased from 25%) } // Wave 7-9: More 5s than 1s for increased difficulty else if (waveNumber <= 9) { return Math.random() < 0.65 ? 5 : 1; // 65% chance of 5-chip (increased from 50%) } // Wave 11-15: Introduce 10-chips earlier and more frequently else if (waveNumber <= 15) { var rand = Math.random(); if (rand < 0.15) { return 10; } else if (rand < 0.7) { return 5; } else { return 1; } } // Wave 16-19: More variety with higher values else if (waveNumber <= 19) { var rand = Math.random(); if (rand < 0.3) { return 10; } else if (rand < 0.8) { return 5; } else { return 1; } } // Wave 21+: Keep scaling gradually with higher difficulty else if (!this.isBossWave(waveNumber)) { var rand = Math.random(); if (rand < 0.08) { return 25; } else if (rand < 0.4) { return 10; } else if (rand < 0.85) { return 5; } else { return 1; } } }, getBossChipValue: function getBossChipValue(waveNumber) { // Mini-boss waves (waves 5, 15, 25, etc.) if (waveNumber % 10 === 5) { var miniBossLevel = Math.floor(waveNumber / 10); var baseMiniBossValue = 100; // Purple chip value return baseMiniBossValue * Math.pow(2, miniBossLevel); } // Main boss waves (waves 10, 20, 30, etc.) var bossLevel = Math.floor(waveNumber / 10); // Base value derived from total health of wave 9 enemies var baseBossValue = 210; return baseBossValue * Math.pow(2, bossLevel - 1); }, isBossWave: function isBossWave(waveNumber) { // Both PvP and Coop now have mini-bosses every 5 waves and main bosses every 10 waves return waveNumber > 0 && (waveNumber % 10 === 0 || waveNumber % 10 === 5); }, spawnChip: function spawnChip(isPlayerSide) { if (this.isBossWave(this.waveNumber)) { // Boss wave: spawn ONE big enemy at the start, then nothing if (!this.bossSpawned) { var bossValue = this.getBossChipValue(this.waveNumber); ChipSpawner.spawnChip(bossValue, isPlayerSide); this.bossSpawned = true; console.log("BOSS spawned with value:", bossValue); } // Don't spawn anything else during boss wave return; } // Normal wave spawning - always single enemy var chipValue = this.getChipValue(this.waveNumber); ChipSpawner.spawnChip(chipValue, isPlayerSide); }, playerBossDefeated: false, aiBossDefeated: false, update: function update() { this.waveTimer++; // Check if wave is complete if (this.waveTimer >= this.waveDuration) { // If it's a boss wave, only advance if both bosses are defeated. if (this.isBossWave(this.waveNumber) && (!this.playerBossDefeated || !this.aiBossDefeated)) { // Don't end the wave, just let it continue until bosses are defeated. } else { // For normal waves, or for boss waves where both bosses are defeated. // Check if both bosses were defeated in a boss wave if (this.isBossWave(this.waveNumber) && this.playerBossDefeated && this.aiBossDefeated) { var bossType = this.waveNumber % 10 === 5 ? "MINI-BOSS" : "BOSS"; console.log("Both " + bossType + "es defeated! Moving to next round!"); createFloatingText('ROUND COMPLETE!', SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0x00ff00); // Reset boss defeat flags this.playerBossDefeated = false; this.aiBossDefeated = false; // Advance to next wave var nextWave = this.waveNumber + 1; this.waveTimer = 0; this.waveNumber = nextWave; this.playerSpawnTimer = 0; this.aiSpawnTimer = 0; this.bossSpawned = false; // Reset boss spawn flag // Check if the next wave is a boss wave and show roulette if needed if (this.isBossWave(this.waveNumber)) { // Pause the game before showing roulette gameReady = false; BossSystem.showBossRoulette(function () { // Resume the game after roulette gameReady = true; // Roulette complete, continue with normal wave logic console.log("Boss roulette completed for wave " + WaveSystem.waveNumber); }); } var waveType; if (this.isBossWave(this.waveNumber)) { waveType = this.waveNumber % 10 === 5 ? "MINI-BOSS WAVE" : "BOSS WAVE"; } else { waveType = "Wave"; } console.log(waveType + " " + this.waveNumber + " starting!"); return; } this.waveTimer = 0; this.waveNumber++; this.playerSpawnTimer = 0; this.aiSpawnTimer = 0; this.bossSpawned = false; // Reset boss spawn flag var waveType; if (this.isBossWave(this.waveNumber)) { waveType = this.waveNumber % 10 === 5 ? "MINI-BOSS WAVE" : "BOSS WAVE"; } else { waveType = "Wave"; } console.log(waveType + " " + this.waveNumber + " starting!"); return; } } // BOSS WAVE LOGIC - Spawn bosses immediately at start of wave if (this.isBossWave(this.waveNumber)) { if (!this.bossSpawned && this.waveTimer === 1) { var bossType = this.waveNumber % 10 === 5 ? "MINI-BOSS" : "BOSS"; console.log("=== " + bossType + " WAVE " + this.waveNumber + " STARTING ==="); // MODIFIED: Set the boss type from stored selection for BOTH mini-bosses and main bosses BossSystem.currentBossType = BossSystem.getBossTypeForWave(this.waveNumber); console.log("Setting boss type for wave " + this.waveNumber + ":", BossSystem.currentBossType); // Spawn bosses normally var playerBossValue = this.getBossChipValue(this.waveNumber); ChipSpawner.spawnChip(playerBossValue, true); if (gameMode === 'pvp' || gameMode === 'coop') { var aiBossValue = this.getBossChipValue(this.waveNumber); ChipSpawner.spawnChip(aiBossValue, false); } else { this.aiBossDefeated = true; } this.bossSpawned = true; return; } // MODIFIED: Boss defeat detection - show roulette for next wave if (this.bossSpawned && this.waveTimer > 120) { var bossType = this.waveNumber % 10 === 5 ? "MINI-BOSS" : "BOSS"; // Check if player side boss is defeated // Count only active chips (not falling rain chips) var activePlayerChipsCount = 0; for (var i = 0; i < activePlayerChips.length; i++) { if (activePlayerChips[i].active) { activePlayerChipsCount++; } } if (!this.playerBossDefeated && activePlayerChipsCount === 0) { this.playerBossDefeated = true; createFloatingText(bossType + ' DEFEATED!', SCREEN_WIDTH / 2, PLAYER_AREA_Y + SLOT_HEIGHT, 0xffd700); // Show roulette for the NEXT boss wave (when both bosses are defeated) if ((gameMode === 'pvp' || gameMode === 'coop') && this.aiBossDefeated) { // Both defeated, show roulette for next boss wave this.showRouletteForNextBoss && this.showRouletteForNextBoss(); } else if (gameMode !== 'pvp' && gameMode !== 'coop') { // In single player modes (not coop), show roulette immediately this.showRouletteForNextBoss && this.showRouletteForNextBoss(); } } // Check if AI side boss is defeated (PvP and Coop) if (gameMode === 'pvp' || gameMode === 'coop') { var activeAIChipsCount = 0; for (var i = 0; i < activeAIChips.length; i++) { if (activeAIChips[i].active) { activeAIChipsCount++; } } if (!this.aiBossDefeated && activeAIChipsCount === 0) { this.aiBossDefeated = true; createFloatingText('AI ' + bossType + ' DEFEATED!', SCREEN_WIDTH / 2, AI_AREA_Y + SLOT_HEIGHT, 0xffd700); // Show roulette for next boss wave if player boss is also defeated if (this.playerBossDefeated) { this.showRouletteForNextBoss && this.showRouletteForNextBoss(); } } } // If both bosses defeated, immediately end the wave if (this.playerBossDefeated && this.aiBossDefeated) { this.waveTimer = this.waveDuration - 1; } } return; // Don't do normal spawning during boss waves } // NORMAL WAVE LOGIC var currentSpawnInterval = this.spawnInterval; if (this.waveNumber === 1) { currentSpawnInterval = 75; // Slightly faster spawning for wave 1 (1.25 seconds) } else if (this.waveNumber >= 2) { currentSpawnInterval = Math.max(45, 60 - Math.floor((this.waveNumber - 2) * 15)); // Wave 2 is slower (60), then speeds up to normal (45) for wave 3+ } // Spawn on player side this.playerSpawnTimer++; if (this.playerSpawnTimer >= currentSpawnInterval) { this.playerSpawnTimer = 0; this.spawnChip(true); } // Spawn on AI side this.aiSpawnTimer++; if (this.aiSpawnTimer >= currentSpawnInterval) { this.aiSpawnTimer = 0; this.spawnChip(false); } } }; /**** * Game State ****/ var gameState = { playerChips: 200, aiChips: 200, playerLives: 3, aiLives: 3, isPlayerTurn: true, dealCost: 25, // Lowered from 38 to 25 // Starting cost dealCount: 0, // ... rest remains the same playerDeck: [], playerHand: [], playerPlayArea: [], aiDeck: [], aiPlayArea: [] }; // Game state management var currentGameState = 'start'; // 'start' or 'playing' var startScreenElements = []; var gameElements = []; /**** * Game Variables ****/ var activePlayerChips = []; var activeAIChips = []; var activeBullets = []; var activeMines = []; var playerTotalDamage = 0; var aiTotalDamage = 0; var playerHandNameTexts = []; var backgroundSuits = []; var slotIndicators = []; var selectedCard = null; var isDragging = false; var originalCardPosition = null; var gameReady = false; var activePlayerChipsContainer = new Container(); // Container for player chips var activeAIChipsContainer = new Container(); // Container for AI chips var playerLifeHearts = []; var aiLifeHearts = []; var opponentNameText = null; var playerNameText = null; var lastPlayerLives = 0; var lastAiLives = 0; var gameMode = 'pvp'; var gameLayer = new Container(); var floorBackground = LK.getAsset('floorbackround', { anchorX: 0.5, anchorY: 0.5 }); floorBackground.x = SCREEN_WIDTH / 2; floorBackground.y = SCREEN_HEIGHT / 2; gameLayer.addChild(floorBackground); var uiLayer = new Container(); game.addChild(gameLayer); game.addChild(uiLayer); /**** * UI Elements ****/ var playerChipsText = new Text2('Chips: 200', { size: 50, fill: 0xffd700, weight: 800, stroke: 0x000000, strokeThickness: 0 }); playerChipsText.x = 50; playerChipsText.y = SCREEN_HEIGHT - 120; playerChipsText.visible = false; uiLayer.addChild(playerChipsText); gameElements.push(playerChipsText); // Add AI stats too for clarity var waveText = new Text2('Wave: 1', { size: 40, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 0 }); waveText.x = SCREEN_WIDTH - 200; waveText.y = 50; waveText.visible = false; uiLayer.addChild(waveText); gameElements.push(waveText); var discardAreaContainer = new Container(); var dealButtonGraphic = discardAreaContainer.attachAsset('dealButton', { anchorX: 0.5, anchorY: 0.5 }); var refundButtonGraphic = discardAreaContainer.attachAsset('refundButton', { anchorX: 0.5, anchorY: 0.5 }); refundButtonGraphic.visible = false; var discardAreaGraphic = dealButtonGraphic; var discardText = new Text2('-25', { size: 50, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 0 }); discardText.anchor.set(0.5, 0.5); discardText.y = 110; discardAreaContainer.addChild(discardText); // Position it right of the hand var handWidthForDiscard = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartXForDiscard = (SCREEN_WIDTH - handWidthForDiscard) / 2; var discardX = handStartXForDiscard + handWidthForDiscard + 30 + DEAL_SLOT_WIDTH / 2; // Make sure it doesn't go off screen if (discardX + DEAL_SLOT_WIDTH / 2 > SCREEN_WIDTH) { discardX = SCREEN_WIDTH - DEAL_SLOT_WIDTH / 2 - 20; } discardAreaContainer.x = discardX + 10 + 10; discardAreaContainer.y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2 + 10 - 10; discardAreaContainer.visible = false; uiLayer.addChild(discardAreaContainer); gameElements.push(discardAreaContainer); discardAreaContainer.down = function () { if (!isDragging && gameState.playerChips >= gameState.dealCost) { // Scale down on press tween.stop(discardAreaContainer, { scaleX: true, scaleY: true }); tween(discardAreaContainer, { scaleX: 0.85, scaleY: 0.85 }, { duration: 150, easing: tween.quadOut }); } }; // Add this new up handler discardAreaContainer.up = function () { if (!isDragging && gameState.playerChips >= gameState.dealCost) { // Scale back up on release tween.stop(discardAreaContainer, { scaleX: true, scaleY: true }); tween(discardAreaContainer, { scaleX: 1.0, scaleY: 1.0 }, { duration: 150, easing: tween.elasticOut }); dealNewHand(); } }; /**** * Game Functions ****/ // --- Kill counter for extra enemy spawn (player kills only) --- var playerKillCounter = 0; function handleChipKill(isPlayerSide) { // Only count chip kills for extra enemy spawn in PvP mode if (gameMode !== 'pvp') { return; } // Only track player kills and spawn extra chips for the AI if (isPlayerSide) { playerKillCounter++; if (playerKillCounter >= 5) { playerKillCounter = 0; // Spawn extra enemy on AI side var chipValue = WaveSystem.getChipValue(WaveSystem.waveNumber); ChipSpawner.spawnChip(chipValue, false); } } } function dealInitialHand() { var cardsToDeal = 5; var dealDelay = 150; // ms var dealCard = function dealCard(i) { if (gameState.playerDeck.length === 0) { gameState.playerDeck = CardSystem.createDeck(); } var cardData = gameState.playerDeck.pop(); var startLevel = Math.floor((WaveSystem.waveNumber - 1) / 10) + 1; var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartX = (SCREEN_WIDTH - handWidth) / 2; var slotX = handStartX + i * DEAL_SLOT_WIDTH + i * 30 + DEAL_SLOT_WIDTH / 2; var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; var startX = slotX; var startY = SCREEN_HEIGHT + DEAL_SLOT_HEIGHT; // Mark slot as occupied immediately to prevent overwriting if deal is pressed too quickly gameState.playerHand[i] = true; var cardBack = LK.getAsset('cardBack', { anchorX: 0.5, anchorY: 0.5 }); cardBack.x = startX; cardBack.y = startY; uiLayer.addChild(cardBack); // Animate card flying into place and flipping tween(cardBack, { x: slotX, y: slotY }, { duration: 250, easing: tween.cubicOut, onFinish: function onFinish() { // Flip animation: shrink back tween(cardBack, { scaleX: 0.01 }, { duration: 150, easing: tween.quadIn, onFinish: function onFinish() { if (cardBack.parent) { cardBack.parent.removeChild(cardBack); } // Create and show the real card var card = new Card(cardData); card.setLevel(startLevel); card.activate(slotX, slotY, false, true); card.scale.x = 0.01; uiLayer.addChild(card); // Replace the placeholder with the actual card object gameState.playerHand[i] = card; // Flip animation: expand card face tween(card, { scaleX: 1.0 }, { duration: 150, easing: tween.quadOut, onFinish: function onFinish() { LK.getSound('cardLand').play(); } }); } }); } }); }; for (var i = 0; i < cardsToDeal; i++) { (function (index) { LK.setTimeout(function () { dealCard(index); }, index * dealDelay); })(i); } // Enable deal button after all animations are scheduled to finish var totalAnimationTime = (cardsToDeal - 1) * dealDelay + 250 + 150 + 200; // Added buffer LK.setTimeout(function () { if (discardAreaContainer) { discardAreaContainer.interactive = true; updateUI(); } }, totalAnimationTime); } function createBurnEffect(x, y) { var numParticles = 4; // Slightly more particles for (var i = 0; i < numParticles; i++) { var particle = LK.getAsset('burnHeartMod', { anchorX: 0.5, anchorY: 0.5 }); particle.x = x + (Math.random() - 0.5) * 80; // Wider spread particle.y = y + (Math.random() - 0.5) * 80; particle.scale.set(0.3 + Math.random() * 0.2); // Adjusted for new asset var angle = Math.random() * Math.PI * 2; var distance = Math.random() * 40 + 25; // Larger movement distance var duration = 400 + Math.random() * 500; // Slightly longer duration var targetX = x + Math.cos(angle) * distance; var targetY = y + Math.sin(angle) * distance - Math.random() * 50; // Float upward more gameLayer.addChild(particle); tween(particle, { x: targetX, y: targetY, alpha: 0, scaleX: 0.1, scaleY: 0.1 }, { duration: duration, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(particle) }); } } // Add new function for poison particles: function createPoisonEffect(x, y) { var numParticles = 3; for (var i = 0; i < numParticles; i++) { var particle = LK.getAsset('toxinClubMod', { anchorX: 0.5, anchorY: 0.5 }); particle.x = x + (Math.random() - 0.5) * 60; particle.y = y + (Math.random() - 0.5) * 60; particle.scale.set((0.2 + Math.random() * 0.1) * 2); particle.tint = 0x00ff00; // Green tint for poison var angle = Math.random() * Math.PI * 2; var distance = Math.random() * 30 + 20; var duration = 300 + Math.random() * 400; var targetX = x + Math.cos(angle) * distance; var targetY = y + Math.sin(angle) * distance - Math.random() * 40; gameLayer.addChild(particle); tween(particle, { x: targetX, y: targetY, alpha: 0, scaleX: 0.05, scaleY: 0.05 }, { duration: duration, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(particle) }); } } function createIceSparkles(x, y) { var numSparkles = 2; for (var i = 0; i < numSparkles; i++) { var sparkle = LK.getAsset('iceCube', { anchorX: 0.5, anchorY: 0.5 }); sparkle.x = x + (Math.random() - 0.5) * 60; sparkle.y = y + (Math.random() - 0.5) * 60; sparkle.scale.set(0.1 + Math.random() * 0.1); sparkle.alpha = 0.6; sparkle.tint = 0x88ddff; // Light blue tint gameLayer.addChild(sparkle); tween(sparkle, { y: sparkle.y - 20, alpha: 0, scaleX: 0.05, scaleY: 0.05 }, { duration: 800, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(sparkle) }); } } function createIceShatterEffect(x, y) { var numShards = 6; for (var i = 0; i < numShards; i++) { var shard = LK.getAsset('iceCube', { anchorX: 0.5, anchorY: 0.5 }); shard.x = x; shard.y = y; shard.scale.set(0.2 + Math.random() * 0.2); shard.tint = 0xaaeeff; // Ice blue tint var angle = Math.PI * 2 * i / numShards + (Math.random() - 0.5) * 0.5; var distance = 40 + Math.random() * 30; var targetX = x + Math.cos(angle) * distance; var targetY = y + Math.sin(angle) * distance; gameLayer.addChild(shard); tween(shard, { x: targetX, y: targetY, alpha: 0, rotation: Math.random() * Math.PI * 2, scaleX: 0.05, scaleY: 0.05 }, { duration: 600, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(shard) }); } } function createModFloatAnimation(target, shadow) { var initialY = target.y; var floatDistance = 10; var baseDuration = 3000; var randomDurationOffset = 1500; var initialScale = shadow.scale.x; var minScale = initialScale * 0.7; var maxScale = initialScale * 1.0; function floatUp() { if (!target.parent || !target.parent.parent || !target.parent.parent.parent) { return; } var duration = baseDuration / 2 + Math.random() * randomDurationOffset; tween(target, { y: initialY - floatDistance }, { duration: duration, easing: tween.easeInOut, onFinish: floatDown }); tween(shadow, { scaleX: minScale, scaleY: minScale }, { duration: duration, easing: tween.easeInOut }); } function floatDown() { if (!target.parent || !target.parent.parent || !target.parent.parent.parent) { return; } var duration = baseDuration / 2 + Math.random() * randomDurationOffset; tween(target, { y: initialY + floatDistance }, { duration: duration, easing: tween.easeInOut, onFinish: floatUp }); tween(shadow, { scaleX: maxScale, scaleY: maxScale }, { duration: duration, easing: tween.easeInOut }); } LK.setTimeout(floatDown, Math.random() * baseDuration); } // Add this new function to calculate greed bonus function calculateGreedBonus(isPlayerSide, baseChipsEarned) { // Only calculate bonus if greed mod is equipped if (ModSystem.getEquippedModAsset('diamonds', isPlayerSide) !== 'chipsDiamondMod') { return 0; } var playArea = isPlayerSide ? gameState.playerPlayArea : gameState.aiPlayArea; var totalBonusPercentage = 0; // Calculate bonus from each diamond card on the board for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = playArea[row][col]; if (card && card.cardData.suit === 'diamonds') { // The "base gain" for this card is 5% var baseGain = 0.05; // Each level adds an additional 10% gain var levelGain = card.level * 0.1; totalBonusPercentage += baseGain + levelGain * 0.6; } } } // Do not return fractional gains - round up return Math.ceil(baseChipsEarned * totalBonusPercentage); } function createStartScreen(fromMatch) { LK.playMusic('titleSong'); ModSystem.init(); // Clear any existing start screen elements startScreenElements.forEach(function (element) { if (element.parent) { element.parent.removeChild(element); } }); startScreenElements = []; var battleScreenContainer; // Add background animation var startScreenAnimContainer = new Container(); uiLayer.addChild(startScreenAnimContainer); startScreenElements.push(startScreenAnimContainer); var suitAssets = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit']; var spacing = 400; var numCols = Math.ceil(SCREEN_WIDTH / spacing) + 3; var numRows = Math.ceil(SCREEN_HEIGHT / spacing) + 3; var patternWidth = numCols * spacing; var patternHeight = numRows * spacing; backgroundSuits = []; for (var row = 0; row < numRows; row++) { for (var col = 0; col < numCols; col++) { var suitIndex = (row + col) % suitAssets.length; var suitId = suitAssets[suitIndex]; var suit = LK.getAsset(suitId, { anchorX: 0.5, anchorY: 0.5 }); suit.x = col * spacing - spacing; suit.y = row * spacing - spacing; suit.alpha = 0.8; suit.scale.set(1.5); suit.baseX = col * spacing; suit.baseY = row * spacing; startScreenAnimContainer.addChild(suit); backgroundSuits.push(suit); } } var gameLogo = LK.getAsset('titleLogo', { anchorX: 0.5, anchorY: 0.5 }); gameLogo.x = SCREEN_WIDTH / 2; gameLogo.y = SCREEN_HEIGHT / 2 - 200; uiLayer.addChild(gameLogo); startScreenElements.push(gameLogo); var bottomBarContainer = new Container(); uiLayer.addChild(bottomBarContainer); startScreenElements.push(bottomBarContainer); function showBattleSelection() { gameLogo.visible = false; bottomBarContainer.visible = true; battleScreenContainer = new Container(); uiLayer.addChild(battleScreenContainer); startScreenElements.push(battleScreenContainer); var pvpIcon = LK.getAsset('pvpIcon', { anchorX: 0.5, anchorY: 0.5, interactive: true }); pvpIcon.scale.set(3); pvpIcon.x = SCREEN_WIDTH * 0.25; pvpIcon.y = SCREEN_HEIGHT * 0.45; battleScreenContainer.addChild(pvpIcon); var pvpButton = LK.getAsset('pvpButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); pvpButton.scale.set(3); pvpButton.x = pvpIcon.x; pvpButton.y = pvpIcon.y + pvpIcon.height / 2 + pvpButton.height / 2 + 150; battleScreenContainer.addChild(pvpButton); var battleRatingText = new Text2('Battle rating: ' + storage.battleRating, { size: 70, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 4 }); battleRatingText.anchor.set(0.5, 0.5); var battleRatingIcon = LK.getAsset('battleRatingIcon', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.8, scaleY: 0.8 }); var totalWidth = battleRatingIcon.width + 10 + battleRatingText.width; var yPos = pvpIcon.y + pvpIcon.height / 2 + 350; battleRatingIcon.x = pvpIcon.x - totalWidth / 2 + battleRatingIcon.width / 2; battleRatingIcon.y = yPos; battleRatingText.x = battleRatingIcon.x + battleRatingIcon.width / 2 + 10 + battleRatingText.width / 2; battleRatingText.y = yPos; battleScreenContainer.addChild(battleRatingIcon); battleScreenContainer.addChild(battleRatingText); var coopIcon = LK.getAsset('coopIcon', { anchorX: 0.5, anchorY: 0.5, interactive: true }); coopIcon.scale.set(3); coopIcon.x = SCREEN_WIDTH * 0.75; coopIcon.y = pvpIcon.y; battleScreenContainer.addChild(coopIcon); var coopButton = LK.getAsset('coopButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); coopButton.scale.set(3); coopButton.x = coopIcon.x; coopButton.y = coopIcon.y + coopIcon.height / 2 + coopButton.height / 2 + 150; battleScreenContainer.addChild(coopButton); var coopHighestWaveText = new Text2('Highest wave: ' + (storage.coopHighestWave || 0), { size: 70, fill: 0xffffff, weight: 800, stroke: 0x000000, strokeThickness: 4 }); coopHighestWaveText.anchor.set(0.5, 0.5); coopHighestWaveText.x = coopIcon.x; coopHighestWaveText.y = coopIcon.y + coopIcon.height / 2 + 350; battleScreenContainer.addChild(coopHighestWaveText); // === DEBUG BUTTON REMOVED === function onPlay(isTutorial, mode) { startGame(isTutorial, mode); } if (!storage.tutorialCompleted && fromMatch !== true) { TutorialSystem.start(); var items = TutorialSystem.startScreenItems; items.mods.button.interactive = false; items.mods.icon.interactive = false; items.shop.button.interactive = false; items.shop.icon.interactive = false; items.mods.button.alpha = 0.5; items.mods.icon.alpha = 0.5; items.shop.button.alpha = 0.5; items.shop.icon.alpha = 0.5; var overlay = new Container(); overlay.interactive = true; overlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.7; overlay.addChild(bg); battleScreenContainer.addChild(overlay); battleScreenContainer.removeChild(pvpIcon); battleScreenContainer.removeChild(pvpButton); overlay.addChild(pvpIcon); overlay.addChild(pvpButton); coopIcon.interactive = false; coopIcon.alpha = 0.3; coopButton.interactive = false; coopButton.alpha = 0.3; TutorialSystem.pulseAnimation(pvpIcon); TutorialSystem.pulseAnimation(pvpButton); var welcomeText = new Text2("Welcome to Double Down Defense! Let’s jump right into a game, tap on PvP to start!", { size: 70, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 5, align: 'center', wordWrap: true, wordWrapWidth: SCREEN_WIDTH - 200 }); welcomeText.anchor.set(0.5, 0.5); welcomeText.x = SCREEN_WIDTH / 2; welcomeText.y = SCREEN_HEIGHT * 0.25; overlay.addChild(welcomeText); pvpIcon.down = function () { onPlay(true, 'pvp'); }; pvpButton.down = function () { onPlay(true, 'pvp'); }; } else { pvpIcon.down = function () { onPlay(false, 'pvp'); }; pvpButton.down = function () { onPlay(false, 'pvp'); }; coopIcon.down = function () { onPlay(false, 'coop'); }; coopButton.down = function () { onPlay(false, 'coop'); }; } } if (fromMatch) { showBattleSelection(); } else { // Animate logo scaling in gameLogo.scale.set(0.01); bottomBarContainer.visible = false; tween(gameLogo, { scaleX: 1, scaleY: 1 }, { duration: 1200, easing: tween.elasticOut, onFinish: function onFinish() { var tapToStartText = new Text2('Tap anywhere to start', { size: 90, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 6 }); tapToStartText.anchor.set(0.5, 0.5); tapToStartText.x = SCREEN_WIDTH / 2; tapToStartText.y = gameLogo.y + gameLogo.height / 2 + 250; uiLayer.addChild(tapToStartText); startScreenElements.push(tapToStartText); function flashAnimation() { if (!tapToStartText.parent) { return; } tween(tapToStartText, { alpha: 0.2 }, { duration: 1200, easing: tween.easeInOut, onFinish: function onFinish() { if (!tapToStartText.parent) { return; } tween(tapToStartText, { alpha: 1.0 }, { duration: 1200, easing: tween.easeInOut, onFinish: flashAnimation }); } }); } flashAnimation(); var screenTapArea = new Container(); screenTapArea.interactive = true; screenTapArea.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); uiLayer.addChild(screenTapArea); startScreenElements.push(screenTapArea); screenTapArea.down = function () { tween.stop(tapToStartText); uiLayer.removeChild(tapToStartText); uiLayer.removeChild(screenTapArea); showBattleSelection(); }; } }); } var startBottomBar = LK.getAsset('bottomBar', { anchorX: 0.5, anchorY: 1 }); startBottomBar.x = SCREEN_WIDTH / 2; startBottomBar.y = SCREEN_HEIGHT; bottomBarContainer.addChild(startBottomBar); var topBar = LK.getAsset('bottomBar', { anchorX: 0.5, anchorY: 0 }); topBar.x = SCREEN_WIDTH / 2; topBar.y = 65; topBar.scale.y = 0.4; bottomBarContainer.addChild(topBar); var moneyText = new Text2('$' + storage.money, { size: 105, fill: 0xffd700, weight: 800, stroke: 0x000000, strokeThickness: 4 }); moneyText.anchor.set(1, 0.5); moneyText.x = SCREEN_WIDTH - 150; moneyText.y = topBar.y + topBar.height * topBar.scale.y / 2; bottomBarContainer.addChild(moneyText); // --- Title screen selection highlight asset --- var titleScreenSelection = LK.getAsset('titleScreenSelection', { anchorX: 0.5, anchorY: 1 }); titleScreenSelection.alpha = 0.3; bottomBarContainer.addChild(titleScreenSelection); // --- Track current selection: "battle", "mods", or "shop" --- var currentTitleScreenSelection = "battle"; // --- Calculate button positions for highlight --- var playButton = LK.getAsset('playButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); playButton.x = SCREEN_WIDTH / 2; playButton.y = SCREEN_HEIGHT - 100; // Add battleIcon directly above playButton var battleIcon = LK.getAsset('battleIcon', { anchorX: 0.5, anchorY: 1, interactive: true }); battleIcon.x = playButton.x; battleIcon.y = playButton.y - playButton.height / 2 - 10; // 30px gap above playButton bottomBarContainer.addChild(battleIcon); bottomBarContainer.addChild(playButton); // --- Suit mod button and mods icon --- var suitModButton = LK.getAsset('suitModButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); suitModButton.x = playButton.x + playButton.width / 2 + 100 + suitModButton.width / 2; suitModButton.y = playButton.y; // Add modsIcon directly above suitModButton, same orientation as battleIcon var modsIcon = LK.getAsset('modsIcon', { anchorX: 0.5, anchorY: 1, interactive: true }); modsIcon.x = suitModButton.x; modsIcon.y = suitModButton.y - suitModButton.height / 2 - 10; // 10px gap above suitModButton bottomBarContainer.addChild(modsIcon); bottomBarContainer.addChild(suitModButton); // --- Shop button and icon --- var shopButton = LK.getAsset('shopButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); shopButton.x = playButton.x - playButton.width / 2 - 100 - shopButton.width / 2; shopButton.y = playButton.y + 10; var shopIcon = LK.getAsset('shopIcon', { anchorX: 0.5, anchorY: 1, interactive: true }); shopIcon.x = shopButton.x; shopIcon.y = shopButton.y - shopButton.height / 2 - 10; bottomBarContainer.addChild(shopIcon); bottomBarContainer.addChild(shopButton); // --- Mods container as before --- // Add modsContainer below the bottom bar and below equipped mods var modsContainer = new Container(); modsContainer.visible = false; // Insert modsContainer into uiLayer just before bottomBarContainer to ensure it's below the bottom bar and equipped mods var bottomBarContainerIndex = uiLayer.getChildIndex(bottomBarContainer); if (bottomBarContainerIndex > 0) { uiLayer.addChildAt(modsContainer, bottomBarContainerIndex); } else { uiLayer.addChild(modsContainer); } startScreenElements.push(modsContainer); // --- Shop Container --- var shopContainer = new Container(); shopContainer.visible = false; uiLayer.addChild(shopContainer); startScreenElements.push(shopContainer); var shopTitle = new Text2('Shop', { size: 150, fill: 0xffffff, weight: 'bold' }); shopTitle.anchor.set(0.5, 0.5); shopTitle.x = SCREEN_WIDTH / 2; shopTitle.y = 400; shopContainer.addChild(shopTitle); // Add black overlay behind the random mod shop item var shopOverlay = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5 }); var overlayWidth = 800; var overlayHeight = 1200; // 2:3 ratio shopOverlay.scale.set(overlayWidth / shopOverlay.width, overlayHeight / shopOverlay.height); shopOverlay.x = SCREEN_WIDTH / 2; shopOverlay.y = 1476 - 200; shopOverlay.tint = 0x000000; shopOverlay.alpha = 0.8; shopContainer.addChild(shopOverlay); // Add shopRandomMod asset in center var shopRandomModAsset = LK.getAsset('shopRandomMod', { anchorX: 0.5, anchorY: 0.5 }); shopRandomModAsset.x = SCREEN_WIDTH / 2; shopRandomModAsset.y = SCREEN_HEIGHT / 2 - 200; shopRandomModAsset.scale.set(0.8); shopContainer.addChild(shopRandomModAsset); // Add descriptive text underneath var shopDescText = new Text2('Buy a random card mod', { size: 60, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 3 }); shopDescText.anchor.set(0.5, 0.5); shopDescText.x = SCREEN_WIDTH / 2; shopDescText.y = shopRandomModAsset.y + shopRandomModAsset.height / 2 + 100; shopContainer.addChild(shopDescText); // Add price text var shopPriceText = new Text2('$' + storage.randomModPrice, { size: 80, fill: 0xffd700, weight: 'bold', stroke: 0x000000, strokeThickness: 4 }); shopPriceText.anchor.set(0.5, 0.5); shopPriceText.x = SCREEN_WIDTH / 2; shopPriceText.y = shopDescText.y + 80; shopContainer.addChild(shopPriceText); function buyRandomMod() { if (storage.money < storage.randomModPrice) { createFloatingText("Not enough money!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 100); return; } var unownedMods = ModSystem.getUnownedMods(); if (unownedMods.length === 0) { createFloatingText("All mods unlocked!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0x00ff00, 100); shopPriceText.setText('SOLD OUT'); shopOverlay.interactive = false; shopRandomModAsset.interactive = false; return; } storage.money -= storage.randomModPrice; moneyText.setText('$' + storage.money); shopOverlay.interactive = false; shopRandomModAsset.interactive = false; // Hide the static shop random mod asset and its text shopRandomModAsset.visible = false; shopDescText.visible = false; shopPriceText.visible = false; var slotContainer = new Container(); // Position it to replace the shopRandomModAsset slotContainer.x = shopRandomModAsset.x; slotContainer.y = shopRandomModAsset.y; shopContainer.addChild(slotContainer); var displayAsset = null; var spinDuration = 50; var spinsLeft = 20 + Math.floor(Math.random() * 15); // NEW LOGIC: Guarantee one of each suit before being fully random. // 1. Find which suits the player already owns at least one mod for. var ownedSuits = {}; for (var ownedModId in ModSystem.ownedMods) { if (ModSystem.ownedMods[ownedModId]) { // Check if the value is true var modData = ModSystem.modData[ownedModId]; if (modData) { ownedSuits[modData.suit] = true; } } } // 2. Identify suits for which the player owns no mods. var suitsWithNoMods = []; CardSystem.suits.forEach(function (suit) { if (!ownedSuits[suit]) { suitsWithNoMods.push(suit); } }); // 3. Create a pool of "priority" mods to choose from. var priorityUnownedMods = []; if (suitsWithNoMods.length > 0) { unownedMods.forEach(function (unownedModId) { var modData = ModSystem.modData[unownedModId]; if (modData && suitsWithNoMods.indexOf(modData.suit) !== -1) { priorityUnownedMods.push(unownedModId); } }); } var finalModId; // 4. Decide which pool to pick the final mod from. if (priorityUnownedMods.length > 0) { // The player is missing mods for some suits, so guarantee one from that pool. finalModId = priorityUnownedMods[Math.floor(Math.random() * priorityUnownedMods.length)]; } else { // The player either has at least one mod for every suit, or there are no unowned mods for the missing suits. // Fallback to picking any unowned mod. finalModId = unownedMods[Math.floor(Math.random() * unownedMods.length)]; } function spin() { spinsLeft--; if (displayAsset && displayAsset.parent) { displayAsset.parent.removeChild(displayAsset); } var modIdToShow = spinsLeft <= 0 ? finalModId : unownedMods[Math.floor(Math.random() * unownedMods.length)]; // Scale to fill the space of the shopRandomModAsset var sizingAsset = LK.getAsset('shopRandomMod', {}); var modAssetForSizing = LK.getAsset(modIdToShow, {}); // Match the visible height of the random mod asset, with a small margin var scaleToFit = sizingAsset.height * shopRandomModAsset.scale.y / modAssetForSizing.height * 0.9; displayAsset = LK.getAsset(modIdToShow, { anchorX: 0.5, anchorY: 0.5, scaleX: scaleToFit, scaleY: scaleToFit }); slotContainer.addChild(displayAsset); if (spinsLeft <= 0) { // REVEAL SEQUENCE ModSystem.unlockMod(finalModId); if (!TutorialSystem.isActive) { storage.randomModPrice = Math.floor(storage.randomModPrice * 1.5) + 50; } shopPriceText.setText('$' + storage.randomModPrice); // Create grey-out overlay var revealOverlay = new Container(); revealOverlay.interactive = true; revealOverlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); uiLayer.addChild(revealOverlay); var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.8; revealOverlay.addChild(bg); // Move the final mod asset to the reveal overlay var finalModAsset = displayAsset; finalModAsset.parent.removeChild(finalModAsset); revealOverlay.addChild(finalModAsset); finalModAsset.x = SCREEN_WIDTH / 2; finalModAsset.y = SCREEN_HEIGHT / 2; // The slot container is now empty, remove it. if (slotContainer.parent) { slotContainer.parent.removeChild(slotContainer); } // Grow larger animation tween(finalModAsset, { scaleX: finalModAsset.scale.x * 1.5, scaleY: finalModAsset.scale.y * 1.5 }, { duration: 500, easing: tween.elasticOut }); // "You received" message var modData = ModSystem.modData[finalModId]; var receivedText = new Text2("You received:\n" + modData.name, { size: 90, fill: 0xffd700, weight: 'bold', stroke: 0x000000, strokeThickness: 6, align: 'center' }); receivedText.anchor.set(0.5, 0.5); receivedText.x = SCREEN_WIDTH / 2; receivedText.y = finalModAsset.y + finalModAsset.height * finalModAsset.scale.y / 2 + 150; revealOverlay.addChild(receivedText); // Tap to continue message var tapToContinue = new Text2("Tap to continue", { size: 60, fill: 0xffffff, weight: 'bold' }); tapToContinue.anchor.set(0.5, 0.5); tapToContinue.x = SCREEN_WIDTH / 2; tapToContinue.y = SCREEN_HEIGHT - 200; revealOverlay.addChild(tapToContinue); // Set up tap to continue revealOverlay.down = function () { revealOverlay.interactive = false; // Prevent multiple taps // Fade out and remove reveal screen tween(revealOverlay, { alpha: 0 }, { duration: 300, onFinish: function onFinish() { if (revealOverlay.parent) { revealOverlay.parent.removeChild(revealOverlay); } // Show shop elements again shopRandomModAsset.visible = true; shopDescText.visible = true; shopPriceText.visible = true; // Re-enable shop interaction if there are mods left if (ModSystem.getUnownedMods().length > 0) { shopOverlay.interactive = true; shopRandomModAsset.interactive = true; } else { shopPriceText.setText('SOLD OUT'); } } }); }; } else { if (spinsLeft < 10) { spinDuration += 25; } if (spinsLeft < 5) { spinDuration += 40; } LK.setTimeout(spin, spinDuration); } } spin(); } shopOverlay.interactive = true; shopOverlay.down = buyRandomMod; shopRandomModAsset.interactive = true; shopRandomModAsset.down = buyRandomMod; // Add pulsing animation to shopRandomMod function createPulseAnimation() { if (!shopRandomModAsset.parent) { return; } tween(shopRandomModAsset, { scaleX: 0.9, scaleY: 0.9 }, { duration: 1000, easing: tween.easeInOut, onFinish: function onFinish() { if (!shopRandomModAsset.parent) { return; } tween(shopRandomModAsset, { scaleX: 0.8, scaleY: 0.8 }, { duration: 1000, easing: tween.easeInOut, onFinish: createPulseAnimation }); } }); } createPulseAnimation(); // --- Selection highlight logic --- // Helper to move the highlight to the correct button function updateTitleScreenSelectionHighlight() { var targetX, targetY, targetW, targetH; if (currentTitleScreenSelection === "battle") { targetX = playButton.x; targetY = playButton.y + playButton.height / 2; // anchorY:1, so bottom edge targetW = playButton.width * 1.1; targetH = playButton.height + battleIcon.height + 20; // Cover button, icon, and gap with padding } else if (currentTitleScreenSelection === "mods") { targetX = suitModButton.x; targetY = suitModButton.y + suitModButton.height / 2; targetW = suitModButton.width * 1.1; targetH = suitModButton.height + modsIcon.height + 20; // Cover button, icon, and gap with padding } else if (currentTitleScreenSelection === "shop") { targetX = shopButton.x; targetY = shopButton.y + shopButton.height / 2; targetW = shopButton.width * 1.2; targetH = shopButton.height + shopIcon.height + 20; } // Animate movement and scaling for smoothness tween.stop(titleScreenSelection); tween(titleScreenSelection, { x: targetX, y: targetY, width: targetW, height: targetH }, { duration: 180, easing: tween.cubicOut }); } // Set initial size and position for highlight (battle by default) titleScreenSelection.width = playButton.width * 1.2; titleScreenSelection.height = playButton.height + battleIcon.height + 20; titleScreenSelection.x = playButton.x; titleScreenSelection.y = playButton.y + playButton.height / 2; // --- Selection switching logic --- // Screens: "battle", "mods", "shop" playButton.down = function () { if (currentTitleScreenSelection !== "battle") { currentTitleScreenSelection = "battle"; updateTitleScreenSelectionHighlight(); } // Show battle screen, hide mods, shop and logo modsContainer.visible = false; shopContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = true; } gameLogo.visible = false; }; suitModButton.down = function () { if (currentTitleScreenSelection === "mods") { return; } if (currentTitleScreenSelection !== "mods") { currentTitleScreenSelection = "mods"; updateTitleScreenSelectionHighlight(); } // Show mods, hide others modsContainer.visible = true; shopContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = false; } gameLogo.visible = false; if (modsContainer.visible) { ModSystem.updateTopSuitDisplay(); // Refresh mod grid visuals var gridContainer = modsContainer.children[modsContainer.children.length - 1]; if (gridContainer && gridContainer.children.length > 0) { var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod']; var childrenPerMod = 4; // Assumes cell, shadow, mod asset, name text for (var modIndex = 0; modIndex < suitModAssets.length; modIndex++) { var assetId = suitModAssets[modIndex]; var isOwned = ModSystem.isModOwned(assetId); var cellIndex = modIndex * childrenPerMod; var modAssetIndex = cellIndex + 2; if (gridContainer.children[cellIndex] && gridContainer.children[modAssetIndex]) { var cell = gridContainer.children[cellIndex]; var modAsset = gridContainer.children[modAssetIndex]; if (isOwned) { modAsset.tint = 0xffffff; modAsset.alpha = 1.0; cell.tint = 0xffffff; } else { modAsset.tint = 0x555555; modAsset.alpha = 0.6; cell.tint = 0x888888; } } } } } }; shopButton.down = function () { if (currentTitleScreenSelection === "shop") { return; } if (currentTitleScreenSelection !== "shop") { currentTitleScreenSelection = "shop"; updateTitleScreenSelectionHighlight(); } // Show shop, hide others shopContainer.visible = true; modsContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = false; } gameLogo.visible = false; }; battleIcon.down = playButton.down; modsIcon.down = suitModButton.down; var originalPlayDown = playButton.down; var originalModsDown = suitModButton.down; var originalShopDown = shopButton.down; playButton.down = originalPlayDown; suitModButton.down = originalModsDown; shopButton.down = originalShopDown; battleIcon.down = playButton.down; modsIcon.down = suitModButton.down; shopIcon.down = shopButton.down; var shopItemsForTutorial = { overlay: shopOverlay, asset: shopRandomModAsset, buyButtonDown: buyRandomMod, priceText: shopPriceText }; // --- Slots Container --- var slotsContainer = new Container(); slotsContainer.visible = false; uiLayer.addChild(slotsContainer); startScreenElements.push(slotsContainer); // All possible combinations - we'll create these by stacking assets var suitAssets = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit']; // Add the new symbols to your value assets var valueAssets = ['slot10', 'slotJ', 'slotQ', 'slotK', 'slotA']; // Add joker as a special symbol (we'll handle it separately) var specialSymbols = ['jokerSuit']; // Your existing joker asset // Function to create a stacked card symbol (50% larger for slots) function createStackedSymbol(suit, value, x, y) { var symbolContainer = new Container(); symbolContainer.x = x; symbolContainer.y = y; // Add suit asset (background) var suitGraphic = LK.getAsset(suit, { anchorX: 0.5, anchorY: 0.5 }); suitGraphic.scale.set(0.8 * 1.4); // 50% larger symbolContainer.addChild(suitGraphic); // Add value asset (on top) var valueGraphic = LK.getAsset(value, { anchorX: 0.5, anchorY: 0.5 }); valueGraphic.scale.set(0.6 * 1.7); // 50% larger symbolContainer.addChild(valueGraphic); // Store the suit and value for later reference symbolContainer.cardSuit = suit; symbolContainer.cardValue = value; return symbolContainer; } // Create 5 slot reels with stacked symbols - NO MASKING var slotReels = []; var currentSymbols = []; // Only one symbol per reel visible var reelWidth = 120 * 2; // 50% larger var reelHeight = 300 * 2; // 50% larger var reelSpacing = 0; // Slightly more spacing for larger symbols var totalReelsWidth = 5 * reelWidth + 4 * reelSpacing; var startX = SCREEN_WIDTH / 2 - totalReelsWidth / 2; // All possible symbols including suits, numbers, and mod symbols var allSymbols = ['heartSuit', 'diamondSuit', 'clubSuit', 'spadeSuit', 'slot10', 'slotJ', 'slotQ', 'slotK', 'slotA']; // Add mod symbols to the pool var modSymbols = Object.keys(ModSystem.modData); allSymbols = allSymbols.concat(modSymbols); var reelCenters = []; // Add this array for (var i = 0; i < 5; i++) { // White background reel var reelBg = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5 }); reelBg.scale.set(reelWidth / reelBg.width, reelHeight / reelBg.height); reelBg.x = startX + reelWidth / 2 + i * (reelWidth + reelSpacing); reelBg.y = SCREEN_HEIGHT / 2 - 360; // Use the same y as slotMachine will be reelBg.tint = 0xffffff; slotsContainer.addChild(reelBg); // Store the center position for this reel reelCenters.push({ x: reelBg.x, y: reelBg.y }); // Create initial stacked symbol var randomSuit = suitAssets[Math.floor(Math.random() * suitAssets.length)]; var randomValue = valueAssets[Math.floor(Math.random() * valueAssets.length)]; var symbol = createStackedSymbol(randomSuit, randomValue, reelBg.x, reelBg.y); slotsContainer.addChild(symbol); slotReels.push(reelBg); currentSymbols.push(symbol); } // Slot machine graphic (move after reels so it appears above them) var slotMachine = LK.getAsset('slotMachine', { anchorX: 0.5, anchorY: 0.5 }); slotMachine.x = SCREEN_WIDTH / 2; slotMachine.y = SCREEN_HEIGHT / 2 - 50; slotsContainer.addChild(slotMachine); // Spin function with simple symbol replacement animation // Remove bet slider and handle, use only bet buttons for betting var currentBet = 10; var minBet = 10; var maxBet = Math.min(1000, storage.money || 100); var betText = new Text2('Bet: $' + currentBet, { size: 50, fill: 0xffffff, weight: 'bold' }); betText.anchor.set(0.5, 0.5); // Place betText in a visually similar location as before betText.x = SCREEN_WIDTH / 2 + 560; betText.y = SCREEN_HEIGHT / 2 + 570; // Only add preset bet buttons for betting var betPresets = [10, 25, 50, 100]; var betAssetIds = { 10: 'bet10', 25: 'bet25', 50: 'bet50', 100: 'bet100' }; var betButtons = []; // Layout: 10 and 25 to the left of spin, 50 and 100 to the right var betButtonSpacingX = 220; var betButtonSpacingY = 220; var spinButtonCenterX = SCREEN_WIDTH / 2; var spinButtonY = SCREEN_HEIGHT / 2 + 650; var leftBetStartX = spinButtonCenterX - betButtonSpacingX * 2.6; var rightBetStartX = spinButtonCenterX + betButtonSpacingX * 1.6; var betButtonY = spinButtonY; var leftBets = [10, 25]; var rightBets = [50, 100]; // Store references to bet and selected assets for toggling var betButtonAssets = {}; var betSelectedAssets = {}; // Place 10 and 25 to the left of spin button for (var i = 0; i < leftBets.length; i++) { (function (betAmount, idx) { var assetId = betAssetIds[betAmount]; var betBtn = LK.getAsset(assetId, { anchorX: 0.5, anchorY: 0.5, interactive: true }); betBtn.x = leftBetStartX + idx * betButtonSpacingX; betBtn.y = betButtonY; betBtn.scale.set(1.2); slotsContainer.addChild(betBtn); betButtonAssets[betAmount] = betBtn; // Create selected asset in same position, alpha 0 var selectedAssetId = assetId + "selected"; var betSelected = LK.getAsset(selectedAssetId, { anchorX: 0.5, anchorY: 0.5, scaleX: 1.2, scaleY: 1.2, x: betBtn.x, y: betBtn.y, alpha: 0 }); slotsContainer.addChild(betSelected); betSelectedAssets[betAmount] = betSelected; betBtn.down = function () { if (isSpinning) { return; } if (betAmount <= maxBet) { // Play slotButton sound LK.getSound('slotButton').play(); // Scale down the current visible button (Y-axis only) tween.stop(betBtn, { scaleY: true }); tween(betBtn, { scaleY: 1.02 // 1.2 * 0.85 }, { duration: 150, easing: tween.quadOut, onFinish: function onFinish() { // Now do the asset switch while scaled down currentBet = betAmount; betText.setText('Bet: $' + currentBet); // Show selected asset, hide original, hide others for (var b in betButtonAssets) { if (parseInt(b) === betAmount) { betButtonAssets[b].visible = false; betSelectedAssets[b].alpha = 1; betSelectedAssets[b].visible = true; // Make sure the selected asset starts at the same scaled down state betSelectedAssets[b].scaleY = 1.02; } else { betButtonAssets[b].visible = true; betSelectedAssets[b].alpha = 0; betSelectedAssets[b].visible = true; // Reset other buttons to normal scale betButtonAssets[b].scaleY = 1.2; betSelectedAssets[b].scaleY = 1.2; } } // Now scale the selected asset back up tween(betSelectedAssets[betAmount], { scaleY: 1.2 }, { duration: 150, easing: tween.elasticOut }); } }); } }; betButtons.push(betBtn); })(leftBets[i], i); } // Place 50 and 100 to the right of spin button for (var i = 0; i < rightBets.length; i++) { (function (betAmount, idx) { var assetId = betAssetIds[betAmount]; var betBtn = LK.getAsset(assetId, { anchorX: 0.5, anchorY: 0.5, interactive: true }); betBtn.x = rightBetStartX + idx * betButtonSpacingX; betBtn.y = betButtonY; betBtn.scale.set(1.2); slotsContainer.addChild(betBtn); betButtonAssets[betAmount] = betBtn; // Create selected asset in same position, alpha 0 var selectedAssetId = assetId + "selected"; var betSelected = LK.getAsset(selectedAssetId, { anchorX: 0.5, anchorY: 0.5, scaleX: 1.2, scaleY: 1.2, x: betBtn.x, y: betBtn.y, alpha: 0 }); slotsContainer.addChild(betSelected); betSelectedAssets[betAmount] = betSelected; betBtn.down = function () { if (isSpinning) { return; } if (betAmount <= maxBet) { // Play slotButton sound LK.getSound('slotButton').play(); // Scale down the current visible button (Y-axis only) tween.stop(betBtn, { scaleY: true }); tween(betBtn, { scaleY: 1 // 1.2 * 0.85 }, { duration: 50, easing: tween.quadOut, onFinish: function onFinish() { // Now do the asset switch while scaled down currentBet = betAmount; betText.setText('Bet: $' + currentBet); // Show selected asset, hide original, hide others for (var b in betButtonAssets) { if (parseInt(b) === betAmount) { betButtonAssets[b].visible = false; betSelectedAssets[b].alpha = 1; betSelectedAssets[b].visible = true; // Make sure the selected asset starts at the same scaled down state betSelectedAssets[b].scaleY = 1.02; } else { betButtonAssets[b].visible = true; betSelectedAssets[b].alpha = 0; betSelectedAssets[b].visible = true; // Reset other buttons to normal scale betButtonAssets[b].scaleY = 1.2; betSelectedAssets[b].scaleY = 1.2; } } // Now scale the selected asset back up tween(betSelectedAssets[betAmount], { scaleY: 1.2 }, { duration: 150, easing: tween.elasticOut }); } }); } }; betButtons.push(betBtn); })(rightBets[i], i); } // Set initial selected state for (var b in betButtonAssets) { if (parseInt(b) === currentBet) { betButtonAssets[b].visible = false; betSelectedAssets[b].alpha = 1; betSelectedAssets[b].visible = true; } else { betButtonAssets[b].visible = true; betSelectedAssets[b].alpha = 0; betSelectedAssets[b].visible = true; } } // Spin button var spinButton = LK.getAsset('spinButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); spinButton.x = SCREEN_WIDTH / 2; spinButton.y = SCREEN_HEIGHT / 2 + 650; slotsContainer.addChild(spinButton); // --- Glowing animation for spin button when not spinning --- var spinGlowTweenActive = false; function startSpinButtonGlow() { if (spinGlowTweenActive) { return; } spinGlowTweenActive = true; function glowIn() { if (!spinButton.parent || isSpinning) { spinGlowTweenActive = false; return; } tween(spinButton, { tint: 0x888888 }, { duration: 700, easing: tween.easeInOut, onFinish: glowOut }); } function glowOut() { if (!spinButton.parent || isSpinning) { spinGlowTweenActive = false; return; } tween(spinButton, { tint: 0xffffff }, { duration: 700, easing: tween.easeInOut, onFinish: glowIn }); } glowIn(); } function stopSpinButtonGlow() { spinGlowTweenActive = false; tween.stop(spinButton, { tint: true }); spinButton.tint = 0xffffff; } // Start glow initially if not spinning if (!isSpinning) { startSpinButtonGlow(); } // Paytable button var paytableButton = LK.getAsset('paytableButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); paytableButton.x = SCREEN_WIDTH / 2 - 535; paytableButton.y = SCREEN_HEIGHT / 2 + 425; slotsContainer.addChild(paytableButton); var isSpinning = false; // Defensive: Define createFloatingText if not already defined to prevent 'Script error.' if (typeof createFloatingText !== "function") { var _createFloatingText = function _createFloatingText(text, x, y, color, size) { // Fallback: log to console if UI not available if (typeof console !== "undefined" && typeof console.log === "function") { console.log("[FLOATING TEXT]", text, x, y, color, size); } }; } // Spin function - UPDATED WITH WEIGHTED MOD PROBABILITY function spinSlots() { if (isSpinning || storage.money < currentBet) { if (storage.money < currentBet) { createFloatingText("Not enough money!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 80); } return; } // Play slotSpin sound when the slots start spinning LK.getSound('slotSpin').play(); // Animate the current symbols off screen first for (var i = 0; i < currentSymbols.length; i++) { (function (index) { var symbol = currentSymbols[index]; if (symbol && symbol.parent) { tween(symbol, { y: symbol.y + 400 }, { duration: 200, easing: tween.quadIn, onFinish: function onFinish() { if (symbol.parent) { symbol.parent.removeChild(symbol); } } }); } })(i); } isSpinning = true; stopSpinButtonGlow(); storage.money -= currentBet; moneyText.setText('$' + storage.money); // NEW: Choose a target mod for this spin (if any unowned mods exist) var targetMod = null; var unownedMods = ModSystem.getUnownedMods(); if (unownedMods.length > 0) { targetMod = unownedMods[Math.floor(Math.random() * unownedMods.length)]; } // Choose final symbols for each reel - UPDATED WITH WEIGHTED LOGIC var finalSymbols = []; for (var i = 0; i < 5; i++) { var rand = Math.random(); if (rand < 0.008) { // 0.1% chance for Joker (super rare) finalSymbols.push({ isJoker: true }); } else if (targetMod && rand < 0.08) { // 20% chance for the target mod symbol (much higher than 0.5%) finalSymbols.push({ isMod: true, modId: targetMod }); } else if (rand < 0.005) { // 0.4% chance for any other random mod symbol if (unownedMods.length > 0) { var randomMod = unownedMods[Math.floor(Math.random() * unownedMods.length)]; finalSymbols.push({ isMod: true, modId: randomMod }); } else { // Fallback to regular card finalSymbols.push({ isMod: false, suit: suitAssets[Math.floor(Math.random() * suitAssets.length)], value: valueAssets[Math.floor(Math.random() * valueAssets.length)] }); } } else if (rand < 0.4) { // 39.5% chance for slotX (junk symbol) finalSymbols.push({ isJunk: true }); } else { // 60% chance for regular card (suit + value combination) finalSymbols.push({ isMod: false, suit: suitAssets[Math.floor(Math.random() * suitAssets.length)], value: valueAssets[Math.floor(Math.random() * valueAssets.length)] }); } } var finishedReels = 0; // Animate each reel by rapidly changing symbols // Animate each reel by rapidly changing symbols for (var i = 0; i < 5; i++) { (function (reelIndex) { var spinCount = 0; var maxSpins = 20 + reelIndex * 5; // Each reel spins longer (this creates the stop timing difference) var currentDelay = 100; // Start fast function updateReelSymbol() { var symbol = currentSymbols[reelIndex]; var reelCenter = reelCenters[reelIndex]; var newSuit, newValue; if (spinCount >= maxSpins) { // Final symbol - use predetermined final result var finalResult = finalSymbols[reelIndex]; var finalSymbol; if (finalResult.isJoker) { finalSymbol = LK.getAsset('jokerSuit', { anchorX: 0.5, anchorY: 0.5 }); finalSymbol.scale.set(0.8 * 1.5); finalSymbol.isJoker = true; } else if (finalResult.isJunk) { finalSymbol = LK.getAsset('slotX', { anchorX: 0.5, anchorY: 0.5 }); finalSymbol.scale.set(0.8 * 1.5); finalSymbol.isJunk = true; } else if (finalResult.isMod) { finalSymbol = LK.getAsset(finalResult.modId, { anchorX: 0.5, anchorY: 0.5 }); finalSymbol.scale.set(0.8 * 1.5); finalSymbol.isMod = true; finalSymbol.modId = finalResult.modId; } else { finalSymbol = createStackedSymbol(finalResult.suit, finalResult.value, 0, 0); } // Position final symbol at top of reel using stored center position finalSymbol.x = reelCenter.x; finalSymbol.y = reelCenter.y - 400; // Start above the reel // Insert before slot machine var slotMachineIndex = slotsContainer.getChildIndex(slotMachine); slotsContainer.addChildAt(finalSymbol, slotMachineIndex); // Tween to center position using stored center tween(finalSymbol, { y: reelCenter.y }, { duration: 300, easing: tween.quadOut, onFinish: function onFinish() { // Play reelStop sound when the symbol lands in the center LK.getSound('reelStop').play(); if (symbol.parent) { symbol.parent.removeChild(symbol); } currentSymbols[reelIndex] = finalSymbol; finishedReels++; if (finishedReels === 5) { checkWin(finalSymbols); isSpinning = false; startSpinButtonGlow(); } } }); return; } // Create random spinning symbol - UPDATED WITH WEIGHTED LOGIC var newSymbol; var spinRand = Math.random(); if (spinRand < 0.4) { newSymbol = LK.getAsset('slotX', { anchorX: 0.5, anchorY: 0.5 }); newSymbol.scale.set(0.8 * 1.5); newSymbol.isJunk = true; } else if (targetMod && spinRand < 0.5) { // 10% chance to show the target mod during spinning for excitement newSymbol = LK.getAsset(targetMod, { anchorX: 0.5, anchorY: 0.5 }); newSymbol.scale.set(0.8 * 1.5); newSymbol.isMod = true; newSymbol.modId = targetMod; } else if (spinRand < 0.52) { // 2% chance for any random mod during spinning if (unownedMods.length > 0) { var modSymbolId = unownedMods[Math.floor(Math.random() * unownedMods.length)]; newSymbol = LK.getAsset(modSymbolId, { anchorX: 0.5, anchorY: 0.5 }); newSymbol.scale.set(0.8 * 1.5); newSymbol.isMod = true; newSymbol.modId = modSymbolId; } else { newSuit = suitAssets[Math.floor(Math.random() * suitAssets.length)]; newValue = valueAssets[Math.floor(Math.random() * valueAssets.length)]; newSymbol = createStackedSymbol(newSuit, newValue, 0, 0); } } else { newSuit = suitAssets[Math.floor(Math.random() * suitAssets.length)]; newValue = valueAssets[Math.floor(Math.random() * valueAssets.length)]; newSymbol = createStackedSymbol(newSuit, newValue, 0, 0); } // Position new symbol at top of reel using stored center position newSymbol.x = reelCenter.x; newSymbol.y = reelCenter.y - 400; // Start above the reel // Insert before slot machine var slotMachineIndex = slotsContainer.getChildIndex(slotMachine); slotsContainer.addChildAt(newSymbol, slotMachineIndex); // Tween new symbol down past the bottom using stored center position tween(newSymbol, { y: reelCenter.y + 400 }, { duration: currentDelay, easing: tween.linear, onFinish: function onFinish() { if (newSymbol.parent) { newSymbol.parent.removeChild(newSymbol); } } }); spinCount++; if (spinCount <= maxSpins) { currentDelay = Math.min(300, 100 + spinCount * 8); LK.setTimeout(updateReelSymbol, currentDelay * 0.7); // Start next symbol before current one finishes } } // FIXED: Start all reels immediately instead of staggered LK.setTimeout(updateReelSymbol, 0); // All reels start spinning at the same time })(i); } } // Win checking function function checkWin(symbols) { // Check for 3 mod symbols first var modCount = {}; var cardSymbols = []; var jokerCount = 0; // Process all symbols, simply skip junk symbols for (var i = 0; i < currentSymbols.length; i++) { var symbol = currentSymbols[i]; if (symbol && symbol.isJoker) { jokerCount++; } else if (symbol && symbol.isJunk) { // Just ignore junk symbols - they don't contribute but don't block wins continue; } else if (symbol && symbol.isMod) { // Mod symbol (from spinning) modCount[symbol.modId] = (modCount[symbol.modId] || 0) + 1; } else if (typeof symbol === "string" && modSymbols.indexOf(symbol) !== -1) { // Defensive: string mod symbol (legacy) modCount[symbol] = (modCount[symbol] || 0) + 1; } else if (symbol && symbol.cardSuit && symbol.cardValue) { // Stacked card symbol var suit = symbol.cardSuit.replace('Suit', ''); // 'heartSuit' -> 'heart' var value = symbol.cardValue.replace('slot', ''); // 'slot10' -> '10' cardSymbols.push({ suit: suit + 's', value: value }); // Add 's' back: 'hearts' } else if (_typeof2(symbol) === "object" && symbol.suit && symbol.value) { // Already a card data object cardSymbols.push({ suit: symbol.suit, value: symbol.value }); } } // Check for mod wins (unchanged) for (var modSymbol in modCount) { if (modCount[modSymbol] >= 3) { ModSystem.unlockMod(modSymbol); createWinAnimation("MOD WON!", 0x00ff00); return; } } // Check for poker hand wins with whatever good symbols we have var totalGoodSymbols = cardSymbols.length + jokerCount; if (totalGoodSymbols >= 2) { // We have at least 2 good symbols (cards + jokers), try to evaluate var handEval = evaluateHandWithJokers(cardSymbols, jokerCount); var payout = calculateSlotsPayout(handEval, currentBet); if (payout > 0) { // Play slotWin sound effect when there's a win at the slots LK.getSound('slotWin').play(); storage.money += payout; moneyText.setText('$' + storage.money); createWinAnimation(handEval.type.replace(/_/g, ' ').toUpperCase() + '\n WIN $' + payout, 0xffd700); } } } function calculateSlotsPayout(handEval, bet) { var multipliers = { 'one_pair': 2, 'two_pair': 3, 'three_of_a_kind': 5, 'straight': 8, 'flush': 10, 'full_house': 15, 'four_of_a_kind': 25, 'straight_flush': 50, 'royal_flush': 100 }; return (multipliers[handEval.type] || 0) * bet; } function createWinAnimation(text, color) { // Use createFloatingText which has proper shadow handling var centerX = SCREEN_WIDTH / 2; var centerY = SCREEN_HEIGHT / 2 - 200; createFloatingText(text, centerX, centerY, color, 200); // Make the particle explosion much bigger and explode outwards in all directions from the floating win text var numParticles = 60; var minRadius = 180; var maxRadius = 600; for (var i = 0; i < numParticles; i++) { var particle = LK.getAsset('explosionParticle', { anchorX: 0.5, anchorY: 0.5 }); // Start at the win text center, with a small random offset for density particle.x = centerX + (Math.random() - 0.5) * 40; particle.y = centerY + (Math.random() - 0.5) * 40; particle.tint = color; particle.scale.set(1.2 + Math.random() * 0.7); // Calculate angle for even spread, but randomize a bit for natural look var angle = Math.PI * 2 * i / numParticles + (Math.random() - 0.5) * 0.25; var distance = minRadius + Math.random() * (maxRadius - minRadius); // Increase speed by increasing distance and reducing duration var speedMultiplier = 2.2; // Increase both distance and reduce duration for higher speed distance *= speedMultiplier; var targetX = centerX + Math.cos(angle) * distance; var targetY = centerY + Math.sin(angle) * distance; slotsContainer.addChild(particle); tween(particle, { x: targetX, y: targetY, alpha: 0, scaleX: 0.1, scaleY: 0.1, rotation: Math.random() * Math.PI * 2 }, { duration: (1800 + Math.random() * 600) / speedMultiplier, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(particle) }); } } spinButton.down = function () { if (!isSpinning && storage.money >= currentBet) { // Play slotButton sound LK.getSound('slotButton').play(); // Scale down on press (Y-axis only) tween.stop(spinButton, { scaleY: true }); tween(spinButton, { scaleY: 0.80 }, { duration: 50, easing: tween.quadOut }); } }; spinButton.up = function () { if (!isSpinning && storage.money >= currentBet) { // Scale back up on release (Y-axis only) tween.stop(spinButton, { scaleY: true }); tween(spinButton, { scaleY: 1.0 }, { duration: 150, easing: tween.elasticOut }); spinSlots(); } }; // Paytable popup paytableButton.down = function () { showPaytable(); }; function showPaytable() { var paytableOverlay = new Container(); paytableOverlay.interactive = true; paytableOverlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); uiLayer.addChild(paytableOverlay); var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.8; paytableOverlay.addChild(bg); var paytableCard = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5 }); paytableCard.scale.set(1600 / paytableCard.width, 2400 / paytableCard.height); paytableCard.x = SCREEN_WIDTH / 2; paytableCard.y = SCREEN_HEIGHT / 2; paytableCard.tint = 0x222222; paytableOverlay.addChild(paytableCard); var title = new Text2('PAYTABLE', { size: 160, fill: 0xffffff, weight: 'bold' }); title.anchor.set(0.5, 0.5); title.x = SCREEN_WIDTH / 2; title.y = SCREEN_HEIGHT / 2 - 800; paytableOverlay.addChild(title); var payouts = ['Royal Flush: 100x', 'Straight Flush: 50x', 'Four of a Kind: 25x', 'Full House: 15x', 'Flush: 10x', 'Straight: 8x', 'Three of a Kind: 5x', 'Two Pair: 3x', 'One Pair: 2x', '', '3 Mod Symbols: Free Mod!']; var yStart = SCREEN_HEIGHT / 2 - 600; payouts.forEach(function (payout, index) { if (payout) { var payoutText = new Text2(payout, { size: 100, fill: index === payouts.length - 1 ? 0x00ff00 : 0xffffff, weight: 'bold' }); payoutText.anchor.set(0.5, 0.5); payoutText.x = SCREEN_WIDTH / 2; payoutText.y = yStart + index * 120; paytableOverlay.addChild(payoutText); } }); var closeText = new Text2('Tap to close', { size: 120, fill: 0xcccccc, weight: 'bold' }); closeText.anchor.set(0.5, 0.5); closeText.x = SCREEN_WIDTH / 2; closeText.y = SCREEN_HEIGHT / 2 + 900; paytableOverlay.addChild(closeText); paytableOverlay.down = function () { if (paytableOverlay.parent) { paytableOverlay.parent.removeChild(paytableOverlay); } }; } // Add slots button to bottom bar (modify the existing button setup) var slotsButton = LK.getAsset('slotsButton', { anchorX: 0.5, anchorY: 0.5, interactive: true }); slotsButton.x = shopButton.x - (shopButton.width + 120); // Position to the left of shop slotsButton.y = shopButton.y - 10; bottomBarContainer.addChild(slotsButton); var slotsIcon = LK.getAsset('slotsIcon', { anchorX: 0.5, anchorY: 1, interactive: true }); slotsIcon.x = slotsButton.x; slotsIcon.y = slotsButton.y - slotsButton.height / 2 - 15; bottomBarContainer.addChild(slotsIcon); // Update selection highlighting to include slots var originalUpdateHighlight = updateTitleScreenSelectionHighlight; updateTitleScreenSelectionHighlight = function updateTitleScreenSelectionHighlight() { var targetX, targetY, targetW, targetH; if (currentTitleScreenSelection === "battle") { targetX = playButton.x; targetY = playButton.y + playButton.height / 2; targetW = playButton.width * 1.1; targetH = playButton.height + battleIcon.height + 20; } else if (currentTitleScreenSelection === "mods") { targetX = suitModButton.x; targetY = suitModButton.y + suitModButton.height / 2; targetW = suitModButton.width * 1.1; targetH = suitModButton.height + modsIcon.height + 20; } else if (currentTitleScreenSelection === "shop") { targetX = shopButton.x; targetY = shopButton.y + shopButton.height / 2; targetW = shopButton.width * 1.2; targetH = shopButton.height + shopIcon.height + 20; } else if (currentTitleScreenSelection === "slots") { targetX = slotsButton.x; targetY = slotsButton.y + slotsButton.height / 2; targetW = slotsButton.width * 1.2; targetH = slotsButton.height + slotsIcon.height + 20; } tween.stop(titleScreenSelection); tween(titleScreenSelection, { x: targetX, y: targetY, width: targetW, height: targetH }, { duration: 180, easing: tween.cubicOut }); }; // Add slots button click handlers // --- Navigation handlers for slots and other screens with spin lockout --- slotsButton.down = function () { // Prevent navigation to slots if already spinning (shouldn't happen, but defensive) if (isSpinning) { createFloatingText("Wait for the spin to finish!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 80); return; } if (currentTitleScreenSelection !== "slots") { currentTitleScreenSelection = "slots"; updateTitleScreenSelectionHighlight(); } // Show slots, hide others slotsContainer.visible = true; modsContainer.visible = false; shopContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = false; } gameLogo.visible = false; // Update max bet based on current money maxBet = Math.min(1000, storage.money || 100); currentBet = Math.min(currentBet, maxBet); betText.setText('Bet: $' + currentBet); // Update bet button/selected asset visibility if (typeof betButtonAssets !== "undefined" && typeof betSelectedAssets !== "undefined") { for (var b in betButtonAssets) { if (parseInt(b) === currentBet) { betButtonAssets[b].visible = false; betSelectedAssets[b].alpha = 1; betSelectedAssets[b].visible = true; } else { betButtonAssets[b].visible = true; betSelectedAssets[b].alpha = 0; betSelectedAssets[b].visible = true; } } } }; // Helper to block navigation away from slots while spinning function blockNavigationIfSpinning() { if (isSpinning) { createFloatingText("Wait for the spin to finish!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 80); return true; } return false; } // Hide slots screen when navigating away using the bottom bar playButton.down = function () { if (blockNavigationIfSpinning()) { return; } if (currentTitleScreenSelection !== "battle") { currentTitleScreenSelection = "battle"; updateTitleScreenSelectionHighlight(); } // Show battle screen, hide mods, shop, slots and logo modsContainer.visible = false; shopContainer.visible = false; slotsContainer.visible = false; // Restore bet button visibility when leaving slots if (typeof betButtonAssets !== "undefined" && typeof betSelectedAssets !== "undefined") { for (var b in betButtonAssets) { betButtonAssets[b].visible = true; betSelectedAssets[b].alpha = 0; betSelectedAssets[b].visible = true; } } if (battleScreenContainer) { battleScreenContainer.visible = true; } gameLogo.visible = false; }; suitModButton.down = function () { if (blockNavigationIfSpinning()) { return; } if (currentTitleScreenSelection === "mods") { return; } if (currentTitleScreenSelection !== "mods") { currentTitleScreenSelection = "mods"; updateTitleScreenSelectionHighlight(); } // Show mods, hide others modsContainer.visible = true; shopContainer.visible = false; slotsContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = false; } gameLogo.visible = false; if (modsContainer.visible) { ModSystem.updateTopSuitDisplay(); // Refresh mod grid visuals var gridContainer = modsContainer.children[modsContainer.children.length - 1]; if (gridContainer && gridContainer.children.length > 0) { var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod']; var childrenPerMod = 4; // Assumes cell, shadow, mod asset, name text for (var modIndex = 0; modIndex < suitModAssets.length; modIndex++) { var assetId = suitModAssets[modIndex]; var isOwned = ModSystem.isModOwned(assetId); var cellIndex = modIndex * childrenPerMod; var modAssetIndex = cellIndex + 2; if (gridContainer.children[cellIndex] && gridContainer.children[modAssetIndex]) { var cell = gridContainer.children[cellIndex]; var modAsset = gridContainer.children[modAssetIndex]; if (isOwned) { modAsset.tint = 0xffffff; modAsset.alpha = 1.0; cell.tint = 0xffffff; } else { modAsset.tint = 0x555555; modAsset.alpha = 0.6; cell.tint = 0x888888; } } } } } }; shopButton.down = function () { if (blockNavigationIfSpinning()) { return; } if (currentTitleScreenSelection === "shop") { return; } if (currentTitleScreenSelection !== "shop") { currentTitleScreenSelection = "shop"; updateTitleScreenSelectionHighlight(); } // Show shop, hide others shopContainer.visible = true; modsContainer.visible = false; slotsContainer.visible = false; if (battleScreenContainer) { battleScreenContainer.visible = false; } gameLogo.visible = false; }; battleIcon.down = playButton.down; modsIcon.down = suitModButton.down; shopIcon.down = shopButton.down; slotsIcon.down = slotsButton.down; // No slider drag logic needed for click-based slider; just call original handlers if they exist var originalGameMove = game.move; game.move = function (x, y, obj) { if (typeof originalGameMove === "function") { originalGameMove.call(this, x, y, obj); } }; var originalGameUp = game.up; game.up = function (x, y, obj) { if (typeof originalGameUp === "function") { originalGameUp.call(this, x, y, obj); } }; // Register slots screen with tutorial system TutorialSystem.registerStartScreenElements({ battle: { button: playButton, icon: battleIcon, down: originalPlayDown }, mods: { button: suitModButton, icon: modsIcon, down: originalModsDown }, shop: { button: shopButton, icon: shopIcon, down: originalShopDown }, slots: { button: slotsButton, icon: slotsIcon, down: slotsButton.down }, modsContainer: modsContainer, shopContainer: shopContainer, slotsContainer: slotsContainer, shopItems: shopItemsForTutorial }); if (TutorialSystem.isActive && fromMatch) { // A small delay to ensure the start screen elements are fully rendered LK.setTimeout(function () { TutorialSystem.advanceStep(); }, 200); } var numCircles = suitAssets.length; var totalBarWidth = SCREEN_WIDTH - 200; var suitSpacing = totalBarWidth / numCircles; var startX = SCREEN_WIDTH / 2 - totalBarWidth / 2 + suitSpacing / 2; var yOffset = SCREEN_HEIGHT * 0.1; var circleY = 300 + yOffset; ModSystem.topSuitGraphics = []; // Reset the array for (var i = 0; i < numCircles; i++) { var circleX = startX + i * suitSpacing; var suitContainer = new Container(); var circleBg = LK.getAsset('card', { anchorX: 0.5, anchorY: 0.5 }); circleBg.scale.set(1.5); suitContainer.addChild(circleBg); suitContainer.x = circleX; suitContainer.y = circleY - SCREEN_HEIGHT * 0.05 + 100; modsContainer.addChild(suitContainer); ModSystem.topSuitGraphics.push(suitContainer); } // --- Dark overlay below the four cards and above the equipped mods text --- var overlayCard = LK.getAsset('card', { anchorX: 0.5, anchorY: 0 }); var overlayWidth = totalBarWidth + 120; // Wide enough for all four cards and some margin var overlayHeight = 650; // Tall enough to cover the cards and the equipped mods text overlayCard.scale.set(overlayWidth / overlayCard.width, overlayHeight / overlayCard.height); overlayCard.x = SCREEN_WIDTH / 2; overlayCard.y = circleY - SCREEN_HEIGHT * 0.05 - overlayCard.height * overlayCard.scale.y / 2 + 130; // Start just above the cards overlayCard.alpha = 0.6; overlayCard.tint = 0x000000; modsContainer.addChildAt(overlayCard, 0); var equippedModsText = new Text2('Currently equipped mods', { size: 45, fill: 0xffffff, weight: '600' }); equippedModsText.anchor.set(0.5, 0); equippedModsText.x = SCREEN_WIDTH / 2; equippedModsText.y = circleY - SCREEN_HEIGHT * 0.05 + 350; // Position 25px below the mod icons modsContainer.addChild(equippedModsText); // --- MODS SCROLLABLE CONTAINER SETUP --- var modsScrollContainer = new Container(); modsScrollContainer.x = SCREEN_WIDTH / 2; modsScrollContainer.y = circleY + 450 - SCREEN_HEIGHT * 0.05; modsScrollContainer.hitArea = new Rectangle(-SCREEN_WIDTH / 2, -2000, SCREEN_WIDTH, 4000); // Full width, tall enough for all rows modsScrollContainer.interactive = true; modsContainer.addChildAt(modsScrollContainer, 0); // The gridContainer will be a child of the scrollable container var gridContainer = new Container(); gridContainer.x = 0; gridContainer.y = 0; modsScrollContainer.addChild(gridContainer); var cols = 4; var rows = 4; var cardForSizing = LK.getAsset('card', {}); var cellWidth = cardForSizing.width; var cellHeight = cardForSizing.height; var colSpacing = 160; var rowSpacing = 140; var gridTotalWidth = cols * cellWidth + (cols - 1) * colSpacing; var gridStartX = -gridTotalWidth / 2; var gridStartY = 50; // Add sabotageSpadesMod, toxinClubMod, gambitDiamondMod, and wildcardHeartMod as the last mods in the grid // Bottom row order: Wildcard, Gambit, Toxin, Sabotage var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod', 'wildcardHeartMod', 'gambitDiamondMod', 'toxinClubMod', 'sabotageSpadesMod']; for (var r = 0; r < rows; r++) { for (var c = 0; c < cols; c++) { var cell = LK.getAsset('card', { anchorX: 0, anchorY: 0 }); cell.scale.set(1.3); cell.x = gridStartX + c * (cellWidth + colSpacing); cell.y = gridStartY + r * (cellHeight + rowSpacing); gridContainer.addChild(cell); var modIndex = r * cols + c; if (modIndex < suitModAssets.length) { var modAssetId = suitModAssets[modIndex]; if (modAssetId) { var shadow = LK.getAsset('suitShadow', { anchorX: 0.5, anchorY: 0.5 }); shadow.x = cell.x + cell.width * cell.scale.x / 2; shadow.y = cell.y + cell.height * cell.scale.y - cell.height * cell.scale.y / 5 + 15; shadow.alpha = 0.3; gridContainer.addChild(shadow); var modAsset = LK.getAsset(modAssetId, { anchorX: 0.5, anchorY: 0.5 }); modAsset.x = cell.x + cell.width * cell.scale.x / 2; modAsset.y = cell.y + cell.height * cell.scale.y / 2; var isOwned = ModSystem.isModOwned(modAssetId); if (!isOwned) { modAsset.tint = 0x555555; modAsset.alpha = 0.6; cell.tint = 0x888888; } gridContainer.addChild(modAsset); var modData = ModSystem.modData[modAssetId]; if (modData) { var nameText = new Text2(modData.name.toUpperCase(), { size: 35, fill: 0x000000, weight: 'bold', strokeThickness: 0 }); nameText.anchor.set(0.5, 0); nameText.x = cell.x + cell.width * cell.scale.x / 2; nameText.y = cell.y + 20; gridContainer.addChild(nameText); } createModFloatAnimation(modAsset, shadow); // Add click handler for mod display to the entire cell card cell.interactive = true; (function (assetId, modAssetRef) { cell.down = function () { ModSystem.showModDisplay(assetId, modAssetRef.x, modAssetRef.y); }; })(modAssetId, modAsset); } } } } // --- SCROLL LOGIC FOR MODS SCREEN --- var modsScrollState = { isDragging: false, lastY: 0, startY: 0, startGridY: 0, minY: 0, maxY: 0 }; // Calculate scroll bounds after grid is built (function setupModsScrollBounds() { // The visible area height for the mods grid (approx 3 rows visible) var visibleHeight = 3 * cellHeight * 1.3 + 2 * rowSpacing + 100; // The total height of the grid var totalGridHeight = rows * cellHeight * 1.3 + (rows - 1) * rowSpacing; // The grid's y=0 is at the top of the first cell, so minY is negative modsScrollState.minY = Math.min(0, visibleHeight - totalGridHeight - gridStartY); modsScrollState.maxY = 0; gridContainer.y = 0; })(); // Add drag handlers to the modsScrollContainer for full width drag modsScrollContainer.interactive = true; modsScrollContainer.down = function (x, y, obj) { // Only allow scroll if modsContainer is visible if (!modsContainer.visible) { return; } modsScrollState.isDragging = true; modsScrollState.lastY = y; modsScrollState.startY = y; modsScrollState.startGridY = gridContainer.y; }; modsScrollContainer.move = function (x, y, obj) { if (!modsScrollState.isDragging) { return; } var dy = y - modsScrollState.lastY; modsScrollState.lastY = y; var newY = gridContainer.y + dy; // Clamp to bounds if (newY < modsScrollState.minY) { newY = modsScrollState.minY; } if (newY > modsScrollState.maxY) { newY = modsScrollState.maxY; } gridContainer.y = newY; }; modsScrollContainer.up = function (x, y, obj) { modsScrollState.isDragging = false; }; currentGameState = 'start'; } function startGame(isTutorial, mode) { gameMode = mode || 'pvp'; LK.stopMusic(); // Clear start screen elements startScreenElements.forEach(function (element) { if (element.parent) { element.parent.removeChild(element); } }); startScreenElements = []; backgroundSuits = []; // Show game elements gameElements.forEach(function (element) { element.visible = true; }); if (gameMode === 'coop') { background.visible = false; coopBackground.visible = true; } else { background.visible = true; coopBackground.visible = false; } currentGameState = 'playing'; initializeGame(isTutorial || false); } // Create a new function for the normal game start sequence: function startNormalGameSequence() { var getReadyText = new Text2('Get ready…', { size: 150, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 10 }); getReadyText.anchor.set(0.5, 0.5); getReadyText.x = SCREEN_WIDTH / 2; getReadyText.y = SCREEN_HEIGHT / 2 - 155; getReadyText.alpha = 0; uiLayer.addChild(getReadyText); tween(getReadyText, { alpha: 1 }, { duration: 500, onFinish: function onFinish() { LK.getSound('getReady').play(); } }); gameReady = false; LK.setTimeout(function () { if (!getReadyText.parent) { return; } getReadyText.setText('Deal \'em!'); LK.getSound('gameStart').play(); dealInitialHand(); LK.setTimeout(function () { if (getReadyText.parent) { tween(getReadyText, { alpha: 0 }, { duration: 500, onFinish: function onFinish() { if (getReadyText.parent) { getReadyText.parent.removeChild(getReadyText); } gameReady = true; LK.playMusic('pvpMusic'); } }); } }, 1000); }, 2000); } function initializeGame(isTutorial) { // Disable deal button at the start of the round discardAreaContainer.interactive = false; discardAreaGraphic.tint = 0x666666; discardAreaGraphic.alpha = 1.0; ModSystem.init(); AISystem.setupMods(); PoolManager.init(); PathSystem.init(); // Initialize play areas gameState.playerPlayArea = []; gameState.aiPlayArea = []; playerHandNameTexts = [null, null]; for (var row = 0; row < PLAY_AREA_ROWS; row++) { gameState.playerPlayArea[row] = []; gameState.aiPlayArea[row] = []; for (var col = 0; col < PLAY_AREA_COLS; col++) { gameState.playerPlayArea[row][col] = null; gameState.aiPlayArea[row][col] = null; } } // Create initial decks gameState.playerDeck = CardSystem.createDeck(); gameState.aiDeck = CardSystem.createDeck(); // Draw grid lines drawPlayAreas(); drawPaths(); createLifeDisplays(); lastPlayerLives = gameState.playerLives; if (gameMode === 'coop') { gameState.aiLives = gameState.playerLives; playerTotalDamage = 0; aiTotalDamage = 0; } lastAiLives = gameState.aiLives; // Initialize player's hand with empty slots gameState.playerHand = [null, null, null, null, null]; // Center bar removed if (isTutorial) { LK.playMusic('pvpMusic'); gameReady = false; AISystem.thinkDelay = 999999; TutorialSystem.startInGameTutorial(); } else { // NEW: Show boss roulette at the very beginning BossSystem.showBossRoulette(function () { // After roulette, show "Get Ready" and start normal game startNormalGameSequence(); }); } } function createLifeDisplays() { // Clear any existing hearts and labels if (opponentNameText && opponentNameText.parent) { opponentNameText.parent.removeChild(opponentNameText); } if (playerNameText && playerNameText.parent) { playerNameText.parent.removeChild(playerNameText); } playerLifeHearts.forEach(function (h) { if (h.parent) { h.parent.removeChild(h); } }); playerLifeHearts = []; aiLifeHearts.forEach(function (h) { if (h.parent) { h.parent.removeChild(h); } }); aiLifeHearts = []; if (gameMode === 'coop') { var heartSpacing = 110; var heartScale = 0.5; // Position to the right of the coop background, adjusted up and left var startX = coopBackground.x + coopBackground.width / 2 + 80 - SCREEN_WIDTH * 0.05; var startY = SCREEN_HEIGHT / 2 - heartSpacing - SCREEN_HEIGHT * 0.07; // Player lives are unified in coop mode for (var i = 0; i < gameState.playerLives; i++) { var heart = LK.getAsset('heartSuit', { anchorX: 0.5, anchorY: 0.5, scaleX: heartScale, scaleY: heartScale }); heart.x = startX; heart.y = startY + i * heartSpacing; uiLayer.addChild(heart); playerLifeHearts.push(heart); } } else { var heartSpacing = 110; var heartScale = 0.5; var startX_AI = 200 - 70; var startX_Player = SCREEN_WIDTH - 200 + 70; var yPos = SCREEN_HEIGHT / 2 - 137 + 10; var labelYPos = yPos - 60; // Opponent Name Text var totalAIHeartsWidth = (gameState.aiLives - 1) * heartSpacing; opponentNameText = new Text2('Opponent', { size: 40, fill: 0xffffff, weight: 800 }); opponentNameText.anchor.set(0.5, 1); opponentNameText.x = startX_AI + totalAIHeartsWidth / 2; opponentNameText.y = labelYPos; uiLayer.addChild(opponentNameText); // Player Name Text var totalPlayerHeartsWidth = (gameState.playerLives - 1) * heartSpacing; playerNameText = new Text2('Player', { size: 40, fill: 0xffffff, weight: 800 }); playerNameText.anchor.set(0.5, 1); playerNameText.x = startX_Player - totalPlayerHeartsWidth / 2; playerNameText.y = labelYPos; uiLayer.addChild(playerNameText); // AI Lives (left side) for (var i = 0; i < gameState.aiLives; i++) { var heart = LK.getAsset('heartSuit', { anchorX: 0.5, anchorY: 0.5, scaleX: heartScale, scaleY: heartScale }); heart.x = startX_AI + i * heartSpacing; heart.y = yPos; uiLayer.addChild(heart); aiLifeHearts.push(heart); } // Player Lives (right side) for (var i = 0; i < gameState.playerLives; i++) { var heart = LK.getAsset('heartSuit', { anchorX: 0.5, anchorY: 0.5, scaleX: heartScale, scaleY: heartScale }); heart.x = startX_Player - i * heartSpacing; heart.y = yPos; uiLayer.addChild(heart); playerLifeHearts.push(heart); } } } function dealNewHand() { if (gameState.playerChips < gameState.dealCost) { return; } // Find an empty slot in the player's hand var emptySlotIndex = -1; for (var i = 0; i < gameState.playerHand.length; i++) { if (!gameState.playerHand[i]) { emptySlotIndex = i; break; } } // If hand is full, do nothing if (emptySlotIndex === -1) { return; } gameState.playerChips -= gameState.dealCost; gameState.dealCount++; // Progressive cost increase with diminishing returns var baseCost = 25; // Changed from 38 to 25 var newCost; if (gameState.dealCount <= 10) { // First 10 deals: 8% increase each time newCost = Math.floor(baseCost * Math.pow(1.08, gameState.dealCount)); } else if (gameState.dealCount <= 25) { // Deals 11-25: 5% increase each time var cost10 = Math.floor(baseCost * Math.pow(1.08, 10)); // Cost at deal 10 var additionalDeals = gameState.dealCount - 10; newCost = Math.floor(cost10 * Math.pow(1.05, additionalDeals)); } else { // Deals 26+: 3% increase each time var cost10 = Math.floor(baseCost * Math.pow(1.08, 10)); var cost25 = Math.floor(cost10 * Math.pow(1.05, 15)); // 15 deals at 5% var additionalDeals = gameState.dealCount - 25; newCost = Math.floor(cost25 * Math.pow(1.03, additionalDeals)); } gameState.dealCost = newCost; if (gameState.playerDeck.length === 0) { gameState.playerDeck = CardSystem.createDeck(); } var cardData = gameState.playerDeck.pop(); // After every 10 waves, new cards dealt start one level higher var startLevel = Math.floor((WaveSystem.waveNumber - 1) / 10) + 1; var i = emptySlotIndex; var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px var handStartX = (SCREEN_WIDTH - handWidth) / 2; var slotX = handStartX + i * DEAL_SLOT_WIDTH + i * 30 + DEAL_SLOT_WIDTH / 2; var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; // Start position - off to the bottom var startX = slotX + (Math.random() - 0.5) * 50; // Slight horizontal variance var startY = SCREEN_HEIGHT + DEAL_SLOT_HEIGHT; // Mark slot as occupied immediately to prevent overwriting if deal is pressed too quickly gameState.playerHand[i] = true; var cardBack = LK.getAsset('cardBack', { anchorX: 0.5, anchorY: 0.5 }); cardBack.x = startX; cardBack.y = startY; uiLayer.addChild(cardBack); // Animate card flying into place and flipping tween(cardBack, { x: slotX, y: slotY }, { duration: 250, easing: tween.cubicOut, onFinish: function onFinish() { // Flip animation: shrink back tween(cardBack, { scaleX: 0.01 }, { duration: 150, easing: tween.quadIn, onFinish: function onFinish() { if (cardBack.parent) { cardBack.parent.removeChild(cardBack); } // Create and show the real card var card = new Card(cardData); card.setLevel(startLevel); card.activate(slotX, slotY, false, true); card.scale.x = 0.01; uiLayer.addChild(card); // Replace the placeholder with the actual card object gameState.playerHand[i] = card; // Flip animation: expand card face tween(card, { scaleX: 1.0 }, { duration: 150, easing: tween.quadOut, onFinish: function onFinish() { LK.getSound('cardLand').play(); } }); } }); } }); updateUI(); } function updateUI() { playerChipsText.setText('Chips: ' + formatNumberWithSuffix(gameState.playerChips)); // Update combined deal/discard button text and appearance when not dragging if (!isDragging) { discardText.setText('-' + formatNumberWithSuffix(gameState.dealCost)); discardText.fill = 0xffffff; // Update button color based on affordability if (gameState.playerChips >= gameState.dealCost) { discardAreaGraphic.tint = 0xffffff; // No tint when affordable discardAreaGraphic.alpha = 1.0; // Full alpha when affordable } else { discardAreaGraphic.tint = 0x666666; // Grey tint when not affordable discardAreaGraphic.alpha = 1.0; // Keep full alpha even when not affordable } } waveText.setText('Wave: ' + WaveSystem.waveNumber); } function drawPlayAreas() { // Draw player play area slots var hand1Text = 'HAND1'; var hand2Text = 'HAND2'; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var slot = new Container(); var slotGraphics = slot.attachAsset('card', { anchorX: 0.5, anchorY: 0.5 }); slotGraphics.alpha = 0.5; var textToShow = row === 0 ? hand1Text : hand2Text; var text = new Text2(textToShow.charAt(col), { size: 180, fill: 0xffffff, weight: 'bold' }); text.anchor.set(0.5); text.alpha = 0.3; slot.addChild(text); slot.x = PLAYER_AREA_X + col * SLOT_WIDTH + SLOT_WIDTH / 2; slot.y = PLAYER_AREA_Y + row * SLOT_HEIGHT + SLOT_HEIGHT / 2; gameLayer.addChild(slot); slotIndicators.push(slot); } } // Draw AI play area slots for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var slot = new Container(); var slotGraphics = slot.attachAsset('card', { anchorX: 0.5, anchorY: 0.5 }); slotGraphics.alpha = 0.5; slotGraphics.tint = 0xff8888; // Red tint for AI area var textToShow = row === 0 ? hand1Text : hand2Text; var text = new Text2(textToShow.charAt(col), { size: 180, fill: 0xffffff, weight: 'bold' }); text.anchor.set(0.5); text.alpha = 0.3; slot.addChild(text); slot.x = AI_AREA_X + col * SLOT_WIDTH + SLOT_WIDTH / 2; slot.y = AI_AREA_Y + row * SLOT_HEIGHT + SLOT_HEIGHT / 2; gameLayer.addChild(slot); slotIndicators.push(slot); } } // Draw player deal area slots (hand) var rating = storage.battleRating; var ratingString = String(rating); while (ratingString.length < 4) { ratingString = '0' + ratingString; } for (var i = 0; i < 5; i++) { var dealSlot = new Container(); var dealSlotGraphics = dealSlot.attachAsset('dealSlot', { anchorX: 0.5, anchorY: 0.5 }); dealSlotGraphics.alpha = 0.5; if (i === 0) { var icon = dealSlot.attachAsset('battleRatingIcon', { anchorX: 0.5, anchorY: 0.5 }); icon.alpha = 0.3; var iconScale = dealSlotGraphics.width * 0.8 / icon.width; icon.scale.set(iconScale); } else { var digit = ratingString.charAt(i - 1); var text = new Text2(digit, { size: 180, fill: 0xffffff, weight: 'bold' }); text.anchor.set(0.5); text.alpha = 0.3; dealSlot.addChild(text); } var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px var handStartX = (SCREEN_WIDTH - handWidth) / 2; dealSlot.x = handStartX + i * DEAL_SLOT_WIDTH + i * 30 + DEAL_SLOT_WIDTH / 2; dealSlot.y = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; gameLayer.addChild(dealSlot); slotIndicators.push(dealSlot); } } function drawPaths() { // Path lines removed - enemies still follow invisible paths } // drawPathSegment function removed - no longer needed since path lines are removed function getSlotPosition(row, col, isPlayerArea) { var baseX = isPlayerArea ? PLAYER_AREA_X : AI_AREA_X; var baseY = isPlayerArea ? PLAYER_AREA_Y : AI_AREA_Y; return { x: baseX + col * SLOT_WIDTH + SLOT_WIDTH / 2, y: baseY + row * SLOT_HEIGHT + SLOT_HEIGHT / 2 }; } function getSlotFromPosition(x, y) { // Check player play area if (x >= PLAYER_AREA_X && x <= PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH && y >= PLAYER_AREA_Y && y <= PLAYER_AREA_Y + PLAY_AREA_ROWS * SLOT_HEIGHT) { var col = Math.floor((x - PLAYER_AREA_X) / SLOT_WIDTH); var row = Math.floor((y - PLAYER_AREA_Y) / SLOT_HEIGHT); if (col >= 0 && col < PLAY_AREA_COLS && row >= 0 && row < PLAY_AREA_ROWS) { return { area: 'player', row: row, col: col }; } } // Check player hand area if (y >= PLAYER_DEAL_AREA_Y && y <= PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT) { var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px var handStartX = (SCREEN_WIDTH - handWidth) / 2; for (var i = 0; i < 5; i++) { var slotXStart = handStartX + i * (DEAL_SLOT_WIDTH + 30); var slotXEnd = slotXStart + DEAL_SLOT_WIDTH; if (x >= slotXStart && x <= slotXEnd) { return { area: 'hand', index: i }; } } } // Check discard area if (discardAreaContainer && x >= discardAreaContainer.x - DEAL_SLOT_WIDTH / 2 && x <= discardAreaContainer.x + DEAL_SLOT_WIDTH / 2 && y >= discardAreaContainer.y - DEAL_SLOT_HEIGHT / 2 && y <= discardAreaContainer.y + DEAL_SLOT_HEIGHT / 2) { return { area: 'discard' }; } return null; } function evaluateRowHand(row, isPlayerArea) { var playArea = isPlayerArea ? gameState.playerPlayArea : gameState.aiPlayArea; var cards = []; for (var col = 0; col < PLAY_AREA_COLS; col++) { if (playArea[row][col]) { cards.push(playArea[row][col]); } } return CardSystem.evaluatePokerHand(cards); } function updateHandNameDisplay(row, handEval) { var existingText = playerHandNameTexts[row]; var shouldShowText = handEval.strength > 1; if (shouldShowText) { var handName = handEval.type.replace(/_/g, ' ').toUpperCase(); if (existingText) { if (existingText.text !== handName) { existingText.setText(handName); } existingText.visible = true; } else { var newText = new Text2(handName, { size: 50, fill: 0xffffff, weight: '800', stroke: 0x000000, strokeThickness: 0 }); newText.anchor.set(0.5, 0); newText.alpha = 0.8; newText.x = PLAYER_AREA_X + PLAY_AREA_COLS * SLOT_WIDTH / 2; newText.y = PLAYER_AREA_Y + (row + 1) * SLOT_HEIGHT - 20; uiLayer.addChild(newText); playerHandNameTexts[row] = newText; } } else { if (existingText) { existingText.visible = false; } } } function applyHandBonuses() { // Apply bonuses to player cards for (var row = 0; row < PLAY_AREA_ROWS; row++) { var handEval = evaluateRowHand(row, true); updateHandNameDisplay(row, handEval); var contributingCards = handEval.contributingCards || []; for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { card.handBonus = handEval.multiplier; card.calculateStats(); card.redOutline.visible = handEval.strength > 1 && contributingCards.indexOf(card) !== -1; } } } // Apply bonuses to AI cards AISystem.applyAIHandBonuses(); } function getAIDifficultySettings(battleRating) { // Post-tutorial AI intelligence now scales more aggressively with battle rating. // Normalize rating from 0 to 1, clamped between 0 and a max rating of 1500 (was 2000). var maxRatingForScaling = 1500; var normalizedRating = Math.max(0, Math.min(battleRating || 0, maxRatingForScaling)) / maxRatingForScaling; // thinkDelay: from 300 (5s) down to 45 (0.75s). Starts faster than the original 360 (6s). var thinkDelay = 300 - normalizedRating * (300 - 45); // optimizationChance: from 10% up to 80%. Higher baseline and ceiling (was 5%-70%). var optimizationChance = 0.1 + normalizedRating * (0.8 - 0.1); // shouldOptimize: enabled above 50 rating (was 100). var shouldOptimize = (battleRating || 0) > 50; return { thinkDelay: Math.floor(thinkDelay), optimizationChance: optimizationChance, shouldOptimize: shouldOptimize, canLevelUp: (battleRating || 0) > 0 }; } /**** * AI System ****/ var AISystem = { thinkTimer: 0, update: function update() { var difficulty = getAIDifficultySettings(storage.battleRating); var currentThinkDelay = TutorialSystem.isActive ? 240 : difficulty.thinkDelay; this.thinkTimer++; if (this.thinkTimer >= currentThinkDelay) { this.thinkTimer = 0; this.makeMove(); } }, shouldDeal: function shouldDeal() { // Deal if we can afford it and have empty slots if (gameState.aiChips < gameState.dealCost) { return false; } var emptySlots = this.countEmptySlots(); // Deal if there are any empty slots at all return emptySlots > 0; }, countEmptySlots: function countEmptySlots() { var count = 0; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { if (!gameState.aiPlayArea[row][col]) { count++; } } } return count; }, countLowLevelCards: function countLowLevelCards() { var count = 0; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.aiPlayArea[row][col]; if (card && card.level <= 2) { count++; } } } return count; }, makeMove: function makeMove() { var difficulty = getAIDifficultySettings(storage.battleRating); // Priority order: Merge > Place > Optimize > Deal. Only one action per cycle. if (difficulty.canLevelUp && this.tryMergeCards()) { // Successfully merged, wait for next think cycle return; } if (this.tryPlaceCards()) { // Successfully placed cards return; } if (difficulty.shouldOptimize && this.optimizeCardPositions()) { // Successfully optimized, wait for next think cycle return; } // As a last resort, try to deal a new card if possible if (this.shouldDeal()) { this.dealAIHand(); } }, tryMergeCards: function tryMergeCards() { // Look for mergeable cards for (var row1 = 0; row1 < PLAY_AREA_ROWS; row1++) { for (var col1 = 0; col1 < PLAY_AREA_COLS; col1++) { var card1 = gameState.aiPlayArea[row1][col1]; if (!card1) { continue; } // Look for a card to merge with for (var row2 = 0; row2 < PLAY_AREA_ROWS; row2++) { for (var col2 = 0; col2 < PLAY_AREA_COLS; col2++) { if (row1 === row2 && col1 === col2) { continue; } var card2 = gameState.aiPlayArea[row2][col2]; if (!card2) { continue; } if (card1.canMergeWith(card2)) { this.mergeCards(card1, card2, row1, col1, row2, col2); return true; } } } } } return false; }, mergeCards: function mergeCards(card1, card2, row1, col1, row2, col2) { var mergedCard = card1.mergeWith(card2); if (mergedCard) { // NEW: Trigger sabotage effect if AI merges a sabotage mod card if (card1.cardData.suit === 'spades' && ModSystem.getEquippedModAsset('spades', false) === 'sabotageSpadesMod' && typeof card1.performSabotage === "function") { card1.performSabotage(); } var oldLevel = card2.level; // Remove old cards gameLayer.removeChild(card1); gameLayer.removeChild(card2); gameState.aiPlayArea[row1][col1] = null; gameState.aiPlayArea[row2][col2] = null; // Place merged card in the first position var pos = getSlotPosition(row1, col1, false); mergedCard.activate(pos.x, pos.y, true, false); gameLayer.addChild(mergedCard); gameState.aiPlayArea[row1][col1] = mergedCard; // Merge animation mergedCard.alpha = 0; mergedCard.scaleX = mergedCard.scaleY = 1.5; tween(mergedCard, { alpha: 1, scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.elasticOut }); createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00, 60); var damageBefore = Math.floor(10 * Math.pow(1.6, oldLevel - 1)); var fireRateBefore = Math.max(15, Math.floor(60 / Math.pow(1.2, oldLevel - 1))); var damageAfter = Math.floor(10 * Math.pow(1.6, mergedCard.level - 1)); var fireRateAfter = Math.max(15, Math.floor(60 / Math.pow(1.2, mergedCard.level - 1))); var damageIncrease = damageBefore > 0 ? Math.round((damageAfter / damageBefore - 1) * 100) : 0; var fireRateIncrease = fireRateAfter > 0 && fireRateAfter < fireRateBefore ? Math.round((fireRateBefore / fireRateAfter - 1) * 100) : 0; var statText = ""; if (damageBefore > 0) { var dmgMult = (damageAfter / damageBefore).toFixed(2); statText = "Dmg x" + dmgMult; } createFloatingText(statText, mergedCard.x, mergedCard.y + 55, 0x00ff00, 35); this.applyAIHandBonuses(); } }, tryPlaceCards: function tryPlaceCards() { // AI doesn't have a "hand" like player, it deals directly to board // This function is for future expansion return false; }, optimizeCardPositions: function optimizeCardPositions() { // Move stronger cards to better positions (like completing poker hands) // For now, just try to complete rows for hand bonuses return this.tryCompletePokerHands(); }, tryCompletePokerHands: function tryCompletePokerHands() { for (var row = 0; row < PLAY_AREA_ROWS; row++) { var rowCards = []; var emptyPositions = []; for (var col = 0; col < PLAY_AREA_COLS; col++) { if (gameState.aiPlayArea[row][col]) { rowCards.push({ card: gameState.aiPlayArea[row][col], col: col }); } else { emptyPositions.push(col); } } // If row is almost complete, try to fill it strategically if (rowCards.length >= 3 && emptyPositions.length > 0) { // Look for cards in other rows that might complete a hand if (this.tryMoveCardToCompleteHand(row, rowCards, emptyPositions[0])) { return true; // A move was made, so we are done for this 'think' cycle } } } return false; // No move was made }, tryMoveCardToCompleteHand: function tryMoveCardToCompleteHand(targetRow, existingCards, targetCol) { var difficulty = getAIDifficultySettings(storage.battleRating); // Look for cards in other positions that might help complete a hand for (var row = 0; row < PLAY_AREA_ROWS; row++) { if (row === targetRow) { continue; } for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.aiPlayArea[row][col]; if (!card) { continue; } // Simple heuristic: move cards of same suit or sequential values var shouldMove = this.cardHelpsHand(card, existingCards); if (shouldMove && Math.random() < difficulty.optimizationChance) { // Dynamic chance to move // Move the card gameState.aiPlayArea[row][col] = null; gameState.aiPlayArea[targetRow][targetCol] = card; var newPos = getSlotPosition(targetRow, targetCol, false); tween(card, { x: newPos.x, y: newPos.y }, { duration: 300, easing: tween.quadOut }); this.applyAIHandBonuses(); return true; } } } return false; }, cardHelpsHand: function cardHelpsHand(card, existingCards) { // Simple heuristic to see if a card might help complete a poker hand var suits = {}; var values = {}; existingCards.forEach(function (cardInfo) { var c = cardInfo.card.cardData; suits[c.suit] = (suits[c.suit] || 0) + 1; values[c.value] = (values[c.value] || 0) + 1; }); // Check if card matches existing suits or values var cardSuit = card.cardData.suit; var cardValue = card.cardData.value; return suits[cardSuit] >= 2 || values[cardValue] >= 1; }, dealAIHand: function dealAIHand() { if (gameState.aiChips < gameState.dealCost) { return; } gameState.aiChips -= gameState.dealCost; // Deal one card to an empty slot var cardData; // AI cannot play jokers, so re-deal if one is drawn. do { if (gameState.aiDeck.length === 0) { gameState.aiDeck = CardSystem.createDeck(); } cardData = gameState.aiDeck.pop(); } while (cardData.suit === 'joker'); // After every 10 waves, new cards dealt start one level higher var startLevel = Math.floor((WaveSystem.waveNumber - 1) / 10) + 1; // Find best empty slot (prefer completing rows) var bestSlot = this.findBestEmptySlot(); if (bestSlot) { var self = this; var pos = getSlotPosition(bestSlot.row, bestSlot.col, false); // Set initial off-screen position and properties for animation var startY = -SLOT_HEIGHT; // Come from top of the screen var aiCardBack = LK.getAsset('aiCardBack', { anchorX: 0.5, anchorY: 0.5 }); aiCardBack.x = pos.x; aiCardBack.y = startY; aiCardBack.rotation = Math.PI * 4; // Two full spins aiCardBack.scale.set(0.1); // Start small gameLayer.addChild(aiCardBack); // Deal animation: spin into place tween(aiCardBack, { y: pos.y, rotation: 0, scaleX: 1, scaleY: 1 }, { duration: 600, easing: tween.quadOut, onFinish: function onFinish() { // Flip animation: shrink back tween(aiCardBack, { scaleX: 0.01 }, { duration: 150, easing: tween.quadIn, onFinish: function onFinish() { if (aiCardBack.parent) { aiCardBack.parent.removeChild(aiCardBack); } // Create and show the real card var card = new Card(cardData); card.setLevel(startLevel); card.activate(pos.x, pos.y, true, false); card.scale.x = 0.01; gameLayer.addChild(card); gameState.aiPlayArea[bestSlot.row][bestSlot.col] = card; // Flip animation: expand card face tween(card, { scaleX: 1.0 }, { duration: 150, easing: tween.quadOut, onFinish: function onFinish() { self.applyAIHandBonuses(); } }); } }); } }); } }, findBestEmptySlot: function findBestEmptySlot() { var emptySlots = []; for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { if (!gameState.aiPlayArea[row][col]) { var score = this.evaluateSlotScore(row, col); emptySlots.push({ row: row, col: col, score: score }); } } } if (emptySlots.length === 0) { return null; } // Sort by score (higher is better) emptySlots.sort(function (a, b) { return b.score - a.score; }); return emptySlots[0]; }, evaluateSlotScore: function evaluateSlotScore(row, col) { var score = 0; var cardsInRow = 0; // Count cards in this row for (var c = 0; c < PLAY_AREA_COLS; c++) { if (gameState.aiPlayArea[row][c]) { cardsInRow++; } } // Prefer completing rows score += cardsInRow * 10; // Slight preference for middle positions score += (2 - Math.abs(col - 2)) * 2; return score; }, applyAIHandBonuses: function applyAIHandBonuses() { // Apply poker hand bonuses to AI cards for (var row = 0; row < PLAY_AREA_ROWS; row++) { var handEval = evaluateRowHand(row, false); var contributingCards = handEval.contributingCards || []; for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.aiPlayArea[row][col]; if (card) { card.handBonus = handEval.multiplier; card.calculateStats(); card.redOutline.visible = handEval.strength > 1 && contributingCards.indexOf(card) !== -1; } } } }, setupMods: function setupMods() { var playerModCount = 0; for (var suit in ModSystem.equippedMods) { if (ModSystem.equippedMods[suit]) { playerModCount++; } } var allMods = Object.keys(ModSystem.modData); var availableModsBySuit = { hearts: [], diamonds: [], clubs: [], spades: [] }; allMods.forEach(function (modId) { var suit = ModSystem.modData[modId].suit; if (suit && availableModsBySuit[suit]) { availableModsBySuit[suit].push(modId); } }); ModSystem.aiEquippedMods = { hearts: null, diamonds: null, clubs: null, spades: null }; var aiModCount = 0; var suits = ['hearts', 'diamonds', 'clubs', 'spades']; for (var i = suits.length - 1; i > 0; i--) { var j = Math.floor(Math.random() * (i + 1)); var temp = suits[i]; suits[i] = suits[j]; suits[j] = temp; } for (var i = 0; i < suits.length; i++) { var suit = suits[i]; if (aiModCount < playerModCount && availableModsBySuit[suit].length > 0) { var randomModForSuit = availableModsBySuit[suit][Math.floor(Math.random() * availableModsBySuit[suit].length)]; ModSystem.aiEquippedMods[suit] = randomModForSuit; aiModCount++; } } } }; /**** * Input Handling ****/ game.down = function (x, y, obj) { // Only handle input during playing state if (currentGameState !== 'playing') { return; } // Check if clicking on a card in hand for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card && Math.abs(x - card.x) < DEAL_SLOT_WIDTH / 2 && Math.abs(y - card.y) < DEAL_SLOT_HEIGHT / 2) { // Block dragging if card is locked if (card.isLocked) { createFloatingText('LOCKED!', card.x, card.y - 30, 0xff0000, 40); return; } selectedCard = card; isDragging = true; originalCardPosition = { area: 'hand', index: i }; uiLayer.addChild(selectedCard); return; } } // Check if clicking on a card in play area for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card && Math.abs(x - card.x) < SLOT_WIDTH / 2 && Math.abs(y - card.y) < SLOT_HEIGHT / 2) { // Block dragging if card is locked if (card.isLocked) { createFloatingText('LOCKED!', card.x, card.y - 30, 0xff0000, 40); return; } selectedCard = card; isDragging = true; originalCardPosition = { area: 'player', row: row, col: col }; // Remove from current position gameState.playerPlayArea[row][col] = null; gameLayer.addChild(selectedCard); return; } } } }; game.move = function (x, y, obj) { // Only handle input during playing state if (currentGameState !== 'playing') { return; } if (isDragging && selectedCard) { selectedCard.x = x; selectedCard.y = y; // Highlight mergeable cards (but not locked ones) // Player's play area for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { // Only show green outline if card can merge AND is not locked card.greenOutline.visible = selectedCard.canMergeWith(card) && !card.isLocked; } } } // Player's hand for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card && card !== selectedCard) { // Only show green outline if card can merge AND is not locked card.greenOutline.visible = selectedCard.canMergeWith(card) && !card.isLocked; } } // Switch to discard mode when dragging discardAreaGraphic.visible = false; refundButtonGraphic.visible = true; // Highlight discard area on hover var isOverDiscard = discardAreaContainer && x >= discardAreaContainer.x - DEAL_SLOT_WIDTH / 2 && x <= discardAreaContainer.x + DEAL_SLOT_WIDTH / 2 && y >= discardAreaContainer.y - DEAL_SLOT_HEIGHT / 2 && y <= discardAreaContainer.y + DEAL_SLOT_HEIGHT / 2; var chipRefund = Math.floor(gameState.dealCost / 2); discardText.setText('+' + formatNumberWithSuffix(chipRefund)); if (isOverDiscard) { discardText.fill = 0xffd700; // Gold color refundButtonGraphic.alpha = 1.0; } else { refundButtonGraphic.alpha = 0.7; discardText.fill = 0x999999; } } else { // When not dragging, show as deal button discardAreaGraphic.visible = true; refundButtonGraphic.visible = false; updateUI(); } }; game.up = function (x, y, obj) { // Only handle input during playing state if (currentGameState !== 'playing') { return; } if (isDragging && selectedCard) { isDragging = false; discardAreaGraphic.visible = true; refundButtonGraphic.visible = false; // Clear all temporary green outlines for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { card.greenOutline.visible = false; } } } for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card) { card.greenOutline.visible = false; } } // Reset to deal button mode updateUI(); var targetSlot = getSlotFromPosition(x, y); if (targetSlot) { // Handle dropping card on discard area if (targetSlot.area === 'discard') { var chipRefund = Math.floor(gameState.dealCost / 2); gameState.playerChips += chipRefund; // Remove from original position data if (originalCardPosition.area === 'hand') { gameState.playerHand[originalCardPosition.index] = null; } else if (originalCardPosition.area === 'player') { // This is already null from game.down, so this is just for safety. gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = null; } // Remove card graphic from scene and memory if (selectedCard.parent) { selectedCard.parent.removeChild(selectedCard); } createFloatingText('+' + formatNumberWithSuffix(chipRefund) + ' Chips', selectedCard.x, selectedCard.y, 0xffd700); selectedCard = null; originalCardPosition = null; updateUI(); // Recalculate bonuses if a card was removed from play area if (originalCardPosition && originalCardPosition.area === 'player') { applyHandBonuses(); } return; // Exit early } if (targetSlot.area === 'player') { var existingCard = gameState.playerPlayArea[targetSlot.row][targetSlot.col]; if (existingCard && selectedCard.canMergeWith(existingCard)) { // Block merging with locked cards if (existingCard.isLocked) { createFloatingText('Cannot merge with locked card!', existingCard.x, existingCard.y, 0xff0000, 40); returnCardToOriginalPosition(); // Clear green outlines and reset UI for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { card.greenOutline.visible = false; } } } for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card) { card.greenOutline.visible = false; } } selectedCard = null; originalCardPosition = null; updateUI(); return; } // Merge in play area var oldLevel = existingCard.level; var mergedCard = selectedCard.mergeWith(existingCard); if (mergedCard) { gameLayer.removeChild(existingCard); var handIndex = gameState.playerHand.indexOf(selectedCard); if (handIndex !== -1) { uiLayer.removeChild(selectedCard); gameState.playerHand[handIndex] = null; } else { gameLayer.removeChild(selectedCard); } var pos = getSlotPosition(targetSlot.row, targetSlot.col, true); mergedCard.activate(pos.x, pos.y, true); gameLayer.addChild(mergedCard); gameState.playerPlayArea[targetSlot.row][targetSlot.col] = mergedCard; mergedCard.alpha = 0; mergedCard.scaleX = mergedCard.scaleY = 2; tween(mergedCard, { alpha: 1, scaleX: 1, scaleY: 1 }, { duration: 300, easing: tween.elasticOut }); LK.getSound('levelUp').play(); createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00, 60); var damageBefore = Math.floor(10 * Math.pow(1.6, oldLevel - 1)); var fireRateBefore = Math.max(15, Math.floor(60 / Math.pow(1.2, oldLevel - 1))); var damageAfter = Math.floor(10 * Math.pow(1.6, mergedCard.level - 1)); var fireRateAfter = Math.max(15, Math.floor(60 / Math.pow(1.2, mergedCard.level - 1))); var damageIncrease = damageBefore > 0 ? Math.round((damageAfter / damageBefore - 1) * 100) : 0; var fireRateIncrease = fireRateAfter > 0 && fireRateAfter < fireRateBefore ? Math.round((fireRateBefore / fireRateAfter - 1) * 100) : 0; var statText = ""; if (damageBefore > 0) { var dmgMult = (damageAfter / damageBefore).toFixed(2); statText = "Dmg x" + dmgMult; } createFloatingText(statText, mergedCard.x, mergedCard.y + 55, 0x00ff00, 35); } } else if (!existingCard) { // Prevent Jokers from being played on the board directly. They can only merge. if (selectedCard.cardData.suit === 'joker') { createFloatingText('Jokers can only level up other cards.', selectedCard.x, selectedCard.y, 0xffcc00); returnCardToOriginalPosition(); } else { // Place in empty slot var pos = getSlotPosition(targetSlot.row, targetSlot.col, true); selectedCard.activate(pos.x, pos.y, true); selectedCard.resetInvestment(); var handIndex = gameState.playerHand.indexOf(selectedCard); if (handIndex !== -1) { uiLayer.removeChild(selectedCard); gameLayer.addChild(selectedCard); gameState.playerHand[handIndex] = null; } gameState.playerPlayArea[targetSlot.row][targetSlot.col] = selectedCard; } } else { // Prevent Jokers from being swapped onto the board. if (selectedCard.cardData.suit === 'joker') { createFloatingText('Jokers can only level up other cards.', selectedCard.x, selectedCard.y, 0xffcc00); returnCardToOriginalPosition(); } else { // Card exists, but cannot merge: swap them with animation var swappedCard = gameState.playerPlayArea[targetSlot.row][targetSlot.col]; // Determine target positions for animation var pos1 = getSlotPosition(targetSlot.row, targetSlot.col, true); var pos2; tween(selectedCard, { x: pos1.x, y: pos1.y }, { duration: 200, easing: tween.quadOut }); // Update selectedCard state selectedCard.isInPlay = true; if (originalCardPosition.area === 'hand') { selectedCard.resetInvestment(); // Card moved from hand to play area gameState.playerHand[originalCardPosition.index] = null; uiLayer.removeChild(selectedCard); gameLayer.addChild(selectedCard); } gameState.playerPlayArea[targetSlot.row][targetSlot.col] = selectedCard; // Determine target for swappedCard and animate if (originalCardPosition.area === 'player') { pos2 = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true); swappedCard.isInPlay = true; gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = swappedCard; } else { // original was hand, so swapped card goes to hand var origHandIndex = originalCardPosition.index; var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartX = (SCREEN_WIDTH - handWidth) / 2; pos2 = { x: handStartX + origHandIndex * DEAL_SLOT_WIDTH + origHandIndex * 30 + DEAL_SLOT_WIDTH / 2, y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2 }; swappedCard.isInPlay = false; gameLayer.removeChild(swappedCard); uiLayer.addChild(swappedCard); gameState.playerHand[origHandIndex] = swappedCard; } tween(swappedCard, { x: pos2.x, y: pos2.y }, { duration: 200, easing: tween.quadOut }); selectedCard.calculateStats(); swappedCard.calculateStats(); } } } else if (targetSlot.area === 'hand') { var existingCard = gameState.playerHand[targetSlot.index]; if (existingCard && existingCard !== selectedCard && selectedCard.canMergeWith(existingCard)) { // Block merging with locked cards if (existingCard.isLocked) { createFloatingText('Cannot merge with locked card!', existingCard.x, existingCard.y, 0xff0000, 40); returnCardToOriginalPosition(); // Clear green outlines and reset UI for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { card.greenOutline.visible = false; } } } for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card) { card.greenOutline.visible = false; } } selectedCard = null; originalCardPosition = null; updateUI(); return; } // Merge in hand var oldLevel = existingCard.level; var mergedCard = selectedCard.mergeWith(existingCard); if (mergedCard) { // Remove old cards var handIndex1 = gameState.playerHand.indexOf(selectedCard); if (handIndex1 !== -1) { uiLayer.removeChild(selectedCard); gameState.playerHand[handIndex1] = null; } else { gameLayer.removeChild(selectedCard); } var handIndex2 = gameState.playerHand.indexOf(existingCard); if (handIndex2 !== -1) { uiLayer.removeChild(existingCard); gameState.playerHand[handIndex2] = null; } // Place merged card in hand var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px var handStartX = (SCREEN_WIDTH - handWidth) / 2; var slotX = handStartX + targetSlot.index * DEAL_SLOT_WIDTH + targetSlot.index * 30 + DEAL_SLOT_WIDTH / 2; var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; mergedCard.activate(slotX, slotY, false, true); uiLayer.addChild(mergedCard); gameState.playerHand[targetSlot.index] = mergedCard; // Merge animation mergedCard.alpha = 0; mergedCard.scaleX = mergedCard.scaleY = 2; tween(mergedCard, { alpha: 1, scaleX: 1, scaleY: 1 }, { duration: 300, easing: tween.elasticOut }); LK.getSound('levelUp').play(); createFloatingText('+Level Up!', mergedCard.x, mergedCard.y - 50, 0x00ff00, 60); var damageBefore = Math.floor(10 * Math.pow(1.6, oldLevel - 1)); var fireRateBefore = Math.max(15, Math.floor(60 / Math.pow(1.2, oldLevel - 1))); var damageAfter = Math.floor(10 * Math.pow(1.6, mergedCard.level - 1)); var fireRateAfter = Math.max(15, Math.floor(60 / Math.pow(1.2, mergedCard.level - 1))); var damageIncrease = damageBefore > 0 ? Math.round((damageAfter / damageBefore - 1) * 100) : 0; var fireRateIncrease = fireRateAfter > 0 && fireRateAfter < fireRateBefore ? Math.round((fireRateBefore / fireRateAfter - 1) * 100) : 0; var statText = ""; if (damageBefore > 0) { var dmgMult = (damageAfter / damageBefore).toFixed(2); statText = "Dmg x" + dmgMult; } createFloatingText(statText, mergedCard.x, mergedCard.y + 55, 0x00ff00, 35); } else { returnCardToOriginalPosition(); } } else if (existingCard && existingCard !== selectedCard) { // Cannot merge, so swap with animation var swappedCard = gameState.playerHand[targetSlot.index]; // Get target positions var targetHandIndex = targetSlot.index; var handWidth1 = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartX1 = (SCREEN_WIDTH - handWidth1) / 2; var pos1 = { x: handStartX1 + targetHandIndex * DEAL_SLOT_WIDTH + targetHandIndex * 30 + DEAL_SLOT_WIDTH / 2, y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2 }; var pos2; // Animate selectedCard tween(selectedCard, { x: pos1.x, y: pos1.y }, { duration: 200, easing: tween.quadOut }); // Update selectedCard state selectedCard.isInPlay = false; // It's going to a hand slot if (originalCardPosition.area === 'player') { selectedCard.resetInvestment(); // Card moved from play area to hand - should not happen here, but for safety. Investment stops due to isInPlay=false gameLayer.removeChild(selectedCard); uiLayer.addChild(selectedCard); } else { // This is a hand-to-hand swap, timer should not be reset. gameState.playerHand[originalCardPosition.index] = null; } gameState.playerHand[targetHandIndex] = selectedCard; // Update swappedCard state if (originalCardPosition.area === 'player') { pos2 = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true); swappedCard.isInPlay = true; uiLayer.removeChild(swappedCard); gameLayer.addChild(swappedCard); gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = swappedCard; } else { // original was hand var origHandIndex = originalCardPosition.index; var handWidth2 = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartX2 = (SCREEN_WIDTH - handWidth2) / 2; pos2 = { x: handStartX2 + origHandIndex * DEAL_SLOT_WIDTH + origHandIndex * 30 + DEAL_SLOT_WIDTH / 2, y: PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2 }; swappedCard.isInPlay = false; gameState.playerHand[origHandIndex] = swappedCard; } tween(swappedCard, { x: pos2.x, y: pos2.y }, { duration: 200, easing: tween.quadOut }); selectedCard.calculateStats(); swappedCard.calculateStats(); } else { returnCardToOriginalPosition(); } } } else { returnCardToOriginalPosition(); } selectedCard = null; originalCardPosition = null; applyHandBonuses(); } }; function returnCardToOriginalPosition() { if (!selectedCard || !originalCardPosition) { return; } if (originalCardPosition.area === 'hand') { // Return to hand slot var handIndex = originalCardPosition.index; var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; // 5 slots + 4 gaps of 30px var handStartX = (SCREEN_WIDTH - handWidth) / 2; var slotX = handStartX + handIndex * DEAL_SLOT_WIDTH + handIndex * 30 + DEAL_SLOT_WIDTH / 2; var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; selectedCard.x = slotX; selectedCard.y = slotY; gameState.playerHand[handIndex] = selectedCard; } else if (originalCardPosition.area === 'player') { // Return to play area slot var pos = getSlotPosition(originalCardPosition.row, originalCardPosition.col, true); selectedCard.x = pos.x; selectedCard.y = pos.y; gameState.playerPlayArea[originalCardPosition.row][originalCardPosition.col] = selectedCard; } } function createOutlinedText(text, options, outlineColor, outlineThickness) { var container = new Container(); // Create the outline by placing shadow texts in 8 directions var offsets = [[-outlineThickness, -outlineThickness], // top-left [0, -outlineThickness], // top [outlineThickness, -outlineThickness], // top-right [outlineThickness, 0], // right [outlineThickness, outlineThickness], // bottom-right [0, outlineThickness], // bottom [-outlineThickness, outlineThickness], // bottom-left [-outlineThickness, 0] // left ]; // Create outline shadows offsets.forEach(function (offset) { var shadowText = new Text2(text, { size: options.size, fill: outlineColor, weight: options.weight // Don't use stroke properties for shadows }); shadowText.anchor.set(options.anchor ? options.anchor[0] : 0.5, options.anchor ? options.anchor[1] : 0.5); shadowText.x = offset[0]; shadowText.y = offset[1]; container.addChild(shadowText); }); // Create the main text on top var mainText = new Text2(text, { size: options.size, fill: options.fill, weight: options.weight }); mainText.anchor.set(options.anchor ? options.anchor[0] : 0.5, options.anchor ? options.anchor[1] : 0.5); container.addChild(mainText); // Add a setText method to the container for easy updates container.setText = function (newText) { // Update all shadow texts for (var i = 0; i < offsets.length; i++) { container.children[i].setText(newText); } // Update main text mainText.setText(newText); }; return container; } function createFloatingText(text, x, y, color, size) { var textOptions = { size: size || 40, fill: color || 0xffffff, weight: 800, anchor: [0.5, 0.5] }; var outlineColor = 0x000000; var outlineThickness = 3; // Add black outline for green level up text if (color === 0x00ff00) { outlineThickness = 6; textOptions.size = (size || 40) * 1.5; // Make it smaller } // Make poker damage text white with black outline, bigger, and animate faster if (color === 0xff0000 && text.startsWith('-')) { textOptions.fill = 0xffffff; // White color outlineColor = 0x000000; // Black outline outlineThickness = 6; // Black outline thickness textOptions.size = (size || 40) * 1.5; // Make it 50% bigger (increased from 30%) } var floatingText = createOutlinedText(text, textOptions, outlineColor, outlineThickness); floatingText.x = x; floatingText.y = y; floatingText.alpha = 1; uiLayer.addChild(floatingText); // Use larger animation for important messages var animationDistance = size && size > 40 ? 120 : 80; var animationDuration = size && size > 40 ? 2000 : 1500; // Make poker damage text animate faster if (color === 0xff0000 && text.startsWith('-')) { animationDuration = 800; // Much faster animation } // Level up text fades faster now if (color === 0x00ff00) { animationDuration = 1000; } // Split animation into two parts var floatDuration = animationDuration * 0.6; // 60% of time for floating up var fadeDuration = animationDuration * 0.4; // 40% of time for fading out // First part: Float upwards with no alpha change tween(floatingText, { y: y - animationDistance * 0.7 // Float up 70% of the distance }, { duration: floatDuration, easing: tween.quadOut, onFinish: function onFinish() { // Second part: Continue floating while fading out tween(floatingText, { y: y - animationDistance, alpha: 0 }, { duration: fadeDuration, easing: tween.quadOut, onFinish: function onFinish() { uiLayer.removeChild(floatingText); } }); } }); } function createExplosion(x, y, color) { var numParticles = 5; for (var i = 0; i < numParticles; i++) { var particle = LK.getAsset('explosionParticle', { anchorX: 0.5, anchorY: 0.5 }); particle.x = x; particle.y = y; particle.tint = color; particle.scale.set(0.5 + Math.random() * 0.5); var angle = Math.random() * Math.PI * 2; var distance = Math.random() * 50 + 20; var duration = 500 + Math.random() * 500; var targetX = x + Math.cos(angle) * distance; var targetY = y + Math.sin(angle) * distance; gameLayer.addChild(particle); tween(particle, { x: targetX, y: targetY, alpha: 0 }, { duration: duration, easing: tween.quadOut, onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(particle) }); } } /**** * Main Game Loop ****/ game.update = function () { // Update tutorial system if (TutorialSystem.isActive) { TutorialSystem.update(); } // Only run game logic when in playing state if (currentGameState !== 'playing') { if (currentGameState === 'start' && backgroundSuits.length > 0) { var speed = 0.5; var spacing = 400; // Calculate pattern dimensions var numCols = Math.ceil(SCREEN_WIDTH / spacing) + 3; var numRows = Math.ceil(SCREEN_HEIGHT / spacing) + 3; var patternWidth = numCols * spacing; var patternHeight = numRows * spacing; for (var i = 0; i < backgroundSuits.length; i++) { var suit = backgroundSuits[i]; // Move diagonally suit.x += speed; suit.y += speed; // Wrap horizontally if (suit.x > SCREEN_WIDTH + spacing * 1.5) { suit.x -= patternWidth; } // Wrap vertically if (suit.y > SCREEN_HEIGHT + spacing * 1.5) { suit.y -= patternHeight; } } } return; } if (!gameReady) { return; } // Update wave spawning system WaveSystem.update(); // Update active chips for (var i = activePlayerChips.length - 1; i >= 0; i--) { activePlayerChips[i].update(); } for (var i = activeAIChips.length - 1; i >= 0; i--) { activeAIChips[i].update(); } // Tutorial Assistance: If an enemy on the player's side gets halfway, destroy it. if (TutorialSystem.isActive) { var assistancePathThreshold = 50; // Halfway down the path for (var i = activePlayerChips.length - 1; i >= 0; i--) { var chip = activePlayerChips[i]; if (chip.pathProgress > assistancePathThreshold) { if (!TutorialSystem.assistanceMessageShown) { TutorialSystem.assistanceMessageShown = true; var message = "It looks like you could use some help! I've taken care of that enemy for you.\n\nThis helping hand is only available in the tutorial. Try adding more cards, merging them, and aiming for better poker hands to get stronger!"; TutorialSystem.showMessage(message, null, function () { TutorialSystem.clearMessage(); }); } // Instantly destroy the chip to assist the player, preventing them from losing in the tutorial. chip.takeDamage(chip.health * 2); } } } // Update active mines for (var i = activeMines.length - 1; i >= 0; i--) { if (activeMines[i]) { activeMines[i].update(); } } // Update active bullets for (var i = activeBullets.length - 1; i >= 0; i--) { activeBullets[i].update(); } // Update cards in play for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { if (gameState.playerPlayArea[row][col]) { gameState.playerPlayArea[row][col].update(); } if (gameState.aiPlayArea[row][col]) { gameState.aiPlayArea[row][col].update(); } } } // Update AI AISystem.update(); // Check win/lose conditions // Update life displays while (gameState.playerLives < lastPlayerLives) { lastPlayerLives--; var heartToFade = playerLifeHearts[lastPlayerLives]; if (heartToFade) { tween(heartToFade, { alpha: 0.2 }, { duration: 500 }); } } while (gameState.aiLives < lastAiLives) { lastAiLives--; var heartToFade = aiLifeHearts[lastAiLives]; if (heartToFade) { tween(heartToFade, { alpha: 0.2 }, { duration: 500 }); } } if (gameMode === 'coop') { if (gameState.playerLives <= 0) { showCoopResultsScreen(); } } else { if (gameState.playerLives <= 0) { showGameOver(false); } else if (gameState.aiLives <= 0) { showGameOver(true); } } updateUI(); }; /**** * Boss System ****/ var BossSystem = { bossTypes: [{ id: 'scramble', name: 'Scramble Boss', description: 'Randomizes your cards', chipAsset: 'bossChipScramble' }, { id: 'lock', name: 'Lock Boss', description: 'Locks your cards', chipAsset: 'bossChipLock' }, { id: 'snake', name: 'Snake Boss', description: 'Creates a train of segments', chipAsset: 'bossChipRain' }, { id: 'immune', name: 'Immune Boss', description: 'Cycles through suit immunities', chipAsset: 'bossChipImmune' }, { id: 'speed', name: 'Speed Boss', description: 'Accelerates over time', chipAsset: 'bossChipSpeed' }], // NEW: Store boss selections for future waves selectedBosses: {}, // Will store: { 10: bossType, 20: bossType, etc. } currentBossType: null, rouletteContainer: null, // NEW: Get the next main boss wave number getNextBossWave: function getNextBossWave() { var currentWave = WaveSystem.waveNumber; // Find the next boss wave (either mini-boss at x5 or main boss at x0) var nextBossWave; if (currentWave % 10 === 0) { // Just finished a main boss, next boss is at +5 (mini-boss) nextBossWave = currentWave + 5; } else if (currentWave % 10 === 5) { // Just finished a mini-boss, next boss is at +5 (main boss) nextBossWave = currentWave + 5; } else { // Find next boss wave (either mini or main) var remainder = currentWave % 10; if (remainder < 5) { nextBossWave = currentWave + (5 - remainder); // Next mini-boss } else { nextBossWave = currentWave + (10 - remainder); // Next main boss } } return nextBossWave; }, selectRandomBossType: function selectRandomBossType() { return this.bossTypes[Math.floor(Math.random() * this.bossTypes.length)]; }, // MODIFIED: Now stores boss for future wave showBossRoulette: function showBossRoulette(callback) { // ADD THIS LINE - Play roulette sound when animation starts LK.getSound('roulette').play(); // Pause the game during roulette var wasGameReady = typeof gameReady !== "undefined" ? gameReady : false; gameReady = false; // Play roulette sound effect at the start of the animation LK.getSound('roulette').play(); var nextBossWave = this.getNextBossWave(); // Determine if it's a mini-boss or main boss var isMiniBoss = nextBossWave % 10 === 5; var bossTypeText = isMiniBoss ? "MINI-BOSS" : "BOSS"; this.rouletteContainer = new Container(); uiLayer.addChild(this.rouletteContainer); // Dark overlay var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.8; this.rouletteContainer.addChild(bg); // Title - show whether it's mini-boss or main boss var title = new Text2(bossTypeText + ' INCOMING', { size: 120, fill: isMiniBoss ? 0xff8800 : 0xff0000, // Orange for mini-boss, red for main boss weight: 'bold', stroke: 0x000000, strokeThickness: 6 }); title.anchor.set(0.5, 0.5); title.x = SCREEN_WIDTH / 2; title.y = 400; this.rouletteContainer.addChild(title); // Horizontal scrolling container var scrollContainer = new Container(); scrollContainer.x = 0; scrollContainer.y = SCREEN_HEIGHT / 2; this.rouletteContainer.addChild(scrollContainer); // Create a long row of boss chips var chipSpacing = 300; var totalChips = 50; var bossChips = []; // Determine which boss will be selected var finalBossType = this.selectRandomBossType(); var finalIndex = this.bossTypes.indexOf(finalBossType); // Calculate positioning var centerX = SCREEN_WIDTH / 2; var finalChipIndex = Math.floor(totalChips * 0.7); // Create the scrolling chips for (var i = 0; i < totalChips; i++) { var chipContainer = new Container(); chipContainer.x = i * chipSpacing; chipContainer.y = 0; scrollContainer.addChild(chipContainer); // Determine which boss type this chip represents var bossTypeIndex; if (i === finalChipIndex) { bossTypeIndex = finalIndex; } else { bossTypeIndex = i % this.bossTypes.length; // Sequential repeating order instead of random } var bossType = this.bossTypes[bossTypeIndex]; // Boss chip graphic var chip = LK.getAsset(bossType.chipAsset, { anchorX: 0.5, anchorY: 0.5 }); chip.scale.set(2); chipContainer.addChild(chip); // Store reference to the final chip if (i === finalChipIndex) { chipContainer.isFinalChip = true; chipContainer.bossType = bossType; } bossChips.push(chipContainer); } // Start the container off-screen to the left scrollContainer.x = -SCREEN_WIDTH; // Calculate final position so the selected chip ends up in center var finalScrollX = centerX - finalChipIndex * chipSpacing; // Animate the scrolling var scrollDuration = 1500; var self = this; tween(scrollContainer, { x: finalScrollX }, { duration: scrollDuration, easing: tween.quadOut, onFinish: function onFinish() { // Find the final chip var selectedChip = null; for (var i = 0; i < bossChips.length; i++) { if (bossChips[i].isFinalChip) { selectedChip = bossChips[i]; break; } } if (selectedChip) { // Fade out all other chips for (var i = 0; i < bossChips.length; i++) { if (!bossChips[i].isFinalChip) { tween(bossChips[i], { alpha: 0 }, { duration: 500 }); } } // Scale up and highlight the selected chip var selectedBossChip = selectedChip.children[0]; LK.getSound('levelUp').play(); tween(selectedChip, { scaleX: 2.0, // Scale up more dramatically scaleY: 2.0 }, { duration: 800, easing: tween.elasticOut, onFinish: function onFinish() { // Change title to show wave number and type title.setText('WAVE ' + nextBossWave + ' ' + bossTypeText); title.fill = 0xffff00; // Change to yellow // Add the boss name text below the chip var nameText = new Text2(selectedChip.bossType.name.toUpperCase(), { size: 100, fill: 0xff0000, weight: 'bold', stroke: 0x000000, strokeThickness: 6 }); nameText.anchor.set(0.5, 0.5); nameText.y = 200; nameText.alpha = 0; selectedChip.addChild(nameText); // Add description text var descText = new Text2(selectedChip.bossType.description, { size: 60, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 4 }); descText.anchor.set(0.5, 0.5); descText.y = 320; descText.alpha = 0; selectedChip.addChild(descText); // Fade in the texts tween(nameText, { alpha: 1 }, { duration: 500 }); tween(descText, { alpha: 1 }, { duration: 500, delay: 200, onFinish: function onFinish() { // Store the selected boss self.selectedBosses[nextBossWave] = finalBossType; self.currentBossType = finalBossType; // Wait then fade out and continue LK.setTimeout(function () { tween(self.rouletteContainer, { alpha: 0 }, { duration: 500, onFinish: function onFinish() { if (self.rouletteContainer && self.rouletteContainer.parent) { self.rouletteContainer.parent.removeChild(self.rouletteContainer); } self.rouletteContainer = null; // Restore game state and call the callback gameReady = wasGameReady; callback(); } }); }, 2000); } }); } }); } } }); }, /* showBossSelection: function showBossSelection(bossType, waveNumber, callback) { // This function is no longer needed } */ // NEW: Get the boss type for a specific wave getBossTypeForWave: function getBossTypeForWave(waveNumber) { return this.selectedBosses[waveNumber] || null; } }; /**** * Game Over ****/ function resetGameAndReturnToMenu() { // This function now encapsulates all the logic to reset the game to its initial state. // 1. Remove all dynamically created game objects from the stage. [].concat(_toConsumableArray(activePlayerChips), _toConsumableArray(activeAIChips), _toConsumableArray(activeBullets), _toConsumableArray(activeMines)).forEach(function (obj) { if (obj.parent) { obj.parent.removeChild(obj); } }); for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { var pCard = gameState.playerPlayArea[r][c]; if (pCard && pCard.parent) { pCard.parent.removeChild(pCard); } var aCard = gameState.aiPlayArea[r][c]; if (aCard && aCard.parent) { aCard.parent.removeChild(aCard); } } } gameState.playerHand.forEach(function (card) { if (card && card.parent) { card.parent.removeChild(card); } }); playerLifeHearts.forEach(function (h) { if (h.parent) { h.parent.removeChild(h); } }); aiLifeHearts.forEach(function (h) { if (h.parent) { h.parent.removeChild(h); } }); playerHandNameTexts.forEach(function (t) { if (t && t.parent) { t.parent.removeChild(t); } }); if (opponentNameText && opponentNameText.parent) { opponentNameText.parent.removeChild(opponentNameText); } if (playerNameText && playerNameText.parent) { playerNameText.parent.removeChild(playerNameText); } slotIndicators.forEach(function (indicator) { if (indicator.parent) { indicator.parent.removeChild(indicator); } }); slotIndicators = []; // 2. Clear all tracking arrays. activePlayerChips = []; activeAIChips = []; activeBullets = []; activeMines = []; playerLifeHearts = []; aiLifeHearts = []; playerHandNameTexts = []; opponentNameText = null; playerNameText = null; // 3. Reset game state variables. gameState.playerChips = 200; gameState.aiChips = 200; gameState.playerLives = 3; gameState.aiLives = 3; gameState.isPlayerTurn = true; gameState.dealCost = 25; // Reset to starting cost of 25 gameState.dealCount = 0; // Reset to starting count gameState.playerDeck = []; gameState.playerHand = []; gameState.playerPlayArea = []; gameState.aiDeck = []; gameState.aiPlayArea = []; // 4. Reset game systems. WaveSystem.waveNumber = 1; WaveSystem.waveTimer = 0; WaveSystem.bossSpawned = false; WaveSystem.playerBossDefeated = false; WaveSystem.aiBossDefeated = false; AISystem.thinkTimer = 0; // Add these lines to reset boss system: BossSystem.selectedBosses = {}; BossSystem.currentBossType = null; if (BossSystem.rouletteContainer && BossSystem.rouletteContainer.parent) { BossSystem.rouletteContainer.parent.removeChild(BossSystem.rouletteContainer); BossSystem.rouletteContainer = null; } // 5. Reset other global variables. lastPlayerLives = 0; lastAiLives = 0; selectedCard = null; isDragging = false; originalCardPosition = null; gameReady = false; // 6. Hide persistent UI. gameElements.forEach(function (el) { el.visible = false; }); background.visible = false; coopBackground.visible = false; // 7. Return to the main menu. createStartScreen(true); } function showResultsScreen() { var resultsContainer = new Container(); uiLayer.addChild(resultsContainer); // Dark overlay var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.7; resultsContainer.addChild(bg); var title = new Text2('VICTORY!', { size: 180, fill: 0xffd700, weight: 'bold', stroke: 0x000000, strokeThickness: 10 }); title.anchor.set(0.5, 0.5); title.x = SCREEN_WIDTH / 2; title.y = 300; resultsContainer.addChild(title); // Calculate Battle Rating var oldRating = storage.battleRating; var waveBonus = (WaveSystem.waveNumber - 1) * 5; var livesBonus = (gameState.playerLives - gameState.aiLives) * 10; var winBonus = 25; var ratingChange = waveBonus + livesBonus + winBonus; ratingChange = Math.max(5, ratingChange); // Minimum 5 rating gain on win var newRating = oldRating + ratingChange; storage.battleRating = newRating; // Display Rating Calculation var yPos = 600; var yStep = 120; var ySubStep = 90; var oldRatingText = new Text2('Previous Rating: ' + oldRating, { size: 80, fill: 0xffffff, weight: 'bold' }); oldRatingText.anchor.set(0.5, 0.5); oldRatingText.x = SCREEN_WIDTH / 2; oldRatingText.y = yPos; resultsContainer.addChild(oldRatingText); yPos += yStep; var waveBonusText = new Text2('Wave Bonus (Wave ' + WaveSystem.waveNumber + '): +' + waveBonus, { size: 70, fill: 0x88ff88, weight: 'normal' }); waveBonusText.anchor.set(0.5, 0.5); waveBonusText.x = SCREEN_WIDTH / 2; waveBonusText.y = yPos; resultsContainer.addChild(waveBonusText); yPos += ySubStep; var livesBonusText; if (livesBonus >= 0) { livesBonusText = new Text2('Performance Bonus: +' + livesBonus, { size: 70, fill: 0x88ff88, weight: 'normal' }); } else { livesBonusText = new Text2('Performance Bonus: ' + livesBonus, { size: 70, fill: 0xff8888, weight: 'normal' }); } livesBonusText.anchor.set(0.5, 0.5); livesBonusText.x = SCREEN_WIDTH / 2; livesBonusText.y = yPos; resultsContainer.addChild(livesBonusText); yPos += ySubStep; var winBonusText = new Text2('Victory Bonus: +' + winBonus, { size: 70, fill: 0x88ff88, weight: 'normal' }); winBonusText.anchor.set(0.5, 0.5); winBonusText.x = SCREEN_WIDTH / 2; winBonusText.y = yPos; resultsContainer.addChild(winBonusText); yPos += yStep + 20; var lineBreak = LK.getAsset('lineBreak', { anchorX: 0.5, anchorY: 0.5 }); lineBreak.x = SCREEN_WIDTH / 2; lineBreak.y = yPos; lineBreak.scale.set(0.8); resultsContainer.addChild(lineBreak); yPos += yStep; var newRatingText = new Text2('New Rating: ' + newRating, { size: 100, fill: 0xffffff, weight: 'bold' }); newRatingText.anchor.set(0.5, 0.5); var battleRatingIcon = LK.getAsset('battleRatingIcon', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.8, scaleY: 0.8 }); var totalWidth = battleRatingIcon.width + 15 + newRatingText.width; battleRatingIcon.x = SCREEN_WIDTH / 2 - totalWidth / 2 + battleRatingIcon.width / 2; battleRatingIcon.y = yPos; newRatingText.x = battleRatingIcon.x + battleRatingIcon.width / 2 + 15 + newRatingText.width / 2; newRatingText.y = yPos; resultsContainer.addChild(battleRatingIcon); resultsContainer.addChild(newRatingText); // Create chest container var chestContainer = new Container(); chestContainer.x = SCREEN_WIDTH / 2; chestContainer.y = 1600; resultsContainer.addChild(chestContainer); // Add small chest var chest = LK.getAsset('smallChest', { anchorX: 0.5, anchorY: 0.5 }); chest.scale.set(0.01); chestContainer.addChild(chest); // Tap to open text var tapToOpenText = new Text2('Tap to open', { size: 60, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 4 }); tapToOpenText.anchor.set(0.5, 0.5); tapToOpenText.y = 120; tapToOpenText.visible = false; chestContainer.addChild(tapToOpenText); // Make chest interactive chestContainer.interactive = true; chestContainer.hitArea = new Rectangle(-150, -150, 300, 300); var chestOpened = false; var moneyReward = 0; // Animate chest in with bounce tween(chest, { scaleX: 1.5, scaleY: 1.5 }, { duration: 800, easing: tween.elasticOut, onFinish: function onFinish() { tapToOpenText.visible = true; // Pulse animation for tap to open text function pulseText() { if (!tapToOpenText.parent || chestOpened) { return; } tween(tapToOpenText, { scaleX: 1.1, scaleY: 1.1 }, { duration: 600, easing: tween.easeInOut, onFinish: function onFinish() { if (!tapToOpenText.parent || chestOpened) { return; } tween(tapToOpenText, { scaleX: 1, scaleY: 1 }, { duration: 600, easing: tween.easeInOut, onFinish: pulseText }); } }); } pulseText(); } }); chestContainer.down = function () { if (chestOpened) { return; } chestOpened = true; tapToOpenText.visible = false; // Wiggle animation tween(chest, { rotation: -0.1 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { tween(chest, { rotation: 0.1 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { tween(chest, { rotation: 0 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { // Flash screen white LK.effects.flashScreen(0xffffff, 300); // Replace with open chest chestContainer.removeChild(chest); var openChest = LK.getAsset('smallChestOpen', { anchorX: 0.5, anchorY: 0.5 }); openChest.scale.set(1.5); chestContainer.addChild(openChest); // Generate random money reward moneyReward = Math.floor(Math.random() * 151) + 100; // 100-250 var startMoney = storage.money; var targetMoney = startMoney + moneyReward; // Money text animation var moneyText = new Text2('$' + moneyReward, { size: 150, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 8 }); moneyText.anchor.set(0.5, 0.5); moneyText.y = -50; moneyText.scale.set(0.1); moneyText.alpha = 0; chestContainer.addChild(moneyText); // Animate scale property directly to avoid potential proxy issues with Text2 objects tween(moneyText.scale, { x: 1, y: 1 }, { duration: 500, easing: tween.backOut }); // Animate other properties on the text object itself tween(moneyText, { alpha: 1, y: -100 }, { duration: 500, easing: tween.backOut, onFinish: function onFinish() { // Rolling number animation var rollDuration = 1000; var startTime = Date.now(); var rollInterval = LK.setInterval(function () { var elapsed = Date.now() - startTime; var progress = Math.min(elapsed / rollDuration, 1); var easedProgress = 1 - Math.pow(1 - progress, 3); // Cubic ease out var currentValue = Math.floor(startMoney + moneyReward * easedProgress); storage.money = currentValue; if (progress >= 1) { LK.clearInterval(rollInterval); storage.money = targetMoney; // Show tap to continue var tapToContinueText = new Text2('Tap to continue', { size: 70, fill: 0x000000, weight: 'bold' }); tapToContinueText.anchor.set(0.5, 0.5); tapToContinueText.y = 200; chestContainer.addChild(tapToContinueText); // Update chest interaction chestContainer.down = function () { tween(resultsContainer, { alpha: 0 }, { duration: 300, onFinish: function onFinish() { if (resultsContainer.parent) { resultsContainer.parent.removeChild(resultsContainer); } resetGameAndReturnToMenu(); } }); }; } }, 16); // ~60fps } }); } }); } }); } }); }; // Animate the screen in resultsContainer.alpha = 0; tween(resultsContainer, { alpha: 1 }, { duration: 500 }); } function showGameOver(playerWon) { // Stop all game action by changing the state. The main update loop will halt. LK.stopMusic(); currentGameState = 'gameover_transition'; // NEW: Immediately stop all active game objects and create particle effects stopAllActionWithParticles(); // Animate the victory or defeat logo. var logoAssetId = playerWon ? 'victoryLogo' : 'defeatLogo'; var endLogo = LK.getAsset(logoAssetId, { anchorX: 0.5, anchorY: 0.5, x: SCREEN_WIDTH / 2, y: SCREEN_HEIGHT / 2 }); endLogo.scale.set(0.01); uiLayer.addChild(endLogo); // Play victory sound when the victory logo is shown if (playerWon) { LK.getSound('victory').play(); } tween(endLogo, { scaleX: 1, scaleY: 1 }, { duration: 1200, easing: tween.elasticOut, onFinish: function onFinish() { // After the animation, wait a moment, then transition. LK.setTimeout(function () { if (endLogo.parent) { endLogo.parent.removeChild(endLogo); } if (playerWon) { if (TutorialSystem.isActive) { // In tutorial, we skip the normal results and go straight to reset/menu to continue tutorial resetGameAndReturnToMenu(); } else { showResultsScreen(); } } else { if (TutorialSystem.isActive) { // Player lost tutorial, let them retry from beginning storage.tutorialCompleted = false; } resetGameAndReturnToMenu(); } }, 1500); } }); } function showCoopResultsScreen() { LK.stopMusic(); currentGameState = 'gameover_transition'; // NEW: Immediately stop all active game objects and create particle effects stopAllActionWithParticles(); var resultsContainer = new Container(); uiLayer.addChild(resultsContainer); // ... rest of the function remains the same // Dark overlay var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.7; resultsContainer.addChild(bg); var title = new Text2('RESULTS', { size: 180, fill: 0xffd700, weight: 'bold', stroke: 0x000000, strokeThickness: 10 }); title.anchor.set(0.5, 0.5); title.x = SCREEN_WIDTH / 2; title.y = 300; resultsContainer.addChild(title); // Wave Reached var waveText = new Text2('Wave Reached: ' + WaveSystem.waveNumber, { size: 80, fill: 0xffffff, weight: 'bold' }); waveText.anchor.set(0.5, 0.5); waveText.x = SCREEN_WIDTH / 2; waveText.y = 600; resultsContainer.addChild(waveText); if (WaveSystem.waveNumber > (storage.coopHighestWave || 0)) { storage.coopHighestWave = WaveSystem.waveNumber; } // Damage percentages var totalDamage = playerTotalDamage + aiTotalDamage; var playerPercent = totalDamage > 0 ? Math.round(playerTotalDamage / totalDamage * 100) : 0; var aiPercent = totalDamage > 0 ? 100 - playerPercent : 0; var playerDamageText = new Text2('Player Damage: ' + playerPercent + '%', { size: 70, fill: 0x88ff88, weight: 'normal' }); playerDamageText.anchor.set(0.5, 0.5); playerDamageText.x = SCREEN_WIDTH / 2; playerDamageText.y = 750; resultsContainer.addChild(playerDamageText); var aiDamageText = new Text2('AI Damage: ' + aiPercent + '%', { size: 70, fill: 0xff8888, weight: 'normal' }); aiDamageText.anchor.set(0.5, 0.5); aiDamageText.x = SCREEN_WIDTH / 2; aiDamageText.y = 850; resultsContainer.addChild(aiDamageText); // Create chest container var chestContainer = new Container(); chestContainer.x = SCREEN_WIDTH / 2; chestContainer.y = 1600; resultsContainer.addChild(chestContainer); // Add small chest var chest = LK.getAsset('smallChest', { anchorX: 0.5, anchorY: 0.5 }); chest.scale.set(0.01); chestContainer.addChild(chest); // Tap to open text var tapToOpenText = new Text2('Tap to open', { size: 60, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 4 }); tapToOpenText.anchor.set(0.5, 0.5); tapToOpenText.y = 120; tapToOpenText.visible = false; chestContainer.addChild(tapToOpenText); // Make chest interactive chestContainer.interactive = true; chestContainer.hitArea = new Rectangle(-150, -150, 300, 300); var chestOpened = false; // Animate chest in with bounce tween(chest, { scaleX: 1.5, scaleY: 1.5 }, { duration: 800, easing: tween.elasticOut, onFinish: function onFinish() { tapToOpenText.visible = true; // Pulse animation for tap to open text function pulseText() { if (!tapToOpenText.parent || chestOpened) { return; } tween(tapToOpenText, { scaleX: 1.1, scaleY: 1.1 }, { duration: 600, easing: tween.easeInOut, onFinish: function onFinish() { if (!tapToOpenText.parent || chestOpened) { return; } tween(tapToOpenText, { scaleX: 1, scaleY: 1 }, { duration: 600, easing: tween.easeInOut, onFinish: pulseText }); } }); } pulseText(); } }); chestContainer.down = function () { if (chestOpened) { return; } chestOpened = true; tapToOpenText.visible = false; // Wiggle animation tween(chest, { rotation: -0.1 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { tween(chest, { rotation: 0.1 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { tween(chest, { rotation: 0 }, { duration: 100, easing: tween.linear, onFinish: function onFinish() { // Flash screen white LK.effects.flashScreen(0xffffff, 300); // Replace with open chest chestContainer.removeChild(chest); var openChest = LK.getAsset('smallChestOpen', { anchorX: 0.5, anchorY: 0.5 }); openChest.scale.set(1.5); chestContainer.addChild(openChest); // Reward calculation var moneyReward = Math.floor(WaveSystem.waveNumber * 5 + playerPercent); var startMoney = storage.money; var targetMoney = startMoney + moneyReward; // Money text animation var moneyText = new Text2('$' + moneyReward, { size: 150, fill: 0xffd700, weight: 'bold', stroke: 0x000000, strokeThickness: 8 }); moneyText.anchor.set(0.5, 0.5); moneyText.y = -50; moneyText.scale.set(0.1); moneyText.alpha = 0; chestContainer.addChild(moneyText); // Animate scale property directly to avoid potential proxy issues with Text2 objects tween(moneyText.scale, { x: 1, y: 1 }, { duration: 500, easing: tween.backOut }); // Animate other properties on the text object itself tween(moneyText, { alpha: 1, y: -100 }, { duration: 500, easing: tween.backOut, onFinish: function onFinish() { // Rolling number animation var rollDuration = 1000; var startTime = Date.now(); var rollInterval = LK.setInterval(function () { var elapsed = Date.now() - startTime; var progress = Math.min(elapsed / rollDuration, 1); var easedProgress = 1 - Math.pow(1 - progress, 3); // Cubic ease out var currentValue = Math.floor(startMoney + moneyReward * easedProgress); storage.money = currentValue; if (progress >= 1) { LK.clearInterval(rollInterval); storage.money = targetMoney; // Show tap to continue var tapToContinueText = new Text2('Tap to continue', { size: 70, fill: 0x000000, weight: 'bold' }); tapToContinueText.anchor.set(0.5, 0.5); tapToContinueText.y = 200; chestContainer.addChild(tapToContinueText); // Update chest interaction chestContainer.down = function () { tween(resultsContainer, { alpha: 0 }, { duration: 300, onFinish: function onFinish() { if (resultsContainer.parent) { resultsContainer.parent.removeChild(resultsContainer); } resetGameAndReturnToMenu(); } }); }; } }, 16); // ~60fps } }); } }); } }); } }); }; // Animate the screen in resultsContainer.alpha = 0; tween(resultsContainer, { alpha: 1 }, { duration: 500 }); } // NEW: Function to stop all action and create particle effects function stopAllActionWithParticles() { // Create explosion particles for all remaining chips [].concat(activePlayerChips, activeAIChips).forEach(function (chip) { if (chip.active && chip.visible) { createChipExplosionParticles(chip.x, chip.y, chip.value); } chip.active = false; chip.visible = false; if (chip.parent) { chip.parent.removeChild(chip); } }); // Create explosion particles for bullets activeBullets.forEach(function (bullet) { if (bullet.active && bullet.visible) { var explosionColor = 0x333333; // Dark Grey for clubs/spades if (bullet.suit === 'hearts' || bullet.suit === 'diamonds') { explosionColor = 0xff0000; // Red for hearts/diamonds } createExplosion(bullet.x, bullet.y, explosionColor); } bullet.active = false; bullet.visible = false; if (bullet.parent) { bullet.parent.removeChild(bullet); } }); // Explode mines activeMines.forEach(function (mine) { if (mine.active && mine.visible) { createExplosion(mine.x, mine.y, 0xffa500); } mine.active = false; mine.visible = false; if (mine.parent) { mine.parent.removeChild(mine); } }); // Clear the arrays activePlayerChips.length = 0; activeAIChips.length = 0; activeBullets.length = 0; activeMines.length = 0; // Stop all card firing by marking them as not in play temporarily for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { if (gameState.playerPlayArea[row][col]) { gameState.playerPlayArea[row][col].isInPlay = false; } if (gameState.aiPlayArea[row][col]) { gameState.aiPlayArea[row][col].isInPlay = false; } } } } // NEW: Enhanced particle effect for chip explosions - celebratory version function createChipExplosionParticles(x, y, chipValue) { var numParticles = Math.min(20, 10 + chipValue); // More particles for celebration var chipColor = getChipColor(chipValue); for (var i = 0; i < numParticles; i++) { var particle = LK.getAsset('explosionParticle', { anchorX: 0.5, anchorY: 0.5 }); particle.x = x + (Math.random() - 0.5) * 40; // Start in a tight cluster particle.y = y + (Math.random() - 0.5) * 40; particle.tint = chipColor; particle.scale.set(0.4 + Math.random() * 0.8); // Launch particles upward in a celebratory fountain pattern var angle = -Math.PI / 2 + (Math.random() - 0.5) * Math.PI * 0.8; // Mostly upward, some spread var initialSpeed = 300 + Math.random() * 400; // Strong upward velocity var gravity = 600; // Gravity pulls them down var velocityX = Math.cos(angle) * initialSpeed; var velocityY = Math.sin(angle) * initialSpeed; // Negative Y is upward var duration = 2000 + Math.random() * 1000; // 2-3 seconds of flight time var targetX = x + velocityX * (duration / 1000); var targetY = y + velocityY * (duration / 1000) + 0.5 * gravity * Math.pow(duration / 1000, 2); // Ensure particles fall well off screen for full celebration effect if (targetY < SCREEN_HEIGHT + 200) { targetY = SCREEN_HEIGHT + 200 + Math.random() * 300; } gameLayer.addChild(particle); // Animate with celebratory spinning and fading tween(particle, { x: targetX, y: targetY, alpha: 0, rotation: Math.random() * Math.PI * 6 // Extra spinning for celebration }, { duration: duration, easing: tween.quadIn, // Natural gravity acceleration onFinish: function (p) { return function () { if (p.parent) { p.parent.removeChild(p); } }; }(particle) }); } } // NEW: Helper function to get chip color based on value function getChipColor(chipValue) { switch (chipValue) { case 1: return 0xffff00; // Yellow case 5: return 0xff0000; // Red case 10: return 0x00ff00; // Green case 25: return 0x0000ff; // Blue case 100: return 0x8000ff; // Purple default: return 0xffffff; // White for boss chips } } /**** * Utility Functions ****/ function formatNumberWithSuffix(number) { // ADD VALIDATION if (typeof number !== 'number' || isNaN(number) || number === Infinity || number === -Infinity) { console.warn("Invalid number for formatting:", number); return "0"; } var num = Math.round(number); if (num < 1000) { return num.toString(); } if (num < 1000000) { return (num / 1000).toFixed(1).replace(/\.0$/, '') + 'K'; } if (num < 1000000000) { return (num / 1000000).toFixed(1).replace(/\.0$/, '') + 'M'; } if (num < 1000000000000) { return (num / 1000000000).toFixed(1).replace(/\.0$/, '') + 'B'; } return (num / 1000000000000).toFixed(1).replace(/\.0$/, '') + 'T'; } function clearPlayerStorage() { storage.battleRating = 0; storage.money = 0; storage.equippedMods = null; storage.ownedMods = null; storage.randomModPrice = 300; storage.tutorialCompleted = false; // Also reset tutorial progress storage.coopHighestWave = 0; // Clear highest wave in coop // Also reset in-memory ModSystem if it's already initialized ModSystem.equippedMods = { hearts: null, diamonds: null, clubs: null, spades: null }; ModSystem.ownedMods = {}; createFloatingText("Player Storage Cleared!", SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 0xff0000, 100); } var TutorialSystem = { isActive: false, step: 0, overlay: null, messageBox: null, pulsingElement: null, isWaitingForTap: false, isWaitingForDrag: false, isWaitingForMerge: false, isWaitingForChipKill: false, isWaitingForJokerMerge: false, nextStepCallback: null, assistanceMessageShown: false, startScreenItems: {}, registerStartScreenElements: function registerStartScreenElements(items) { this.startScreenItems = items; }, start: function start() { this.isActive = true; this.step = 0; this.assistanceMessageShown = false; }, startInGameTutorial: function startInGameTutorial() { this.isActive = true; this.step = 1; this.assistanceMessageShown = false; dealInitialHand(); var self = this; LK.setTimeout(function () { self.advanceStep(); }, 1500); }, update: function update() { if (!this.isActive) { return; } if (this.isWaitingForDrag) { for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (gameState.playerPlayArea[r][c]) { this.isWaitingForDrag = false; this.advanceStep(); return; } } } } if (this.isWaitingForMerge) { var mergeCompleted = false; // Check play area for a leveled-up card for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { if (gameState.playerPlayArea[r][c] && gameState.playerPlayArea[r][c].level >= 2) { mergeCompleted = true; break; } } if (mergeCompleted) { break; } } // If not found in play area, check the hand if (!mergeCompleted) { for (var i = 0; i < gameState.playerHand.length; i++) { if (gameState.playerHand[i] && gameState.playerHand[i].level >= 2) { mergeCompleted = true; break; } } } if (mergeCompleted) { this.isWaitingForMerge = false; this.advanceStep(); return; } } if (this.isWaitingForJokerMerge) { var hasLevel3PlusCard = false; var level2PlusCardCount = 0; // Check play area for cards for (var r = 0; r < PLAY_AREA_ROWS; r++) { for (var c = 0; c < PLAY_AREA_COLS; c++) { var card = gameState.playerPlayArea[r][c]; if (card) { if (card.level >= 3) { hasLevel3PlusCard = true; } if (card.level >= 2) { level2PlusCardCount++; } } } } // Also check player's hand for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card) { if (card.level >= 3) { hasLevel3PlusCard = true; } if (card.level >= 2) { level2PlusCardCount++; } } } if (hasLevel3PlusCard || level2PlusCardCount >= 2) { this.isWaitingForJokerMerge = false; this.advanceStep(); return; } } if (this.isWaitingForChipKill) { if (activePlayerChips.length === 0) { this.isWaitingForChipKill = false; this.advanceStep(); } } }, advanceStep: function advanceStep() { this.clearMessage(); this.step++; switch (this.step) { case 2: this.explainDrag(); break; case 3: this.waitForDrag(); break; case 4: this.spawnFirstEnemy(); break; case 5: this.waitForKill(); break; case 6: this.explainMerge(); break; case 7: this.waitForMerge(); break; case 8: this.explainJoker(); break; case 9: this.instructJokerMerge(); break; case 10: this.startWaves(); break; case 11: this.explainPokerHands(); break; case 12: this.explainDiscard(); break; case 13: this.guaranteedWin(); break; case 14: this.guideToShop(); break; case 15: this.guideToRandomMod(); break; case 16: this.guideToModsScreen(); break; case 17: this.explainEquipMod(); break; case 18: this.completeTutorial(); break; } }, showMessage: function showMessage(text, elementToPulse, waitForTapCallback, isPostGame) { this.clearMessage(); this.overlay = new Container(); if (!isPostGame) { this.overlay.interactive = true; } this.overlay.hitArea = new Rectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); var bg = LK.getAsset('card', { width: SCREEN_WIDTH, height: SCREEN_HEIGHT, anchorX: 0, anchorY: 0 }); bg.tint = 0x000000; bg.alpha = 0.7; this.overlay.addChild(bg); uiLayer.addChild(this.overlay); this.messageBox = new Text2(text, { size: 70, fill: 0xffffff, weight: 'bold', stroke: 0x000000, strokeThickness: 5, align: 'center', wordWrap: true, wordWrapWidth: SCREEN_WIDTH - 200 }); this.messageBox.anchor.set(0.5, 0.5); this.messageBox.x = SCREEN_WIDTH / 2; this.messageBox.y = isPostGame ? SCREEN_HEIGHT - 650 : SCREEN_HEIGHT / 2; this.overlay.addChild(this.messageBox); if (elementToPulse) { this.pulsingElement = elementToPulse; if (elementToPulse.parent) { this.pulsingElementOriginalParent = elementToPulse.parent; this.overlay.addChild(elementToPulse); } this.pulseAnimation(elementToPulse); } if (waitForTapCallback) { this.isWaitingForTap = true; this.nextStepCallback = waitForTapCallback; this.overlay.down = function () { if (TutorialSystem.isWaitingForTap) { TutorialSystem.isWaitingForTap = false; TutorialSystem.nextStepCallback(); } }; } }, clearMessage: function clearMessage() { if (this.pulsingElement) { tween.stop(this.pulsingElement); if (this.pulsingElement.scale) { tween.stop(this.pulsingElement.scale); } if (this.pulsingElement.originalScaleX) { this.pulsingElement.scale.set(this.pulsingElement.originalScaleX, this.pulsingElement.originalScaleY); } if (this.pulsingElementOriginalParent) { this.pulsingElementOriginalParent.addChild(this.pulsingElement); this.pulsingElementOriginalParent = null; } this.pulsingElement = null; } if (this.overlay) { if (this.overlay.parent) { this.overlay.parent.removeChild(this.overlay); } this.overlay = null; this.messageBox = null; } }, pulseAnimation: function pulseAnimation(element) { var self = this; var originalScaleX = element.originalScaleX || (element.scale ? element.scale.x : 1); var originalScaleY = element.originalScaleY || (element.scale ? element.scale.y : 1); element.originalScaleX = originalScaleX; element.originalScaleY = originalScaleY; tween(element.scale, { x: originalScaleX * 1.1, y: originalScaleY * 1.1 }, { duration: 700, easing: tween.easeInOut, onFinish: function onFinish() { if (element.parent) { tween(element.scale, { x: originalScaleX, y: originalScaleY }, { duration: 700, easing: tween.easeInOut, onFinish: function onFinish() { if (element.parent) { self.pulseAnimation(element); } } }); } } }); }, explainDrag: function explainDrag() { var self = this; var cardInHand = gameState.playerHand.find(function (c) { return c !== null; }); if (cardInHand) { self.showMessage("You've been dealt 5 cards. Drag one to an empty slot on your board to play it.", cardInHand, self.advanceStep.bind(self)); } }, waitForDrag: function waitForDrag() { this.isWaitingForDrag = true; }, explainDiscard: function explainDiscard() { this.showMessage("You can also drag cards to the draw button to sell them for a refund.\n\nTap to continue.", discardAreaContainer, this.advanceStep.bind(this)); }, spawnFirstEnemy: function spawnFirstEnemy() { this.showMessage("Excellent! A card on the board will automatically attack enemies. Let's see it in action!", null, function () { TutorialSystem.clearMessage(); ChipSpawner.spawnChip(1, true); TutorialSystem.advanceStep(); }); }, waitForKill: function waitForKill() { this.isWaitingForChipKill = true; }, explainMerge: function explainMerge() { this.showMessage("Well done! You can level up cards by merging them. Drag a card onto another of the SAME SUIT or SAME VALUE to merge them.\nNote: When you merge, the new card will be a random value and suit, but its level will increase!", null, function () { TutorialSystem.clearMessage(); var cardIndices = []; for (var i = 0; i < gameState.playerHand.length; i++) { if (gameState.playerHand[i]) { cardIndices.push(i); } } if (cardIndices.length >= 2) { var index1 = cardIndices[0]; var index2 = cardIndices[1]; var oldCard1 = gameState.playerHand[index1]; var oldCard2 = gameState.playerHand[index2]; // Make them same suit to be mergeable var newCardData1 = { suit: 'spades', value: 'A', id: 'spades_A' }; var newCardData2 = { suit: 'spades', value: 'K', id: 'spades_K' }; if (oldCard1 && oldCard1.parent) { oldCard1.parent.removeChild(oldCard1); } if (oldCard2 && oldCard2.parent) { oldCard2.parent.removeChild(oldCard2); } placeCardInHand(new Card(newCardData1), index1); placeCardInHand(new Card(newCardData2), index2); } TutorialSystem.advanceStep(); }); }, waitForMerge: function waitForMerge() { this.isWaitingForMerge = true; }, explainJoker: function explainJoker() { this.showMessage("Fantastic! Jokers are special. They can merge with ANY card to raise its level.", null, function () { TutorialSystem.clearMessage(); // Place a Joker in hand var jokerData = { suit: 'joker', value: 'black', id: 'joker_black' }; placeCardInHand(new Card(jokerData), 2); // Place it in the middle of the hand TutorialSystem.advanceStep(); }); }, instructJokerMerge: function instructJokerMerge() { var self = this; var jokerInHand = gameState.playerHand[2]; if (jokerInHand) { var message = "Now drag the Joker from your hand onto a card on your board to level it up!"; // We pulse the joker, as that's the one to drag. this.showMessage(message, jokerInHand, function () { self.clearMessage(); self.isWaitingForJokerMerge = true; }); } else { // Failsafe this.advanceStep(); } }, startWaves: function startWaves() { this.showMessage("Perfect! Merging is key to victory. Now, a real wave is coming. The AI will also start playing.", null, function () { TutorialSystem.clearMessage(); gameReady = true; AISystem.thinkDelay = 240; TutorialSystem.advanceStep(); }); }, explainPokerHands: function explainPokerHands() { LK.setTimeout(function () { TutorialSystem.showMessage("Placing cards in rows creates poker hands, like 'pairs' or 'straights', giving them a massive damage boost!", null, function () { TutorialSystem.clearMessage(); TutorialSystem.advanceStep(); }); }, 8000); }, guaranteedWin: function guaranteedWin() {}, guideToShop: function guideToShop() { var items = this.startScreenItems; var message = "You won! As a reward, you get a FREE mod. Go to the shop to claim it."; this.setupPostGameGuide(message, items.shop.button, [items.battle.button, items.mods.button]); var shopClickHandler = function shopClickHandler() { items.shop.down(); TutorialSystem.clearMessage(); [items.battle.button, items.mods.button, items.shop.button].forEach(function (b) { b.interactive = true; b.alpha = 1; }); TutorialSystem.advanceStep(); }; items.shop.button.down = shopClickHandler; items.shop.icon.down = shopClickHandler; }, guideToRandomMod: function guideToRandomMod() { var items = this.startScreenItems.shopItems; var message = "Tap the glowing item to get your free random mod!"; var originalPrice = storage.randomModPrice; storage.randomModPrice = 0; items.priceText.setText('$0'); this.showMessage(message, null); if (this.overlay) { // Hide the dark background and make overlay non-interactive to allow clicks on shop this.overlay.getChildAt(0).visible = false; this.overlay.interactive = false; } items.overlay.interactive = items.asset.interactive = true; var originalBuy = items.buyButtonDown; items.overlay.down = items.asset.down = function () { items.overlay.down = items.asset.down = function () {}; // Prevent multi-click originalBuy(); storage.randomModPrice = originalPrice; LK.setTimeout(function () { TutorialSystem.clearMessage(); TutorialSystem.advanceStep(); }, 3500); }; }, guideToModsScreen: function guideToModsScreen() { var items = this.startScreenItems; items.shopContainer.visible = false; var message = "Awesome! Now let's equip your new mod. Go to the mods screen."; this.setupPostGameGuide(message, items.mods.button, [items.battle.button, items.shop.button]); var modsClickHandler = function modsClickHandler() { items.mods.down(); TutorialSystem.clearMessage(); [items.battle.button, items.mods.button, items.shop.button].forEach(function (b) { b.interactive = true; b.alpha = 1; }); TutorialSystem.advanceStep(); }; items.mods.button.down = modsClickHandler; items.mods.icon.down = modsClickHandler; }, explainEquipMod: function explainEquipMod() { // First, manually refresh the visual state of all mods in the grid // because the grid was created before the player owned the new mod. var modsContainer = this.startScreenItems.modsContainer; // The gridContainer is the last major element added to the modsContainer. var gridContainer = modsContainer.children[modsContainer.children.length - 1]; if (gridContainer && gridContainer.children.length > 0) { var suitModAssets = ['burnHeartMod', 'chipsDiamondMod', 'spreadClubMod', 'freezeSpadeMod', 'unityHeartsMod', 'gamblerDiamondsMod', 'slowClubsMod', 'mineSpadesMod', 'investmentHeartsMod', 'boostDiamondsMod', 'ricochetClubsMod', 'deathSpadesMod']; var childrenPerMod = 4; // Assumes cell, shadow, mod asset, name text for (var modIndex = 0; modIndex < suitModAssets.length; modIndex++) { var assetId = suitModAssets[modIndex]; var isOwned = ModSystem.isModOwned(assetId); var cellIndex = modIndex * childrenPerMod; var modAssetIndex = cellIndex + 2; if (gridContainer.children[cellIndex] && gridContainer.children[modAssetIndex]) { var cell = gridContainer.children[cellIndex]; var modAsset = gridContainer.children[modAssetIndex]; if (isOwned) { modAsset.tint = 0xffffff; modAsset.alpha = 1.0; cell.tint = 0xffffff; } else { modAsset.tint = 0x555555; modAsset.alpha = 0.6; cell.tint = 0x888888; } } } } var message = "This screen shows all mods. Tap your new mod, then tap 'Equip' to use it in battle!"; this.showMessage(message, null, function () { TutorialSystem.clearMessage(); var originalEquip = ModSystem.equipMod; ModSystem.equipMod = function (modAssetId) { originalEquip.call(ModSystem, modAssetId); TutorialSystem.advanceStep(); ModSystem.equipMod = originalEquip; }; }); // Make the tutorial overlay transparent so the mods screen is fully visible. if (this.overlay) { this.overlay.getChildAt(0).visible = false; } }, completeTutorial: function completeTutorial() { this.showMessage("Tutorial complete! You're ready for battle. Good luck!", null, function () { TutorialSystem.clearMessage(); storage.tutorialCompleted = true; TutorialSystem.isActive = false; var items = TutorialSystem.startScreenItems; [items.battle, items.mods, items.shop].forEach(function (item) { if (item && item.button && item.icon) { item.button.interactive = true; item.button.alpha = 1.0; item.icon.interactive = true; item.icon.alpha = 1.0; } }); TutorialSystem.startScreenItems.modsContainer.visible = false; TutorialSystem.startScreenItems.battle.down(); }); }, setupPostGameGuide: function setupPostGameGuide(message, elementToPulse, elementsToDisable) { this.clearMessage(); this.showMessage(message, null, null, true); // isPostGame = true var items = this.startScreenItems; // Disable other buttons and their icons elementsToDisable.forEach(function (el) { el.interactive = false; el.alpha = 0.5; if (el === items.battle.button) { items.battle.icon.interactive = false; items.battle.icon.alpha = 0.5; } else if (el === items.mods.button) { items.mods.icon.interactive = false; items.mods.icon.alpha = 0.5; } else if (el === items.shop.button) { items.shop.icon.interactive = false; items.shop.icon.alpha = 0.5; } }); // Enable the target button and its icon elementToPulse.interactive = true; elementToPulse.alpha = 1.0; var iconToPulse = null; if (elementToPulse === items.shop.button) { iconToPulse = items.shop.icon; } else if (elementToPulse === items.mods.button) { iconToPulse = items.mods.icon; } if (iconToPulse) { iconToPulse.interactive = true; iconToPulse.alpha = 1.0; } // Bring the container with all buttons on top of the overlay if (this.overlay && elementToPulse.parent && elementToPulse.parent.parent) { elementToPulse.parent.parent.addChild(elementToPulse.parent); } this.pulsingElement = elementToPulse; this.pulseAnimation(this.pulsingElement); } }; function placeCardInHand(card, index) { var handWidth = 5 * DEAL_SLOT_WIDTH + 4 * 30; var handStartX = (SCREEN_WIDTH - handWidth) / 2; var slotX = handStartX + index * DEAL_SLOT_WIDTH + index * 30 + DEAL_SLOT_WIDTH / 2; var slotY = PLAYER_DEAL_AREA_Y + DEAL_SLOT_HEIGHT / 2; card.activate(slotX, slotY, false, true); uiLayer.addChild(card); gameState.playerHand[index] = card; } function displayHandInfo() { // Show current poker hand evaluations for debugging for (var row = 0; row < PLAY_AREA_ROWS; row++) { var handEval = evaluateRowHand(row, true); console.log('Player Row ' + row + ':', handEval.type, 'Multiplier:', handEval.multiplier); } } var background = LK.getAsset('background', { anchorX: 0.5, anchorY: 0 }); background.x = SCREEN_WIDTH / 2; background.y = 50; background.visible = false; gameLayer.addChild(background); var coopBackground = LK.getAsset('coopBackground', { anchorX: 0.5, anchorY: 0 }); coopBackground.x = SCREEN_WIDTH / 2; coopBackground.y = 50; coopBackground.visible = false; gameLayer.addChild(coopBackground); // Place two chipracks side by side in the center at the top of the screen var chipRack1 = LK.getAsset('chipRack', { anchorX: 0.5, anchorY: 0 }); var rackWidth = chipRack1.width; var rackHeight = chipRack1.height; chipRack1.x = SCREEN_WIDTH / 2 - rackWidth / 2; chipRack1.y = 60 - rackHeight * 0.75 + 30; chipRack1.visible = false; gameLayer.addChild(chipRack1); gameElements.push(chipRack1); var chipRack2 = LK.getAsset('chipRack', { anchorX: 0.5, anchorY: 0 }); chipRack2.x = SCREEN_WIDTH / 2 + rackWidth / 2; chipRack2.y = 60 - rackHeight * 0.75 + 30; chipRack2.visible = false; gameLayer.addChild(chipRack2); gameElements.push(chipRack2); var border = LK.getAsset('border', { anchorX: 0.5, anchorY: 0.5 }); border.x = SCREEN_WIDTH / 2; border.y = SCREEN_HEIGHT / 2; border.visible = false; gameLayer.addChild(border); gameElements.push(border); var bottomBar = LK.getAsset('bottomBar', { anchorX: 0.5, anchorY: 1 }); bottomBar.x = SCREEN_WIDTH / 2; bottomBar.y = SCREEN_HEIGHT; bottomBar.visible = false; gameLayer.addChild(bottomBar); gameElements.push(bottomBar); // Show start screen instead of initializing game immediately createStartScreen(); // Add active chips container below the bottom bar gameLayer.addChildAt(activePlayerChipsContainer, gameLayer.getChildIndex(bottomBar)); gameLayer.addChildAt(activeAIChipsContainer, gameLayer.getChildIndex(bottomBar)); // Add chipStack asset above chips display var chipStack = LK.getAsset('chipStack', { anchorX: 0.5, anchorY: 1 }); chipStack.x = playerChipsText.x + playerChipsText.width / 2; chipStack.y = playerChipsText.y - 10; chipStack.visible = false; uiLayer.addChild(chipStack); gameElements.push(chipStack); ; ; // Helper to show roulette for the next boss wave WaveSystem.showRouletteForNextBoss = function () { var nextBossWave = BossSystem.getNextBossWave(); if (nextBossWave > this.waveNumber) { BossSystem.showBossRoulette(function () { // Roulette complete, continue with normal wave logic console.log("Boss roulette completed for wave " + nextBossWave); }); } }; function evaluateHandWithJokers(cardSymbols, jokerCount) { var totalSymbols = cardSymbols.length + jokerCount; if (jokerCount === 0 && cardSymbols.length >= 2) { // No jokers, use existing evaluation but allow for partial hands var tempCards = cardSymbols.map(function (data) { return { cardData: data }; }); return CardSystem.evaluatePokerHand(tempCards); } // With jokers present if (jokerCount >= 4) { return { type: 'four_of_a_kind', strength: 8, multiplier: 25 }; } if (jokerCount >= 3) { return { type: 'three_of_a_kind', strength: 4, multiplier: 5 }; } if (jokerCount >= 2) { return { type: 'three_of_a_kind', strength: 4, multiplier: 5 }; } if (jokerCount >= 1) { // 1 joker guarantees at least a pair return { type: 'one_pair', strength: 2, multiplier: 2 }; } // Fallback for edge cases return { type: 'none', strength: 0, multiplier: 1 }; } function clearAllGreenOutlines() { // Clear all temporary green outlines for (var row = 0; row < PLAY_AREA_ROWS; row++) { for (var col = 0; col < PLAY_AREA_COLS; col++) { var card = gameState.playerPlayArea[row][col]; if (card) { card.greenOutline.visible = false; } } } for (var i = 0; i < gameState.playerHand.length; i++) { var card = gameState.playerHand[i]; if (card) { card.greenOutline.visible = false; } } }