Upit | Learn about creating the game Max vs Monsters with gen AI

Play

Max vs Monsters

blackwidowink

MaxVsMonsters

227

Playit

Become the legendary treasure hunter, Maximillion, and delve deep into monster lairs to plunder their gold and jewels. Swipe/drag up to jump, twice for double jump, swipe/drag right for slide, tap/click to perform a slash attack. Swipe down to drop down to lower platforms. Swipe left to fire bow. Run. Fight. Treasure. Repeat. Remixed for the #YusufRemixChallenge.

#YusufRemixChallenge

#Endless

#Runner

#Treasure

#Monsters

Creation History

Code edit (4 edits merged)

Please save this source code

User prompt

Update with: var dieFrame = Math.min(Math.floor(((30 - self.deathTimer) * 2.7) / 20), self.dieAnimation.length - 1);

Code edit (5 edits merged)

Please save this source code

User prompt

Update as needed with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 35; // Increased from 25 for more distance self.throwBackDistance = 0; self.hitTimer = 20; } }; // In the isDying section, adjust the frame timing: var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 10), self.dieAnimation.length - 1); // Changed from 7.5 to 10 for slower animation

User prompt

Update as needed with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 25; self.throwBackDistance = 0; self.hitTimer = 20; // Removed all vertical velocity/offset variables } }; // In the isDying section, remove all vertical movement code and just keep: if (self.isDying) { // Continue throw back during death self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1); self.sprites[dieOffset + dieFrame].alpha = 1; self.deathTimer--; if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } }

Code edit (1 edits merged)

Please save this source code

User prompt

Update as needed with: self.isDying = true; self.deathTimer = 30; self.verticalSpeed = -25; // Increased from -15 for more height // And in the isDying section: self.verticalSpeed += 0.5; // Reduced from 0.8 for slower fall

Code edit (1 edits merged)

Please save this source code

User prompt

Update only as needed with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 25; self.throwBackDistance = 0; self.hitTimer = 20; self.verticalOffset = 0; // Add to track vertical position change } }; self.update = function () { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Decrease hit timer self.hitTimer--; // Once hit timer expires, start death animation if (self.hitTimer <= 0) { self.isHit = false; self.isDying = true; self.deathTimer = 30; self.verticalSpeed = -15; // Add upward speed at death start } } else if (self.isDying) { // Continue throw back during death self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Handle vertical movement self.verticalOffset += self.verticalSpeed; self.verticalSpeed += 0.8; // Add gravity self.y += self.verticalSpeed; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1); self.sprites[dieOffset + dieFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } else { // Original movement and animation code... } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update as needed with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 25; // Increased from 15 self.throwBackDistance = 0; self.hitTimer = 20; // Added hit timer for longer hit frame } }; self.update = function () { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Slower decay than 0.9 // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Decrease hit timer self.hitTimer--; // Once hit timer expires, start death animation if (self.hitTimer <= 0) { self.isHit = false; self.isDying = true; self.deathTimer = 30; // About half a second at 60fps } } else if (self.isDying) { // Continue throw back during death self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1); self.sprites[dieOffset + dieFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } else { // Original movement and animation code... } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 25; self.throwBackDistance = 0; self.hitTimer = 20; // Increased from 10 to 20 for longer hit frame display (about 1/3 second) } }; self.update = function () { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Continue throwback self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Decrease hit timer self.hitTimer--; // Transition to death animation if (self.hitTimer <= 0) { self.isHit = false; self.isDying = true; self.deathFrame = 0; // Track death animation frame explicitly self.frameTimer = 7; // Control frame timing } } else if (self.isDying) { // Continue throwback during death animation self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Handle death animation with explicit frame control var dieOffset = self.runAnimation.length + self.hitAnimation.length; self.sprites[dieOffset + self.deathFrame].alpha = 1; // Control frame timing self.frameTimer--; if (self.frameTimer <= 0) { self.deathFrame++; self.frameTimer = 7; // Reset frame timer // When we reach the last frame, hold it for 30 frames (0.5 seconds) if (self.deathFrame >= self.dieAnimation.length) { self.deathFrame = self.dieAnimation.length - 1; self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } } else { // Original movement and animation code... } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update as needed with: self.hit = function () { if (!self.isHit && !self.isDying) { self.isHit = true; self.throwBackSpeed = 25; // Increased from 15 for stronger throwback self.throwBackDistance = 0; // Remove the velocityY change since animation will handle vertical movement self.hitTimer = 10; // Short hit animation duration (about 1/6 second at 60fps) } }; self.update = function () { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Continue throwback throughout hit and death animations self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.95; // Slower decay for longer throwback // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Decrease hit timer self.hitTimer--; // Transition to death animation sooner if (self.hitTimer <= 0) { self.isHit = false; self.isDying = true; self.deathTimer = 30; // Half second hold at 60fps } } else if (self.isDying) { // Continue throwback during death animation self.x += self.throwBackSpeed; self.throwBackSpeed *= 0.95; // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1); self.sprites[dieOffset + dieFrame].alpha = 1; // Only start counting down death timer when we reach last frame if (dieFrame === self.dieAnimation.length - 1) { self.deathTimer--; } // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } else { // Original movement and animation code... } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update as needed with: self.update = function() { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += Math.abs(self.throwBackSpeed); self.throwBackSpeed *= 0.9; // Slow down the throw // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Once throw back is complete, start death animation if (self.throwBackDistance >= self.maxThrowBack || Math.abs(self.throwBackSpeed) < 0.1) { self.isHit = false; self.isDying = true; self.deathTimer = 30; // About half a second at 60fps console.log("Transitioning to death animation"); // Debug log } } else if (self.isDying) { // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1); console.log("Death animation frame:", dieFrame); // Debug log self.sprites[dieOffset + dieFrame].alpha = 1; // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } else { // Original movement and run animation code... self.x -= self.speed; if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; if (!self.checkPlatformCollision()) { // Let them fall if not on platform } } if (self.type === 'goblin') { self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; } } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

