:quality(85)/https://cdn.frvr.ai/67ecc52b564cfd69d877315d.png)
:quality(85)/https://cdn.upit.com/v4f0pp18i9pfczsn4n5pst2n.jpeg)
:quality(85)/https://cdn.frvr.ai/67ecc5c7564cfd69d877315f.png)
Creation History
Code edit (1 edits merged)
Please save this source code
User prompt
Update with: self.update = function () { self.y -= self.speed; // Enemies move up the screen toward the player // Calculate scale based on y position (smaller as they approach dragon) var maxDistance = 2732; // Screen height var minScale = 0.3; // Smallest size var maxScale = 2.0; // Largest size var distancePercent = (self.y) / maxDistance; var newScale = minScale + (distancePercent * (maxScale - minScale)); // Apply scaling self.scaleX = newScale; self.scaleY = newScale; // Also adjust speed based on proximity (slower as they get closer) var baseSpeed = self.type; self.speed = baseSpeed * (0.5 + (distancePercent * 0.5)); };
Code edit (1 edits merged)
Please save this source code
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = -5; // NEGATIVE to scroll upward self.horizonY = 2732 * 0.7; // Horizon at 70% down the screen self.groundWidth = 2048; // Width at bottom self.groundWidthFar = 2048; // Make horizon line full width self.segmentHeight = 300; // Add a thinner horizon line that spans full width var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = 2048 / 2; horizon.y = self.horizonY; horizon.width = 2048; // Full width horizon.height = 10; // Make it thinner horizon.tint = 0x555555; // Darker color // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil((2732 - self.horizonY) / self.segmentHeight) + 2; self.segments = []; // Create segments by using boxes with varying widths for (var i = 0; i < self.segmentCount; i++) { var segmentContainer = new Container(); self.addChild(segmentContainer); // Position from horizon down segmentContainer.y = self.horizonY + i * self.segmentHeight; segmentContainer.x = 2048 / 2; // Center horizontally // Calculate widths based on distance from horizon var distFromHorizon = segmentContainer.y - self.horizonY; var totalDist = 2732 - self.horizonY; var perspectiveFactor = Math.min(1, distFromHorizon / totalDist); var segmentWidth = self.groundWidthFar * (0.7 + 0.3 * perspectiveFactor); // Create main segment var segment = segmentContainer.attachAsset('ground', { anchorX: 0.5, anchorY: 0 }); segment.width = segmentWidth; segment.height = self.segmentHeight; // Store for scrolling self.segments.push({ container: segmentContainer, segment: segment, origY: segmentContainer.y }); } self.update = function() { // Scroll all segments upward (negative direction) for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely above horizon, move it to the bottom if (seg.container.y < self.horizonY - self.segmentHeight) { // Find the segment that's currently lowest var lowestY = -Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y > lowestY) { lowestY = self.segments[j].container.y; } } // Place this segment below the lowest one seg.container.y = lowestY + self.segmentHeight; } // Update width based on perspective for a smoother effect var distFromHorizon = seg.container.y - self.horizonY; var totalDist = 2732 - self.horizonY; var perspectiveFactor = Math.min(1, distFromHorizon / totalDist); // Calculate width - wider at bottom, narrower at horizon var segmentWidth = 2048 * (0.7 + 0.3 * perspectiveFactor); seg.segment.width = segmentWidth; } }; return self; });
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = 5; self.horizonY = 2732 * 0.7; // Horizon at 70% down the screen self.groundWidth = 2048; // Width at bottom self.groundWidthFar = 1200; // Width at horizon self.segmentHeight = 300; // Add a horizon line var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = 2048 / 2; horizon.y = self.horizonY; horizon.width = self.groundWidthFar; // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil((2732 - self.horizonY) / self.segmentHeight) + 2; self.segments = []; // Create segments by using multiple boxes side by side for (var i = 0; i < self.segmentCount; i++) { var segmentContainer = new Container(); self.addChild(segmentContainer); // Position from horizon down segmentContainer.y = self.horizonY + i * self.segmentHeight; segmentContainer.x = 2048 / 2; // Center horizontally // Calculate widths based on distance from horizon var distFromHorizon = segmentContainer.y - self.horizonY; var totalDist = 2732 - self.horizonY; var perspectiveFactor = Math.min(1, distFromHorizon / totalDist); var topWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; var bottomWidth = topWidth + (self.scrollSpeed * 2); // Make bottom slightly wider // Create main segment var segment = segmentContainer.attachAsset('ground', { anchorX: 0.5, anchorY: 0 }); segment.width = topWidth; segment.height = self.segmentHeight; // Store for scrolling self.segments.push({ container: segmentContainer, segment: segment, topWidth: topWidth, bottomWidth: bottomWidth }); } self.update = function() { // Scroll all segments downward for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely below screen, move it to the top if (seg.container.y > 2732 + self.segmentHeight) { // Find the segment that's currently highest var highestY = Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y < highestY) { highestY = self.segments[j].container.y; } } // Place this segment above the highest one seg.container.y = highestY - self.segmentHeight; // Recalculate width based on new position var distFromHorizon = seg.container.y - self.horizonY; var totalDist = 2732 - self.horizonY; var perspectiveFactor = Math.min(1, distFromHorizon / totalDist); var newWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; seg.segment.width = newWidth; } // Update width based on perspective for a smoother effect var distFromHorizon = seg.container.y - self.horizonY; var totalDist = 2732 - self.horizonY; var perspectiveFactor = Math.min(1, distFromHorizon / totalDist); var newWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; seg.segment.width = newWidth; } }; return self; });
User prompt
Please fix the bug: 'undefined is not a constructor (evaluating 'new Graphics()')' in or related to this line: 'var trapezoid = new Graphics();' Line Number: 251
User prompt
Please fix the bug: 'undefined is not a constructor (evaluating 'new LK.Graphics()')' in or related to this line: 'var trapezoid = new LK.Graphics();' Line Number: 251
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = 5; // Now this will be positive to scroll downward self.horizonY = 2732 * 0.7; // Horizon at 70% down the screen self.groundWidth = 2048; // Width at bottom self.groundWidthFar = 1200; // Width at horizon self.segmentHeight = 300; // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil((2732 - self.horizonY) / self.segmentHeight) + 2; // +2 for overlap self.segments = []; // Create trapezoid-shaped ground segments using multiple ground pieces for (var i = 0; i < self.segmentCount; i++) { // Create a container for this segment var segmentContainer = new Container(); self.addChild(segmentContainer); segmentContainer.x = 2048 / 2; // Center horizontally // Position segment from horizon and down var yPos = self.horizonY + i * self.segmentHeight; segmentContainer.y = yPos; // Calculate top and bottom widths for this segment var distFromHorizonTop = yPos - self.horizonY; var distFromHorizonBottom = yPos + self.segmentHeight - self.horizonY; var totalDist = 2732 - self.horizonY; var topWidthFactor = Math.min(1, distFromHorizonTop / totalDist); var bottomWidthFactor = Math.min(1, distFromHorizonBottom / totalDist); var topWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * topWidthFactor; var bottomWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * bottomWidthFactor; // Instead of one rectangle, create a trapezoid using custom graphics var trapezoid = new LK.Graphics(); segmentContainer.addChild(trapezoid); // Set color and draw trapezoid trapezoid.beginFill(0x8B4513); trapezoid.moveTo(-topWidth/2, 0); trapezoid.lineTo(topWidth/2, 0); trapezoid.lineTo(bottomWidth/2, self.segmentHeight); trapezoid.lineTo(-bottomWidth/2, self.segmentHeight); trapezoid.lineTo(-topWidth/2, 0); trapezoid.endFill(); // Store in our array for scrolling self.segments.push({ container: segmentContainer, trapezoid: trapezoid, topWidth: topWidth, bottomWidth: bottomWidth }); } // Add a horizon line var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = 2048 / 2; horizon.y = self.horizonY; horizon.width = self.groundWidthFar; self.update = function() { // Scroll all segments downward (positive direction) for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely below screen, move it to the top if (seg.container.y > 2732 + self.segmentHeight) { // Find the segment that's currently highest var highestY = Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y < highestY) { highestY = self.segments[j].container.y; } } // Place this segment above the highest one seg.container.y = highestY - self.segmentHeight; // Recalculate trapezoid dimensions based on new position var yPos = seg.container.y; var distFromHorizonTop = yPos - self.horizonY; var distFromHorizonBottom = yPos + self.segmentHeight - self.horizonY; var totalDist = 2732 - self.horizonY; var topWidthFactor = Math.min(1, distFromHorizonTop / totalDist); var bottomWidthFactor = Math.min(1, distFromHorizonBottom / totalDist); var topWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * topWidthFactor; var bottomWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * bottomWidthFactor; // Update trapezoid seg.trapezoid.clear(); seg.trapezoid.beginFill(0x8B4513); seg.trapezoid.moveTo(-topWidth/2, 0); seg.trapezoid.lineTo(topWidth/2, 0); seg.trapezoid.lineTo(bottomWidth/2, self.segmentHeight); seg.trapezoid.lineTo(-bottomWidth/2, self.segmentHeight); seg.trapezoid.lineTo(-topWidth/2, 0); seg.trapezoid.endFill(); } } }; return self; });
User prompt
Reverse the direction of the ground scroll.
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = 5; self.horizonY = 2732 * 0.7; // Move horizon lower (70% down the screen) self.groundWidth = 2048; self.groundWidthFar = 1200; // Width at horizon self.segmentHeight = 300; // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil((2732 - self.horizonY) / self.segmentHeight) + 1; self.segments = []; // Create trapezoid-shaped ground segments for (var i = 0; i < self.segmentCount; i++) { // Create a container for this segment (to handle the trapezoid shape) var segmentContainer = new Container(); self.addChild(segmentContainer); // Create the actual ground piece var segment = segmentContainer.attachAsset('ground', { anchorX: 0.5, anchorY: 0 // Anchor at top }); // Position the segment segmentContainer.y = self.horizonY + i * self.segmentHeight; segmentContainer.x = 2048 / 2; // Center horizontally // Store in our array for scrolling self.segments.push({ container: segmentContainer, segment: segment, index: i }); } // Add a horizon line var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = 2048 / 2; // Center horizontally horizon.y = self.horizonY; horizon.width = self.groundWidthFar; // Update trapezoid shapes based on their position self.updateSegmentShapes = function() { for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; var distFromHorizon = seg.container.y - self.horizonY; // Calculate width based on distance from horizon // Segments closer to horizon are narrower var perspectiveFactor = Math.min(1, distFromHorizon / (2732 - self.horizonY)); var segmentWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; // Update the segment shape seg.segment.width = segmentWidth; seg.segment.x = 0; // Center within container // Make closer segments taller for better perspective seg.segment.height = self.segmentHeight * (0.7 + 0.3 * perspectiveFactor); } }; self.update = function() { // Scroll all segments downward for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely below screen, move it to the top if (seg.container.y > 2732 + self.segmentHeight) { // Find the segment that's currently highest var highestY = Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y < highestY) { highestY = self.segments[j].container.y; } } // Place this segment above the highest one seg.container.y = highestY - self.segmentHeight; } } // Update shapes each frame to maintain perspective self.updateSegmentShapes(); }; // Initialize shapes self.updateSegmentShapes(); return self; });
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = 5; self.horizonY = 2732 * 0.7; // Move horizon lower (70% down the screen) self.groundWidth = 2048; self.groundWidthFar = 1200; // Width at horizon self.segmentHeight = 300; // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil((2732 - self.horizonY) / self.segmentHeight) + 1; self.segments = []; // Create trapezoid-shaped ground segments for (var i = 0; i < self.segmentCount; i++) { // Create a container for this segment (to handle the trapezoid shape) var segmentContainer = new Container(); self.addChild(segmentContainer); // Create the actual ground piece var segment = segmentContainer.attachAsset('ground', { anchorX: 0.5, anchorY: 0 // Anchor at top }); // Position the segment segmentContainer.y = self.horizonY + i * self.segmentHeight; segmentContainer.x = 2048 / 2; // Center horizontally // Store in our array for scrolling self.segments.push({ container: segmentContainer, segment: segment, index: i }); } // Add a horizon line var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = 2048 / 2; // Center horizontally horizon.y = self.horizonY; horizon.width = self.groundWidthFar; // Update trapezoid shapes based on their position self.updateSegmentShapes = function() { for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; var distFromHorizon = seg.container.y - self.horizonY; // Calculate width based on distance from horizon // Segments closer to horizon are narrower var perspectiveFactor = Math.min(1, distFromHorizon / (2732 - self.horizonY)); var segmentWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; // Update the segment shape seg.segment.width = segmentWidth; seg.segment.x = 0; // Center within container // Make closer segments taller for better perspective seg.segment.height = self.segmentHeight * (0.7 + 0.3 * perspectiveFactor); } }; self.update = function() { // Scroll all segments downward for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely below screen, move it to the top if (seg.container.y > 2732 + self.segmentHeight) { // Find the segment that's currently highest var highestY = Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y < highestY) { highestY = self.segments[j].container.y; } } // Place this segment above the highest one seg.container.y = highestY - self.segmentHeight; } } // Update shapes each frame to maintain perspective self.updateSegmentShapes(); }; // Initialize shapes self.updateSegmentShapes(); return self; });
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Set up ground configuration self.scrollSpeed = 5; self.horizonY = 2732 * 0.5; // Horizon at middle of screen self.groundWidth = 2048; self.groundWidthFar = 1200; // Width at horizon self.segmentHeight = 300; // Calculate how many segments we need to fill screen self.segmentCount = Math.ceil(2732 / self.segmentHeight) + 1; self.segments = []; // Create trapezoid-shaped ground segments for (var i = 0; i < self.segmentCount; i++) { // Create a container for this segment (to handle the trapezoid shape) var segmentContainer = new Container(); self.addChild(segmentContainer); // Create the actual ground piece var segment = segmentContainer.attachAsset('ground', { anchorX: 0.5, anchorY: 0 // Anchor at top }); // Position the segment segmentContainer.y = self.horizonY + i * self.segmentHeight; // Store in our array for scrolling self.segments.push({ container: segmentContainer, segment: segment, index: i }); } // Add a horizon line var horizon = self.attachAsset('groundFar', { anchorX: 0.5, anchorY: 1 // Anchor at bottom }); horizon.x = self.groundWidth / 2; horizon.y = self.horizonY; horizon.width = self.groundWidthFar; // Update trapezoid shapes based on their position self.updateSegmentShapes = function() { for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; var distFromHorizon = seg.container.y - self.horizonY; // Calculate width based on distance from horizon // Segments closer to horizon are narrower var perspectiveFactor = Math.min(1, distFromHorizon / (2732 - self.horizonY)); var segmentWidth = self.groundWidthFar + (self.groundWidth - self.groundWidthFar) * perspectiveFactor; // Update the segment shape seg.segment.width = segmentWidth; seg.segment.x = segmentWidth / 2; // Center within container // Make closer segments taller for better perspective seg.segment.height = self.segmentHeight * (0.7 + 0.3 * perspectiveFactor); } }; self.update = function() { // Scroll all segments downward for (var i = 0; i < self.segments.length; i++) { var seg = self.segments[i]; seg.container.y += self.scrollSpeed; // If segment has moved completely below screen, move it to the top if (seg.container.y > 2732 + self.segmentHeight) { // Find the segment that's currently highest var highestY = Infinity; for (var j = 0; j < self.segments.length; j++) { if (j !== i && self.segments[j].container.y < highestY) { highestY = self.segments[j].container.y; } } // Place this segment above the highest one seg.container.y = highestY - self.segmentHeight; } } // Update shapes each frame to maintain perspective self.updateSegmentShapes(); }; // Initialize shapes self.updateSegmentShapes(); return self; });
User prompt
Update with: var GroundScroller = Container.expand(function () { var self = Container.call(this); // Create multiple ground segments that will scroll self.segments = []; self.segmentCount = 5; self.scrollSpeed = 3; // Create initial segments for (var i = 0; i < self.segmentCount; i++) { var segment = self.attachAsset('ground', { anchorX: 0.5, anchorY: 0 }); // Position segments in perspective var distance = i / (self.segmentCount - 1); // 0 to 1 (0 = closest, 1 = farthest) var yPos = 2732 - (600 * i); // Position them sequentially down the screen var width = 2048 * (1 - 0.7 * distance); // Gets narrower with distance segment.y = yPos; segment.width = width; segment.height = 300 * (1 - 0.4 * distance); // Gets shorter with distance segment.x = 2048 / 2; // Center horizontally // Store segment info self.segments.push({ graphic: segment, baseY: yPos, width: width, height: segment.height, distance: distance }); } self.update = function() { // Scroll all segments downward for (var i = 0; i < self.segments.length; i++) { var segment = self.segments[i]; segment.graphic.y += self.scrollSpeed * (1 - 0.5 * segment.distance); // Slower movement far away // Reset segment when it goes off screen if (segment.graphic.y > 2732 + segment.height) { // Find the segment that's farthest up var farthestIdx = 0; var farthestY = self.segments[0].graphic.y; for (var j = 1; j < self.segments.length; j++) { if (self.segments[j].graphic.y < farthestY) { farthestY = self.segments[j].graphic.y; farthestIdx = j; } } // Position this segment just above the farthest one segment.graphic.y = farthestY - segment.height; } } }; return self; });
Code edit (1 edits merged)
Please save this source code
User prompt
Update with: // In the Enemy class, modify the update function: self.update = function () { // Calculate perspective factor (0 at bottom, 1 at top) var screenHeight = 2732; var perspectiveFactor = (screenHeight - self.y) / screenHeight; // Move slower as they get "farther" away var adjustedSpeed = self.speed * (1 - 0.7 * perspectiveFactor); self.y -= adjustedSpeed; // Scale down as they move "farther" away var scale = 1 - 0.6 * perspectiveFactor; self.scaleX = scale; self.scaleY = scale; };
Code edit (1 edits merged)
Please save this source code
User prompt
Remove the dragon eyes from the dragon head class
User prompt
Add dragonHeadOpen asset to dragon head class and set alpha to 0. When players mouth is open set dragonHeadOpen alpha to 1 and dragonHead alpha to 0
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Default starting position self.x = 2048 / 2; self.y = 2732 * 0.2; // Position smoothing variables self.targetX = self.x; self.targetY = self.y; self.positionSmoothingFactor = 0.15; self.update = function () { // Position tracking with nose if (facekit.noseTip) { self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; // Apply smoothing to position self.x += (self.targetX - self.x) * self.positionSmoothingFactor; self.y += (self.targetY - self.y) * self.positionSmoothingFactor; } // Super simple direct rotation that must work if (facekit.leftEye && facekit.rightEye) { // Get direct eye angle var dx = facekit.rightEye.x - facekit.leftEye.x; var dy = facekit.rightEye.y - facekit.leftEye.y; // Direct rotation assignment - no smoothing yet self.rotation = -Math.atan2(dy, dx) * 0.3; // Scale down directly } }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Default starting position self.x = 2048 / 2; self.y = 2732 * 0.2; // Position smoothing variables self.targetX = self.x; self.targetY = self.y; self.positionSmoothingFactor = 0.1; // Lower for smoother movement // Rotation variables exactly as in your example self.targetTilt = 0; self.tiltSmoothingFactor = 0.07; // Reduced for smoother movement self.tiltScaleFactor = 0.07; // Reduced for less sensitivity // Calculate face tilt based on eye and mouth positions self.calculateFaceTilt = function() { if (facekit.leftEye && facekit.rightEye && facekit.mouthCenter) { // Calculate midpoint between eyes var eyeMidX = (facekit.leftEye.x + facekit.rightEye.x) / 2; var eyeMidY = (facekit.leftEye.y + facekit.rightEye.y) / 2; // Calculate angle between eye midpoint and mouth, negated to fix direction var dx = facekit.mouthCenter.x - eyeMidX; var dy = facekit.mouthCenter.y - eyeMidY; var angle = -(Math.atan2(dx, dy) * (180 / Math.PI)); // Reduced sensitivity and limit return Math.max(-12, Math.min(12, angle * 0.12)); } return 0; // Default to straight when face points aren't available }; self.update = function () { // Only update position if nose tracking is available, otherwise keep default position if (facekit.noseTip) { self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; } else { // Gradually return to default position when tracking is lost self.targetX = 2048 / 2; self.targetY = 2732 * 0.2; } // Apply smoothing to position - very gradual self.x += (self.targetX - self.x) * self.positionSmoothingFactor; self.y += (self.targetY - self.y) * self.positionSmoothingFactor; // Apply face tilt calculation for rotation if (facekit.leftEye && facekit.rightEye && facekit.mouthCenter) { // Calculate tilt in degrees var tiltDegrees = self.calculateFaceTilt(); self.targetTilt = tiltDegrees * self.tiltScaleFactor; // Convert degrees to radians for rotation var targetTiltRadians = self.targetTilt * (Math.PI / 180); // Apply very smooth rotation self.rotation += (targetTiltRadians - self.rotation) * self.tiltSmoothingFactor; } else { // Gradually return to level when tracking is lost self.rotation += (0 - self.rotation) * 0.05; } }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Position smoothing variables self.targetX = 2048 / 2; self.targetY = 2732 * 0.2; self.smoothingFactor = 0.15; // Simplified rotation variables self.currentRotation = 0; self.targetRotation = 0; self.rotationSmoothing = 0.1; self.update = function () { // Position tracking if (facekit.noseTip) { self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; } // Apply position smoothing self.x += (self.targetX - self.x) * self.smoothingFactor; self.y += (self.targetY - self.y) * self.smoothingFactor; // Fixed rotation calculation with reversed direction if (facekit.leftEye && facekit.rightEye) { // Calculate angle between eyes var dx = facekit.rightEye.x - facekit.leftEye.x; var dy = facekit.rightEye.y - facekit.leftEye.y; // Get the raw angle in radians and negate it to reverse the direction var rawAngle = -Math.atan2(dy, dx); // Limit the rotation to prevent extreme angles (±0.3 radians ≈ ±17 degrees) self.targetRotation = Math.max(-0.3, Math.min(0.3, rawAngle)); // Apply rotation smoothing self.rotation += (self.targetRotation - self.rotation) * self.rotationSmoothing; } }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Position smoothing variables self.targetX = 2048 / 2; self.targetY = 2732 * 0.2; self.smoothingFactor = 0.15; // Simplified rotation variables self.currentRotation = 0; self.targetRotation = 0; self.rotationSmoothing = 0.1; self.update = function () { // Position tracking if (facekit.noseTip) { self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; } // Apply position smoothing self.x += (self.targetX - self.x) * self.smoothingFactor; self.y += (self.targetY - self.y) * self.smoothingFactor; // Simplified rotation calculation directly from eye positions if (facekit.leftEye && facekit.rightEye) { // Calculate angle between eyes (simpler approach) var dx = facekit.rightEye.x - facekit.leftEye.x; var dy = facekit.rightEye.y - facekit.leftEye.y; // Get the raw angle in radians var rawAngle = Math.atan2(dy, dx); // Limit the rotation to prevent extreme angles (±0.3 radians ≈ ±17 degrees) self.targetRotation = Math.max(-0.3, Math.min(0.3, rawAngle)); // Apply rotation smoothing self.rotation += (self.targetRotation - self.rotation) * self.rotationSmoothing; // Debug output - uncomment if you have console logging // console.log("Eyes dx/dy:", dx, dy, "Target rotation:", self.targetRotation, "Current rotation:", self.rotation); } }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Position smoothing variables self.targetX = 2048 / 2; self.targetY = 2732 * 0.2; self.smoothingFactor = 0.15; // Rotation/tilt variables using the provided code approach self.targetTilt = 0; self.tiltSmoothingFactor = 0.11; self.tiltScaleFactor = 0.09; // Calculate face tilt based on eye and mouth positions self.calculateFaceTilt = function() { if (facekit.leftEye && facekit.rightEye && facekit.mouthCenter) { // Calculate midpoint between eyes var eyeMidX = (facekit.leftEye.x + facekit.rightEye.x) / 2; var eyeMidY = (facekit.leftEye.y + facekit.rightEye.y) / 2; // Calculate angle between eye midpoint and mouth, negated to fix direction var dx = facekit.mouthCenter.x - eyeMidX; var dy = facekit.mouthCenter.y - eyeMidY; var angle = -(Math.atan2(dx, dy) * (180 / Math.PI)); // Reduced max angle to ±15 degrees and lowered multiplier return Math.max(-15, Math.min(15, angle * 0.15)); } return 0; // Default to straight when face points aren't available }; self.update = function () { // Track the nose position instead of mouth if (facekit.noseTip) { // Set target positions based on nose tip self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; } // Apply smoothing to position self.x += (self.targetX - self.x) * self.smoothingFactor; self.y += (self.targetY - self.y) * self.smoothingFactor; // Apply face tilt calculation for rotation if (facekit.leftEye && facekit.rightEye) { self.targetTilt = self.calculateFaceTilt() * self.tiltScaleFactor; // Reduce max rotation to ±15 degrees self.targetTilt = Math.max(-15, Math.min(15, self.targetTilt)); // Convert degrees to radians for rotation var targetTiltRadians = self.targetTilt * (Math.PI / 180); self.rotation += (targetTiltRadians - self.rotation) * self.tiltSmoothingFactor; } }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Position smoothing variables self.targetX = 2048 / 2; // Default center position self.targetY = 2732 * 0.2; self.smoothingFactor = 0.15; // Previous positions for stable rotation calculation self.prevX = self.targetX; self.prevY = self.targetY; // Rotation variables self.targetRotation = 0; self.rotationSmoothingFactor = 0.08; self.maxRotation = Math.PI / 8; // Limit rotation to avoid flipping self.update = function () { // Track the nose position if (facekit.noseTip) { // Store previous position before updating self.prevX = self.x; self.prevY = self.y; // Set target positions based on nose tip self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; // Limit the rotation calculation to small head movements // Only calculate rotation if we've moved enough to avoid jitter var dx = self.targetX - self.prevX; var dy = self.targetY - self.prevY; var distance = Math.sqrt(dx * dx + dy * dy); if (distance > 3) { // Minimum threshold for rotation calculation // Calculate rotation based on movement direction var angle = Math.atan2(dy, dx); // Limit rotation to prevent upside-down dragon var limitedAngle = Math.max(-self.maxRotation, Math.min(self.maxRotation, angle)); self.targetRotation = limitedAngle; } } // Apply smoothing to position self.x += (self.targetX - self.x) * self.smoothingFactor; self.y += (self.targetY - self.y) * self.smoothingFactor; // Apply smoothing to rotation with limits var rotationDiff = self.targetRotation - self.rotation; // Normalize the rotation difference while (rotationDiff > Math.PI) rotationDiff -= Math.PI * 2; while (rotationDiff < -Math.PI) rotationDiff += Math.PI * 2; // Apply smoothed rotation with limiting self.rotation += rotationDiff * self.rotationSmoothingFactor; }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
User prompt
Update with: var DragonHead = Container.expand(function () { var self = Container.call(this); var head = self.attachAsset('dragonHead', { anchorX: 0.5, anchorY: 0.5, scaleX: 2, scaleY: 2 }); var leftEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: -50, y: -30 }); var rightEye = self.attachAsset('dragonEyes', { anchorX: 0.5, anchorY: 0.5, x: 50, y: -30 }); // Position smoothing variables self.targetX = 0; self.targetY = 0; self.smoothingFactor = 0.15; // Adjust for more/less smoothing // Rotation smoothing variables self.targetRotation = 0; self.rotationSmoothingFactor = 0.1; // Adjust for more/less smoothing self.update = function () { // Track the nose position instead of mouth if (facekit.noseTip) { // Set target positions based on nose tip self.targetX = facekit.noseTip.x; self.targetY = facekit.noseTip.y; // Calculate rotation if we have both eyes if (facekit.leftEye && facekit.rightEye) { var dx = facekit.rightEye.x - facekit.leftEye.x; var dy = facekit.rightEye.y - facekit.leftEye.y; self.targetRotation = Math.atan2(dy, dx); } } // Apply smoothing to position self.x += (self.targetX - self.x) * self.smoothingFactor; self.y += (self.targetY - self.y) * self.smoothingFactor; // Apply smoothing to rotation self.rotation += (self.targetRotation - self.rotation) * self.rotationSmoothingFactor; }; return self; }); ↪💡 Consider importing and using the following plugins: @upit/facekit.v1
/****
* Plugins
****/
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");
var facekit = LK.import("@upit/facekit.v1");
/****
* Classes
****/
var DragonHead = Container.expand(function () {
var self = Container.call(this);
var head = self.attachAsset('dragonHead', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2
});
var headOpen = self.attachAsset('dragonHeadOpen', {
anchorX: 0.5,
anchorY: 0.5,
scaleX: 2,
scaleY: 2,
alpha: 0
});
// Position smoothing variables
self.targetX = 2048 / 2;
self.targetY = 2732 * 0.2;
self.smoothingFactor = 0.15;
// Simplified rotation variables
self.currentRotation = 0;
self.targetRotation = 0;
self.rotationSmoothing = 0.1;
self.update = function () {
// Position tracking
if (facekit.noseTip) {
self.targetX = facekit.noseTip.x;
self.targetY = facekit.noseTip.y;
}
// Apply position smoothing
self.x += (self.targetX - self.x) * self.smoothingFactor;
self.y += (self.targetY - self.y) * self.smoothingFactor;
// Simplified rotation calculation directly from eye positions
if (facekit.leftEye && facekit.rightEye) {
// Calculate angle between eyes (simpler approach)
var dx = facekit.rightEye.x - facekit.leftEye.x;
var dy = facekit.rightEye.y - facekit.leftEye.y;
// Get the raw angle in radians and negate it to reverse the direction
var rawAngle = -Math.atan2(dy, dx);
// Limit the rotation to prevent extreme angles (±0.3 radians ≈ ±17 degrees)
self.targetRotation = Math.max(-0.3, Math.min(0.3, rawAngle));
// Apply rotation smoothing
self.rotation += (self.targetRotation - self.rotation) * self.rotationSmoothing;
// Debug output - uncomment if you have console logging
// console.log("Eyes dx/dy:", dx, dy, "Target rotation:", self.targetRotation, "Current rotation:", self.rotation);
}
// Toggle dragon head assets based on mouth open state
if (facekit && facekit.mouthOpen) {
head.alpha = 0;
headOpen.alpha = 1;
} else {
head.alpha = 1;
headOpen.alpha = 0;
}
};
return self;
});
var Enemy = Container.expand(function (type) {
var self = Container.call(this);
var assetId = 'enemy1';
if (type === 2) {
assetId = 'enemy2';
}
if (type === 3) {
assetId = 'enemy3';
}
self.type = type || 1;
var enemyGraphic = self.attachAsset(assetId, {
anchorX: 0.5,
anchorY: 0.5
});
// Different enemy types have different speeds and health
switch (self.type) {
case 1:
self.speed = 2;
self.health = 1;
break;
case 2:
self.speed = 1.5;
self.health = 2;
break;
case 3:
self.speed = 3;
self.health = 1;
break;
}
self.update = function () {
self.y -= self.speed; // Enemies move up the screen toward the player
// Calculate scale based on y position (smaller as they approach dragon)
var maxDistance = 2732; // Screen height
var minScale = 0.3; // Smallest size
var maxScale = 2.0; // Largest size
var distancePercent = self.y / maxDistance;
var newScale = minScale + distancePercent * (maxScale - minScale);
// Apply scaling
self.scaleX = newScale;
self.scaleY = newScale;
// Also adjust speed based on proximity (slower as they get closer)
var baseSpeed = self.type;
self.speed = baseSpeed * (0.5 + distancePercent * 0.5);
};
self.hit = function () {
self.health--;
// Visual feedback when hit
LK.effects.flashObject(enemyGraphic, 0xff0000, 200);
// Different death animations based on enemy type
if (self.health <= 0) {
if (self.type === 1) {
// Type 1 enemy burns to ash
tween(enemyGraphic, {
alpha: 0,
scaleX: 0.5,
scaleY: 0.5
}, {
duration: 500,
easing: tween.easeOut,
onFinish: function onFinish() {
self.toDestroy = true;
}
});
} else if (self.type === 2) {
// Type 2 enemy spins away
tween(enemyGraphic, {
rotation: Math.PI * 4,
y: self.y + 300
}, {
duration: 700,
easing: tween.easeIn,
onFinish: function onFinish() {
self.toDestroy = true;
}
});
} else if (self.type === 3) {
// Type 3 enemy explodes outward
tween(enemyGraphic, {
alpha: 0,
scaleX: 2,
scaleY: 2
}, {
duration: 300,
easing: tween.easeOut,
onFinish: function onFinish() {
self.toDestroy = true;
}
});
}
return true;
}
return false;
};
return self;
});
var FireParticle = Container.expand(function () {
var self = Container.call(this);
var particle = self.attachAsset('fireParticle', {
anchorX: 0.5,
anchorY: 0.5
});
self.vx = Math.random() * 4 - 2;
self.vy = Math.random() * 2 + 1;
self.lifespan = 20 + Math.random() * 20;
self.age = 0;
self.update = function () {
self.x += self.vx;
self.y += self.vy;
self.age++;
particle.alpha = 1 - self.age / self.lifespan;
if (self.age >= self.lifespan) {
self.destroy();
}
};
return self;
});
var Fireball = Container.expand(function () {
var self = Container.call(this);
var fireballGraphic = self.attachAsset('fireball', {
anchorX: 0.5,
anchorY: 0.5
});
self.speed = 15;
self.active = true;
self.update = function () {
if (!self.active) {
return;
}
self.y += self.speed;
// Create fire trail particles
if (Math.random() < 0.3) {
createFireParticle(self.x + (Math.random() * 40 - 20), self.y + 20);
}
};
return self;
});
var FlyingBackground = Container.expand(function () {
var self = Container.call(this);
// Create sky background (top half)
var sky = self.attachAsset('skyBackground', {
anchorX: 0.5,
anchorY: 1.0,
// Anchor to bottom
x: 2048 / 2,
y: 2732 / 2 // Place at middle of screen
});
// Create field background (bottom half)
var field = self.attachAsset('fieldBackground', {
anchorX: 0.5,
anchorY: 0,
// Anchor to top
x: 2048 / 2,
y: 2732 / 2 // Place at middle of screen
});
// Create horizon line (implied by the two backgrounds meeting)
// Center point where the dragon is
self.centerX = 2048 / 2;
self.centerY = 2732 * 0.2; // Same as dragon y-position
// Create clouds
self.clouds = [];
for (var i = 0; i < 6; i++) {
var cloud = self.attachAsset('cloudShape', {
anchorX: 0.5,
anchorY: 0.5,
x: Math.random() * 2048,
y: Math.random() * (2732 / 2 - 100),
// In sky only
alpha: 0.8,
scaleX: 0.8 + Math.random() * 0.5,
scaleY: 0.7 + Math.random() * 0.3
});
// Randomize cloud properties
self.clouds.push({
sprite: cloud,
speedX: 0.5 + Math.random(),
speedY: 1 + Math.random() * 2
});
}
// Create field elements (trees, bushes, etc)
self.fieldElements = [];
for (var j = 0; j < 10; j++) {
var fieldElement = self.attachAsset('fieldElement', {
anchorX: 0.5,
anchorY: 0.5,
x: Math.random() * 2048,
y: 2732 / 2 + 100 + Math.random() * (2732 / 2 - 200),
// In field only, not too close to horizon
scaleX: 0.5 + Math.random() * 1.5,
scaleY: 0.5 + Math.random() * 1.5
});
// Store with speed properties
self.fieldElements.push({
sprite: fieldElement,
speedX: 1 + Math.random() * 2,
speedY: 3 + Math.random() * 4
});
}
self.update = function () {
// Update clouds (slow movement)
for (var i = 0; i < self.clouds.length; i++) {
var cloud = self.clouds[i];
// Move cloud toward player (down and slightly sideways)
cloud.sprite.y += cloud.speedY;
cloud.sprite.x += cloud.sprite.x > self.centerX ? -cloud.speedX : cloud.speedX;
// Scale cloud as it approaches (subtle effect)
cloud.sprite.scaleX += 0.002;
cloud.sprite.scaleY += 0.002;
// Reset cloud if it moves off screen
if (cloud.sprite.y > 2732 / 2 || cloud.sprite.scaleX > 2) {
cloud.sprite.x = Math.random() * 2048;
cloud.sprite.y = -100;
cloud.sprite.scaleX = 0.8 + Math.random() * 0.5;
cloud.sprite.scaleY = 0.7 + Math.random() * 0.3;
}
}
// Update field elements (faster movement)
for (var j = 0; j < self.fieldElements.length; j++) {
var element = self.fieldElements[j];
// Move field element toward player (up and expanding outward)
element.sprite.y -= element.speedY;
element.sprite.x += element.sprite.x > self.centerX ? element.speedX : -element.speedX;
// Scale element as it approaches
element.sprite.scaleX += 0.01;
element.sprite.scaleY += 0.01;
// Reset element if it moves off screen
if (element.sprite.y < 2732 / 2 || element.sprite.scaleX > 3 || element.sprite.x < -100 || element.sprite.x > 2048 + 100) {
element.sprite.x = Math.random() * 2048;
element.sprite.y = 2732 + 100;
element.sprite.scaleX = 0.5 + Math.random() * 0.5;
element.sprite.scaleY = 0.5 + Math.random() * 0.5;
}
}
};
return self;
});
var PowerBar = Container.expand(function () {
var self = Container.call(this);
// Background bar
var background = self.attachAsset('powerBarBg', {
anchorX: 0.5,
anchorY: 0.5
});
// Foreground bar (showing power level)
var bar = self.attachAsset('powerBar', {
anchorX: 0,
anchorY: 0.5,
x: -250
});
self.maxWidth = 500;
self.setPower = function (percent) {
var newWidth = self.maxWidth * percent;
bar.width = Math.max(0, Math.min(newWidth, self.maxWidth));
// Change color based on power level
if (percent < 0.3) {
bar.tint = 0xe74c3c; // Red when low
} else if (percent < 0.6) {
bar.tint = 0xf39c12; // Orange when medium
} else {
bar.tint = 0x2ecc71; // Green when high
}
};
return self;
});
/****
* Initialize Game
****/
var game = new LK.Game({
backgroundColor: 0x000000
});
/****
* Game Code
****/
// Set dark blue background for sky effect
game.setBackgroundColor(0x2c3e50);
// Game state variables
var score = 0;
var firepower = 100;
var maxFirepower = 100;
var firepowerRechargeRate = 0.5;
var firepowerUseRate = 2;
var gameActive = true;
var fireballs = [];
var enemies = [];
var fireParticles = [];
var isFiring = false;
var lastFireTime = 0;
var fireRate = 150; // ms between fireballs
var enemySpawnRate = 60; // Frames between enemy spawns
var difficultyScaling = 0;
var flyingBackground = new FlyingBackground();
game.addChild(flyingBackground);
// Create dragon head (player character)
var dragon = game.addChild(new DragonHead());
dragon.x = 2048 / 2;
dragon.y = 2732 * 0.2; // Place dragon at top fifth of screen
// Create power bar
var powerBar = new PowerBar();
powerBar.x = 2048 / 2;
powerBar.y = 150;
LK.gui.top.addChild(powerBar);
// Score display
var scoreTxt = new Text2('0', {
size: 80,
fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
scoreTxt.y = 50;
LK.gui.top.addChild(scoreTxt);
// Create a function to add fire particles
function createFireParticle(x, y) {
var particle = new FireParticle();
particle.x = x;
particle.y = y;
game.addChild(particle);
fireParticles.push(particle);
}
// Function to spawn a fireball
function spawnFireball() {
if (!gameActive || firepower < 10) {
return;
}
var now = Date.now();
if (now - lastFireTime < fireRate) {
return;
}
lastFireTime = now;
// Create new fireball
var fireball = new Fireball();
fireball.x = dragon.x;
fireball.y = dragon.y + 50; // Spawn below dragon's mouth
game.addChild(fireball);
fireballs.push(fireball);
// Use firepower
firepower -= firepowerUseRate;
powerBar.setPower(firepower / maxFirepower);
// Play sound
LK.getSound('firebreathSound').play();
}
// Function to spawn enemies
function spawnEnemy() {
if (!gameActive) {
return;
}
// Create enemy of random type
var type = Math.floor(Math.random() * 3) + 1;
var enemy = new Enemy(type);
// Position randomly along bottom of screen
enemy.x = Math.random() * (2048 - 200) + 100;
enemy.y = 2732 + 100; // Start below screen
game.addChild(enemy);
enemies.push(enemy);
}
// Game update logic
game.update = function () {
if (!gameActive) {
return;
}
// Check if mouth is open for fire breathing
if (facekit && facekit.mouthOpen) {
isFiring = true;
spawnFireball();
} else {
isFiring = false;
}
// Recharge firepower when not firing
if (!isFiring && firepower < maxFirepower) {
firepower += firepowerRechargeRate;
powerBar.setPower(firepower / maxFirepower);
}
// Warn player when power is low
if (firepower < 20 && Math.floor(LK.ticks) % 60 === 0) {
LK.getSound('powerLow').play();
}
// Spawn enemies
if (LK.ticks % Math.max(10, enemySpawnRate - difficultyScaling) === 0) {
spawnEnemy();
}
// Increase difficulty over time
if (LK.ticks % 300 === 0 && difficultyScaling < 40) {
difficultyScaling += 1;
}
// Update fireballs and check for collisions
for (var i = fireballs.length - 1; i >= 0; i--) {
var fireball = fireballs[i];
// Remove fireballs that go off screen
if (fireball.y < -100) {
fireball.destroy();
fireballs.splice(i, 1);
continue;
}
// Check for collisions with enemies
for (var j = enemies.length - 1; j >= 0; j--) {
var enemy = enemies[j];
if (fireball.active && fireball.intersects(enemy)) {
// Hit the enemy
var killed = enemy.hit();
if (killed) {
score += enemy.type * 10;
scoreTxt.setText(score);
LK.setScore(score);
LK.getSound('enemyDefeat').play();
}
// Deactivate the fireball
fireball.active = false;
// Destroy it after a slight delay (for visual effect)
LK.setTimeout(function () {
if (fireballs.indexOf(fireball) !== -1) {
fireball.destroy();
fireballs.splice(fireballs.indexOf(fireball), 1);
}
}, 100);
break;
}
}
}
// Update enemies
for (var k = enemies.length - 1; k >= 0; k--) {
var currentEnemy = enemies[k];
// Remove enemies marked for destruction
if (currentEnemy.toDestroy) {
currentEnemy.destroy();
enemies.splice(k, 1);
continue;
}
// Check if enemy reaches player
if (currentEnemy.y < 300) {
// Game over
gameActive = false;
LK.getSound('gameOverSound').play();
LK.showGameOver();
}
}
// Update fire particles
for (var m = fireParticles.length - 1; m >= 0; m--) {
if (!fireParticles[m].parent) {
fireParticles.splice(m, 1);
}
}
};
// Start background music
LK.playMusic('gameMusic', {
fade: {
start: 0,
end: 0.3,
duration: 1000
}
}); ===================================================================
--- original.js
+++ change.js
@@ -355,8 +355,10 @@
var lastFireTime = 0;
var fireRate = 150; // ms between fireballs
var enemySpawnRate = 60; // Frames between enemy spawns
var difficultyScaling = 0;
+var flyingBackground = new FlyingBackground();
+game.addChild(flyingBackground);
// Create dragon head (player character)
var dragon = game.addChild(new DragonHead());
dragon.x = 2048 / 2;
dragon.y = 2732 * 0.2; // Place dragon at top fifth of screen
Images
:quality(85)/https://cdn.frvr.ai/67db42c016a72d6be958a257.png%3F3)
A clear blue sky background with no clouds.. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67dc8b60cb1aadfe5b876136.png%3F3)
:quality(85)/https://cdn.frvr.ai/67dd8a8418c018e03ce22fec.png%3F3)
:quality(85)/https://cdn.frvr.ai/67ddbcfb80c994e12f823a02.png%3F3)
:quality(85)/https://cdn.frvr.ai/67ddc12180c994e12f823a87.png%3F3)
:quality(85)/https://cdn.frvr.ai/67ddecbd9d8cc9d5bc23c73e.png%3F3)
:quality(85)/https://cdn.frvr.ai/67ddecf59d8cc9d5bc23c742.png%3F3)
:quality(85)/https://cdn.frvr.ai/67ddfca69d8cc9d5bc23c760.png%3F3)
a small bush. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e17a1350386d955cdb9c9d.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e2d0b8eb88f01d7a14285c.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e373e4f4509c053e8b39fe.png%3F3)
a wooden arrow with red feathers and a metal arrow head. Completely vertical orientation. Cartoon. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e37dfaa9b5a34b9f51774b.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e4383f0de700590fa36cea.png%3F3)
A small vertical flame. Cartoon. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e43daf010d770a13abb813.png%3F3)
a black scorch mark on the ground left by a meteor impact. cartoon. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e44215258796807174b22d.png%3F3)
A bright spark. Cartoon. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e44782258796807174b23e.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e4d3ca000ead8a904dd63b.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c15639298bd9fa52d8dd.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c19a39298bd9fa52d8ef.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c1dc39298bd9fa52d8fe.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c20c39298bd9fa52d902.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c2d039298bd9fa52d92a.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c33c39298bd9fa52d93c.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c56839298bd9fa52d952.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e5c75139298bd9fa52d95d.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e810e10bf83f5289aafb3c.png%3F3)
a red heart. cartoon. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67e8168b0bf83f5289aafbd8.png%3F3)
:quality(85)/https://cdn.frvr.ai/67e818200bf83f5289aafc32.png%3F3)
An SVG of the word **BOSS** in sharp red font.. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67eaedc8b6f22e1325c60b9a.png%3F3)
:quality(85)/https://cdn.frvr.ai/67eaeeaeb6f22e1325c60bd9.png%3F3)
An SVG of the word “Start” written in fire. Cartoon.. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows
:quality(85)/https://cdn.frvr.ai/67ecac4be043b22751c9e9b0.png%3F3)
