Upit | Learn about creating the game Sky Samur.ai with gen AI

Play

Sky Samur.ai

octo

SkySamurai

2.3K

7mo

Playit

Jump, dodge, survive!! Test your ninja reflexes in this addictive endless runner game. How high can you go?

#endlessrunner2024

#endlessrunner

#hypercasual

#ninja

#survival

#action

Creation History

User prompt

make the booster appears once every 5 arrays instead of 2

User prompt

add another sound for performing a jump called "jumping"

Code edit (1 edits merged)

Please save this source code

User prompt

When the player collects the booster, increase the player.immune counter, set player.alpha to 0.5, and start the timer for the blinking effect. Use a single timeout or interval to manage both the immunity period and the blinking phase. Example: 5 seconds of transparency (alpha = 0.5). 2 seconds of blinking (toggle alpha between 0.5 and 1 every 200 ms). After the 7 seconds, ensure the player.immune is decremented and alpha is reset to 1. Add a new boolean flag player.isBlinking to manage the blinking state separately. Update the player.update method to respect the blinking state and avoid overwriting the alpha property during blinking. Adjust the booster collection logic to set and manage the isImmune and isBlinking flags appropriately.

User prompt

When the player collects the booster, increase the player.immune counter, set player.alpha to 0.5, and start the timer for the blinking effect. Manage Immunity and Blinking Together: Use a single timeout or interval to manage both the immunity period and the blinking phase. Example: 5 seconds of transparency (alpha = 0.5). 2 seconds of blinking (toggle alpha between 0.5 and 1 every 200 ms). End Immunity Properly: After the 7 seconds, ensure the player.immune is decremented and alpha is reset to 1. Replace the numerical player.immune with a boolean player.isImmune to indicate whether the player is currently immune. Introduce a Blinking Flag: Add a new boolean flag player.isBlinking to manage the blinking state separately. Modify the Update Method: Update the player.update method to respect the blinking state and avoid overwriting the alpha property during blinking. Refactor Booster Collection Logic: Adjust the booster collection logic to set and manage the isImmune and isBlinking flags appropriately.

User prompt

make the booster appears once every 2 coin arrays instead of 5

User prompt

make the player's blinking effect last for the last 3 seconds instead of the last 2 seconds of the immunity, and have the transparency in the beginning for only 4 secodns instead of 5

User prompt

make the booster appears once every 2 arrays

User prompt

Use Boolean Flags: Replace the numerical player.immune with a boolean player.isImmune to indicate whether the player is currently immune. Introduce a Blinking Flag: Add a new boolean flag player.isBlinking to manage the blinking state separately. Modify the Update Method: Update the player.update method to respect the blinking state and avoid overwriting the alpha property during blinking. Refactor Booster Collection Logic: Adjust the booster collection logic to set and manage the isImmune and isBlinking flags appropriately.

User prompt

Collecting the Booster: When the player collects the booster, increase the player.immune counter, set player.alpha to 0.5, and start the timer for the blinking effect. Manage Immunity and Blinking Together: Use a single timeout or interval to manage both the immunity period and the blinking phase. Example: 5 seconds of transparency (alpha = 0.5). 2 seconds of blinking (toggle alpha between 0.5 and 1 every 200 ms). End Immunity Properly: After the 7 seconds, ensure the player.immune is decremented and alpha is reset to 1.

User prompt

the blinking effect doesn't work. after 5 seconds of normal transparency, the player's transparency should blink for the last 2 seconds of the booster's immunity effect to indicate it's wearing off

User prompt

add a visual indicator for when the immunity is wearing off, where the player is transparent for the first 5 seconds and blinks during the last 2 seconds. Immediately set player.alpha = 0.5 and increase the player.immune counter. Use LK.setTimeout to wait for 5 seconds before starting the blinking effect. After 5 seconds, start an interval (every 200 milliseconds) to toggle the player's alpha between 0.5 and 1. This creates the blinking effect. After the blinking effect lasts for 2 seconds, clear the blinking interval. Set player.immune-- and player.alpha = 1 to restore normal visibility.

User prompt

split the immunity transparency into 2 parts. right now the entire duration is 7 seconds. keep it that way, with the exception that you only maintain the ful transparency for the first 5 seconds, then the other 2 seconds, make the character blink, by alternative between the 505 transparency and fully visible. the immunity is still in effect for the entire 7 seconds, only the transaprency method is affected

User prompt

the blinking should only tart happening at the last 2 seconds before the immunity state is running off. right now it's happening across the entire duration

User prompt

