/**** 
* Classes
****/ 
// Assets are automatically created based on usage in the code.
// Ball class
var Ball = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the ball asset
	var ballGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set initial properties
	self.radius = ballGraphics.width / 2; // Assuming the asset is a circle
	self.gravity = 0.5;
	self.velocityY = 0;
	self.rotationAngle = 0; // Rotation angle of the ball
	self.hasHitRectangle = false; // Flag to check if the ball has hit the rectangle
	// Ball update method
	self.update = function () {
		// Apply gravity with increased force to ensure it surpasses all other forces
		// Correctly apply gravity to the ball
		// Apply gravity to the ball's vertical velocity consistently every tick
		self.velocityY += self.gravity;
		// Update the ball's vertical position based on the velocity
		self.y += self.velocityY;
		// Derive horizontal velocity from rotation
		var movementDirection = self.rotationAngle < 0 ? -1 : 1; // Determine the direction of movement based on the rotation of the ball
		// Dynamically adjust sensitivity based on gameplay needs
		var baseSensitivity = 1; // Base sensitivity factor increased
		var dynamicSensitivityAdjustment = 0.1; // Additional sensitivity based on game state or player progress increased
		var movementSensitivity = baseSensitivity + dynamicSensitivityAdjustment; // Total sensitivity for ball's movement updated
		var movementInertia = Math.abs(self.rotationAngle) * movementSensitivity; // Calculate movement inertia
		self.velocityX = movementDirection * movementInertia; // Apply movement inertia to horizontal velocity
		self.x += self.velocityX; // Apply the horizontal velocity to the ball
		// Initialize ball animation to flip horizontally every second outside update method
		self.animationInitialized = false; // Flag to ensure the animation setup runs only once
		self.initAnimation = function () {
			if (!self.animationInitialized) {
				self.animationInitialized = true;
				self.flipFrame = function () {
					ballGraphics.flipX = ballGraphics.flipX === 0 ? 1 : 0; // Toggle flipX between 0 and 1
				};
				LK.setInterval(self.flipFrame, 1000); // Flip frame every 1000ms (1 second)
			}
		};
		self.initAnimation();
	};
});
// Platform class
var Platform = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the platform asset
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set initial properties
	self.width = platformGraphics.width;
	self.height = platformGraphics.height;
	self.canInteract = true; // Flag to determine if the platform can interact with the ball
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000 // Init game with black background 
});

