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

/**** 
* Classes
****/ 
var Cube = Container.expand(function () {
	var self = Container.call(this);
	// Glow effect (bottom layer)
	var cubeGlow = self.attachAsset('cubeGlow', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	cubeGlow.alpha = 0.4;
	// Main cube body
	var cubeGraphics = self.attachAsset('cube', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Highlight layer
	var cubeHighlight = self.attachAsset('cubeHighlight', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	cubeHighlight.alpha = 0.6;
	// Core layer
	var cubeCore = self.attachAsset('cubeCore', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Inner detail
	var cubeInner = self.attachAsset('cubeInner', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	cubeInner.alpha = 0.8;
	self.velocityY = 0;
	self.gravity = 0.5;
	self.jumpForce = -18;
	self.maxJumpForce = -24;
	self.isGrounded = false;
	self.groundY = 2400;
	self.update = function () {
		// Store previous state for particle effects
		var wasGrounded = self.isGrounded;
		// Apply gravity
		self.velocityY += self.gravity;
		self.y += self.velocityY;
		// Enhanced rotation with speed variation
		var rotationSpeed = 0.03 + Math.abs(self.velocityY) * 0.002;
		self.rotation += rotationSpeed;
		// Pulsing glow effect
		cubeGlow.alpha = 0.3 + Math.sin(LK.ticks * 0.1) * 0.15;
		cubeGlow.scaleX = 1 + Math.sin(LK.ticks * 0.15) * 0.1;
		cubeGlow.scaleY = 1 + Math.sin(LK.ticks * 0.15) * 0.1;
		// Trail particles when moving fast
		if (Math.abs(self.velocityY) > 3 && LK.ticks % 3 === 0) {
			if (typeof particles !== 'undefined') {
				var trailParticle = new Particle('trail', self.x + (Math.random() - 0.5) * 20, self.y - 20);
				particles.push(trailParticle);
				game.addChild(trailParticle);
			}
		}
		// Ground collision
		if (self.y >= self.groundY) {
			self.y = self.groundY;
			self.velocityY = 0;
			self.isGrounded = true;
			// Landing particles
			if (!wasGrounded && typeof particles !== 'undefined') {
				for (var i = 0; i < 8; i++) {
					var landParticle = new Particle('land', self.x + (Math.random() - 0.5) * 40, self.y);
					particles.push(landParticle);
					game.addChild(landParticle);
				}
			}
		} else {
			self.isGrounded = false;
		}
	};
	self.jump = function (force) {
		if (self.isGrounded) {
			self.velocityY = force;
			self.isGrounded = false;
			LK.getSound('jump').play();
			// Jump particles
			if (typeof particles !== 'undefined') {
				for (var i = 0; i < 12; i++) {
					var jumpParticle = new Particle('jump', self.x + (Math.random() - 0.5) * 30, self.y);
					particles.push(jumpParticle);
					game.addChild(jumpParticle);
				}
			}
			// Enhanced visual feedback
			tween(cubeGlow).to({
				scaleX: 1.5,
				scaleY: 1.5,
				alpha: 0.8
			}, 200).then(function () {
				tween(cubeGlow).to({
					scaleX: 1,
					scaleY: 1,
					alpha: 0.4
				}, 300);
			});
		}
	};
	return self;
});
var Ground = Container.expand(function () {
	var self = Container.call(this);
	// Shadow layer (bottom)
	var groundShadow = self.attachAsset('groundShadow', {
		anchorX: 0,
		anchorY: 0
	});
	groundShadow.y = 32;
	// Main ground body
	var groundGraphics = self.attachAsset('ground', {
		anchorX: 0,
		anchorY: 0
	});
	// Pattern layer
	var groundPattern = self.attachAsset('groundPattern', {
		anchorX: 0,
		anchorY: 0
	});
	groundPattern.x = 10;
	groundPattern.y = 10;
	// Highlight layer (top)
	var groundHighlight = self.attachAsset('groundHighlight', {
		anchorX: 0,
		anchorY: 0
	});
	groundHighlight.x = 5;
	groundHighlight.y = 2;
	self.speed = -5;
	self.update = function () {
		self.x += self.speed;
	};
	return self;
});
var LevelButton = Container.expand(function (levelNum, config, unlocked) {
	var self = Container.call(this);
	self.levelNum = levelNum;
	self.unlocked = unlocked;
	// Button background
	var buttonBg = self.attachAsset('ground', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	buttonBg.width = 300;
	buttonBg.height = 120;
	if (!unlocked) {
		buttonBg.tint = 0x666666;
	}
	// Level number text
	var levelText = new Text2(levelNum.toString(), {
		size: 60,
		fill: unlocked ? 0xFFFFFF : 0x999999
	});
	levelText.anchor.set(0.5, 0.3);
	self.addChild(levelText);
	// Level name text
	var nameText = new Text2(config.name, {
		size: 30,
		fill: unlocked ? 0xFFFFFF : 0x999999
	});
	nameText.anchor.set(0.5, 0.7);
	self.addChild(nameText);
	self.down = function (x, y, obj) {
		if (self.unlocked) {
			selectedLevel = self.levelNum;
			startLevel(selectedLevel);
		}
	};
	return self;
});
var Obstacle = Container.expand(function (type) {
	var self = Container.call(this);
	var obstacleGraphics;
	self.type = type || 'spike';
	self.speed = -5;
	if (self.type === 'spike') {
		// Glow effect for spike
		var spikeGlow = self.attachAsset('spikeGlow', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		spikeGlow.alpha = 0.3;
		// Create triangular spike using layered shapes
		var spikeBottom = self.attachAsset('spikeBottom', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		var spikeMiddle = self.attachAsset('spikeMiddle', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		spikeMiddle.y = -20;
		var spikeTop = self.attachAsset('spikeTop', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		spikeTop.y = -40;
		// Core crystal effect
		var spikeCore = self.attachAsset('spikeCore', {
			anchorX: 0.5,
			anchorY: 1.0
		});
		spikeCore.y = -35;
		spikeCore.alpha = 0.9;
	} else if (self.type === 'barrier') {
		// Glow effect for barrier
		var barrierGlow = self.attachAsset('barrierGlow', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		barrierGlow.alpha = 0.4;
		// Main barrier
		obstacleGraphics = self.attachAsset('barrier', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Highlight layer
		var barrierHighlight = self.attachAsset('barrierHighlight', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// Core metallic layer
		var barrierCore = self.attachAsset('barrierCore', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		barrierCore.alpha = 0.8;
	}
	self.update = function () {
		self.x += self.speed;
		// Add pulsing glow animation
		if (self.type === 'spike' && spikeGlow) {
			spikeGlow.alpha = 0.2 + Math.sin(LK.ticks * 0.08) * 0.15;
			spikeCore.alpha = 0.7 + Math.sin(LK.ticks * 0.12) * 0.3;
		} else if (self.type === 'barrier' && barrierGlow) {
			barrierGlow.alpha = 0.3 + Math.sin(LK.ticks * 0.06) * 0.1;
			barrierCore.alpha = 0.6 + Math.sin(LK.ticks * 0.1) * 0.2;
		}
	};
	return self;
});
var Particle = Container.expand(function (type, startX, startY) {
	var self = Container.call(this);
	self.type = type;
	self.lifespan = 60; // 1 second at 60fps
	self.age = 0;
	var particleGraphics;
	if (type === 'jump') {
		particleGraphics = self.attachAsset('jumpParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.velocityX = (Math.random() - 0.5) * 8;
		self.velocityY = Math.random() * -6 - 2;
	} else if (type === 'land') {
		particleGraphics = self.attachAsset('landParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.velocityX = (Math.random() - 0.5) * 12;
		self.velocityY = Math.random() * -4 - 1;
	} else if (type === 'trail') {
		particleGraphics = self.attachAsset('trailParticle', {
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.velocityX = (Math.random() - 0.5) * 4 - 5;
		self.velocityY = (Math.random() - 0.5) * 4;
	}
	self.x = startX;
	self.y = startY;
	self.update = function () {
		self.age++;
		self.x += self.velocityX;
		self.y += self.velocityY;
		self.velocityY += 0.2; // gravity
		// Fade out over time
		var fadeProgress = self.age / self.lifespan;
		self.alpha = 1 - fadeProgress;
		// Scale down over time
		var scale = 1 - fadeProgress * 0.5;
		self.scaleX = scale;
		self.scaleY = scale;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Particle effects assets
// Enhanced spike assets with crystal-like appearance
// Enhanced barrier assets with metallic appearance
// Enhanced ground assets with texture and depth
// Enhanced cube assets with glow effects
var cube;
var obstacles = [];
var groundTiles = [];
var particles = [];
var isJumping = false;
var jumpStartTime = 0;
var gameSpeed = 5;
var distance = 0;
var obstacleTimer = 0;
var groundTimer = 0;
// Game state management
var gameState = 'menu'; // 'menu' or 'playing'
var selectedLevel = 1;
var maxUnlockedLevel = 5;
var levelButtons = [];
// Level configurations
var levelConfigs = [{
	name: "Easy Jump",
	speed: 3,
	obstacleFreq: 120,
	gravity: 0.3
}, {
	name: "Medium Hop",
	speed: 5,
	obstacleFreq: 90,
	gravity: 0.5
}, {
	name: "Hard Leap",
	speed: 7,
	obstacleFreq: 70,
	gravity: 0.7
}, {
	name: "Expert Dash",
	speed: 9,
	obstacleFreq: 50,
	gravity: 0.9
}, {
	name: "Master Jump",
	speed: 12,
	obstacleFreq: 40,
	gravity: 1.2
}];
function createMenu() {
	gameState = 'menu';
	// Clear any existing game elements
	clearGameElements();
	// Title
	var titleText = new Text2('DASH JUMP', {
		size: 120,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0);
	titleText.x = 2048 / 2;
	titleText.y = 400;
	game.addChild(titleText);
	// Level selection title
	var selectText = new Text2('SELECT LEVEL', {
		size: 60,
		fill: 0xFFFFFF
	});
	selectText.anchor.set(0.5, 0);
	selectText.x = 2048 / 2;
	selectText.y = 600;
	game.addChild(selectText);
	// Create level buttons
	levelButtons = [];
	for (var i = 0; i < levelConfigs.length; i++) {
		var levelNum = i + 1;
		var unlocked = true; // All levels are now unlocked
		var button = game.addChild(new LevelButton(levelNum, levelConfigs[i], unlocked));
		var row = Math.floor(i / 2);
		var col = i % 2;
		button.x = 2048 / 2 + (col - 0.5) * 350;
		button.y = 800 + row * 200;
		levelButtons.push(button);
	}
}
function clearGameElements() {
	// Remove all children except GUI elements
	for (var i = game.children.length - 1; i >= 0; i--) {
		game.children[i].destroy();
	}
	// Clear arrays
	obstacles = [];
	groundTiles = [];
	levelButtons = [];
	particles = [];
}
function startLevel(levelNum) {
	gameState = 'playing';
	var config = levelConfigs[levelNum - 1];
	// Clear menu
	clearGameElements();
	// Apply level configuration
	gameSpeed = config.speed;
	// Initialize cube with level settings
	cube = game.addChild(new Cube());
	cube.x = 300;
	cube.y = 2400;
	cube.gravity = config.gravity;
	// Initialize ground tiles
	for (var i = 0; i < 15; i++) {
		var groundTile = game.addChild(new Ground());
		groundTile.x = i * 200;
		groundTile.y = 2440;
		groundTile.speed = -gameSpeed;
		groundTiles.push(groundTile);
	}
	// Reset game variables
	distance = 0;
	obstacleTimer = 0;
	groundTimer = 0;
	isJumping = false;
	// Update score display
	scoreTxt.setText('Level ' + levelNum + ' - Distance: 0');
}
// Initialize menu instead of game
createMenu();
// Score display
var scoreTxt = new Text2('Distance: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
function spawnObstacle() {
	var obstacleType = Math.random() < 0.7 ? 'spike' : 'barrier';
	var obstacle = game.addChild(new Obstacle(obstacleType));
	obstacle.x = 2200;
	obstacle.speed = -gameSpeed;
	if (obstacleType === 'spike') {
		obstacle.y = 2400;
	} else {
		obstacle.y = Math.random() < 0.5 ? 2300 : 2200;
	}
	obstacles.push(obstacle);
}
function spawnGround() {
	var groundTile = game.addChild(new Ground());
	groundTile.x = 2200;
	groundTile.y = 2440;
	groundTile.speed = -gameSpeed;
	groundTiles.push(groundTile);
}
game.down = function (x, y, obj) {
	if (gameState === 'playing' && !isJumping) {
		isJumping = true;
		jumpStartTime = LK.ticks;
	}
};
game.up = function (x, y, obj) {
	if (gameState === 'playing' && isJumping) {
		var holdDuration = LK.ticks - jumpStartTime;
		var jumpForce = cube.jumpForce;
		// Increase jump force based on hold duration (max 30 ticks)
		if (holdDuration > 5) {
			var extraForce = Math.min(holdDuration - 5, 25) * 0.2;
			jumpForce = cube.jumpForce - extraForce;
			jumpForce = Math.max(jumpForce, cube.maxJumpForce);
		}
		cube.jump(jumpForce);
		isJumping = false;
	}
};
game.update = function () {
	if (gameState !== 'playing') return;
	// Update distance
	distance += 0.1;
	scoreTxt.setText('Level ' + selectedLevel + ' - Distance: ' + Math.floor(distance));
	// Check level completion (every 200 distance units)
	if (Math.floor(distance) >= 200) {
		// Level completed - return to menu
		createMenu();
		return;
	}
	var config = levelConfigs[selectedLevel - 1];
	// Spawn obstacles
	obstacleTimer++;
	if (obstacleTimer >= config.obstacleFreq + Math.random() * 30) {
		spawnObstacle();
		obstacleTimer = 0;
	}
	// Spawn ground tiles
	groundTimer++;
	if (groundTimer >= 25) {
		spawnGround();
		groundTimer = 0;
	}
	// Update and check obstacles
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obstacle = obstacles[i];
		if (obstacle.lastX === undefined) obstacle.lastX = obstacle.x;
		// Remove off-screen obstacles
		if (obstacle.lastX >= -100 && obstacle.x < -100) {
			obstacle.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Check collision with cube
		if (obstacle.intersects(cube)) {
			LK.getSound('death').play();
			LK.effects.flashScreen(0xff0000, 500);
			createMenu();
			return;
		}
		obstacle.lastX = obstacle.x;
	}
	// Update and check ground tiles
	for (var j = groundTiles.length - 1; j >= 0; j--) {
		var ground = groundTiles[j];
		if (ground.lastX === undefined) ground.lastX = ground.x;
		// Remove off-screen ground tiles
		if (ground.lastX >= -200 && ground.x < -200) {
			ground.destroy();
			groundTiles.splice(j, 1);
			continue;
		}
		ground.lastX = ground.x;
	}
	// Update and manage particles
	for (var k = particles.length - 1; k >= 0; k--) {
		var particle = particles[k];
		if (particle.age >= particle.lifespan) {
			particle.destroy();
			particles.splice(k, 1);
		}
	}
};

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