/**** 
* 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 a flip timer for the ball
		self.flipTimer = 0;
		// Update method to include timed flipping
		self.update = function () {
			self.velocityY += self.gravity;
			self.y += self.velocityY;
			var movementDirection = self.rotationAngle < 0 ? -1 : 1;
			var baseSensitivity = 1;
			var dynamicSensitivityAdjustment = 0.1;
			var movementSensitivity = baseSensitivity + dynamicSensitivityAdjustment;
			var movementInertia = Math.abs(self.rotationAngle) * movementSensitivity;
			self.velocityX = movementDirection * movementInertia;
			self.x += self.velocityX;
			// Update flip timer and flip ball graphic every second
			self.flipTimer += 1 / 5; // Assuming game runs at 60 FPS
			if (self.flipTimer >= 1) {
				ballGraphics.scale.x *= -1; // Flip the ball graphic
				self.flipTimer = 0; // Reset timer
			}
		};
	};
});
// 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 background image to the game, stretching it to fill the entire screen
var background = LK.getAsset('background', {
	anchorX: 0.0,
	// Anchor to the top-left corner
	anchorY: 0.0,
	// Anchor to the top-left corner
	x: 0,
	// Position at the top-left corner
	y: 0,
	// Position at the top-left corner
	scaleX: game.width / 2048,
	// Scale horizontally to fill the screen
	scaleY: game.height / 2048 // Scale vertically to fill the screen
});
game.addChild(background);
// Initialize score and add score text to the screen
var score = 0; // Initialize score variable
var scoreCountingStarted = false; // Flag to track if score counting has started
var scoreText = new Text2(score.toString(), {
	size: 250,
	fill: "#ffffff",
	// White color for better visibility
	stroke: "#000000",
	// Black color for the outline
	strokeThickness: 10 // Outline thickness
});
// Position the score text at the top center of the screen
scoreText.anchor.set(0.5, 0); // Center the text horizontally
scoreText.x = 1024; // Center horizontally in the game view
scoreText.y = 50; // Position at the top with some margin
// Add the score text to the game
game.addChild(scoreText);
// Add the new rectangle asset to the game
var centerRectangle = LK.getAsset('centerRectangle', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 1024,
	y: 1850,
	alpha: 0 // Make the rectangle invisible
});
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 = 2222; // 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;
	// Start score counting when the player moves the platform for the first time
	// Moved score counting start condition inside the platform movement check to ensure it starts after the first movement
	if (!scoreCountingStarted && platform.x !== oldPlatformX) {
		scoreCountingStarted = true;
		LK.setInterval(function () {
			score += 1;
			scoreText.setText(score.toString());
		}, 1000);
	}
	// Calculate the displacement of the platform from the center of the screen
	var displacement = platform.x - 1024;
	// Correct the logic for determining the direction of the ball's rotation based on the platform's position relative to the ball's center
	var rotationDirection = platform.x > ball.x ? -1 : 1; // Rotate clockwise if platform's middle is to the left of the ball's center, and vice versa
	// Adjust the sensitivity of the ball's rotation to the platform's movement
	var rotationSensitivity = 0.00025 + score * 0.00001; // Increase rotationSensitivity by 0.1 for each score increment
	// Calculate rotational inertia based on the absolute value of displacement
	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;
});