/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); /**** * Classes ****/ var ColoredBall = Container.expand(function (assetId) { var self = Container.call(this); var ballGraphics = self.attachAsset(assetId, { anchorX: 0.5, anchorY: 0.5 }); self.speedX = 0; self.speedY = 0; self.friction = 0.99; // Friction to slow down the ball self.update = function () { self.x += self.speedX; self.y += self.speedY; // Apply friction self.speedX *= self.friction; self.speedY *= self.friction; // Stop the ball if speed is very low if (Math.abs(self.speedX) < 0.1 && Math.abs(self.speedY) < 0.1) { self.speedX = 0; self.speedY = 0; } }; return self; }); var Cue = Container.expand(function () { var self = Container.call(this); // You'll need to define a shape or image asset for the cue stick // Assuming you have a 'cueStickAsset' defined in Assets var cueGraphics = self.attachAsset('cueStickAsset', { anchorX: 0.5, anchorY: 1.0 // Anchor at the bottom edge (handle on opposite side) }); self.update = function () { // The cue will likely be positioned and rotated based on the drag input // in the game.move and game.up handlers. }; return self; }); //Storage library which should be used for persistent game data //var storage = LK.import('@upit/storage.v1'); //Library for using the camera (the background becomes the user's camera video feed) and the microphone. It can access face coordinates for interactive play, as well detect microphone volume / voice interactions //var facekit = LK.import('@upit/facekit.v1'); //Classes can only be defined here. You cannot create inline classes in the games code. var CueBall = Container.expand(function () { var self = Container.call(this); var ballGraphics = self.attachAsset('cueBall', { anchorX: 0.5, anchorY: 0.5 }); self.speedX = 0; self.speedY = 0; self.friction = 0.99; // Friction to slow down the ball self.update = function () { self.x += self.speedX; self.y += self.speedY; // Apply friction self.speedX *= self.friction; self.speedY *= self.friction; // Stop the ball if speed is very low if (Math.abs(self.speedX) < 0.1 && Math.abs(self.speedY) < 0.1) { self.speedX = 0; self.speedY = 0; } }; return self; }); var Pocket = Container.expand(function () { var self = Container.call(this); self.attachAsset('pocket', { anchorX: 0.5, anchorY: 0.5 }); return self; }); var TableEdge = Container.expand(function (width, height) { var self = Container.call(this); self.attachAsset('tableEdge', { width: width, height: height, anchorX: 0.5, anchorY: 0.5 }); return self; }); /**** * Initialize Game ****/ var game = new LK.Game({ backgroundColor: 0x228B22 // Init game with forest green background }); /**** * Game Code ****/ // Assuming striped balls are the same size as solid balls //Minimalistic tween library which should be used for animations over time, including tinting / colouring an object, scaling, rotating, or changing any game object property. //Only include the plugins you need to create the game. // Create the shooting line visualization // Note: We can't draw lines directly. We'll simulate with a long thin box asset if needed. // For now, we'll just handle the logic and power calculation. // Create and position the cue // cue = new Cue(); // This is created in game.down // game.addChild(cue); // This is added in game.down // cue.x = cueBall.x; // This is set in game.down and game.move // cue.y = cueBall.y; // This is set in game.down and game.move // If you have a line drawing asset: /* Supported Types: 1. Shape: 2. Image: 3. Sound: 4. Music: */ //Note game dimensions are 2048x2732 var background = LK.getAsset('background2', { anchorX: 0, anchorY: 0, width: 2048, height: 2732, x: 0, y: 0 }); game.addChild(background); // Game elements var cueBall = null; // Initialize cueBall here var coloredBalls = []; var pockets = []; var tableEdges = []; // Game state // var draggingCueBall = false; // This logic is replaced by draggingCue // var dragStartX = 0; // No longer used for this cue mechanic // var dragStartY = 0; // No longer used for this cue mechanic var shotPower = 0; // Represents the power of the shot, calculated on release var maxShotPower = 200; // Adjust as needed for desired power var shootingLine = null; // Placeholder for the shooting line, currently unused // Note: The following declarations are duplicates from lines {1i} to {1s} // var cueBall = null; // var coloredBalls = []; // var pockets = []; // var tableEdges = []; // Game state // var draggingCueBall = false; // var dragStartX = 0; // var dragStartY = 0; // var shotPower = 0; // var maxShotPower = 200; // var shootingLine = null; var cue = null; // Initialize cue variable var shotTaken = false; // Track if a shot has been taken this turn // var cueVerticalOffset = 200; // No longer used var CUE_TIP_TO_BALL_SURFACE_OFFSET = 5; // Make cue stick very close to the cue ball var draggingCue = false; // True if player is dragging the cue stick // Create pockets // Create pockets // Create pockets function createPockets() { var pocketSize = 200; var edgeOffset = 50; // Adjust to align with the new edge positions // Top pockets var topLeftPocket = new Pocket(); topLeftPocket.x = edgeOffset; topLeftPocket.y = edgeOffset; game.addChild(topLeftPocket); pockets.push(topLeftPocket); var topMiddlePocket = new Pocket(); topMiddlePocket.x = 2048 / 2; topMiddlePocket.y = edgeOffset; game.addChild(topMiddlePocket); pockets.push(topMiddlePocket); var topRightPocket = new Pocket(); topRightPocket.x = 2048 - edgeOffset; topRightPocket.y = edgeOffset; game.addChild(topRightPocket); pockets.push(topRightPocket); // Bottom pockets var bottomLeftPocket = new Pocket(); bottomLeftPocket.x = edgeOffset; bottomLeftPocket.y = 2732 - edgeOffset; game.addChild(bottomLeftPocket); pockets.push(bottomLeftPocket); var bottomMiddlePocket = new Pocket(); bottomMiddlePocket.x = 2048 / 2; bottomMiddlePocket.y = 2732 - edgeOffset; game.addChild(bottomMiddlePocket); pockets.push(bottomMiddlePocket); var bottomRightPocket = new Pocket(); bottomRightPocket.x = 2048 - edgeOffset; bottomRightPocket.y = 2732 - edgeOffset; game.addChild(bottomRightPocket); pockets.push(bottomRightPocket); } // Create table edges function createTableEdges() { var edgeThickness = 20; var pocketOffset = 100; // Should align with pocket edge // Top edges var topLeftEdge = new TableEdge(2048 / 2 - pocketOffset, edgeThickness); topLeftEdge.x = pocketOffset + (2048 / 2 - pocketOffset) / 2; topLeftEdge.y = edgeThickness / 2; // Position at the top edge game.addChild(topLeftEdge); tableEdges.push(topLeftEdge); var topRightEdge = new TableEdge(2048 / 2 - pocketOffset, edgeThickness); topRightEdge.x = 2048 - pocketOffset - (2048 / 2 - pocketOffset) / 2; topRightEdge.y = edgeThickness / 2; // Position at the top edge game.addChild(topRightEdge); tableEdges.push(topRightEdge); // Bottom edges var bottomLeftEdge = new TableEdge(2048 / 2 - pocketOffset, edgeThickness); bottomLeftEdge.x = pocketOffset + (2048 / 2 - pocketOffset) / 2; bottomLeftEdge.y = 2732 - edgeThickness / 2; // Position at the bottom edge game.addChild(bottomLeftEdge); tableEdges.push(bottomLeftEdge); var bottomRightEdge = new TableEdge(2048 / 2 - pocketOffset, edgeThickness); bottomRightEdge.x = 2048 - pocketOffset - (2048 / 2 - pocketOffset) / 2; bottomRightEdge.y = 2732 - edgeThickness / 2; // Position at the bottom edge game.addChild(bottomRightEdge); tableEdges.push(bottomRightEdge); // Left edges var leftTopEdge = new TableEdge(edgeThickness, 2732 / 2 - pocketOffset); leftTopEdge.x = edgeThickness / 2; // Position at the left edge leftTopEdge.y = pocketOffset + (2732 / 2 - pocketOffset) / 2; // Position aligned with pockets game.addChild(leftTopEdge); tableEdges.push(leftTopEdge); var leftBottomEdge = new TableEdge(edgeThickness, 2732 / 2 - pocketOffset); leftBottomEdge.x = edgeThickness / 2; // Position at the left edge leftBottomEdge.y = 2732 - pocketOffset - (2732 / 2 - pocketOffset) / 2; // Position aligned with pockets game.addChild(leftBottomEdge); tableEdges.push(leftBottomEdge); var rightTopEdge = new TableEdge(edgeThickness, 2732 / 2 - pocketOffset); rightTopEdge.x = 2048 - edgeThickness / 2; // Position at the right edge rightTopEdge.y = pocketOffset + (2732 / 2 - pocketOffset) / 2; // Position aligned with pockets game.addChild(rightTopEdge); tableEdges.push(rightTopEdge); var rightBottomEdge = new TableEdge(edgeThickness, 2732 / 2 - pocketOffset); rightBottomEdge.x = 2048 - edgeThickness / 2; // Position at the right edge rightBottomEdge.y = 2732 - pocketOffset - (2732 / 2 - pocketOffset) / 2; // Position aligned with pockets game.addChild(rightBottomEdge); tableEdges.push(rightBottomEdge); } // Create balls function createBalls() { cueBall = new CueBall(); cueBall.x = 2048 / 2; cueBall.y = 2732 * 0.75; // Position cue ball at the bottom game.addChild(cueBall); // Create the cue stick cue = new Cue(); game.addChild(cue); //{1K} // Cue is added once // Initial position and orientation for the cue // Position cue handle "behind" (larger Y coordinate) the cueBall if (cueBall && cue) { var handle_distance_from_ball_center = cue.height + cueBall.width / 2 + CUE_TIP_TO_BALL_SURFACE_OFFSET; // Use reduced offset for closer cue cue.x = cueBall.x; cue.y = cueBall.y + handle_distance_from_ball_center; var initialAngle = Math.atan2(cueBall.y - cue.y, cueBall.x - cue.x); // Assuming cue asset's tip is along its positive local Y-axis (anchorY=0.0 means handle is at top of image) cue.rotation = initialAngle - Math.PI / 2; } cue.visible = true; // Ensure cue is visible at the start // Create some colored balls in a triangle formation var startX = 2048 / 2; var startY = 2732 * 0.25; // Position colored balls at the top var ballSpacing = cueBall.width * 1.2; // Spacing between balls var numRows = 5; // Define the order of balls for the rack (standard 8-ball setup) var ballOrder = ['solidYellow', // Row 1 'solidBlue', 'solidRed', // Row 2 'stripedOrange', 'stripedGreen', 'solidBrown', // Row 3 'stripedBlue', 'stripedRed', 'solidBlack', 'solidPurple', // Row 4 (solid black ball in the middle) 'solidGreen', 'stripedYellow', 'stripedBrown', 'stripedPurple', 'solidOrange' // Row 5 ]; // stripedBlack has been removed from the ballOrder array var ballIndex = 0; for (var row = 0; row < numRows; row++) { for (var col = 0; col <= row; col++) { var assetId = ballOrder[ballIndex]; var ball = new ColoredBall(assetId); // Calculate x and y positions for the flipped triangle ball.x = startX + col * ballSpacing - row * ballSpacing / 2; ball.y = startY + (numRows - 1 - row) * ballSpacing; // Flip the row calculation game.addChild(ball); coloredBalls.push(ball); ball.lastIntersectingBall = false; // Initialize collision tracking ballIndex++; } } } createPockets(); createTableEdges(); createBalls(); // Handle ball collisions with table edges function handleEdgeCollisions(ball) { // Store last position for transition detection if (ball.lastX === undefined) { ball.lastX = ball.x; } if (ball.lastY === undefined) { ball.lastY = ball.y; } var ballRadius = ball.width / 2; var hitEdge = false; // Define table boundaries with a small margin to ensure balls never escape var leftBound = ballRadius; var rightBound = 2048 - ballRadius; var topBound = ballRadius; var bottomBound = 2732 - ballRadius; // Check collision with table edges and enforce boundaries // Check collision with vertical edges (left and right table bounds) if (ball.x <= leftBound) { ball.x = leftBound; // Force ball to stay within boundary ball.speedX = Math.abs(ball.speedX); // Force positive X velocity (rightward) hitEdge = true; } else if (ball.x >= rightBound) { ball.x = rightBound; // Force ball to stay within boundary ball.speedX = -Math.abs(ball.speedX); // Force negative X velocity (leftward) hitEdge = true; } // Check collision with horizontal edges (top and bottom table bounds) if (ball.y <= topBound) { ball.y = topBound; // Force ball to stay within boundary ball.speedY = Math.abs(ball.speedY); // Force positive Y velocity (downward) hitEdge = true; } else if (ball.y >= bottomBound) { ball.y = bottomBound; // Force ball to stay within boundary ball.speedY = -Math.abs(ball.speedY); // Force negative Y velocity (upward) hitEdge = true; } // Play collision sound if we hit an edge if (hitEdge) { LK.getSound('collision').play(); } // Double-check clamping to absolutely ensure ball stays within table boundaries ball.x = Math.max(leftBound, Math.min(rightBound, ball.x)); ball.y = Math.max(topBound, Math.min(bottomBound, ball.y)); // Update last position with the now clamped values ball.lastX = ball.x; ball.lastY = ball.y; } // Handle collisions between balls function handleBallCollisions() { var allBalls = [cueBall].concat(coloredBalls); // Initialize collidedThisTick flags and ensure lastIntersectingBall is defined for (var k = 0; k < allBalls.length; k++) { if (allBalls[k].lastIntersectingBall === undefined) { allBalls[k].lastIntersectingBall = false; } allBalls[k].collidedThisTick = false; } for (var i = 0; i < allBalls.length; i++) { var ball1 = allBalls[i]; for (var j = i + 1; j < allBalls.length; j++) { var ball2 = allBalls[j]; var dx = ball2.x - ball1.x; var dy = ball2.y - ball1.y; var distance = Math.sqrt(dx * dx + dy * dy); var minDistance = ball1.width / 2 + ball2.width / 2; // Check for overlap based on distance between centers and sum of radii var currentPairwiseIntersecting = distance < minDistance; if (currentPairwiseIntersecting) { ball1.collidedThisTick = true; ball2.collidedThisTick = true; // Process collision physics if balls are intersecting. // This allows for continuous interaction and ensures collisions register // even if balls were previously touching. // Simple collision response (based on elastic collision) var angle = Math.atan2(dy, dx); var sin = Math.sin(angle); var cos = Math.cos(angle); // Rotate ball1 velocity var vel1X = ball1.speedX * cos + ball1.speedY * sin; var vel1Y = ball1.speedY * cos - ball1.speedX * sin; // Rotate ball2 velocity var vel2X = ball2.speedX * cos + ball2.speedY * sin; var vel2Y = ball2.speedY * cos - ball2.speedX * sin; // Perform 1D collision (balls exchange velocities along the collision axis) var finalVel1X = vel2X; var finalVel2X = vel1X; // Rotate velocities back ball1.speedX = finalVel1X * cos - vel1Y * sin; ball1.speedY = vel1Y * cos + finalVel1X * sin; ball2.speedX = finalVel2X * cos - vel2Y * sin; ball2.speedY = vel2Y * cos + finalVel2X * sin; // Move balls apart to prevent sticking if they are overlapping var overlap = minDistance - distance; if (overlap > 0) { // Ensure distance is not zero to prevent division by zero var separationAmount = overlap / (distance > 0 ? distance : 1); var sepX = dx * separationAmount; var sepY = dy * separationAmount; // Move ball1 away from ball2 by half the overlap ball1.x -= sepX / 2; ball1.y -= sepY / 2; // Move ball2 away from ball1 by half the overlap ball2.x += sepX / 2; ball2.y += sepY / 2; // Make sure balls don't end up outside the table after separation var ballRadius = ball1.width / 2; ball1.x = Math.max(ballRadius, Math.min(2048 - ballRadius, ball1.x)); ball1.y = Math.max(ballRadius, Math.min(2732 - ballRadius, ball1.y)); ballRadius = ball2.width / 2; ball2.x = Math.max(ballRadius, Math.min(2048 - ballRadius, ball2.x)); ball2.y = Math.max(ballRadius, Math.min(2732 - ballRadius, ball2.y)); } LK.getSound('collision').play(); } } } // After all pairs are checked, update lastIntersectingBall for the next game tick for (var k = 0; k < allBalls.length; k++) { allBalls[k].lastIntersectingBall = allBalls[k].collidedThisTick; } } // Handle ball potting function handlePotting() { var allBalls = [cueBall].concat(coloredBalls); for (var i = allBalls.length - 1; i >= 0; i--) { var ball = allBalls[i]; for (var j = 0; j < pockets.length; j++) { var pocket = pockets[j]; var currentIntersecting = ball.intersects(pocket); if (!ball.lastIntersectingPocket && currentIntersecting) { // Ball is potted if (ball === cueBall) { // Cue ball potted - handle as a foul or reset console.log("Cue ball potted!"); // For a simple game, let's just reset the cue ball cueBall.x = 2048 / 2; cueBall.y = 2732 * 0.75; cueBall.speedX = 0; cueBall.speedY = 0; LK.getSound('pot').play(); } else { // Colored ball potted console.log("Colored ball potted!"); ball.destroy(); coloredBalls.splice(i, 1); LK.getSound('pot').play(); // Check for win condition if (coloredBalls.length === 0) { LK.showYouWin(); } } break; // Ball can only be potted in one pocket at a time } ball.lastIntersectingPocket = currentIntersecting; // Update last state } } } // Mouse or touch down on game object game.down = function (x, y, obj) { // Only allow cue interaction if a shot is not currently in progress and cue/cueBall exist if (!shotTaken && cue && cueBall) { draggingCue = true; // Snap cue's handle (anchor 0.5, 0.0) to the mouse cursor position // Calculate the angle from the drag point to the cue ball center var angleToWhiteBall = Math.atan2(cueBall.y - y, cueBall.x - x); // Place the cue handle at the closest possible distance from the cue ball center, along the drag direction var handle_distance_from_ball_center = cue.height + cueBall.width / 2 + CUE_TIP_TO_BALL_SURFACE_OFFSET; cue.x = cueBall.x - handle_distance_from_ball_center * Math.cos(angleToWhiteBall); cue.y = cueBall.y - handle_distance_from_ball_center * Math.sin(angleToWhiteBall); // Aim cue's tip towards the white ball cue.rotation = angleToWhiteBall - Math.PI / 2; // Assumes cue asset's positive Y is "down" its length cue.visible = true; // Ensure cue is visible when interaction starts } }; // Mouse or touch move on game object game.move = function (x, y, obj) { if (draggingCue && cue && cueBall) { // Calculate the angle from the cursor to the cue ball center var angleToWhiteBall = Math.atan2(cueBall.y - y, cueBall.x - x); // Place the cue handle at the cursor position, but keep the cue tip always pointing at the cue ball cue.x = x; cue.y = y; cue.rotation = angleToWhiteBall - Math.PI / 2; } }; // Mouse or touch up on game object game.up = function (x, y, obj) { if (draggingCue && cue && cueBall) { // Ensure cue and cueBall exist draggingCue = false; // Calculate vector from cue handle (current mouse position) to cueBall center var dx_shot = cueBall.x - cue.x; var dy_shot = cueBall.y - cue.y; var dist_cue_handle_to_ball_center = Math.sqrt(dx_shot * dx_shot + dy_shot * dy_shot); // Power is based on how far the cue handle is pulled back from the white ball, // beyond the cue's own length (where cue tip would be at ball's center). var minimumShotPower = 50; var powerFactor = Math.max(0, dist_cue_handle_to_ball_center - cue.height); shotPower = Math.max(minimumShotPower, Math.min(powerFactor * 0.2, maxShotPower)); // Sensitivity 0.2, adjust as needed if (shotPower > 0) { var shootAngle = Math.atan2(dy_shot, dx_shot); // Angle from cue handle to white ball // Calculate target position for cue handle for the tween animation. // The cue's tip should visually end up CUE_TIP_TO_BALL_SURFACE_OFFSET from the cueBall's surface. // The handle is cue.height from the tip. The ball's radius is cueBall.width / 2. var distanceFromBallCenterToHandleTarget = cue.height + cueBall.width / 2 + CUE_TIP_TO_BALL_SURFACE_OFFSET; var targetHandleX = cueBall.x - distanceFromBallCenterToHandleTarget * Math.cos(shootAngle); var targetHandleY = cueBall.y - distanceFromBallCenterToHandleTarget * Math.sin(shootAngle); // Animate the cue hitting the ball tween(cue, { x: targetHandleX, y: targetHandleY }, { duration: 100, // Duration of the hit animation in ms easing: tween.easeOut, // Apply an easing function for smoother animation onFinish: function onFinish() { // Apply force to the cue ball after the animation completes cueBall.speedX = Math.cos(shootAngle) * shotPower; cueBall.speedY = Math.sin(shootAngle) * shotPower; shotTaken = true; // Mark that a shot has been taken cue.visible = false; // Hide cue during the shot } }); } else { // If shotPower is 0, no tween or shot, cue might be reset by game.update if balls are stopped. // Ensure shotTaken remains false if no actual shot is made. shotTaken = false; } } }; // Ask LK engine to update game every game tick game.update = function () { // Update ball positions cueBall.update(); for (var i = 0; i < coloredBalls.length; i++) { coloredBalls[i].update(); } // Handle collisions handleEdgeCollisions(cueBall); // Clamping for cueBall is now handled within handleEdgeCollisions for (var i = 0; i < coloredBalls.length; i++) { handleEdgeCollisions(coloredBalls[i]); // Clamping for coloredBalls is now handled within handleEdgeCollisions } handleBallCollisions(); // Handle potting handlePotting(); // You can add a check here to see if all balls have stopped moving // before allowing another shot. var allStopped = true; if (Math.abs(cueBall.speedX) > 0.1 || Math.abs(cueBall.speedY) > 0.1) { allStopped = false; } for (var i = 0; i < coloredBalls.length; i++) { if (Math.abs(coloredBalls[i].speedX) > 0.1 || Math.abs(coloredBalls[i].speedY) > 0.1) { allStopped = false; break; } } // Example: if all balls stopped and not dragging, you could enable a "next turn" or allow another shot if (allStopped && shotTaken && cue && cueBall) { // Check if cue and cueBall also exist shotTaken = false; // Reset for the next turn/aiming phase // Make the cue visible again and position it for the next shot cue.visible = true; var handle_distance_from_ball_center = cue.height + cueBall.width / 2 + CUE_TIP_TO_BALL_SURFACE_OFFSET; // Use reduced offset for closer cue cue.x = cueBall.x; cue.y = cueBall.y + handle_distance_from_ball_center; var angleToWhiteBall = Math.atan2(cueBall.y - cue.y, cueBall.x - cue.x); cue.rotation = angleToWhiteBall - Math.PI / 2; // Aim at cueBall } };