/**** * Plugins ****/ var tween = LK.import("@upit/tween.v1"); var storage = LK.import("@upit/storage.v1", { currentLevel: 1, highestLevel: 1 }); /**** * Classes ****/ var Car = Container.expand(function () { var self = Container.call(this); // Car properties self.speed = 0; self.maxSpeed = 12; // Doubled the max speed for faster gameplay self.acceleration = 0.1; self.deceleration = 0.05; self.steeringAngle = 0; self.maxSteeringAngle = 0.12; // Significantly increased for better steering response self.isReversing = false; self.isColliding = false; // Create car body var carBody = self.attachAsset('car', { anchorX: 0.5, anchorY: 0.5 }); // Method to update car position based on physics self.updatePhysics = function () { // Apply acceleration/deceleration if (self.acceleratorPressed) { if (!self.isReversing) { // Do not apply any deceleration when gas pedal is pressed if (self.speed > 0) { // Moving forward - accelerate without resistance self.speed = Math.min(self.speed + self.acceleration, self.maxSpeed); } else { // Starting from stopped or reverse - accelerate normally self.speed = Math.min(self.speed + self.acceleration, self.maxSpeed); } } else { self.speed = Math.max(self.speed - self.acceleration, -self.maxSpeed / 2); } } else { if (self.speed > 0) { self.speed = Math.max(0, self.speed - self.deceleration); } else if (self.speed < 0) { self.speed = Math.min(0, self.speed + self.deceleration); } } // Apply braking with improved reverse transition if (self.brakePressed) { // If we're moving forward, brake normally if (self.speed > 0) { self.speed = Math.max(0, self.speed - self.deceleration * 3); } // If we're not moving much or in reverse else { // If we're close to stopping or already in reverse if (Math.abs(self.speed) < 0.5 || self.isReversing) { // Set reverse mode immediately self.isReversing = true; self.reverseEngaged = true; // Smoothly transition to reverse speed or maintain current reverse speed if (self.speed > -6.0) { // Gradual acceleration into reverse to avoid jerky transitions self.speed = Math.max(-6.0, self.speed - self.acceleration * 2); } } // If we're still slowing down before going into reverse else { self.speed = Math.min(0, self.speed + self.deceleration * 3); } } } else { // When brake is released if (self.acceleratorPressed) { // If gas pedal is pressed, exit reverse mode self.isReversing = false; self.reverseEngaged = false; } else if (Math.abs(self.speed) < 0.05) { // Only reset reverse state when car is fully stopped and no pedals are pressed self.isReversing = false; self.reverseEngaged = false; } } // Update position and rotation based on speed and steering with improved physics if (Math.abs(self.speed) > 0.1) { // Progressive steering response based on speed // More responsive at low speeds, more stable at high speeds var speedRatio = Math.abs(self.speed) / self.maxSpeed; // Dynamic steering factor with better curve var steeringFactor; if (speedRatio < 0.2) { // More responsive at very low speeds for better maneuverability steeringFactor = 1.4 - speedRatio * 1.5; } else if (speedRatio > 0.7) { // More stable at high speeds steeringFactor = 0.8 - (speedRatio - 0.7) * 0.3; } else { // Balanced middle range steeringFactor = 1.1 - speedRatio * 0.5; } // Apply steering with direction-aware adjustment // Reduce steering response when in reverse for more intuitive control var directionFactor = self.speed > 0 ? 1 : 0.8; // Add direction multiplier to correct steering direction in reverse var directionMultiplier = self.speed >= 0 ? 1 : -1; // Calculate rotation with smoother curve, reduced oversteer and better physics var baseRotationAmount = directionMultiplier * self.steeringAngle * Math.abs(self.speed) / 2.0 * steeringFactor * directionFactor; // Apply stability correction based on current rotation rate if (self.lastRotationAmount === undefined) { self.lastRotationAmount = 0; } // Adaptive stability control to counteract excessive rotation (oversteer) var rotationRate = Math.abs(self.lastRotationAmount); var stabilityFactor = 1.0; if (rotationRate > 0.005 && Math.abs(self.speed) > 2) { // Apply progressive stability control as rotation rate increases stabilityFactor = 1.0 - Math.min(0.3, rotationRate * 10); } var rotationAmount = baseRotationAmount * stabilityFactor; // Store rotation amount for next frame stability calculation self.lastRotationAmount = rotationAmount; // Apply rotation self.rotation += rotationAmount; // Update position based on rotation and speed with improved physics self.x += Math.sin(self.rotation) * self.speed; self.y -= Math.cos(self.rotation) * self.speed; } }; // Reset car state self.reset = function (x, y, rotation) { self.x = x; self.y = y + 333; // Load the car 333 units lower self.rotation = rotation || 0; self.speed = 0; self.steeringAngle = 0; self.isReversing = false; self.isColliding = false; self.acceleratorPressed = false; self.brakePressed = false; }; // Check if car is within boundaries, colliding with obstacles, or touching screen edges self.checkBoundaries = function (boundaries) { // Check for screen edge collisions var carBox = { x: self.x - self.width / 4, y: self.y - self.height / 4, width: self.width / 2, height: self.height / 2 }; // Screen boundaries (adding some buffer to avoid triggering too early) var screenLeft = 20; var screenRight = 2048 - 20; var screenTop = 20; var screenBottom = 2732 - 20; // Check if car touches any screen edge if (carBox.x < screenLeft || carBox.x + carBox.width > screenRight || carBox.y < screenTop || carBox.y + carBox.height > screenBottom) { return true; } // Check boundaries from level for (var i = 0; i < boundaries.length; i++) { var boundaryBox = { x: boundaries[i].x - boundaries[i].width / 4, y: boundaries[i].y - boundaries[i].width / 4, width: boundaries[i].width / 2, height: boundaries[i].height / 2 }; // Check if car's inner part collides with boundary's inner part var collision = !(carBox.x + carBox.width < boundaryBox.x || carBox.x > boundaryBox.x + boundaryBox.width || carBox.y + carBox.height < boundaryBox.y || carBox.y > boundaryBox.y + boundaryBox.height); if (collision) { return true; } } return false; }; // Check if car is colliding with obstacles self.checkObstacleCollision = function (obstacles) { for (var i = 0; i < obstacles.length; i++) { var obstacle = obstacles[i]; // Use accurate asset dimensions for precise collision detection var carBox = { x: self.x - carBody.width / 3, // Use 1/3 of width for more accurate collision box y: self.y - carBody.height / 3, // Use 1/3 of height for more accurate collision box width: carBody.width / 1.5, // 2/3 width for actual car body size height: carBody.height / 1.5 // 2/3 height for actual car body size }; var obstacleAsset = obstacle.children[0]; var obstacleBox = { x: obstacle.x - obstacleAsset.width / 3, // Use 2/3 width of obstacle for more forgiving collision y: obstacle.y - obstacleAsset.height / 3, // Use 2/3 height of obstacle for more forgiving collision width: obstacleAsset.width / 1.5, // 2/3 width for more forgiving obstacle size height: obstacleAsset.height / 1.5 // 2/3 height for more forgiving obstacle size }; // Check if car collides with the obstacle's actual body size var collision = !(carBox.x + carBox.width < obstacleBox.x || carBox.x > obstacleBox.x + obstacleBox.width || carBox.y + carBox.height < obstacleBox.y || carBox.y > obstacleBox.y + obstacleBox.height); if (collision) { return true; } } return false; }; return self; }); var Level = Container.expand(function (levelNum) { var self = Container.call(this); // Level properties self.levelNumber = levelNum; self.obstacles = []; self.boundaries = []; self.parkingSpot = null; self.isCompleted = false; // Background for level var background = self.attachAsset('levelBackground', { anchorX: 0, anchorY: 0, alpha: 0.5 }); var parkingLot = self.addChild(LK.getAsset('parkingLot', { anchorX: 0.5, anchorY: 0.5, x: 2048 / 2, y: 2732 / 2 - 150, alpha: 0.8 })); // Setup level configuration self.setup = function () { // Clear existing obstacles for (var i = 0; i < self.obstacles.length; i++) { self.obstacles[i].destroy(); } self.obstacles = []; // Clear existing boundaries for (var i = 0; i < self.boundaries.length; i++) { self.boundaries[i].destroy(); } self.boundaries = []; // Clear existing parking spot if (self.parkingSpot) { self.removeChild(self.parkingSpot); self.parkingSpot.destroy(); self.parkingSpot = null; } // Right boundary has been removed // Setup level based on level number switch (self.levelNumber) { case 1: self.setupLevel1(); break; case 2: self.setupLevel2(); break; case 3: self.setupLevel3(); break; default: self.setupLevel1(); } self.isCompleted = false; // Make sure the parking spot animation starts if (self.parkingSpot) { self.parkingSpot.startFlashing(); } }; self.setupLevel1 = function () { // Simple level with just a parking spot // Remove any existing parking spot first if (self.parkingSpot) { self.removeChild(self.parkingSpot); self.parkingSpot.destroy(); } self.parkingSpot = new ParkingSpot(); self.parkingSpot.x = 2048 / 2 + 587; // Moved right by 7 units from 580 to 587 self.parkingSpot.y = 2732 / 2 - 592; // Moved down by 30 units (from -622 to -592) self.parkingSpot.rotation = Math.PI / 2; // Rotated 90 degrees self.addChild(self.parkingSpot); // Add one simple obstacle var obstacle = new Obstacle(); obstacle.x = 2048 / 2 - 537; // Moved left by 7 units from -530 to -537 obstacle.y = 2732 / 2 + 240; // Moved down by 40 units from +200 to +240 obstacle.rotation = Math.PI / 2; // Rotate 90 degrees clockwise self.addChild(obstacle); self.obstacles.push(obstacle); // Add car2 obstacle to the center of level1 var car2Obstacle = new Container(); var car2Graphics = car2Obstacle.attachAsset('car2', { anchorX: 0.5, anchorY: 0.5 }); car2Obstacle.x = 2048 / 2; // Center of the screen (x-coordinate) car2Obstacle.y = 2732 / 2; // Center of the screen (y-coordinate) car2Obstacle.rotation = 0; // No rotation self.addChild(car2Obstacle); self.obstacles.push(car2Obstacle); }; self.setupLevel2 = function () { // Add parking spot in more challenging position // Remove any existing parking spot first if (self.parkingSpot) { self.removeChild(self.parkingSpot); self.parkingSpot.destroy(); } self.parkingSpot = new ParkingSpot(); self.parkingSpot.x = 2048 / 2 + 584; // Moved right by 7 units from +577 to +584 self.parkingSpot.y = 2732 / 2 - 595; // Moved up by 20 more units from -575 to -595 self.parkingSpot.rotation = Math.PI / 2; // Rotated 90 degrees self.addChild(self.parkingSpot); // Add trolley upward from greenspot var trolley = new Container(); var trolleyGraphics = trolley.attachAsset('trolley', { anchorX: 0.5, anchorY: 0.5 }); trolley.x = 2048 / 2 + 577 + 123; // Moved right by 123 units from parking spot trolley.y = 2732 / 2 - 750 - 333; // Upward from greenspot, moved up by 333 units self.addChild(trolley); self.obstacles.push(trolley); // Add second trolley 1234 units under the first one var trolley2 = new Container(); var trolley2Graphics = trolley2.attachAsset('trolley', { anchorX: 0.5, anchorY: 0.5 }); trolley2.x = 2048 / 2 + 577 + 123; // Same x position as the first trolley trolley2.y = trolley.y + 1234; // 1234 units below the first trolley self.addChild(trolley2); self.obstacles.push(trolley2); // Add more obstacles var obstacle1 = new Obstacle(); obstacle1.x = 2048 / 2 - 525; // Moved left by 50 units from -475 to -525 obstacle1.y = 2732 / 2 - 600; // Moved up by 300 units from -300 to -600 obstacle1.rotation = Math.PI / 2; // Rotate right by 90 degrees self.addChild(obstacle1); self.obstacles.push(obstacle1); var obstacle2 = new Obstacle(); obstacle2.x = 2048 / 2 + 545; // Moved right by 25 units from +520 to +545 obstacle2.y = 2732 / 2 - 300 + 111 + 33; // Moved down by 144 units (111 + 33) obstacle2.rotation = -Math.PI / 2; // Rotate left by 90 degrees self.addChild(obstacle2); self.obstacles.push(obstacle2); // Add moving obstacle - start from level1 obstacle position var movingObstacle = new Obstacle(); // Starting position same as level1 obstacle: x:2048/2-537, y:2732/2+240 movingObstacle.x = 2048 / 2 - 537; movingObstacle.y = 2732 / 2 + 240; movingObstacle.rotation = Math.PI / 2; // Rotate 90 degrees clockwise self.addChild(movingObstacle); self.obstacles.push(movingObstacle); // Add 90-degree right rotation to the car1 obstacle for level2 movingObstacle.rotation = Math.PI / 2; // Rotate right by 90 degrees // Create a smooth, realistic turning arc with continuous rotation var startX = movingObstacle.x; var startY = movingObstacle.y; var centerX = 2048 / 2; var centerY = startY; // Set up a larger turning radius for more realistic car movement var turnRadius = 650; // Larger radius for smoother, more realistic turning // Start with car facing right (90 degrees) movingObstacle.rotation = Math.PI / 2; // Use a customized tween for smoother, more realistic car turning movement tween(movingObstacle, { x: centerX // Initial target - will be updated in onUpdate }, { duration: 5000, // Longer duration for smoother, more realistic turning easing: tween.easeInOut, onUpdate: function onUpdate(progress) { // Create a more gradual, continuous turning motion // Calculate current angle in the turning arc (0 to PI/2) var angle = progress * Math.PI / 2; // Calculate position on the arc using parametric equations // This creates a proper turning radius rather than mirroring if (progress < 0.95) { // During main turning phase // Calculate car position along circular arc var arcX = centerX - Math.sin(angle) * turnRadius; var arcY = centerY - Math.cos(angle) * turnRadius; // Position car along the arc movingObstacle.x = arcX; movingObstacle.y = arcY; // Calculate tangent angle at this point on the arc // This gives realistic orientation as car follows the arc // Start at PI/2 (facing right) and rotate to 0 (facing up) var rotationAngle = Math.PI / 2 - angle; // Apply smooth rotation to the car movingObstacle.rotation = rotationAngle; } else { // Final straightening at end of turn (last 5% of animation) var finalProgress = (progress - 0.95) / 0.05; var finalPosition = centerY - turnRadius - finalProgress * 300; // Keep X position fixed at center after completing the arc movingObstacle.x = centerX; movingObstacle.y = finalPosition; // Ensure car is facing directly upward at the end movingObstacle.rotation = 0; } }, onFinish: function onFinish() { // Make sure car is fully facing upward when finished movingObstacle.rotation = 0; // After completing the turn, continue moving upward tween(movingObstacle, { y: -1000 // Move much further beyond top edge of screen to ensure it completely exits }, { duration: 4000, easing: tween.easeInOut }); } }); }; self.setupLevel3 = function () { // Add parking spot in difficult position // Remove any existing parking spot first if (self.parkingSpot) { self.removeChild(self.parkingSpot); self.parkingSpot.destroy(); } self.parkingSpot = new ParkingSpot(); self.parkingSpot.x = 2048 / 2 - 400; self.parkingSpot.y = 2732 / 2 - 600; self.parkingSpot.rotation = Math.PI; // Rotated 180 degrees self.addChild(self.parkingSpot); // Add many obstacles in a maze-like pattern var obstaclePositions = [{ x: 2048 / 2 - 600, y: 2732 / 2 - 300 }, { x: 2048 / 2 - 400, y: 2732 / 2 - 300 }, { x: 2048 / 2 - 200, y: 2732 / 2 - 300 }, { x: 2048 / 2, y: 2732 / 2 - 300 }, { x: 2048 / 2 + 200, y: 2732 / 2 - 300 }, { x: 2048 / 2 + 400, y: 2732 / 2 - 300 }, { x: 2048 / 2 - 600, y: 2732 / 2 }, { x: 2048 / 2, y: 2732 / 2 }, { x: 2048 / 2 + 600, y: 2732 / 2 }, { x: 2048 / 2 - 600, y: 2732 / 2 + 300 }, { x: 2048 / 2 - 400, y: 2732 / 2 + 300 }, { x: 2048 / 2 - 200, y: 2732 / 2 + 300 }, { x: 2048 / 2, y: 2732 / 2 + 300 }, { x: 2048 / 2 + 200, y: 2732 / 2 + 300 }]; for (var i = 0; i < obstaclePositions.length; i++) { var obstacle = new Obstacle(); obstacle.x = obstaclePositions[i].x; obstacle.y = obstaclePositions[i].y; self.addChild(obstacle); self.obstacles.push(obstacle); } // Add two moving obstacles var movingObstacle1 = new Obstacle(); movingObstacle1.initMoving(2048 / 2 - 500, 2732 / 2 - 500, 2048 / 2 + 500, 2732 / 2 - 500, 4); self.addChild(movingObstacle1); self.obstacles.push(movingObstacle1); var movingObstacle2 = new Obstacle(); movingObstacle2.initMoving(2048 / 2 + 500, 2732 / 2 + 200, 2048 / 2 - 500, 2732 / 2 + 200, 3); self.addChild(movingObstacle2); self.obstacles.push(movingObstacle2); }; self.update = function () { // Update all moving obstacles for (var i = 0; i < self.obstacles.length; i++) { if (self.obstacles[i].isMoving) { self.obstacles[i].update(); } } // Update display order for static obstacles too var carInstance = null; // Find the car in the game's children for (var i = 0; i < game.children.length; i++) { if (game.children[i] instanceof Car) { carInstance = game.children[i]; break; } } if (carInstance && carInstance.parent && typeof carInstance.parent.swapChildren === 'function') { // Update z-index for all obstacles based on position relative to car for (var i = 0; i < self.obstacles.length; i++) { if (self.obstacles[i].parent) { if (self.obstacles[i].y > carInstance.y) { // If obstacle is below the car, bring obstacle to front carInstance.parent.swapChildren(carInstance, self.obstacles[i]); } else { // If car is below obstacle, bring car to front carInstance.parent.swapChildren(self.obstacles[i], carInstance); } } } } }; return self; }); var LevelSelector = Container.expand(function () { var self = Container.call(this); // Create semi-transparent background var bg = self.attachAsset('levelBackground', { anchorX: 0.5, anchorY: 0.5, alpha: 0.8 }); // Center the popup self.x = 2048 / 2; self.y = 2732 / 2; // Level buttons container self.buttonsContainer = new Container(); self.addChild(self.buttonsContainer); // Title text var titleText = new Text2('SELECT LEVEL', { size: 100, fill: 0xFFFFFF }); titleText.anchor.set(0.5, 0.5); titleText.y = -600; // Moved 300 units upward from -300 to -600 self.addChild(titleText); // Create level buttons self.createButtons = function (highestLevel) { // Clear existing buttons while (self.buttonsContainer.children.length > 0) { self.buttonsContainer.removeChild(self.buttonsContainer.children[0]); } // Calculate button positions var buttonSize = 150 * 2.5; // Scale up level icons by 2.5x var spacing = 50 * 2; // Double the spacing between icons var maxButtons = 3; // Maximum number of levels var totalWidth = maxButtons * buttonSize + (maxButtons - 1) * spacing; for (var i = 1; i <= maxButtons; i++) { var button = new Container(); // Create button background var buttonBg = button.attachAsset('levelIcon', { anchorX: 0.5, anchorY: 0.5, width: buttonSize, height: buttonSize, alpha: 0.8 }); // Use proper assets for each level var levelIcon; if (i === 3) { levelIcon = button.addChild(LK.getAsset('LB', { anchorX: 0.5, anchorY: 0.5, alpha: i <= highestLevel ? 1.0 : 0.4, scaleX: 2.5, // Scale up by 2.5x scaleY: 2.5 // Scale up by 2.5x })); } else { levelIcon = button.addChild(LK.getAsset('levelIcon', { anchorX: 0.5, anchorY: 0.5, alpha: i <= highestLevel ? 1.0 : 0.4, scaleX: 2.5, // Scale up by 2.5x scaleY: 2.5 // Scale up by 2.5x })); } // Button text - add level number in the center of the icon var buttonText = new Text2(i.toString(), { size: 80 * 2.5, // Scale up text size by 2.5x fill: i <= highestLevel ? 0xFFFFFF : 0x888888 }); buttonText.anchor.set(0.5, 0.5); // Position text in the center of the icon instead of below it button.addChild(buttonText); // Position the button button.x = (i - (maxButtons + 1) / 2) * (buttonSize + spacing); button.y = 0; // Make button interactive button.interactive = true; button.levelNumber = i; button.enabled = i <= highestLevel; // Store reference for easy access button.down = function (x, y, obj) { if (this.enabled) { self.onLevelSelected(this.levelNumber); } }; self.buttonsContainer.addChild(button); } }; // Close button var closeButton = new Text2('✕', { size: 200, fill: 0xFFFFFF }); closeButton.anchor.set(0.5, 0.5); closeButton.x = bg.width / 2 - 50 - 77; // Moved left by 77 units closeButton.y = -bg.height / 2 + 50 + 77; // Moved down by 77 units closeButton.interactive = true; closeButton.down = function () { self.hide(); }; self.addChild(closeButton); // Level selection callback (to be set by game code) self.onLevelSelected = function (levelNum) { // Default implementation - will be overridden self.hide(); }; // Show popup self.show = function () { self.visible = true; self.alpha = 0; tween(self, { alpha: 1 }, { duration: 300, easing: tween.easeOut }); }; // Hide popup self.hide = function () { tween(self, { alpha: 0 }, { duration: 300, easing: tween.easeOut, onFinish: function onFinish() { self.visible = false; // Show the level selector button again when popup is hidden if (levelSelectorBtn) { levelSelectorBtn.visible = true; } } }); }; // Initially hidden self.visible = false; return self; }); var Obstacle = Container.expand(function () { var self = Container.call(this); var obstacleGraphics = self.attachAsset('car1', { anchorX: 0.5, anchorY: 0.5 }); // For moving obstacles self.speed = 0; self.direction = 0; self.pathStart = { x: 0, y: 0 }; self.pathEnd = { x: 0, y: 0 }; self.isMoving = false; // Initialize as a moving obstacle self.initMoving = function (startX, startY, endX, endY, moveSpeed) { self.pathStart = { x: startX, y: startY }; self.pathEnd = { x: endX, y: endY }; self.x = startX; self.y = startY; self.speed = (moveSpeed || 2) / 3; // Slow down obstacle to 1/3 of original speed self.isMoving = true; // Calculate direction var dx = endX - startX; var dy = endY - startY; self.direction = Math.atan2(dy, dx); }; // Update position for moving obstacles self.update = function () { if (!self.isMoving) { return; } self.x += Math.cos(self.direction) * self.speed; self.y += Math.sin(self.direction) * self.speed; // Check if reached end point var distToEnd = Math.sqrt(Math.pow(self.x - self.pathEnd.x, 2) + Math.pow(self.y - self.pathEnd.y, 2)); if (distToEnd < self.speed) { // Swap start and end points var temp = self.pathStart; self.pathStart = self.pathEnd; self.pathEnd = temp; // Recalculate direction var dx = self.pathEnd.x - self.x; var dy = self.pathEnd.y - self.y; self.direction = Math.atan2(dy, dx); } // Z-ordering is now handled centrally in Level.update() method }; return self; }); var ParkingSpot = Container.expand(function () { var self = Container.call(this); var spotGraphics = self.attachAsset('parkingSpot', { anchorX: 0.5, anchorY: 0.5, alpha: 0.5 }); // Add flashing animation to the parking spot self.startFlashing = function () { // Create a subtle pulsing effect tween(spotGraphics, { alpha: 0.7 }, { duration: 1200, easing: tween.easeInOut, onFinish: function onFinish() { tween(spotGraphics, { alpha: 0.5 }, { duration: 1200, easing: tween.easeInOut, onFinish: self.startFlashing }); } }); }; // Start the flashing animation self.startFlashing(); // Check if car is properly parked self.isCarParked = function (car) { // Check if car's center is inside parking spot and nearly stopped var carCenterX = car.x; var carCenterY = car.y; var spotLeft = self.x - self.width / 2; var spotRight = self.x + self.width / 2; var spotTop = self.y - self.height / 2; var spotBottom = self.y + self.height / 2; // Check if car's center is within the parking spot and it's nearly stopped var carInSpot = carCenterX > spotLeft && carCenterX < spotRight && carCenterY > spotTop && carCenterY < spotBottom && Math.abs(car.speed) < 0.2; if (carInSpot) { // Check alignment - handle both forward and backward parking var carAngle = (car.rotation % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2); var spotAngle = (self.rotation % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2); // Check both normal alignment and 180-degree reversed alignment var normalAngleDiff = Math.abs(carAngle - spotAngle); var reversedAngleDiff = Math.abs(carAngle - (spotAngle + Math.PI) % (Math.PI * 2)); // Normalize both angle differences to be within [0, PI] if (normalAngleDiff > Math.PI) { normalAngleDiff = Math.PI * 2 - normalAngleDiff; } if (reversedAngleDiff > Math.PI) { reversedAngleDiff = Math.PI * 2 - reversedAngleDiff; } // Car is considered parked when it's aligned with the spot either forward or backward (within 15 degrees) return Math.min(normalAngleDiff, reversedAngleDiff) < Math.PI / 12; } return false; }; return self; }); var SimplePedal = Container.expand(function (type) { var self = Container.call(this); var pedalAsset = type === 'accelerator' ? 'gasPedal' : 'brakePedal'; var pedal = self.attachAsset(pedalAsset, { anchorX: 0.5, anchorY: 0.5 }); self.type = type; self.isPressed = false; self.pressAmount = 0; // 0 to 1 // Handle touch/mouse events self.down = function (x, y, obj) { self.isPressed = true; self.pressAmount = 1; tween(pedal, { scaleX: 0.9, scaleY: 0.9, alpha: 0.8 }, { duration: 100 }); }; self.up = function () { self.isPressed = false; self.pressAmount = 0; tween(pedal, { scaleX: 1, scaleY: 1, alpha: 1 }, { duration: 200, easing: tween.easeOut }); }; self.updatePressAmount = function (y) { // Simple pedals always return full amount when pressed self.pressAmount = self.isPressed ? 1 : 0; }; return self; }); var SteeringControl = Container.expand(function () { var self = Container.call(this); var wheel = self.attachAsset('steeringWheel', { anchorX: 0.5, anchorY: 0.5 }); self.baseRotation = 0; self.maxRotation = Math.PI * 0.85; // Significantly increased rotation range for more turning capability self.isDragging = false; self.lastAngle = 0; self.lastDragUpdate = 0; self.targetRotation = 0; // Get current steering value (-1 to 1) self.getSteeringValue = function () { return self.rotation / self.maxRotation; }; // Handle touch/mouse events self.down = function (x, y, obj) { self.isDragging = true; self.lastDragUpdate = 0; // Reset drag update tracker self.lastAngle = Math.atan2(y - wheel.height / 2, x - wheel.width / 2); }; self.up = function () { self.isDragging = false; // Auto-center the steering wheel when released tween(self, { rotation: 0 }, { duration: 500, easing: tween.easeOut }); }; return self; }); /**** * Initialize Game ****/ // Utility function to swap children in containers (not available in old PixiJS) will be defined in Game Code section var game = new LK.Game({ backgroundColor: 0x444444 }); /**** * Game Code ****/ // Game state // Utility function to swap children in containers (not available in old PixiJS) if (!Container.prototype.swapChildren) { Container.prototype.swapChildren = function (child1, child2) { // Validate that both children exist and are in this container if (!child1 || !child2) { return; } var index1 = this.children.indexOf(child1); var index2 = this.children.indexOf(child2); if (index1 >= 0 && index2 >= 0) { // Store references to the children var temp = this.children[index1]; // Replace the children directly this.children[index1] = this.children[index2]; this.children[index2] = temp; } }; } var currentLevel = storage.currentLevel || 1; var highestLevel = storage.highestLevel || 1; var gameState = 'playing'; // 'playing', 'success', 'crashed' // Create game elements var level = new Level(currentLevel); game.addChild(level); level.setup(); var car = new Car(); car.reset(2048 / 2, 2732 / 2 + 600, 0); // Start at bottom of screen facing up with vertical orientation game.addChild(car); // Create UI controls var steeringWheel = new SteeringControl(); steeringWheel.x = 350; steeringWheel.y = 2732 - 350; game.addChild(steeringWheel); var acceleratorPedal = new SimplePedal('accelerator'); acceleratorPedal.x = 2048 - 200 + 69; acceleratorPedal.y = 2732 - 350 + 123 - 20; // Moved up by 20 units acceleratorPedal.scale.set(1.5); game.addChild(acceleratorPedal); var brakePedal = new SimplePedal('brake'); brakePedal.x = 2048 - 450; brakePedal.y = 2732 - 350 + 123 + 15; brakePedal.scale.set(1.5); game.addChild(brakePedal); // Create UI elements var levelText = new Text2('Level ' + currentLevel, { size: 100, fill: 0xFFFFFF }); levelText.anchor.set(0.5, 0); LK.gui.top.addChild(levelText); // Level 1 button removed // Add level selector button to the right top corner var levelSelectorBtn = new Container(); var lbAsset = levelSelectorBtn.addChild(LK.getAsset('LB', { anchorX: 0.5, anchorY: 0.5, scaleX: 1, scaleY: 1 })); levelSelectorBtn.x = -120; // Position from the right edge levelSelectorBtn.y = 100; levelSelectorBtn.interactive = true; LK.gui.topRight.addChild(levelSelectorBtn); // Create level selector popup var levelSelector = new LevelSelector(); game.addChild(levelSelector); // Connect level selection callback levelSelector.onLevelSelected = function (levelNum) { // Only allow selection if level is unlocked if (levelNum <= highestLevel) { currentLevel = levelNum; storage.currentLevel = currentLevel; loadLevel(currentLevel); levelSelector.hide(); } }; // Level 1 button handler removed // Handle level selector button press levelSelectorBtn.down = function () { // Update buttons with latest unlocked levels levelSelector.createButtons(highestLevel); // Show level selector popup levelSelector.show(); // Hide the level selector button while the popup is active levelSelectorBtn.visible = false; // The levelSelectorBtn is a Container with LB asset, not a Text element // No need to update text on the button }; var instructionText = new Text2('', { size: 70, fill: 0xFFFFFF }); instructionText.anchor.set(0.5, 0); instructionText.y = 120; LK.gui.top.addChild(instructionText); var statusText = new Text2('', { size: 100, fill: 0xFFFFFF }); statusText.anchor.set(0.5, 0.5); LK.gui.center.addChild(statusText); // Game mechanics function updateCarControls() { // Update car controls based on steering wheel and pedal inputs // Apply steering with improved progressive smoothing var steeringValue = steeringWheel.getSteeringValue(); // Dynamic smoothness based on speed - smoother at high speeds var speedFactor = Math.min(1, Math.abs(car.speed) / (car.maxSpeed * 0.5)); var steeringSmoothness = 0.05 + speedFactor * 0.15; // More responsive at low speeds, smoother at high speeds // Initialize lastSteeringAngle if needed if (car.lastSteeringAngle === undefined) { car.lastSteeringAngle = steeringValue * car.maxSteeringAngle; } // Apply progressive dampening with reduced oversteer at turns var dampening = 0.65 + Math.abs(steeringValue) * 0.08; // Reduced overall steering amplification var targetSteeringAngle = steeringValue * car.maxSteeringAngle * dampening; // Apply counter-steering bias to prevent excessive oversteer during rapid turns if (Math.abs(car.steeringAngle) > 0.05 && Math.abs(car.speed) > 3) { // Apply subtle counter-steering tendency for stability during turns var oversteerCorrection = 0.15 * Math.sign(car.steeringAngle) * Math.min(1, Math.abs(car.steeringAngle) / 0.1); targetSteeringAngle -= oversteerCorrection * speedFactor; } // Apply adaptive smoothing with increased responsiveness for small movements var angleDifference = Math.abs(targetSteeringAngle - car.lastSteeringAngle); var adaptiveSmoothness = steeringSmoothness * (0.85 + angleDifference / car.maxSteeringAngle * 0.3); adaptiveSmoothness = Math.min(0.25, Math.max(0.05, adaptiveSmoothness)); // More consistent smoothing bounds car.steeringAngle = car.lastSteeringAngle * (1 - adaptiveSmoothness) + targetSteeringAngle * adaptiveSmoothness; car.lastSteeringAngle = car.steeringAngle; // Better synchronized wheel-to-car feedback - gradual correction with smoother interpolation if (!steeringWheel.isDragging) { var idealWheelRotation = car.steeringAngle / car.maxSteeringAngle * steeringWheel.maxRotation; var wheelCorrectionSpeed = 0.08 + speedFactor * 0.07; // Faster correction at higher speeds steeringWheel.rotation = steeringWheel.rotation * (1 - wheelCorrectionSpeed) + idealWheelRotation * wheelCorrectionSpeed; } // Update pedal states car.acceleratorPressed = acceleratorPedal.isPressed; car.brakePressed = brakePedal.isPressed; } function checkCollisions() { // Check collisions with obstacles using car's collision detection method if (car.checkObstacleCollision(level.obstacles) && gameState === 'playing') { LK.getSound('crash').play(); gameState = 'crashed'; car.isColliding = true; LK.effects.flashObject(car, 0xff0000, 1000); statusText.setText('CRASHED!'); resetLevel(2000); return true; } // Check collisions with boundaries if (car.checkBoundaries(level.boundaries) && gameState === 'playing') { LK.getSound('crash').play(); gameState = 'crashed'; car.isColliding = true; LK.effects.flashObject(car, 0xff0000, 1000); statusText.setText('OUT OF BOUNDS!'); resetLevel(2000); return true; } return false; } function checkParking() { // Check if car is correctly parked if (level.parkingSpot.isCarParked(car) && gameState === 'playing') { LK.getSound('success').play(); gameState = 'success'; statusText.setText('PARKED!'); // Update level progress if (currentLevel >= highestLevel) { highestLevel = currentLevel + 1; storage.highestLevel = highestLevel; } // Proceed to next level after delay LK.setTimeout(function () { if (currentLevel < 3) { currentLevel++; storage.currentLevel = currentLevel; loadLevel(currentLevel); } else { // Game completed statusText.setText('GAME COMPLETED!'); LK.setTimeout(function () { // Reset to level 1 currentLevel = 1; storage.currentLevel = currentLevel; loadLevel(currentLevel); }, 2000); } }, 1500); return true; } return false; } function resetLevel(delay) { LK.setTimeout(function () { car.reset(2048 / 2, 2732 / 2 + 600, 0); gameState = 'playing'; statusText.setText(''); }, delay || 0); } function loadLevel(levelNum) { level.levelNumber = levelNum; level.setup(); levelText.setText('Level ' + levelNum); car.reset(2048 / 2, 2732 / 2 + 600, 0); gameState = 'playing'; statusText.setText(''); } // Handle drag events for steering wheel function handleSteeringDrag(x, y) { if (steeringWheel.isDragging) { var centerX = steeringWheel.x; var centerY = steeringWheel.y; // Calculate angle relative to center of wheel var angle = Math.atan2(y - centerY, x - centerX); // If this is the first update after starting drag, just store the angle if (!steeringWheel.lastDragUpdate || steeringWheel.lastDragUpdate < LK.ticks - 5) { steeringWheel.lastAngle = angle; steeringWheel.lastDragUpdate = LK.ticks; return; } // Calculate rotation change with improved smoothing var angleDiff = angle - steeringWheel.lastAngle; // Adjust for angle wrap-around if (angleDiff > Math.PI) { angleDiff -= Math.PI * 2; } if (angleDiff < -Math.PI) { angleDiff += Math.PI * 2; } // Apply adaptive sensitivity based on angle magnitude // Smaller movements are more precise, larger movements more responsive var baseSensitivity = 0.65; var adaptiveSensitivity = baseSensitivity * (1 - Math.min(0.3, Math.abs(angleDiff) / Math.PI)); angleDiff *= adaptiveSensitivity; // Progressive deadzone to prevent micro-movements but allow precision if (Math.abs(angleDiff) < 0.005) { angleDiff = 0; } else if (Math.abs(angleDiff) < 0.02) { // Gradually scale up small movements for better precision angleDiff *= (Math.abs(angleDiff) - 0.005) / 0.015; } // Apply rotation with limits using smooth interpolation var targetRotation = steeringWheel.rotation + angleDiff; targetRotation = Math.max(-steeringWheel.maxRotation, Math.min(steeringWheel.maxRotation, targetRotation)); // Dynamic smoothing: more responsive for quick movements, smoother for small adjustments var movementSpeed = Math.abs(angleDiff) * 20; // Measure how fast the wheel is being turned var smoothFactor = Math.min(0.9, 0.7 + movementSpeed * 0.4); // Adaptive smoothing // Apply smoothing with better dynamics steeringWheel.rotation = steeringWheel.rotation * (1 - smoothFactor) + targetRotation * smoothFactor; // Update last angle and timestamp steeringWheel.lastAngle = angle; steeringWheel.lastDragUpdate = LK.ticks; } } // Handle pedal drag events function handlePedalDrag(x, y, pedal) { if (pedal.isPressed) { pedal.updatePressAmount(y); } } // Mouse/touch event handlers game.down = function (x, y, obj) { // Check if clicked on a control var localPoint; // Check if level selector is visible and handle its clicks first if (levelSelector.visible) { // First check if we clicked on the close button in the level selector localPoint = levelSelector.toLocal({ x: x, y: y }); // Check if click is within the level selector if (localPoint.x >= -levelSelector.width / 2 && localPoint.x <= levelSelector.width / 2 && localPoint.y >= -levelSelector.height / 2 && localPoint.y <= levelSelector.height / 2) { // First check for close button click (direct child of level selector) for (var i = 0; i < levelSelector.children.length; i++) { var child = levelSelector.children[i]; if (child instanceof Text2 && child.text === '✕') { // Check if click is within close button bounds if (Math.abs(localPoint.x - child.x) < 100 && Math.abs(localPoint.y - child.y) < 100) { child.down(); // Directly call down handler on close button levelSelector.hide(); return; } } } // If we didn't click the close button, check level buttons // Check each button in the buttons container for (var i = 0; i < levelSelector.buttonsContainer.children.length; i++) { var button = levelSelector.buttonsContainer.children[i]; // Convert global click coordinates directly to button's local space var buttonLocalPoint = button.toLocal({ x: x, y: y }); // Check if click is within button bounds using its actual dimensions var buttonWidth = button.children[0].width; var buttonHeight = button.children[0].height; if (Math.abs(buttonLocalPoint.x) < buttonWidth / 2 && Math.abs(buttonLocalPoint.y) < buttonHeight / 2) { // If level is unlocked, load it if (button.levelNumber <= highestLevel) { // Call the level select handler directly levelSelector.onLevelSelected(button.levelNumber); return; // Exit after selecting level } } } return; // Don't process any other clicks if we clicked within the level selector } } // Note: We need to check each control separately since we can't easily determine // which one was clicked directly from the event // Check steering wheel localPoint = steeringWheel.toLocal({ x: x, y: y }); if (localPoint.x >= 0 && localPoint.x <= steeringWheel.width && localPoint.y >= 0 && localPoint.y <= steeringWheel.height) { steeringWheel.down(localPoint.x, localPoint.y, steeringWheel); } // Check accelerator pedal localPoint = acceleratorPedal.toLocal({ x: x, y: y }); if (localPoint.x >= 0 && localPoint.x <= acceleratorPedal.width && localPoint.y >= 0 && localPoint.y <= acceleratorPedal.height) { acceleratorPedal.down(localPoint.x, localPoint.y, acceleratorPedal); } // Check brake pedal localPoint = brakePedal.toLocal({ x: x, y: y }); if (localPoint.x >= 0 && localPoint.x <= brakePedal.width && localPoint.y >= 0 && localPoint.y <= brakePedal.height) { brakePedal.down(localPoint.x, localPoint.y, brakePedal); } }; game.up = function (x, y, obj) { // Release all controls steeringWheel.up(); acceleratorPedal.up(); brakePedal.up(); }; game.move = function (x, y, obj) { // Handle drag events for controls handleSteeringDrag(x, y); handlePedalDrag(x, y, acceleratorPedal); handlePedalDrag(x, y, brakePedal); }; // Main game loop game.update = function () { if (gameState === 'playing') { // Update car controls updateCarControls(); // Update car physics car.updatePhysics(); // Update level (moving obstacles, etc.) level.update(); // Check for collisions and parking if (!checkCollisions()) { checkParking(); } // Play engine sound based on car speed if (Math.abs(car.speed) > 0.5 && LK.ticks % 60 === 0) { LK.getSound('engine').play(); } } }; // Play background music LK.playMusic('bgmusic', { fade: { start: 0, end: 0.3, duration: 1000 } });