/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1", { highScore: 0 }); /**** * Classes ****/ var HitFeedback = Container.expand(function () { var self = Container.call(this); self.feedbackText = null; self.messages = ['WOW!', 'AMAZING!!', 'INCREDIBLE!', 'SPECTACULAR!', 'SUPER!!', 'UNSTOPPABLE!!!']; self.init = function () { // Create feedback text with golden color self.feedbackText = new Text2('', { size: 480, fill: 0xFFD700, font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); self.feedbackText.anchor.set(0.5, 0.5); self.addChild(self.feedbackText); // Initially hide the text self.feedbackText.alpha = 0; return self; }; self.showMessage = function (hitCount) { // Determine which message to show based on hit count var index = Math.min(Math.floor(hitCount / 5) - 1, self.messages.length - 1); if (index < 0) { return; } // Don't show anything for less than 5 hits var message = self.messages[index]; // Add combo count to the message var comboMessage = "Combo: " + hitCount + "\n" + message; // Play one of the three streak sounds randomly when milestone hit var streakSounds = ['streakSound', 'hitSound2', 'hitSound3']; var randomSoundIndex = Math.floor(Math.random() * streakSounds.length); LK.getSound(streakSounds[randomSoundIndex]).play(); // Stop any ongoing animations tween.stop(self.feedbackText, { alpha: true, scaleX: true, scaleY: true, rotation: true }); // Set the text self.feedbackText.setText(comboMessage); // Reset properties for animation self.feedbackText.alpha = 0; self.feedbackText.scale.set(0.5, 0.5); self.feedbackText.rotation = -0.1; // Animate in tween(self.feedbackText, { alpha: 1, scaleX: 1.2, scaleY: 1.2, rotation: 0.1 }, { duration: 300, easing: tween.elasticOut, onFinish: function onFinish() { // Hold for a moment LK.setTimeout(function () { // Animate out tween(self.feedbackText, { alpha: 0, scaleX: 1.5, scaleY: 1.5, rotation: 0 }, { duration: 400, easing: tween.easeOut }); }, 600); } }); }; return self; }); var Note = Container.expand(function () { var self = Container.call(this); self.type = 'normal'; // normal, perfect, good self.lane = 0; // 0-3 for different lanes self.speed = 10; // Base speed self.active = true; // Whether note is still active self.scored = false; // Whether note has been scored self.noteGraphics = null; self.perspective = 0; // 0 = distance, 1 = close to screen self.baseWidth = 180; // The base width for perspective scaling self.baseHeight = 30; // The base height for perspective scaling self.distanceZ = 0; // Z-coordinate for 3D perspective (0 = far, 1 = close) self.init = function (noteType, laneNum, noteSpeed) { self.type = noteType || 'normal'; self.lane = laneNum || 0; self.speed = 10; // Reduced speed for lower difficulty self.distanceZ = 0; // Start far away self.targetX = null; // Target x position for the lane self.xSpeed = null; // How fast to move horizontally per frame // Create note graphic based on type var assetId = 'note'; if (self.type === 'perfect') { assetId = 'perfectNote'; } else if (self.type === 'good') { assetId = 'goodNote'; } self.noteGraphics = self.attachAsset(assetId, { anchorX: 0.5, anchorY: 0.5, alpha: 0.9 }); // Apply initial perspective (start small) self.updatePerspective(0); return self; }; // Update visual perspective based on distance value (0=far, 1=close) self.updatePerspective = function (distanceValue) { self.distanceZ = distanceValue; // Calculate scale based on distance (smaller when far, normal size when close) var scale = 0.3 + distanceValue * 0.7; // Scale from 30% to 100% // Apply scale to note self.noteGraphics.scale.x = scale; self.noteGraphics.scale.y = scale; // Adjust alpha to fade in as it gets closer self.noteGraphics.alpha = 0.5 + distanceValue * 0.5; }; self.update = function () { if (!self.active) { return; } // Move note down self.y += self.speed; // Store last speed for smooth changes self.lastSpeed = self.speed; // Move note horizontally towards target lane if xSpeed is defined if (self.xSpeed) { // Calculate remaining distance to target var remainingX = self.targetX - self.x; // Move towards target, but don't overshoot if (Math.abs(remainingX) < Math.abs(self.xSpeed)) { self.x = self.targetX; // Arrived at exact position } else { self.x += self.xSpeed; // Move towards target } } // Calculate perspective based on y position // Map y position from starting position to target (2500) to 0-1 perspective value var startPos = 2732 / 2 + noteStartY; var targetPos = 2500; var totalDistance = targetPos - startPos; var perspectiveValue = Math.max(0, Math.min(1, (self.y - startPos) / totalDistance)); self.updatePerspective(perspectiveValue); // Check if note passed through target zone and wasn't scored var hitY = targetZones[self.lane].y; var targetBottom = hitY + targetBoxSize.height / 2; // Track when note passes completely through the target zone if (self.y > targetBottom + 50 && !self.scored) { // Note passed through target zone without being hit self.miss(); } // Check if note is completely out of bounds and hasn't been scored else if (self.y > 2732 + 100 && !self.scored) { self.miss(); } }; self.hit = function (accuracy) { if (!self.active || self.scored) { return; } self.scored = true; self.active = false; // Create hit effect LK.effects.flashObject(self, 0xFFFFFF, 300); if (accuracy === 'perfect') { LK.getSound('perfectSound').play(); tween(self.noteGraphics, { alpha: 0, scaleX: 1.5, scaleY: 1.5 }, { duration: 300, onFinish: function onFinish() { self.destroy(); } }); } else if (accuracy === 'good') { LK.getSound('hitSound').play(); tween(self.noteGraphics, { alpha: 0, scaleX: 1.3, scaleY: 1.3 }, { duration: 300, onFinish: function onFinish() { self.destroy(); } }); } else { LK.getSound('hitSound').play(); tween(self.noteGraphics, { alpha: 0 }, { duration: 200, onFinish: function onFinish() { self.destroy(); } }); } }; self.miss = function () { if (!self.active || self.scored) { return; } self.scored = true; self.active = false; // Increment missedNotes counter only if the note passed through target zone var hitY = targetZones[self.lane].y; var targetTop = hitY - targetBoxSize.height / 2; var targetBottom = hitY + targetBoxSize.height / 2; var wasInTargetZone = self.y >= targetTop && self.y <= targetBottom; if (wasInTargetZone || self.y > targetBottom) { // Only count as missed if it was in or passed the target zone missedNotes++; // Increment consecutive misses consecutiveMisses++; // Reset consecutive hits and feedback threshold consecutiveHits = 0; lastFeedbackThreshold = 0; } // Update accuracy display when a note is missed scoreDisplay.updateAccuracy(calculateAccuracy()); scoreDisplay.showFeedback('miss'); LK.getSound('missSound').play(); // Change to missed note appearance if (self.noteGraphics) { self.removeChild(self.noteGraphics); } self.noteGraphics = self.attachAsset('missedNote', { anchorX: 0.5, anchorY: 0.5, alpha: 0.5 }); tween(self.noteGraphics, { alpha: 0 }, { duration: 200, onFinish: function onFinish() { self.destroy(); } }); }; return self; }); var ScoreDisplay = Container.expand(function () { var self = Container.call(this); self.scoreText = null; self.comboText = null; self.accuracyText = null; self.feedbackText = null; self.init = function () { // Create score text self.scoreText = new Text2('Score: 0', { size: 80, fill: 0xFFFFFF }); self.scoreText.anchor.set(0.5, 0); self.addChild(self.scoreText); // Create high score text self.highScoreText = new Text2('High Score: ' + highScore, { size: 40, fill: 0xFFAA00 }); self.highScoreText.anchor.set(0.5, 0); self.highScoreText.y = 100; self.addChild(self.highScoreText); // Create accuracy text self.accuracyText = new Text2('Accuracy: 0%', { size: 40, fill: 0xDDDDDD }); self.accuracyText.anchor.set(0.5, 0); self.accuracyText.y = 160; self.addChild(self.accuracyText); // Create feedback text for "Perfect!", "Good!", "Miss!" self.feedbackText = new Text2('', { size: 90, fill: 0xFFFFFF }); self.feedbackText.anchor.set(0.5, 0.5); self.feedbackText.y = 300; self.addChild(self.feedbackText); return self; }; self.updateScore = function (score) { self.scoreText.setText('Score: ' + score); }; // Combo update method removed self.updateAccuracy = function (accuracy) { // Color code the accuracy based on performance var color = "#DDDDDD"; // Default color if (accuracy >= 90) { color = "#00FF00"; // Excellent (green) } else if (accuracy >= 75) { color = "#FFFF00"; // Good (yellow) } else if (accuracy >= 50) { color = "#FFA500"; // Fair (orange) } else { color = "#FF0000"; // Poor (red) } self.accuracyText.setText('Accuracy: ' + accuracy + '%', { fill: color }); }; self.updateHighScore = function (newHighScore) { self.highScoreText.setText('High Score: ' + newHighScore); }; self.showFeedback = function (type) { // Clear any existing animations tween.stop(self.feedbackText, { alpha: true, scaleX: true, scaleY: true }); var color = "#FFFFFF"; var text = ""; if (type === 'perfect') { text = "Perfect!"; color = "#FF4500"; } else if (type === 'good') { text = "Good!"; color = "#32CD32"; } else if (type === 'miss') { text = "Miss!"; color = "#888888"; } self.feedbackText.setText(text); // Set the text with the new color in the style self.feedbackText.setText(text, { fill: color }); self.feedbackText.alpha = 1; self.feedbackText.scale.set(1.3, 1.3); tween(self.feedbackText, { alpha: 0, scaleX: 1, scaleY: 1 }, { duration: 600, easing: tween.easeOut }); }; return self; }); var TargetZone = Container.expand(function () { var self = Container.call(this); self.lane = 0; self.zoneGraphics = null; self.active = false; self.pulseTimer = 0; self.perspectiveLines = null; self.init = function (laneNum) { self.lane = laneNum || 0; // Create target zone with 3D perspective appearance self.zoneGraphics = self.attachAsset('targetZone', { anchorX: 0.5, anchorY: 0.5, alpha: 0.4, width: targetBoxSize.width, // Use the target box size variable here height: targetBoxSize.height }); // Create perspective guide elements to enhance 3D effect self.createPerspectiveGuides(); return self; }; // Add perspective guides to enhance 3D effect self.createPerspectiveGuides = function () { self.perspectiveLines = new Container(); self.addChild(self.perspectiveLines); // Create 3D perspective indicator lines in the lane for (var i = 1; i <= 3; i++) { var depth = i * 0.25; // 0.25, 0.5, 0.75 positions var lineSize = targetBoxSize.width * (0.4 + depth * 0.6); // Gets larger as it gets closer var opacity = 0.15 + (1 - depth) * 0.1; // Fades as it gets closer var line = LK.getAsset('targetZone', { anchorX: 0.5, anchorY: 0.5, width: lineSize, height: 5, alpha: opacity }); // Position lines above the target zone line.y = -(400 * depth); self.perspectiveLines.addChild(line); } }; self.update = function () { // Subtle pulsing effect when not active if (!self.active) { self.pulseTimer += 0.05; self.zoneGraphics.alpha = 0.3 + Math.sin(self.pulseTimer) * 0.1; } }; self.activate = function () { if (self.active) { return; } self.active = true; tween(self.zoneGraphics, { alpha: 0.8, scaleX: 1.1, scaleY: 1.1 }, { duration: 100, onFinish: function onFinish() { self.deactivate(); } }); }; self.deactivate = function () { self.active = false; tween(self.zoneGraphics, { alpha: 0.4, scaleX: 1.0, scaleY: 1.0 }, { duration: 200 }); }; self.down = function (x, y, obj) { self.activate(); }; return self; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x111133 }); /**** * Game Code ****/ // Default size, will be overridden when initialized // Game configuration var laneCount = 4; var laneWidth = 2048 / laneCount; var targetBoxSize = { width: 500, height: 400 }; // Adjustable target zone dimensions var noteStartY = -800; // Adjustable starting position for notes, default is 200 above screen center var minNoteSpeed = 5; // Minimum speed of notes at game start var maxNoteSpeed = 40; // Maximum speed notes can reach var speedRampUpTime = 60 * 240; // Time in frames to reach max speed (30 seconds at 60fps) var gameSpeed = minNoteSpeed; // Starting game speed uses minNoteSpeed var currentLevel = 1; var difficultyMultiplier = 1.0; var speedIncreaseInterval = 300; // Frames between speed increases (5 seconds at 60fps) var speedIncreaseAmount = 0.05; // How much to increase speed each interval var speedIncreaseMax = maxNoteSpeed / minNoteSpeed; // Maximum speed multiplier derived from min/max speed var lastSpeedIncreaseTime = 0; // Track last time speed was increased var beatFrequency = 60; // Frames between beat patterns var beatVariance = 10; // Random variation in beat timing var nextBeatFrame = 20; // When to spawn the next beat var perspectiveEnabled = true; // Enable the perspective effect var perspectiveHeight = 2000; // Visual height of the 3D perspective lane // Note spawning configuration var minNotesPerSecond = 0.05; // Minimum notes per second at game start (at 60fps) var maxNotesPerSecond = 2.5; // Maximum notes per second the game can reach var noteRampUpTime = 60 * 480; // Time in frames to reach max notes per second (4 minutes at 60fps) var currentNotesPerSecond = minNotesPerSecond; // Current notes per second rate var noteSpawnCounter = 0; // Counter for note spawning logic // Game state var score = 0; var combo = 0; var maxCombo = 0; var totalNotes = 0; var hitNotes = 0; var missedNotes = 0; // Track notes that passed through the target zone var consecutiveMisses = 0; // Track consecutive misses var consecutiveHits = 0; // Track consecutive hits for feedback messages var hitStreakThreshold = 12; // Number of consecutive hits needed to show feedback var lastFeedbackThreshold = 0; // Last threshold where feedback was shown var maxConsecutiveMissesAllowed = 10; // Maximum consecutive misses allowed before game over - can be adjusted for difficulty var perfectHits = 0; var activeNotes = []; var targetZones = []; var gameStarted = false; var gameOver = false; var highScore = storage.highScore || 0; var hitFeedback; // Container for hit streak feedback messages // UI elements var scoreDisplay; var startText; var backgroundShape; // Add background layers // First add the back background layer var backgroundBackShape = game.addChild(LK.getAsset('backgroundBack', { anchorX: 0, anchorY: 0, width: 2048, height: 2732 })); // Background image removed // Make sure backgroundBackShape is at the bottom of the display stack game.setChildIndex(backgroundBackShape, 0); // Create perspective lanes and target zones function createPerspectiveLane(laneNum) { var container = new Container(); var laneX = laneWidth * (laneNum + 0.5); // Add the lane image var laneImage = LK.getAsset('noteLane', { anchorX: 0.5, anchorY: 0, alpha: 0.6, width: targetBoxSize.width * 0.9 // Make it slightly narrower than target box }); // Position the lane image laneImage.y = 500; // Start position laneImage.height = perspectiveHeight; // Set lane height // Add some subtle perspective effect with gradual fade var gradient = []; for (var i = 1; i <= 5; i++) { var distance = i / 5; // 0.2 to 1.0 var y = 500 + distance * 1800; // Map to y positions var lineOpacity = 0.05 + (1 - distance) * 0.1; // Fade with distance // Create lane markers as subtle horizontal lines var marker = LK.getAsset('targetZone', { anchorX: 0.5, anchorY: 0.5, width: targetBoxSize.width * (0.4 + distance * 0.6), height: 2, alpha: lineOpacity }); marker.y = y; gradient.push(marker); container.addChild(marker); } // Add lane image last so it appears on top of markers container.addChild(laneImage); container.x = laneX; return container; } // Create perspective lanes - use a single lane image background instead of multiple lanes if (perspectiveEnabled) { // Add a single noteLane image spanning the entire width of the game var fullLaneImage = LK.getAsset('noteLane', { anchorX: 0.5, anchorY: 0, alpha: 0.6, width: 2048, // Full game width height: perspectiveHeight }); // Position the lane image fullLaneImage.x = 2048 / 2; // Center horizontally fullLaneImage.y = 500; // Start position game.addChild(fullLaneImage); // Add subtle lane markers to help with visual guidance for (var i = 1; i <= laneCount - 1; i++) { // Create divider lines between lanes var divider = LK.getAsset('targetZone', { anchorX: 0.5, anchorY: 0, width: 2, height: perspectiveHeight, alpha: 0.3 }); divider.x = laneWidth * i; // Position at lane dividers divider.y = 500; game.addChild(divider); } } // Create target zones for (var i = 0; i < laneCount; i++) { var zone = new TargetZone().init(i); zone.x = laneWidth * (i + 0.5); zone.y = 2500; // Bottom of screen targetZones.push(zone); game.addChild(zone); } // Create and position score display scoreDisplay = new ScoreDisplay().init(); scoreDisplay.x = 2048 / 2; scoreDisplay.y = 150; game.addChild(scoreDisplay); // Create hit streak feedback display hitFeedback = new HitFeedback().init(); hitFeedback.x = 2048 / 2; hitFeedback.y = 2732 / 3; // Positioned in the top third of the screen game.addChild(hitFeedback); // Create start text startText = new Text2('Tap to Start', { size: 120, fill: 0xFFFFFF }); startText.anchor.set(0.5, 0.5); startText.x = 2048 / 2; startText.y = 2732 / 2; game.addChild(startText); // Calculate accuracy as a percentage function calculateAccuracy() { // Base case: if no notes have reached the target zone yet if (hitNotes + missedNotes === 0) { return 100; } // Calculate the actual percentage of notes hit versus total notes that passed through the target zone return Math.floor(hitNotes / (hitNotes + missedNotes) * 100); } // Spawn a new note function spawnNote() { var laneNum = Math.floor(Math.random() * laneCount); var noteType = 'normal'; // 20% chance for a "perfect" note, 30% chance for a "good" note var rand = Math.random(); if (rand < 0.2) { noteType = 'perfect'; } else if (rand < 0.5) { noteType = 'good'; } // Use constant speed for all notes, regardless of game progress var noteSpeed = 10; // Reduced constant speed value for lower difficulty var note = new Note().init(noteType, laneNum, noteSpeed); note.x = 2048 / 2; // Start at the center of the screen on x axis note.y = 2732 / 2 + noteStartY; // Start above center of the screen based on noteStartY variable note.targetX = laneWidth * (laneNum + 0.5); // Store target x position // Calculate distance to travel in x axis var xDistance = note.targetX - note.x; // Calculate time to reach target zone based on y distance and speed var timeToTarget = (2500 - (2732 / 2 + noteStartY)) / noteSpeed; // Calculate how much to move per frame to reach target at the same time as reaching target zone note.xSpeed = xDistance / timeToTarget; // No immediate tween - will move gradually in update function // Apply perspective effect if (perspectiveEnabled) { // Start with small scale to create distance effect note.updatePerspective(0); // 0 = far away // Apply entrance animation for perspective effect note.noteGraphics.alpha = 0.4; // Start more transparent // Apply a grow animation to the note as it appears tween(note.noteGraphics, { alpha: 0.9 }, { duration: 300, easing: tween.easeOut }); } activeNotes.push(note); game.addChild(note); totalNotes++; return note; } // Generate beat pattern function generateBeatPattern() { var patternLength = Math.min(4, 1 + Math.floor(currentLevel / 2)); for (var i = 0; i < patternLength; i++) { // Stagger notes based on pattern position LK.setTimeout(function () { if (!gameOver && gameStarted) { spawnNote(); } }, i * (200 / difficultyMultiplier)); } } // Check if a note is in the hit zone function checkNoteHit(laneNum) { var hitZone = targetZones[laneNum]; var hitY = hitZone.y; var hitFound = false; // Find notes in this lane for (var i = 0; i < activeNotes.length; i++) { var note = activeNotes[i]; if (note.lane === laneNum && note.active && !note.scored) { // Check if note is inside target zone bounds var targetTop = hitY - targetBoxSize.height / 2; var targetBottom = hitY + targetBoxSize.height / 2; var isInsideTargetZone = note.y >= targetTop && note.y <= targetBottom; if (isInsideTargetZone) { // Calculate distance from perfect hit position as a percentage of target box height var distance = Math.abs(note.y - hitY); var distancePercent = distance / (targetBoxSize.height / 2); // Different hit zones based on percentage of target box height if (distancePercent < 0.3) { // Perfect hit - center 30% of target zone score += 100; hitNotes++; perfectHits++; note.hit('perfect'); scoreDisplay.showFeedback('perfect'); hitFound = true; // Reset consecutive misses on successful hit consecutiveMisses = 0; // Increment consecutive hits consecutiveHits++; // Show feedback message at each hit streak milestone if (Math.floor(consecutiveHits / hitStreakThreshold) > lastFeedbackThreshold) { lastFeedbackThreshold = Math.floor(consecutiveHits / hitStreakThreshold); hitFeedback.showMessage(consecutiveHits); } break; } else if (distancePercent < 0.7) { // Good hit - middle 40% of target zone score += 50; hitNotes++; note.hit('good'); scoreDisplay.showFeedback('good'); hitFound = true; // Reset consecutive misses on successful hit consecutiveMisses = 0; // Increment consecutive hits consecutiveHits++; // Show feedback message at each hit streak milestone if (Math.floor(consecutiveHits / hitStreakThreshold) > lastFeedbackThreshold) { lastFeedbackThreshold = Math.floor(consecutiveHits / hitStreakThreshold); hitFeedback.showMessage(consecutiveHits); } break; } else { // Within bounds but not centered - early/late hit at edges of target zone score += 10; hitNotes++; note.hit('early'); scoreDisplay.showFeedback('good'); hitFound = true; // Reset consecutive misses on successful hit consecutiveMisses = 0; // Increment consecutive hits consecutiveHits++; // Show feedback message at each hit streak milestone if (Math.floor(consecutiveHits / hitStreakThreshold) > lastFeedbackThreshold) { lastFeedbackThreshold = Math.floor(consecutiveHits / hitStreakThreshold); hitFeedback.showMessage(consecutiveHits); } break; } } } } // If we didn't hit any notes, it's a miss if (!hitFound) { scoreDisplay.showFeedback('miss'); // Note: We don't increment consecutiveMisses here because this is a tap miss, // not a note pass-through miss which is handled in Note.miss() } // Update score display var roundedScore = Math.floor(score); scoreDisplay.updateScore(roundedScore); maxCombo = Math.max(maxCombo, combo); // Check and update high score if (roundedScore > highScore) { highScore = roundedScore; storage.highScore = highScore; scoreDisplay.updateHighScore(highScore); // Flash high score when new record is set if (roundedScore > 0) { scoreDisplay.showFeedback("New High Score!"); LK.effects.flashObject(scoreDisplay.highScoreText, 0xFFFF00, 500); } } // Update accuracy after every note hit var accuracy = calculateAccuracy(); scoreDisplay.updateAccuracy(accuracy); return hitFound; } // Handle tap on a lane function handleLaneTap(laneNum) { if (!gameStarted || gameOver) { return; } targetZones[laneNum].activate(); return checkNoteHit(laneNum); } // Start the game function startGame() { if (gameStarted) { return; } gameStarted = true; game.removeChild(startText); // Reset game state score = 0; combo = 0; maxCombo = 0; totalNotes = 0; hitNotes = 0; missedNotes = 0; // Reset missed notes counter consecutiveMisses = 0; // Reset consecutive misses counter consecutiveHits = 0; // Reset consecutive hits counter lastFeedbackThreshold = 0; // Reset feedback threshold perfectHits = 0; currentLevel = 1; difficultyMultiplier = 1.0; gameSpeed = minNoteSpeed; // Reset base speed to minimum lastSpeedIncreaseTime = 0; // Reset note spawning variables currentNotesPerSecond = minNotesPerSecond; noteSpawnCounter = 0; gameOver = false; // Update UI scoreDisplay.updateScore(score); // Initialize accuracy with default 100% at game start scoreDisplay.updateAccuracy(100); scoreDisplay.updateHighScore(highScore); // Initial speed up message scoreDisplay.showFeedback("Get Ready!"); // Start music LK.playMusic('gameMusic', { fade: { start: 0, end: 1, duration: 1000 } }); // Set the first beat to spawn soon nextBeatFrame = 60; } // Check if game should end (based on time or score) function checkGameOver() { // For demo purposes, end game after reaching level 10 if (currentLevel >= 10 && score >= 10000) { endGame(true); // Win } // Player loses if accuracy drops too low if (totalNotes > 20 && calculateAccuracy() < 40) { endGame(false); // Lose due to low accuracy } // Player loses if they miss too many notes in a row if (consecutiveMisses >= maxConsecutiveMissesAllowed) { endGame(false); // Lose due to too many consecutive misses } } // End the game function endGame(win) { gameOver = true; // Fade out music LK.playMusic('gameMusic', { fade: { start: 1, end: 0, duration: 800 } }); // Save high score to storage if (score > highScore) { highScore = Math.floor(score); storage.highScore = highScore; } // Show game over or win screen based on performance if (win) { LK.showYouWin(); } else { LK.showGameOver(); } } // Handle lane tap detection - we'll divide the screen into lanes function getLaneFromPosition(x) { return Math.floor(x / laneWidth); } // Handle touch events game.down = function (x, y, obj) { if (!gameStarted) { startGame(); } else { var lane = getLaneFromPosition(x); if (lane >= 0 && lane < laneCount) { handleLaneTap(lane); } } }; game.update = function () { if (!gameStarted) { return; } // Update all active notes for (var i = activeNotes.length - 1; i >= 0; i--) { var note = activeNotes[i]; // Remove notes that have been scored and faded out if (!note.active && note.scored) { activeNotes.splice(i, 1); } } // Update target zones for (var j = 0; j < targetZones.length; j++) { targetZones[j].update(); } // Calculate note spawning rate based on progress if (gameStarted && !gameOver) { // Calculate progress for notes per second (separate from speed progress) var progressToMaxNoteRate = Math.min(1.0, LK.ticks / noteRampUpTime); // Calculate new notes per second rate based on progress between min and max currentNotesPerSecond = minNotesPerSecond + (maxNotesPerSecond - minNotesPerSecond) * progressToMaxNoteRate; // Calculate frames between notes based on notes per second var framesBetweenNotes = Math.floor(60 / currentNotesPerSecond); // Spawn notes based on the current rate noteSpawnCounter++; if (noteSpawnCounter >= framesBetweenNotes) { spawnNote(); noteSpawnCounter = 0; // Visual feedback when note rate increases significantly if (LK.ticks % 600 === 0 && progressToMaxNoteRate > 0.2) { scoreDisplay.showFeedback("More Notes!"); } } } // Generate new beat patterns at intervals - this is now supplementary to the base note spawning if (gameStarted && !gameOver) { if (LK.ticks >= nextBeatFrame) { generateBeatPattern(); // Calculate next beat timing with some variance var interval = beatFrequency - currentLevel * 5; interval = Math.max(interval, 30); // Don't go too fast var variance = Math.floor(Math.random() * beatVariance) - beatVariance / 2; nextBeatFrame = LK.ticks + interval + variance; // Increase difficulty over time if (LK.ticks % 600 === 0) { // Every 10 seconds currentLevel++; difficultyMultiplier = 1.0 + currentLevel * 0.2; // Increased from 0.1 to 0.2 for faster speed growth // No longer dynamically increasing speed of existing notes for (var i = 0; i < activeNotes.length; i++) { var note = activeNotes[i]; // We no longer change speed of active notes } } } } // No longer applying speed increases to notes during gameplay if (gameStarted && !gameOver) { // We still calculate this for other game mechanics, but don't apply to note speeds var progressToMaxSpeed = Math.min(1.0, LK.ticks / speedRampUpTime); var newGameSpeed = minNoteSpeed + (maxNoteSpeed - minNoteSpeed) * progressToMaxSpeed; // Only update game speed variable but don't change note speeds if (Math.abs(gameSpeed - newGameSpeed) > 0.1) { // Update game speed for new notes gameSpeed = newGameSpeed; // Visual feedback when speed increases significantly if (LK.ticks % 300 === 0) { scoreDisplay.showFeedback("Speed Up!"); // Flash effect on target zones to indicate increased speed for (var i = 0; i < targetZones.length; i++) { LK.effects.flashObject(targetZones[i], 0xFF4500, 300); } } } } // Check for game over conditions checkGameOver(); // Check if missedNotes exceeds limit for automatic game over if (missedNotes >= 10) { endGame(false); // Lose due to too many missed notes } };