/**** 
* Game Code
****/ 
// Add the new rectangle asset to the game
var centerRectangle = LK.getAsset('centerRectangle', {
	anchorX: 0.5,
	// Center anchor x-coordinate
	anchorY: 0.5,
	// Center anchor y-coordinate
	x: 1024,
	// Center position x-coordinate
	y: 1850 // Center position y-coordinate
});
game.addChild(centerRectangle);
// Initialize balls
var ball = game.addChild(new Ball());
ball.x = 1024; // Center horizontally
ball.y = 1100; // Start from the top
var platform = game.addChild(new Platform());
platform.x = 1024; // Center horizontally
platform.y = 2220; // Position lower
// Check collision between ball and platform
function checkCollision() {
	var dx = ball.x - platform.x;
	var dy = ball.y - platform.y;
	var distance = Math.sqrt(dx * dx + dy * dy);
	if (platform.canInteract && distance < ball.radius + platform.height / 2) {
		// Correct collision detection between ball and platform
		// Reduce the horizontal contact point of the platform with the ball
		// Calculate the center point of the platform and the boundaries of the narrow collision zone
		var platformCenterX = platform.x;
		var narrowZoneWidth = platform.width * 0.8; // Increase the contact width to 80% of the platform's total width
		var narrowZoneLeftBoundary = platformCenterX - narrowZoneWidth / 2;
		var narrowZoneRightBoundary = platformCenterX + narrowZoneWidth / 2;
		// Check if the ball is within the narrow collision zone and above the platform
		if (ball.y + ball.radius > platform.y - platform.height / 2 && ball.x > narrowZoneLeftBoundary && ball.x < narrowZoneRightBoundary) {
			// If the ball is touching the platform, reverse the ball's vertical velocity
			ball.velocityY *= -0.5; // Apply a dampening effect to simulate a bounce
			ball.y = platform.y - platform.height / 2 - ball.radius; // Adjust the ball's position to be above the platform
			// This code block should be removed as it incorrectly disables platform interaction prematurely
		}
		// Check collision between ball and centerRectangle
		var rectDx = ball.x - centerRectangle.x;
		var rectDy = ball.y - centerRectangle.y;
		var rectDistance = Math.sqrt(rectDx * rectDx + rectDy * rectDy);
		if (rectDistance < ball.radius + centerRectangle.height / 2) {
			platform.canInteract = false; // Disable platform interaction when ball touches the rectangle
		}
	}
}
// Game tick event
LK.on('tick', function () {
	ball.update();
	checkCollision();
	// Add boundaries around the screen edges
	if (ball.x - ball.radius < 0) {
		ball.x = ball.radius;
	}
	if (ball.x + ball.radius > 2048) {
		ball.x = 2048 - ball.radius;
	}
	if (ball.y - ball.radius < 0) {
		ball.y = ball.radius;
		ball.velocityY = 0;
	}
	if (ball.y + ball.radius > 2732) {
		LK.showGameOver();
	}
});
// Touch event to move the platform
var targetX = platform.x; // Initialize targetX to the current platform position
game.on('move', function (obj) {
	var pos = obj.event.getLocalPosition(game);
	targetX = pos.x; // Update targetX when the cursor moves
});
LK.on('tick', function () {
	var oldPlatformX = platform.x;
	var speedLimit = 20; // Set the speed limit
	var newPlatformX = targetX;
	var speed = newPlatformX - oldPlatformX;
	if (Math.abs(speed) > speedLimit) {
		// If the calculated speed exceeds the limit, adjust the new position of the platform
		newPlatformX = oldPlatformX + (speed > 0 ? speedLimit : -speedLimit);
	}
	// Limit the platform's movement to 200 pixels to the left and right from the center of the screen
	if (newPlatformX < 1024 - 200) {
		newPlatformX = 1024 - 200;
	} else if (newPlatformX > 1024 + 200) {
		newPlatformX = 1024 + 200;
	}
	platform.x = newPlatformX;
	// Calculate the displacement of the platform from the center of the screen
	var displacement = platform.x - 1024;
	// Adjust the rotation angle based on the displacement
	// Rotate the ball when the platform moves
	// Determine the direction of rotation based on the movement of the platform
	var rotationDirection = displacement < 0 ? 1 : -1;
	// Adjust the sensitivity of the ball's rotation to the platform's movement
	var rotationSensitivity = 0.0005; // Increase this value to enhance the ball's rotation
	// Calculate rotational inertia
	var rotationalInertia = Math.abs(displacement) * rotationSensitivity;
	// Apply rotational inertia to rotation angle
	ball.rotationAngle += rotationDirection * rotationalInertia;
	// Apply the rotation to the ball
	ball.rotation = ball.rotationAngle;
	// Correlate the ball's rotation with its horizontal movement
	// Determine the direction of movement based on the rotation of the ball
	var movementDirection = ball.rotationAngle < 0 ? 1 : -1;
	// Adjust the sensitivity of the ball's movement to its rotation
	var movementSensitivity = 0.01; // Increase this value to enhance the ball's movement
	// Calculate movement inertia
	var movementInertia = Math.abs(ball.rotationAngle) * movementSensitivity;
	// Apply movement inertia to horizontal velocity
	ball.velocityX = movementDirection * movementInertia;
	// Apply the horizontal velocity to the ball
	ball.x += ball.velocityX;
});