Code edit (1 edits merged)

Please save this source code

User prompt

Update with: // In game.update, modify the enemy collision check for (var j = enemies.length - 1; j >= 0; j--) { enemies[j].update(); var playerBounds = player.getBounds(); var enemyBounds = enemies[j].getBounds(); if (playerBounds.left < enemyBounds.right && playerBounds.right > enemyBounds.left && playerBounds.top < enemyBounds.bottom && playerBounds.bottom > enemyBounds.top) { if (player.isAttacking) { // Hit the enemy if player is attacking enemies[j].hit(); // Add score if not already passed if (!enemies[j].passed) { enemies[j].passed = true; LK.setScore(LK.getScore() + 1); scoreText.setText(LK.getScore()); } } else if (!enemies[j].isHit && !enemies[j].isDying) { // Only die from enemy touch if enemy isn't already hit/dying LK.effects.flashScreen(0xff0000, 1000); LK.showGameOver(); } } else if (player.x > enemies[j].x && !enemies[j].passed) { enemies[j].passed = true; LK.setScore(LK.getScore() + 1); scoreText.setText(LK.getScore()); } }

Code edit (11 edits merged)

Please save this source code

User prompt

Update with: self.update = function() { // Hide all sprites first for (var i = 0; i < self.sprites.length; i++) { self.sprites[i].alpha = 0; } if (self.isHit) { // Handle throw back motion self.x += self.throwBackSpeed; self.throwBackDistance += self.throwBackSpeed; self.throwBackSpeed *= 0.9; // Slow down the throw // Show hit animation var hitOffset = self.runAnimation.length; self.sprites[hitOffset].alpha = 1; // Once throw back is complete, start death animation if (self.throwBackDistance >= self.maxThrowBack) { self.isHit = false; self.isDying = true; self.deathTimer = 30; // About half a second at 60fps } } else if (self.isDying) { // Handle death animation var dieOffset = self.runAnimation.length + self.hitAnimation.length; var dieFrame = Math.floor((30 - self.deathTimer) / 7.5); // 30 frames / 4 animations ≈ 7.5 if (dieFrame < self.dieAnimation.length) { self.sprites[dieOffset + dieFrame].alpha = 1; } // Count down death timer self.deathTimer--; // After timer expires, fade out if (self.deathTimer <= 0) { self.alpha -= 0.1; if (self.alpha <= 0) { self.destroy(); } } } else { // Original movement and animation code // Move left self.x -= self.speed; // Original platform and gravity code if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; if (!self.checkPlatformCollision()) { // Let them fall if not on platform } } // Handle run animation if (self.type === 'goblin') { self.animationCounter += self.animationSpeed; if (self.animationCounter >= 1) { self.animationCounter = 0; self.runFrame = (self.runFrame + 1) % self.runAnimation.length; } self.sprites[self.runFrame].alpha = 1; } } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update with: if (self.type === 'goblin') { // Setup all animations self.runAnimation = ['goblinrun1', 'goblinrun2', 'goblinrun3', 'goblinrun4', 'goblinrun5', 'goblinrun6', 'goblinrun7', 'goblinrun8']; // Pre-attach all animation frames // Run animation for (var i = 0; i < self.runAnimation.length; i++) { var sprite = self.attachAsset(self.runAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = i === 0 ? 1 : 0; self.sprites.push(sprite); } // Hit animation for (var i = 0; i < self.hitAnimation.length; i++) { var sprite = self.attachAsset(self.hitAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } // Die animation for (var i = 0; i < self.dieAnimation.length; i++) { var sprite = self.attachAsset(self.dieAnimation[i], { anchorX: 0.5, anchorY: 0.5 }); sprite.alpha = 0; self.sprites.push(sprite); } }

Code edit (1 edits merged)

Please save this source code

User prompt

Update with: self.update = function() { // Move left self.x -= self.speed; // Handle platform-based movement if (self.currentPlatform) { var platformHalfWidth = 500; var stillOnPlatform = self.x > self.currentPlatform.x - platformHalfWidth && self.x < self.currentPlatform.x + platformHalfWidth; if (!stillOnPlatform) { self.isOnGround = false; self.currentPlatform = null; self.velocityY = 0.1; // Start falling with a small initial velocity } } // Apply gravity if not on ground if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; // Check for ANY platform collision while falling var foundPlatform = false; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; var platformHalfWidth = 500; if (self.x >= platform.x - platformHalfWidth && self.x <= platform.x + platformHalfWidth && self.y <= platform.y - ENEMY_PLATFORM_OFFSET && self.y + self.velocityY >= platform.y - ENEMY_PLATFORM_OFFSET) { // Land on this platform self.y = platform.y - ENEMY_PLATFORM_OFFSET; self.isOnGround = true; self.currentPlatform = platform; self.velocityY = 0; foundPlatform = true; break; } } // Only check for ground if no platform was found and we want ground behavior // Remove this section to let enemies fall off the screen } // Handle animations for goblin if (self.type === 'goblin') { // Animation code remains unchanged } // Destroy if off screen if (self.x < -50 || self.y > 2732) { self.destroy(); } };

User prompt

Update with: self.checkPlatformCollision = function() { var onAnyPlatform = false; var platformHalfWidth = 500; for (var i = 0; i < platforms.length; i++) { var platform = platforms[i]; var leftEdge = platform.x - platformHalfWidth; var rightEdge = platform.x + platformHalfWidth; // Check if enemy is above the platform and falling down toward it if (self.x >= leftEdge && self.x <= rightEdge && self.velocityY > 0 && // Must be falling down self.y < platform.y - ENEMY_PLATFORM_OFFSET && self.y + self.velocityY >= platform.y - ENEMY_PLATFORM_OFFSET) { // Landing on the platform onAnyPlatform = true; self.currentPlatform = platform; self.y = platform.y - ENEMY_PLATFORM_OFFSET; self.isOnGround = true; self.velocityY = 0; return true; } } return false; };

User prompt

Update with: if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; // Check for platform collision while falling if (!self.checkPlatformCollision()) { // Remove the ground check - no more ground reset // Let them continue falling if they don't hit a platform } }

User prompt

Update with: if (!self.isOnGround) { self.velocityY += 0.7; self.y += self.velocityY; // Check for platform collision while falling self.checkPlatformCollision(); // No ground collision check - let them fall off screen }

Code edit (1 edits merged)

Please save this source code

User prompt

Update with: enemySpawnCounter++; if (enemySpawnCounter >= enemySpawnInterval) { // Only spawn enemies if there are valid platforms available var availablePlatforms = platforms.filter(function(p) { // Look for platforms that are just off-screen to the right return p.x > 2048 - 100 && p.x < 2048 + 300; }); // Only spawn an enemy if we have a platform to put it on if (availablePlatforms.length > 0) { var enemy = new Enemy('goblin'); var platform = availablePlatforms[Math.floor(Math.random() * availablePlatforms.length)]; enemy.x = platform.x; // Spawn directly above the platform enemy.y = platform.y - ENEMY_PLATFORM_OFFSET; enemy.currentPlatform = platform; enemies.push(enemy); game.addChild(enemy); enemySpawnInterval = Math.floor(Math.random() * 150) + 100; // Slightly longer intervals enemySpawnCounter = 0; } else { // No valid platforms, just reset counter but don't spawn enemySpawnCounter = Math.max(0, enemySpawnCounter - 20); // Back up a bit to try again soon } }

/**** 
* Classes
****/ 
var Enemy = Container.expand(function (type) {
	var self = Container.call(this);
	// Enemy properties
	self.type = type || 'basic';
	self.speed = 7;
	self.isOnGround = true;
	self.velocityY = 0;
	self.currentPlatform = null;
	self.groundY = 2732 / 1.5; // Same as player ground Y
	self.hitAnimation = ['goblinhit1'];
	self.dieAnimation = ['goblindie1', 'goblindie2', 'goblindie3', 'goblindie4'];
	self.isHit = false;
	self.isDying = false;
	self.deathTimer = 0;
	self.throwBackSpeed = 15; // Initial backwards throw speed
	self.throwBackDistance = 0; // Track distance thrown
	self.maxThrowBack = 200; // Maximum throw back distance
	// Add bounding box properties
	self.hitboxWidth = 200; // Smaller than the 150px sprite width
	self.hitboxHeight = 260; // Adjusted for goblin height
	// Animation properties for goblin
	self.runAnimation = [];
	self.runFrame = 0;
	self.animationSpeed = 0.08;
	self.animationCounter = 0;
	self.sprites = [];
	// Initialize based on enemy type
	if (self.type === 'goblin') {
		// Setup all animations
		self.runAnimation = ['goblinrun1', 'goblinrun2', 'goblinrun3', 'goblinrun4', 'goblinrun5', 'goblinrun6', 'goblinrun7', 'goblinrun8'];
		// Pre-attach all animation frames
		// Run animation
		for (var i = 0; i < self.runAnimation.length; i++) {
			var sprite = self.attachAsset(self.runAnimation[i], {
				anchorX: 0.5,
				anchorY: 0.5
			});
			sprite.alpha = i === 0 ? 1 : 0;
			self.sprites.push(sprite);
		}
		// Hit animation
		for (var i = 0; i < self.hitAnimation.length; i++) {
			var sprite = self.attachAsset(self.hitAnimation[i], {
				anchorX: 0.5,
				anchorY: 0.5
			});
			sprite.alpha = 0;
			self.sprites.push(sprite);
		}
		// Die animation
		for (var i = 0; i < self.dieAnimation.length; i++) {
			var sprite = self.attachAsset(self.dieAnimation[i], {
				anchorX: 0.5,
				anchorY: 0.5
			});
			sprite.alpha = 0;
			self.sprites.push(sprite);
		}
	} else {
		// Basic enemy (original version)
		var enemyGraphics = self.attachAsset('enemy', {
			anchorX: 0.5,
			anchorY: 0.5
		});
	}
	self.checkPlatformCollision = function () {
		var onAnyPlatform = false;
		var platformHalfWidth = 500;
		for (var i = 0; i < platforms.length; i++) {
			var platform = platforms[i];
			var leftEdge = platform.x - platformHalfWidth;
			var rightEdge = platform.x + platformHalfWidth;
			// First check if we're on a platform (exact position check)
			if (self.x >= leftEdge && self.x <= rightEdge) {
				if (Math.abs(self.y - (platform.y - ENEMY_PLATFORM_OFFSET)) < 5) {
					onAnyPlatform = true;
					self.currentPlatform = platform;
					self.y = platform.y - ENEMY_PLATFORM_OFFSET;
					self.isOnGround = true;
					self.velocityY = 0;
					return true;
				}
				// NEW CODE: Check for passing through platform during fall
				// This detects if the enemy will cross the platform in the next frame
				if (self.velocityY > 0 &&
				// Must be falling down
				self.y < platform.y - ENEMY_PLATFORM_OFFSET && self.y + self.velocityY >= platform.y - ENEMY_PLATFORM_OFFSET) {
					self.y = platform.y - ENEMY_PLATFORM_OFFSET;
					self.velocityY = 0;
					self.isOnGround = true;
					self.currentPlatform = platform;
					return true;
				}
			}
		}
		return false;
	};
	// Update collision check method
	self.getBounds = function () {
		return {
			left: self.x - self.hitboxWidth / 2,
			right: self.x + self.hitboxWidth / 2,
			top: self.y - self.hitboxHeight / 2,
			bottom: self.y + self.hitboxHeight / 2
		};
	};
	self.hit = function () {
		if (!self.isHit && !self.isDying) {
			self.isHit = true;
			self.throwBackSpeed = 35; // Increased from 25 for more distance
			self.throwBackDistance = 0;
			self.hitTimer = 20; // Added hit timer for longer hit frame
			// Removed vertical velocity/offset variables
		}
	};
	self.update = function () {
		// Hide all sprites first
		for (var i = 0; i < self.sprites.length; i++) {
			self.sprites[i].alpha = 0;
		}
		if (self.isHit) {
			// Handle throw back motion
			self.x += self.throwBackSpeed;
			self.throwBackDistance += Math.abs(self.throwBackSpeed);
			self.throwBackSpeed *= 0.95; // Slower decay than 0.9
			// Show hit animation
			var hitOffset = self.runAnimation.length;
			self.sprites[hitOffset].alpha = 1;
			// Decrease hit timer
			self.hitTimer--;
			// Once hit timer expires, start death animation
			if (self.hitTimer <= 0) {
				self.isHit = false;
				self.isDying = true;
				self.deathTimer = 30; // About half a second at 60fps
			}
		} else if (self.isDying) {
			// Continue throw back during death
			self.x += self.throwBackSpeed;
			self.throwBackSpeed *= 0.95;
			// Removed vertical movement code
			// Handle death animation
			var dieOffset = self.runAnimation.length + self.hitAnimation.length;
			var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 10), self.dieAnimation.length - 1); // Changed from 7.5 to 10 for slower animation
			self.sprites[dieOffset + dieFrame].alpha = 1;
			// Count down death timer
			self.deathTimer--;
			// After timer expires, fade out
			if (self.deathTimer <= 0) {
				self.alpha -= 0.1;
				if (self.alpha <= 0) {
					self.destroy();
				}
			}
		} else {
			// Original movement and animation code
			// Move left
			self.x -= self.speed;
			// Original platform and gravity code
			if (!self.isOnGround) {
				self.velocityY += 0.7;
				self.y += self.velocityY;
				if (!self.checkPlatformCollision()) {
					// Let them fall if not on platform
				}
			}
			// Handle run animation
			if (self.type === 'goblin') {
				self.animationCounter += self.animationSpeed;
				if (self.animationCounter >= 1) {
					self.animationCounter = 0;
					self.runFrame = (self.runFrame + 1) % self.runAnimation.length;
				}
				self.sprites[self.runFrame].alpha = 1;
			}
		}
		// Destroy if off screen
		if (self.x < -50 || self.y > 2732) {
			self.destroy();
		}
	};
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.attachAsset('platform', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 5;
	self.passed = false;
	self.update = function () {
		self.x -= self.speed;
		if (self.x < -500) {
			// Increased value to ensure platforms are fully off-screen
			self.destroy();
		}
	};
});
//<Assets used in the game will automatically appear here>
var Player = Container.expand(function () {
	var self = Container.call(this);
	// Animation properties
	self.runAnimation = ['playerrun1', 'playerrun2', 'playerrun3', 'playerrun4', 'playerrun5', 'playerrun6'];
	self.jumpAnimation = ['playerjump1', 'playerjump2', 'playerjump3'];
	self.attackAnimation = ['playerattack1', 'playerattack2', 'playerattack3', 'playerattack4', 'playerattack5'];
	self.isAttacking = false;
	self.attackFrame = 0;
	self.runFrame = 0;
	self.animationSpeed = 0.08;
	self.attackAnimationSpeed = 0.15; // Higher number = faster animation
	self.animationCounter = 0;
	self.sprites = [];
	self.groundY = 2732 * 0.9; // Move ground much lower to allow falling from all platforms
	// Add bounding box properties
	self.hitboxWidth = 100; // Smaller than the 600px animation frames
	self.hitboxHeight = 150; // Adjusted for player height
	// Platform collision properties
	self.isOnGround = true;
	self.currentPlatform = null;
	// Pre-attach all animation frames but make only the first one visible
	// First add run animation sprites
	for (var i = 0; i < self.runAnimation.length; i++) {
		var sprite = self.attachAsset(self.runAnimation[i], {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Set all frames except the first to be invisible
		sprite.alpha = i === 0 ? 1 : 0;
		self.sprites.push(sprite);
	}
	// Then add jump animation sprites
	for (var i = 0; i < self.jumpAnimation.length; i++) {
		var sprite = self.attachAsset(self.jumpAnimation[i], {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Set all jump frames to invisible initially
		sprite.alpha = 0;
		self.sprites.push(sprite);
	}
	for (var i = 0; i < self.attackAnimation.length; i++) {
		var sprite = self.attachAsset(self.attackAnimation[i], {
			anchorX: 0.5,
			anchorY: 0.5
		});
		sprite.alpha = 0;
		self.sprites.push(sprite);
	}
	// Movement properties
	self.speed = 5;
	self.jumpHeight = 40; // Keeping the original jump height
	self.isJumping = false;
	self.velocityY = 0;
	self.jumpState = "none"; // Added to track jump animation phases
	self.jumpStartTime = 0;
	// Add method to get actual collision bounds
	self.getBounds = function () {
		return {
			left: self.x - self.hitboxWidth / 2,
			right: self.x + self.hitboxWidth / 2,
			top: self.y - self.hitboxHeight / 2,
			bottom: self.y + self.hitboxHeight / 2
		};
	};
	self.update = function () {
		// Hide all sprites first
		for (var i = 0; i < self.sprites.length; i++) {
			self.sprites[i].alpha = 0;
		}
		// Handle platform collision and falling physics first
		if (!self.isOnGround && !self.isJumping) {
			self.velocityY += 0.7;
			self.y += self.velocityY;
			self.checkPlatformCollision();
		}
		// Handle jumping physics
		if (self.isJumping) {
			self.y += self.velocityY;
			self.velocityY += 0.7;
			// Get jump frame index offset
			var jumpOffset = self.runAnimation.length;
			// Check for landing on platforms while falling during a jump
			self.checkPlatformCollision();
			// End jump if hitting the original ground (for backward compatibility)
			if (self.y >= self.groundY && !self.currentPlatform) {
				self.y = self.groundY;
				self.isJumping = false;
				self.velocityY = 0;
				self.jumpState = "none";
				self.isOnGround = true;
			}
		}
		// IMPORTANT: Platform collision check - runs EVERY frame
		var onAnyPlatform = false;
		var platformHalfWidth = 500; // half of platform width (1000/2)
		// First, check platform collisions
		for (var i = 0; i < platforms.length; i++) {
			var platform = platforms[i];
			var leftEdge = platform.x - platformHalfWidth;
			var rightEdge = platform.x + platformHalfWidth;
			// Check if player is within horizontal bounds of platform
			if (self.x >= leftEdge && self.x <= rightEdge) {
				// If we're at platform height and not jumping
				if (Math.abs(self.y - (platform.y - 250)) < 5 && !self.isJumping) {
					onAnyPlatform = true;
					self.currentPlatform = platform;
					self.y = platform.y - 250;
					self.isOnGround = true;
					self.velocityY = 0;
					break;
				}
			}
		}
		// Handle falling state
		if (!onAnyPlatform && !self.isJumping) {
			self.isOnGround = false;
			self.currentPlatform = null;
			// Apply gravity
			if (self.velocityY === 0) {
				self.velocityY = 0.1;
			}
			self.velocityY += 0.1;
			self.y += self.velocityY;
			// Ground collision check comes AFTER falling movement
			if (self.y >= self.groundY) {
				// Reached the bottom of the screen - game over
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		}
		// Now handle animations - attack takes priority if active
		if (self.isAttacking) {
			var attackOffset = self.runAnimation.length + self.jumpAnimation.length;
			self.animationCounter += self.attackAnimationSpeed;
			if (self.animationCounter >= 1) {
				self.animationCounter = 0;
				self.attackFrame++;
				if (self.attackFrame >= self.attackAnimation.length) {
					self.isAttacking = false;
					self.attackFrame = 0;
				}
			}
			self.sprites[attackOffset + self.attackFrame].alpha = 1;
		}
		// If not attacking, show jump or run animation
		else if (self.isJumping || !self.isOnGround) {
			var jumpOffset = self.runAnimation.length;
			var currentTime = Date.now();
			if (currentTime - self.jumpStartTime < 100) {
				self.sprites[jumpOffset + 0].alpha = 1;
			} else if (self.velocityY < 0) {
				self.sprites[jumpOffset + 1].alpha = 1;
			} else if (self.velocityY > 0) {
				self.sprites[jumpOffset + 2].alpha = 1;
			}
		} else if (self.isOnGround) {
			self.animationCounter += self.animationSpeed;
			if (self.animationCounter >= 1) {
				self.animationCounter = 0;
				self.runFrame = (self.runFrame + 1) % self.runAnimation.length;
			}
			self.sprites[self.runFrame].alpha = 1;
		}
		// If on a platform, check if we're still above it
		if (self.currentPlatform) {
			var platformHalfWidth = platformWidth / 2; // Use platformWidth constant
			var stillOnPlatform = self.x > self.currentPlatform.x - platformHalfWidth && self.x < self.currentPlatform.x + platformHalfWidth;
			if (!stillOnPlatform) {
				var foundAnotherPlatform = false;
				for (var i = 0; i < platforms.length; i++) {
					var otherPlatform = platforms[i];
					if (otherPlatform === self.currentPlatform) {
						continue;
					}
					var otherHalfWidth = platformWidth / 2;
					if (self.x > otherPlatform.x - otherHalfWidth && self.x < otherPlatform.x + otherHalfWidth) {
						// We found another platform directly below player
						self.currentPlatform = otherPlatform;
						foundAnotherPlatform = true;
						break;
					}
				}
				// Only fall if we didn't find another platform
				if (!foundAnotherPlatform) {
					self.isOnGround = false;
					self.currentPlatform = null;
					// Start falling with initial velocity
					self.velocityY = 0.1;
				}
			}
		}
		// Check if player has fallen off the bottom of the screen
		if (self.y > 2732) {
			LK.effects.flashScreen(0xff0000, 1000);
			LK.showGameOver();
		}
	};
	self.jump = function () {
		if (self.isOnGround) {
			self.isJumping = true;
			self.isOnGround = false;
			self.velocityY = -self.jumpHeight;
			self.jumpState = "start";
			self.jumpStartTime = Date.now();
			self.currentPlatform = null;
		} else if (self.isJumping && self.velocityY < 10) {
			// Allow for a small double-jump to reach higher platforms
			// Only if not falling too fast
			self.velocityY = -self.jumpHeight * 0.7;
			self.jumpStartTime = Date.now();
		}
	};
	self.attack = function () {
		if (!self.isAttacking) {
			self.isAttacking = true;
			self.attackFrame = 0;
			self.animationCounter = 0;
		}
	};
	self.checkPlatformCollision = function () {
		for (var i = 0; i < platforms.length; i++) {
			var platform = platforms[i];
			var platformHalfWidth = platform.width / 2;
			// The offset should match exactly how the player aligns with the lower platform initially
			var playerPlatformOffset = 250; // This is the exact offset between player.y and lowPlatformHeight
			// Check if player is above the platform and falling
			if (self.velocityY > 0 &&
			// Must be falling down
			self.y < platform.y - playerPlatformOffset && self.y + self.velocityY >= platform.y - playerPlatformOffset && self.x > platform.x - platformHalfWidth && self.x < platform.x + platformHalfWidth) {
				// Land on the platform with the exact same positioning as on the low platform
				self.y = platform.y - playerPlatformOffset;
				self.velocityY = 0;
				self.isJumping = false;
				self.isOnGround = true;
				self.currentPlatform = platform;
				return;
			}
		}
	};
});

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

/**** 
* Game Code
****/ 
var GAME_WIDTH = 2048;
var ENEMY_PLATFORM_OFFSET = 220; // Adjust this value
var platforms = [];
var platformWidth = 1000; // Define platform width based on asset size
var platformSpawnInterval = 60;
var platformSpawnCounter = 0;
var platformOverlap = 50;
var platformSpeed = 5; // Define platform speed globally
var platformSpawnInterval = 190;
// = (1000 - 50) / 5 = 190
// Define the two fixed platform heights
var lowPlatformHeight = 2732 / 1.5 + 250; // Regular height (player.y + 250)
var highPlatformHeight = lowPlatformHeight - 600; // High platform (600 pixels higher)
var minPlatformsInSequence = 5; // Minimum platforms in a sequence
var maxPlatformsInSequence = 10; // Maximum platforms in a sequence
var platformsUntilNextChange = 5; // Initial longer ground sequence
var currentPlatformHeight = lowPlatformHeight;
var lastPlatformHeight = lowPlatformHeight;
// Simple toggle for alternating platform heights
var useHighPlatform = false;
var platformGap = 200; // Gap between platforms
var lastPlatformX = 0; // Track the last platform position
var touchStartX = 0;
var touchStartY = 0;
var touchEndX = 0;
var touchEndY = 0;
//<Assets used in the game will automatically appear here>
var background = game.addChild(LK.getAsset('background', {
	anchorX: 0,
	anchorY: 0,
	alpha: 0
}));
background.x = 0;
background.y = 0;
// Initialize player
var player = game.addChild(new Player());
player.x = 2048 / 4.5;
player.y = 2732 / 1.5;
// Initialize enemies
var enemies = [];
var enemySpawnInterval = 100;
var enemySpawnCounter = 0;
// Create a new Text2 object to display the score
var scoreText = new Text2('0', {
	size: 100,
	fill: 0xFFFFFF
});
// Add the score text to the game GUI at the top center of the screen
LK.gui.top.addChild(scoreText);
scoreText.x = 2048 / 2;
scoreText.y = 0;
// Initialize the game with starting platforms
function initializeGame() {
	// Create initial platforms at the low level
	for (var i = 0; i < 5; i++) {
		var platform = new Platform();
		if (i === 0) {
			// First platform centered on player
			platform.x = player.x;
		} else {
			// Position with slight overlap
			platform.x = lastPlatformX + platformWidth - platformOverlap;
		}
		platform.y = lowPlatformHeight;
		platforms.push(platform);
		game.addChild(platform);
		lastPlatformX = platform.x;
	}
	lastPlatformHeight = lowPlatformHeight;
	player.isOnGround = true;
	player.currentPlatform = platforms[0];
}
initializeGame();
// Handle game updates
game.update = function () {
	player.update();
	// Check if we need to spawn a new sequence of platforms
	var lastPlatform = platforms[platforms.length - 1];
	if (lastPlatform && lastPlatform.x < GAME_WIDTH + 500) {
		// Spawn further off-screen to prevent pop-in
		// Time to spawn a new sequence
		if (platformsUntilNextChange <= 0) {
			// Switch height
			currentPlatformHeight = currentPlatformHeight === lowPlatformHeight ? highPlatformHeight : lowPlatformHeight;
			// Generate new random sequence length
			platformsUntilNextChange = Math.floor(Math.random() * (maxPlatformsInSequence - minPlatformsInSequence + 1)) + minPlatformsInSequence;
			// Make ground sequences longer
			if (currentPlatformHeight === lowPlatformHeight) {
				platformsUntilNextChange += 5;
			}
		}
		// Spawn a single platform in the sequence
		var platform = new Platform();
		platform.x = lastPlatform.x + (platformWidth - platformOverlap);
		platform.y = currentPlatformHeight;
		platforms.push(platform);
		game.addChild(platform);
		// Decrement the counter for each platform added
		platformsUntilNextChange--;
	}
	// Update platforms
	for (var i = platforms.length - 1; i >= 0; i--) {
		platforms[i].update();
		// Remove platforms that are destroyed
		if (platforms[i].destroyed) {
			platforms.splice(i, 1);
		}
	}
	// Enemy handling (keep your existing enemy code)
	enemySpawnCounter++;
	if (enemySpawnCounter >= enemySpawnInterval) {
		// Only spawn enemies if there are valid platforms available
		var availablePlatforms = platforms.filter(function (p) {
			// Look for platforms that are just off-screen to the right
			return p.x > 2048 - 100 && p.x < 2048 + 300;
		});
		// Only spawn an enemy if we have a platform to put it on
		if (availablePlatforms.length > 0) {
			var enemy = new Enemy('goblin');
			var platform = availablePlatforms[Math.floor(Math.random() * availablePlatforms.length)];
			enemy.x = platform.x; // Spawn directly above the platform
			enemy.y = platform.y - ENEMY_PLATFORM_OFFSET;
			enemy.currentPlatform = platform;
			enemies.push(enemy);
			game.addChild(enemy);
			enemySpawnInterval = Math.floor(Math.random() * 150) + 100; // Slightly longer intervals
			enemySpawnCounter = 0;
		} else {
			// No valid platforms, just reset counter but don't spawn
			enemySpawnCounter = Math.max(0, enemySpawnCounter - 20); // Back up a bit to try again soon
		}
	}
	// Update enemies
	for (var j = enemies.length - 1; j >= 0; j--) {
		enemies[j].update();
		var playerBounds = player.getBounds();
		var enemyBounds = enemies[j].getBounds();
		if (playerBounds.left < enemyBounds.right && playerBounds.right > enemyBounds.left && playerBounds.top < enemyBounds.bottom && playerBounds.bottom > enemyBounds.top) {
			if (player.isAttacking) {
				// Hit the enemy if player is attacking
				enemies[j].hit();
				// Add score if not already passed
				if (!enemies[j].passed) {
					enemies[j].passed = true;
					LK.setScore(LK.getScore() + 1);
					scoreText.setText(LK.getScore());
				}
			} else if (!enemies[j].isHit && !enemies[j].isDying) {
				// Only die from enemy touch if enemy isn't already hit/dying
				LK.effects.flashScreen(0xff0000, 1000);
				LK.showGameOver();
			}
		} else if (player.x > enemies[j].x && !enemies[j].passed) {
			enemies[j].passed = true;
			LK.setScore(LK.getScore() + 1);
			scoreText.setText(LK.getScore());
		}
	}
};
// Handle player jump
game.down = function (x, y, obj) {
	touchStartX = x;
	touchStartY = y;
};
game.up = function (x, y, obj) {
	touchEndX = x;
	touchEndY = y;
	// Calculate swipe
	var deltaY = touchStartY - touchEndY;
	var deltaX = Math.abs(touchStartX - touchEndX);
	// If vertical swipe (more vertical than horizontal movement)
	if (deltaY > 50 && deltaY > deltaX) {
		player.jump();
	} else {
		// Regular tap/click triggers attack
		player.attack();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -109,9 +109,9 @@
 	};
 	self.hit = function () {
 		if (!self.isHit && !self.isDying) {
 			self.isHit = true;
-			self.throwBackSpeed = 25; // Increased from 15
+			self.throwBackSpeed = 35; // Increased from 25 for more distance
 			self.throwBackDistance = 0;
 			self.hitTimer = 20; // Added hit timer for longer hit frame
 			// Removed vertical velocity/offset variables
 		}
@@ -143,9 +143,9 @@
 			self.throwBackSpeed *= 0.95;
 			// Removed vertical movement code
 			// Handle death animation
 			var dieOffset = self.runAnimation.length + self.hitAnimation.length;
-			var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 7.5), self.dieAnimation.length - 1);
+			var dieFrame = Math.min(Math.floor((30 - self.deathTimer) / 10), self.dieAnimation.length - 1); // Changed from 7.5 to 10 for slower animation
 			self.sprites[dieOffset + dieFrame].alpha = 1;
 			// Count down death timer
 			self.deathTimer--;
 			// After timer expires, fade out