/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1"); /**** * Classes ****/ var Arrow = Container.expand(function () { var self = Container.call(this); self.sprite = self.attachAsset('arrow', { anchorX: 0.5, anchorY: 0.5 }); self.speed = 25; // Magnitude of velocity self.damage = 1; self.startX = 0; // Initial X position, set by Player self.startY = 0; // Initial Y position, set by Player self.rotation = 0; // Current angle of arrow in radians self.velocityX = 0; // X component of velocity self.velocityY = 0; // Y component of velocity var MAX_DISTANCE_FOR_FULL_HOMING = 400; // Pixels after which homing is at max strength (Reduced from 800) var MAX_TURN_RATE = 0.018; // Max radians per frame the arrow can turn (Further reduced from 0.035) self.update = function () { if (UPGRADE_REGISTRY.tracking_arrow > 0 && enemies && enemies.length > 0 && player) { // Added player check var closestEnemy = null; var minDistanceSq = Infinity; for (var i = 0; i < enemies.length; i++) { var enemy = enemies[i]; // Condition to ensure enemy is in front of the player if (!enemy || enemy.isDying || enemy.isHit || enemy.destroyed || enemy.x < player.x) { continue; } var dx = enemy.x - self.x; var dy = enemy.y - self.y; var distSq = dx * dx + dy * dy; if (distSq < minDistanceSq) { minDistanceSq = distSq; closestEnemy = enemy; } } if (closestEnemy) { // No need to check closestEnemy.x < player.x again, already handled in loop var traveledDx = self.x - self.startX; var traveledDy = self.y - self.startY; var distanceTraveled = Math.sqrt(traveledDx * traveledDx + traveledDy * traveledDy); var homingFactor = 0; if (MAX_DISTANCE_FOR_FULL_HOMING > 0) { homingFactor = Math.min(1.0, distanceTraveled / MAX_DISTANCE_FOR_FULL_HOMING); } var targetAngle = Math.atan2(closestEnemy.y - self.y, closestEnemy.x - self.x); var angleDiff = targetAngle - self.rotation; while (angleDiff > Math.PI) { angleDiff -= 2 * Math.PI; } while (angleDiff < -Math.PI) { angleDiff += 2 * Math.PI; } var turnAmount = Math.max(-MAX_TURN_RATE, Math.min(MAX_TURN_RATE, angleDiff)) * homingFactor; self.rotation += turnAmount; } } self.velocityX = Math.cos(self.rotation) * self.speed; self.velocityY = Math.sin(self.rotation) * self.speed; self.x += self.velocityX * gameSpeedMultiplier; self.y += self.velocityY * gameSpeedMultiplier; self.sprite.rotation = self.rotation; // Add particle effect for tracking arrows if (UPGRADE_REGISTRY.tracking_arrow > 0 && LK.ticks % 3 === 0) { // Spawn every 3 ticks for a denser trail // Calculate spawn position slightly behind the arrow's tail var arrowTailOffsetX = Math.cos(self.rotation) * (self.sprite.width * 0.5 + 10); var arrowTailOffsetY = Math.sin(self.rotation) * (self.sprite.width * 0.5 + 10); var particleX = self.x - arrowTailOffsetX; var particleY = self.y - arrowTailOffsetY; var particle = new ArrowParticle(particleX, particleY); game.addChild(particle); arrowParticles.push(particle); } // Off-screen destruction logic is now handled in game.update }; self.getBounds = function () { // A slightly more generous bounding box to account for rotation. // Uses the sprite's largest dimension to define a square box. var arrowWidth = self.sprite.width > 0 ? self.sprite.width : 120; var arrowHeight = self.sprite.height > 0 ? self.sprite.height : 31.2; var size = Math.max(arrowWidth, arrowHeight) * 0.6; // Make it a bit smaller than full diagonal return { left: self.x - size / 2, right: self.x + size / 2, top: self.y - size / 2, bottom: self.y + size / 2 }; }; self.updateAmmo = function (amount) { // This method seems to belong to a UI element, not the Arrow projectile itself. // Keeping it here as per original structure, but it might be an error in original code. // Assuming self.ammoText exists if this method is called. if (self.ammoText) { self.ammoText.setText('x' + amount); if (amount >= 10) { self.ammoText.x = -150; } else { self.ammoText.x = -100; } } }; return self; }); var ArrowParticle = Container.expand(function (x, y) { var self = Container.call(this); self.sprite = self.attachAsset('pixel', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.2, // Increased particle size // Small particles scaleY: 0.2, // Increased particle size alpha: 0.9, // Initial alpha tint: 0xFF69B4 // Pink color for particles }); self.x = x; self.y = y; self.driftX = (Math.random() - 0.5) * 1.5; // Random horizontal drift self.driftY = (Math.random() - 0.5) * 1.5 + 0.75; // Add a consistent downward push, ensuring particles mostly drift down self.destroyQueued = false; var durationMs = 200 + Math.random() * 200; // Lifespan of 200-400ms tween(self.sprite, { alpha: 0 }, { duration: durationMs, easing: tween.linear, // Simple linear fade onFinish: function onFinish() { self.destroyQueued = true; } }); self.update = function () { if (self.destroyQueued) { // If marked for destruction by tween, do nothing further here. // game.update will handle actual removal. return; } self.x += self.driftX; self.y += self.driftY; // Particles also need to scroll with the screen self.x -= PLATFORM_SPEED * gameSpeedMultiplier; }; return self; }); var ArrowPickup = Container.expand(function () { var self = Container.call(this); self.sprite = self.attachAsset('arrow', { anchorX: 0.2, anchorY: 0.5, scaleX: 1.2, scaleY: 1.2 }); // Initialize physics properties CollectibleBehavior.initPhysics(self); self.collect = function () { if (!self.collected) { self.collected = true; player.ammoCount += 1; scoreManager.updateAmmo(player.ammoCount); LK.getSound('arrowpickup').play(); // Create arrow popup var popup = LK.getAsset('arrow', { anchorX: 0.5, anchorY: 0.5, scaleX: 1.3, scaleY: 1.3 }); popup.x = self.x - 50; popup.y = self.y - 200; popup.velocityY = -3; popup.lifespan = 45; popup.update = function () { this.y += this.velocityY; this.lifespan--; if (this.lifespan < 15) { this.alpha -= 0.07; } if (this.alpha <= 0 || this.lifespan <= 0) { this.destroy(); } }; game.addChild(popup); self.destroy(); } }; self.update = function () { CollectibleBehavior.standardUpdate(self); }; return self; }); // Refactored classes - keeping original Container.expand pattern var Coin = Container.expand(function (type) { var self = Container.call(this); // Set type and create sprite self.type = type || 'coin'; self.sprite = self.attachAsset(self.type, { anchorX: 0.5, anchorY: 0.5, tint: 0xFFFFFF }); // Initialize physics properties CollectibleBehavior.initPhysics(self); // Get value based on type self.getValue = function () { switch (self.type) { case 'diamond': return 10; case 'emerald': return 5; case 'ruby': return 3; default: return 1; } }; // Collection functionality self.collect = function () { if (!self.collected) { self.collected = true; var value = self.getValue(); scoreManager.addScore(value, self.x, self.y); LK.getSound('coincollect').play(); self.destroy(); } }; // Standard update method using shared behavior self.update = function () { CollectibleBehavior.standardUpdate(self); }; self.checkPlatformCollision = function () { return GameUtils.checkPlatformCollision(self, 80, true) != null; }; return self; }); // CrumblePiece class var CrumblePiece = Container.expand(function (pieceNum) { var self = Container.call(this); self.sprite = self.attachAsset('crumblepiece' + pieceNum, { anchorX: 0.5, anchorY: 0.5 }); self.velocityX = 0; self.velocityY = 0; self.rotationSpeed = 0; self.update = function () { // Apply physics self.velocityY += 0.5; // gravity self.x += self.velocityX; self.y += self.velocityY; self.rotation += self.rotationSpeed; // Destroy if off screen if (self.y > GAME_HEIGHT || self.x < -100) { self.destroy(); } }; return self; }); var CustomText = Container.expand(function (text, options) { var self = Container.call(this); // Basic settings self.size = options.size || 70; self.scaleSize = self.size / 70; self.letterSpacing = (options.letterSpacing || 10) * self.scaleSize; self.fill = options.fill || 0xFFFFFF; self.wordWrap = options.wordWrap || false; self.wordWrapWidth = options.wordWrapWidth || 800; self.lineHeight = (options.lineHeight || 1.2) * self.size; self.letters = []; self.letterPool = {}; // Pool of letter sprites by character self.text = ''; self.width = 0; self.height = 0; // Track height for multi-line text // Get asset name for character - keep original mapping logic self.getAssetForChar = function (_char) { if (_char.match(/[a-z]/i)) { return 'letter_' + _char.toLowerCase(); } else if (_char.match(/[0-9]/)) { return 'number_' + _char; } else { switch (_char) { case '.': return 'period_mark'; case ',': return 'comma_mark'; case '!': return 'exclamation_mark'; case '?': return 'question_mark'; case '+': return 'addition_mark'; case '*': return 'multiplication_mark'; case ' ': return null; default: return null; } } }; // Get or create sprite from pool self.getOrCreateSprite = function (_char2) { // Initialize pool for this character if needed if (!self.letterPool[_char2]) { self.letterPool[_char2] = []; } // Try to find an inactive sprite var sprite = self.letterPool[_char2].find(function (s) { return !s.active; }); // Create new sprite if none available if (!sprite) { var assetName = self.getAssetForChar(_char2); if (assetName) { sprite = self.attachAsset(assetName, { anchorX: 0.5, anchorY: 0.5, scaleX: self.scaleSize, scaleY: self.scaleSize }); if (self.fill) { sprite.tint = self.fill; } sprite.active = false; sprite.alpha = 0; // Store character type for position adjustments sprite.charType = _char2; self.letterPool[_char2].push(sprite); } } return sprite; }; // Calculate the width a text would take self.calculateTextWidth = function (text) { var width = 0; for (var i = 0; i < text.length; i++) { var _char4 = text[i]; if (_char4 === ' ') { width += 40 * self.scaleSize; } else { width += 50 * self.scaleSize + self.letterSpacing; } } return width; }; // Break text into lines for word wrap self.breakTextIntoLines = function (text) { // First handle explicit line breaks if (text.includes('\n')) { var explicitLines = text.split('\n'); var result = []; // Process each explicit line for word wrapping for (var j = 0; j < explicitLines.length; j++) { if (self.wordWrap) { var wrappedLines = this.breakTextIntoLines(explicitLines[j]); result = result.concat(wrappedLines); } else { result.push(explicitLines[j]); } } return result; } if (!self.wordWrap) { return [text]; } var words = text.split(' '); var lines = []; var currentLine = ''; var currentWidth = 0; var spaceWidth = 40 * self.scaleSize; for (var i = 0; i < words.length; i++) { var word = words[i]; var wordWidth = self.calculateTextWidth(word); // Check if adding this word would exceed the line width if (currentWidth + wordWidth > self.wordWrapWidth && currentLine !== '') { lines.push(currentLine.trim()); currentLine = word + ' '; currentWidth = wordWidth + spaceWidth; } else { currentLine += word + ' '; currentWidth += wordWidth + spaceWidth; } } // Add the last line if there's anything left if (currentLine.trim() !== '') { lines.push(currentLine.trim()); } return lines; }; // Set text content with sprite pooling self.setText = function (newText) { // Always convert to string newText = String(newText); // Deactivate all current letters self.letters.forEach(function (letter) { letter.active = false; letter.alpha = 0; }); self.letters = []; // Break text into lines if word wrap is enabled var lines = self.breakTextIntoLines(newText); var maxLineWidth = 0; // Position tracking var currentX = 0; var currentY = 0; var lineCount = 0; // Process each line for (var lineIndex = 0; lineIndex < lines.length; lineIndex++) { var line = lines[lineIndex]; currentX = 0; // Reset X position for each line // Create/reuse sprites for each character in this line for (var i = 0; i < line.length; i++) { var _char3 = line[i]; // Handle spaces if (_char3 === ' ') { currentX += 40 * self.scaleSize; continue; } // Get or create sprite var sprite = self.getOrCreateSprite(_char3); if (sprite) { sprite.active = true; sprite.alpha = 1; sprite.x = currentX; sprite.y = currentY; // Add vertical position adjustment for punctuation if (_char3 === '.' || _char3 === ',') { sprite.y += 20 * self.scaleSize; // Move periods and commas down } else if (_char3 === '*') { sprite.y += 10 * self.scaleSize; // Move multiplication mark down slightly } self.letters.push(sprite); currentX += 50 * self.scaleSize + self.letterSpacing; } } // Track the maximum line width if (currentX > maxLineWidth) { maxLineWidth = currentX; } // Move to next line if (lineIndex < lines.length - 1) { currentY += self.lineHeight; lineCount++; } } // Update width and height properties self.width = maxLineWidth; self.height = (lineCount + 1) * self.lineHeight; if (self.letters.length === 0) { self.width = 0; self.height = 0; } // Handle anchor alignment if (options.anchorX === 1) { // Right-aligned text for (var i = 0; i < self.letters.length; i++) { self.letters[i].x -= self.width; } } else if (options.anchorX === 0.5) { // Center-aligned each line var currentLine = 0; var lineStart = 0; var lineEnd = 0; var lineWidth = 0; for (var i = 0; i < self.letters.length; i++) { // Check if we're in a new line var letterY = self.letters[i].y; if (i === 0 || letterY !== self.letters[lineStart].y) { // Process previous line if this isn't the first letter if (i > 0) { lineEnd = i - 1; lineWidth = self.letters[lineEnd].x + 50 * self.scaleSize / 2; // Center this line for (var j = lineStart; j <= lineEnd; j++) { self.letters[j].x -= lineWidth / 2; } } // Start tracking new line lineStart = i; } } // Process the last line if (lineStart < self.letters.length) { lineEnd = self.letters.length - 1; lineWidth = self.letters[lineEnd].x + 50 * self.scaleSize / 2; // Center this line for (var j = lineStart; j <= lineEnd; j++) { self.letters[j].x -= lineWidth / 2; } } } // Store current text self.text = newText; }; // Cleanup method self.destroy = function () { // Properly destroy all pooled sprites Object.values(self.letterPool).forEach(function (pool) { pool.forEach(function (sprite) { if (sprite.destroy) { sprite.destroy(); } }); }); self.letterPool = {}; self.letters = []; Container.prototype.destroy.call(this); }; // Initialize with provided text self.setText(text); return self; }); // Enemy class with refactored animation management var Enemy = Container.expand(function (type) { var self = Container.call(this); // Enemy properties self.type = type || 'basic'; self.speed = 7; self.isOnGround = true; self.velocityY = 0; self.currentPlatform = null; self.groundY = GAME_HEIGHT / 1.5; self.isHit = false; self.isDying = false; self.deathTimer = 0; self.throwBackSpeed = 15; self.throwBackDistance = 0; // Add mushroom-specific properties self.isAttacking = false; self.attackTimer = 0; self.attackDuration = 100; // 60 frames for attack animation self.attackCooldown = 180; // Cooldown before next attack self.attackCooldownTimer = 0; self.sporesReleased = false; // Flag to ensure spores only released once per attack // Loot modifier - skeletons get 1.5x self.lootModifier = self.type === 'skeleton' ? 1.6 : 1.0; self.maxThrowBack = 200; self.hitType = 'none'; // Can be 'none', 'attack', or 'slide' // Hitbox properties self.hitboxWidth = 200; self.hitboxHeight = self.type === 'eyeball' ? 90 : 260; // Animation properties self.sprites = []; self.animationCounter = 0; self.animationSpeed = 0.11; // Define all animation arrays based on enemy type if (self.type === 'mushroom') { // Mushroom-specific properties self.runFrame = 0; self.speed = 6; self.runAnimation = ['mushroomrun1', 'mushroomrun2', 'mushroomrun3', 'mushroomrun4', 'mushroomrun5', 'mushroomrun6', 'mushroomrun7', 'mushroomrun8']; self.hitAnimation = ['mushroomhit1', 'mushroomhit2']; // New hit animations self.dieAnimation = ['mushroomdie1', 'mushroomdie2', 'mushroomdie3', 'mushroomdie4']; // New death animations } else if (self.type === 'eyeball') { // Eyeball-specific properties self.isFlying = true; self.flyingHeight = 0; self.verticalSpeed = 2; self.maxVerticalSpeed = 4; self.homingDelay = 80; self.homingTimer = 0; self.flyFrame = 0; // Animation frames self.flyAnimation = ['eyefly1', 'eyefly2', 'eyefly3', 'eyefly4', 'eyefly5', 'eyefly6', 'eyefly7', 'eyefly8']; self.hitAnimation = ['eyedie1', 'eyedie2']; self.dieAnimation = ['eyedie3', 'eyedie4', 'eyedie5']; } else if (self.type === 'goblin') { // Goblin-specific properties self.runFrame = 0; // Animation frames self.runAnimation = ['goblinrun1', 'goblinrun2', 'goblinrun3', 'goblinrun4', 'goblinrun5', 'goblinrun6', 'goblinrun7', 'goblinrun8']; self.hitAnimation = ['goblinhit1']; self.dieAnimation = ['goblindie1', 'goblindie2', 'goblindie3', 'goblindie4']; } else if (self.type === 'skeleton') { // Skeleton-specific properties self.runFrame = 0; self.speed = 6; // Slower than goblin // Throwing properties self.isThrowing = false; self.throwingTimer = 0; self.throwingDuration = 90; self.throwingPauseTime = 15; self.throwingFrame = 0; // Animation frames self.runAnimation = ['skeletonwalk1', 'skeletonwalk2', 'skeletonwalk3', 'skeletonwalk4']; self.hitAnimation = ['skeletonhit1', 'skeletonhit2']; self.dieAnimation = ['skeletondie1', 'skeletondie2', 'skeletondie3', 'skeletondie4']; self.throwingAnimation = ['skeletonthrow1', 'skeletonthrow2', 'skeletonthrow3', 'skeletonthrow4', 'skeletonthrow5', 'skeletonthrow6']; } // Initialize animation sprites for eyeball self.initEyeballSprites = function () { // Add fly animations for (var i = 0; i < self.flyAnimation.length; i++) { var sprite = self.attachAsset(self.flyAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Add hit animations for (var i = 0; i < self.hitAnimation.length; i++) { var sprite = self.attachAsset(self.hitAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add die animations for (var i = 0; i < self.dieAnimation.length; i++) { var sprite = self.attachAsset(self.dieAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }; // Initialize animation sprites for goblin self.initGoblinSprites = function () { // Add run animations for (var i = 0; i < self.runAnimation.length; i++) { var sprite = self.attachAsset(self.runAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Add hit animations for (var i = 0; i < self.hitAnimation.length; i++) { var sprite = self.attachAsset(self.hitAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add die animations for (var i = 0; i < self.dieAnimation.length; i++) { var sprite = self.attachAsset(self.dieAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }; // Initialize animation sprites for skeleton self.initSkeletonSprites = function () { // Add walk animations for (var i = 0; i < self.runAnimation.length; i++) { var sprite = self.attachAsset(self.runAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Add hit animations for (var i = 0; i < self.hitAnimation.length; i++) { var sprite = self.attachAsset(self.hitAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add die animations for (var i = 0; i < self.dieAnimation.length; i++) { var sprite = self.attachAsset(self.dieAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add throwing animations for (var i = 0; i < self.throwingAnimation.length; i++) { var sprite = self.attachAsset(self.throwingAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }; self.initMushroomSprites = function () { // Add run animations for (var i = 0; i < self.runAnimation.length; i++) { var sprite = self.attachAsset(self.runAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Add hit animations for (var i = 0; i < self.hitAnimation.length; i++) { var sprite = self.attachAsset(self.hitAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add die animations for (var i = 0; i < self.dieAnimation.length; i++) { var sprite = self.attachAsset(self.dieAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } for (var i = 0; i < 5; i++) { var sprite = self.attachAsset('mushroomattack' + (i + 1), { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }; // Hide all animation sprites self.hideAllSprites = function () { for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } }; // Update eyeball hit/die animation - fixed to allow falling without platform collision self.updateEyeballDamageState = function () { if (self.isHit) { var hitOffset = self.flyAnimation.length; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.x += self.throwBackSpeed; // Apply vertical velocity without any dampening on the first few frames // to ensure the eyeball gets significant vertical movement if (self.hitTimer > 30) { // Apply full vertical movement without reduction for initial frames self.y += self.velocityY; } else { // After initial frames, gradually reduce the vertical movement self.y += self.velocityY; self.velocityY *= 0.8; // Less aggressive dampening to maintain vertical motion } self.throwBackSpeed *= 0.95; // Show hit animation var hitFrame = Math.floor(self.hitTimer / 100) % 2; self.sprites[hitOffset + hitFrame].alpha = 1; self.hitTimer--; if (self.hitTimer <= 0) { self.isHit = false; if (self.hitType === 'attack') { // Only start dying if it was a regular attack self.isDying = true; self.deathTimer = 180; self.deathFrame = 0; // Add dropLoot here when transitioning to dying state self.dropLoot(); } self.hitType = 'none'; } } else if (self.isDying) { var dieOffset = self.flyAnimation.length + self.hitAnimation.length; // Apply gravity without platform collision - this ensures constant falling self.velocityY += 0.5; self.y += self.velocityY; // Keep moving horizontally during fall self.x -= PLATFORM_SPEED * 0.5; // Progress through death frames if (self.deathTimer > 120) { self.sprites[dieOffset].alpha = 1; // eyedie3 } else if (self.deathTimer > 60) { self.sprites[dieOffset + 1].alpha = 1; // eyedie4 } else { self.sprites[dieOffset + 2].alpha = 1; // eyedie5 } self.deathTimer--; if (self.deathTimer <= 0) { self.alpha -= 0.05; if (self.alpha <= 0) { self.destroy(); } } } }; // Update eyeball normal movement self.updateEyeballNormalState = function () { self.x -= self.speed * gameSpeedMultiplier; // Only start homing after delay if (self.homingTimer >= self.homingDelay) { // Home toward player var deltaY = player.y - self.y; self.velocityY += deltaY > 0 ? 0.2 : -0.2; self.velocityY = Math.max(-self.maxVerticalSpeed, Math.min(self.maxVerticalSpeed, self.velocityY)); } else { // Before homing, maintain height with slight wave motion self.velocityY = Math.sin(self.homingTimer * 0.05) * 2; self.homingTimer++; } self.y += self.velocityY; // Animate self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.flyFrame = (self.flyFrame + 1) % self.flyAnimation.length; } self.sprites[self.flyFrame].alpha = 1; }; // Update goblin hit animation self.updateGoblinHitState = function () { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Check if still on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.75; self.y += self.velocityY; self.checkPlatformCollision(); } // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Decrease hit timer self.hitTimer--; // Once hit timer expires, check hit type if (self.hitTimer <= 0) { self.isHit = false; if (self.hitType === 'attack') { self.isDying = true; self.deathTimer = 60; self.deathFrame = 0; self.dropLoot(); } self.hitType = 'none'; } }; // Update skeleton hit animation self.updateSkeletonHitState = function () { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Check if still on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // Show hit animation var hitOffset = self.runAnimation.length; var hitFrame = Math.floor(self.hitTimer / 18) % 2; // Alternate between hit frames self.sprites[hitOffset + hitFrame].alpha = 1; // Decrease hit timer self.hitTimer--; // Once hit timer expires, check hit type if (self.hitTimer <= 0) { self.isHit = false; if (self.hitType === 'attack') { self.isDying = true; self.deathTimer = 60; self.deathFrame = 0; self.dropLoot(); } self.hitType = 'none'; } }; // Update goblin dying animation self.updateGoblinDyingState = function () { // Continue throw back during death self.x += self.throwBackSpeed; // Check if still on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // After halfway through death animation, match platform speed if (self.deathFrame >= 2) { self.x -= PLATFORM_SPEED; } self.throwBackSpeed *= 0.95; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; // Progress frame every 15 frames if (self.deathTimer % 15 === 0 && self.deathFrame < self.dieAnimation.length - 1) { self.deathFrame++; } self.sprites[dieOffset + self.deathFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } }; // Update skeleton dying animation self.updateSkeletonDyingState = function () { // Continue throw back during death self.x += self.throwBackSpeed; // Check if still on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // After halfway through death animation, match platform speed if (self.deathFrame >= 2) { self.x -= PLATFORM_SPEED; } self.throwBackSpeed *= 0.95; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; // Progress frame every 15 frames if (self.deathTimer % 15 === 0 && self.deathFrame < self.dieAnimation.length - 1) { self.deathFrame++; } self.sprites[dieOffset + self.deathFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } }; // Update goblin normal movement self.updateGoblinNormalState = function () { // Move left with speed multiplier self.x -= self.speed * gameSpeedMultiplier; // Platform and gravity code if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // Ensure goblin stays on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Animate running self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; }; // Update skeleton throwing animation self.updateSkeletonThrowingState = function () { // Always move exactly with platform speed during throwing self.x -= PLATFORM_SPEED * gameSpeedMultiplier; // Offset to find throwing animation sprites var throwOffset = self.runAnimation.length + self.hitAnimation.length + self.dieAnimation.length; // Progress through throwing frames if (self.throwingTimer > self.throwingDuration - self.throwingPauseTime) { // Early frames building up to throw var frameIndex = Math.floor((self.throwingDuration - self.throwingTimer) / ((self.throwingDuration - self.throwingPauseTime) / 5)); frameIndex = Math.min(4, Math.max(0, frameIndex)); self.sprites[throwOffset + frameIndex].alpha = 1; } else if (self.throwingTimer <= Math.floor(self.throwingDuration * 0.8) && self.throwingTimer > Math.floor(self.throwingDuration * 0.8) - 2 && !self.swordThrown) { // Flag to ensure we only throw once during this window self.swordThrown = true; // Create and initialize sword with more robust positioning var sword = new SkeletonSword(); sword.x = self.x - 100; // Fixed position relative to skeleton sword.y = self.y - 100; // Explicitly set initial velocity independent of gameSpeedMultiplier sword.constantVelocity = 8; // Fixed velocity // Add the sword to the game and tracking array game.addChild(sword); skeletonSwords.push(sword); // Show throwing frame self.sprites[throwOffset + 5].alpha = 1; } else if (self.throwingTimer <= self.throwingPauseTime) { // During pause, keep showing the final frame self.sprites[throwOffset + 5].alpha = 1; } else { // Middle of animation (after throw, before pause) self.sprites[throwOffset + 5].alpha = 1; } // Decrease timer self.throwingTimer--; // End throwing state and restore speed if (self.throwingTimer <= 0) { self.isThrowing = false; self.swordThrown = false; // Reset the flag self.speed = self.originalSpeed || 6; } }; // Update skeleton normal movement self.updateSkeletonNormalState = function () { // Track if this is the first time we're seeing this skeleton if (self.initialThrowMade === undefined) { self.initialThrowMade = false; self.enteredScreenTime = LK.ticks; self.throwDelay = 60; // Reduce delay before first throw } // Check for initial throw if (!self.initialThrowMade && self.x < GAME_WIDTH + 300 && self.isOnGround && !self.isThrowing) { if (LK.ticks - self.enteredScreenTime > self.throwDelay) { self.isThrowing = true; self.swordThrown = false; // Initialize flag here self.throwingTimer = self.throwingDuration; self.throwingFrame = 0; self.originalSpeed = self.speed; self.initialThrowMade = true; } } // Continue with normal movement regardless of throw state // Move left with speed multiplier self.x -= self.speed * gameSpeedMultiplier; // Platform and gravity code if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // Ensure skeleton stays on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Animate walking - slower animation speed for skeleton self.animationCounter += self.animationSpeed * 0.8; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; }; self.updateMushroomNormalState = function () { // Check if should attack if (self.checkMushroomAttack()) { return; // Skip normal update if starting attack } // Decrease attack cooldown timer if (self.attackCooldownTimer > 0) { self.attackCooldownTimer--; } // Keep existing normal state code // Move left with speed multiplier self.x -= self.speed * gameSpeedMultiplier; // Platform and gravity code if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // Ensure mushroom stays on platform if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; // Check for another platform for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Start falling if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Animate walking self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; }; self.updateMushroomHitState = function () { // Same movement physics as before self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Platform collision check (same as before) if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.75; self.y += self.velocityY; self.checkPlatformCollision(); } // Show hit animation - Sequential progression through hit frames var hitOffset = self.runAnimation.length; // Calculate hit frame based on timer // If we have 2 hit frames and hitTimer starts at 35, show first frame for first half, second frame for second half var hitProgress = 1 - self.hitTimer / 35; // Normalize from 0 to 1 var hitFrame = Math.min(Math.floor(hitProgress * self.hitAnimation.length), self.hitAnimation.length - 1); self.sprites[hitOffset + hitFrame].alpha = 1; // Decrease hit timer self.hitTimer--; // Once hit timer expires, check hit type if (self.hitTimer <= 0) { self.isHit = false; if (self.hitType === 'attack') { self.isDying = true; self.deathTimer = 60; self.deathFrame = 0; self.dropLoot(); } self.hitType = 'none'; } }; self.updateMushroomDyingState = function () { // Same movement physics as before self.x += self.throwBackSpeed; // Platform collision check (same as before) if (self.currentPlatform) { var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH && Math.abs(self.y - (otherPlatform.y - ENEMY_PLATFORM_OFFSET)) < 5) { self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } } } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; self.checkPlatformCollision(); } // After halfway through death animation, match platform speed if (self.deathFrame >= 2) { self.x -= PLATFORM_SPEED; } self.throwBackSpeed *= 0.95; // Handle death animation - Updated to progress through all frames var dieOffset = self.runAnimation.length + self.hitAnimation.length; // Progress frame every 15 frames (similar to other enemy death animations) if (self.deathTimer % 15 === 0 && self.deathFrame < self.dieAnimation.length - 1) { self.deathFrame++; } self.sprites[dieOffset + self.deathFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } }; self.checkMushroomAttack = function () { if (self.type !== 'mushroom' || self.isHit || self.isDying || self.isAttacking || self.attackCooldownTimer > 0) { return false; } // Attack when player is in range (horizontal and vertical distance check) var distanceX = Math.abs(player.x - self.x); var distanceY = Math.abs(player.y - self.y); if (distanceX < 800 && distanceY < 700 && self.x > player.x) { // Store original position relative to platform BEFORE changing state self.platformOffset = self.currentPlatform ? self.x - self.currentPlatform.x : 0; // Set attacking state self.isAttacking = true; self.attackTimer = self.attackDuration; self.sporesReleased = false; self.originalSpeed = self.speed; // Don't change position here - we'll maintain platform-relative position return true; } return false; }; // Add mushroom attack animation update self.updateMushroomAttackState = function () { // Get offset to find attack animation sprites var attackOffset = self.runAnimation.length + self.hitAnimation.length + self.dieAnimation.length; // Calculate which frame to display based on attack progress var frameProgress = (self.attackDuration - self.attackTimer) / self.attackDuration; var attackFrame = Math.min(Math.floor(frameProgress * 5), 4); // Show current attack frame self.sprites[attackOffset + attackFrame].alpha = 1; // Play hiss sound when attack animation starts if (attackFrame === 0 && self.attackTimer === self.attackDuration - 1) { LK.getSound('mushroomhiss').play(); } // Release spores at frame 3 (middle of animation) if (attackFrame === 3 && !self.sporesReleased) { self.releaseSpores(); self.sporesReleased = true; } // If on a platform, maintain position relative to that platform if (self.currentPlatform) { // Use stored platform offset (which is 0 if not previously set) self.x = self.currentPlatform.x + (self.platformOffset || 0); } else { // If not on a platform, just match platform movement speed self.x -= PLATFORM_SPEED * gameSpeedMultiplier; } // Count down attack timer self.attackTimer--; // End attack when timer expires if (self.attackTimer <= 0) { self.isAttacking = false; self.speed = self.originalSpeed || 6; self.attackCooldownTimer = self.attackCooldown; } }; // Function to release spores in the specified pattern self.releaseSpores = function () { // Create 5 spores in pattern described var directions = [{ x: 1, y: 0 }, // Right { x: -1, y: 0 }, // Left { x: 0, y: -1 }, // Up { x: 0.7, y: -0.7 }, // Up-right diagonal { x: -0.7, y: -0.7 } // Up-left diagonal ]; // Calculate an offset position IN FRONT of the mushroom // This compensates for the platform movement and animation delay var offsetX = self.x; // Add a significant forward offset var offsetY = self.y - 50; // Slightly above as before // Play mushroom burst sound effect LK.getSound('mushroomburst').play(); for (var i = 0; i < directions.length; i++) { var spore = new Spore(); // Position spores at the offset position spore.x = offsetX; spore.y = offsetY; // Don't add PLATFORM_SPEED to the velocityX, as that's causing over-compensation spore.velocityX = directions[i].x * spore.speed; spore.velocityY = directions[i].y * spore.speed; // Add to game game.addChild(spore); // Add to a global array for tracking if needed if (!window.spores) { window.spores = []; } window.spores.push(spore); } }; // Check platform collision self.checkPlatformCollision = function () { var onAnyPlatform = false; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; var leftEdge = platform.x - PLATFORM_HALF_WIDTH; var rightEdge = platform.x + PLATFORM_HALF_WIDTH; if (self.x >= leftEdge && self.x <= rightEdge) { if (Math.abs(self.y - (platform.y - ENEMY_PLATFORM_OFFSET)) < 5) { // Add this check: if (platform instanceof CrumblePlatform) { platform.trigger(); } // Rest of the collision code remains the same // Add this check: if (platform instanceof CrumblePlatform) { platform.trigger(); } // Rest of the collision code remains the same onAnyPlatform = true; self.currentPlatform = platform; self.y = platform.y - ENEMY_PLATFORM_OFFSET; self.isOnGround = true; self.velocityY = 0; return true; } if (self.velocityY > 0 && self.y < platform.y - ENEMY_PLATFORM_OFFSET && self.y + self.velocityY >= platform.y - ENEMY_PLATFORM_OFFSET) { // Add this check here too: if (platform instanceof CrumblePlatform) { platform.trigger(); } // Rest of the collision code remains the same // Add this check here too: if (platform instanceof CrumblePlatform) { platform.trigger(); } // Rest of the collision code remains the same self.y = platform.y - ENEMY_PLATFORM_OFFSET; self.velocityY = 0; self.isOnGround = true; self.currentPlatform = platform; return true; } } } if (!onAnyPlatform) { self.isOnGround = false; self.currentPlatform = null; } return false; }; // Get collision bounds self.getBounds = function () { return { left: self.x - self.hitboxWidth / 2, right: self.x + self.hitboxWidth / 2, top: self.y - self.hitboxHeight / 2, bottom: self.y + self.hitboxHeight / 2 }; }; self.slideHit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; // Check if player has slide damage upgrade if (player.slideDamage && player.slideDamageTimer <= 0) { // If upgraded, treat as regular attack self.hitType = 'attack'; player.slideDamageTimer = player.slideDamageCooldown; } else { // Otherwise just knockback self.hitType = 'slide'; } self.throwBackSpeed = 25; self.throwBackDistance = 0; self.hitTimer = 30; // Add vertical trajectory for eyeball hits based on Y position comparison with player var verticalTrajectory; if (self.type === 'eyeball') { // (existing eyeball trajectory calculation) var yDifference = self.y - player.y; var heightThreshold = 100; // Adjust this value to control the size of the middle zone if (yDifference < -heightThreshold) { // Eyeball is well above player, push upward strongly verticalTrajectory = -20; } else if (yDifference > heightThreshold) { // Eyeball is well below player, push downward strongly verticalTrajectory = 14; } else { // Eyeball is in middle zone, small upward push verticalTrajectory = -2; } self.velocityY = verticalTrajectory; } // Play the appropriate hit sound based on enemy type if (self.type === 'eyeball') { LK.getSound('eyeballhit').play(); } else if (self.type === 'skeleton') { LK.getSound('skeletonhit').play(); } else if (self.type === 'mushroom' && player.slideDamage) { LK.getSound('mushroomdie').play(); } else if (self.type === 'mushroom') { LK.getSound('mushroombounce').play(); } else { LK.getSound('enemyhit').play(); } // Add particle effect var particleOffset = self.type === 'eyeball' ? 175 : 250; particleSystem.emitFromHit(self.x + particleOffset, self.y, player.x, verticalTrajectory, self.type); } }; // Hit handling self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.hitType = 'attack'; // Specify this is a regular attack hit self.throwBackSpeed = 25; self.throwBackDistance = 0; self.hitTimer = 35; // Calculate vertical trajectory for eyeball hits based on Y position comparison with player var verticalTrajectory; if (self.type === 'eyeball') { var yDifference = self.y - player.y; var heightThreshold = 100; // Adjust this value to control the size of the middle zone if (yDifference < -heightThreshold) { // Eyeball is well above player, push upward strongly verticalTrajectory = -20; } else if (yDifference > heightThreshold) { // Eyeball is well below player, push downward strongly verticalTrajectory = 14; } else { // Eyeball is in middle zone, small upward push verticalTrajectory = -2; } // Immediately apply the vertical trajectory with stronger values self.velocityY = verticalTrajectory; // Set the velocity for the eyeball } else { self.velocityY = 0; // Reset vertical velocity for new hit for non-eyeball enemies } // Play appropriate hit sound based on enemy type if (self.type === 'mushroom') { LK.getSound('mushroomdie').play(); } // Add particle effect var particleOffset = self.type === 'eyeball' ? 175 : 250; particleSystem.emitFromHit(self.x + particleOffset, self.y, player.x, verticalTrajectory, self.type); } }; self.dropLoot = function () { // Don't drop collectibles during tutorial if (tutorialActive) { return; } // Apply loot multiplier from Fortune Finder upgrade var lootMultiplier = player.lootMultiplier || 1.0; // Determine number of coins to drop (1-5) adjusted by loot modifier and player's upgrade var coinCount = Math.floor(GameUtils.randomRange(1, 6) * self.lootModifier * lootMultiplier); // Small chance for jewels - increased by loot modifier AND player upgrade var dropJewel = Math.random(); var jewelChance = 0.02 * self.lootModifier * lootMultiplier; // Base 2% chance multiplied by modifiers if (dropJewel < jewelChance) { // Diamond (rarest) var diamond = new Coin('diamond'); diamond.x = self.x; diamond.y = self.y; diamond.velocityX = GameUtils.randomRange(-2, 2); // Reduced horizontal velocity diamond.velocityY = -GameUtils.randomRange(6, 10); // Reduced vertical velocity game.addChild(diamond); coins.push(diamond); } else if (dropJewel < jewelChance * 2) { // Emerald var emerald = new Coin('emerald'); emerald.x = self.x; emerald.y = self.y; emerald.velocityX = GameUtils.randomRange(-2, 2); // Reduced horizontal velocity emerald.velocityY = -GameUtils.randomRange(6, 10); // Reduced vertical velocity game.addChild(emerald); coins.push(emerald); } else if (dropJewel < jewelChance * 3) { // Ruby var ruby = new Coin('ruby'); ruby.x = self.x; ruby.y = self.y; ruby.velocityX = GameUtils.randomRange(-2, 2); // Reduced horizontal velocity ruby.velocityY = -GameUtils.randomRange(6, 10); // Reduced vertical velocity game.addChild(ruby); coins.push(ruby); } // Drop regular coins for (var i = 0; i < coinCount; i++) { var coin = new Coin(); coin.x = self.x; coin.y = self.y; coin.velocityX = GameUtils.randomRange(-2, 2); // Reduced horizontal velocity coin.velocityY = -GameUtils.randomRange(6, 10); // Reduced vertical velocity game.addChild(coin); coins.push(coin); } }; self.isDeathAnimationComplete = function () { return self.isDying && self.deathTimer <= 10; // Check if we're near the end of death animation }; // Main update method self.update = function () { // Hide all sprites first self.hideAllSprites(); // Handle different enemy types and states if (self.type === 'eyeball') { if (self.isHit || self.isDying) { self.updateEyeballDamageState(); } else { self.updateEyeballNormalState(); } } else if (self.type === 'skeleton') { // Skeleton logic if (self.isHit) { self.updateSkeletonHitState(); } else if (self.isDying) { self.updateSkeletonDyingState(); } else if (self.isThrowing) { self.updateSkeletonThrowingState(); } else { self.updateSkeletonNormalState(); } } else if (self.type === 'mushroom') { // Mushroom logic - modified to include attack state if (self.isHit) { self.updateMushroomHitState(); } else if (self.isDying) { self.updateMushroomDyingState(); } else if (self.isAttacking) { self.updateMushroomAttackState(); } else { self.updateMushroomNormalState(); } } else { // Goblin logic if (self.isHit) { self.updateGoblinHitState(); } else if (self.isDying) { self.updateGoblinDyingState(); } else { self.updateGoblinNormalState(); } } // Destroy if off screen if (self.x < -50 || self.y > GAME_HEIGHT) { self.destroy(); } }; // Initialize based on enemy type AFTER defining the methods if (self.type === 'eyeball') { self.initEyeballSprites(); } else if (self.type === 'goblin') { self.initGoblinSprites(); } else if (self.type === 'skeleton') { self.initSkeletonSprites(); } else if (self.type === 'mushroom') { self.initMushroomSprites(); } else { // Basic enemy var enemyGraphics = self.attachAsset('enemy', { anchorX: 0.5, anchorY: 0.5 }); } return self; }); var HealthPotion = Container.expand(function () { var self = Container.call(this); // Create sprite self.sprite = self.attachAsset('healthpotion', { anchorX: 0.5, anchorY: 0.8 }); // Initialize physics properties CollectibleBehavior.initPhysics(self); // Collection functionality self.collect = function () { if (!self.collected && player.currentHealth < player.maxHealth) { self.collected = true; player.currentHealth++; player.heartContainer.updateHealth(player.currentHealth); player.heartContainer.alpha = 1; player.heartVisibilityTimer = player.heartVisibilityDuration; // Create heart popup var popup = LK.getAsset('heart', { anchorX: 0.5, anchorY: 0.5, tint: 0xFF0000 }); popup.scaleX = 1.6; // Adjust scale to match original size popup.scaleY = 1.6; popup.x = self.x - 50; popup.y = self.y - 200; popup.velocityY = -3; popup.lifespan = 45; popup.update = function () { this.y += this.velocityY; this.lifespan--; if (this.lifespan < 15) { this.alpha -= 0.07; } if (this.alpha <= 0 || this.lifespan <= 0) { this.destroy(); } }; game.addChild(popup); LK.getSound('potion').play(); self.destroy(); } }; // Standard update using shared behavior self.update = function () { CollectibleBehavior.standardUpdate(self); }; self.checkPlatformCollision = function () { return GameUtils.checkPlatformCollision(self, 80, true) != null; }; return self; }); var HeartContainer = Container.expand(function () { var self = Container.call(this); self.maxHealth = 3; self.currentHealth = 3; self.hearts = []; // Calculate total width of heart display var heartSpacing = 80; var totalWidth = (self.maxHealth - 1) * heartSpacing; // Initialize hearts with centered positioning for (var i = 0; i < self.maxHealth; i++) { var heart = self.attachAsset('heart', { anchorX: 0.5, anchorY: 0.5, tint: 0xCC0000 }); heart.x = i * heartSpacing - totalWidth / 2; heart.y = 0; self.hearts.push(heart); } // Start invisible self.alpha = 0; // NEW METHOD: Update max health and add/remove heart sprites as needed self.updateMaxHealth = function (newMaxHealth) { var heartSpacing = 80; // Add new hearts if needed if (newMaxHealth > self.maxHealth) { for (var i = self.maxHealth; i < newMaxHealth; i++) { var heart = self.attachAsset('heart', { anchorX: 0.5, anchorY: 0.5, tint: 0xCC0000 }); self.hearts.push(heart); } } // Remove hearts if needed (unlikely, but for completeness) else if (newMaxHealth < self.maxHealth) { for (var i = self.maxHealth - 1; i >= newMaxHealth; i--) { if (self.hearts[i]) { self.hearts[i].destroy(); self.hearts.pop(); } } } // Update max health value self.maxHealth = newMaxHealth; // Recalculate total width and reposition all hearts totalWidth = (self.maxHealth - 1) * heartSpacing; for (var i = 0; i < self.hearts.length; i++) { self.hearts[i].x = i * heartSpacing - totalWidth / 2; } }; self.updateHealth = function (newHealth) { self.currentHealth = newHealth; // Update heart display for (var i = 0; i < self.maxHealth; i++) { if (i < newHealth) { // Full heart self.hearts[i].tint = 0xFF0000; self.hearts[i].alpha = 1; } else { // Empty heart self.hearts[i].tint = 0x000000; self.hearts[i].alpha = 0.5; } } }; return self; }); var Jar = Container.expand(function () { var self = Container.call(this); // Attach jar sprite self.sprite = self.attachAsset('jar', { anchorX: 0.5, anchorY: 0.5, tint: 0xC0C0C0 }); // Initialize as breakable BreakableBehavior.initBreakable(self); // Break functionality self["break"] = function () { BreakableBehavior.standardBreak(self, JarPiece, 4, function (jar) { // Get loot multiplier from player var lootMultiplier = player.lootMultiplier || 1.0; // Spawn health potion with low chance - improved by loot multiplier if (Math.random() < 0.05 * (player.potionDropChance || 1.0)) { var potion = new HealthPotion(); potion.x = jar.x; potion.y = jar.y; potion.velocityX = GameUtils.randomRange(2, 6); // Reduced horizontal velocity potion.velocityY = -GameUtils.randomRange(8, 14); // Reduced vertical velocity game.addChild(potion); coins.push(potion); } // Add chance for arrow - improved by loot multiplier if (Math.random() < 0.25 * (player.arrowDropChance || 1.0)) { var arrow = new ArrowPickup(); arrow.x = jar.x; arrow.y = jar.y; arrow.velocityX = GameUtils.randomRange(2, 6); arrow.velocityY = -GameUtils.randomRange(8, 14); // Set rotation to 90 degrees counterclockwise arrow.sprite.rotation = -Math.PI / 2; arrow.platformOffset = 200; game.addChild(arrow); coins.push(arrow); } // Spawn coins - quantity affected by loot multiplier var coinCount = Math.floor(GameUtils.randomRange(1, 9) * lootMultiplier); for (var i = 0; i < coinCount; i++) { var coin = new Coin(); coin.x = jar.x; coin.y = jar.y; coin.velocityX = GameUtils.randomRange(2, 6); // Reduced horizontal velocity coin.velocityY = -GameUtils.randomRange(8, 14); // Reduced vertical velocity game.addChild(coin); coins.push(coin); } LK.getSound('jarbreak').play(); }); }; return self; }); var JarPiece = Container.expand(function (pieceNum) { var self = Container.call(this); // Attach piece sprite self.sprite = self.attachAsset('jarpiece' + pieceNum, { anchorX: 0.5, anchorY: 0.5, tint: 0xC0C0C0 }); // Initialize as piece PieceBehavior.initPiece(self); // Update method self.update = function () { PieceBehavior.standardUpdate(self); }; self.checkPlatformCollision = function () { return GameUtils.checkPlatformCollision(self, 80, true) != null; }; return self; }); var ParticlePool = Container.expand(function (maxParticles) { var self = Container.call(this); self.particles = []; self.activeParticles = []; self.redTints = [0xff0000, 0xff3333, 0xcc0000]; for (var i = 0; i < maxParticles; i++) { var particle = self.attachAsset('pixel', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.2, scaleY: 0.2 }); particle.alpha = 0; particle.velocityX = 0; particle.velocityY = 0; particle.lifespan = 0; particle.fadeSpeed = 0; self.particles.push(particle); } self.emitFromHit = function (x, y, playerX, verticalTrajectory, enemyType) { var directionX = x - playerX; var directionSign = Math.sign(directionX); for (var i = 0; i < 20; i++) { if (self.particles.length === 0) { break; } var particle = self.particles.pop(); self.activeParticles.push(particle); particle.x = x; particle.y = y; particle.alpha = 1; // Only apply red tint if not skeleton enemy type if (enemyType !== 'skeleton') { particle.tint = self.redTints[Math.floor(Math.random() * self.redTints.length)]; } else { particle.tint = 0xFFFFFF; // White particles for skeleton } // Set scale var particleSize = Math.random() * 0.2 + 0.2; particle.scaleX = particleSize; particle.scaleY = particleSize; var angle = Math.random() * Math.PI / 2 - Math.PI / 4; var speed = Math.random() * 5 + 10; particle.velocityX = Math.cos(angle) * speed * directionSign; // Use provided vertical trajectory if available, otherwise use default calculation if (verticalTrajectory !== undefined) { // Add some randomness while maintaining the general direction var randomFactor = Math.random() * 0.5 + 0.75; // 0.75 to 1.25 range particle.velocityY = verticalTrajectory * randomFactor; } else { particle.velocityY = Math.sin(angle) * speed; } particle.lifespan = 100; particle.fadeSpeed = 1 / 60; } }; self.update = function () { for (var i = self.activeParticles.length - 1; i >= 0; i--) { var particle = self.activeParticles[i]; particle.x += particle.velocityX; particle.y += particle.velocityY; particle.alpha -= particle.fadeSpeed; particle.lifespan--; if (particle.lifespan <= 0 || particle.alpha <= 0) { particle.alpha = 0; self.activeParticles.splice(i, 1); self.particles.push(particle); } } }; return self; }); var Platform = Container.expand(function () { var self = Container.call(this); var platformGraphics = self.attachAsset('platform', { anchorX: 0.5, anchorY: 0.5 }); self.speed = PLATFORM_SPEED; self.passed = false; self.update = function () { self.x -= PLATFORM_SPEED * gameSpeedMultiplier; if (self.x < -500) { self.destroy(); } }; return self; }); var CrumblePlatform = Platform.expand(function () { var self = Platform.call(this); // Override the sprite self.sprite = self.attachAsset('crumbleplatform', { anchorX: 0.5, anchorY: 0.5 }); self.originalY = 0; // Crumbling state self.isCrumbling = false; self.crumbleDelay = 60; // frames before breaking self.crumbleTimer = 0; self.triggered = false; self.broken = false; // Add this flag to prevent multiple breaks // Override update method self.update = function () { // Normal platform movement self.x -= PLATFORM_SPEED * gameSpeedMultiplier; // Handle crumbling state if (self.isCrumbling && !self.broken) { // Quick shake effect var shakeIntensity = Math.min(6, 2 + (self.crumbleDelay - self.crumbleTimer) / 5); self.sprite.y = Math.random() * shakeIntensity * 2 - shakeIntensity; self.crumbleTimer--; // Only break when the timer is actually finished if (self.crumbleTimer <= 0) { self["break"](); } } // Check if off screen if (self.x < -500) { self.destroy(); } }; self.trigger = function () { if (!self.triggered && !self.broken) { LK.getSound('platformcrumble').play(); self.triggered = true; self.isCrumbling = true; self.crumbleTimer = self.crumbleDelay; self.sprite.originalY = self.sprite.y; } }; self["break"] = function () { if (self.broken) { return; } self.broken = true; LK.getSound('rocksfall').play(); // CRITICAL FIX: Remove from platforms array BEFORE updating entities var index = platforms.indexOf(self); if (index !== -1) { platforms.splice(index, 1); } // Force all entities on this platform to fall if (player && player.currentPlatform === self) { player.isOnGround = false; player.currentPlatform = null; player.velocityY = 3; // Stronger initial velocity } // Check all enemies too for (var i = 0; i < enemies.length; i++) { if (enemies[i].currentPlatform === self) { enemies[i].isOnGround = false; enemies[i].currentPlatform = null; enemies[i].velocityY = 1; } } // Spawn 10 pieces distributed across the platform width for (var i = 0; i < 10; i++) { var pieceNum = Math.floor(Math.random() * 3) + 1; var piece = new CrumblePiece(pieceNum); // Distribute pieces across the platform width var distributionOffset = i / 9 * PLATFORM_WIDTH - PLATFORM_HALF_WIDTH; piece.x = self.x + distributionOffset + (Math.random() * 80 - 40); // Add small random offset piece.y = self.y + (Math.random() * 30 - 15); // Small vertical variation // Vary the falling speeds and behaviors piece.velocityX = -PLATFORM_SPEED + (Math.random() * 2 - 1); // Slight x variation piece.velocityY = Math.random() * 3; // Some pieces fall faster than others piece.rotationSpeed = (Math.random() - 0.5) * 0.25; // More varied rotation game.addChild(piece); } self.destroy(); }; return self; }); // Player class with refactored animation management var Player = Container.expand(function () { var self = Container.call(this); // Animation properties self.runAnimation = ['playerrun1', 'playerrun2', 'playerrun3', 'playerrun4', 'playerrun5', 'playerrun6']; self.jumpAnimation = ['playerjump1', 'playerjump2', 'playerjump3']; self.attackAnimation = ['playerattack1', 'playerattack2', 'playerattack3', 'playerattack4', 'playerattack5']; self.airAttackAnimation = ['playerairattack1', 'playerairattack2', 'playerairattack3', 'playerairattack4']; self.slideAnimation = ['playerslide1', 'playerslide2']; self.standUpAnimation = ['playerstand1', 'playerstand2', 'playerstand3']; self.deathAnimation = ['playerdie1', 'playerdie2', 'playerdie3', 'playerdie4', 'playerdie5', 'playerdie6', 'playerdie7']; self.bowAnimation = ['playerbow4', 'playerbow5', 'playerbow6', 'playerbow7', 'playerbow8', 'playerbow9']; self.airDashAnimation = ['playerairdash']; self.groundSlamAnimation = ['playergroundslam1', 'playergroundslam2', 'playergroundslam3', 'playergroundslam4', 'playergroundslam5', 'playergroundslam6']; // Bow properties self.isShooting = false; self.bowFrame = 0; self.bowCooldown = 20; // Frames of cooldown self.bowCooldownTimer = 0; self.ammoCount = 5; // Animation states self.isAttacking = false; self.attackFrame = 0; self.runFrame = 0; self.animationSpeed = 0.092; self.attackAnimationSpeed = 0.15; self.animationCounter = 0; self.sprites = []; // Death animation properties self.isDying = false; self.deathFrame = 0; self.deathTimer = 0; self.deathDuration = 100; self.deathAnimationSpeed = 0.1; // Physics properties self.groundY = GAME_HEIGHT * 0.9; self.hitboxWidth = 150; self.hitboxHeight = 300; self.attackHitboxWidth = 200; self.attackHitboxHeight = 400; self.attackHitboxOffset = 50; // Platform collision properties self.isOnGround = true; self.currentPlatform = null; // Health properties self.heartContainer = heartContainer; self.maxHealth = 3; self.currentHealth = 3; self.isInvulnerable = false; self.invulnerabilityDuration = 90; self.invulnerabilityTimer = 0; self.heartVisibilityTimer = 0; self.heartVisibilityDuration = 120; // Movement properties self.speed = 5; self.jumpHeight = 40; self.isJumping = false; self.velocityY = 0; self.jumpState = "none"; self.jumpStartTime = 0; self.isSliding = false; self.slideTimer = 0; self.slideDuration = 100; self.standUpDuration = 30; self.slideCooldown = 30; self.lastSlideTime = 0; self.slideSpeedMultiplier = 1.75; self.slideDamage = false; // Will be set based on upgrade self.slideDamageCooldown = 15; // Frames between slide damage hits self.slideDamageTimer = 0; // Current cooldown timer self.normalHitboxHeight = self.hitboxHeight; // Store original height self.slideHitboxHeight = 200; // Make it taller self.slideHitboxYOffset = 150; // Move it much lower self.isAirDashing = false; self.canAirDash = true; // Reset when landing self.airDashTimer = 0; self.airDashDuration = 100; // Half of slide duration since it's faster self.airDashSpeedMultiplier = 2.3; // Slightly faster than slide self.shadowImages = []; // Add ground slam properties self.isGroundSlamming = false; self.groundSlamFrame = 0; self.groundSlamPhase = "start"; // "start", "air", "impact" self.canGroundSlam = true; // Can only ground slam once per jump self.groundSlamAnimationSpeed = 0.15; self.groundSlamImpactTimer = 0; // Initialize animation sprites self.initAnimations = function () { // Run animations for (var i = 0; i < self.runAnimation.length; i++) { var sprite = self.attachAsset(self.runAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Jump animations for (var i = 0; i < self.jumpAnimation.length; i++) { var sprite = self.attachAsset(self.jumpAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Attack animations for (var i = 0; i < self.attackAnimation.length; i++) { var sprite = self.attachAsset(self.attackAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Air attack animations for (var i = 0; i < self.airAttackAnimation.length; i++) { var sprite = self.attachAsset(self.airAttackAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add slide animations for (var i = 0; i < self.slideAnimation.length; i++) { var sprite = self.attachAsset(self.slideAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add stand up animations for (var i = 0; i < self.standUpAnimation.length; i++) { var sprite = self.attachAsset(self.standUpAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add death animations for (var i = 0; i < self.deathAnimation.length; i++) { var sprite = self.attachAsset(self.deathAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add bow animations for (var i = 0; i < self.bowAnimation.length; i++) { var sprite = self.attachAsset(self.bowAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Add air dash animation for (var i = 0; i < self.airDashAnimation.length; i++) { var sprite = self.attachAsset(self.airDashAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } for (var i = 0; i < self.groundSlamAnimation.length; i++) { var sprite = self.attachAsset(self.groundSlamAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }; // Call initialization self.initAnimations(); // Get collision bounds self.getBounds = function () { // For collecting items, always use the full-size hitbox return { left: self.x - self.hitboxWidth / 2, right: self.x + self.hitboxWidth / 2, top: self.y - self.normalHitboxHeight / 2, bottom: self.y + self.normalHitboxHeight / 2 }; }; // Get attack hitbox self.getAttackBounds = function () { if (!self.isAttacking || self.isSliding) { // Add sliding check here return null; } return { left: self.x + (self.attackHitboxOffset - self.attackHitboxWidth / 2), right: self.x + (self.attackHitboxOffset + self.attackHitboxWidth / 2), top: self.y - self.attackHitboxHeight / 2, bottom: self.y + self.attackHitboxHeight / 2 }; }; self.getSlideAttackBounds = function () { if (!self.isSliding) { return null; } return { left: self.x + self.hitboxWidth / 2, // Extend hitbox forward during slide right: self.x + self.hitboxWidth / 2 + 100, // Adjust width as needed top: self.y - self.slideHitboxHeight / 2 + self.slideHitboxYOffset, bottom: self.y + self.slideHitboxHeight / 2 + self.slideHitboxYOffset }; }; self.getCollisionBounds = function () { if (self.isSliding) { return { left: self.x - self.hitboxWidth / 2, right: self.x + self.hitboxWidth / 2, top: self.y - self.slideHitboxHeight / 2 + self.slideHitboxYOffset, bottom: self.y + self.slideHitboxHeight / 2 + self.slideHitboxYOffset }; } return self.getBounds(); }; // Update heart container self.updateHeartContainer = function () { self.heartContainer.x = self.x + 80; self.heartContainer.y = self.y - 200; // Handle heart visibility if (self.heartVisibilityTimer > 0) { self.heartVisibilityTimer--; if (self.heartVisibilityTimer <= 0) { self.heartContainer.alpha = 0; } } }; // Update invulnerability state self.updateInvulnerability = function () { if (self.isInvulnerable) { self.invulnerabilityTimer--; // Flash only the player, not the hearts self.alpha = self.invulnerabilityTimer % 10 < 5 ? 0.5 : 1; if (self.invulnerabilityTimer <= 0) { self.isInvulnerable = false; self.alpha = 1; } } }; // Handle platform collision self.handlePlatformCollision = function () { // Check if on any platform var onAnyPlatform = false; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; // Use EXACT platform bounds for edge detection - no added buffer var leftEdge = platform.x - PLATFORM_HALF_WIDTH; var rightEdge = platform.x + PLATFORM_HALF_WIDTH; // Check if player is within horizontal bounds of platform if (self.x >= leftEdge && self.x <= rightEdge) { // If we're at platform height and not jumping if (Math.abs(self.y - (platform.y - PLAYER_PLATFORM_OFFSET)) < 5 && !self.isJumping) { onAnyPlatform = true; // Add this check for crumble platforms if (platform instanceof CrumblePlatform) { platform.trigger(); } self.currentPlatform = platform; self.y = platform.y - PLAYER_PLATFORM_OFFSET; self.isOnGround = true; self.velocityY = 0; break; } } } // Handle falling state if (!onAnyPlatform && !self.isJumping) { self.isOnGround = false; self.currentPlatform = null; // Apply gravity if (self.velocityY === 0) { self.velocityY = 0.1; } } // If on a platform, check if still above it - use EXACT edge detection if (self.currentPlatform) { // Add check for destroyed platform if (self.currentPlatform.destroyed || self.currentPlatform.broken) { self.isOnGround = false; self.currentPlatform = null; if (self.velocityY === 0) { self.velocityY = 0.1; } return; } // Use EXACT platform bounds - no buffer for edge detection when moving var stillOnPlatform = self.x >= self.currentPlatform.x - PLATFORM_HALF_WIDTH && self.x <= self.currentPlatform.x + PLATFORM_HALF_WIDTH; if (!stillOnPlatform) { var foundAnotherPlatform = false; for (var i = 0; i < platforms.length; i++) { var otherPlatform = platforms[i]; if (otherPlatform === self.currentPlatform) { continue; } // Use EXACT platform bounds for other platforms too if (self.x >= otherPlatform.x - PLATFORM_HALF_WIDTH && self.x <= otherPlatform.x + PLATFORM_HALF_WIDTH) { // Found another platform self.currentPlatform = otherPlatform; foundAnotherPlatform = true; break; } } // Fall if no other platform found if (!foundAnotherPlatform) { self.isOnGround = false; self.currentPlatform = null; self.velocityY = 0.1; } } } }; // Apply physics (separated from animation) - fixed to check collisions for ALL falling cases self.applyPhysics = function () { // First, check if current platform reference is valid if (self.currentPlatform && (self.currentPlatform.destroyed || self.currentPlatform instanceof CrumblePlatform && self.currentPlatform.broken)) { // Force falling state if platform reference is to a broken/destroyed platform self.isOnGround = false; self.currentPlatform = null; if (self.velocityY < 1) { self.velocityY = 1; // Ensure downward movement begins } } // Then apply normal physics if (!self.isOnGround || self.isJumping) { // Apply velocity and gravity self.y += self.velocityY; self.velocityY += 0.89; // Increase gravity effect // Check for landing on platforms var hitPlatform = self.checkPlatformCollision(); } // Check for falling off screen - but instead of immediate game over, // let player continue to fall, then trigger game over after 3 seconds if (self.y > GAME_HEIGHT && !self.isDying && !self.dyingInAir) { // Start death animation instead of immediately showing game over SaveManager.save(); self.isDying = true; self.deathTimer = 0; self.deathFrame = 0; // Set game speed multiplier to 0 when player dies gameSpeedMultiplier = 0; // Stop background music and play gameover sound LK.stopMusic(); LK.getSound('gameover').play(); // Flash screen LK.effects.flashScreen(0xff0000, 1000); // Schedule game over call after 3 seconds LK.setTimeout(function () { LK.showGameOver(); }, 3000); } }; // Update attack animation self.updateAttackAnimation = function () { var attackOffset = self.runAnimation.length + self.jumpAnimation.length; self.animationCounter += self.attackAnimationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.attackFrame++; if (self.attackFrame >= self.attackAnimation.length) { self.isAttacking = false; self.attackFrame = 0; } } self.sprites[attackOffset + self.attackFrame].alpha = 1; }; // Update air attack animation self.updateAirAttackAnimation = function () { var airAttackOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length; self.animationCounter += self.attackAnimationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.attackFrame++; if (self.attackFrame >= self.airAttackAnimation.length) { self.isAttacking = false; self.attackFrame = 0; } } self.sprites[airAttackOffset + self.attackFrame].alpha = 1; }; // Update jump animation (only animation, not physics) self.updateJumpAnimation = function () { var jumpOffset = self.runAnimation.length; var currentTime = Date.now(); // Show appropriate jump frame if (currentTime - self.jumpStartTime < 100) { self.sprites[jumpOffset + 0].alpha = 1; } else if (self.velocityY < 0) { self.sprites[jumpOffset + 1].alpha = 1; } else if (self.velocityY > 0) { self.sprites[jumpOffset + 2].alpha = 1; } }; // Update slide animation self.updateSlideAnimation = function () { var slideOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length + self.airAttackAnimation.length; var standUpOffset = slideOffset + self.slideAnimation.length; self.slideTimer--; if (self.slideTimer > self.standUpDuration) { // Main slide animation (alternate between first two frames) self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; } var slideFrame = Math.floor(self.animationCounter * 2); self.sprites[slideOffset + slideFrame].alpha = 1; // Create dust particles behind player during slide (every 5 frames) if (LK.ticks % 5 === 0) { // Create 2-3 particles per emission var particleCount = 2 + Math.floor(Math.random() * 2); for (var i = 0; i < particleCount; i++) { var particle = game.addChild(LK.getAsset('pixel', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.1 + Math.random() * 0.2, scaleY: 0.1 + Math.random() * 0.2, alpha: 0.7 + Math.random() * 0.3 })); // Position particles behind player near ground level particle.x = self.x + 120 - Math.random() * 50; particle.y = self.y + 145 + Math.random() * 40; // Set velocities with slight variation particle.velocityX = -Math.random() * 3 - 1; particle.velocityY = -Math.random() * 2; // Add slight random rotation particle.rotationSpeed = (Math.random() - 0.5) * 0.1; particle.lifespan = 20 + Math.floor(Math.random() * 15); // Add update method to particles particle.update = function () { this.x += this.velocityX; this.y += this.velocityY; this.rotation += this.rotationSpeed; this.lifespan--; if (this.lifespan < 10) { this.alpha -= 0.1; } if (this.lifespan <= 0) { this.destroy(); } }; } } } else if (self.slideTimer > 0) { // Stand up animation var standUpFrame = Math.floor((self.standUpDuration - self.slideTimer) / (self.standUpDuration / self.standUpAnimation.length)); self.sprites[standUpOffset + standUpFrame].alpha = 1; } else { // End slide if (self.slideTimer <= 0) { self.isSliding = false; self.hitboxHeight = self.normalHitboxHeight; self.lastSlideTime = Date.now(); // Reset speed multiplier instead of base speed gameSpeedMultiplier = 1.0; } } }; self.updateAirDashAnimation = function () { // Calculate offset to find air dash animation sprite var airDashOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length + self.airAttackAnimation.length + self.slideAnimation.length + self.standUpAnimation.length + self.deathAnimation.length + self.bowAnimation.length; // Show air dash sprite self.sprites[airDashOffset].alpha = 1; // Add quick clockwise rotation during air dash if (self.airDashTimer === self.airDashDuration) { // Reset rotation at start of dash self.rotation = 0; // Play air dash sound effect LK.getSound('airdash').play(); // Start rotation tween - make it happen faster and then hold value tween(self, { rotation: Math.PI / 8 // Rotate about 30 degrees clockwise }, { duration: 100, // Much faster rotation (300ms instead of ~1.5s) easing: tween.easeOut // No onFinish needed since we'll hold this rotation for the dash duration }); } // Keep vertical velocity at 0 during dash self.velocityY = 0; // Update shadow positions with slight motion effect self.shadowImages.forEach(function (shadow, index) { // Add slight vertical variation to shadows for more dynamic feel var verticalOffset = Math.sin(self.airDashTimer * 0.1 + index * 0.5) * 10; // Adjust spacing and position for a more dramatic trail effect shadow.x = self.x - (80 * (index + 1) + (self.airDashDuration - self.airDashTimer) * 0.5); shadow.y = self.y + verticalOffset; shadow.alpha = 0.3 - index * 0.05; // More gradual fade out for longer trails // Add slight rotation to shadows shadow.rotation = self.rotation * (0.6 - index * 0.1); // Less rotation for farther shadows }); self.airDashTimer--; if (self.airDashTimer <= 0) { self.isAirDashing = false; gameSpeedMultiplier = 1.0; // Reset rotation back to normal when dash ends tween(self, { rotation: 0 }, { duration: 300, easing: tween.easeOut }); // Clean up shadows self.shadowImages.forEach(function (shadow) { if (shadow.parent) { shadow.destroy(); } }); self.shadowImages = []; } }; self.updateBowAnimation = function () { var bowOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length + self.airAttackAnimation.length + self.slideAnimation.length + self.standUpAnimation.length + self.deathAnimation.length; self.animationCounter += self.attackAnimationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.bowFrame++; // Spawn arrow at frame 5 if (self.bowFrame === 5) { // If in tutorial, always spawn arrow if (tutorialActive) { var arrow = new Arrow(); arrow.x = self.x + 100; arrow.y = self.y + 20; arrow.startX = arrow.x; arrow.startY = arrow.y; arrow.rotation = 0; // Default right direction for tutorial game.addChild(arrow); arrows.push(arrow); LK.getSound('arrowfire').play(); } else if (self.ammoCount > 0) { var arrow = new Arrow(); arrow.x = self.x + 100; arrow.y = self.y + 20; arrow.startX = arrow.x; arrow.startY = arrow.y; // Smart initial aiming for tracking arrows var initialRotation = 0; // Default straight right if (UPGRADE_REGISTRY.tracking_arrow > 0 && enemies && enemies.length > 0) { // Find the best target within a reasonable cone var bestTarget = null; var bestScore = -1; var coneAngle = Math.PI / 3; // 60 degree cone (30 degrees up/down from horizontal) var maxDistance = 1000; // Maximum distance to consider for initial aiming for (var i = 0; i < enemies.length; i++) { var enemy = enemies[i]; if (!enemy || enemy.isDying || enemy.isHit || enemy.destroyed || enemy.x < self.x) { continue; } var dx = enemy.x - arrow.x; var dy = enemy.y - arrow.y; var distance = Math.sqrt(dx * dx + dy * dy); var angleToEnemy = Math.atan2(dy, dx); // Check if enemy is within cone and reasonable distance if (distance <= maxDistance && Math.abs(angleToEnemy) <= coneAngle / 2) { // Score based on proximity and how centered they are in the cone var centeredness = 1 - Math.abs(angleToEnemy) / (coneAngle / 2); var proximity = 1 - distance / maxDistance; var score = centeredness * 0.6 + proximity * 0.4; if (score > bestScore) { bestScore = score; bestTarget = enemy; } } } // If we found a good target, aim at it initially if (bestTarget) { initialRotation = Math.atan2(bestTarget.y - arrow.y, bestTarget.x - arrow.x); } } arrow.rotation = initialRotation; arrow.sprite.rotation = initialRotation; game.addChild(arrow); arrows.push(arrow); LK.getSound('arrowfire').play(); } else { // Play bow fire sound effect when no ammo LK.getSound('bowfiring').play(); } } if (self.bowFrame >= self.bowAnimation.length) { self.isShooting = false; self.bowFrame = 0; self.bowCooldownTimer = self.bowCooldown; } } self.sprites[bowOffset + self.bowFrame].alpha = 1; }; // Update death animation self.updateDeathAnimation = function () { // Calculate offset to find the death animation sprites var deathOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length + self.airAttackAnimation.length + self.slideAnimation.length + self.standUpAnimation.length; // Progress timer self.deathTimer++; // Calculate frame based on timer // We want the animation to play through all frames over the death duration var frameProgress = self.deathTimer / self.deathDuration * self.deathAnimation.length; var newFrame = Math.min(Math.floor(frameProgress), self.deathAnimation.length - 1); // Update frame if it's changed if (newFrame != self.deathFrame) { self.deathFrame = newFrame; } // Show current frame self.sprites[deathOffset + self.deathFrame].alpha = 1; // Death animation is complete, but game over is handled by the timeout if (self.deathTimer >= self.deathDuration) { // Game over is now triggered by the timeout in takeDamage } }; // Update run animation self.updateRunAnimation = function () { self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; }; self.updateGroundSlamAnimation = function () { // Calculate offset to find ground slam animation sprites var groundSlamOffset = self.runAnimation.length + self.jumpAnimation.length + self.attackAnimation.length + self.airAttackAnimation.length + self.slideAnimation.length + self.standUpAnimation.length + self.deathAnimation.length + self.bowAnimation.length + self.airDashAnimation.length; // Create hitbox for the slam (used both in air and on impact) var slamHitbox = { left: self.x - 200, right: self.x + 200, top: self.y, bottom: self.y + 200 }; // Update animation based on phase if (self.groundSlamPhase === "start") { // Show first frame briefly self.sprites[groundSlamOffset].alpha = 1; self.animationCounter += self.attackAnimationSpeed; if (self.animationCounter >= 1) { self.groundSlamPhase = "air"; self.animationCounter = 0; } } else if (self.groundSlamPhase === "air") { // Alternate between frames 2 and 3 while falling self.animationCounter += self.attackAnimationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.groundSlamFrame = (self.groundSlamFrame + 1) % 2; } self.sprites[groundSlamOffset + 1 + self.groundSlamFrame].alpha = 1; // Check for enemies and breakables during descent self.checkGroundSlamHits(slamHitbox); // Check if we've hit the ground if (self.isOnGround) { self.groundSlamPhase = "impact"; self.groundSlamFrame = 0; self.groundSlamImpactTimer = 30; self.animationCounter = 0; // Apply screen shake effect on impact applyScreenShake(); LK.getSound('groundimpact').play(); // Do one final more powerful hit check on impact self.applyGroundSlamDamage(); } } else if (self.groundSlamPhase === "impact") { // Cycle through frames 4-6 for impact self.animationCounter += self.attackAnimationSpeed * 1.5; if (self.animationCounter >= 1) { self.animationCounter = 0; self.groundSlamFrame++; if (self.groundSlamFrame >= 3) { self.isGroundSlamming = false; return; } } self.sprites[groundSlamOffset + 3 + self.groundSlamFrame].alpha = 1; // Count down timer self.groundSlamImpactTimer--; if (self.groundSlamImpactTimer <= 0) { self.isGroundSlamming = false; } } }; self.applyGroundSlamDamage = function () { // Create larger hitbox for ground slam var slamHitbox = { left: self.x - 300, right: self.x + 300, top: self.y, bottom: self.y + 200 }; // Add particle spray effect when landing self.createGroundSlamParticles(); // Check all enemies for (var i = 0; i < enemies.length; i++) { var enemy = enemies[i]; if (!enemy.isHit && !enemy.isDying) { var enemyBounds = enemy.getBounds(); // If enemy is on ground and in range if (GameUtils.checkCollision(slamHitbox, enemyBounds) && (enemy.isOnGround || enemy.y > self.y)) { enemy.hit(); // Play appropriate sound if (enemy.type === 'eyeball') { LK.getSound('eyeballhit').play(); } else if (enemy.type === 'skeleton') { LK.getSound('skeletonhit').play(); } else { LK.getSound('enemyhit').play(); } // Create more particles for impact particleSystem.emitFromHit(enemy.x + 250, enemy.y, self.x, 5, enemy.type); } } } }; // Add a new method to create ground slam particles self.createGroundSlamParticles = function () { // Create a large number of particles for dramatic effect var particleCount = 25 + Math.floor(Math.random() * 10); for (var i = 0; i < particleCount; i++) { var particle = game.addChild(LK.getAsset('pixel', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.1 + Math.random() * 0.3, scaleY: 0.1 + Math.random() * 0.3, alpha: 0.7 + Math.random() * 0.3, // Keep particles untinted (white) tint: 0xFFFFFF })); // Position particles at the point of impact particle.x = self.x + Math.random() * 300 - 150; // Spread horizontally particle.y = self.y + 145; // Just above ground level // Set velocities with upward trajectory var angle = Math.PI / 2 + (Math.random() - 0.5) * 0.8; // Mostly upward with spread var speed = 3 + Math.random() * 9; // Varying speeds particle.velocityX = Math.cos(angle) * speed * (Math.random() > 0.5 ? 1 : -1); particle.velocityY = -Math.sin(angle) * speed; // Negative for upward // Add slight random rotation particle.rotationSpeed = (Math.random() - 0.5) * 0.2; // Longer lifespan for more dramatic effect particle.lifespan = 25 + Math.floor(Math.random() * 20); // Add update method to particles particle.update = function () { this.x += this.velocityX; this.y += this.velocityY; this.velocityY += 0.3; // Apply gravity this.rotation += this.rotationSpeed; this.lifespan--; // Start fading out near end of life if (this.lifespan < 10) { this.alpha -= 0.1; } if (this.lifespan <= 0 || this.alpha <= 0) { this.destroy(); } }; } }; self.checkGroundSlamHits = function (slamHitbox) { // Check enemies for (var i = 0; i < enemies.length; i++) { var enemy = enemies[i]; if (!enemy.isHit && !enemy.isDying) { var enemyBounds = enemy.getBounds(); if (GameUtils.checkCollision(slamHitbox, enemyBounds)) { enemy.hit(); // Play appropriate sound if (enemy.type === 'eyeball') { LK.getSound('eyeballhit').play(); } else if (enemy.type === 'skeleton') { LK.getSound('skeletonhit').play(); } else { LK.getSound('enemyhit').play(); } // Create particles particleSystem.emitFromHit(enemy.x + 250, enemy.y, self.x, 5, enemy.type); } } } // Check for breakable objects (jars and chests) for (var i = collectibles.length - 1; i >= 0; i--) { var collectible = collectibles[i]; // Only check jars and chests if (collectible instanceof Jar || collectible instanceof TreasureChest) { var itemBounds = { left: collectible.x - 50, right: collectible.x + 50, top: collectible.y - 75, bottom: collectible.y + 75 }; if (GameUtils.checkCollision(slamHitbox, itemBounds)) { collectible["break"](); collectibles.splice(i, 1); } } } }; // Modified applyLandingSquash function self.applyLandingSquash = function () { // More extreme initial squash values for better visibility var initialScaleX = 1.2; var initialScaleY = 0.8; var targetScaleX = 1.0; var targetScaleY = 1.0; var duration = 370; // ms - slightly longer duration // Apply squash to the entire player container instead of individual sprites self.scale.set(initialScaleX, initialScaleY); // Clear any existing scale tweens tween.stop(self.scale, { x: true, y: true }); // Tween back to normal scale with a slight delay LK.setTimeout(function () { tween(self.scale, { x: targetScaleX, y: targetScaleY }, { duration: duration, easing: tween.elasticOut // Keep the bouncier easing }); }, 90); // Slightly longer delay }; self.checkPlatformBelow = function () { if (!self.currentPlatform) { return null; } // Get current platform height var currentHeight = self.currentPlatform.y; // Find the closest platform below current one var platformBelow = null; var minDistance = Infinity; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; // Skip if it's not below us or if it's our current platform if (platform === self.currentPlatform || platform.y <= currentHeight) { continue; } // Check if we're within platform width bounds if (Math.abs(platform.x - self.x) < PLATFORM_HALF_WIDTH) { var distance = platform.y - currentHeight; if (distance < minDistance) { minDistance = distance; platformBelow = platform; } } } return platformBelow; }; // Check platform collision - fix to properly detect platforms when falling self.checkPlatformCollision = function () { // Update timer first if (self.brokenPlatformTimer > 0) { self.brokenPlatformTimer--; } for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; // Skip platforms that are broken or destroyed if (platform.broken || platform.destroyed) { continue; } // Skip this specific platform if it's the one that just broke if (self.brokenPlatformTimer > 0 && platform === self.lastBrokenPlatform) { continue; } // Keep the extra buffer for landing on platforms for a smoother experience // but ensure it's consistent with other checks if (self.velocityY > 0 && self.y < platform.y - PLAYER_PLATFORM_OFFSET && self.y + self.velocityY >= platform.y - PLAYER_PLATFORM_OFFSET - 20 && self.x >= platform.x - PLATFORM_HALF_WIDTH && self.x <= platform.x + PLATFORM_HALF_WIDTH) { // Add this check for crumble platforms if (platform instanceof CrumblePlatform) { platform.trigger(); } self.y = platform.y - PLAYER_PLATFORM_OFFSET; self.velocityY = 0; self.isJumping = false; self.isOnGround = true; self.currentPlatform = platform; self.applyLandingSquash(); if (self.isOnGround) { self.canAirDash = true; self.canGroundSlam = true; // Clear any remaining shadow images self.shadowImages.forEach(function (shadow) { if (shadow.parent) { shadow.destroy(); } }); self.shadowImages = []; } return true; } } return false; }; // Hide all sprites self.hideAllSprites = function () { for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } }; self.checkCollectibles = function () { // Always check for collectibles regardless of state for (var i = 0; i < coins.length; i++) { var coin = coins[i]; var itemBounds = { left: coin.x - 25, right: coin.x + 25, top: coin.y - 25, bottom: coin.y + 25 }; if (GameUtils.checkCollision(self.getBounds(), itemBounds)) { coin.collect(); } } }; // Jump method self.jump = function () { // Add a timestamp check specifically for tutorial if (!self.lastJumpTime) { self.lastJumpTime = 0; } var currentTime = Date.now(); if (tutorialActive && currentTime - self.lastJumpTime < 300) { return; // Block rapid jumps in tutorial } self.lastJumpTime = currentTime; if (self.isSliding || self.isShooting && self.bowFrame < 2) { // Only prevent jumps at start of bow animation return; } if (self.isOnGround) { self.isJumping = true; self.isOnGround = false; self.velocityY = -self.jumpHeight; self.jumpState = "start"; self.jumpStartTime = Date.now(); LK.getSound('playerjump').play(); self.currentPlatform = null; if (tutorialManager && tutorialManager.currentState === tutorialManager.states.DOUBLE_JUMP) { tutorialManager.firstJumpPerformed = true; } } else if (self.isJumping && self.velocityY < 10) { // Small double-jump to reach higher platforms self.velocityY = -self.jumpHeight * 0.7; self.jumpStartTime = Date.now(); if (tutorialManager && tutorialManager.currentState === tutorialManager.states.DOUBLE_JUMP) { tutorialManager.secondJumpPerformed = true; } } }; // Add slide method self.slide = function () { var currentTime = Date.now(); if (!self.isSliding && self.isOnGround && !self.isJumping && !self.isAttacking && currentTime - self.lastSlideTime > self.slideCooldown) { self.isSliding = true; self.slideTimer = self.slideDuration; self.hitboxHeight = self.slideHitboxHeight; self.animationCounter = 0; // Play slide sound effect LK.getSound('slide').play(); // Adjust game speed multiplier instead of base speed gameSpeedMultiplier = self.slideSpeedMultiplier; } }; self.airDash = function () { if (!self.canAirDash || self.isOnGround || self.isSliding || self.isAttacking || self.isShooting || self.isAirDashing) { return; } self.isAirDashing = true; self.airDashTimer = self.airDashDuration; self.canAirDash = false; self.velocityY = 0; // Create shadow images - increased from 2 to 4 for more dramatic effect for (var i = 0; i < 4; i++) { var shadow = game.addChild(LK.getAsset('playerairdash', { anchorX: 0.5, anchorY: 0.5, alpha: 0.3 - i * 0.05, // Adjusted alpha reduction to spread across more shadows x: self.x - 80 * (i + 1), // Adjusted spacing to create a tighter trail y: self.y })); self.shadowImages.push(shadow); } gameSpeedMultiplier = self.airDashSpeedMultiplier; }; // Attack method self.attack = function () { if (!self.isAttacking && !self.isSliding) { // Add sliding check here self.isAttacking = true; self.attackFrame = 0; self.animationCounter = 0; LK.getSound('swordslash').play(); } }; self.groundSlam = function () { if (!self.hasGroundSlam) { return; } // Only allow if in air, not already slamming, and can slam if (!self.isOnGround && !self.isGroundSlamming && self.canGroundSlam && !self.isSliding && !self.isAttacking && !self.isAirDashing && !self.isShooting) { self.isGroundSlamming = true; self.canGroundSlam = false; // Use up the slam for this jump self.groundSlamFrame = 0; self.groundSlamPhase = "start"; self.animationCounter = 0; // Boost downward velocity self.velocityY = 15; // Strong downward force // Play sound effect (can use sword slash for now) LK.getSound('groundsmashfalling').play(); } }; self.fallThrough = function () { if (self.isOnGround && !self.isJumping && !self.isSliding && !self.isAttacking) { var platformBelow = self.checkPlatformBelow(); if (platformBelow) { // Disable platform collision temporarily self.isOnGround = false; self.currentPlatform = null; self.velocityY = 5; // Start with a small downward velocity // Re-enable platform collision after a short delay LK.setTimeout(function () { self.checkPlatformCollision = self.originalCheckPlatformCollision; }, 250); // Adjust timing as needed // Store the original collision check and temporarily disable it self.originalCheckPlatformCollision = self.checkPlatformCollision; self.checkPlatformCollision = function () { return null; }; } } }; self.shoot = function () { // If in tutorial, only allow shooting during bow phase if (tutorialActive && tutorialManager.currentState !== tutorialManager.states.BOW) { return; } if (!self.isShooting && !self.isSliding && self.bowCooldownTimer <= 0) { if (self.isOnGround || !self.isOnGround) { // Allow shooting in air or ground self.isShooting = true; self.bowFrame = 0; self.animationCounter = 0; // If in tutorial, don't consume ammo if (!tutorialActive) { if (self.ammoCount <= 0) { // Play bow fire sound effect when no ammo LK.getSound('bowfiring').play(); return; } self.ammoCount--; scoreManager.updateAmmo(self.ammoCount); } // If in air, pause vertical movement if (!self.isOnGround) { self.velocityY = 0; } } } }; // Take damage method self.takeDamage = function () { if (!self.isInvulnerable && !self.isDying) { LK.getSound('playerouch').play(); self.currentHealth--; self.heartContainer.updateHealth(self.currentHealth); // Show hearts and set visibility timer self.heartContainer.alpha = 1; self.heartVisibilityTimer = self.heartVisibilityDuration; // Visual feedback self.isInvulnerable = true; self.invulnerabilityTimer = self.invulnerabilityDuration; // Flash player red self.tint = 0xFF0000; tween(self, { tint: 0xFFFFFF }, { duration: 500, easing: tween.easeOut }); // Add red screen flash LK.effects.flashScreen(0xff0000, 300); // Existing damage code... if (self.currentHealth <= 0) { // Save before game over SaveManager.save(); // If in the air, find the nearest platform to fall to if (!self.isOnGround) { // Start the dying sequence but let them fall first self.dyingInAir = true; // Find the closest platform below the player var closestPlatform = null; var closestDistance = Infinity; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; // Check if platform is below player and within horizontal range if (platform.y > self.y && Math.abs(platform.x - self.x) < PLATFORM_HALF_WIDTH) { var distance = platform.y - self.y; if (distance < closestDistance) { closestDistance = distance; closestPlatform = platform; } } } // If we found a platform, let player fall to it naturally // Otherwise proceed with normal death sequence if (!closestPlatform) { startDeathSequence(); } // Player will continue falling until they hit a platform or go off screen // The death sequence will be triggered in the update method } else { // Start death sequence immediately if already on ground startDeathSequence(); } } } function startDeathSequence() { // Start death animation self.isDying = true; self.deathTimer = 0; self.deathFrame = 0; // Set game speed multiplier to 0 when player dies gameSpeedMultiplier = 0; // Stop background music and play gameover sound LK.stopMusic(); LK.getSound('gameover').play(); // Flash screen LK.effects.flashScreen(0xff0000, 1000); // Apply one final screen shake for dramatic effect applyScreenShake(); // Schedule game over call after 2 seconds LK.setTimeout(function () { LK.showGameOver(); }, 2000); } }; // Main update method self.update = function () { // Update heart container self.updateHeartContainer(); // Hide all sprites self.hideAllSprites(); if (self.slideDamageTimer > 0) { self.slideDamageTimer--; } if (self.isAirDashing) { // Update air dash animation self.updateAirDashAnimation(); } // If player is dying but still in the air, apply physics to let them fall if (self.dyingInAir) { // Apply physics for falling self.applyPhysics(); // Check if they've landed on a platform if (self.isOnGround) { // They've landed, now start the death sequence self.dyingInAir = false; self.isDying = true; self.deathTimer = 0; self.deathFrame = 0; gameSpeedMultiplier = 0; LK.stopMusic(); LK.getSound('gameover').play(); LK.effects.flashScreen(0xff0000, 1000); applyScreenShake(); LK.setTimeout(function () { LK.showGameOver(); }, 2000); } // Show falling animation var jumpOffset = self.runAnimation.length; self.sprites[jumpOffset + 2].alpha = 1; // Show falling frame return; } // If player is dying normally, only update death animation if (self.isDying) { self.updateDeathAnimation(); return; } // Update bow cooldown if (self.bowCooldownTimer > 0) { self.bowCooldownTimer--; } // Apply physics FIRST - this now happens regardless of animation state if (!self.isAirDashing) { self.applyPhysics(); } // Handle platform collision and falling self.handlePlatformCollision(); // Handle invulnerability self.updateInvulnerability(); // Update animations based on state if (self.isGroundSlamming) { self.updateGroundSlamAnimation(); } else if (self.isAirDashing) { self.updateAirDashAnimation(); } else if (self.isShooting) { self.updateBowAnimation(); } else if (self.isSliding) { self.updateSlideAnimation(); self.checkCollectibles(); // Explicitly check during slide } else if (self.isAttacking) { if (self.isJumping || !self.isOnGround && !self.isSliding) { self.updateAirAttackAnimation(); } else { self.updateAttackAnimation(); } } else if (self.isJumping || !self.isOnGround) { self.updateJumpAnimation(); } else if (self.isOnGround) { self.updateRunAnimation(); } // Check for falling off screen if (self.y > GAME_HEIGHT && !self.isDying) { // Start death animation instead of immediately showing game over self.isDying = true; self.deathTimer = 0; self.deathFrame = 0; LK.effects.flashScreen(0xff0000, 1000); } }; return self; }); var ScorePopup = Container.expand(function (x, y, amount) { var self = Container.call(this); // Create the text using CustomText instead of Text2 self.text = new CustomText('+' + amount, { size: 70, fill: 0xFFFFFF }); self.addChild(self.text); self.x = x; self.y = y; self.velocityY = -3; self.lifespan = 45; self.update = function () { self.y += self.velocityY; self.lifespan--; if (self.lifespan < 15) { self.alpha -= 0.07; } if (self.alpha <= 0 || self.lifespan <= 0) { self.destroy(); } }; return self; }); var ShopManager = Container.expand(function () { var self = Container.call(this); self.categories = ['Health', 'Combat', 'Ranged', 'Loot', 'Spells']; self.currentCategory = 'Health'; self.currentUpgradeIndex = 0; // Track current upgrade in category self.categoryUpgrades = []; // Store current category's upgrades self.selectedUpgrade = null; // Define upgrades with proper effects - no storage modification self.upgrades = [{ id: 'health_increase', category: 'Health', title: 'Heart Container', description: 'Increase maximum health by one heart', basePrice: 300, maxLevel: 2, icon: 'health_increase_icon', // Effect only for immediate visual feedback in shop effect: function effect(level) { console.log("Health upgrade purchased: level " + level); // Could update preview if needed } }, { id: 'arrow_capacity', category: 'Ranged', title: 'Quiver Expansion', description: 'Start with more arrows', basePrice: 100, maxLevel: 5, icon: 'arrow_capacity_icon', effect: function effect(level) { console.log("Arrow capacity upgrade purchased: level " + level); } }, // --- Tracking Arrow upgrade inserted here --- { id: 'tracking_arrow', category: 'Ranged', title: 'Magic Arrow', description: 'Arrows gain basic homing capabilities and can ricochet to nearby enemies', basePrice: 1200, maxLevel: 1, icon: 'arrow_finder_icon', effect: function effect(level) { console.log("Tracking Arrow upgrade purchased: level " + level); } }, // --- End Tracking Arrow upgrade --- { id: 'levitate', category: 'Spells', title: 'Levitate', description: 'Coming soon.', basePrice: 99999, maxLevel: 0, icon: 'levitate_icon', effect: function effect(level) { console.log("Levitate upgrade purchased: level " + level); } }, { id: 'slide_damage', category: 'Combat', title: 'Crushing Slide', description: 'Sliding now damages enemies', basePrice: 1000, maxLevel: 1, icon: 'icon_combat', effect: function effect(level) { console.log("Slide damage upgrade purchased: level " + level); } }, { id: 'ground_slam', category: 'Combat', title: 'Ground Slam', description: 'Smash downward by swiping down from the air to damage enemies below', basePrice: 1000, maxLevel: 1, icon: 'icon_combat', effect: function effect(level) { console.log("Ground slam upgrade purchased: level " + level); } }, { id: 'better_loot', category: 'Loot', title: 'Fortune Finder', description: 'Increase chances of finding valuable loot', basePrice: 400, maxLevel: 4, icon: 'icon_treasure', effect: function effect(level) {} }, { id: 'potion_chance', category: 'Health', title: 'Potion Finder', description: 'Increases the chance of health potions dropping from breakable objects', basePrice: 300, // Cheaper than health container (600) maxLevel: 3, icon: 'healthpotion', effect: function effect(level) {} }, { id: 'arrow_finder', category: 'Ranged', title: 'Arrow Finder', description: 'Increases the chance of arrows dropping from breakable objects', basePrice: 300, maxLevel: 3, icon: 'arrow_capacity_icon', effect: function effect(level) {} }, { id: 'loot_magnet', category: 'Loot', title: 'Loot Magnet', description: 'Increases collection range for coins and items', basePrice: 300, maxLevel: 3, icon: 'icon_treasure', effect: function effect(level) { console.log("Loot magnet upgrade purchased: level " + level); } }]; // Create tabs self.createTabs(); // Create upgrade list self.upgradeList = new Container(); self.addChild(self.upgradeList); // Create buy button self.createBuyButton(); self.initPlayerAnimation(); // Initial setup self.showCategory('Health'); self.createArrows(); return self; }); var ShopUpgrade = Container.expand(function (config) { var self = Container.call(this); // Keep all existing properties self.id = config.id; self.category = config.category; self.title = config.title; self.description = config.description; self.basePrice = config.basePrice; self.level = 0; self.maxLevel = config.maxLevel || 1; self.icon = config.icon; self.effect = config.effect; // Create a container for the window contents self.windowContainer = new Container(); self.addChild(self.windowContainer); // Add background to the container self.background = self.windowContainer.attachAsset('shop_window', { anchorX: 0.5, anchorY: 0.5 }); self.iconSprite = self.windowContainer.attachAsset(self.id + '_icon', { anchorX: 0.5, anchorY: 0.5 }); self.iconSprite.x = -330; self.iconSprite.y = -500; self.titleText = new CustomText(self.title, { size: 50, fill: 0xE6D5AC, letterSpacing: 5 }); self.windowContainer.addChild(self.titleText); self.titleText.x = -200; self.titleText.y = -500; self.descriptionText = new CustomText(self.description + '.', { size: 45, fill: 0xA89F8A, letterSpacing: 5, wordWrapWidth: 800, wordWrap: true }); self.windowContainer.addChild(self.descriptionText); self.descriptionText.x = -370; self.descriptionText.y = -350; self.levelText = new CustomText('LEVEL ' + self.level + (self.level >= self.maxLevel ? ' MAX' : ''), { size: 60, fill: 0xE6D5AC, letterSpacing: 5 }); self.windowContainer.addChild(self.levelText); self.levelText.x = -370; self.levelText.y = 530; // Methods with proper separation of concerns self.getCurrentPrice = function () { return self.basePrice * Math.pow(2, self.level); }; self.canPurchase = function (gold) { return self.level < self.maxLevel && gold >= self.getCurrentPrice(); }; self.purchase = function () { if (self.level < self.maxLevel) { this.level++; // UPDATE THE REGISTRY switch (this.id) { case 'health_increase': UPGRADE_REGISTRY.health_increase = this.level; break; case 'arrow_capacity': UPGRADE_REGISTRY.arrow_capacity = this.level; break; case 'levitate': UPGRADE_REGISTRY.levitate = this.level; break; case 'slide_damage': UPGRADE_REGISTRY.slide_damage = this.level; break; case 'better_loot': UPGRADE_REGISTRY.better_loot = this.level; break; case 'potion_chance': UPGRADE_REGISTRY.potion_chance = this.level; break; case 'arrow_finder': UPGRADE_REGISTRY.arrow_finder = this.level; break; case 'ground_slam': UPGRADE_REGISTRY.ground_slam = this.level; break; case 'loot_magnet': UPGRADE_REGISTRY.loot_magnet = this.level; break; case 'tracking_arrow': UPGRADE_REGISTRY.tracking_arrow = this.level; break; } // Update UI text this.levelText.setText('LEVEL ' + this.level + (this.level >= this.maxLevel ? ' MAX' : '')); // Apply the effect for immediate feedback this.effect(this.level); return true; } return false; }; }); // Add ShopUpgrade.prototype methods here var SkeletonSword = Container.expand(function () { var self = Container.call(this); // Attach the sword sprite self.sprite = self.attachAsset('skeletonsword', { anchorX: 0.5, anchorY: 0.5 }); // Set properties with default values self.speed = 6; self.rotationSpeed = -0.1; self.constantVelocity = 8; // Can be overridden when created // Update method called every frame self.update = function () { // Use constantVelocity if set, otherwise fall back to speed * gameSpeedMultiplier var velocity = self.constantVelocity || self.speed * gameSpeedMultiplier; // Move the sword self.x -= velocity; // Rotate counterclockwise self.sprite.rotation += self.rotationSpeed; // Destroy if off screen if (self.x < -100) { self.destroy(); } }; // Get bounds for collision detection self.getBounds = function () { return { left: self.x - 40, right: self.x + 40, top: self.y - 40, bottom: self.y + 40 }; }; return self; }); var Spore = Container.expand(function () { var self = Container.call(this); // Animation properties self.frame = 0; self.animationCounter = 0; self.animationSpeed = 0.035; self.sprites = []; // Physics properties self.velocityX = 0; self.velocityY = 0; self.lifespan = 180; // Increased lifespan self.initialSpeed = 4.0; // Slower initial speed self.speed = self.initialSpeed; self.damage = 1; self.isExploding = false; self.hasHitPlayer = false; self.isActive = true; // New flag to track if this spore is still active for collision // Initialize animation sprites for (var i = 1; i <= 8; i++) { var sprite = self.attachAsset('spore' + i, { anchorX: 0.5, anchorY: 0.5, scaleX: 1.3, scaleY: 1.3 }); sprite.alpha = i === 1 ? 1 : 0; self.sprites.push(sprite); } // Get collision bounds - only return bounds if the spore is active self.getBounds = function () { if (!self.isActive) { // Return a dummy bounds that can't possibly collide with anything return { left: -9999, right: -9999, top: -9999, bottom: -9999 }; } return { left: self.x - 40, right: self.x + 40, top: self.y - 40, bottom: self.y + 40 }; }; // Override the destroy method to ensure proper cleanup var originalDestroy = self.destroy; self.destroy = function () { self.isActive = false; // Mark as inactive first // Remove from global spores array if it exists if (window.spores) { var index = window.spores.indexOf(self); if (index !== -1) { window.spores.splice(index, 1); } } // Call the original destroy method originalDestroy.call(self); }; // Hide all sprites self.hideAllSprites = function () { for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } }; // Start explosion animation self.explode = function () { if (!self.isExploding) { self.isExploding = true; self.frame = 4; // Start at explosion frame self.lifespan = Math.min(self.lifespan, 30); // Short explosion time // Stop movement self.velocityX *= 0.3; self.velocityY *= 0.3; // Deactivate the spore for collision once explosion starts self.isActive = false; } }; // Update method self.update = function () { // Hide all sprites first self.hideAllSprites(); // Move spore self.x += self.velocityX; self.y += self.velocityY; // Apply platform movement to match world movement self.x -= PLATFORM_SPEED * gameSpeedMultiplier; // Update animation self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.frame = (self.frame + 1) % self.sprites.length; } self.sprites[self.frame].alpha = 1; // Decrease lifespan self.lifespan--; // Start fading out near end of life if (self.lifespan < 30) { self.alpha = self.lifespan / 30; } // Destroy if off screen or lifespan ended if (self.x < -100 || self.x > GAME_WIDTH + 100 || self.y < -100 || self.y > GAME_HEIGHT + 100 || self.lifespan <= 0) { self.destroy(); } }; return self; }); /**** * Constants ****/ var Torch = Container.expand(function () { var self = Container.call(this); // Create base torch sprite self.base = self.attachAsset('torch', { anchorX: 0.5, anchorY: 1 }); // Create flame sprite self.flame = self.attachAsset('torchflame', { anchorX: 0.5, anchorY: 1, y: -180 }); // Create aura sprite self.aura = self.attachAsset('torchaura', { anchorX: 0.5, anchorY: 0.5, alpha: 0.3, y: -250 }); // Animation properties self.flameTime = Math.random() * Math.PI * 2; self.auraTime = Math.random() * Math.PI * 2; self.flameSpeed = 0.05; self.auraSpeed = 0.03; // Update animation self.update = function () { // Animate flame scale self.flameTime += self.flameSpeed; var flameScale = 1 + Math.sin(self.flameTime) * 0.2; self.flame.scaleY = flameScale; // Random flip chance for flame if (Math.random() < 0.02) { self.flame.scaleX *= -1; } // Animate aura alpha self.auraTime += self.auraSpeed; var auraAlpha = 0.3 + Math.sin(self.auraTime) * 0.15; self.aura.alpha = auraAlpha; }; return self; }); var TreasureChest = Container.expand(function () { var self = Container.call(this); // Attach chest sprite self.sprite = self.attachAsset('treasurechest', { anchorX: 0.5, anchorY: 0.5, tint: 0xC0C0C0 }); // Initialize as breakable BreakableBehavior.initBreakable(self); // Break functionality self["break"] = function () { BreakableBehavior.standardBreak(self, TreasureChestPiece, 4, function (chest) { // Get loot multiplier from player var lootMultiplier = player.lootMultiplier || 1.0; // Spawn health potion with medium chance - improved by loot multiplier if (Math.random() < 0.25 * (player.potionDropChance || 1.0)) { var potion = new HealthPotion(); potion.x = chest.x; potion.y = chest.y; potion.velocityX = GameUtils.randomRange(1, 6); // Reduced horizontal velocity potion.velocityY = -GameUtils.randomRange(8, 16); // Reduced vertical velocity game.addChild(potion); coins.push(potion); } // Higher chance for arrows - improved by loot multiplier if (Math.random() < 0.40 * (player.arrowDropChance || 1.0)) { var arrowCount = Math.floor(GameUtils.randomRange(1, 4) * lootMultiplier); for (var i = 0; i < arrowCount; i++) { var arrow = new ArrowPickup(); arrow.x = chest.x; arrow.y = chest.y; arrow.velocityX = GameUtils.randomRange(1, 6); arrow.velocityY = -GameUtils.randomRange(8, 16); // Set rotation to 90 degrees counterclockwise arrow.sprite.rotation = -Math.PI / 2; arrow.platformOffset = 40; game.addChild(arrow); coins.push(arrow); } } // Spawn valuable items - quantity affected by loot multiplier var totalItems = Math.floor(GameUtils.randomRange(3, 9) * lootMultiplier); for (var i = 0; i < totalItems; i++) { // Random chance for different gems - probabilities improved by loot multiplier var rand = Math.random(); var item; // Increase chances for better gems based on multiplier (cap at reasonable values) var diamondChance = Math.min(0.05 * lootMultiplier, 0.15); var emeraldChance = Math.min(0.15 * lootMultiplier, 0.25); var rubyChance = Math.min(0.30 * lootMultiplier, 0.40); if (rand < diamondChance) { item = new Coin('diamond'); } else if (rand < emeraldChance) { item = new Coin('emerald'); } else if (rand < rubyChance) { item = new Coin('ruby'); } else { item = new Coin('coin'); } item.x = chest.x; item.y = chest.y; item.velocityX = GameUtils.randomRange(1, 6); // Reduced horizontal velocity item.velocityY = -GameUtils.randomRange(8, 16); // Reduced vertical velocity game.addChild(item); coins.push(item); } LK.getSound('woodbreak').play(); }); }; return self; }); var TreasureChestPiece = Container.expand(function (pieceNum) { var self = Container.call(this); // Attach piece sprite self.sprite = self.attachAsset('treasurechestpiece' + pieceNum, { anchorX: 0.5, anchorY: 0.5, tint: 0xC0C0C0 }); // Initialize as piece PieceBehavior.initPiece(self); // Update method self.update = function () { PieceBehavior.standardUpdate(self); }; self.checkPlatformCollision = function () { return GameUtils.checkPlatformCollision(self, 80, true) != null; }; return self; }); var TutorialManager = Container.expand(function () { var self = Container.call(this); // Tutorial states self.states = { ATTACK: 'attack', BOW: 'bow', JUMP: 'jump', DROP_DOWN: 'drop_down', DOUBLE_JUMP: 'double_jump', TRANSITIONING_TO_SLIDE: 'transitioning_to_slide', // New state SLIDE: 'slide', AIR_DASH: 'air_dash', COMPLETE: 'complete' }; //POG_REPLACE_LINE>{yq} // Current state and tracking self.currentState = self.states.ATTACK; self.enemyKilledByAttack = false; self.enemyKilledByBow = false; self.dropDownInput = false; self.hasJumped = false; self.hasDoubleJumped = false; self.hasAirDashSucceeded = false; self.firstJumpPerformed = false; self.secondJumpPerformed = false; // Message display self.messageContainer = new Container(); self.messageText = new CustomText('', { size: 60, fill: 0xFFFFFF, letterSpacing: 5, wordWrap: true, wordWrapWidth: 1200, anchorX: 0.5 }); self.messageContainer.addChild(self.messageText); self.messageContainer.width = 1200; self.messageContainer.x = GAME_WIDTH / 2; self.messageContainer.y = GAME_HEIGHT / 3.2; self.messageText.x = 0; // Center the text in the container self.messageText.y = 0; // Center the text in the container // Initialize tutorial self.init = function () { self.slideSword = null; // Track the sword for slide phase self.platformRemovalTimer = 0; self.removingPlatforms = false; self.hasSlideSucceeded = false; // Create invulnerable player player = game.addChild(new Player()); player.x = GAME_WIDTH / 4.5; player.y = GAME_HEIGHT / 1.5 - 100; player.isInvulnerable = true; // Reset state tracking self.enemyKilledByAttack = false; self.enemyKilledByBow = false; self.dropDownInput = false; // Set up initial platforms self.setupInitialPlatforms(); // Add message container game.addChild(self.messageContainer); self.setMessage("Tap anywhere to attack \n Kill the goblin!"); // Add backbutton centered under the main platform self.backButton = self.messageContainer.attachAsset('backbutton', { anchorX: 0.5, anchorY: 0.5 }); self.backButton.x = -700; self.backButton.y = -500; // 400px below message, visually under platform // Add touch handler for backbutton self.backButtonDown = function (x, y, obj) { // Only allow backbutton if tutorial is active if (tutorialActive && typeof self.complete === "function") { // Add visual feedback animation tween(self.backButton, { scaleX: 0.9, scaleY: 0.9 }, { duration: 100, easing: tween.easeOut, onFinish: function onFinish() { tween(self.backButton, { scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.easeOut, onFinish: function onFinish() { self.complete(); } }); } }); // Play menu select sound LK.getSound('menuselect').play(); } }; self.backButton.down = self.backButtonDown; // Clear any existing enemies/arrows enemies = []; arrows = []; self.spawnTutorialEnemy(); }; // Message handling self.setMessage = function (text) { // First, remove the existing text if (self.messageText.parent) { self.messageContainer.removeChild(self.messageText); } // Create a new text object each time (like the shop does) self.messageText = new CustomText(text, { size: 60, fill: 0xFFFFFF, letterSpacing: 5, wordWrap: true, wordWrapWidth: 1200, anchorX: 0.5 }); // Add to container with fixed positioning self.messageContainer.addChild(self.messageText); self.messageText.x = 0; self.messageText.y = 0; }; // Platform setup and management self.setupInitialPlatforms = function () { for (var i = 0; i < 5; i++) { var platform = new Platform(); platform.x = i * (PLATFORM_WIDTH - PLATFORM_OVERLAP); platform.y = lowPlatformHeight; platforms.push(platform); game.addChild(platform); } }; self.setupJumpPlatforms = function () { // Clear any high platforms for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y < lowPlatformHeight) { platforms[i].destroy(); platforms.splice(i, 1); } } // Create initial high platform var platform = new Platform(); platform.x = GAME_WIDTH; platform.y = highPlatformHeight; platforms.push(platform); game.addChild(platform); }; self.setupDoubleJumpPlatforms = function () { // Clear any existing high platforms for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y < lowPlatformHeight) { platforms[i].destroy(); platforms.splice(i, 1); } } // Create initial highest platform var platform = new Platform(); platform.x = GAME_WIDTH; platform.y = HIGHEST_PLATFORM_HEIGHT; platforms.push(platform); game.addChild(platform); }; self.updateTutorialPlatforms = function () { // Always maintain ground level platforms var lastGroundPlatform = null; for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y === lowPlatformHeight) { lastGroundPlatform = platforms[i]; break; } } if (lastGroundPlatform && lastGroundPlatform.x < GAME_WIDTH + 500) { var platform = new Platform(); platform.x = lastGroundPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP); platform.y = lowPlatformHeight; platforms.push(platform); game.addChild(platform); } // During JUMP and DROP_DOWN phases, maintain mid height platforms if (self.currentState === self.states.JUMP || self.currentState === self.states.DROP_DOWN) { var lastMidPlatform = null; for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y === highPlatformHeight) { lastMidPlatform = platforms[i]; break; } } if (lastMidPlatform && lastMidPlatform.x < GAME_WIDTH + 500) { var platform = new Platform(); platform.x = lastMidPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP); platform.y = highPlatformHeight; platforms.push(platform); game.addChild(platform); } } // During DOUBLE_JUMP phase, maintain highest platforms else if (self.currentState === self.states.DOUBLE_JUMP) { var lastHighPlatform = null; for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y === HIGHEST_PLATFORM_HEIGHT) { lastHighPlatform = platforms[i]; break; } } if (!lastHighPlatform || lastHighPlatform.x < GAME_WIDTH + 500) { var platform = new Platform(); platform.x = lastHighPlatform ? lastHighPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP) : GAME_WIDTH + 100; platform.y = HIGHEST_PLATFORM_HEIGHT; platforms.push(platform); game.addChild(platform); } } // Update existing platforms for (var i = platforms.length - 1; i >= 0; i--) { platforms[i].update(); if (platforms[i].destroyed) { platforms.splice(i, 1); } } }; // Enemy spawning and handling self.spawnTutorialEnemy = function () { if (self.currentState === self.states.ATTACK || self.currentState === self.states.BOW) { // Clear existing enemies for (var i = enemies.length - 1; i >= 0; i--) { enemies[i].destroy(); } enemies = []; var enemy = new Enemy('goblin'); enemy.x = GAME_WIDTH + 200; // Start offscreen to the right enemy.y = lowPlatformHeight - ENEMY_PLATFORM_OFFSET; enemy.isOnGround = true; enemy.currentPlatform = platforms[0]; enemies.push(enemy); game.addChild(enemy); } }; // State progression check self.checkStateProgress = function () { switch (self.currentState) { case self.states.ATTACK: // Reset if enemy killed by bow if (self.enemyKilledByBow) { self.enemyKilledByBow = false; self.spawnTutorialEnemy(); return; } // Progress if enemy killed by attack and death animation is nearly complete if (self.enemyKilledByAttack && (enemies.length === 0 || enemies[0] && enemies[0].isDeathAnimationComplete())) { self.enemyKilledByAttack = false; self.currentState = self.states.BOW; self.setMessage("Swipe left to fire your bow"); self.spawnTutorialEnemy(); } break; case self.states.BOW: // Reset if enemy killed by attack if (self.enemyKilledByAttack) { self.enemyKilledByAttack = false; self.spawnTutorialEnemy(); return; } // Progress if enemy killed by bow and death animation is nearly complete if (self.enemyKilledByBow && (enemies.length === 0 || enemies[0] && enemies[0].isDeathAnimationComplete())) { self.enemyKilledByBow = false; self.currentState = self.states.JUMP; self.setMessage("Swipe up to jump"); self.setupJumpPlatforms(); } break; case self.states.JUMP: if (self.hasJumped && player.isOnGround && player.currentPlatform && player.currentPlatform.y === highPlatformHeight) { self.currentState = self.states.DROP_DOWN; self.setMessage("Swipe down to drop back down"); self.hasJumped = false; // Reset for next use } break; case self.states.DROP_DOWN: if (self.dropDownInput && player.isOnGround && player.currentPlatform && player.currentPlatform.y === lowPlatformHeight) { self.currentState = self.states.DOUBLE_JUMP; self.setMessage("Swipe up twice for double jump"); self.setupDoubleJumpPlatforms(); self.dropDownInput = false; } break; case self.states.DOUBLE_JUMP: if (self.firstJumpPerformed && self.secondJumpPerformed && player.isOnGround && player.currentPlatform && player.currentPlatform.y === HIGHEST_PLATFORM_HEIGHT && !self.removingPlatforms) { self.currentState = self.states.TRANSITIONING_TO_SLIDE; self.platformRemovalTimer = 30; self.removingPlatforms = true; } break; case self.states.TRANSITIONING_TO_SLIDE: if (self.platformRemovalTimer > 0) { self.platformRemovalTimer--; if (self.platformRemovalTimer === 0) { // Remove all high platforms after delay for (var i = platforms.length - 1; i >= 0; i--) { if (platforms[i].y < lowPlatformHeight) { platforms[i].destroy(); platforms.splice(i, 1); } } } } // Check for transition to slide state after platforms are removed if (self.platformRemovalTimer === 0 && player.isOnGround && player.currentPlatform && player.currentPlatform.y === lowPlatformHeight) { self.currentState = self.states.SLIDE; self.setMessage("Swipe right to slide\nDodge the sword"); self.removingPlatforms = false; // Reset jump tracking self.firstJumpPerformed = false; self.secondJumpPerformed = false; } break; case self.states.SLIDE: // Only spawn sword if in slide state and player is on ground if (!self.slideSword && player.isOnGround && player.currentPlatform && player.currentPlatform.y === lowPlatformHeight) { self.slideSword = new SkeletonSword(); self.slideSword.x = GAME_WIDTH + 100; self.slideSword.y = player.y - 120; game.addChild(self.slideSword); } // Track successful slide with a new flag if (!self.hasSlideSucceeded && self.slideSword && self.slideSword.x < player.x && player.isSliding) { self.hasSlideSucceeded = true; } if (self.hasSlideSucceeded && !player.isSliding) { self.currentState = self.states.AIR_DASH; self.setMessage("Swipe right while in the air to air dash!"); self.hasSlideSucceeded = false; self.hasAirDashSucceeded = false; // Reset player state for air dashing player.canAirDash = true; } break; case self.states.AIR_DASH: // Simply check if the player has air dashed if (!self.hasAirDashSucceeded && player.isAirDashing) { self.hasAirDashSucceeded = true; // As soon as they air dash, consider the tutorial complete LK.setTimeout(function () { self.currentState = self.states.COMPLETE; self.setMessage("That's it!\nNow go get some treasure!"); LK.setTimeout(function () { self.complete(); }, 3000); }, 1000); // Wait 1 second after air dash before showing completion message } break; } }; // Input handling // Inside TutorialManager's checkInput method, where it checks different states self.checkInput = function (startX, startY, endX, endY) { if (!gameStarted || player.isDying) { return; } // Initialize the jump tracking property if it doesn't exist if (!self.inputProcessed) { self.inputProcessed = false; } var deltaY = endY - startY; var deltaX = endX - startX; // Ignore very small movements if (Math.abs(deltaY) < VERTICAL_DEADZONE && Math.abs(deltaX) < VERTICAL_DEADZONE) { if (self.currentState === self.states.ATTACK) { player.attack(); } self.inputProcessed = true; return; } // Don't process the same input multiple times if (self.inputProcessed) { return; } self.inputProcessed = true; // Track last jump time to prevent multiple jumps from a single swipe if (!self.lastJumpTime) { self.lastJumpTime = 0; } var currentTime = Date.now(); // Check directional swipes if (Math.abs(deltaX) > Math.abs(deltaY)) { if (deltaX < -70 && self.currentState === self.states.BOW) { player.shoot(); } else if (deltaX > 70 && self.currentState === self.states.SLIDE) { player.slide(); } // ADD THIS AIR DASH HANDLING RIGHT HERE else if (deltaX > 70 && self.currentState === self.states.AIR_DASH && !player.isOnGround) { player.airDash(); } } else { if (deltaY < -120) { // Upward swipe with cooldown check if (currentTime - self.lastJumpTime > JUMP_COOLDOWN) { if (self.currentState === self.states.JUMP) { self.hasJumped = true; player.jump(); self.lastJumpTime = currentTime; } else if (self.currentState === self.states.DOUBLE_JUMP) { self.hasDoubleJumped = true; player.jump(); self.lastJumpTime = currentTime; } else if (self.currentState === self.states.AIR_DASH) { // Allow jumping during air dash tutorial too player.jump(); self.lastJumpTime = currentTime; } } } else if (deltaY > 120 && self.currentState === self.states.DROP_DOWN) { self.dropDownInput = true; player.fallThrough(); } } }; // Main update loop self.update = function () { // Update platforms self.updateTutorialPlatforms(); // Update arrows and check collisions for (var i = arrows.length - 1; i >= 0; i--) { arrows[i].update(); if (arrows[i].destroyed) { arrows.splice(i, 1); continue; } // Check arrow collisions with enemies for (var j = enemies.length - 1; j >= 0; j--) { var enemy = enemies[j]; if (GameUtils.checkCollision(arrows[i].getBounds(), enemy.getBounds())) { if (!enemy.isHit && !enemy.isDying) { enemy.hit(); LK.getSound('enemyhit').play(); arrows[i].destroy(); arrows.splice(i, 1); if (self.currentState === self.states.BOW) { self.enemyKilledByBow = true; } break; } } } } // --- SLIDE SKELETON SWORD LOGIC BEGIN --- if (self.currentState === self.states.SLIDE) { // Only spawn one sword at a time if (!self.slideSword && player.isOnGround && !player.isJumping) { self.slideSword = new SkeletonSword(); self.slideSword.x = GAME_WIDTH + 100; self.slideSword.y = player.y - 120; game.addChild(self.slideSword); } else if (self.slideSword) { // Update sword self.slideSword.update(); // Check collision with player (must slide under to avoid) var swordBounds = self.slideSword.getBounds(); var playerBounds = player.getCollisionBounds(); // Only count as a hit if player is NOT sliding if (GameUtils.checkCollision(swordBounds, playerBounds) && !player.isSliding && !player.isDying && !player.isInvulnerable) { // Flash screen red when hit LK.effects.flashScreen(0xff0000, 300); // Remove sword so it can respawn self.slideSword.destroy(); self.slideSword = null; } // If sword leaves screen, reset it if (self.slideSword && (self.slideSword.x < -100 || self.slideSword.destroyed)) { if (self.slideSword.parent) { self.slideSword.destroy(); } self.slideSword = null; } } } else { // Clean up sword if not in slide state if (self.slideSword && self.slideSword.parent) { self.slideSword.destroy(); } self.slideSword = null; } // --- SLIDE SKELETON SWORD LOGIC END --- // Update enemies and check collisions for (var i = enemies.length - 1; i >= 0; i--) { enemies[i].update(); // Check for attack collisions var playerBounds = player.getCollisionBounds(); var enemyBounds = enemies[i].getBounds(); var attackBounds = player.getAttackBounds(); if (attackBounds && !enemies[i].isHit && !enemies[i].isDying) { if (enemies[i].x > player.x && GameUtils.checkCollision(attackBounds, enemyBounds)) { enemies[i].hit(); LK.getSound('enemyhit').play(); if (self.currentState === self.states.ATTACK) { self.enemyKilledByAttack = true; } else if (self.currentState === self.states.BOW) { self.enemyKilledByAttack = true; } continue; } } // Remove destroyed enemies if (enemies[i].destroyed || enemies[i].x < -50) { enemies.splice(i, 1); // Only respawn if the enemy wasn't killed correctly if (!self.enemyKilledByAttack && !self.enemyKilledByBow) { self.spawnTutorialEnemy(); } } } // Update particle effects if (particleSystem) { particleSystem.update(); } // Check state progression self.checkStateProgress(); }; // Cleanup and completion self.complete = function () { if (self.slideSword && self.slideSword.parent) { self.slideSword.destroy(); self.slideSword = null; } if (self.backButton) { self.backButton.destroy(); self.backButton = null; } self.messageContainer.destroy(); for (var i = platforms.length - 1; i >= 0; i--) { platforms[i].destroy(); } platforms = []; for (var i = enemies.length - 1; i >= 0; i--) { enemies[i].destroy(); } enemies = []; for (var i = arrows.length - 1; i >= 0; i--) { arrows[i].destroy(); } arrows = []; if (player) { player.destroy(); player = null; } createTitleScreen(); gameStarted = false; tutorialActive = false; }; return self; }); /**** * Initialize Game ****/ /**** * Game Variables ****/ // Containers /**** * Game Initialization ****/ var game = new LK.Game({ backgroundColor: 0x000000 }); /**** * Game Code ****/ //resetAllStorage(); // Add ShopUpgrade.prototype methods here // Base collectible behavior for items that can be collected /**** * Game Management ****/ initializeStorage(); ShopUpgrade.prototype.setSelected = function (isSelected) { var self = this; // Find the background asset within windowContainer children var background = null; for (var i = 0; i < self.windowContainer.children.length; i++) { if (self.windowContainer.children[i].asset && (self.windowContainer.children[i].asset.id === 'shop_upgrade_bg' || self.windowContainer.children[i].asset.id === 'shop_upgrade_bg_selected')) { background = self.windowContainer.children[i]; break; } } if (background) { background.asset = isSelected ? 'shop_upgrade_bg_selected' : 'shop_upgrade_bg'; } }; var SaveManager = { // Save all game data save: function save() { // Update gold in registry from score manager UPGRADE_REGISTRY.gold = Number(scoreManager.getScore()) || 0; // Save gold from registry to storage storage.gold = UPGRADE_REGISTRY.gold; // Save all upgrade levels directly from registry storage.healthUpgrade = UPGRADE_REGISTRY.health_increase; storage.arrowUpgrade = UPGRADE_REGISTRY.arrow_capacity; storage.levitateUpgrade = UPGRADE_REGISTRY.levitate; storage.slideUpgrade = UPGRADE_REGISTRY.slide_damage; storage.lootUpgrade = UPGRADE_REGISTRY.better_loot; storage.potionChanceUpgrade = UPGRADE_REGISTRY.potion_chance; storage.arrowFinderUpgrade = UPGRADE_REGISTRY.arrow_finder; storage.groundSlamUpgrade = UPGRADE_REGISTRY.ground_slam; storage.lootMagnetUpgrade = UPGRADE_REGISTRY.loot_magnet; // Save tracking_arrow upgrade storage.trackingArrowUpgrade = UPGRADE_REGISTRY.tracking_arrow; // Track timestamp storage.lastSaveTime = Date.now(); }, // Load saved game data load: function load() { // Initialize registry from storage with safe number conversions UPGRADE_REGISTRY.health_increase = parseInt(storage.healthUpgrade) || 0; UPGRADE_REGISTRY.arrow_capacity = parseInt(storage.arrowUpgrade) || 0; UPGRADE_REGISTRY.levitate = parseInt(storage.levitateUpgrade) || 0; UPGRADE_REGISTRY.slide_damage = parseInt(storage.slideUpgrade) || 0; UPGRADE_REGISTRY.better_loot = parseInt(storage.lootUpgrade) || 0; UPGRADE_REGISTRY.potion_chance = parseInt(storage.potionChanceUpgrade) || 0; UPGRADE_REGISTRY.arrow_finder = parseInt(storage.arrowFinderUpgrade) || 0; UPGRADE_REGISTRY.ground_slam = parseInt(storage.groundSlamUpgrade) || 0; UPGRADE_REGISTRY.loot_magnet = parseInt(storage.lootMagnetUpgrade) || 0; // Load tracking_arrow upgrade UPGRADE_REGISTRY.tracking_arrow = parseInt(storage.trackingArrowUpgrade) || 0; // Load gold with explicit number conversion UPGRADE_REGISTRY.gold = parseInt(storage.gold) || 0; // Update score display if (scoreManager) { scoreManager.setScore(UPGRADE_REGISTRY.gold); } // If shop exists, update the visual state of upgrades this.updateShopDisplay(); // Apply the loaded upgrade effects to the player this.applyUpgradeEffects(); }, // Update shop display based on registry values updateShopDisplay: function updateShopDisplay() { if (game.shopManager && game.shopManager.upgrades) { game.shopManager.upgrades.forEach(function (upgrade) { // Get the appropriate level from registry var registryLevel = 0; switch (upgrade.id) { case 'health_increase': registryLevel = UPGRADE_REGISTRY.health_increase; break; case 'arrow_capacity': registryLevel = UPGRADE_REGISTRY.arrow_capacity; break; case 'levitate': registryLevel = UPGRADE_REGISTRY.levitate; break; case 'slide_damage': registryLevel = UPGRADE_REGISTRY.slide_damage; break; case 'better_loot': registryLevel = UPGRADE_REGISTRY.better_loot; break; case 'potion_chance': registryLevel = UPGRADE_REGISTRY.potion_chance; break; case 'arrow_finder': registryLevel = UPGRADE_REGISTRY.arrow_finder; break; case 'ground_slam': registryLevel = UPGRADE_REGISTRY.ground_slam; break; case 'loot_magnet': registryLevel = UPGRADE_REGISTRY.loot_magnet; break; case 'tracking_arrow': registryLevel = UPGRADE_REGISTRY.tracking_arrow; break; } // Update internal level directly from registry upgrade.level = registryLevel; // Update UI text if (upgrade.levelText) { upgrade.levelText.setText('LEVEL ' + upgrade.level + (upgrade.level >= upgrade.maxLevel ? ' MAX' : '')); } console.log("Updated " + upgrade.id + " display to level " + upgrade.level); }); } }, // Apply upgrade effects to player applyUpgradeEffects: function applyUpgradeEffects(player) { if (!player && window.player) { player = window.player; } if (!player) { return; } // Reset to base values player.maxHealth = 3; player.ammoCount = 5; player.hasLevitate = false; player.slideDamage = false; player.hasGroundSlam = false; player.arrowDropChance = 1.0; player.lootMultiplier = 1.0; player.potionDropChance = 1.0; player.lootMagnetRange = 1.0; // Apply all upgrades from registry player.maxHealth += UPGRADE_REGISTRY.health_increase; player.currentHealth = player.maxHealth; player.ammoCount += UPGRADE_REGISTRY.arrow_capacity * 2; player.hasLevitate = UPGRADE_REGISTRY.levitate > 0; player.hasGroundSlam = UPGRADE_REGISTRY.ground_slam > 0; player.slideDamage = UPGRADE_REGISTRY.slide_damage > 0; player.lootMultiplier = 1 + UPGRADE_REGISTRY.better_loot * 0.15; player.potionDropChance = 1 + UPGRADE_REGISTRY.potion_chance * 0.5; player.arrowDropChance = 1 + UPGRADE_REGISTRY.arrow_finder * 0.5; player.lootMagnetRange = 1 + UPGRADE_REGISTRY.loot_magnet * 0.5; // Update UI elements if (player.heartContainer) { player.heartContainer.updateMaxHealth(player.maxHealth); player.heartContainer.updateHealth(player.currentHealth); } if (scoreManager) { scoreManager.updateAmmo(player.ammoCount); } }, // Clear all saved data clear: function clear() { // Reset storage storage.gold = 0; storage.healthUpgrade = 0; storage.arrowUpgrade = 0; storage.levitateUpgrade = 0; storage.slideUpgrade = 0; storage.lootUpgrade = 0; // Reset registry UPGRADE_REGISTRY.gold = 0; UPGRADE_REGISTRY.health_increase = 0; UPGRADE_REGISTRY.arrow_capacity = 0; UPGRADE_REGISTRY.levitate = 0; UPGRADE_REGISTRY.slide_damage = 0; UPGRADE_REGISTRY.better_loot = 0; UPGRADE_REGISTRY.potion_chance = 0; UPGRADE_REGISTRY.arrow_finder = 0; } }; ShopManager.prototype.initPlayerAnimation = function () { var self = this; self.playerSprites = []; self.idleFrame = 0; self.animationCounter = 0; self.animationSpeed = 0.037; // Create sprites for idle animation for (var i = 1; i <= 4; i++) { // Create and attach first var sprite = self.attachAsset('playeridle' + i, { anchorX: 0.5, anchorY: 0.5, x: -550, y: 400 }); // Set initial visibility sprite.alpha = i === 1 ? 1 : 0; // Push to array after attaching self.playerSprites.push(sprite); } }; ShopManager.prototype.hideAllSprites = function () { var self = this; for (var i = 0; i < self.playerSprites.length; i++) { self.playerSprites[i].alpha = 0; } }; ShopManager.prototype.updatePlayerAnimation = function () { var self = this; // Hide all sprites first self.hideAllSprites(); // Update animation self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.idleFrame = (self.idleFrame + 1) % self.playerSprites.length; } // Show current frame self.playerSprites[self.idleFrame].alpha = 1; }; ShopManager.prototype.updateArrowVisibility = function () { var self = this; // Check if arrows exist before updating their visibility if (self.leftArrow) { // Only show left arrow if we're not at the first upgrade self.leftArrow.alpha = self.currentUpgradeIndex > 0 ? 1 : 0; } if (self.rightArrow) { // Only show right arrow if we're not at the last upgrade self.rightArrow.alpha = self.currentUpgradeIndex < self.categoryUpgrades.length - 1 ? 1 : 0; } }; ShopManager.prototype.createTabs = function () { var self = this; // Add shop background first self.shopBackground = self.attachAsset('shop_background', { anchorX: 0.5, anchorY: 0.5 }); // Add shop banner self.shopBanner = self.attachAsset('shop_banner', { anchorX: 0.5, anchorY: 0.5, y: -1000 }); // Create tabs container AFTER background self.tabs = new Container(); self.tabs.x = 0; self.tabs.y = -880; self.addChild(self.tabs); // This adds it on top of previously added elements // Add windows self.playerWindow = self.attachAsset('shop_player', { anchorX: 0.5, anchorY: 0.5, x: -490, y: 60 }); // Gold display self.goldWindow = new Container(); // Create container instead of asset // Add dark window background first var goldWindowBg = self.goldWindow.attachAsset('shop_dark_window', { anchorX: 0.5, anchorY: 0.5 }); self.goldWindow.x = -490; self.goldWindow.y = 850; self.addChild(self.goldWindow); self.createGoldDisplay(); // Create category tabs var spacing = 335; var startX = -(self.categories.length - 1) * spacing / 2; self.categories.forEach(function (category, index) { var tab = new Container(); // Create both tab backgrounds var normalBg = tab.attachAsset('shop_tab', { anchorX: 0.5, anchorY: 0.5 }); var selectedBg = tab.attachAsset('shop_tab_selected', { anchorX: 0.5, anchorY: 0.5 }); selectedBg.alpha = 0; // Initially hide the selected state var text = new CustomText(category, { size: 48, fill: 0xE6D5AC, letterSpacing: 5 }); tab.addChild(text); // Position text at center of tab text.x = -text.width / 2 + 10; text.y = 0; tab.x = startX + spacing * index; tab.y = 180; tab.down = function () { // Play sound when tab is clicked LK.getSound('menuselect').play(); self.showCategory(category); }; self.tabs.addChild(tab); }); }; ShopManager.prototype.createBuyButton = function () { var self = this; self.buyButton = new Container(); self.buyButtonBg = self.buyButton.attachAsset('shop_button', { anchorX: 0.5, anchorY: 0.5 }); self.priceContainer = new Container(); self.priceText = new CustomText('', { size: 60, fill: 0xFFFFFF, letterSpacing: 5 }); self.priceCoinIcon = LK.getAsset('coin', { anchorX: 0, anchorY: 0.5, scaleX: 1.3, scaleY: 1.3 }); // Position coin at fixed location self.priceCoinIcon.x = 160; self.priceCoinIcon.y = 40; // Initially position text with some default value self.priceText.x = self.priceCoinIcon.x - 10; self.priceText.y = 40; self.priceContainer.addChild(self.priceText); self.priceContainer.addChild(self.priceCoinIcon); self.priceContainer.y = -300; self.buyButton.addChild(self.priceContainer); self.buyButton.x = 525; self.buyButton.y = 850; self.buyButton.down = function () { self.purchaseSelectedUpgrade(); }; self.addChild(self.buyButton); }; ShopManager.prototype.showCategory = function (category) { var self = this; self.currentCategory = category; // Filter upgrades for this category self.categoryUpgrades = self.upgrades.filter(function (upgrade) { return upgrade.category === category; }); // Reset to first upgrade in category self.currentUpgradeIndex = 0; // Show first upgrade self.showUpgradeAtIndex(0); // Update tab visuals self.tabs.children.forEach(function (tab) { var isSelected = tab.children[2].text === category; tab.children[0].alpha = isSelected ? 0 : 1; // normal bg tab.children[1].alpha = isSelected ? 1 : 0; // selected bg }); }; ShopManager.prototype.showUpgradeAtIndex = function (index) { var self = this; // Update current index self.currentUpgradeIndex = index; // Clear existing upgrades self.upgradeList.removeChildren(); // Show upgrade at current index if (self.categoryUpgrades.length > 0) { var upgradeConfig = self.categoryUpgrades[self.currentUpgradeIndex]; var upgrade = new ShopUpgrade(upgradeConfig); // Initialize level from registry based on ID switch (upgrade.id) { case 'health_increase': upgrade.level = UPGRADE_REGISTRY.health_increase; break; case 'arrow_capacity': upgrade.level = UPGRADE_REGISTRY.arrow_capacity; break; case 'levitate': upgrade.level = UPGRADE_REGISTRY.levitate; break; case 'slide_damage': upgrade.level = UPGRADE_REGISTRY.slide_damage; break; case 'better_loot': upgrade.level = UPGRADE_REGISTRY.better_loot; break; case 'potion_chance': upgrade.level = UPGRADE_REGISTRY.potion_chance || 0; break; case 'arrow_finder': upgrade.level = UPGRADE_REGISTRY.arrow_finder || 0; break; case 'ground_slam': upgrade.level = UPGRADE_REGISTRY.ground_slam; break; case 'loot_magnet': upgrade.level = UPGRADE_REGISTRY.loot_magnet; break; case 'tracking_arrow': upgrade.level = UPGRADE_REGISTRY.tracking_arrow || 0; break; } // Update level text to match registry upgrade.levelText.setText('LEVEL ' + upgrade.level + (upgrade.level >= upgrade.maxLevel ? ' MAX' : '')); upgrade.x = 355; upgrade.y = 60; self.upgradeList.addChild(upgrade); // Make sure we're selecting the upgrade self.selectedUpgrade = upgrade; } // Update arrow visibility self.updateArrowVisibility(); // Update buy button self.updateBuyButton(); }; ShopManager.prototype.createArrows = function () { var self = this; // Create left arrow self.leftArrow = new Container(); self.leftArrow.attachAsset('shop_arrow', { anchorX: 0.5, anchorY: 0.5, scaleX: -1, // Flip horizontally alpha: 1 }); self.leftArrow.x = 0; self.leftArrow.y = 150; // Center with the upgrade display self.addChild(self.leftArrow); // Create right arrow self.rightArrow = new Container(); self.rightArrow.attachAsset('shop_arrow', { anchorX: 0.5, anchorY: 0.5, alpha: 1 }); self.rightArrow.x = 710; self.rightArrow.y = 150; // Center with the upgrade display self.addChild(self.rightArrow); // Set up interactions self.leftArrow.down = function () { if (self.currentUpgradeIndex > 0) { LK.getSound('menuselect').play(); self.showUpgradeAtIndex(self.currentUpgradeIndex - 1); } }; self.rightArrow.down = function () { if (self.currentUpgradeIndex < self.categoryUpgrades.length - 1) { LK.getSound('menuselect').play(); self.showUpgradeAtIndex(self.currentUpgradeIndex + 1); } }; // Set initial visibility if (self.leftArrow && self.rightArrow) { self.updateArrowVisibility(); } }; ShopManager.prototype.selectUpgrade = function (upgrade) { var self = this; // Deselect previous upgrade if (self.selectedUpgrade) { self.selectedUpgrade.setSelected(false); } self.selectedUpgrade = upgrade; upgrade.setSelected(true); // Update buy button and price self.updateBuyButton(); }; ShopManager.prototype.updateBuyButton = function () { var self = this; if (!self.selectedUpgrade) { return; } var price = self.selectedUpgrade.getCurrentPrice(); var canAfford = scoreManager.getScore() >= price; var isMaxLevel = self.selectedUpgrade.level >= self.selectedUpgrade.maxLevel; // Store current price length to detect changes var oldLength = self.priceText.text.length; var newLength = (isMaxLevel ? 'MAX' : price.toString()).length; // Store current vertical position var currentY = self.priceText.y; // Update buy button based on max level first if (isMaxLevel) { self.priceText.setText('MAX'); self.priceCoinIcon.visible = false; self.priceText.x = 0; // Center the MAX text self.buyButtonBg.tint = 0x888888; } else { // If changing from 4 to 3 digits, completely recreate the text if (oldLength > 3 && newLength === 3) { // Remove the old text if (self.priceText.parent) { self.priceContainer.removeChild(self.priceText); } // Create new text with same properties self.priceText = new CustomText(price.toString(), { size: 60, fill: 0xFFFFFF, letterSpacing: 5 }); // Restore the vertical position self.priceText.y = currentY; self.priceContainer.addChild(self.priceText); } else { // Just update the text for other cases self.priceText.setText(price.toString()); } self.priceCoinIcon.visible = true; self.priceCoinIcon.x = 160; // Fixed position var textPadding = 10; self.priceText.x = self.priceCoinIcon.x - textPadding - self.priceText.width; self.buyButtonBg.tint = canAfford ? 0xFFFFFF : 0x888888; } // Update total gold display self.updateTotalGold(); }; ShopManager.prototype.purchaseSelectedUpgrade = function () { var self = this; if (!self.selectedUpgrade) { return; } var price = self.selectedUpgrade.getCurrentPrice(); if (scoreManager.getScore() >= price && self.selectedUpgrade.level < self.selectedUpgrade.maxLevel) { // Add visual feedback animation for buy button tween(self.buyButton, { scaleX: 0.9, scaleY: 0.9 }, { duration: 100, easing: tween.easeOut, onFinish: function onFinish() { tween(self.buyButton, { scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.easeOut }); } }); // Deduct price using the global scoreManager scoreManager.addScore(-price); // Call purchase() method var result = self.selectedUpgrade.purchase(); // Play purchase sound LK.getSound('shopbuy').play(); // Update button UI self.updateBuyButton(); // Save the changes SaveManager.save(); } else { // Play "can't buy" sound when player doesn't have enough gold or upgrade is maxed LK.getSound('cantbuy').play(); } }; ShopManager.prototype.createGoldDisplay = function () { var self = this; // Create a container for the gold display self.goldDisplayContainer = new Container(); self.totalGoldText = new CustomText('0', { size: 90, fill: 0xE6D5AC, letterSpacing: 5 }); self.totalGoldCoinIcon = LK.getAsset('coin', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); self.goldDisplayContainer.addChild(self.totalGoldText); self.goldDisplayContainer.addChild(self.totalGoldCoinIcon); self.goldDisplayContainer.x = 90; // Center of gold window self.goldDisplayContainer.y = -50; // Position text and coin self.totalGoldText.x = -50; self.totalGoldText.y = 65; self.totalGoldCoinIcon.x = 70; self.totalGoldCoinIcon.y = 70; // Add to the window self.goldWindow.addChild(self.goldDisplayContainer); // Initial update self.updateTotalGold(); }; ShopManager.prototype.updateTotalGold = function () { var self = this; var totalGold = scoreManager.getScore(); self.totalGoldText.setText(totalGold.toString()); // Keep coin at fixed position self.totalGoldCoinIcon.x = 165; // Fixed position // Right-align text relative to coin // Adjust position based on digit count but keep right edge aligned var textPadding = 50; // Space between text and coin self.totalGoldText.x = self.totalGoldCoinIcon.x - textPadding - self.totalGoldText.width; }; ShopManager.prototype.update = function () { this.updatePlayerAnimation(); this.updateBuyButton(); }; var CollectibleBehavior = { initPhysics: function initPhysics(self) { self.velocityX = 0; self.velocityY = 0; self.collected = false; self.bounceCount = 0; self.maxBounces = 2; }, standardUpdate: function standardUpdate(self) { if (self.collected) { return; } // Apply physics self.velocityY += 0.5; // gravity self.x += self.velocityX; // Original throw physics self.y += self.velocityY; self.x -= PLATFORM_SPEED * (gameSpeedMultiplier - 1); // Only apply the extra speed from sliding // Check for platform collision with bounce if (self.velocityY > 0) { GameUtils.checkPlatformCollision(self, 80, true); } // Check if off screen if (self.x < -50 || self.y > GAME_HEIGHT) { self.destroy(); return; } // Only apply magnet effect if it's not a health potion OR if player is not at full health if (!(self instanceof HealthPotion && player.currentHealth >= player.maxHealth)) { if (player.lootMagnetRange > 1) { var dx = player.x - self.x; var dy = player.y - self.y; var distance = Math.sqrt(dx * dx + dy * dy); var maxAttractionRange = 300 * player.lootMagnetRange; if (distance < maxAttractionRange) { // Calculate attraction strength based on distance var strength = (1 - distance / maxAttractionRange) * 3; self.velocityX += dx / distance * strength; self.velocityY += dy / distance * strength; } } } // Player collection detection - use slide hitbox height if sliding var playerBounds = { left: player.x - player.hitboxWidth / 2, right: player.x + player.hitboxWidth / 2, top: player.y - player.hitboxHeight / 2, bottom: player.y + player.hitboxHeight / 2 }; var magnetRange = player.lootMagnetRange || 1; var itemBounds = { left: self.x - 25 * magnetRange, right: self.x + 25 * magnetRange, top: self.y - 25 * magnetRange, bottom: self.y + 25 * magnetRange }; if (GameUtils.checkCollision(playerBounds, itemBounds)) { self.collect(); } } }; // Base behavior for breakable objects var BreakableBehavior = { initBreakable: function initBreakable(self) { self.isBreaking = false; self.currentPlatform = null; }, standardBreak: function standardBreak(self, pieceClass, pieceCount, itemSpawnCallback) { if (self.isBreaking) { return; } self.isBreaking = true; // Spawn pieces for (var i = 1; i <= pieceCount; i++) { var piece = new pieceClass(i); piece.x = self.x; piece.y = self.y; piece.velocityX = GameUtils.randomRange(-6, 6); piece.velocityY = -GameUtils.randomRange(6, 12); piece.rotationSpeed = GameUtils.randomRange(-0.1, 0.1); game.addChild(piece); } // Call the custom item spawn callback if (itemSpawnCallback) { itemSpawnCallback(self); } self.destroy(); } }; // Base behavior for pieces of broken objects var PieceBehavior = { initPiece: function initPiece(self) { self.velocityX = 0; self.velocityY = 0; self.rotationSpeed = 0; self.fadeSpeed = 0.02; self.bounceCount = 0; self.maxBounces = 2; }, standardUpdate: function standardUpdate(self) { // Apply physics self.velocityY += 0.5; // gravity self.x += self.velocityX; self.y += self.velocityY; self.rotation += self.rotationSpeed; // Check for platform collision var platformCollision = GameUtils.checkPlatformCollision(self, 80, self.bounceCount < self.maxBounces); if (platformCollision && self.bounceCount >= self.maxBounces) { // Start fading after max bounces self.velocityY = 0; self.velocityX = -PLATFORM_SPEED; self.alpha -= self.fadeSpeed; if (self.alpha <= 0) { self.destroy(); } } // Destroy if off screen if (self.x < -50 || self.y > GAME_HEIGHT) { self.destroy(); } } }; /**** * Constants ****/ var GAME_WIDTH = 2048; var GAME_HEIGHT = 2732; var PLATFORM_WIDTH = 1000; var PLATFORM_HALF_WIDTH = PLATFORM_WIDTH / 2; var PLATFORM_OVERLAP = 50; var PLATFORM_SPEED = 5; var GAP_START_TIME = 90000; // 1.5 minutes in milliseconds var ENEMY_PLATFORM_OFFSET = 225; var PLAYER_PLATFORM_OFFSET = 250; var MIN_PLATFORMS_IN_SEQUENCE = 2; var MAX_PLATFORMS_IN_SEQUENCE = 5; var JUMP_COOLDOWN = 200; var MOVE_THRESHOLD = 90; var SLIDE_MOVE_THRESHOLD = 300; var VERTICAL_DEADZONE = 30; var RICOCHET_SEARCH_RADIUS_SQ = 1000 * 1000; // Further increased search radius for ricochet targets var RICOCHET_ARROW_SPEED = 40; var UPGRADE_REGISTRY = { gold: 0, health_increase: 0, arrow_capacity: 0, levitate: 0, slide_damage: 0, better_loot: 0, potion_chance: 0, arrow_finder: 0, ground_slam: 0, loot_magnet: 0, tracking_arrow: 0 }; /**** * Utilities ****/ function initializeStorage() { if (storage.gold === undefined) { storage.gold = 0; } if (storage.healthUpgrade === undefined) { storage.healthUpgrade = 0; } if (storage.arrowUpgrade === undefined) { storage.arrowUpgrade = 0; } if (storage.levitateUpgrade === undefined) { storage.levitateUpgrade = 0; } if (storage.slideUpgrade === undefined) { storage.slideUpgrade = 0; } if (storage.lootUpgrade === undefined) { storage.lootUpgrade = 0; } if (storage.potionChanceUpgrade === undefined) { storage.potionChanceUpgrade = 0; } if (storage.arrowFinderUpgrade === undefined) { storage.arrowFinderUpgrade = 0; } if (storage.groundSlamUpgrade === undefined) { storage.groundSlamUpgrade = 0; } if (storage.lootMagnetUpgrade === undefined) { storage.lootMagnetUpgrade = 0; } // Add trackingArrowUpgrade initialization if (storage.trackingArrowUpgrade === undefined) { storage.trackingArrowUpgrade = 0; } } var GameUtils = { // Check for collision between two rectangular bounds checkCollision: function checkCollision(bounds1, bounds2) { return bounds1.left < bounds2.right && bounds1.right > bounds2.left && bounds1.top < bounds2.bottom && bounds1.bottom > bounds2.top; }, // Check platform collision with standard offset checkPlatformCollision: function checkPlatformCollision(obj, offsetY, bounceOnCollision) { for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; if (Math.abs(obj.y - (platform.y - offsetY)) < 10 && obj.x > platform.x - PLATFORM_HALF_WIDTH && obj.x < platform.x + PLATFORM_HALF_WIDTH) { obj.y = platform.y - offsetY; if (bounceOnCollision && obj.bounceCount < obj.maxBounces) { LK.getSound('coinbounce').play(); var impactSpeed = Math.abs(obj.velocityY); obj.velocityY = -(impactSpeed * 0.5); obj.velocityX *= 0.8; obj.bounceCount++; return true; } else if (bounceOnCollision) { obj.velocityY = 0; obj.velocityX = -PLATFORM_SPEED; } return platform; } } return null; }, // Get random value within range randomRange: function randomRange(min, max) { return Math.random() * (max - min) + min; }, // Check if position is clear for spawning canSpawnAtPosition: function canSpawnAtPosition(x) { var safeDistance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 200; for (var i = 0; i < collectibles.length; i++) { if (Math.abs(collectibles[i].x - x) < safeDistance) { return false; } } return true; } }; var ScoreManager = function ScoreManager() { var self = {}; // Initialize score first self.score = 0; // Define methods before using them self.getScore = function () { return self.score; }; self.setScore = function (newScore) { var oldScore = self.score; self.score = newScore; // Update the registry UPGRADE_REGISTRY.gold = self.score; // Check if digit count has changed var oldLength = oldScore.toString().length; var newLength = newScore.toString().length; if (oldLength !== newLength && self.scoreText) { // Store current position var currentX = self.scoreText.x; var currentY = self.scoreText.y; // Remove old text if (self.scoreText.parent) { self.container.removeChild(self.scoreText); } // Create new text self.scoreText = new CustomText(newScore.toString(), { size: 100, fill: 0xFFFFFF, letterSpacing: 5 }); // Restore position properties self.scoreText.y = currentY; self.container.addChild(self.scoreText); } else if (self.scoreText) { // Just update text content self.scoreText.setText(newScore.toString()); } // Keep right edge at a fixed position if (self.scoreText) { var rightEdgePosition = -10; // Fixed right edge position self.scoreText.x = rightEdgePosition - self.scoreText.width; } }; self.addScore = function (amount, x, y) { self.setScore(self.score + amount); // Update the registry UPGRADE_REGISTRY.gold = self.score; SaveManager.save(); LK.setScore(self.score); // Create score popup if position is provided if (x !== undefined && y !== undefined) { var popup = new ScorePopup(x, y - 30, amount); game.addChild(popup); } }; // Create UI elements self.scoreText = new CustomText('0', { size: 100, fill: 0xFFFFFF, letterSpacing: 5 }); // Initialize with default position self.scoreText.x = -100; // AFTER UI elements exist AND methods are defined, load saved score if (storage.gold) { self.score = Number(storage.gold); self.setScore(self.score); // Now this is safe because scoreText exists and setScore is defined } self.coinIcon = LK.getAsset('coin', { anchorX: 0, anchorY: 0.5, scaleX: 2, scaleY: 2 }); // New ammo display self.ammoText = new CustomText('0*', { size: 90, fill: 0xFFFFFF, letterSpacing: 5 }); self.ammoIcon = LK.getAsset('arrow', { anchorX: 0, anchorY: 0.5, scaleX: 1.3, scaleY: 1.3, rotation: -Math.PI / 2 // Rotate 90 degrees counterclockwise }); // Initialize container self.container = new Container(); self.container.addChild(self.scoreText); self.container.addChild(self.coinIcon); self.container.addChild(self.ammoText); self.container.addChild(self.ammoIcon); // Position container self.container.x = GAME_WIDTH - 100; self.container.y = 100; // Position elements // Position elements self.scoreText.x = -200; // Less negative value self.scoreText.y = 0; // Center vertically self.coinIcon.x = 0; self.coinIcon.y = 0; self.ammoText.x = 30; self.ammoText.y = 170; // Place below coin display self.ammoIcon.x = 55; self.ammoIcon.y = 240; // Place below coin display // Add ammo update method self.updateAmmo = function (amount) { self.ammoText.setText(amount + '*'); // Instead of hardcoded adjustments based on digit count, // calculate the width of the text and properly align it // Keep the right edge at a fixed position var rightEdgePosition = 30; // Fixed right edge position self.ammoText.x = rightEdgePosition - self.ammoText.width; }; return self; }; /**** * Game Variables ****/ // Containers var backgroundContainer = game.addChild(new Container()); var midgroundContainer = game.addChild(new Container()); var foregroundContainer = game.addChild(new Container()); var scoreManager; var scoreContainer = game.addChild(new Container()); // Game state var gameStarted = false; var titleScreen; var playButton; var gameStartTime; var tutorialActive = false; var tutorialManager; var tutorialButton; var playButtonFlashInterval; // Platform management var platforms = []; var gameSpeedMultiplier = 1.0; var platformSpawnCounter = 0; var platformsUntilNextChange = 0; var lowPlatformHeight = GAME_HEIGHT / 1.5 + PLAYER_PLATFORM_OFFSET - 100; var highPlatformHeight = lowPlatformHeight - 600; var HIGHEST_PLATFORM_HEIGHT = highPlatformHeight - 600; var LOWEST_PLATFORM_HEIGHT = lowPlatformHeight + 600; // var RICOCHET_SEARCH_RADIUS_SQ = 500 * 500; // Moved to Constants section // var RICOCHET_ARROW_SPEED = 40; // Moved to Constants section var currentPlatformHeight = lowPlatformHeight; var lastPlatformHeight = lowPlatformHeight; var lastPlatformX = 0; var currentPlatformPattern = 'A'; // 'A' for 1&3, 'B' for 2&4 var currentStraightHeight; // Touch controls var touchStartX = 0; var touchStartY = 0; var touchEndX = 0; var touchEndY = 0; var lastMoveY = 0; var lastJumpTime = 0; // Game objects var jars = []; var coins = []; var collectibles = []; var arrows = []; var skeletonSwords = []; var arrowParticles = []; // Array to hold arrow trail particles var jarSpawnCounter = 0; var jarSpawnInterval = 10; var chestSpawnCounter = 0; var chestSpawnInterval = 75; var enemies = []; var enemySpawnCounter = 0; var enemySpawnInterval = 100; var eyeballSpawnCounter = 0; var eyeballSpawnInterval = 200; var particleSystem; var heartContainer = new HeartContainer(); scoreManager = new ScoreManager(); // Create it early var player; // Background elements var bg1 = backgroundContainer.addChild(LK.getAsset('background', { anchorX: 0, anchorY: 1 })); var bg2 = backgroundContainer.addChild(LK.getAsset('background', { anchorX: 0, anchorY: 1 })); bg1.y = GAME_HEIGHT; bg2.y = GAME_HEIGHT; bg2.x = GAME_WIDTH; // Midground elements var mg1 = midgroundContainer.addChild(LK.getAsset('midground', { anchorX: 0, anchorY: 1, tint: 0x777777 })); var mg2 = midgroundContainer.addChild(LK.getAsset('midground', { anchorX: 0, anchorY: 1, tint: 0x777777 })); mg1.y = GAME_HEIGHT; mg2.y = GAME_HEIGHT; mg2.x = GAME_WIDTH; // Foreground elements var fg1 = foregroundContainer.addChild(LK.getAsset('foreground', { anchorX: 0, anchorY: 1, tint: 0x777777 })); var fg2 = foregroundContainer.addChild(LK.getAsset('foreground', { anchorX: 0, anchorY: 1, tint: 0x777777 })); fg1.y = GAME_HEIGHT * 1.25; fg2.y = GAME_HEIGHT * 1.25; fg1.x = 0; fg2.x = GAME_WIDTH; /**** * Game Functions ****/ // Screen shake effect function function applyScreenShake() { var shakeIntensity = 30; var shakeDuration = 400; var shakeCount = 8; var originalX = game.x; var originalY = game.y; // Stop any existing shake tween.stop(game, { x: true, y: true }); // Reset position to ensure we start from 0,0 game.x = 0; game.y = 0; // Recursive function to create multiple shakes function createShake(count) { if (count <= 0) { // Final tween to settle back to original position tween(game, { x: originalX, y: originalY }, { duration: shakeDuration / 4, easing: tween.easeOut }); return; } // Calculate decreasing intensity var currentIntensity = shakeIntensity * (count / shakeCount); // Random offset direction var offsetX = (Math.random() - 0.5) * 2 * currentIntensity; var offsetY = (Math.random() - 0.5) * 2 * currentIntensity; // Apply shake movement tween(game, { x: offsetX, y: offsetY }, { duration: shakeDuration / shakeCount, easing: tween.linear, onFinish: function onFinish() { createShake(count - 1); } }); } // Start the shake sequence createShake(shakeCount); } function createGameplayShopButton() { // Create shop button in top corner var shopButton = game.addChild(LK.getAsset('shopbutton', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.7, scaleY: 0.7 })); shopButton.x = 250; shopButton.y = 310; // Position below score display shopButton.down = function () { // Pause the game var previousGameSpeed = gameSpeedMultiplier; // IMPORTANT FIX: Force cancel any active movement states if (player) { // Cancel slide if active if (player.isSliding) { player.isSliding = false; player.slideTimer = 0; player.hitboxHeight = player.normalHitboxHeight; } // Cancel air dash if active if (player.isAirDashing) { player.isAirDashing = false; player.airDashTimer = 0; // Clean up shadows player.shadowImages.forEach(function (shadow) { if (shadow.parent) { shadow.destroy(); } }); player.shadowImages = []; // Reset rotation player.rotation = 0; } } // Now set game speed to 0 gameSpeedMultiplier = 0; // Open shop openGameplayShop(); // Function to return to game function resumeGame() { // Close shop if (game.shopManager && game.shopManager.parent) { game.shopManager.destroy(); game.shopManager = null; } // Restore game speed, but ensure it's not the enhanced speed from slide/dash gameSpeedMultiplier = 1.0; // IMPORTANT FIX: Always restore to 1.0, not previousGameSpeed // Remove back button using our reference if (gameplayBackButton && gameplayBackButton.parent) { gameplayBackButton.destroy(); } } // Add custom back button for gameplay shop gameplayBackButton = game.addChild(LK.getAsset('backbutton', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.75, scaleY: 0.75, x: GAME_WIDTH / 2, y: GAME_HEIGHT - 200 })); gameplayBackButton.down = function () { LK.getSound('menuselect').play(); resumeGame(); }; }; return shopButton; } // Modified openShop function for gameplay function openGameplayShop() { SaveManager.load(); // Create shop if it doesn't exist if (!game.shopManager) { game.shopManager = new ShopManager(); game.shopManager.x = GAME_WIDTH / 2; game.shopManager.y = GAME_HEIGHT / 2; } // Show shop and force an update game.addChild(game.shopManager); game.shopManager.updateTotalGold(); // Override the purchase function to apply upgrades immediately var originalPurchase = game.shopManager.purchaseSelectedUpgrade; game.shopManager.purchaseSelectedUpgrade = function () { originalPurchase.call(game.shopManager); SaveManager.applyUpgradeEffects(player); }; } function applyPlayerUpgradeEffects() { if (!player) { return; } // Apply health upgrade if saved if (storage.playerMaxHealth) { player.maxHealth = parseInt(storage.playerMaxHealth); player.currentHealth = player.maxHealth; player.heartContainer.updateHealth(player.currentHealth); } // Apply arrow capacity upgrade if saved if (storage.playerArrowCapacity) { player.ammoCount = parseInt(storage.playerArrowCapacity); scoreManager.updateAmmo(player.ammoCount); } // Apply levitate upgrade if saved if (storage.playerHasLevitate) { player.hasLevitate = true; } // Apply any other player effect upgrades here } // Create the title screen function createTitleScreen() { titleScreen = new Container(); game.addChild(titleScreen); // Add title image with fade-in var titleImage = titleScreen.attachAsset('title', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); titleImage.x = GAME_WIDTH / 2; titleImage.y = GAME_HEIGHT / 2.7; // Fade in title tween(titleImage, { alpha: 1 }, { duration: 1000, easing: tween.easeIn }); // Add play button playButton = titleScreen.attachAsset('playbutton', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); playButton.x = GAME_WIDTH / 2; playButton.y = GAME_HEIGHT / 1.4; tween(playButton, { alpha: 1 }, { duration: 1000, easing: tween.easeIn }); // Add tutorial button tutorialButton = titleScreen.attachAsset('tutorialbutton', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); tutorialButton.x = GAME_WIDTH / 3; tutorialButton.y = GAME_HEIGHT / 1.15; tween(tutorialButton, { alpha: 1 }, { duration: 1000, easing: tween.easeIn }); var shopButton = titleScreen.attachAsset('shopbutton', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); shopButton.x = GAME_WIDTH / 1.4; shopButton.y = GAME_HEIGHT / 1.15; // Position between play and tutorial buttons shopButton.down = function () { // Add visual feedback animation tween(shopButton, { scaleX: 0.9, scaleY: 0.9 }, { duration: 100, easing: tween.easeOut, onFinish: function onFinish() { tween(shopButton, { scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.easeOut, onFinish: function onFinish() { openShop(); } }); } }); // Play menu select sound LK.getSound('menuselect').play(); }; tween(shopButton, { alpha: 1 }, { duration: 1000, easing: tween.easeIn }); // Add flashing animation for play button only function flashPlayButton() { tween(playButton, { alpha: 0 }, { duration: 250, easing: tween.linear, onFinish: function onFinish() { tween(playButton, { alpha: 1 }, { duration: 250, easing: tween.linear }); } }); } if (playButtonFlashInterval) { LK.clearInterval(playButtonFlashInterval); } // Flash every 2 seconds playButtonFlashInterval = LK.setInterval(flashPlayButton, 2000); // Initialize torch decorations initializeTorches(); } function resetAllStorage() { // Log the current state // Delete all stored values storage.gold = 0; storage.healthUpgrade = 0; storage.arrowUpgrade = 0; storage.levitateUpgrade = 0; storage.slideUpgrade = 0; storage.lootUpgrade = 0; storage.groundSlamUpgrade = 0; storage.potionChanceUpgrade = 0; storage.arrowFinderUpgrade = 0; } function openShop() { // Hide title screen titleScreen.visible = false; SaveManager.load(); // Create shop if it doesn't exist if (!game.shopManager) { game.shopManager = new ShopManager(); game.shopManager.x = GAME_WIDTH / 2; game.shopManager.y = GAME_HEIGHT / 2; } // Show shop and force an update game.addChild(game.shopManager); game.shopManager.updateTotalGold(); // Add back button var backButton = game.shopManager.attachAsset('backbutton', { anchorX: 0.5, anchorY: 0.5, scaleX: 0.75, scaleY: 0.75, x: 0, y: 1100 }); backButton.down = function () { // Add visual feedback animation tween(backButton, { scaleX: 0.65, scaleY: 0.65 }, { duration: 100, easing: tween.easeOut, onFinish: function onFinish() { tween(backButton, { scaleX: 0.75, scaleY: 0.75 }, { duration: 200, easing: tween.easeOut, onFinish: function onFinish() { closeShop(); } }); } }); // Play menu select sound LK.getSound('menuselect').play(); }; } function closeShop() { // Save the current state before closing SaveManager.save(); if (game.shopManager && game.shopManager.parent) { game.shopManager.destroy(); // Destroy the manager and all its children game.shopManager = null; // Clear the reference } // Ensure title screen is visible after shop closes if (titleScreen && !titleScreen.parent) { // If title screen was destroyed or removed, recreate it createTitleScreen(); } else if (titleScreen) { titleScreen.visible = true; } } // Place torches in the scene function initializeTorches() { // Check if torches already exist if (midgroundContainer.children.some(function (child) { return child instanceof Torch; })) { return; } // Create torches for the two background sections var torch1 = new Torch(); torch1.x = 25; torch1.y = GAME_HEIGHT * 0.7; midgroundContainer.addChild(torch1); var torch2 = new Torch(); torch2.x = GAME_WIDTH + 25; torch2.y = GAME_HEIGHT * 0.7; midgroundContainer.addChild(torch2); } function startTutorial() { // Clear title screen titleScreen.destroy(); // Initialize game state gameStarted = true; tutorialActive = true; // Create and initialize tutorial manager tutorialManager = new TutorialManager(); tutorialManager.init(); // Initialize particle system if needed if (!particleSystem) { particleSystem = new ParticlePool(100); game.addChild(particleSystem); } } // Initialize game elements function initializeGame() { // Create player SaveManager.load(); player = game.addChild(new Player()); player.x = GAME_WIDTH / 4.5; player.y = GAME_HEIGHT / 1.5 - 100; game.addChild(heartContainer); SaveManager.applyUpgradeEffects(player); scoreManager.updateAmmo(player.ammoCount); // Create initial platforms at the low level for (var i = 0; i < 5; i++) { var platform = new Platform(); if (i === 0) { // First platform centered on player platform.x = player.x; } else { // Position with slight overlap platform.x = lastPlatformX + PLATFORM_WIDTH - PLATFORM_OVERLAP; } platform.y = lowPlatformHeight; platforms.push(platform); game.addChild(platform); lastPlatformX = platform.x; } lastPlatformHeight = lowPlatformHeight; currentPlatformPattern = 'A'; platformsUntilNextChange = 0; // This will trigger new sequence immediately after initial platforms player.isOnGround = true; player.currentPlatform = platforms[0]; } // Start the game function startGame() { gameStarted = true; gameStartTime = Date.now(); titleScreen.destroy(); // Initialize score manager game.addChild(scoreManager.container); initializeGame(); // Initialize particle system particleSystem = new ParticlePool(100); game.addChild(particleSystem); // Add shop button to gameplay createGameplayShopButton(); // Show health player.heartContainer.alpha = 1; player.heartVisibilityTimer = 120; // Play background music LK.playMusic('backgroundmusic1', { fade: { start: 0, end: 0.7, duration: 3500 } }); } // Update background layers function updateBackgrounds() { // Background layer (slowest) bg1.x -= PLATFORM_SPEED * 0.3 * gameSpeedMultiplier; bg2.x -= PLATFORM_SPEED * 0.3 * gameSpeedMultiplier; if (bg1.x <= -GAME_WIDTH) { bg1.x = bg2.x + GAME_WIDTH; } if (bg2.x <= -GAME_WIDTH) { bg2.x = bg1.x + GAME_WIDTH; } // Midground layer mg1.x -= PLATFORM_SPEED * 0.6 * gameSpeedMultiplier; mg2.x -= PLATFORM_SPEED * 0.6 * gameSpeedMultiplier; if (mg1.x <= -GAME_WIDTH) { mg1.x = mg2.x + GAME_WIDTH; } if (mg2.x <= -GAME_WIDTH) { mg2.x = mg1.x + GAME_WIDTH; } // Foreground layer (fastest) fg1.x -= PLATFORM_SPEED * gameSpeedMultiplier; fg2.x -= PLATFORM_SPEED * gameSpeedMultiplier; if (fg1.x <= -GAME_WIDTH) { fg1.x = fg2.x + GAME_WIDTH; } if (fg2.x <= -GAME_WIDTH) { fg2.x = fg1.x + GAME_WIDTH; } // Update torches for (var i = 0; i < midgroundContainer.children.length; i++) { var child = midgroundContainer.children[i]; if (child instanceof Torch) { child.update(); child.x -= PLATFORM_SPEED * 0.6 * gameSpeedMultiplier; if (child.x <= -GAME_WIDTH) { child.x = child.x + GAME_WIDTH * 2; } } } } // Update and spawn platforms function updatePlatforms() { var lastPlatform = platforms[platforms.length - 1]; if (lastPlatform && lastPlatform.x < GAME_WIDTH + 500) { // Special case for first platform after initial sequence if (!currentPlatformPattern) { currentPlatformPattern = 'A'; platformsUntilNextChange = Math.floor(Math.random() * (MAX_PLATFORMS_IN_SEQUENCE - MIN_PLATFORMS_IN_SEQUENCE + 1)) + MIN_PLATFORMS_IN_SEQUENCE; } if (platformsUntilNextChange <= 0) { // Add chance to switch to pattern C (straight section) var patternChance = Math.random(); if (patternChance < 0.1) { currentPlatformPattern = 'C'; platformsUntilNextChange = Math.floor(Math.random() * 4) + 6; currentStraightHeight = Math.random() < 0.5 ? highPlatformHeight : lowPlatformHeight; } else { currentPlatformPattern = currentPlatformPattern === 'A' ? 'B' : 'A'; platformsUntilNextChange = Math.floor(Math.random() * (MAX_PLATFORMS_IN_SEQUENCE - MIN_PLATFORMS_IN_SEQUENCE + 1)) + MIN_PLATFORMS_IN_SEQUENCE; } } // Calculate gap probability var timeSinceStart = Date.now() - gameStartTime; var baseGapChance = 0.025; var additionalChance = Math.min(0.10, timeSinceStart / 600000); var totalGapChance = baseGapChance + additionalChance; // Calculate trap platform chance based on time var baseTrapChance = 0.01; // 1% base chance var additionalChance = Math.min(0.15, timeSinceStart / 300000); // Up to 15% extra after 5 minutes var totalTrapChance = baseTrapChance + additionalChance; if (currentPlatformPattern === 'C') { // Single platform for straight sections, using stored height var platform; if (Math.random() < totalTrapChance) { platform = new CrumblePlatform(); } else { platform = new Platform(); } if (Math.random() < totalGapChance) { platform.x = lastPlatform.x + (PLATFORM_WIDTH + 400); } else { platform.x = lastPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP); } platform.y = currentStraightHeight; platforms.push(platform); game.addChild(platform); } else { // Regular dual platform patterns with possible double gaps var platformUpper, platformLower; // Create upper platform if (Math.random() < totalTrapChance) { platformUpper = new CrumblePlatform(); } else { platformUpper = new Platform(); } // Create lower platform if (Math.random() < totalTrapChance) { platformLower = new CrumblePlatform(); } else { platformLower = new Platform(); } // Determine gap type with random chance var gapChance = Math.random(); var hasDoubleGap = gapChance < totalGapChance * 0.3; // 30% of gap chance is double gap var hasSingleGap = !hasDoubleGap && gapChance < totalGapChance; // Remaining gap chance is single gap // If single gap, randomly choose which platform gets it var upperGap = hasDoubleGap || hasSingleGap && Math.random() < 0.5; var lowerGap = hasDoubleGap || hasSingleGap && !upperGap; // Position upper platform if (upperGap) { platformUpper.x = lastPlatform.x + (PLATFORM_WIDTH + 400); } else { platformUpper.x = lastPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP); } // Position lower platform if (lowerGap) { platformLower.x = lastPlatform.x + (PLATFORM_WIDTH + 400); } else { platformLower.x = lastPlatform.x + (PLATFORM_WIDTH - PLATFORM_OVERLAP); } if (currentPlatformPattern === 'A') { platformUpper.y = HIGHEST_PLATFORM_HEIGHT; platformLower.y = lowPlatformHeight; } else { platformUpper.y = highPlatformHeight; platformLower.y = LOWEST_PLATFORM_HEIGHT; } platforms.push(platformUpper); platforms.push(platformLower); game.addChild(platformUpper); game.addChild(platformLower); } platformsUntilNextChange--; } // Update platforms for (var i = platforms.length - 1; i >= 0; i--) { platforms[i].update(); if (platforms[i].destroyed) { platforms.splice(i, 1); } } } // Update and spawn collectibles function updateCollectibles() { // Jar spawning jarSpawnCounter++; if (jarSpawnCounter >= jarSpawnInterval) { var availablePlatforms = platforms.filter(function (p) { return p.x > GAME_WIDTH && p.x < GAME_WIDTH + 300 && !(p instanceof CrumblePlatform); }); // Try to spawn on multiple platforms availablePlatforms.forEach(function (platform) { if (Math.random() < 0.25 && GameUtils.canSpawnAtPosition(platform.x)) { // Adjusted probability var jar = new Jar(); jar.x = platform.x; jar.y = platform.y - 130; jar.currentPlatform = platform; collectibles.push(jar); game.addChild(jar); } }); jarSpawnCounter = 0; } // Treasure chest spawning chestSpawnCounter++; if (chestSpawnCounter >= chestSpawnInterval) { var availablePlatforms = platforms.filter(function (p) { return p.x > GAME_WIDTH && p.x < GAME_WIDTH + 300 && !(p instanceof CrumblePlatform); }); availablePlatforms.forEach(function (platform) { if (Math.random() < 0.12 && GameUtils.canSpawnAtPosition(platform.x)) { // Adjusted probability var chest = new TreasureChest(); chest.x = platform.x; chest.y = platform.y - 130; chest.currentPlatform = platform; collectibles.push(chest); game.addChild(chest); } }); chestSpawnCounter = 0; } // Update existing collectibles for (var i = collectibles.length - 1; i >= 0; i--) { var collectible = collectibles[i]; if (collectible.currentPlatform) { collectible.x = collectible.currentPlatform.x; } var attackBounds = player.getAttackBounds(); var slideAttackBounds = player.getSlideAttackBounds(); var itemBounds = { left: collectible.x - 50, right: collectible.x + 50, top: collectible.y - 75, bottom: collectible.y + 75 }; if (attackBounds && GameUtils.checkCollision(attackBounds, itemBounds) || slideAttackBounds && GameUtils.checkCollision(slideAttackBounds, itemBounds)) { collectible["break"](); collectibles.splice(i, 1); continue; } if (collectible.x < -50) { collectible.destroy(); collectibles.splice(i, 1); } } // Update coins and other collectibles for (var i = coins.length - 1; i >= 0; i--) { coins[i].update(); if (coins[i].destroyed) { coins.splice(i, 1); } } // Update score popups for (var i = game.children.length - 1; i >= 0; i--) { var child = game.children[i]; if (child instanceof ScorePopup) { child.update(); } } } // Update and spawn enemies function updateEnemies() { if (game.shopManager && game.shopManager.parent) { return; } if (!tutorialActive) { var isPlatformOccupied = function isPlatformOccupied(platform) { return enemies.some(function (enemy) { return enemy.currentPlatform === platform && (enemy.type === 'goblin' || enemy.type === 'skeleton' || enemy.type === 'mushroom'); }); }; // Get available platforms for ground enemies var availablePlatforms = platforms.filter(function (p) { return p.x > GAME_WIDTH - 100 && p.x < GAME_WIDTH + 300; }); // Filter out platforms that already have ground enemies var unoccupiedPlatforms = availablePlatforms.filter(function (p) { return !isPlatformOccupied(p); }); // Unified enemy spawn counter for all ground enemies enemySpawnCounter++; // If we have available platforms and it's time to spawn if (enemySpawnCounter >= enemySpawnInterval && unoccupiedPlatforms.length > 0) { // Decide how many enemies to spawn (1-3 based on available platforms) var spawnCount = Math.min(Math.floor(Math.random() * 3) + 1, unoccupiedPlatforms.length); for (var i = 0; i < spawnCount; i++) { // Choose a random platform from unoccupied ones var platformIndex = Math.floor(Math.random() * unoccupiedPlatforms.length); var platform = unoccupiedPlatforms[platformIndex]; // Choose enemy type randomly with weighted probabilities var enemyRandom = Math.random(); var enemyType; if (enemyRandom < 0.45) { enemyType = 'goblin'; // 45% chance for goblin } else if (enemyRandom < 0.75) { enemyType = 'mushroom'; // 30% chance for mushroom } else { enemyType = 'skeleton'; // 25% chance for skeleton } // Create the enemy var enemy = new Enemy(enemyType); enemy.x = platform.x; enemy.y = platform.y - ENEMY_PLATFORM_OFFSET; enemy.currentPlatform = platform; enemies.push(enemy); game.addChild(enemy); // Remove the used platform from available platforms unoccupiedPlatforms.splice(platformIndex, 1); } // Reset the counter with a random interval enemySpawnInterval = Math.floor(Math.random() * 100) + 150; enemySpawnCounter = 0; } // Eyeball spawning - kept separate since they don't use platforms eyeballSpawnCounter++; if (eyeballSpawnCounter >= eyeballSpawnInterval) { var enemy = new Enemy('eyeball'); var heightRange = LOWEST_PLATFORM_HEIGHT - HIGHEST_PLATFORM_HEIGHT; var randomHeight = Math.random() * heightRange; enemy.x = GAME_WIDTH + 100; enemy.y = HIGHEST_PLATFORM_HEIGHT + randomHeight; enemies.push(enemy); game.addChild(enemy); // Random interval between 200-400 ticks eyeballSpawnInterval = Math.floor(Math.random() * 200) + 200; eyeballSpawnCounter = 0; } } // Update enemies and check collisions for (var j = enemies.length - 1; j >= 0; j--) { enemies[j].update(); // Check if enemy has been destroyed if (enemies[j].destroyed) { enemies.splice(j, 1); continue; } // Skip if enemy is far behind player if (enemies[j].x < player.x - 100) { continue; } var playerBounds = player.getCollisionBounds(); var enemyBounds = enemies[j].getBounds(); var attackBounds = player.getAttackBounds(); var slideAttackBounds = player.getSlideAttackBounds(); // Check for attack collision first if (attackBounds && !enemies[j].isHit && !enemies[j].isDying) { if (enemies[j].x > player.x && GameUtils.checkCollision(attackBounds, enemyBounds)) { enemies[j].hit(); if (enemies[j].type === 'eyeball') { LK.getSound('eyeballhit').play(); } else if (enemies[j].type === 'skeleton') { LK.getSound('skeletonhit').play(); } else { LK.getSound('enemyhit').play(); } continue; } } // In the updateEnemies() function, inside the enemy update loop for (var i = arrows.length - 1; i >= 0; i--) { var arrow = arrows[i]; if (GameUtils.checkCollision(arrow.getBounds(), enemyBounds)) { // Only hit the enemy and destroy arrow if enemy is not already hit or dying if (!enemies[j].isHit && !enemies[j].isDying) { enemies[j].hit(); if (enemies[j].type === 'eyeball') { LK.getSound('eyeballhit').play(); } else if (enemies[j].type === 'skeleton') { LK.getSound('skeletonhit').play(); } else { LK.getSound('enemyhit').play(); } // Ricochet logic for tracking arrows if (UPGRADE_REGISTRY.tracking_arrow > 0) { var firstHitEnemy = enemies[j]; // The enemy that was just hit by 'arrow' var closestSecondEnemy = null; var minDistanceSqToSecondEnemy = RICOCHET_SEARCH_RADIUS_SQ; for (var k = 0; k < enemies.length; k++) { var potentialSecondEnemy = enemies[k]; // Ensure we're not targeting the same enemy, and the potential target is valid and in front of the player if (potentialSecondEnemy === firstHitEnemy || !potentialSecondEnemy || potentialSecondEnemy.isDying || potentialSecondEnemy.isHit || potentialSecondEnemy.destroyed || player && potentialSecondEnemy.x < player.x) { // Check against player's X position continue; } var dxRicochet = potentialSecondEnemy.x - firstHitEnemy.x; var dyRicochet = potentialSecondEnemy.y - firstHitEnemy.y; var distSqRicochet = dxRicochet * dxRicochet + dyRicochet * dyRicochet; if (distSqRicochet < minDistanceSqToSecondEnemy) { minDistanceSqToSecondEnemy = distSqRicochet; closestSecondEnemy = potentialSecondEnemy; } } if (closestSecondEnemy) { var ricochetArrow = new Arrow(); ricochetArrow.x = firstHitEnemy.x; ricochetArrow.y = firstHitEnemy.y; // Set startX/Y for tracking logic, relative to the new arrow's origin ricochetArrow.startX = ricochetArrow.x; ricochetArrow.startY = ricochetArrow.y; // Calculate the angle to the target and set it as the arrow's rotation ricochetArrow.rotation = Math.atan2(closestSecondEnemy.y - ricochetArrow.y, closestSecondEnemy.x - ricochetArrow.x); // Set the sprite rotation to match immediately ricochetArrow.sprite.rotation = ricochetArrow.rotation; // IMPORTANT: Update the velocity components to match the rotation ricochetArrow.velocityX = Math.cos(ricochetArrow.rotation) * RICOCHET_ARROW_SPEED; ricochetArrow.velocityY = Math.sin(ricochetArrow.rotation) * RICOCHET_ARROW_SPEED; ricochetArrow.speed = RICOCHET_ARROW_SPEED; ricochetArrow.damage = arrow.damage; game.addChild(ricochetArrow); arrows.push(ricochetArrow); } } // Only destroy the arrow if it actually damages an enemy arrow.destroy(); arrows.splice(i, 1); break; } // Arrows pass through already hit/dying enemies } } for (var i = skeletonSwords.length - 1; i >= 0; i--) { if (!skeletonSwords[i]) { skeletonSwords.splice(i, 1); continue; } skeletonSwords[i].update(); // Check collision with player if (GameUtils.checkCollision(skeletonSwords[i].getBounds(), playerBounds)) { if (!player.isInvulnerable && !player.isDying) { player.takeDamage(); skeletonSwords[i].destroy(); skeletonSwords.splice(i, 1); } } // Remove destroyed swords - safely check if the sword exists first and if it has destroyed property if (skeletonSwords[i] && skeletonSwords[i].destroyed === true) { skeletonSwords.splice(i, 1); } } // In the updateEnemies function where spore collisions are checked if (window.spores) { for (var i = window.spores.length - 1; i >= 0; i--) { var spore = window.spores[i]; // Skip if spore is invalid or already marked for removal if (!spore || !spore.parent || spore.destroyed) { window.spores.splice(i, 1); continue; } // Update spore spore.update(); // Only check collisions if the spore is active and player can take damage if (spore.isActive && !player.isInvulnerable && !player.isDying) { if (GameUtils.checkCollision(spore.getBounds(), player.getCollisionBounds())) { player.takeDamage(); spore.hasHitPlayer = true; spore.explode(); } } // Safety check - if spore is destroyed but still in array, remove it if (spore.destroyed) { window.spores.splice(i, 1); } } } // Check for slide collision if (slideAttackBounds && !enemies[j].isHit && !enemies[j].isDying) { if (enemies[j].x > player.x && GameUtils.checkCollision(slideAttackBounds, enemyBounds)) { enemies[j].slideHit(); continue; } } if ((slideAttackBounds || player.isAirDashing && playerBounds) && !enemies[j].isHit && !enemies[j].isDying) { if (enemies[j].x > player.x && GameUtils.checkCollision(player.isAirDashing ? playerBounds : slideAttackBounds, enemyBounds)) { enemies[j].slideHit(); continue; } } if (GameUtils.checkCollision(playerBounds, enemyBounds)) { if (!enemies[j].isHit && !enemies[j].isDying) { player.takeDamage(); } } } } if (!game.saveManager) { game.saveManager = SaveManager; SaveManager.load(); } // Create the initial title screen createTitleScreen(); /**** * Game Loop & Input Handlers ****/ // Main game update loop // Modify the main game update function game.update = function () { // Always update backgrounds updateBackgrounds(); if (!gameStarted) { // Add shop update here if shop is open if (game.shopManager) { game.shopManager.update(); } return; } // Update player and particles player.update(); if (particleSystem) { particleSystem.update(); } // Update arrows for (var i = arrows.length - 1; i >= 0; i--) { var arrow_to_check = arrows[i]; // Use a temporary variable for clarity arrow_to_check.update(); // Check if arrow is outside screen boundaries and handle destruction if (arrow_to_check.x > GAME_WIDTH || arrow_to_check.x < 0 || arrow_to_check.y > GAME_HEIGHT || arrow_to_check.y < 0) { arrow_to_check.destroy(); arrows.splice(i, 1); continue; // Arrow removed, skip to next iteration } // Fallback check: if arrow was destroyed by other means (e.g., enemy collision) // Note: Enemy collision logic in updateEnemies also splices. This is a safeguard. if (arrow_to_check.destroyed) { arrows.splice(i, 1); // No continue needed here as it's the last check for this arrow in this part of the loop } } for (var i = game.children.length - 1; i >= 0; i--) { var child = game.children[i]; if (child instanceof CrumblePiece) { child.update(); } } // Update arrow trail particles for (var k = arrowParticles.length - 1; k >= 0; k--) { var p = arrowParticles[k]; p.update(); // Check if particle is marked for destruction by its tween and is visually faded if (p.destroyQueued && p.sprite.alpha < 0.05) { p.destroy(); arrowParticles.splice(k, 1); } else if (p.x < -50 || p.x > GAME_WIDTH + 50 || p.y < -50 || p.y > GAME_HEIGHT + 50) { // Fallback: destroy if way off-screen (e.g. if tween was interrupted or didn't complete) p.destroy(); arrowParticles.splice(k, 1); } } if (tutorialActive) { tutorialManager.update(); } else { // Normal game updates updatePlatforms(); updateCollectibles(); updateEnemies(); } }; // Handle touch/click events game.down = function (x, y, obj) { touchStartX = x; touchStartY = y; }; game.up = function (x, y, obj) { if (game.shopManager && game.shopManager.parent) { return; } if (!gameStarted) { // Don't process button clicks if shop is open if (game.shopManager && game.shopManager.parent) { return; } var playButtonBounds = { left: playButton.x - playButton.width / 2, right: playButton.x + playButton.width / 2, top: playButton.y - playButton.height / 2, bottom: playButton.y + playButton.height / 2 }; var tutorialButtonBounds = { left: tutorialButton.x - tutorialButton.width / 2, right: tutorialButton.x + tutorialButton.width / 2, top: tutorialButton.y - tutorialButton.height / 2, bottom: tutorialButton.y + tutorialButton.height / 2 }; if (x >= playButtonBounds.left && x <= playButtonBounds.right && y >= playButtonBounds.top && y <= playButtonBounds.bottom) { // Check if the button has already been pressed if (game.playButtonPressed) { return; } game.playButtonPressed = true; // Stop the flashing animation if (playButtonFlashInterval) { LK.clearInterval(playButtonFlashInterval); playButtonFlashInterval = null; // Ensure button is fully visible before animation playButton.alpha = 1; } // Play start game sound effect LK.getSound('startgame').play(); // Add scale animation tween(playButton, { scaleX: 0.8, scaleY: 0.8 }, { duration: 150, easing: tween.easeOut, onFinish: function onFinish() { tween(playButton, { scaleX: 1, scaleY: 1 }, { duration: 250, easing: tween.easeOut, onFinish: function onFinish() { // Start game after a 1 second delay LK.setTimeout(function () { startGame(); }, 900); } }); } }); } else if (x >= tutorialButtonBounds.left && x <= tutorialButtonBounds.right && y >= tutorialButtonBounds.top && y <= tutorialButtonBounds.bottom) { // Add visual feedback animation tween(tutorialButton, { scaleX: 0.9, scaleY: 0.9 }, { duration: 100, easing: tween.easeOut, onFinish: function onFinish() { tween(tutorialButton, { scaleX: 1, scaleY: 1 }, { duration: 200, easing: tween.easeOut, onFinish: function onFinish() { startTutorial(); } }); } }); // Play menu select sound LK.getSound('menuselect').play(); return; } return; } // Prevent input if player is dying or air dying if (player && (player.isDying || player.dyingInAir)) { return; } if (tutorialActive && tutorialManager) { tutorialManager.inputProcessed = false; // Reset the flag on touch end } touchEndX = x; touchEndY = y; if (tutorialActive) { tutorialManager.checkInput(touchStartX, touchStartY, touchEndX, touchEndY); } var deltaY = touchEndY - touchStartY; var deltaX = touchEndX - touchStartX; // Ignore very small movements if (Math.abs(deltaY) < VERTICAL_DEADZONE && Math.abs(deltaX) < VERTICAL_DEADZONE) { player.attack(); // Just treat as tap/attack return; } if (Math.abs(deltaX) > Math.abs(deltaY)) { // Horizontal swipe if (deltaX > 50) { if (player.isOnGround) { player.slide(); } else { player.airDash(); } } else if (deltaX < -50) { // Left swipe - trigger bow shot player.shoot(); } } else if (deltaY > 120) { // Downward swipe if (!player.isOnGround) { player.groundSlam(); // Call ground slam FIRST when in air } else { player.fallThrough(); } } else if (deltaY < -120) { // Upward swipe - existing jump code var currentTime = Date.now(); if (currentTime - lastJumpTime > JUMP_COOLDOWN) { player.jump(); lastJumpTime = currentTime; } } else { // Tap - existing attack code player.attack(); } }; game.move = function (x, y, obj) { if (!gameStarted) { return; } var deltaX = x - touchStartX; lastMoveY = y; };