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

/**** 
* Classes
****/ 
var BattleUI = Container.expand(function () {
	var self = Container.call(this);
	var bg = self.attachAsset('battleBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	bg.alpha = 0.9;
	self.hunkDisplay = null;
	self.resistanceBar = null;
	self.resistanceFill = null;
	self.spellButtons = [];
	self.setup = function (hunk) {
		self.hunkDisplay = self.addChild(new Container());
		var hunkAssets = ['hunk', 'hunk2', 'hunk3', 'hunk4'];
		// For animated hunks, we need to create an animated display
		if (hunk.hunkType === 0) {
			// Create animation frames for battle display - mushroom hunk
			self.hunkIdleFrames = [];
			self.currentBattleFrame = 0;
			var frameAssets = ['hunk', 'hunka', 'hunkb', 'hunkc', 'hunkd', 'hunke'];
			for (var i = 0; i < frameAssets.length; i++) {
				var frame = self.hunkDisplay.attachAsset(frameAssets[i], {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 2,
					scaleY: 2,
					alpha: i === 0 ? 1 : 0
				});
				self.hunkIdleFrames.push(frame);
			}
			// Start battle idle animation
			self.startBattleIdleAnimation();
		} else if (hunk.hunkType === 1) {
			// Create animation frames for battle display - hunk2
			self.hunkIdleFrames = [];
			self.currentBattleFrame = 0;
			var frameAssets = ['hunk2', 'hunk2a', 'hunk2b', 'hunk2c', 'hunk2d'];
			for (var i = 0; i < frameAssets.length; i++) {
				var frame = self.hunkDisplay.attachAsset(frameAssets[i], {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 2,
					scaleY: 2,
					alpha: i === 0 ? 1 : 0
				});
				self.hunkIdleFrames.push(frame);
			}
			// Start battle idle animation
			self.startBattleIdleAnimation();
		} else if (hunk.hunkType === 2) {
			// Create animation frames for battle display - hunk3
			self.hunkIdleFrames = [];
			self.currentBattleFrame = 0;
			var frameAssets = ['hunk3', 'hunk3a', 'hunk3b', 'hunk3c', 'hunk3d'];
			for (var i = 0; i < frameAssets.length; i++) {
				var frame = self.hunkDisplay.attachAsset(frameAssets[i], {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 2,
					scaleY: 2,
					alpha: i === 0 ? 1 : 0
				});
				self.hunkIdleFrames.push(frame);
			}
			// Start battle idle animation
			self.startBattleIdleAnimation();
		} else if (hunk.hunkType === 3) {
			// Create animation frames for battle display - hunk4
			self.hunkIdleFrames = [];
			self.currentBattleFrame = 0;
			var frameAssets = ['hunk4', 'hunk4a', 'hunk4b', 'hunk4c', 'hunk4d'];
			for (var i = 0; i < frameAssets.length; i++) {
				var frame = self.hunkDisplay.attachAsset(frameAssets[i], {
					anchorX: 0.5,
					anchorY: 0.5,
					scaleX: 2,
					scaleY: 2,
					alpha: i === 0 ? 1 : 0
				});
				self.hunkIdleFrames.push(frame);
			}
			// Start battle idle animation
			self.startBattleIdleAnimation();
		} else {
			// Normal static display for other hunks
			var hunkGraphic = self.hunkDisplay.attachAsset(hunkAssets[hunk.hunkType], {
				anchorX: 0.5,
				anchorY: 0.5,
				scaleX: 2,
				scaleY: 2
			});
		}
		self.hunkDisplay.y = -200;
		var barBg = self.attachAsset('resistanceBar', {
			anchorX: 0.5,
			anchorY: 0.5,
			y: 50
		});
		self.resistanceFill = self.attachAsset('resistanceFill', {
			anchorX: 0,
			anchorY: 0.5,
			x: -150,
			y: 50
		});
		self.updateResistance(hunk.resistance, hunk.maxResistance);
		var spell1 = self.attachAsset('spellButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: -200,
			y: 200
		});
		spell1.interactive = true;
		self.spellButtons.push(spell1);
		var spell1Text = new Text2('Hypnotize', {
			size: 40,
			fill: 0xFFFFFF
		});
		spell1Text.anchor.set(0.5, 0.5);
		spell1.addChild(spell1Text);
		var spell2 = self.attachAsset('spellButton', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 200,
			y: 200
		});
		spell2.interactive = true;
		self.spellButtons.push(spell2);
		var spell2Text = new Text2('Charm', {
			size: 40,
			fill: 0xFFFFFF
		});
		spell2Text.anchor.set(0.5, 0.5);
		spell2.addChild(spell2Text);
		var captureBtn = self.attachAsset('crystal', {
			anchorX: 0.5,
			anchorY: 0.5,
			x: 0,
			y: 350,
			scaleX: 1.5,
			scaleY: 1.5
		});
		captureBtn.interactive = true;
		self.captureButton = captureBtn;
		var captureText = new Text2('Capture', {
			size: 30,
			fill: 0xFFFFFF
		});
		captureText.anchor.set(0.5, 0.5);
		captureBtn.addChild(captureText);
	};
	self.updateResistance = function (current, max) {
		if (self.resistanceFill) {
			self.resistanceFill.scale.x = current / max;
		}
	};
	self.startBattleIdleAnimation = function () {
		if (!self.hunkIdleFrames || self.hunkIdleFrames.length === 0) return;
		var currentFrame = self.hunkIdleFrames[self.currentBattleFrame];
		var nextFrameIndex = (self.currentBattleFrame + 1) % self.hunkIdleFrames.length;
		var nextFrame = self.hunkIdleFrames[nextFrameIndex];
		tween(currentFrame, {
			alpha: 0
		}, {
			duration: 150,
			easing: tween.linear
		});
		tween(nextFrame, {
			alpha: 1
		}, {
			duration: 150,
			easing: tween.linear
		});
		self.currentBattleFrame = nextFrameIndex;
		self.battleAnimationTimer = LK.setTimeout(function () {
			self.startBattleIdleAnimation();
		}, 200);
	};
	self.cleanup = function () {
		if (self.battleAnimationTimer) {
			LK.clearTimeout(self.battleAnimationTimer);
		}
		self.destroy();
	};
	return self;
});
var Bloodmage = Container.expand(function () {
	var self = Container.call(this);
	var body = self.attachAsset('bloodmage', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	self.velocityX = 0;
	self.velocityY = 0;
	self.grounded = false;
	self.doubleJumpAvailable = true;
	self.speed = 8;
	self.jumpPower = 25;
	self.gravity = 1.2;
	self.isMoving = false;
	self.idleFrames = [];
	self.walkFrames = [];
	self.currentIdleFrame = 0;
	self.currentWalkFrame = 0;
	self.idleAnimationTimer = 0;
	self.walkAnimationTimer = 0;
	self.jumpFrames = [];
	self.currentJumpFrame = 0;
	self.jumpAnimationTimer = 0;
	self.isJumping = false;
	self.facingDirection = -1; // -1 for right (assets face left), 1 for left
	self.lastJumpTime = 0;
	self.jumpCount = 0;
	// Create idle animation frames
	self.idleFrames.push(self.attachAsset('playeridle', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.idleFrames.push(self.attachAsset('playeridle2', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.idleFrames.push(self.attachAsset('playeridle3', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.idleFrames.push(self.attachAsset('playeridle4', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.idleFrames.push(self.attachAsset('playeridle5', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	// Create walking animation frames
	self.walkFrames.push(self.attachAsset('playerwalk', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk2', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk3', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk4', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk5', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk6', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk7', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.walkFrames.push(self.attachAsset('playerwalk8', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	// Create jump animation frames
	self.jumpFrames.push(self.attachAsset('playerjump', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.jumpFrames.push(self.attachAsset('playerjump2', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.jumpFrames.push(self.attachAsset('playerjump3', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.jumpFrames.push(self.attachAsset('playerjump4', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.jumpFrames.push(self.attachAsset('playerjump5', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.jumpFrames.push(self.attachAsset('playerjump6', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0
	}));
	self.startIdleAnimation = function () {
		if (self.isMoving) return;
		// Hide main body and walking frames, show current idle frame
		body.alpha = 0;
		for (var i = 0; i < self.walkFrames.length; i++) {
			self.walkFrames[i].alpha = 0;
		}
		for (var i = 0; i < self.idleFrames.length; i++) {
			self.idleFrames[i].alpha = i === self.currentIdleFrame ? 1 : 0;
		}
		// Smoothly fade out current frame and fade in next frame
		var currentFrame = self.idleFrames[self.currentIdleFrame];
		var nextFrameIndex = (self.currentIdleFrame + 1) % self.idleFrames.length;
		var nextFrame = self.idleFrames[nextFrameIndex];
		tween(currentFrame, {
			alpha: 0
		}, {
			duration: 100
		});
		tween(nextFrame, {
			alpha: 1
		}, {
			duration: 100
		});
		self.currentIdleFrame = nextFrameIndex;
		// Schedule next frame change
		self.idleAnimationTimer = LK.setTimeout(function () {
			if (!self.isMoving) {
				self.startIdleAnimation();
			}
		}, 150);
	};
	self.stopIdleAnimation = function () {
		LK.clearTimeout(self.idleAnimationTimer);
		// Hide main body and idle frames
		body.alpha = 0;
		for (var i = 0; i < self.idleFrames.length; i++) {
			self.idleFrames[i].alpha = 0;
		}
		// Only start walking if we're actually moving
		if (self.isMoving) {
			self.startWalkingAnimation();
		}
	};
	self.startWalkingAnimation = function () {
		if (!self.isMoving) return;
		// Hide idle frames and show current walk frame
		for (var i = 0; i < self.idleFrames.length; i++) {
			self.idleFrames[i].alpha = 0;
		}
		for (var i = 0; i < self.walkFrames.length; i++) {
			self.walkFrames[i].alpha = i === self.currentWalkFrame ? 1 : 0;
		}
		// Update facing direction based on velocity
		if (self.velocityX > 0) self.facingDirection = -1; // Moving right, but assets face left by default
		else if (self.velocityX < 0) self.facingDirection = 1; // Moving left, matches asset default
		// Apply direction to all frames
		for (var i = 0; i < self.walkFrames.length; i++) {
			self.walkFrames[i].scale.x = Math.abs(self.walkFrames[i].scale.x) * self.facingDirection;
		}
		// Smoothly fade out current frame and fade in next frame
		var currentFrame = self.walkFrames[self.currentWalkFrame];
		var nextFrameIndex = (self.currentWalkFrame + 1) % self.walkFrames.length;
		var nextFrame = self.walkFrames[nextFrameIndex];
		tween(currentFrame, {
			alpha: 0
		}, {
			duration: 50
		});
		tween(nextFrame, {
			alpha: 1
		}, {
			duration: 50
		});
		self.currentWalkFrame = nextFrameIndex;
		// Schedule next frame change
		self.walkAnimationTimer = LK.setTimeout(function () {
			if (self.isMoving) {
				self.startWalkingAnimation();
			}
		}, 100);
	};
	self.stopWalkingAnimation = function () {
		LK.clearTimeout(self.walkAnimationTimer);
		// Hide walking frames
		for (var i = 0; i < self.walkFrames.length; i++) {
			self.walkFrames[i].alpha = 0;
		}
	};
	self.startJumpAnimation = function () {
		// Hide all other frames
		body.alpha = 0;
		for (var i = 0; i < self.idleFrames.length; i++) {
			self.idleFrames[i].alpha = 0;
		}
		for (var i = 0; i < self.walkFrames.length; i++) {
			self.walkFrames[i].alpha = 0;
		}
		// Apply direction to jump frames
		for (var i = 0; i < self.jumpFrames.length; i++) {
			self.jumpFrames[i].scale.x = Math.abs(self.jumpFrames[i].scale.x) * self.facingDirection;
		}
		// Calculate which frame to show based on jump progress
		var jumpProgress = 0;
		if (self.velocityY < -15) {
			jumpProgress = 0; // Start of jump
		} else if (self.velocityY < -5) {
			jumpProgress = 1; // Rising
		} else if (self.velocityY < 5) {
			jumpProgress = 2; // Peak
		} else if (self.velocityY < 15) {
			jumpProgress = 3; // Falling
		} else {
			jumpProgress = 4; // Landing
		}
		// Ensure we don't go past available frames
		var frameIndex = Math.min(jumpProgress, self.jumpFrames.length - 1);
		// Show appropriate jump frame
		for (var i = 0; i < self.jumpFrames.length; i++) {
			self.jumpFrames[i].alpha = i === frameIndex ? 1 : 0;
		}
	};
	self.stopJumpAnimation = function () {
		// Hide all jump frames
		for (var i = 0; i < self.jumpFrames.length; i++) {
			self.jumpFrames[i].alpha = 0;
		}
	};
	self.update = function () {
		self.velocityY += self.gravity;
		self.x += self.velocityX;
		self.y += self.velocityY;
		// Check if jumping
		var wasJumping = self.isJumping;
		self.isJumping = !self.grounded || Math.abs(self.velocityY) > 2;
		// Handle animation state
		var wasMoving = self.isMoving;
		self.isMoving = Math.abs(self.velocityX) > 0.1;
		if (self.isJumping) {
			// Handle jump animation
			if (!wasJumping) {
				// Just started jumping
				self.stopWalkingAnimation();
				self.stopIdleAnimation();
			}
			self.startJumpAnimation();
		} else {
			// Not jumping
			if (wasJumping) {
				// Just landed
				self.stopJumpAnimation();
				if (self.isMoving) {
					self.startWalkingAnimation();
				} else {
					self.startIdleAnimation();
				}
			} else {
				// Ground movement
				if (wasMoving && !self.isMoving) {
					// Just stopped moving
					self.stopWalkingAnimation();
					self.startIdleAnimation();
				} else if (!wasMoving && self.isMoving) {
					// Just started moving
					self.stopIdleAnimation();
				}
			}
		}
	};
	self.jump = function () {
		var jumpExecuted = false;
		if (self.grounded) {
			// First jump from ground
			self.velocityY = -self.jumpPower;
			self.grounded = false;
			self.doubleJumpAvailable = true; // Reset double jump availability when leaving ground
			LK.getSound('jump').play();
			jumpExecuted = true;
		} else if (self.doubleJumpAvailable && !self.grounded) {
			// Double jump in air - always use higher power
			self.velocityY = -self.jumpPower * 1.3;
			self.doubleJumpAvailable = false;
			LK.getSound('jump').play();
			jumpExecuted = true;
			// Create spell2 effect at the base of the character
			var spellEffect = worldContainer.attachAsset('spell2', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: self.x,
				y: self.y - 10,
				// Position at base of character (shoes level)
				alpha: 0.8
			});
			// Animate the spell effect - fade in and out quickly
			tween(spellEffect, {
				alpha: 0,
				scaleX: 1.5,
				scaleY: 1.5
			}, {
				duration: 400,
				easing: tween.easeOut,
				onFinish: function onFinish() {
					spellEffect.destroy();
				}
			});
		}
		return jumpExecuted;
	};
	return self;
});
var Building = Container.expand(function () {
	var self = Container.call(this);
	// Randomly choose between building assets
	var buildingAsset = Math.random() > 0.5 ? 'building' : 'Building2';
	var building = self.attachAsset(buildingAsset, {
		anchorX: 0.5,
		anchorY: 1.0
	});
	building.tint = 0x2a2a2a + Math.floor(Math.random() * 0x222222);
	// Randomly choose between neon sign assets
	var neonAsset = Math.random() > 0.5 ? 'neonSign' : 'neonsign2';
	var neonSign = self.attachAsset(neonAsset, {
		anchorX: 0.5,
		anchorY: 0.5,
		x: Math.random() * 200 - 100,
		y: -400 + Math.random() * 100
	});
	neonSign.alpha = 0.8;
	// Apply random tint to neon signs for variety
	neonSign.tint = [0xFF00FF, 0x00FFFF, 0xFFFF00, 0xFF0088, 0x88FF00][Math.floor(Math.random() * 5)];
	// Animate neon sign with random duration
	var animDuration = 1500 + Math.random() * 1000;
	tween(neonSign, {
		alpha: 0.3
	}, {
		duration: animDuration,
		easing: tween.easeInOut,
		onFinish: function onFinish() {
			tween(neonSign, {
				alpha: 0.8
			}, {
				duration: animDuration,
				easing: tween.easeInOut
			});
		}
	});
	return self;
});
var Hunk = Container.expand(function () {
	var self = Container.call(this);
	// Randomly select one of the 4 hunk types
	var hunkAssets = ['hunk', 'hunk2', 'hunk3', 'hunk4'];
	self.hunkType = Math.floor(Math.random() * hunkAssets.length);
	var body = self.attachAsset(hunkAssets[self.hunkType], {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Different resistance values for different hunk types
	self.resistance = [100, 120, 150, 80][self.hunkType];
	self.maxResistance = self.resistance;
	self.captured = false;
	self.idleFrames = [];
	self.currentIdleFrame = 0;
	self.idleAnimationTimer = 0;
	self.startIdleAnimation = function () {
		if (self.hunkType !== 0 && self.hunkType !== 1 && self.hunkType !== 2 && self.hunkType !== 3 || self.captured) return;
		// Get current and next frame
		var currentFrame = self.idleFrames[self.currentIdleFrame];
		var nextFrameIndex = (self.currentIdleFrame + 1) % self.idleFrames.length;
		var nextFrame = self.idleFrames[nextFrameIndex];
		// Smoothly fade between frames
		tween(currentFrame, {
			alpha: 0
		}, {
			duration: 150,
			easing: tween.linear
		});
		tween(nextFrame, {
			alpha: 1
		}, {
			duration: 150,
			easing: tween.linear
		});
		self.currentIdleFrame = nextFrameIndex;
		// Schedule next frame change
		self.idleAnimationTime = LK.setTimeout(function () {
			if (!self.captured && (self.hunkType === 0 || self.hunkType === 1 || self.hunkType === 2 || self.hunkType === 3)) {
				self.startIdleAnimation();
			}
		}, 200);
	};
	// If this is hunk (index 0), set up idle animation with hunk and hunka-e
	if (self.hunkType === 0) {
		// Hide main body for animated hunk as we'll use animation frames
		body.alpha = 0;
		// Create idle animation frames for mushroom hunk
		self.idleFrames.push(self.attachAsset('hunk', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 1
		}));
		self.idleFrames.push(self.attachAsset('hunka', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunkb', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunkc', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunkd', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunke', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		// Start idle animation
		self.startIdleAnimation();
	} else if (self.hunkType === 1) {
		// Hide main body for animated hunk2 as we'll use animation frames
		body.alpha = 0;
		// Create idle animation frames for hunk2
		self.idleFrames.push(self.attachAsset('hunk2', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 1
		}));
		self.idleFrames.push(self.attachAsset('hunk2a', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk2b', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk2c', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk2d', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		// Start idle animation
		self.startIdleAnimation();
	} else if (self.hunkType === 2) {
		// Hide main body for animated hunk3 as we'll use animation frames
		body.alpha = 0;
		// Create idle animation frames for hunk3
		self.idleFrames.push(self.attachAsset('hunk3', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 1
		}));
		self.idleFrames.push(self.attachAsset('hunk3a', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk3b', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk3c', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk3d', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		// Start idle animation
		self.startIdleAnimation();
	} else if (self.hunkType === 3) {
		// Hide main body for animated hunk4 as we'll use animation frames
		body.alpha = 0;
		// Create idle animation frames for hunk4
		self.idleFrames.push(self.attachAsset('hunk4', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 1
		}));
		self.idleFrames.push(self.attachAsset('hunk4a', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk4b', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk4c', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		self.idleFrames.push(self.attachAsset('hunk4d', {
			anchorX: 0.5,
			anchorY: 1.0,
			alpha: 0
		}));
		// Start idle animation
		self.startIdleAnimation();
	}
	self.stopIdleAnimation = function () {
		if (self.idleAnimationTimer) {
			LK.clearTimeout(self.idleAnimationTimer);
			self.idleAnimationTimer = 0;
		}
		// Hide all idle frames
		for (var i = 0; i < self.idleFrames.length; i++) {
			self.idleFrames[i].alpha = 0;
		}
	};
	// Override destroy to clean up animation
	var originalDestroy = self.destroy;
	self.destroy = function () {
		self.stopIdleAnimation();
		originalDestroy.call(self);
	};
	return self;
});
var Platform = Container.expand(function () {
	var self = Container.call(this);
	// Randomly select one of the 4 platform types
	var platformAssets = ['platform', 'platform2', 'platform3', 'platform4'];
	var selectedPlatform = platformAssets[Math.floor(Math.random() * platformAssets.length)];
	var platform = self.attachAsset(selectedPlatform, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Store platform type for reference
	self.platformType = selectedPlatform;
	return self;
});

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

/**** 
* Game Code
****/ 
game.setBackgroundColor(0x0a0a0a);
var bloodmage = null;
var platforms = [];
var buildings = [];
var hunks = [];
var currentHunk = null;
var battleUI = null;
var inBattle = false;
var cameraX = 0;
var worldContainer = null;
var trackpadPressed = false;
var trackpadAngle = 0;
var capturedHunks = storage.capturedHunks || [];
var brostiary = storage.brostiary || {};
var bropageOverlay = null;
var bropageShowing = false;
var lastJumpTime = 0;
var doubleTapThreshold = 300; // milliseconds for double tap detection
worldContainer = game.addChild(new Container());
function createLevel() {
	// Add bg2 as the furthest background layer to fill empty spaces
	var background2 = worldContainer.attachAsset('bg2', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048,
		y: 1366,
		scaleX: 1.5,
		scaleY: 1.5
	});
	// Add main background layer on top
	var background = worldContainer.attachAsset('bg', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 2048,
		y: 1366,
		scaleX: 0.6,
		scaleY: 0.6
	});
	// Removed tint to make background brighter
	for (var i = 0; i < 5; i++) {
		var building = new Building();
		building.x = 400 + i * 800;
		building.y = 1800;
		buildings.push(building);
		worldContainer.addChild(building);
	}
	var ground = new Platform();
	ground.x = 1024;
	ground.y = 2000;
	ground.scale.x = 10;
	platforms.push(ground);
	worldContainer.addChild(ground);
	for (var i = 0; i < 8; i++) {
		var platform = new Platform();
		platform.x = 300 + i * 500;
		platform.y = 1600 - i % 3 * 200;
		platforms.push(platform);
		worldContainer.addChild(platform);
		// Only spawn hunks on platforms that are far enough from starting position
		if (i % 2 === 1 && i > 1) {
			// Skip first potential hunk spawn (i=1) to ensure player has space
			var hunk = new Hunk();
			hunk.x = platform.x;
			hunk.y = platform.y - 20;
			hunks.push(hunk);
			worldContainer.addChild(hunk);
		}
	}
	bloodmage = new Bloodmage();
	bloodmage.x = 150;
	bloodmage.y = 1800;
	worldContainer.addChild(bloodmage);
	// Start idle animation initially
	bloodmage.startIdleAnimation();
}
createLevel();
var trackpadBg = LK.gui.bottomLeft.attachAsset('trackpadBg', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 200,
	y: -200
});
trackpadBg.interactive = true;
var trackpadThumb = LK.gui.bottomLeft.attachAsset('trackpadThumb', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: 200,
	y: -200
});
var jumpBtn = LK.gui.bottomRight.attachAsset('jumpButton', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -200,
	y: -200
});
jumpBtn.interactive = true;
// Direct event handlers for better responsiveness
trackpadBg.down = function (x, y, obj) {
	if (inBattle || bropageShowing) return;
	trackpadPressed = true;
	updateTrackpad(x, y);
};
trackpadBg.move = function (x, y, obj) {
	if (!trackpadPressed || inBattle || bropageShowing) return;
	updateTrackpad(x, y);
};
trackpadBg.up = function () {
	trackpadPressed = false;
	if (bloodmage) {
		bloodmage.velocityX = 0;
	}
	trackpadThumb.x = 200;
	trackpadThumb.y = -200;
};
jumpBtn.down = function () {
	if (bloodmage && !inBattle && !bropageShowing) {
		var _animateButtonBlink = function animateButtonBlink() {
			if (currentBlinkFrame < blinkFrames.length) {
				// Get the current frame asset and apply it to the button
				var frameAsset = LK.getAsset(blinkFrames[currentBlinkFrame], {
					anchorX: 0.5,
					anchorY: 0.5
				});
				// Replace button content temporarily
				// Keep jump button visible - just layer blink on top
				// Add blink frame to GUI
				var blinkFrame = LK.gui.bottomRight.addChild(frameAsset);
				blinkFrame.x = -200;
				blinkFrame.y = -200;
				// Animate the blink frame
				tween(blinkFrame, {
					alpha: 0.8
				}, {
					duration: 50,
					onFinish: function onFinish() {
						tween(blinkFrame, {
							alpha: 0
						}, {
							duration: 50,
							onFinish: function onFinish() {
								blinkFrame.destroy();
								currentBlinkFrame++;
								if (currentBlinkFrame < blinkFrames.length) {
									_animateButtonBlink();
								}
							}
						});
					}
				});
			}
		};
		// Start button blink animation
		var blinkFrames = ['buttonblink', 'buttonblink2', 'buttonblink3', 'buttonblink4'];
		var currentBlinkFrame = 0;
		_animateButtonBlink();
		var currentTime = Date.now();
		var timeSinceLastJump = currentTime - bloodmage.lastJumpTime;
		// Check for double tap timing
		if (timeSinceLastJump < doubleTapThreshold && bloodmage.jumpCount === 1 && bloodmage.grounded) {
			// Double tap detected - perform higher jump
			bloodmage.velocityY = -bloodmage.jumpPower * 1.5;
			bloodmage.grounded = false;
			bloodmage.doubleJumpAvailable = true;
			LK.getSound('jump').play();
			bloodmage.jumpCount = 0; // Reset for next sequence
		} else {
			// Normal jump attempt
			var jumpSuccess = bloodmage.jump();
			if (jumpSuccess) {
				bloodmage.lastJumpTime = currentTime;
				bloodmage.jumpCount = bloodmage.grounded ? 1 : 0; // Track if this was first jump
			}
		}
	}
};
var jumpText = new Text2('JUMP', {
	size: 40,
	fill: 0xFFFFFF
});
jumpText.anchor.set(0.5, 0.5);
jumpBtn.addChild(jumpText);
var scoreText = new Text2('Hunks: ' + capturedHunks.length, {
	size: 60,
	fill: 0xFF00FF
});
scoreText.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreText);
// Add brostiary icon to top right corner
var brostiaryIcon = LK.gui.topRight.attachAsset('brostiary', {
	anchorX: 0.5,
	anchorY: 0.5,
	x: -150,
	y: 150,
	scaleX: 1.5,
	scaleY: 1.5
});
brostiaryIcon.interactive = true;
brostiaryIcon.down = function () {
	showBropage();
};
function showBropage() {
	if (bropageShowing || inBattle) return;
	bropageShowing = true;
	// Create overlay container
	bropageOverlay = game.addChild(new Container());
	// Add semi-transparent background
	var bgOverlay = bropageOverlay.attachAsset('bropage', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: 1024,
		y: 1366,
		scaleX: 2,
		scaleY: 2.5
	});
	bgOverlay.alpha = 0.95;
	bgOverlay.interactive = true;
	// Add title text
	var titleText = new Text2('HUNK COLLECTION', {
		size: 80,
		fill: 0xFF00FF
	});
	titleText.anchor.set(0.5, 0.5);
	titleText.x = 1024;
	titleText.y = 500;
	bropageOverlay.addChild(titleText);
	// Display collected hunks information
	var hunkNames = ['Classic Hunk', 'Cyber Hunk', 'Mega Hunk', 'Mini Hunk'];
	var yOffset = 700;
	for (var i = 0; i < 4; i++) {
		var hunkText = new Text2(hunkNames[i] + ': ' + (brostiary[i] ? 'COLLECTED' : 'NOT FOUND'), {
			size: 60,
			fill: brostiary[i] ? 0x00FF00 : 0xFF0000
		});
		hunkText.anchor.set(0.5, 0.5);
		hunkText.x = 1024;
		hunkText.y = yOffset + i * 120;
		bropageOverlay.addChild(hunkText);
	}
	// Add collection stats
	var collectedCount = 0;
	for (var key in brostiary) {
		if (brostiary[key]) collectedCount++;
	}
	var statsText = new Text2('Total Collected: ' + collectedCount + '/4', {
		size: 70,
		fill: 0xFFFFFF
	});
	statsText.anchor.set(0.5, 0.5);
	statsText.x = 1024;
	statsText.y = 1200;
	bropageOverlay.addChild(statsText);
	// Add close instruction
	var closeText = new Text2('TAP ANYWHERE TO CLOSE', {
		size: 50,
		fill: 0xFFFF00
	});
	closeText.anchor.set(0.5, 0.5);
	closeText.x = 1024;
	closeText.y = 1500;
	bropageOverlay.addChild(closeText);
	// Handle close on tap
	bgOverlay.down = function () {
		closeBropage();
	};
}
function closeBropage() {
	if (!bropageShowing || !bropageOverlay) return;
	bropageShowing = false;
	bropageOverlay.destroy();
	bropageOverlay = null;
}
function updateCamera() {
	if (bloodmage) {
		var targetX = -bloodmage.x + 1024;
		cameraX += (targetX - cameraX) * 0.1;
		worldContainer.x = cameraX;
	}
}
function checkCollisions() {
	if (!bloodmage || inBattle) return;
	bloodmage.grounded = false;
	for (var i = 0; i < platforms.length; i++) {
		var platform = platforms[i];
		var platLeft = platform.x - platform.width * platform.scale.x / 2;
		var platRight = platform.x + platform.width * platform.scale.x / 2;
		var platTop = platform.y - platform.height / 2;
		var platBottom = platform.y + platform.height / 2;
		var mageLeft = bloodmage.x - 40;
		var mageRight = bloodmage.x + 40;
		var mageTop = bloodmage.y - 120;
		var mageBottom = bloodmage.y;
		if (mageRight > platLeft && mageLeft < platRight && mageBottom > platTop && mageTop < platBottom) {
			if (bloodmage.velocityY > 0 && mageBottom - bloodmage.velocityY <= platTop) {
				bloodmage.y = platTop;
				bloodmage.velocityY = 0;
				bloodmage.grounded = true;
				bloodmage.jumpCount = 0; // Reset jump count when landing
			}
		}
	}
	if (bloodmage.y > 2500) {
		bloodmage.x = 200;
		bloodmage.y = 1800;
		bloodmage.velocityX = 0;
		bloodmage.velocityY = 0;
	}
	for (var i = 0; i < hunks.length; i++) {
		var hunk = hunks[i];
		if (!hunk.captured && bloodmage.intersects(hunk)) {
			startBattle(hunk);
			break;
		}
	}
}
function startBattle(hunk) {
	inBattle = true;
	currentHunk = hunk;
	bloodmage.velocityX = 0;
	bloodmage.velocityY = 0;
	battleUI = game.addChild(new BattleUI());
	battleUI.x = 1024;
	battleUI.y = 1366;
	battleUI.setup(hunk);
	battleUI.spellButtons[0].down = function () {
		castSpell(25);
	};
	battleUI.spellButtons[1].down = function () {
		castSpell(15);
	};
	battleUI.captureButton.down = function () {
		attemptCapture();
	};
}
function castSpell(damage) {
	if (!currentHunk || !battleUI || !battleUI.hunkDisplay) return;
	currentHunk.resistance = Math.max(0, currentHunk.resistance - damage);
	battleUI.updateResistance(currentHunk.resistance, currentHunk.maxResistance);
	LK.getSound('spell').play();
	tween(battleUI.hunkDisplay, {
		rotation: Math.PI * 2
	}, {
		duration: 500,
		onFinish: function onFinish() {
			if (battleUI && battleUI.hunkDisplay) {
				battleUI.hunkDisplay.rotation = 0;
			}
		}
	});
}
function attemptCapture() {
	if (!currentHunk || !battleUI) return;
	if (currentHunk.resistance < 30) {
		LK.getSound('capture').play();
		currentHunk.captured = true;
		currentHunk.visible = false;
		// Stop idle animation for animated hunk
		if (currentHunk.hunkType === 0 || currentHunk.hunkType === 1 || currentHunk.hunkType === 2 || currentHunk.hunkType === 3) {
			currentHunk.stopIdleAnimation();
		}
		capturedHunks.push(currentHunk.hunkType);
		storage.capturedHunks = capturedHunks;
		if (!brostiary[currentHunk.hunkType]) {
			brostiary[currentHunk.hunkType] = true;
			storage.brostiary = brostiary;
		}
		scoreText.setText('Hunks: ' + capturedHunks.length);
		battleUI.cleanup();
		battleUI = null;
		inBattle = false;
		currentHunk = null;
		if (capturedHunks.length >= 10) {
			LK.showYouWin();
		}
	} else {
		LK.effects.flashObject(battleUI.captureButton, 0xFF0000, 500);
	}
}
game.down = function (x, y, obj) {
	if (inBattle || bropageShowing) return;
	// Convert game coordinates to local GUI coordinates for trackpad
	var localPos = LK.gui.bottomLeft.toLocal({
		x: x,
		y: y
	});
	var dx = localPos.x - 200;
	var dy = localPos.y - -200;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist < 150) {
		// Increased hit area
		trackpadPressed = true;
		trackpadAngle = Math.atan2(dy, dx);
		updateTrackpad(x, y);
		return; // Exit early to prevent overlap
	}
	// Convert game coordinates to local GUI coordinates for jump button
	localPos = LK.gui.bottomRight.toLocal({
		x: x,
		y: y
	});
	dx = localPos.x - -200;
	dy = localPos.y - -200;
	dist = Math.sqrt(dx * dx + dy * dy);
	if (dist < 150 && bloodmage) {
		var _animateButtonBlink2 = function animateButtonBlink() {
			if (currentBlinkFrame < blinkFrames.length) {
				// Get the current frame asset and apply it to the button
				var frameAsset = LK.getAsset(blinkFrames[currentBlinkFrame], {
					anchorX: 0.5,
					anchorY: 0.5
				});
				// Replace button content temporarily
				// Keep jump button visible - just layer blink on top
				// Add blink frame to GUI
				var blinkFrame = LK.gui.bottomRight.addChild(frameAsset);
				blinkFrame.x = -200;
				blinkFrame.y = -200;
				// Animate the blink frame
				tween(blinkFrame, {
					alpha: 0.8
				}, {
					duration: 50,
					onFinish: function onFinish() {
						tween(blinkFrame, {
							alpha: 0
						}, {
							duration: 50,
							onFinish: function onFinish() {
								blinkFrame.destroy();
								currentBlinkFrame++;
								if (currentBlinkFrame < blinkFrames.length) {
									_animateButtonBlink2();
								}
							}
						});
					}
				});
			}
		};
		// Increased hit area
		// Start button blink animation
		var blinkFrames = ['buttonblink', 'buttonblink2', 'buttonblink3', 'buttonblink4'];
		var currentBlinkFrame = 0;
		_animateButtonBlink2();
		var currentTime = Date.now();
		var timeSinceLastJump = currentTime - bloodmage.lastJumpTime;
		// Check for double tap timing
		if (timeSinceLastJump < doubleTapThreshold && bloodmage.jumpCount === 1 && bloodmage.grounded) {
			// Double tap detected - perform higher jump
			bloodmage.velocityY = -bloodmage.jumpPower * 1.5;
			bloodmage.grounded = false;
			bloodmage.doubleJumpAvailable = true;
			LK.getSound('jump').play();
			bloodmage.jumpCount = 0; // Reset for next sequence
		} else {
			// Normal jump attempt
			var jumpSuccess = bloodmage.jump();
			if (jumpSuccess) {
				bloodmage.lastJumpTime = currentTime;
				bloodmage.jumpCount = bloodmage.grounded ? 1 : 0; // Track if this was first jump
			}
		}
	}
};
game.move = function (x, y, obj) {
	if (!trackpadPressed || inBattle || bropageShowing) return;
	updateTrackpad(x, y);
};
game.up = function () {
	trackpadPressed = false;
	if (bloodmage) {
		bloodmage.velocityX = 0;
	}
	trackpadThumb.x = 200;
	trackpadThumb.y = -200;
};
function updateTrackpad(x, y) {
	// x and y are already in local coordinates for GUI elements
	var dx = x - 200;
	var dy = y - -200;
	var dist = Math.sqrt(dx * dx + dy * dy);
	if (dist > 80) {
		dx = dx / dist * 80;
		dy = dy / dist * 80;
	}
	trackpadThumb.x = 200 + dx;
	trackpadThumb.y = -200 + dy;
	if (bloodmage && dist > 5) {
		// Lower dead zone
		// More responsive movement
		bloodmage.velocityX = dx / 80 * bloodmage.speed * 1.5; // Increased responsiveness
	}
}
game.update = function () {
	if (!inBattle) {
		checkCollisions();
		updateCamera();
	}
};
LK.playMusic('cyberpunk');

===================================================================
--- original.js
+++ change.js
@@ -500,8 +500,29 @@
 			self.velocityY = -self.jumpPower * 1.3;
 			self.doubleJumpAvailable = false;
 			LK.getSound('jump').play();
 			jumpExecuted = true;
+			// Create spell2 effect at the base of the character
+			var spellEffect = worldContainer.attachAsset('spell2', {
+				anchorX: 0.5,
+				anchorY: 0.5,
+				x: self.x,
+				y: self.y - 10,
+				// Position at base of character (shoes level)
+				alpha: 0.8
+			});
+			// Animate the spell effect - fade in and out quickly
+			tween(spellEffect, {
+				alpha: 0,
+				scaleX: 1.5,
+				scaleY: 1.5
+			}, {
+				duration: 400,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					spellEffect.destroy();
+				}
+			});
 		}
 		return jumpExecuted;
 	};
 	return self;