/**** * Classes ****/ // Ball class for the bouncing balls - now with improved collision var Ball = Container.expand(function () { var self = Container.call(this); var ballGraphics = self.attachAsset('ball', { anchorX: 0.5, anchorY: 0.5 }); // Set up ball properties self.radius = 50; // Ball radius self.collisionShape = CollisionShape.circle(self.radius); // Set constant speed for the balls self.baseSpeed = 4 + Math.random() * 2; // Base speed between 4-6 // Set initial direction with uniform speed var angle = Math.random() * Math.PI * 2; // Random angle in radians self.speedX = Math.cos(angle) * self.baseSpeed; self.speedY = Math.sin(angle) * self.baseSpeed; // Add mass for physics calculations - slightly randomize for natural behavior self.mass = Math.random() * 0.5 + 0.75; // Mass between 0.75-1.25 // Update function to move the ball and handle bouncing with improved physics self.update = function () { // Move the ball self.x += self.speedX; self.y += self.speedY; // Instead of damping, normalize the velocity to maintain constant speed self.normalizeSpeed(); // Bounce off the walls with proper reflection var wallDamping = 0.95; // Higher value = better momentum conservation if (self.x < self.radius) { self.x = self.radius; // Prevent sticking to the edge self.speedX = Math.abs(self.speedX); self.normalizeSpeed(); } else if (self.x > 2048 - self.radius) { self.x = 2048 - self.radius; // Prevent sticking to the edge self.speedX = -Math.abs(self.speedX); self.normalizeSpeed(); } if (self.y < self.radius) { self.y = self.radius; // Prevent sticking to the edge self.speedY = Math.abs(self.speedY); self.normalizeSpeed(); } else if (self.y > 2732 - self.radius) { self.y = 2732 - self.radius; // Prevent sticking to the edge self.speedY = -Math.abs(self.speedY); self.normalizeSpeed(); } // Visually indicate the ball's speed through rotation ballGraphics.rotation += 0.05; // Constant rotation for constant speed }; // Add a method to normalize speed to keep it constant self.normalizeSpeed = function () { // Calculate current speed var currentSpeed = Math.sqrt(self.speedX * self.speedX + self.speedY * self.speedY); // Skip normalization if speed is zero to avoid division by zero if (currentSpeed < 0.1) { // Generate new random direction if ball has stopped var newAngle = Math.random() * Math.PI * 2; self.speedX = Math.cos(newAngle) * self.baseSpeed; self.speedY = Math.sin(newAngle) * self.baseSpeed; return; } // Normalize to maintain constant speed var ratio = self.baseSpeed / currentSpeed; self.speedX *= ratio; self.speedY *= ratio; }; // Improved collision detection using shape-based checks self.intersects = function (other) { var otherShape = other.collisionShape || CollisionShape.circle(other.radius || 50); return self.collisionShape.intersects(self, otherShape, other); }; // Handle elastic collision response with improved collision shapes self.collideWith = function (other) { // Skip if either object doesn't have a collision shape var otherShape = other.collisionShape || CollisionShape.circle(other.radius || 50); if (!otherShape) { return; } // Get collision info (normal and penetration) var collInfo = self.collisionShape.getCollisionInfo(self, otherShape, other); if (!collInfo || collInfo.penetration <= 0) { return; } var nx = collInfo.normal.x; var ny = collInfo.normal.y; var penetration = collInfo.penetration; // Calculate relative velocity var vx = self.speedX - (other.speedX || 0); var vy = self.speedY - (other.speedY || 0); // Calculate velocity component along the normal var velocityAlongNormal = vx * nx + vy * ny; // Don't resolve collision if objects are moving away from each other if (velocityAlongNormal > 0) { return; } // Calculate restitution (bounciness) var restitution = 0.95; // Calculate impulse scalar var otherMass = other.mass || 2.0; var impulse = -(1 + restitution) * velocityAlongNormal; impulse /= 1 / self.mass + 1 / otherMass; // Apply impulse self.speedX -= impulse * nx / self.mass; self.speedY -= impulse * ny / self.mass; // Play bounce sound if (other instanceof Enemy) { LK.getSound('bounce').play(); } // Normalize to maintain constant speed after collision self.normalizeSpeed(); // If other is a dynamic object (has speed) if (other.speedX !== undefined) { other.speedX += impulse * nx / otherMass; other.speedY += impulse * ny / otherMass; if (other.normalizeSpeed) { other.normalizeSpeed(); } } // Add position correction to avoid sinking var correctionPercent = 0.6; // Higher for better separation var correction = penetration * correctionPercent; self.x -= correction * nx * (1 / self.mass) / (1 / self.mass + 1 / otherMass); self.y -= correction * ny * (1 / self.mass) / (1 / self.mass + 1 / otherMass); if (other.speedX !== undefined) { other.x += correction * nx * (1 / otherMass) / (1 / self.mass + 1 / otherMass); other.y += correction * ny * (1 / otherMass) / (1 / self.mass + 1 / otherMass); } }; }); // Enemy class with different shapes var Enemy = Container.expand(function () { var self = Container.call(this); // Randomly choose a shape type var shapeType = Math.random() < 0.3 ? "rect" : "circle"; // Create the appropriate graphics based on shape if (shapeType === "rect") { // Create rectangle graphics var rectWidth = 100; var rectHeight = 100; var rect = self.attachAsset('ball', { anchorX: 0.5, anchorY: 0.5 }); rect.width = rectWidth; rect.height = rectHeight; rect.tint = 0xff0000; // Set collision shape as rectangle self.collisionShape = CollisionShape.rect(rectWidth, rectHeight); } else { // Use the ball asset for circle enemies var enemyGraphics = self.attachAsset('ball', { anchorX: 0.5, anchorY: 0.5 }); // Set collision shape as circle self.radius = 50; self.collisionShape = CollisionShape.circle(self.radius); } // Set initial health self.health = 10; // Add mass property - rectangles are heavier self.mass = shapeType === "rect" ? 3.0 : 2.0; // Create health display var healthTxt = new Text2("Health: " + self.health, { size: 50, fill: 0xffffff }); healthTxt.anchor.set(0.5, 0); self.addChild(healthTxt); // Update function to update health display and enemy size self.update = function () { healthTxt.setText("Health: " + self.health); // Update size based on health, minimum scale is 0.1 var newScale = Math.max(self.health / 10, 0.1); if (shapeType === "rect") { rect.scale.set(newScale); // Update collision shape dimensions with new scale self.collisionShape.width = rectWidth * newScale; self.collisionShape.height = rectHeight * newScale; } else { enemyGraphics.scale.set(newScale); // Update collision shape radius with new scale self.collisionShape.radius = self.radius * newScale; } // Adjust text position based on scale var vertOffset = shapeType === "rect" ? rectHeight / 2 * newScale : self.radius * newScale; healthTxt.y = -vertOffset - 10; // Add a subtle pulsing effect based on health var pulseAmount = Math.sin(Date.now() * 0.005) * 0.05; if (shapeType === "rect") { rect.scale.set(newScale + pulseAmount * (self.health / 10)); } else { enemyGraphics.scale.set(newScale + pulseAmount * (self.health / 10)); } }; // Handle clicks to decrease health self.down = function (x, y, obj) { self.health--; score++; // Increase score when ball is losing health // Check if enemy is destroyed if (self.health <= 0) { // Add to score for killing enemy score += 5; // Create explosion effect var explosion = new Text2("💥", { size: 150, fill: 0xffff00 }); explosion.anchor.set(0.5, 0.5); explosion.x = self.x; explosion.y = self.y; game.addChild(explosion); // Remove explosion after animation LK.setTimeout(function () { game.removeChild(explosion); }, 800); // Find a new valid position to respawn respawnEnemy(self); } }; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x000000 //Init game with black background }); /**** * Game Code ****/ // Initialize variables // Base Collision Shape class to be extended var CollisionShape = { circle: function circle(radius) { return { type: "circle", radius: radius, // Check if this shape intersects another shape intersects: function intersects(center, otherShape, otherCenter) { if (otherShape.type === "circle") { // Circle-Circle collision var dx = center.x - otherCenter.x; var dy = center.y - otherCenter.y; var distance = Math.sqrt(dx * dx + dy * dy); return distance < this.radius + otherShape.radius; } else if (otherShape.type === "rect") { // Circle-Rectangle collision return otherShape.intersects(otherCenter, this, center); } return false; }, // Calculate collision normal and penetration depth getCollisionInfo: function getCollisionInfo(center, otherShape, otherCenter) { if (otherShape.type === "circle") { // Circle-Circle collision var dx = otherCenter.x - center.x; var dy = otherCenter.y - center.y; var distance = Math.sqrt(dx * dx + dy * dy); // Avoid division by zero if (distance === 0) { return { normal: { x: 1, y: 0 }, penetration: this.radius + otherShape.radius }; } return { normal: { x: dx / distance, y: dy / distance }, penetration: this.radius + otherShape.radius - distance }; } else if (otherShape.type === "rect") { // Use the rectangle's method but invert the normal var info = otherShape.getCollisionInfo(otherCenter, this, center); info.normal.x = -info.normal.x; info.normal.y = -info.normal.y; return info; } return null; } }; }, rect: function rect(width, height) { return { type: "rect", width: width, height: height, // Check if this shape intersects another shape intersects: function intersects(center, otherShape, otherCenter) { if (otherShape.type === "circle") { // Rectangle-Circle collision // Find the closest point to the circle within the rectangle var closestX = Math.max(center.x - this.width / 2, Math.min(otherCenter.x, center.x + this.width / 2)); var closestY = Math.max(center.y - this.height / 2, Math.min(otherCenter.y, center.y + this.height / 2)); // Calculate the distance between the circle's center and this closest point var distanceX = otherCenter.x - closestX; var distanceY = otherCenter.y - closestY; // If the distance is less than the circle's radius, an intersection occurs var distanceSquared = distanceX * distanceX + distanceY * distanceY; return distanceSquared < otherShape.radius * otherShape.radius; } else if (otherShape.type === "rect") { // Rectangle-Rectangle collision (AABB) var dx = Math.abs(center.x - otherCenter.x); var dy = Math.abs(center.y - otherCenter.y); var combinedHalfWidth = (this.width + otherShape.width) / 2; var combinedHalfHeight = (this.height + otherShape.height) / 2; return dx < combinedHalfWidth && dy < combinedHalfHeight; } return false; }, // Calculate collision normal and penetration depth getCollisionInfo: function getCollisionInfo(center, otherShape, otherCenter) { if (otherShape.type === "circle") { // Rectangle-Circle collision // Find the closest point to the circle within the rectangle var closestX = Math.max(center.x - this.width / 2, Math.min(otherCenter.x, center.x + this.width / 2)); var closestY = Math.max(center.y - this.height / 2, Math.min(otherCenter.y, center.y + this.height / 2)); // Vector from closest point to circle center var dx = otherCenter.x - closestX; var dy = otherCenter.y - closestY; var distance = Math.sqrt(dx * dx + dy * dy); // Avoid division by zero if (distance === 0) { // Circle is inside the rectangle, push in the shallowest direction var xToEdge = Math.min(Math.abs(center.x + this.width / 2 - otherCenter.x), Math.abs(center.x - this.width / 2 - otherCenter.x)); var yToEdge = Math.min(Math.abs(center.y + this.height / 2 - otherCenter.y), Math.abs(center.y - this.height / 2 - otherCenter.y)); if (xToEdge < yToEdge) { return { normal: { x: otherCenter.x > center.x ? 1 : -1, y: 0 }, penetration: xToEdge + otherShape.radius }; } else { return { normal: { x: 0, y: otherCenter.y > center.y ? 1 : -1 }, penetration: yToEdge + otherShape.radius }; } } return { normal: { x: dx / distance, y: dy / distance }, penetration: otherShape.radius - distance }; } else if (otherShape.type === "rect") { // Rectangle-Rectangle collision var overlapX = (this.width + otherShape.width) / 2 - Math.abs(center.x - otherCenter.x); var overlapY = (this.height + otherShape.height) / 2 - Math.abs(center.y - otherCenter.y); if (overlapX < overlapY) { return { normal: { x: center.x < otherCenter.x ? -1 : 1, y: 0 }, penetration: overlapX }; } else { return { normal: { x: 0, y: center.y < otherCenter.y ? -1 : 1 }, penetration: overlapY }; } } return null; } }; } }; var circles = []; var balls = []; var score = 0; var lastTime = Date.now(); // Track costs and pricing var ballCost = 10; // Starting cost for balls var enemyCost = 10; // Starting cost for enemies var costIncreaseFactor = 5; // How much the cost increases per purchase // Create score display var scoreTxt = new Text2("Score: 0", { size: 100, fill: 0xffffff }); scoreTxt.anchor.set(0.5, 0); LK.gui.top.addChild(scoreTxt); // Function to update score and shop button texts function updateScore() { scoreTxt.setText("Score: " + score); shopButton.setText("Buy Ball (" + ballCost + ")"); addEnemyButton.setText("Add Enemy (" + enemyCost + ")"); } // Function to add a new enemy function addEnemy() { var newEnemy = new Enemy(); // Ensure the enemy doesn't spawn on top of existing objects var validPosition = false; var attempts = 0; var newX, newY; while (!validPosition && attempts < 100) { validPosition = true; attempts++; newX = Math.random() * (2048 - 200) + 100; newY = Math.random() * (2732 - 200) + 100; // Check if too close to any existing enemies for (var i = 0; i < circles.length; i++) { var dx = newX - circles[i].x; var dy = newY - circles[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } // Check if too close to any existing balls for (var i = 0; i < balls.length; i++) { var dx = newX - balls[i].x; var dy = newY - balls[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } } newEnemy.x = newX; newEnemy.y = newY; // Make special effects based on enemy shape if (newEnemy.collisionShape.type === "rect") { // Add a special spawn effect for rectangular enemies var spawnEffect = new Text2("⬜", { size: 120, fill: 0xffffaa }); spawnEffect.anchor.set(0.5, 0.5); spawnEffect.x = newEnemy.x; spawnEffect.y = newEnemy.y; game.addChild(spawnEffect); // Remove effect after a delay LK.setTimeout(function () { game.removeChild(spawnEffect); }, 500); } circles.push(newEnemy); game.addChild(newEnemy); } // Function to buy a new ball function buyBall() { // Check if the player has enough points if (score >= ballCost) { // Subtract the cost from the score score -= ballCost; // Create a new ball var newBall = new Ball(); // Find a valid position for the new ball var validPosition = false; var attempts = 0; var newX, newY; while (!validPosition && attempts < 100) { validPosition = true; attempts++; newX = Math.random() * (2048 - 200) + 100; newY = Math.random() * (2732 - 200) + 100; // Check if too close to any existing enemies for (var i = 0; i < circles.length; i++) { var dx = newX - circles[i].x; var dy = newY - circles[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } // Check if too close to any existing balls for (var i = 0; i < balls.length; i++) { var dx = newX - balls[i].x; var dy = newY - balls[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } } newBall.x = newX; newBall.y = newY; // Add a visual spawn effect var spawnEffect = new Text2("⭐", { size: 100, fill: 0xffff00 }); spawnEffect.anchor.set(0.5, 0.5); spawnEffect.x = newX; spawnEffect.y = newY; game.addChild(spawnEffect); // Animate and remove the spawn effect LK.setTimeout(function () { game.removeChild(spawnEffect); }, 500); game.addChild(newBall); balls.push(newBall); // Give the correct speed from the start newBall.normalizeSpeed(); // Increase the cost for the next purchase ballCost += costIncreaseFactor; // Update the score and shop displays updateScore(); } else { // If the player doesn't have enough points, display a message var notEnoughMsg = new Text2("Need " + ballCost + " points!", { size: 50, fill: 0xff0000 }); notEnoughMsg.anchor.set(0.5, 0); notEnoughMsg.x = game.width / 2; notEnoughMsg.y = game.height / 2; game.addChild(notEnoughMsg); // Remove the message after a short delay LK.setTimeout(function () { game.removeChild(notEnoughMsg); }, 1500); } } // Create a shop button var shopButton = new Text2("Buy Ball (" + ballCost + ")", { size: 80, fill: 0xffffff }); shopButton.anchor.set(1, 1); LK.gui.bottomRight.addChild(shopButton); // Add a click event to the shop button to buy a new ball shopButton.down = function (x, y, obj) { buyBall(); }; // Create an add enemy button with cost var addEnemyButton = new Text2("Add Enemy (" + enemyCost + ")", { size: 80, fill: 0xffffff }); addEnemyButton.anchor.set(0, 1); LK.gui.bottomLeft.addChild(addEnemyButton); // Add a click event to the add enemy button addEnemyButton.down = function (x, y, obj) { if (score >= enemyCost) { score -= enemyCost; addEnemy(); // Increase the cost for the next purchase enemyCost += costIncreaseFactor; updateScore(); } else { var notEnoughMsg = new Text2("Need " + enemyCost + " points!", { size: 50, fill: 0xff0000 }); notEnoughMsg.anchor.set(0.5, 0); notEnoughMsg.x = game.width / 2; notEnoughMsg.y = game.height / 2; game.addChild(notEnoughMsg); LK.setTimeout(function () { game.removeChild(notEnoughMsg); }, 1500); } }; // Add initial enemy addEnemy(); // Function to find a valid position and respawn an enemy function respawnEnemy(enemy) { // Find a valid position for respawning var validPosition = false; var attempts = 0; var newX, newY; while (!validPosition && attempts < 100) { validPosition = true; attempts++; newX = Math.random() * (2048 - 200) + 100; newY = Math.random() * (2732 - 200) + 100; // Check if too close to any existing enemies for (var i = 0; i < circles.length; i++) { // Skip the enemy we're respawning if (circles[i] === enemy) { continue; } var dx = newX - circles[i].x; var dy = newY - circles[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } // Check if too close to any existing balls for (var i = 0; i < balls.length; i++) { var dx = newX - balls[i].x; var dy = newY - balls[i].y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < 150) { validPosition = false; break; } } } // Move enemy to new position and reset health enemy.x = newX; enemy.y = newY; enemy.health = 10; // Reset health } // Update function called every tick game.update = function () { // Calculate delta time for frame-rate independent physics var currentTime = Date.now(); var deltaTime = (currentTime - lastTime) / 1000; // Convert to seconds deltaTime = Math.min(deltaTime, 0.1); // Cap delta time to avoid large jumps lastTime = currentTime; // Update all circles for (var i = 0; i < circles.length; i++) { circles[i].update(); // Check if any enemies have health <= 0 if (circles[i].health <= 0) { // Find new position to respawn this enemy respawnEnemy(circles[i]); } } // Update all balls for (var i = 0; i < balls.length; i++) { balls[i].update(); // Check for collisions with other balls - use double for-loop to avoid checking same pairs twice for (var j = i + 1; j < balls.length; j++) { if (balls[i].intersects(balls[j])) { balls[i].collideWith(balls[j]); } } // Check for collisions with enemies for (var k = 0; k < circles.length; k++) { if (balls[i].intersects(circles[k])) { // Handle collision physics with improved shape detection balls[i].collideWith(circles[k]); // Get collision vector direction for visual effects var dx = balls[i].x - circles[k].x; var dy = balls[i].y - circles[k].y; var length = Math.sqrt(dx * dx + dy * dy); // Make sure ball direction is away from the enemy after collision var dotProduct = balls[i].speedX * dx + balls[i].speedY * dy; if (dotProduct < 0) { // Ball is moving toward enemy, adjust direction balls[i].speedX = dx / length * balls[i].baseSpeed; balls[i].speedY = dy / length * balls[i].baseSpeed; balls[i].normalizeSpeed(); } // Determine damage based on collision shape var damageMultiplier = circles[k].collisionShape && circles[k].collisionShape.type === "rect" ? 0.8 : 1.0; var impactForce = balls[i].baseSpeed; var damage = Math.max(1, Math.floor(impactForce * balls[i].mass * damageMultiplier / 2)); // Apply different visual effects based on shape type var impactSymbol = circles[k].collisionShape && circles[k].collisionShape.type === "rect" ? "🔸" : "💢"; var impact = new Text2(impactSymbol, { size: 50, fill: 0xffffff }); // Reduce enemy health based on ball's speed var impactForce = balls[i].baseSpeed; // Scale damage based on impact force and ball mass var damage = Math.max(1, Math.floor(impactForce * balls[i].mass / 2)); circles[k].health -= damage; // Increase score proportional to damage score += damage; // Create impact effect var impact = new Text2("💢", { size: 50, fill: 0xffffff }); impact.anchor.set(0.5, 0.5); impact.x = balls[i].x; impact.y = balls[i].y; game.addChild(impact); // Remove impact after a short time LK.setTimeout(function (impactEffect) { return function () { game.removeChild(impactEffect); }; }(impact), 200); } } } // Add Easter egg: Press space to speed up all balls temporarily LK.on("keydown", function (e) { if (e.key === " " || e.keyCode === 32) { // Boost all balls for (var i = 0; i < balls.length; i++) { balls[i].baseSpeed *= 1.5; // Increase speed by 50% balls[i].normalizeSpeed(); // Create a boost effect var boost = new Text2("⚡", { size: 80, fill: 0xffff00 }); boost.anchor.set(0.5, 0.5); boost.x = balls[i].x; boost.y = balls[i].y; game.addChild(boost); // Remove the boost effect after a short time LK.setTimeout(function (boostEffect) { return function () { game.removeChild(boostEffect); }; }(boost), 300); // Reset the speed after 2 seconds LK.setTimeout(function (ball) { return function () { ball.baseSpeed /= 1.5; ball.normalizeSpeed(); }; }(balls[i]), 2000); } } }); // Add status display for current costs var costInfoX = 20; var costInfoY = game.height - 180; // Draw info text in top left corner showing current costs if (!game.costInfo) { game.costInfo = new Text2("", { size: 30, fill: 0xcccccc }); game.costInfo.anchor.set(0, 0); game.costInfo.x = costInfoX; game.costInfo.y = costInfoY; game.addChild(game.costInfo); } // Update the cost info display game.costInfo.setText("Ball count: " + balls.length + "\n" + "Enemy count: " + circles.length + "\n" + "Next ball cost: " + ballCost + "\n" + "Next enemy cost: " + enemyCost); // Update score display updateScore(); };