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

/**** 
* Classes
****/ 
var Slime = Container.expand(function () {
	var self = Container.call(this);
	// Create and attach the slime asset
	self.attachAsset('ClasicSlime', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 500,
		height: 500
	});
	self.lastX = self.lastY = 0;
	self.baseX = 0;
	self.baseY = 0;
	self.setBasePosition = function (x, y) {
		self.baseX = x;
		self.baseY = y;
		self.x = x;
		self.y = y;
	};
	self.update = function () {
		self.lastX = self.x;
		self.lastY = self.y;
	};
	return self;
});
var Star = Container.expand(function () {
	var self = Container.call(this);
	var starGraphics = self.attachAsset('Star', {
		anchorX: 0.5,
		anchorY: 0.5,
		width: 100,
		height: 100
	});
	self.setColorByRarity = function (rarityLevel) {
		var colors = [0xaaaaaa, 0x82b3c9, 0x4aa564, 0x2e8ece, 0x9b59b6, 0xe67e22, 0xe74c3c, 0xf1c40f, 0x1abc9c, 0xffffff];
		starGraphics.tint = rarityLevel >= 1 && rarityLevel <= 10 ? colors[rarityLevel - 1] : colors[0];
		// Create glow effect with subtle pulsation
		self.glowIntensity = 0.2 + rarityLevel / 10;
		LK.setTimeout(function () {
			tween(starGraphics, {
				scaleX: 1 + self.glowIntensity * 0.1,
				scaleY: 1 + self.glowIntensity * 0.1
			}, {
				duration: 1000 + rarityLevel * 100,
				easing: tween.easeInOut,
				repeat: -1,
				yoyo: true
			});
		}, Math.random() * 500);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create BGMenu for bottom half of screen
var bgMenu = LK.getAsset('BGMenu', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 2032 / 2,
	width: 2048,
	height: 3532 / 2
});
// Create BG for top half of screen
var bg = LK.getAsset('BG', {
	anchorX: 0,
	anchorY: 0,
	x: 0,
	y: 0,
	width: 2048,
	height: 2032 / 2
});
// Create interface element at the top of BGMenu
var interfaz = LK.getAsset('Interfaz', {
	anchorX: 0.5,
	anchorY: 0,
	width: 2048,
	height: 400
});
// Position the interface at the top of BGMenu
interfaz.x = bgMenu.width / 2;
interfaz.y = bgMenu.y;
// Create left button
var leftButton = LK.getAsset('BotonChange', {
	anchorX: 0.5,
	anchorY: 0.5,
	scaleX: -1,
	// Flip horizontally to point left
	x: -800,
	y: interfaz.height / 2
});
// Add event handlers for left button
leftButton.interactive = true;
leftButton.down = function () {
	changeSlime('prev');
};
// Create right button
var rightButton = LK.getAsset('BotonChange', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 800,
	y: interfaz.height / 2
});
// Add event handlers for right button
rightButton.interactive = true;
rightButton.down = function () {
	changeSlime('next');
};
var currentSlimeIndex = 0;
// Function to wrap text that exceeds screen width
function wrapText(text, maxWidth, textSize) {
	if (!text) {
		return "";
	}
	var words = text.split(' ');
	var wrappedText = '',
		line = '';
	var charsPerLine = Math.floor(maxWidth / (textSize * 0.5));
	for (var i = 0; i < words.length; i++) {
		var testLine = line + words[i] + ' ';
		if (testLine.length > charsPerLine) {
			wrappedText += line.trim() + '\n';
			line = words[i] + ' ';
		} else {
			line = testLine;
		}
	}
	return wrappedText + line.trim();
}
// Create structured slime information
var rarityNamesByValue = {
	1: "Common",
	2: "Unusual",
	3: "Uncommon",
	4: "Remarkable",
	5: "Rare",
	6: "Exceptional",
	7: "Mythical",
	8: "Legendary",
	9: "Ancient",
	10: "Divine"
};
// Function to sort slimes by rarity from highest to lowest
function sortSlimesByRarity(slimes) {
	return slimes.slice().sort(function (a, b) {
		return b.Rarity - a.Rarity; // Sort in descending order (highest to lowest)
	});
}
// Structured SlimeInfo array with all properties in a single place
var SlimeInfo = [{
	SlimeName: 'Clasic Slime',
	Rarity: 1,
	History: 'The most common and friendly of all slimes, Clasic Slimes are believed to be the original form from which all other slimes evolved.',
	Location: 'Meadows, gardens, and anywhere with fresh dew',
	FavoriteFood: 'Fresh grass and morning dew',
	Ability: 'Can split into two smaller slimes when threatened',
	Stats: {
		strength: 3,
		agility: 5,
		defense: 2,
		magic: 1,
		luck: 2,
		mysticism: 1
	},
	Lifespan: '5-8 years'
}, {
	SlimeName: 'Snowy Slime',
	Rarity: 2,
	History: 'Snowy Slimes are born from snowdrifts touched by moonlight. They are gentle and love cold climates.',
	Location: 'Snowfields, icy caves, and mountaintops',
	FavoriteFood: 'Icicles and frozen berries',
	Ability: 'Can lower the temperature around them, freezing small puddles instantly',
	Stats: {
		strength: 3,
		agility: 2,
		defense: 8,
		magic: 6,
		luck: 4,
		mysticism: 5
	},
	Lifespan: '12-15 years'
}, {
	SlimeName: 'Water Slime',
	Rarity: 3,
	History: 'Formed from enchanted raindrops, Water Slimes are playful and quick, often found near rivers.',
	Location: 'Lakes, rivers, and rainy forests',
	FavoriteFood: 'Pure spring water and water lilies',
	Ability: 'Can merge with water to become invisible and move swiftly',
	Stats: {
		strength: 2,
		agility: 7,
		defense: 1,
		magic: 5,
		luck: 4,
		mysticism: 3
	},
	Lifespan: '8-12 years'
}, {
	SlimeName: 'Rock Slime',
	Rarity: 4,
	History: 'Rock Slimes are the result of slimes living near mineral-rich caves, slowly absorbing stone and earth.',
	Location: 'Caves, rocky hills, and mountain bases',
	FavoriteFood: 'Pebbles and mineral-rich soil',
	Ability: 'Can harden their bodies to become nearly unbreakable for short periods',
	Stats: {
		strength: 8,
		agility: 1,
		defense: 9,
		magic: 2,
		luck: 3,
		mysticism: 1
	},
	Lifespan: '20-30 years'
}, {
	SlimeName: 'Fire Slime',
	Rarity: 5,
	History: 'Fire Slimes are born from the embers of ancient volcanoes, carrying a spark of elemental fire within.',
	Location: 'Volcanoes, hot springs, and scorched plains',
	FavoriteFood: 'Charcoal and spicy peppers',
	Ability: 'Can ignite themselves to ward off predators and light dark places',
	Stats: {
		strength: 6,
		agility: 3,
		defense: 4,
		magic: 7,
		luck: 2,
		mysticism: 6
	},
	Lifespan: '10-15 years'
}, {
	SlimeName: 'Shadow Slime',
	Rarity: 6,
	History: 'Shadow Slimes are born in places untouched by light, absorbing the darkness around them.',
	Location: 'Caverns, abandoned ruins, and deep forests at night',
	FavoriteFood: 'Shadows and nocturnal insects',
	Ability: 'Can blend into shadows and become nearly invisible',
	Stats: {
		strength: 5,
		agility: 8,
		defense: 3,
		magic: 9,
		luck: 6,
		mysticism: 8
	},
	Lifespan: '30-40 years'
}, {
	SlimeName: 'Forest Slime',
	Rarity: 7,
	History: 'Forest Slimes are the guardians of ancient woods, formed from moss and enchanted leaves.',
	Location: 'Dense forests, groves, and magical thickets',
	FavoriteFood: 'Moss, leaves, and wildflowers',
	Ability: 'Can heal plants and accelerate their growth',
	Stats: {
		strength: 4,
		agility: 6,
		defense: 5,
		magic: 8,
		luck: 5,
		mysticism: 7
	},
	Lifespan: '25-35 years'
}, {
	SlimeName: 'Beast Slime',
	Rarity: 8,
	History: 'Beast Slimes are fierce and wild, believed to have evolved by mimicking the strongest animals in their environment.',
	Location: 'Savannahs, jungles, and wild plains',
	FavoriteFood: 'Raw meat and wild fruits',
	Ability: 'Can roar to intimidate foes and temporarily boost their own strength',
	Stats: {
		strength: 9,
		agility: 7,
		defense: 7,
		magic: 3,
		luck: 8,
		mysticism: 2
	},
	Lifespan: '18-25 years'
}, {
	SlimeName: 'Lucky Slime',
	Rarity: 8,
	History: 'Lucky Slimes are said to be born during rare celestial events, bringing fortune to those who find them.',
	Location: 'Rainbow fields, clover patches, and near waterfalls',
	FavoriteFood: 'Four-leaf clovers and golden apples',
	Ability: 'Can increase the luck of nearby creatures and find hidden treasures',
	Stats: {
		strength: 3,
		agility: 5,
		defense: 2,
		magic: 6,
		luck: 10,
		mysticism: 4
	},
	Lifespan: '10-20 years'
}, {
	SlimeName: 'Runic Slime',
	Rarity: 9,
	History: 'Runic Slimes are ancient beings, their bodies inscribed with glowing runes of power.',
	Location: 'Ancient temples, rune circles, and magical libraries',
	FavoriteFood: 'Enchanted stones and magical scrolls',
	Ability: 'Can cast simple spells and decipher ancient languages',
	Stats: {
		strength: 5,
		agility: 4,
		defense: 3,
		magic: 9,
		luck: 7,
		mysticism: 10
	},
	Lifespan: '50-100 years'
}, {
	SlimeName: 'Divine Slime',
	Rarity: 10,
	History: 'Divine Slimes are legendary, said to descend from the heavens during times of great need.',
	Location: 'Sacred groves, mountaintops, and places of worship',
	FavoriteFood: 'Nectar from sacred flowers and pure spring water',
	Ability: 'Can heal wounds and purify water with a touch',
	Stats: {
		strength: 7,
		agility: 4,
		defense: 6,
		magic: 10,
		luck: 10,
		mysticism: 9
	},
	Lifespan: 'Unknown, possibly eternal'
}, {
	SlimeName: 'Fruit Slime',
	Rarity: 5,
	History: 'Born from the essence of vibrant orchards, Fruit Slimes emerged when magical runoff seeped into ancient fruit groves.',
	Location: 'Orchards, fruit markets, and gardens with sweet-smelling blossoms',
	FavoriteFood: 'Overripe fruits and berry preserves',
	Ability: 'Can change color based on the last fruit consumed, and releases a sweet aroma that calms nearby creatures',
	Stats: {
		strength: 4,
		agility: 6,
		defense: 3,
		magic: 7,
		luck: 6,
		mysticism: 5
	},
	Lifespan: '15-20 years, longer if fed a varied diet of exotic fruits'
}, {
	SlimeName: 'Ghost Slime',
	Rarity: 7,
	History: 'Ghost Slimes formed when regular slimes wandered into haunted areas and absorbed spectral essence, gaining ethereal properties.',
	Location: 'Abandoned buildings, ancient ruins, and places with strong spiritual energy',
	FavoriteFood: 'Emotions, particularly nostalgia and melancholy',
	Ability: 'Can phase through solid objects and temporarily become invisible when threatened',
	Stats: {
		strength: 2,
		agility: 7,
		defense: 3,
		magic: 9,
		luck: 6,
		mysticism: 8
	},
	Lifespan: 'Potentially immortal, though they can fade away if they lose their spectral essence'
}, {
	SlimeName: 'King Slime',
	Rarity: 9,
	History: 'The legendary King Slime is said to be born once a century when a slime absorbs royal essence from an ancient crown.',
	Location: 'Hidden chambers in royal castles and within the deepest parts of enchanted forests',
	FavoriteFood: 'Precious metals and gems, particularly gold and rubies',
	Ability: 'Can command lesser slimes and temporarily grow to massive size, becoming nearly invulnerable',
	Stats: {
		strength: 8,
		agility: 4,
		defense: 8,
		magic: 7,
		luck: 7,
		mysticism: 9
	},
	Lifespan: 'Over 200 years, with some specimens reported to live for millennia'
}, {
	SlimeName: 'Golden Slime',
	Rarity: 10,
	History: 'Golden Slimes are incredibly rare mutations that occur when a slime is exposed to concentrated alchemical gold for generations.',
	Location: 'Ancient treasure vaults, alchemist laboratories, and the hearts of mountains rich with gold deposits',
	FavoriteFood: 'Gold dust and magical essences',
	Ability: 'Turns objects it consumes partially to gold and can detect precious metals at great distances',
	Stats: {
		strength: 6,
		agility: 3,
		defense: 9,
		magic: 8,
		luck: 10,
		mysticism: 8
	},
	Lifespan: 'Virtually immortal as long as they consume small amounts of gold regularly'
}];
// Sort SlimeInfo by rarity (highest to lowest)
SlimeInfo = sortSlimesByRarity(SlimeInfo);
// Update slimes array based on the new sorted SlimeInfo
slimes = SlimeInfo.map(function (slime, index) {
	// Get the appropriate slime asset name based on the SlimeName
	var slimeName = slime.SlimeName.replace(/\s+/g, '');
	return slimeName;
});
// Extract arrays for backward compatibility and easier access
var slimeNames = SlimeInfo.map(function (slime) {
	return slime.SlimeName;
});
var rarityValues = SlimeInfo.map(function (slime) {
	return slime.Rarity;
});
var histories = SlimeInfo.map(function (slime) {
	return slime.History;
});
var locations = SlimeInfo.map(function (slime) {
	return slime.Location;
});
var favoriteFoods = SlimeInfo.map(function (slime) {
	return slime.FavoriteFood;
});
var abilities = SlimeInfo.map(function (slime) {
	return slime.Ability;
});
var stats = SlimeInfo.map(function (slime) {
	return slime.Stats;
});
var lifespans = SlimeInfo.map(function (slime) {
	return slime.Lifespan;
});
// Create text display for slime name
var slimeNameText = new Text2(slimeNames[currentSlimeIndex], {
	size: 100,
	fill: 0xFFFFFF
});
slimeNameText.anchor.set(0.5, 0.5);
slimeNameText.x = 0;
slimeNameText.y = interfaz.height / 2;
// Create a slime and add it to the scene
var slime = new Slime();
// Position slime at the center of BG and set base position
var centerX = bg.width / 2;
var centerY = bg.height / 2;
slime.setBasePosition(centerX, centerY);
// Set initial properties for animations
slime.alpha = 1;
slime.scaleX = 1;
slime.scaleY = 1;
// Play background music
LK.playMusic('BGSong3');
// --- Info Panel for BGMenu ---
var infoPanelHeight = bgMenu.height - interfaz.height - 40;
var infoPanelWidth = bgMenu.width;
var infoPanelY = bgMenu.y + interfaz.height + 20;
var infoPanelX = bgMenu.x + (bgMenu.width - infoPanelWidth) / 2; // Center horizontally
// Create a container for the info panel
var infoPanel = new Container();
infoPanel.x = infoPanelX;
infoPanel.y = infoPanelY;
// No background for the info panel
// Prepare info categories and data
var infoCategories = [{
	title: "Rarity",
	get: function get(i) {
		var rarityValue = SlimeInfo[i].Rarity;
		this.currentRarityValue = rarityValue;
		return rarityNamesByValue[rarityValue];
	}
}, {
	title: "History",
	get: function get(i) {
		return SlimeInfo[i].History;
	}
}, {
	title: "Location",
	get: function get(i) {
		return SlimeInfo[i].Location;
	}
}, {
	title: "Favorite Food",
	get: function get(i) {
		return SlimeInfo[i].FavoriteFood;
	}
}, {
	title: "Ability",
	get: function get(i) {
		return SlimeInfo[i].Ability;
	}
}, {
	title: "Stats",
	get: function get(i) {
		var s = SlimeInfo[i].Stats;
		// Create visual stat bars with colored values using actual colors instead of tags
		function formatStat(name, value) {
			var barChars = "■".repeat(value);
			var emptyChars = "□".repeat(10 - value);
			return name + ": " + value + " [" + barChars + emptyChars + "]";
		}
		// Create a single column with all 6 stats
		var statText = "";
		statText += formatStat("Strength", s.strength) + "\n";
		statText += formatStat("Agility", s.agility) + "\n";
		statText += formatStat("Defense", s.defense) + "\n";
		statText += formatStat("Magic", s.magic) + "\n";
		statText += formatStat("Luck", s.luck) + "\n";
		statText += formatStat("Mysticism", s.mysticism);
		return statText;
	}
}, {
	title: "Lifespan",
	get: function get(i) {
		return SlimeInfo[i].Lifespan;
	}
}];
// Create a container for the scrollable text
var infoTextContainer = new Container();
infoTextContainer.x = 30;
infoTextContainer.y = 30; // Add top margin
// Function to update info text for current slime
function updateInfoPanel() {
	// Remove old children
	infoTextContainer.removeChildren();
	var y = 0;
	for (var c = 0; c < infoCategories.length; c++) {
		// Add extra spacing between sections if not the first section
		if (c > 0) {
			y += 80; // Add extra spacing between sections
		}
		// Title with gradient effect based on category
		var titleColors = {
			"Rarity": 0xFFD700,
			"History": 0xCF9FFF,
			"Location": 0x98FB98,
			"Favorite Food": 0xFF7F50,
			"Ability": 0x00BFFF,
			"Stats": 0xFF1493,
			"Lifespan": 0x00FA9A
		};
		var titleColor = titleColors[infoCategories[c].title] || 0xFFF7B2;
		var titleText = new Text2(infoCategories[c].title, {
			size: 110,
			fill: titleColor,
			font: "GillSans-Bold",
			align: "center",
			dropShadow: true,
			dropShadowColor: 0x000000,
			dropShadowDistance: 3,
			dropShadowAlpha: 0.5
		});
		titleText.anchor.set(0.5, 0);
		titleText.x = infoPanelWidth / 2 - 30;
		titleText.y = y;
		infoTextContainer.addChild(titleText);
		y += titleText.height + 6;
		// Info - wrap text to fit screen width
		var infoContent = infoCategories[c].get(currentSlimeIndex);
		var wrappedText = infoContent;
		// Only apply text wrapping if not the stats category (which already has formatting)
		if (infoCategories[c].title !== "Stats") {
			wrappedText = wrapText(infoContent, infoPanelWidth - 60, 85); // Wrap text with some padding
		}
		// Choose text color based on category
		var textColors = {
			"Rarity": 0xFFFACD,
			"History": 0xE6E6FA,
			"Location": 0xF0FFF0,
			"Favorite Food": 0xFFE4E1,
			"Ability": 0xE0FFFF,
			"Stats": 0xFFE4E1,
			"Lifespan": 0xF0FFFF
		};
		var textColor = textColors[infoCategories[c].title] || 0xFFFFFF;
		var infoText = new Text2(wrappedText, {
			size: 85,
			fill: textColor,
			font: "GillSans",
			align: infoCategories[c].title === "Stats" ? "left" : "center",
			dropShadow: true,
			dropShadowColor: 0x333333,
			dropShadowDistance: 2,
			dropShadowAlpha: 0.3
		});
		// Set anchor based on content type
		if (infoCategories[c].title === "Stats") {
			infoText.anchor.set(0.5, 0); // Center align stats too
			infoText.x = infoPanelWidth / 2 - 30;
		} else {
			infoText.anchor.set(0.5, 0); // Center align for other content
			infoText.x = infoPanelWidth / 2 - 30;
		}
		infoText.y = y + 20;
		infoTextContainer.addChild(infoText);
		// If this is the rarity category, add colored stars
		if (infoCategories[c].title === "Rarity" && infoCategories[c].currentRarityValue) {
			var starContainer = new Container();
			starContainer.x = infoPanelWidth / 2 - 30;
			starContainer.y = y + infoText.height + 40;
			var rarityValue = infoCategories[c].currentRarityValue;
			var starSpacing = 110,
				totalWidth = (rarityValue - 1) * starSpacing;
			var startX = -totalWidth / 2;
			for (var s = 0; s < rarityValue; s++) {
				var star = new Star();
				star.x = startX + s * starSpacing;
				star.y = 20;
				star.alpha = 0;
				star.scale.x = star.scale.y = 0.5;
				star.setColorByRarity(rarityValue);
				starContainer.addChild(star);
				(function (targetStar, delay) {
					LK.setTimeout(function () {
						tween(targetStar, {
							alpha: 1,
							scaleX: 1,
							scaleY: 1
						}, {
							duration: 400,
							easing: tween.easeOut
						});
					}, delay);
				})(star, s * 200);
			}
			infoTextContainer.addChild(starContainer);
			y += 80;
		}
		y += infoText.height + 24;
	}
	infoTextContainer.totalHeight = y;
}
updateInfoPanel();
// --- Scrolling logic for info panel with visual enhancements ---
var scrollOffset = 0;
var maxScroll = 0;
function updateScrollLimits() {
	maxScroll = Math.max(0, infoTextContainer.totalHeight - infoPanelHeight + 40 + 60); // Add 60px to account for top and bottom margins
	// Create smooth bounce effect when reaching limits
	if (scrollOffset < 0) {
		scrollOffset = 0;
		tween(infoTextContainer, {
			y: 30
		}, {
			duration: 300,
			easing: tween.elasticOut
		});
	}
	if (scrollOffset > maxScroll) {
		scrollOffset = maxScroll;
		tween(infoTextContainer, {
			y: 30 - maxScroll
		}, {
			duration: 300,
			easing: tween.elasticOut
		});
	}
	// Apply smooth scrolling
	if (!scrollTweenActive && isScrolling === false) {
		tween(infoTextContainer, {
			y: 30 - scrollOffset
		}, {
			duration: 100,
			easing: tween.easeOut
		});
	} else {
		infoTextContainer.y = 30 - scrollOffset; // Apply top margin to starting position
	}
}
updateScrollLimits();
// Touch/mouse drag to scroll with inertia and visual feedback
var isScrolling = false,
	lastScrollY = 0,
	scrollVelocity = 0,
	lastScrollTime = 0,
	scrollTweenActive = false,
	scrollTracker = [];
infoPanel.interactive = true;
infoPanel.down = function (x, y, obj) {
	isScrolling = true;
	lastScrollY = y;
	lastScrollTime = Date.now();
	scrollTracker = []; // Reset scroll tracking
	if (scrollTweenActive) {
		tween.stop(infoTextContainer, {
			y: true
		});
		scrollTweenActive = false;
	}
};
infoPanel.move = function (x, y, obj) {
	if (isScrolling) {
		var currentTime = Date.now();
		var timeDelta = currentTime - lastScrollTime;
		var dy = y - lastScrollY;
		// Track last few movements for better momentum calculation
		scrollTracker.push({
			dy: dy,
			time: timeDelta
		});
		if (scrollTracker.length > 5) {
			scrollTracker.shift();
		}
		if (timeDelta > 0) {
			scrollVelocity = dy / timeDelta * 15;
		}
		scrollOffset -= dy;
		updateScrollLimits();
		lastScrollY = y;
		lastScrollTime = currentTime;
	}
};
infoPanel.up = function (x, y, obj) {
	if (isScrolling) {
		isScrolling = false;
		// Calculate average velocity from recent movements for smoother scroll
		var recentVelocity = 0;
		var totalWeight = 0;
		for (var i = 0; i < scrollTracker.length; i++) {
			var weight = (i + 1) / scrollTracker.length;
			recentVelocity += scrollTracker[i].dy / scrollTracker[i].time * weight;
			totalWeight += weight;
		}
		if (totalWeight > 0) {
			scrollVelocity = recentVelocity / totalWeight * 15;
		}
		if (Math.abs(scrollVelocity) > 0.1) {
			var targetScroll = Math.max(0, Math.min(maxScroll, scrollOffset - scrollVelocity * 50));
			var targetY = 30 - targetScroll;
			scrollTweenActive = true;
			tween(infoTextContainer, {
				y: targetY
			}, {
				duration: 1000,
				easing: tween.easeOutQuint,
				onFinish: function onFinish() {
					scrollOffset = 30 - infoTextContainer.y;
					scrollTweenActive = false;
				}
			});
		}
	}
};
// Unified handler for both navigation buttons
function createButtonHandler(direction) {
	return function (x, y, obj) {
		changeSlime(direction);
		updateInfoPanel();
		updateScrollLimits();
	};
}
leftButton.down = createButtonHandler('prev');
rightButton.down = createButtonHandler('next');
// When changing slime, update info panel and scroll position
function updateSlimeAndInfo() {
	// Stop existing tweens before starting new ones to prevent animation conflicts
	tween.stop(slime);
	// Enhanced slime transition effects with color flash and particle-like animation
	tween(slime, {
		alpha: 0,
		scaleX: 0.8,
		scaleY: 0.8,
		rotation: -0.1
	}, {
		duration: 300,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			// Flash background with slime color
			var slimeColors = [0xa154b0, 0xd6f1ff, 0x757eff, 0xa3a3a3, 0xff5c5c, 0x303030, 0x0dbf51, 0x794311, 0xffe600, 0x4f226d, 0xf7f497];
			LK.effects.flashObject(bg, slimeColors[currentSlimeIndex], 300);
			slime.removeChildren();
			slime.attachAsset(slimes[currentSlimeIndex], {
				anchorX: 0.5,
				anchorY: 0.5,
				width: 500,
				height: 500
			});
			// Reset to base position to prevent drift
			slime.x = slime.baseX;
			slime.y = slime.baseY;
			slime.alpha = 0;
			slime.scaleX = 0.8;
			slime.scaleY = 0.8;
			slime.rotation = 0.1;
			// More dynamic entrance animation
			tween(slime, {
				alpha: 1,
				scaleX: 1.2,
				scaleY: 1.2,
				rotation: 0
			}, {
				duration: 400,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(slime, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 500,
						easing: tween.elasticOut
					});
					// Add gentle bobbing animation but store a reference to the initial position
					var initialY = bg.height / 2; // Store original position
					LK.setTimeout(function () {
						tween(slime, {
							y: initialY - 15
						}, {
							duration: 1200,
							easing: tween.easeInOut,
							repeat: -1,
							yoyo: true
						});
					}, 500);
				}
			});
		}
	});
	// Define a map of slime names to colors
	var slimeColorMap = {
		'ClasicSlime': 0xa154b0,
		// ClasicSlime (purple)
		'SnowySlime': 0xd6f1ff,
		// SnowySlime (light blue)
		'WaterSlime': 0x757eff,
		// WaterSlime (blue)
		'RockSlime': 0xa3a3a3,
		// RockSlime (gray)
		'FireSlime': 0xff5c5c,
		// FireSlime (red)
		'ShadowSlime': 0x303030,
		// ShadowSlime (dark gray)
		'ForestSlime': 0x0dbf51,
		// ForestSlime (green)
		'BeastSlime': 0x794311,
		// BeastSlime (brown)
		'LuckySlime': 0xffe600,
		// LuckySlime (yellow)
		'RunicSlime': 0x4f226d,
		// RunicSlime (dark purple)
		'DivineSlime': 0xf7f497,
		// DivineSlime (light yellow)
		'FruitSlime': 0xbd2e97,
		// FruitSlime (pink/magenta)
		'GhostSlime': 0x8675fb,
		// GhostSlime (light purple)
		'KingSlime': 0x8fc62a,
		// KingSlime (lime green)
		'GoldenSlime': 0xe6ca43 // GoldenSlime (gold)
	};
	// Generate slimeColors array based on the new order of SlimeInfo
	var slimeColors = SlimeInfo.map(function (slime) {
		var slimeName = slime.SlimeName.replace(/\s+/g, '');
		return slimeColorMap[slimeName] || 0xFFFFFF; // Default to white if not found
	});
	tween(slimeNameText, {
		alpha: 0,
		scaleX: 0.9,
		scaleY: 0.9
	}, {
		duration: 200,
		easing: tween.easeOut,
		onFinish: function onFinish() {
			slimeNameText.setText(SlimeInfo[currentSlimeIndex].SlimeName);
			// Initialize style object if it doesn't exist
			if (!slimeNameText.style) {
				slimeNameText.style = {};
			}
			// Apply slime-specific text color
			slimeNameText.style.fill = slimeColors[currentSlimeIndex];
			slimeNameText.style.dropShadow = true;
			slimeNameText.style.dropShadowColor = 0x000000;
			slimeNameText.style.dropShadowDistance = 3;
			slimeNameText.style.dropShadowAlpha = 0.5;
			// Create more dynamic animation for the name
			tween(slimeNameText, {
				alpha: 1,
				scaleX: 1.1,
				scaleY: 1.1
			}, {
				duration: 200,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					tween(slimeNameText, {
						scaleX: 1,
						scaleY: 1
					}, {
						duration: 400,
						easing: tween.elasticOut
					});
				}
			});
		}
	});
	// Update content and scroll position
	updateInfoPanel();
	scrollOffset = 0;
	updateScrollLimits();
	// Fade in info container
	infoTextContainer.alpha = 0;
	tween(infoTextContainer, {
		alpha: 1
	}, {
		duration: 400,
		easing: tween.easeOut
	});
}
function changeSlime(direction) {
	currentSlimeIndex = direction === 'next' ? (currentSlimeIndex + 1) % slimes.length : (currentSlimeIndex - 1 + slimes.length) % slimes.length;
	updateSlimeAndInfo();
}
/*
* Asset initialization
*/
game.addChild(bgMenu);
game.addChild(infoPanel);
infoPanel.addChild(infoTextContainer);
game.addChild(bg);
game.addChild(interfaz);
interfaz.addChild(leftButton);
interfaz.addChild(rightButton);
interfaz.addChild(slimeNameText);
game.addChild(slime);

===================================================================
--- original.js
+++ change.js