/**** 
* 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'];
		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.cleanup = function () {
		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,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk2', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk3', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk4', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk5', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk6', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	self.walkFrames.push(self.attachAsset('playerwalk7', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.2,
		scaleY: 0.33
	}));
	self.walkFrames.push(self.attachAsset('playerwalk8', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.3,
		scaleY: 0.5
	}));
	// Create jump animation frames
	self.jumpFrames.push(self.attachAsset('playerjump', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	self.jumpFrames.push(self.attachAsset('playerjump2', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	self.jumpFrames.push(self.attachAsset('playerjump3', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	self.jumpFrames.push(self.attachAsset('playerjump4', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	self.jumpFrames.push(self.attachAsset('playerjump5', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	self.jumpFrames.push(self.attachAsset('playerjump6', {
		anchorX: 0.5,
		anchorY: 1.0,
		alpha: 0,
		scaleX: 0.25,
		scaleY: 0.25
	}));
	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;
		}
		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;
	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 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);
		if (i % 2 === 1) {
			var hunk = new Hunk();
			hunk.x = platform.x;
			hunk.y = platform.y - 20;
			hunks.push(hunk);
			worldContainer.addChild(hunk);
		}
	}
	bloodmage = new Bloodmage();
	bloodmage.x = 200;
	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) return;
	trackpadPressed = true;
	updateTrackpad(x, y);
};
trackpadBg.move = function (x, y, obj) {
	if (!trackpadPressed || inBattle) 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) {
		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);
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) 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() {
			battleUI.hunkDisplay.rotation = 0;
		}
	});
}
function attemptCapture() {
	if (!currentHunk || !battleUI) return;
	if (currentHunk.resistance < 30) {
		LK.getSound('capture').play();
		currentHunk.captured = true;
		currentHunk.visible = false;
		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) 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) {
		// Increased hit area
		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) 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
@@ -491,13 +491,17 @@
 	return self;
 });
 var Platform = Container.expand(function () {
 	var self = Container.call(this);
-	var platform = self.attachAsset('platform', {
+	// 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
 	});
-	platform.tint = 0x1a1a1a + Math.floor(Math.random() * 0x333333);
+	// Store platform type for reference
+	self.platformType = selectedPlatform;
 	return self;
 });
 
 /****