during the last 2 seconds of invisibility, the player shoulb blink before turning back to fully visible. the blinking is an animation that alternates between the 50% trasnaprency and fully visible

User prompt

make the booster duration from 5 seconds to 7

User prompt

add a second sound effect when collecting the booster called invisible

User prompt

add a sound effect when collecting the booster

User prompt

make the booster appear once every 5 coin arrays instead every single one

Code edit (1 edits merged)

Please save this source code

User prompt

make the booster appear once every 1 array instead of every second

User prompt

the booster sometimes overlaps a cell that contains a coin. the booster needs to always be placed in a cell that does not contain a coin. so pick one of the empty cells in the array when you place the booster

/**** 
* Classes
****/ 
// Define the BackgroundContainer class
var BackgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	var backgroundGraphics1 = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2048 / 2732,
		scaleY: 2732 / 2732
	});
	backgroundGraphics1.x = 2048 / 2;
	backgroundGraphics1.y = 2732 / 2;
	var backgroundGraphics2 = self.attachAsset('background', {
		anchorX: 0.5,
		anchorY: 0.5,
		scaleX: 2048 / 2732,
		scaleY: 2732 / 2732
	});
	backgroundGraphics2.x = 2048 / 2;
	backgroundGraphics2.y = -2732 / 2;
	self.backgroundGraphics1 = backgroundGraphics1;
	self.backgroundGraphics2 = backgroundGraphics2;
	self.update = function () {
		if (gameStarted) {
			self.backgroundGraphics1.y -= backgroundSpeed;
			self.backgroundGraphics2.y -= backgroundSpeed;
			backgroundSpeed += backgroundAcceleration;
		}
		// Ensure backgrounds stay within bounds after jump movement
		if (self.backgroundGraphics1.y > 2732 / 2) {
			self.backgroundGraphics1.y = self.backgroundGraphics2.y - 2732;
		}
		if (self.backgroundGraphics2.y > 2732 / 2) {
			self.backgroundGraphics2.y = self.backgroundGraphics1.y - 2732;
		}
		if (self.backgroundGraphics1.y <= -2732 / 2) {
			self.backgroundGraphics1.y = self.backgroundGraphics2.y + 2732;
		}
		if (self.backgroundGraphics2.y <= -2732 / 2) {
			self.backgroundGraphics2.y = self.backgroundGraphics1.y + 2732;
		}
	};
	return self;
});
var Booster = Container.expand(function () {
	var self = Container.call(this);
	var boosterGraphics = self.attachAsset('booster', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = boosterGraphics.width;
	self.height = boosterGraphics.height;
	self.speed = 2;
	self.update = function () {
		self.speed += 0.05; // Acceleration
		self.y += self.speed;
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
// Define the Coin class
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinGraphics = self.attachAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = coinGraphics.width;
	self.height = coinGraphics.height;
	self.speed = 2;
	self.animationFrames = [LK.getAsset('coin', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_2', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_3', {
		anchorX: 0.5,
		anchorY: 0.5
	}), LK.getAsset('coin_2', {
		anchorX: 0.5,
		anchorY: 0.5
	})];
	self.currentFrame = 0;
	self.frameDuration = 144; // 300 milliseconds per frame
	self.lastFrameChange = Date.now();
	self.update = function () {
		self.speed += 0.05; // Acceleration
		self.y += self.speed;
		// Handle animation frame change
		if (Date.now() - self.lastFrameChange >= self.frameDuration) {
			self.currentFrame = (self.currentFrame + 1) % self.animationFrames.length;
			self.removeChildAt(0);
			self.addChild(self.animationFrames[self.currentFrame]);
			self.lastFrameChange = Date.now();
		}
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
// Define the ForegroundContainer class
var ForegroundContainer = Container.expand(function () {
	var self = Container.call(this);
	return self;
});
// Define the MidgroundContainer class
var MidgroundContainer = Container.expand(function () {
	var self = Container.call(this);
	return self;
});
// Define the Obstacle class
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	var obstacleGraphics = self.attachAsset('obstacle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = obstacleGraphics.width;
	self.height = obstacleGraphics.height;
	self.speed = 5;
	self.rotationSpeed = Math.random() < 0.5 ? 0.03 : -0.03; // Randomly decide rotation direction
	self.update = function () {
		self.speed += 0.2; // Acceleration
		self.y += self.speed;
		self.rotation += self.rotationSpeed; // Add rotation
		if (self.y > 2732 + self.height / 2) {
			self.destroy();
		}
	};
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = platformGraphics.width;
	self.height = platformGraphics.height;
	self.update = function () {
		if (gameStarted) {
			self.y += 30;
			if (self.y > 2732 + self.height / 2) {
				self.destroy();
			}
		}
	};
	return self;
});
//<Assets used in the game will automatically appear here>
// Define the Player class
var Player = Container.expand(function () {
	var self = Container.call(this);
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerGraphics.visible = false;
	var playerIdleGraphics = self.attachAsset('player_idle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerIdleGraphics.visible = true;
	self.playerWidth = playerGraphics.width;
	self.playerHeight = playerGraphics.height;
	self.playerIdleWidth = playerIdleGraphics.width;
	self.playerIdleHeight = playerIdleGraphics.height;
	self.speed = playerHorizontalSpeed;
	self.slidingSpeed = playerSlidingSpeed; // Add sliding speed property
	self.direction = 1; // 1: right, -1: left
	self.isTouchingWall = true; // true: player is touching a wall, false: player is in mid air
	self.update = function () {
		if (gameStarted) {
			if (!self.isBlinking) {
				self.alpha = self.immune > 0 ? 0.5 : 1;
			}
			if (self.direction === -1 && self.x > self.playerWidth / 2 - 60) {
				self.x -= self.speed;
				if (self.x <= self.playerWidth / 2 - 60) {
					self.x = self.playerWidth / 2 - 60; // Prevent the player from going past the left edge of the screen
					self.isTouchingWall = true;
					playerGraphics.scale.x = -1; // Flip the player's x axis
				}
			} else if (self.direction === 1 && self.x < 2048 - self.playerWidth / 2 + 60) {
				self.x += self.speed;
				if (self.x >= 2048 - self.playerWidth / 2 + 60) {
					self.x = 2048 - self.playerWidth / 2 + 60; // Prevent the player from going past the right edge of the screen
					self.isTouchingWall = true;
					playerGraphics.scale.x = 1; // Flip the player's x axis back to its original state
				}
			}
			self.y += self.verticalSpeed; // Apply the vertical speed to the player's position
			if (self.y < 0) {
				// Prevent the player from going off the top of the screen
				self.y = 0;
				self.verticalSpeed = 0;
			}
			// Removed game over check in the player update method
			if (self.isTouchingWall) {
				// Reset the vertical speed and apply the sliding speed when the player touches a wall
				self.verticalSpeed = 0;
				self.slidingSpeed += playerSlidingAcceleration;
				self.y += self.slidingSpeed;
			}
		}
	};
	self.immune = false; // Add a new property to the player to make it immune to spikes
	self.isBlinking = false; // Add a new property to manage the blinking state
	self.jump = function () {
		if (self.isTouchingWall) {
			if (!gameStarted) {
				gameStarted = true;
				firstJump = true; // Set the firstJump flag to true after the first jump
			}
			self.direction *= -1;
			self.verticalSpeed = -playerVerticalJumpSpeed; // Set the vertical speed when jumping
			self.slidingSpeed = playerSlidingSpeed; // Reset the sliding speed
			self.isTouchingWall = false;
			playerGraphics.visible = true;
			playerIdleGraphics.visible = false;
			// Move backgrounds down by 200 pixels
			backgroundContainer.backgroundGraphics1.y += 300;
			backgroundContainer.backgroundGraphics2.y += 300;
			// Move forest down by 100 pixels
			forest.y += 300;
			// Reset background speed
			backgroundSpeed = initialBackgroundSpeed;
			// Move all spikes down by 500 pixels
			for (var i = 0; i < spikes.length; i++) {
				spikes[i].y += spikeMovement;
			}
			// Reset the spikes' upwards movement speed
			spikeUpwardsMovement = spikeSpeed;
			self.immune++; // Increment immunity to spikes after jumping
			LK.setTimeout(function () {
				// Set a timeout to remove the immunity after half a second
				self.immune--;
			}, 100);
			spawnObstacle(); // Spawn a new obstacle whenever the player jumps
		}
	};
	return self;
});
// Define the Spike class
var Spike = Container.expand(function () {
	var self = Container.call(this);
	var spikeGraphics = self.attachAsset('spikes', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.width = spikeGraphics.width;
	self.height = spikeGraphics.height;
	self.hasMoved = false; // Add hasMoved flag
	self.update = function () {
		if (self.y > 2732 + self.height / 2 + 500) {
			self.destroy();
		}
		if (player.isTouchingWall) {
			self.y -= spikeSpeed;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Function to check score and start spike intervals
function checkAndStartSpikes() {
	if (LK.getScore() >= scoreThreshold && !spikeInterval && gameStarted) {
		spikeInterval = LK.setInterval(spawnSpike, spikeIntervalTime);
	}
}
// Declare global variables for background speed and acceleration
var initialBackgroundSpeed = 1;
var backgroundSpeed = initialBackgroundSpeed;
var backgroundAcceleration = 0.02;
var firstJump = false; // Flag to track the first jump
// Declare a global variable to track if the game has started
var gameStarted = false;
// Initialize BackgroundContainer, MidgroundContainer, and ForegroundContainer
var backgroundContainer = game.addChild(new BackgroundContainer());
var midgroundContainer = game.addChild(new MidgroundContainer());
var foregroundContainer = game.addChild(new ForegroundContainer());
var playerVerticalJumpSpeed = 20;
// Declare global variables for player's horizontal, vertical and sliding speed
var playerHorizontalSpeed = 80;
var playerSlidingSpeed = 1;
var playerSlidingAcceleration = 0.02;
// Declare a global variable to track if the game has started
var gameStarted = false;
// Declare global variables for the spikes movement, their upwards movement and their acceleration
var spikeMovement = 500;
var spikeUpwardsMovement = 10;
var spikeAcceleration = 0.02;
// Declare global variables for spike interval and score threshold
var spikeIntervalTime = 15000;
var scoreThreshold = 10;
// Initialize player
var player = foregroundContainer.addChild(new Player());
player.immune = 0; // Add a new property to the player to make it immune to spikes
// Add forest asset to the midground container
var forest = LK.getAsset('forest', {
	anchorX: 0.5,
	anchorY: 0,
	scaleX: 1,
	scaleY: 1,
	x: 2048 / 2,
	y: 2732 / 2
});
midgroundContainer.addChild(forest);
// Initialize platform and place it below the player_idle
var platform = midgroundContainer.addChild(new Platform());
platform.x = 2048 / 2;
platform.y = 2732 - 500 + player.playerIdleHeight / 2 + platform.height / 2;
// Initialize coins array
var coins = [];
// Track the number of coin arrays generated
var coinArrayCounter = 0;
// Initialize spikes array
var spikes = [];
// Set the direction at the start of the game
var spikePlacementFlag = Math.random() < 0.5 ? true : false;
// Initialize the first spike (Removed initial spike generation)
player.verticalSpeed = 0;
player.x = 2048 / 2;
player.y = 2732 - 430;
// Initialize obstacles array
var obstacles = [];
// Function to spawn obstacles
function spawnObstacle() {
	if (gameStarted) {
		var obstacle = new Obstacle();
		obstacle.x = Math.random() * (2048 - 800) + 400; // Add padding to the enemy spawner
		obstacle.y = -obstacle.height / 2;
		obstacles.push(obstacle);
		game.addChild(obstacle);
	}
}
// Function to spawn coins
function spawnCoins() {
	// Define the 18 available spots
	var spots = [];
	for (var i = 0; i < 3; i++) {
		for (var j = 0; j < 6; j++) {
			spots.push({
				x: j * (150 + 100) + 400,
				y: i * (150 + 50) - 500
			});
		}
	}
	// Shuffle the spots array
	for (var i = spots.length - 1; i > 0; i--) {
		var j = Math.floor(Math.random() * (i + 1));
		var temp = spots[i];
		spots[i] = spots[j];
		spots[j] = temp;
	}
	// Generate a random number of coins (between 4 and 9) in random spots
	var numCoins = Math.floor(Math.random() * 8) + 5;
	for (var i = 0; i < numCoins; i++) {
		var coin = new Coin();
		coin.x = spots[i].x;
		coin.y = spots[i].y;
		coins.push(coin);
		game.addChild(coin);
	}
	// Increment the coin array counter
	coinArrayCounter++;
	// Add booster to a random spot every 5 coin array generations
	if (coinArrayCounter % 5 === 0) {
		var booster = new Booster();
		// Find an empty spot for the booster
		var emptySpots = spots.slice(numCoins); // Get the remaining spots after placing coins
		var randomEmptySpot = Math.floor(Math.random() * emptySpots.length);
		booster.x = emptySpots[randomEmptySpot].x;
		booster.y = emptySpots[randomEmptySpot].y;
		coins.push(booster);
		game.addChild(booster);
	}
}
// Function to spawn spikes
function spawnSpike() {
	var spike = new Spike();
	spike.x = spikePlacementFlag ? spike.width / 2 : 2048 - spike.width / 2; // Attach to the wall based on the flag
	spike.y = -spike.height / 2;
	if (spike.x === 2048 - spike.width / 2) {
		// If the spike is on the right wall
		spike.scale.x = -1; // Flip the spike on its x axis
	}
	spikes.push(spike);
	game.addChild(spike);
	spikePlacementFlag = !spikePlacementFlag; // Flip the flag after each spike placement
}
// Initialize score text
var scoreTxt = new Text2('0', {
	size: 150,
	fill: "#ffffff",
	stroke: "#000000",
	strokeThickness: 15
});
scoreTxt.anchor.set(0.5, 0); // Sets anchor to the center of the top edge of the text.
scoreTxt.y -= 950; // Move the score 500 pixels higher
LK.gui.center.addChild(scoreTxt); // Add the score text to the GUI overlay.
// Set interval to spawn spikes and coins
var coinInterval;
var spikeInterval;
checkAndStartSpikes();
// Handle touch events
game.down = function (x, y, obj) {
	if (!gameStarted) {
		gameStarted = true;
		player.direction = Math.random() < 0.5 ? -1 : 1;
		LK.playMusic('background_music');
		// Spawn coins immediately after the first jump
		spawnCoins();
		// Start generating coins after the set interval
		coinInterval = LK.setInterval(spawnCoins, 3500);
		// Start generating spikes after the score threshold
		checkAndStartSpikes();
	}
	player.jump();
	// Play a sound effect when the player jumps
	LK.getSound('jump').play();
	LK.getSound('jumping').play();
};
game.up = function (x, y, obj) {
	// No operations needed here
};
// Update game logic
game.update = function () {
	if (gameStarted) {
		backgroundContainer.update();
		player.update();
		if (player.y > 2732 - player.height / 2) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		}
		platform.update();
		forest.y -= 2; // Move the forest upwards by 1 pixel
		if (forest.y < -forest.height) {
			forest.destroy();
		}
		for (var i = obstacles.length - 1; i >= 0; i--) {
			obstacles[i].update();
			if (player.intersects(obstacles[i]) && player.immune <= 0) {
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
		for (var i = coins.length - 1; i >= 0; i--) {
			coins[i].update();
			if (coins[i].y > 2732 + coins[i].height / 2) {
				coins[i].destroy();
				coins.splice(i, 1);
			}
			if (player.intersects(coins[i])) {
				if (coins[i] instanceof Booster) {
					player.immune++;
					player.alpha = 0.5;
					player.isBlinking = false;
					LK.getSound('booster').play(); // Play booster sound effect
					LK.getSound('invisible').play(); // Play invisible sound effect
					// Start the immunity and blinking timer
					var immunityDuration = 4600; // 5 seconds of transparency
					var blinkingDuration = 2400; // 2 seconds of blinking
					var blinkingInterval = 200; // Toggle alpha every 200 ms
					// Set timeout for the transparency period
					LK.setTimeout(function () {
						player.isBlinking = true;
						var blinkTimer = LK.setInterval(function () {
							player.alpha = player.alpha === 0.5 ? 1 : 0.5;
						}, blinkingInterval);
						// Set timeout for the blinking period
						LK.setTimeout(function () {
							LK.clearInterval(blinkTimer);
							player.immune--;
							player.alpha = 1;
							player.isBlinking = false;
						}, blinkingDuration);
					}, immunityDuration);
				} else {
					LK.setScore(LK.getScore() + 1);
					scoreTxt.setText(LK.getScore());
					LK.getSound('coin').play();
				}
				coins[i].destroy();
				coins.splice(i, 1);
				spawnObstacle();
				checkAndStartSpikes();
			}
		}
		for (var i = spikes.length - 1; i >= 0; i--) {
			if (player.intersects(spikes[i]) && player.immune <= 0) {
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
	}
};
var spikeSpeed = 3;

===================================================================
--- original.js
+++ change.js
@@ -379,10 +379,10 @@
 		game.addChild(coin);
 	}
 	// Increment the coin array counter
 	coinArrayCounter++;
-	// Add booster to a random spot every 2 coin array generations
-	if (coinArrayCounter % 2 === 0) {
+	// Add booster to a random spot every 5 coin array generations
+	if (coinArrayCounter % 5 === 0) {
 		var booster = new Booster();
 		// Find an empty spot for the booster
 		var emptySpots = spots.slice(numCoins); // Get the remaining spots after placing coins
 		var randomEmptySpot = Math.floor(Math.random() * emptySpots.length);