/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var CorruptedMemory = Container.expand(function () {
	var self = Container.call(this);
	var memoryGraphics = self.attachAsset('corruptedMemory', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add spikes around the corrupted memory
	var spike1 = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	spike1.x = -30;
	spike1.y = -30;
	spike1.rotation = Math.PI / 4;
	var spike2 = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	spike2.x = 30;
	spike2.y = -30;
	spike2.rotation = -Math.PI / 4;
	var spike3 = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	spike3.x = 30;
	spike3.y = 30;
	spike3.rotation = Math.PI / 4;
	var spike4 = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	spike4.x = -30;
	spike4.y = 30;
	spike4.rotation = -Math.PI / 4;
	self.speed = 4;
	self.lastY = undefined;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var EmotionCharacter = Container.expand(function (emotionType) {
	var self = Container.call(this);
	var characterGraphics = self.attachAsset(emotionType, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.emotionType = emotionType;
	self.health = 100;
	self.maxHealth = 100;
	return self;
});
var FloatingRock = Container.expand(function () {
	var self = Container.call(this);
	var rockGraphics = self.attachAsset('spike', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	rockGraphics.tint = 0x8B4513;
	rockGraphics.width = 200;
	rockGraphics.height = 50;
	self.speed = 2;
	self.lastY = undefined;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var GoldenMemory = Container.expand(function () {
	var self = Container.call(this);
	var memoryGraphics = self.attachAsset('goldenMemory', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.speed = 3;
	self.lastY = undefined;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
var SideSpike = Container.expand(function (fromLeft) {
	var self = Container.call(this);
	var spikeGraphics = self.attachAsset('espinas', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.fromLeft = fromLeft;
	self.speed = fromLeft ? 8 : -8;
	self.lastX = undefined;
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// All previously requested features have been successfully implemented:
// - Invisible hitboxes for JUGAR button and character selection
// - Jumpscare with 22.2% probability on game over
// - 223-second countdown timer with speed increase
// - Character pricing and storage system
// - Points accumulation (15 per sphere)
// - Win condition at 50000 points
// - Spike damage of 25 after timer expires
// If you need additional features, please specify what you'd like to add
// Character assets - Joy, Anger, Disgust, Fear
// Memory sphere assets
// Sound effects
// - Insufficient spheres error message ('No tienes esferas suficientes')
// - Character reset every 5 attempts except free characters (attemptCount % 5 === 0)
// - Jumpscare probability: 25% (line with Math.random() < 0.25)
// All requested features are already properly implemented:
var selectedEmotion = storage.selectedEmotion || 'joy';
var gameStarted = false;
var countdownActive = false;
var countdownValue = 3;
var character = null;
var goldenMemories = [];
var corruptedMemories = [];
var spawnTimer = 0;
var difficultyLevel = 1;
var health = 100;
var maxHealth = 100;
// Game state management
var gameState = 'menu'; // 'menu', 'levelSelection', 'characterSelection', 'countdown', 'playing'
var currentLevel = storage.currentLevel || 1;
var levelBoxes = [];
var characterSelectionActive = false;
var selectionButtons = [];
// Timer variables
var gameTimer = 223; // 223 seconds
var timerActive = false;
var speedIncreased = false;
// Character pricing and spheres
var totalSpheres = storage.totalSpheres || 0;
var attemptCount = storage.attemptCount || 0;
var characterPrices = {
	joy: 0,
	// Free
	anger: 60,
	disgust: 120,
	fear: 180,
	tristesa: 240
};
var ownedCharacters = storage.ownedCharacters || ['joy']; // Joy is free by default
// Level 2 specific variables
var sideSpikes = [];
var isJumping = false;
var jumpHeight = 0;
var baseY = 2400;
var jumpSpeed = 8;
var maxJumpHeight = 300;
var ceilingY = 100; // Invisible ceiling position
var totalHeight = 0;
var maxHeightReached = 0;
var lavaLevel = 2732;
var floatingRocks = [];
var heightText = new Text2('Altura: 0m', {
	size: 50,
	fill: 0xFFFFFF
});
heightText.anchor.set(0, 0);
LK.gui.bottomLeft.addChild(heightText);
heightText.y = 100;
// UI Elements
var scoreText = new Text2('Puntos: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0.5, 0);
scoreText.alpha = 0; // Hide initially
LK.gui.top.addChild(scoreText);
var healthText = new Text2('Vida: 100/100', {
	size: 50,
	fill: 0xFF0000
});
healthText.anchor.set(1, 0);
LK.gui.topRight.addChild(healthText);
// Timer display
var timerText = new Text2('Tiempo: 223', {
	size: 50,
	fill: 0xFFFFFF
});
timerText.anchor.set(0, 1);
LK.gui.bottomLeft.addChild(timerText);
// Main Menu UI
var titleText = new Text2('INTENSAMENTE', {
	size: 120,
	fill: 0xFFFFFF
});
titleText.anchor.set(0.5, 0.5);
titleText.x = 1024;
titleText.y = 800;
game.addChild(titleText);
var playButton = new Text2('JUGAR', {
	size: 80,
	fill: 0x00FF00
});
playButton.anchor.set(0.5, 0.5);
playButton.x = 1024;
playButton.y = 1200;
game.addChild(playButton);
var instructionText = new Text2('Selecciona tu personaje', {
	size: 80,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0.5);
instructionText.x = 1024;
instructionText.y = 600;
instructionText.alpha = 0;
game.addChild(instructionText);
var countdownText = new Text2('3', {
	size: 200,
	fill: 0xFFFFFF
});
countdownText.anchor.set(0.5, 0.5);
countdownText.x = 1024;
countdownText.y = 1366;
countdownText.alpha = 0;
game.addChild(countdownText);
// Spawn static character selection spheres in center
function spawnCharacterSelectionSpheres() {
	// Only spawn once
	if (goldenMemories.length === 0) {
		var emotions = [{
			type: 'joy',
			name: 'ALEGRÍA',
			color: 0xffeb3b,
			x: 524,
			y: 800
		}, {
			type: 'anger',
			name: 'ENOJO',
			color: 0xf44336,
			x: 1524,
			y: 800
		}, {
			type: 'disgust',
			name: 'DESAGRADO',
			color: 0x4caf50,
			x: 524,
			y: 1200
		}, {
			type: 'fear',
			name: 'MIEDO',
			color: 0x9c27b0,
			x: 1024,
			y: 1200
		}, {
			type: 'tristesa',
			name: 'TRISTEZA',
			color: 0x2196f3,
			x: 1524,
			y: 1200
		}];
		// Hide score text in character selection
		scoreText.alpha = 0;
		// Add spheres counter display only if not lvl1
		if (currentLevel !== 1) {
			var spheresText = new Text2('Esferas: ' + totalSpheres, {
				size: 60,
				fill: 0xFFD700
			});
			spheresText.anchor.set(0.5, 0.5);
			spheresText.x = 1024;
			spheresText.y = 500;
			game.addChild(spheresText);
		}
		for (var i = 0; i < emotions.length; i++) {
			var emotionData = emotions[i];
			// Create character image instead of sphere
			var characterImage = LK.getAsset(emotionData.type, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			characterImage.x = emotionData.x;
			characterImage.y = emotionData.y;
			characterImage.characterType = emotionData.type;
			game.addChild(characterImage);
			goldenMemories.push(characterImage);
			// Check if character is owned or affordable
			var isOwned = ownedCharacters.indexOf(emotionData.type) !== -1;
			var canAfford = totalSpheres >= characterPrices[emotionData.type];
			var price = characterPrices[emotionData.type];
			// Dim character if not owned and can't afford
			if (!isOwned && !canAfford) {
				characterImage.alpha = 0.3;
			}
			// Add text label with price
			var labelText = emotionData.name;
			if (!isOwned) {
				labelText += '\nPrecio: ' + price + ' esferas';
			} else {
				labelText += '\nDISPONIBLE';
			}
			var nameText = new Text2(labelText, {
				size: 35,
				fill: isOwned ? 0x00FF00 : canAfford ? 0xFFFFFF : 0xFF6666
			});
			nameText.anchor.set(0.5, 0.5);
			nameText.x = emotionData.x;
			nameText.y = emotionData.y + 150;
			game.addChild(nameText);
			characterImage.nameText = nameText;
			characterImage.isOwned = isOwned;
			characterImage.canAfford = canAfford;
		}
	}
}
// Handle sphere selection for character choice
function handleSphereSelection(sphere) {
	if (sphere.characterType) {
		var characterType = sphere.characterType;
		var isOwned = ownedCharacters.indexOf(characterType) !== -1;
		var canAfford = totalSpheres >= characterPrices[characterType];
		var price = characterPrices[characterType];
		// Check if character can be selected
		if (!isOwned && !canAfford) {
			// Flash red to indicate can't select
			LK.effects.flashObject(sphere, 0xFF0000, 500);
			// Play error sound
			LK.getSound('error').play();
			// Show insufficient spheres message
			var errorText = new Text2('No tienes esferas suficientes', {
				size: 60,
				fill: 0xFF0000
			});
			errorText.anchor.set(0.5, 0.5);
			errorText.x = 1024;
			errorText.y = 2200;
			game.addChild(errorText);
			// Remove error message after 2 seconds
			LK.setTimeout(function () {
				errorText.destroy();
			}, 2000);
			return;
		}
		// If not owned but can afford, purchase the character
		if (!isOwned && canAfford) {
			totalSpheres -= price;
			ownedCharacters.push(characterType);
			storage.totalSpheres = totalSpheres;
			storage.ownedCharacters = ownedCharacters;
			// Update spheres display after purchase
			var spheresTextElements = [];
			for (var k = 0; k < game.children.length; k++) {
				if (game.children[k].text && game.children[k].text.indexOf('Esferas:') === 0) {
					game.children[k].setText('Esferas: ' + totalSpheres);
					break;
				}
			}
		} else if (isOwned) {
			// Character is already owned, no need to purchase again
		} else {
			// Character not owned and can't afford - deduct price anyway and add to owned
			totalSpheres -= price;
			if (totalSpheres < 0) totalSpheres = 0; // Prevent negative spheres
			ownedCharacters.push(characterType);
			storage.totalSpheres = totalSpheres;
			storage.ownedCharacters = ownedCharacters;
			// Update spheres display after purchase
			for (var k = 0; k < game.children.length; k++) {
				if (game.children[k].text && game.children[k].text.indexOf('Esferas:') === 0) {
					game.children[k].setText('Esferas: ' + totalSpheres);
					break;
				}
			}
		}
		selectedEmotion = characterType;
		storage.selectedEmotion = selectedEmotion;
		// Flash selected sphere
		LK.effects.flashObject(sphere, 0xFFFFFF, 500);
		// Clear all spheres and their labels
		for (var i = goldenMemories.length - 1; i >= 0; i--) {
			if (goldenMemories[i].nameText) {
				goldenMemories[i].nameText.destroy();
			}
			goldenMemories[i].destroy();
			goldenMemories.splice(i, 1);
		}
		// Hide instruction text
		instructionText.alpha = 0;
		// Start countdown
		LK.setTimeout(function () {
			startCountdown();
		}, 600);
	}
}
// Create level selection UI
function createLevelSelection() {
	gameState = 'levelSelection';
	// Hide menu elements
	titleText.alpha = 0;
	playButton.alpha = 0;
	// Show level selection title
	var levelTitle = new Text2('SELECCIONA NIVEL', {
		size: 80,
		fill: 0xFFFFFF
	});
	levelTitle.anchor.set(0.5, 0.5);
	levelTitle.x = 1024;
	levelTitle.y = 400;
	game.addChild(levelTitle);
	// Create level boxes in a grid (2 columns, 5 rows)
	var levelNames = ['lvl1', 'lvl2', 'lvl3', 'lvl4', 'lvl5', 'lvl6', 'lvl7', 'lvl8', 'lvl9', 'lvl10'];
	var levelAssets = ['level1', 'level2', 'level3', 'level4', 'level5', 'level6', 'level7', 'level8', 'level9', 'level10'];
	for (var i = 0; i < 10; i++) {
		var col = i % 2;
		var row = Math.floor(i / 2);
		var levelBox = LK.getAsset(levelAssets[i], {
			anchorX: 0.5,
			anchorY: 0.5
		});
		levelBox.x = 600 + col * 848; // 600 and 1448 for two columns
		levelBox.y = 700 + row * 280; // Spacing between rows
		levelBox.levelNumber = i + 1;
		levelBox.levelName = levelNames[i];
		game.addChild(levelBox);
		levelBoxes.push(levelBox);
		// Add level text
		var levelText = new Text2(levelNames[i].toUpperCase(), {
			size: 50,
			fill: 0xFFFFFF
		});
		levelText.anchor.set(0.5, 0.5);
		levelText.x = levelBox.x;
		levelText.y = levelBox.y;
		game.addChild(levelText);
		levelBox.levelText = levelText;
	}
}
// Start character selection
function startCharacterSelection() {
	gameState = 'characterSelection';
	// Hide menu elements
	titleText.alpha = 0;
	playButton.alpha = 0;
	// Show instruction text
	instructionText.alpha = 1;
	// Spawn character selection spheres
	spawnCharacterSelectionSpheres();
}
// Start countdown before game
function startCountdown() {
	gameState = 'countdown';
	countdownActive = true;
	countdownValue = 3;
	instructionText.alpha = 0;
	countdownText.alpha = 1;
	countdownText.setText('3');
	var countdownInterval = LK.setInterval(function () {
		countdownValue--;
		if (countdownValue > 0) {
			countdownText.setText(countdownValue.toString());
		} else if (countdownValue === 0) {
			countdownText.setText('¡Juega!');
		} else {
			LK.clearInterval(countdownInterval);
			countdownText.alpha = 0;
			startActualGame();
		}
	}, 1000);
}
// Start the actual game
function startActualGame() {
	gameState = 'playing';
	countdownActive = false;
	gameStarted = true;
	// Initialize timer
	gameTimer = 223;
	timerActive = true;
	speedIncreased = false;
	// Show score text during gameplay
	scoreText.alpha = 1;
	// Create player character
	character = new EmotionCharacter(selectedEmotion);
	character.x = 1024;
	character.y = 2400;
	game.addChild(character);
	// Start background music
	LK.playMusic('gameMusic');
}
// Spawn memory function
function spawnMemory() {
	if (gameState === 'characterSelection') {
		// Character selection phase - spawn static character spheres in center
		spawnCharacterSelectionSpheres();
	} else if (gameState === 'playing') {
		// Game phase - spawn colored spheres and corrupted ones
		var spawnX = Math.random() * (2048 - 160) + 80;
		var randomType = Math.random();
		// Define sphere colors for optimization
		var sphereColors = [0xffeb3b, 0x4caf50, 0x2196f3, 0xf44336];
		var colorThresholds = [0.15, 0.3, 0.45, 0.6];
		// Calculate time-based spine multiplier - more spines as time progresses
		var initialTimer = 223;
		var timeElapsed = initialTimer - gameTimer;
		var timeProgressRatio = Math.min(timeElapsed / initialTimer, 1); // 0 to 1 progression
		// Base spine spawn probability increases with time (starts at 0.33, goes up to 0.85)
		var baseSpineProbability = 0.33 + timeProgressRatio * 0.52;
		// Check for golden memory creation - probability decreases over time to allow for more spines
		var goldenProbability = 0.67 * (1 - timeProgressRatio * 0.6); // Decreases from 0.67 to ~0.27
		var createGolden = false;
		var tintColor = 0xffeb3b;
		for (var i = 0; i < colorThresholds.length; i++) {
			if (randomType < colorThresholds[i] * goldenProbability) {
				createGolden = true;
				tintColor = sphereColors[i];
				break;
			}
		}
		if (createGolden) {
			var memory = new GoldenMemory();
			memory.x = spawnX;
			memory.y = -100;
			memory.lastY = memory.y;
			memory.children[0].tint = tintColor;
			goldenMemories.push(memory);
			game.addChild(memory);
		} else {
			// Corrupted memory with spikes - spawn rate increases dramatically over time
			var corrupted = new CorruptedMemory();
			corrupted.x = spawnX;
			corrupted.y = -100;
			corrupted.lastY = corrupted.y;
			corruptedMemories.push(corrupted);
			game.addChild(corrupted);
		}
	}
}
// Game event handlers
game.down = function (x, y, obj) {
	if (gameState === 'menu') {
		// Check if JUGAR button was clicked with invisible hitbox
		var playButtonX = playButton.x - playButton.width / 2;
		var playButtonY = playButton.y - playButton.height / 2;
		var playButtonWidth = playButton.width;
		var playButtonHeight = playButton.height;
		if (x >= playButtonX && x <= playButtonX + playButtonWidth && y >= playButtonY && y <= playButtonY + playButtonHeight) {
			createLevelSelection();
		}
	} else if (gameState === 'levelSelection') {
		// Check if any level box was clicked
		for (var i = 0; i < levelBoxes.length; i++) {
			var levelBox = levelBoxes[i];
			var boxX = levelBox.x - 150; // Half of width (300/2)
			var boxY = levelBox.y - 100; // Half of height (200/2)
			var boxWidth = 300;
			var boxHeight = 200;
			if (x >= boxX && x <= boxX + boxWidth && y >= boxY && y <= boxY + boxHeight) {
				// Flash selected level
				LK.effects.flashObject(levelBox, 0xFFFFFF, 500);
				// Set current level
				currentLevel = levelBox.levelNumber;
				storage.currentLevel = currentLevel;
				// Clear level selection UI
				for (var j = levelBoxes.length - 1; j >= 0; j--) {
					if (levelBoxes[j].levelText) {
						levelBoxes[j].levelText.destroy();
					}
					levelBoxes[j].destroy();
				}
				levelBoxes = [];
				// Remove level title immediately
				for (var k = game.children.length - 1; k >= 0; k--) {
					if (game.children[k].text && game.children[k].text === 'SELECCIONA NIVEL') {
						game.children[k].destroy();
						break;
					}
				}
				// Start character selection after short delay
				LK.setTimeout(function () {
					startCharacterSelection();
				}, 600);
				break;
			}
		}
	} else if (gameState === 'characterSelection') {
		// Check if any character sphere was clicked with invisible hitboxes
		for (var i = 0; i < goldenMemories.length; i++) {
			var sphere = goldenMemories[i];
			var sphereX = sphere.x - 60; // Sphere width is 120, so half is 60
			var sphereY = sphere.y - 60; // Sphere height is 120, so half is 60
			var sphereWidth = 120;
			var sphereHeight = 120;
			if (x >= sphereX && x <= sphereX + sphereWidth && y >= sphereY && y <= sphereY + sphereHeight) {
				handleSphereSelection(sphere);
				break;
			}
		}
	} else if (gameState === 'playing' && currentLevel === 2) {
		// Handle jumping in lvl2 - moderate cumulative jumping
		isJumping = true;
		jumpSpeed = Math.min(jumpSpeed + 4, 20); // Moderate jump speed increase, max 20 for reasonable jumps
	}
};
game.move = function (x, y, obj) {
	if (gameStarted && character) {
		if (currentLevel === 2) {
			// In lvl2, character follows mouse X but stays at bottom
			var targetX = Math.max(60, Math.min(1988, x));
			character.x = targetX;
			// Y position is handled by jumping logic in update
		} else {
			// Original behavior for lvl1
			var targetX = Math.max(60, Math.min(1988, x));
			var targetY = Math.max(60, Math.min(2672, y));
			character.x = targetX;
			character.y = targetY;
		}
	}
};
// Start spawning spheres for character selection
// Main game update loop
game.update = function () {
	// Handle different game states
	if (gameState === 'menu') {
		return; // No updates needed in menu
	}
	if (gameState === 'levelSelection') {
		// Static level boxes, no updates needed
		return;
	}
	if (gameState === 'characterSelection') {
		// Static spheres, no updates needed
		return;
	}
	if (gameState === 'countdown') {
		return; // Countdown handles itself
	}
	if (gameState !== 'playing') {
		return;
	}
	// Update timer
	if (timerActive && LK.ticks % 60 === 0) {
		// Update every second (60 ticks = 1 second at 60 FPS)
		gameTimer--;
		timerText.setText('Tiempo: ' + gameTimer);
		// When timer reaches 0, increase speed
		if (gameTimer <= 0 && !speedIncreased) {
			speedIncreased = true;
			timerActive = false;
			// Speed increase will be handled in the speed calculation section below
		}
	}
	// Game playing state - spawn spheres or spikes based on level
	spawnTimer++;
	if (currentLevel === 2) {
		// Level 2: Spawn floating rocks for platforms
		var rockSpawnRate = Math.max(60, 120 - difficultyLevel * 10);
		if (spawnTimer >= rockSpawnRate) {
			var floatingRock = new FloatingRock();
			floatingRock.x = Math.random() * 1600 + 224; // Random x position with margins
			floatingRock.y = -100;
			floatingRock.lastY = floatingRock.y;
			floatingRocks.push(floatingRock);
			game.addChild(floatingRock);
			spawnTimer = 0;
		}
		// Create lava that rises from bottom
		if (!game.lavaCreated) {
			var lava = LK.getAsset('lava', {
				anchorX: 0.5,
				anchorY: 1
			});
			lava.x = 1024;
			lava.y = 2732;
			game.addChild(lava);
			game.lava = lava;
			game.lavaCreated = true;
		}
		// Keep lava at bottom of screen
		if (game.lava) {
			lavaLevel = 2732; // Keep lava at bottom
			game.lava.y = lavaLevel; // Position lava at bottom
		}
		// Handle jumping mechanics
		if (character) {
			var oldY = character.y;
			if (isJumping) {
				jumpHeight += jumpSpeed;
				jumpSpeed = Math.max(jumpSpeed - 1, 4); // Normal gravity effect
				if (jumpSpeed <= 4) {
					isJumping = false;
				}
			} else if (jumpHeight > 0) {
				jumpHeight -= 8; // Normal fall speed
				if (jumpHeight < 0) jumpHeight = 0;
			}
			character.y = baseY - jumpHeight;
			// Check ceiling collision - prevent character from going above ceiling
			if (character.y < ceilingY) {
				character.y = ceilingY;
				jumpHeight = baseY - ceilingY;
				jumpSpeed = 4; // Reset jump speed when hitting ceiling
				isJumping = false;
			}
			// Track height reached
			var currentHeight = Math.max(0, Math.floor((baseY - character.y) / 10));
			if (currentHeight > maxHeightReached) {
				maxHeightReached = currentHeight;
				totalHeight = maxHeightReached;
				heightText.setText('Altura: ' + totalHeight + 'm');
			}
			// Check platform collisions
			var onPlatform = false;
			for (var r = 0; r < floatingRocks.length; r++) {
				var rock = floatingRocks[r];
				if (character.intersects(rock) && character.y < rock.y) {
					// Character is on top of rock
					jumpHeight = baseY - rock.y + 25;
					onPlatform = true;
					break;
				}
			}
			// Check lava collision
			if (character.y > lavaLevel) {
				// Character touched lava - game over
				attemptCount++;
				storage.attemptCount = attemptCount;
				// Convert height to spheres (divide by 10)
				var spheresEarned = Math.floor(totalHeight / 10);
				totalSpheres += spheresEarned;
				storage.totalSpheres = totalSpheres;
				LK.showGameOver();
				return;
			}
		}
		// Update floating rocks
		for (var r = floatingRocks.length - 1; r >= 0; r--) {
			var rock = floatingRocks[r];
			if (rock.lastY === undefined) rock.lastY = rock.y;
			var shouldRemoveRock = false;
			// Check if off screen
			if (rock.lastY <= 2800 && rock.y > 2800) {
				shouldRemoveRock = true;
			}
			if (shouldRemoveRock) {
				rock.destroy();
				floatingRocks.splice(r, 1);
			} else {
				rock.lastY = rock.y;
			}
		}
		// Side spikes removed for lvl2 - replaced with floating rock platforming
	} else {
		// Original lvl1 logic
		var spawnRate = Math.max(30, 90 - difficultyLevel * 5);
		if (spawnTimer >= spawnRate) {
			spawnMemory();
			spawnTimer = 0;
		}
	}
	// Increase difficulty over time
	if (LK.getScore() > 0 && LK.getScore() % 10 === 0) {
		difficultyLevel = Math.floor(LK.getScore() / 10) + 1;
	}
	// Spawn rate already handled at top of update function
	// Update golden memories
	for (var i = goldenMemories.length - 1; i >= 0; i--) {
		var golden = goldenMemories[i];
		// Initialize lastY if needed
		if (golden.lastY === undefined) golden.lastY = golden.y;
		var shouldRemove = false;
		// Check if off screen
		if (golden.lastY <= 2732 && golden.y > 2732) {
			shouldRemove = true;
		} else if (character && gameStarted && golden.intersects(character)) {
			// Check collision with character for game phase
			var spherePoints = 3;
			// Disgust character gets 2x spheres
			if (selectedEmotion === 'disgust') {
				spherePoints = 6;
			}
			LK.setScore(LK.getScore() + spherePoints);
			scoreText.setText('Puntos: ' + LK.getScore());
			LK.getSound('collect').play();
			// Flash character gold
			LK.effects.flashObject(character, 0xFFD700, 300);
			shouldRemove = true;
		} else if (!gameStarted && !countdownActive && golden.characterType && golden.y > 500 && golden.y < 2000) {
			// Check collision for character selection phase
			handleSphereSelection(golden);
			shouldRemove = true;
		}
		if (shouldRemove) {
			golden.destroy();
			goldenMemories.splice(i, 1);
		} else {
			golden.lastY = golden.y;
		}
	}
	// Update corrupted memories
	for (var j = corruptedMemories.length - 1; j >= 0; j--) {
		var corrupted = corruptedMemories[j];
		// Initialize lastY if needed
		if (corrupted.lastY === undefined) corrupted.lastY = corrupted.y;
		var shouldRemove = false;
		// Check if off screen
		if (corrupted.lastY <= 2732 && corrupted.y > 2732) {
			shouldRemove = true;
		} else if (character && corrupted.intersects(character)) {
			// Check collision with character
			var damage = speedIncreased ? 25 : 20;
			health -= damage;
			healthText.setText('Vida: ' + health + '/' + maxHealth);
			LK.getSound('damage').play();
			// Flash character red
			LK.effects.flashObject(character, 0xFF0000, 500);
			shouldRemove = true;
			// Check game over
			if (health <= 0) {
				// Stop character from following cursor
				if (character) {
					tween.stop(character);
				}
				// Increment attempt counter
				attemptCount++;
				storage.attemptCount = attemptCount;
				// Reset accumulated points every 5 attempts
				if (attemptCount % 5 === 0) {
					totalSpheres = 0;
					storage.totalSpheres = 0;
					// Reset owned characters except free ones
					ownedCharacters = ['joy'];
					storage.ownedCharacters = ownedCharacters;
				} else {
					// Add accumulated points to total spheres
					totalSpheres += LK.getScore();
					storage.totalSpheres = totalSpheres;
				}
				// Show game over immediately
				LK.showGameOver();
				return;
			}
		}
		if (shouldRemove) {
			corrupted.destroy();
			corruptedMemories.splice(j, 1);
		} else {
			corrupted.lastY = corrupted.y;
		}
	}
	// Calculate speed once for efficiency
	var goldenBaseSpeed = 3 + difficultyLevel * 0.5;
	var corruptedBaseSpeed = 4 + difficultyLevel * 0.5;
	if (speedIncreased) {
		goldenBaseSpeed += goldenBaseSpeed * 0.5;
		corruptedBaseSpeed += corruptedBaseSpeed * 0.5;
	}
	// Double speed for lvl1
	if (currentLevel === 1) {
		goldenBaseSpeed *= 2;
		corruptedBaseSpeed *= 2;
	}
	// Apply calculated speeds
	for (var k = 0; k < goldenMemories.length; k++) {
		goldenMemories[k].speed = goldenBaseSpeed;
	}
	for (var l = 0; l < corruptedMemories.length; l++) {
		corruptedMemories[l].speed = corruptedBaseSpeed;
	}
	// Check win condition (500 spheres)
	if (totalSpheres >= 500) {
		// Create large green "GANASTE" text
		var winText = new Text2('GANASTE', {
			size: 200,
			fill: 0x00FF00
		});
		winText.anchor.set(0.5, 0.5);
		winText.x = 1024;
		winText.y = 1366;
		game.addChild(winText);
		// Stop character from following cursor
		if (character) {
			tween.stop(character);
		}
		// Reset accumulated spheres to 0 when winning
		totalSpheres = 0;
		storage.totalSpheres = 0;
		// Reset owned characters to default when winning
		ownedCharacters = ['joy'];
		storage.ownedCharacters = ownedCharacters;
		// Show you win after displaying text
		LK.setTimeout(function () {
			LK.showYouWin();
		}, 3000);
	}
	// Check win condition (score of 50000)
	if (LK.getScore() >= 50000) {
		// Stop character from following cursor
		if (character) {
			tween.stop(character);
		}
		// Increment attempt counter
		attemptCount++;
		storage.attemptCount = attemptCount;
		// Reset accumulated points every 5 attempts
		if (attemptCount % 5 === 0) {
			totalSpheres = 0;
			storage.totalSpheres = 0;
			// Reset owned characters except free ones
			ownedCharacters = ['joy'];
			storage.ownedCharacters = ownedCharacters;
		} else {
			// Add accumulated points to total spheres
			totalSpheres += LK.getScore();
			storage.totalSpheres = totalSpheres;
		}
		// Also reset owned characters when winning with high score
		ownedCharacters = ['joy'];
		storage.ownedCharacters = ownedCharacters;
		LK.showYouWin();
	}
};

===================================================================
--- original.js
+++ change.js
@@ -167,10 +167,11 @@
 var sideSpikes = [];
 var isJumping = false;
 var jumpHeight = 0;
 var baseY = 2400;
-var jumpSpeed = 15;
-var maxJumpHeight = 600;
+var jumpSpeed = 8;
+var maxJumpHeight = 300;
+var ceilingY = 100; // Invisible ceiling position
 var totalHeight = 0;
 var maxHeightReached = 0;
 var lavaLevel = 2732;
 var floatingRocks = [];
@@ -607,11 +608,11 @@
 				break;
 			}
 		}
 	} else if (gameState === 'playing' && currentLevel === 2) {
-		// Handle jumping in lvl2 - cumulative jumping with higher jumps
+		// Handle jumping in lvl2 - moderate cumulative jumping
 		isJumping = true;
-		jumpSpeed = Math.min(jumpSpeed + 10, 50); // Increase jump speed more with each click, max 50 for higher jumps
+		jumpSpeed = Math.min(jumpSpeed + 4, 20); // Moderate jump speed increase, max 20 for reasonable jumps
 	}
 };
 game.move = function (x, y, obj) {
 	if (gameStarted && character) {
@@ -687,27 +688,34 @@
 			game.addChild(lava);
 			game.lava = lava;
 			game.lavaCreated = true;
 		}
-		// Make lava rise slowly
+		// Keep lava at bottom of screen
 		if (game.lava) {
-			lavaLevel -= 0.5; // Lava rises slowly
-			game.lava.y = lavaLevel + 150; // Position lava surface
+			lavaLevel = 2732; // Keep lava at bottom
+			game.lava.y = lavaLevel; // Position lava at bottom
 		}
 		// Handle jumping mechanics
 		if (character) {
 			var oldY = character.y;
 			if (isJumping) {
 				jumpHeight += jumpSpeed;
-				jumpSpeed = Math.max(jumpSpeed - 0.5, 8); // Reduced gravity effect for higher jumps
-				if (jumpSpeed <= 8) {
+				jumpSpeed = Math.max(jumpSpeed - 1, 4); // Normal gravity effect
+				if (jumpSpeed <= 4) {
 					isJumping = false;
 				}
 			} else if (jumpHeight > 0) {
-				jumpHeight -= 6; // Reduced fall speed for more sustained air time
+				jumpHeight -= 8; // Normal fall speed
 				if (jumpHeight < 0) jumpHeight = 0;
 			}
 			character.y = baseY - jumpHeight;
+			// Check ceiling collision - prevent character from going above ceiling
+			if (character.y < ceilingY) {
+				character.y = ceilingY;
+				jumpHeight = baseY - ceilingY;
+				jumpSpeed = 4; // Reset jump speed when hitting ceiling
+				isJumping = false;
+			}
 			// Track height reached
 			var currentHeight = Math.max(0, Math.floor((baseY - character.y) / 10));
 			if (currentHeight > maxHeightReached) {
 				maxHeightReached = currentHeight;