/****
* 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 - 10; // 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: 20 // 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 = -20; // 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;
score += 1;
scoreText.setText(score.toString());
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;
});
perfectly round basketball ball. pixelated. 8 bit.. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.
Create an image of a basketball player's hand, focusing on the hand only without showing the entire arm. The hand should be positioned with the index finger extended upwards. pixelated. 8 bit.. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.
basketball court background seen from the perspective of a player. pixelated. 8 bit. Single Game Texture. In-Game asset. 2d. Blank background. High contrast. No shadows.