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

/**** 
* Classes
****/ 
var AimLine = Container.expand(function () {
	var self = Container.call(this);
	var line = self.attachAsset('aimLine', {
		anchorX: 0.5,
		anchorY: 0
	});
	self.update = function (angle, length) {
		line.rotation = angle;
		line.height = length;
	};
	return self;
});
var Bullet = Container.expand(function () {
	var self = Container.call(this);
	var bulletGraphics = self.attachAsset('ball', {
		anchorX: 0.5,
		anchorY: 0.5,
		rotation: 0
	});
	self.speedX = 0;
	self.speedY = 0;
	self.bounces = 0;
	// Set max bounces based on game difficulty
	if (typeof gameDifficulty !== 'undefined') {
		switch (gameDifficulty) {
			case "easy":
				self.maxBounces = 10; // More bounces for easy mode
				break;
			case "normal":
				self.maxBounces = 8;
				break;
			case "hard":
				self.maxBounces = 5; // Fewer bounces for hard mode
				break;
			default:
				self.maxBounces = 8;
		}
	} else {
		self.maxBounces = 8; // Default value
	}
	self.isActive = true;
	self.update = function () {
		if (!self.isActive) {
			return;
		}
		// Apply velocity
		self.x += self.speedX;
		self.y += self.speedY;
		// Apply a small rotation for visual effect
		bulletGraphics.rotation += 0.05;
		// Check for wall collisions
		if (self.x < 30 || self.x > 2018) {
			self.speedX *= -0.9; // Lose some energy on bounce
			if (self.x < 30) {
				self.x = 30;
			}
			if (self.x > 2018) {
				self.x = 2018;
			}
			self.bounces++;
			LK.getSound('bounce').play();
		}
		if (self.y < 30 || self.y > 2702) {
			self.speedY *= -0.9; // Lose some energy on bounce
			if (self.y < 30) {
				self.y = 30;
			}
			if (self.y > 2702) {
				self.y = 2702;
			}
			self.bounces++;
			LK.getSound('bounce').play();
		}
		// Check if bullet should be removed
		if (self.bounces >= self.maxBounces || Math.abs(self.speedX) < 0.5 && Math.abs(self.speedY) < 0.5) {
			self.isActive = false;
		}
	};
	return self;
});
var Difficulty = Container.expand(function () {
	var self = Container.call(this);
	// Button base size and spacing
	var buttonWidth = 300;
	var buttonHeight = 100;
	var spacing = 30;
	// Create title
	var titleText = new Text2('SELECT DIFFICULTY', {
		size: 80,
		fill: 0xFFFFFF
	});
	titleText.anchor.set(0.5, 0);
	titleText.y = -200;
	self.addChild(titleText);
	// Create difficulty buttons
	var easyButton = createButton('EASY', -buttonWidth - spacing / 2, 0, 0x44AA44);
	var normalButton = createButton('NORMAL', 0, 0, 0x4477AA);
	var hardButton = createButton('HARD', buttonWidth + spacing / 2, 0, 0xAA4444);
	self.addChild(easyButton);
	self.addChild(normalButton);
	self.addChild(hardButton);
	function createButton(text, xPos, yPos, color) {
		var button = new Container();
		// Button background
		var bg = button.attachAsset('powerMeter', {
			anchorX: 0.5,
			anchorY: 0.5,
			width: buttonWidth,
			height: buttonHeight,
			tint: color
		});
		// Button text
		var txt = new Text2(text, {
			size: 50,
			fill: 0xFFFFFF
		});
		txt.anchor.set(0.5, 0.5);
		button.addChild(txt);
		// Position button
		button.x = xPos;
		button.y = yPos;
		// Add interaction
		button.down = function () {
			selectDifficulty(text.toLowerCase());
		};
		return button;
	}
	function selectDifficulty(level) {
		// Set difficulty and hide selector
		gameDifficulty = level;
		self.visible = false;
		// Save selected difficulty
		storage.setItem('bulletBounce_difficulty', level);
		// Start the game with selected difficulty
		initGame();
	}
	return self;
});
var PowerMeter = Container.expand(function () {
	var self = Container.call(this);
	var meterBg = self.attachAsset('powerMeter', {
		anchorX: 0,
		anchorY: 0.5,
		tint: 0x444444
	});
	var meterFill = self.attachAsset('powerMeter', {
		anchorX: 0,
		anchorY: 0.5,
		scaleX: 0.5
	});
	self.setPower = function (power, maxPower) {
		meterFill.scaleX = power / maxPower;
	};
	return self;
});
var Target = Container.expand(function () {
	var self = Container.call(this);
	var targetGraphics = self.attachAsset('target', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.isHit = false;
	self.hit = function () {
		if (self.isHit) {
			return;
		}
		self.isHit = true;
		LK.getSound('targetHit').play();
		LK.effects.flashObject(self, 0xffffff, 300);
		tween(targetGraphics, {
			alpha: 0,
			scaleX: 0.2,
			scaleY: 0.2
		}, {
			duration: 500,
			easing: tween.easeOut,
			onFinish: function onFinish() {
				targetGraphics.visible = false;
			}
		});
		// Increment score
		LK.setScore(LK.getScore() + 100);
	};
	return self;
});
var Turret = Container.expand(function () {
	var self = Container.call(this);
	var base = self.attachAsset('turret', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var barrel = self.attachAsset('turretBarrel', {
		anchorX: 0,
		anchorY: 0.5,
		x: 0,
		y: 0
	});
	self.angle = 0;
	self.power = 10;
	self.maxPower = 20;
	self.isDragging = false;
	self.updateRotation = function (angle) {
		self.angle = angle;
		barrel.rotation = angle;
	};
	self.setPower = function (power) {
		self.power = Math.max(5, Math.min(self.maxPower, power));
	};
	self.getShootVelocity = function () {
		return {
			x: Math.cos(self.angle) * self.power,
			y: Math.sin(self.angle) * self.power
		};
	};
	return self;
});
var Wall = Container.expand(function () {
	var self = Container.call(this);
	var wallGraphics = self.attachAsset('wall', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
var turret;
var bullets = [];
var targets = [];
var walls = [];
var powerMeter;
var aimLine;
var isDragging = false;
var dragStartX, dragStartY;
var currentLevel = 1;
var shotsRemaining = 5;
var totalTargets = 0;
var targetsHit = 0;
var difficultySelector;
var gameDifficulty = "normal"; // Default difficulty
// UI elements
var shotsTxt;
var levelTxt;
function initGame() {
	// Check if game is starting fresh or resuming from difficulty selection
	if (!difficultySelector || !difficultySelector.visible) {
		// Create turret
		turret = new Turret();
		turret.x = 100;
		turret.y = 2732 - 100;
		game.addChild(turret);
		// Create aim line
		aimLine = new AimLine();
		aimLine.x = turret.x;
		aimLine.y = turret.y;
		game.addChild(aimLine);
		// Create power meter
		powerMeter = new PowerMeter();
		powerMeter.x = 50;
		powerMeter.y = 2732 - 200;
		game.addChild(powerMeter);
		powerMeter.setPower(turret.power, turret.maxPower);
		// Setup UI
		shotsTxt = new Text2('Shots: ' + shotsRemaining, {
			size: 50,
			fill: 0xFFFFFF
		});
		shotsTxt.anchor.set(0, 0);
		LK.gui.topRight.addChild(shotsTxt);
		levelTxt = new Text2('Level: ' + currentLevel, {
			size: 50,
			fill: 0xFFFFFF
		});
		levelTxt.anchor.set(0, 0);
		LK.gui.top.addChild(levelTxt);
		// Score text
		var scoreTxt = new Text2('Score: 0', {
			size: 50,
			fill: 0xFFFFFF
		});
		scoreTxt.anchor.set(1, 0);
		LK.gui.topRight.addChild(scoreTxt);
		// Update score display
		LK.setInterval(function () {
			scoreTxt.setText('Score: ' + LK.getScore());
		}, 100);
		// Load level with current difficulty
		loadLevel(currentLevel);
		// Play background music
		LK.playMusic('gameMusic');
	}
}
function loadLevel(level) {
	// Clear any existing level elements
	clearLevel();
	// Update level display
	levelTxt.setText('Level: ' + level);
	// Reset shots based on difficulty
	switch (gameDifficulty) {
		case "easy":
			shotsRemaining = 5 + level;
			break;
		case "normal":
			shotsRemaining = 3 + level;
			break;
		case "hard":
			shotsRemaining = 2 + Math.floor(level / 2);
			break;
		default:
			shotsRemaining = 3 + level;
	}
	shotsTxt.setText('Shots: ' + shotsRemaining);
	// Different level layouts
	switch (level) {
		case 1:
			// Basic level with random targets
			var targetCount = 3;
			for (var i = 0; i < targetCount; i++) {
				createTarget(500 + Math.random() * 1000, 300 + Math.random() * 800);
			}
			// Add random walls
			createWall(500 + Math.random() * 200, 500 + Math.random() * 200, Math.random() * Math.PI / 2);
			createWall(1300 + Math.random() * 200, 900 + Math.random() * 200, Math.random() * Math.PI / 2);
			break;
		case 2:
			// More complex level with random elements
			var targetCount = 5;
			for (var i = 0; i < targetCount; i++) {
				createTarget(400 + Math.random() * 1200, 400 + Math.random() * 1100);
			}
			// Add random walls
			createWall(400 + Math.random() * 100, 800 + Math.random() * 100, Math.random() * Math.PI / 4);
			createWall(1500 + Math.random() * 100, 800 + Math.random() * 100, Math.random() * Math.PI / 4);
			createWall(900 + Math.random() * 200, 300 + Math.random() * 100, Math.PI / 2 + Math.random() * 0.3);
			createWall(900 + Math.random() * 200, 1400 + Math.random() * 100, Math.PI / 2 + Math.random() * 0.3);
			break;
		case 3:
			// Advanced level with random elements
			var targetCount = 7;
			for (var i = 0; i < targetCount; i++) {
				// Create targets in different quadrants of the screen
				if (i < 2) {
					createTarget(300 + Math.random() * 400, 300 + Math.random() * 400);
				} else if (i < 4) {
					createTarget(1300 + Math.random() * 400, 300 + Math.random() * 400);
				} else if (i < 6) {
					createTarget(300 + Math.random() * 400, 1100 + Math.random() * 400);
				} else {
					createTarget(1300 + Math.random() * 400, 1100 + Math.random() * 400);
				}
			}
			// Add walls in a maze-like structure with some randomness
			createWall(600 + Math.random() * 100, 600 + Math.random() * 100, Math.random() * 0.2);
			createWall(1300 + Math.random() * 100, 600 + Math.random() * 100, Math.random() * 0.2);
			createWall(600 + Math.random() * 100, 1200 + Math.random() * 100, Math.random() * 0.2);
			createWall(1300 + Math.random() * 100, 1200 + Math.random() * 100, Math.random() * 0.2);
			createWall(1000 + Math.random() * 100, 600 + Math.random() * 100, Math.PI / 2 + Math.random() * 0.2);
			createWall(1000 + Math.random() * 100, 1200 + Math.random() * 100, Math.PI / 2 + Math.random() * 0.2);
			break;
		default:
			// For levels beyond 3, create a fully random level with more targets and walls
			// Adjust difficulty based on selected mode
			var difficultyMultiplier;
			switch (gameDifficulty) {
				case "easy":
					difficultyMultiplier = 0.7; // Fewer targets and walls
					break;
				case "normal":
					difficultyMultiplier = 1.0; // Normal difficulty
					break;
				case "hard":
					difficultyMultiplier = 1.5; // More targets and walls
					break;
				default:
					difficultyMultiplier = 1.0;
			}
			// Generate random number of targets based on level and difficulty
			var numTargets = Math.max(2, Math.floor((3 + Math.random() * level * 2) * difficultyMultiplier));
			for (var i = 0; i < numTargets; i++) {
				createTarget(300 + Math.random() * 1400, 300 + Math.random() * 1500);
			}
			// Generate random number of walls based on level and difficulty
			var numWalls = Math.max(2, Math.floor(Math.random() * level * 1.5 * difficultyMultiplier));
			for (var i = 0; i < numWalls; i++) {
				createWall(300 + Math.random() * 1400, 300 + Math.random() * 1500, Math.random() * Math.PI);
			}
			break;
	}
	// Track targets for win condition
	totalTargets = targets.length;
	targetsHit = 0;
}
function clearLevel() {
	// Remove all bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		game.removeChild(bullets[i]);
		bullets.splice(i, 1);
	}
	// Remove all targets
	for (var i = targets.length - 1; i >= 0; i--) {
		game.removeChild(targets[i]);
		targets.splice(i, 1);
	}
	// Remove all walls
	for (var i = walls.length - 1; i >= 0; i--) {
		game.removeChild(walls[i]);
		walls.splice(i, 1);
	}
}
function createTarget(x, y) {
	var target = new Target();
	target.x = x;
	target.y = y;
	game.addChild(target);
	targets.push(target);
	return target;
}
function createWall(x, y, rotation) {
	var wall = new Wall();
	wall.x = x;
	wall.y = y;
	wall.rotation = rotation;
	game.addChild(wall);
	walls.push(wall);
	return wall;
}
function fireBullet() {
	if (shotsRemaining <= 0) {
		return;
	}
	// Decrease shots remaining
	shotsRemaining--;
	shotsTxt.setText('Shots: ' + shotsRemaining);
	// Create new bullet
	var bullet = new Bullet();
	bullet.x = turret.x;
	bullet.y = turret.y;
	// Get velocity from turret angle and power
	var velocity = turret.getShootVelocity();
	bullet.speedX = velocity.x;
	bullet.speedY = velocity.y;
	// Add to game
	game.addChild(bullet);
	bullets.push(bullet);
	// Play sound
	LK.getSound('shoot').play();
	// Flash turret
	LK.effects.flashObject(turret, 0xffffff, 200);
}
function checkCollisions() {
	// Check all active bullets
	for (var i = bullets.length - 1; i >= 0; i--) {
		var bullet = bullets[i];
		if (!bullet.isActive) {
			// Remove inactive bullets
			game.removeChild(bullet);
			bullets.splice(i, 1);
			continue;
		}
		// Check for wall collisions
		for (var j = 0; j < walls.length; j++) {
			var wall = walls[j];
			if (bullet.intersects(wall)) {
				// Calculate bounce direction based on wall angle
				var wallAngle = wall.rotation;
				var normalAngle = wallAngle + Math.PI / 2;
				// Reflect velocity based on wall normal
				var speed = Math.sqrt(bullet.speedX * bullet.speedX + bullet.speedY * bullet.speedY);
				var bulletAngle = Math.atan2(bullet.speedY, bullet.speedX);
				var reflectionAngle = 2 * normalAngle - bulletAngle;
				bullet.speedX = Math.cos(reflectionAngle) * speed * 0.8; // Lose some energy
				bullet.speedY = Math.sin(reflectionAngle) * speed * 0.8;
				// Move bullet slightly away from wall to prevent multiple collisions
				bullet.x += bullet.speedX;
				bullet.y += bullet.speedY;
				bullet.bounces++;
				LK.getSound('bounce').play();
			}
		}
		// Check for target collisions
		for (var j = 0; j < targets.length; j++) {
			var target = targets[j];
			if (!target.isHit && bullet.intersects(target)) {
				target.hit();
				targetsHit++;
				// Check if level complete
				if (targetsHit >= totalTargets) {
					levelComplete();
				}
			}
		}
	}
}
function levelComplete() {
	LK.setTimeout(function () {
		// Advance to next level
		currentLevel++;
		loadLevel(currentLevel);
	}, 1000);
}
function checkGameOver() {
	// Game over conditions
	if (shotsRemaining <= 0 && bullets.length === 0) {
		// Check if any targets left
		var anyTargetsLeft = false;
		for (var i = 0; i < targets.length; i++) {
			if (!targets[i].isHit) {
				anyTargetsLeft = true;
				break;
			}
		}
		if (anyTargetsLeft) {
			// Player has lost
			LK.setTimeout(function () {
				LK.showGameOver();
			}, 1000);
		}
	}
}
function calculateAimAngle(x, y) {
	// Calculate angle from turret to mouse/touch point
	var dx = x - turret.x;
	var dy = y - turret.y;
	return Math.atan2(dy, dx);
}
function updateAimLine() {
	aimLine.update(turret.angle, 200);
}
// Load previously selected difficulty if available
var savedDifficulty = storage.getItem('bulletBounce_difficulty');
if (savedDifficulty) {
	gameDifficulty = savedDifficulty;
}
// Create difficulty selector
difficultySelector = new Difficulty();
difficultySelector.x = 2048 / 2;
difficultySelector.y = 2732 / 2;
game.addChild(difficultySelector);
// If we just want to start the game directly with saved difficulty, uncomment this:
// difficultySelector.visible = false;
// initGame();
// Event handlers
game.down = function (x, y, obj) {
	isDragging = true;
	dragStartX = x;
	dragStartY = y;
	// Set initial angle
	var angle = calculateAimAngle(x, y);
	turret.updateRotation(angle);
	updateAimLine();
};
game.move = function (x, y, obj) {
	if (isDragging) {
		// Update turret angle
		var angle = calculateAimAngle(x, y);
		turret.updateRotation(angle);
		// Calculate power based on drag distance
		var dx = x - dragStartX;
		var dy = y - dragStartY;
		var dragDistance = Math.sqrt(dx * dx + dy * dy);
		var power = Math.min(turret.maxPower, dragDistance / 50);
		turret.setPower(power);
		// Update power meter
		powerMeter.setPower(turret.power, turret.maxPower);
		// Update aim line
		updateAimLine();
	}
};
game.up = function (x, y, obj) {
	if (isDragging) {
		isDragging = false;
		fireBullet();
	}
};
// Game update loop
game.update = function () {
	// Update all bullets
	for (var i = 0; i < bullets.length; i++) {
		bullets[i].update();
	}
	// Check for collisions
	checkCollisions();
	// Check for game over
	checkGameOver();
};

===================================================================
--- original.js
+++ change.js
@@ -28,9 +28,26 @@
 	});
 	self.speedX = 0;
 	self.speedY = 0;
 	self.bounces = 0;
-	self.maxBounces = 8; // Increased from 5 to 8 for more bounces with the larger ball
+	// Set max bounces based on game difficulty
+	if (typeof gameDifficulty !== 'undefined') {
+		switch (gameDifficulty) {
+			case "easy":
+				self.maxBounces = 10; // More bounces for easy mode
+				break;
+			case "normal":
+				self.maxBounces = 8;
+				break;
+			case "hard":
+				self.maxBounces = 5; // Fewer bounces for hard mode
+				break;
+			default:
+				self.maxBounces = 8;
+		}
+	} else {
+		self.maxBounces = 8; // Default value
+	}
 	self.isActive = true;
 	self.update = function () {
 		if (!self.isActive) {
 			return;
@@ -69,8 +86,66 @@
 		}
 	};
 	return self;
 });
+var Difficulty = Container.expand(function () {
+	var self = Container.call(this);
+	// Button base size and spacing
+	var buttonWidth = 300;
+	var buttonHeight = 100;
+	var spacing = 30;
+	// Create title
+	var titleText = new Text2('SELECT DIFFICULTY', {
+		size: 80,
+		fill: 0xFFFFFF
+	});
+	titleText.anchor.set(0.5, 0);
+	titleText.y = -200;
+	self.addChild(titleText);
+	// Create difficulty buttons
+	var easyButton = createButton('EASY', -buttonWidth - spacing / 2, 0, 0x44AA44);
+	var normalButton = createButton('NORMAL', 0, 0, 0x4477AA);
+	var hardButton = createButton('HARD', buttonWidth + spacing / 2, 0, 0xAA4444);
+	self.addChild(easyButton);
+	self.addChild(normalButton);
+	self.addChild(hardButton);
+	function createButton(text, xPos, yPos, color) {
+		var button = new Container();
+		// Button background
+		var bg = button.attachAsset('powerMeter', {
+			anchorX: 0.5,
+			anchorY: 0.5,
+			width: buttonWidth,
+			height: buttonHeight,
+			tint: color
+		});
+		// Button text
+		var txt = new Text2(text, {
+			size: 50,
+			fill: 0xFFFFFF
+		});
+		txt.anchor.set(0.5, 0.5);
+		button.addChild(txt);
+		// Position button
+		button.x = xPos;
+		button.y = yPos;
+		// Add interaction
+		button.down = function () {
+			selectDifficulty(text.toLowerCase());
+		};
+		return button;
+	}
+	function selectDifficulty(level) {
+		// Set difficulty and hide selector
+		gameDifficulty = level;
+		self.visible = false;
+		// Save selected difficulty
+		storage.setItem('bulletBounce_difficulty', level);
+		// Start the game with selected difficulty
+		initGame();
+	}
+	return self;
+});
 var PowerMeter = Container.expand(function () {
 	var self = Container.call(this);
 	var meterBg = self.attachAsset('powerMeter', {
 		anchorX: 0,
@@ -179,64 +254,81 @@
 var currentLevel = 1;
 var shotsRemaining = 5;
 var totalTargets = 0;
 var targetsHit = 0;
+var difficultySelector;
+var gameDifficulty = "normal"; // Default difficulty
 // UI elements
 var shotsTxt;
 var levelTxt;
 function initGame() {
-	// Create turret
-	turret = new Turret();
-	turret.x = 100;
-	turret.y = 2732 - 100;
-	game.addChild(turret);
-	// Create aim line
-	aimLine = new AimLine();
-	aimLine.x = turret.x;
-	aimLine.y = turret.y;
-	game.addChild(aimLine);
-	// Create power meter
-	powerMeter = new PowerMeter();
-	powerMeter.x = 50;
-	powerMeter.y = 2732 - 200;
-	game.addChild(powerMeter);
-	powerMeter.setPower(turret.power, turret.maxPower);
-	// Setup UI
-	shotsTxt = new Text2('Shots: ' + shotsRemaining, {
-		size: 50,
-		fill: 0xFFFFFF
-	});
-	shotsTxt.anchor.set(0, 0);
-	LK.gui.topRight.addChild(shotsTxt);
-	levelTxt = new Text2('Level: ' + currentLevel, {
-		size: 50,
-		fill: 0xFFFFFF
-	});
-	levelTxt.anchor.set(0, 0);
-	LK.gui.top.addChild(levelTxt);
-	// Score text
-	var scoreTxt = new Text2('Score: 0', {
-		size: 50,
-		fill: 0xFFFFFF
-	});
-	scoreTxt.anchor.set(1, 0);
-	LK.gui.topRight.addChild(scoreTxt);
-	// Update score display
-	LK.setInterval(function () {
-		scoreTxt.setText('Score: ' + LK.getScore());
-	}, 100);
-	// Load level
-	loadLevel(currentLevel);
-	// Play background music
-	LK.playMusic('gameMusic');
+	// Check if game is starting fresh or resuming from difficulty selection
+	if (!difficultySelector || !difficultySelector.visible) {
+		// Create turret
+		turret = new Turret();
+		turret.x = 100;
+		turret.y = 2732 - 100;
+		game.addChild(turret);
+		// Create aim line
+		aimLine = new AimLine();
+		aimLine.x = turret.x;
+		aimLine.y = turret.y;
+		game.addChild(aimLine);
+		// Create power meter
+		powerMeter = new PowerMeter();
+		powerMeter.x = 50;
+		powerMeter.y = 2732 - 200;
+		game.addChild(powerMeter);
+		powerMeter.setPower(turret.power, turret.maxPower);
+		// Setup UI
+		shotsTxt = new Text2('Shots: ' + shotsRemaining, {
+			size: 50,
+			fill: 0xFFFFFF
+		});
+		shotsTxt.anchor.set(0, 0);
+		LK.gui.topRight.addChild(shotsTxt);
+		levelTxt = new Text2('Level: ' + currentLevel, {
+			size: 50,
+			fill: 0xFFFFFF
+		});
+		levelTxt.anchor.set(0, 0);
+		LK.gui.top.addChild(levelTxt);
+		// Score text
+		var scoreTxt = new Text2('Score: 0', {
+			size: 50,
+			fill: 0xFFFFFF
+		});
+		scoreTxt.anchor.set(1, 0);
+		LK.gui.topRight.addChild(scoreTxt);
+		// Update score display
+		LK.setInterval(function () {
+			scoreTxt.setText('Score: ' + LK.getScore());
+		}, 100);
+		// Load level with current difficulty
+		loadLevel(currentLevel);
+		// Play background music
+		LK.playMusic('gameMusic');
+	}
 }
 function loadLevel(level) {
 	// Clear any existing level elements
 	clearLevel();
 	// Update level display
 	levelTxt.setText('Level: ' + level);
-	// Reset shots
-	shotsRemaining = 3 + level;
+	// Reset shots based on difficulty
+	switch (gameDifficulty) {
+		case "easy":
+			shotsRemaining = 5 + level;
+			break;
+		case "normal":
+			shotsRemaining = 3 + level;
+			break;
+		case "hard":
+			shotsRemaining = 2 + Math.floor(level / 2);
+			break;
+		default:
+			shotsRemaining = 3 + level;
+	}
 	shotsTxt.setText('Shots: ' + shotsRemaining);
 	// Different level layouts
 	switch (level) {
 		case 1:
@@ -285,15 +377,30 @@
 			createWall(1000 + Math.random() * 100, 1200 + Math.random() * 100, Math.PI / 2 + Math.random() * 0.2);
 			break;
 		default:
 			// For levels beyond 3, create a fully random level with more targets and walls
-			// Generate random number of targets based on level
-			var numTargets = 3 + Math.floor(Math.random() * level * 2);
+			// Adjust difficulty based on selected mode
+			var difficultyMultiplier;
+			switch (gameDifficulty) {
+				case "easy":
+					difficultyMultiplier = 0.7; // Fewer targets and walls
+					break;
+				case "normal":
+					difficultyMultiplier = 1.0; // Normal difficulty
+					break;
+				case "hard":
+					difficultyMultiplier = 1.5; // More targets and walls
+					break;
+				default:
+					difficultyMultiplier = 1.0;
+			}
+			// Generate random number of targets based on level and difficulty
+			var numTargets = Math.max(2, Math.floor((3 + Math.random() * level * 2) * difficultyMultiplier));
 			for (var i = 0; i < numTargets; i++) {
 				createTarget(300 + Math.random() * 1400, 300 + Math.random() * 1500);
 			}
-			// Generate random number of walls based on level
-			var numWalls = Math.max(2, Math.floor(Math.random() * level * 1.5));
+			// Generate random number of walls based on level and difficulty
+			var numWalls = Math.max(2, Math.floor(Math.random() * level * 1.5 * difficultyMultiplier));
 			for (var i = 0; i < numWalls; i++) {
 				createWall(300 + Math.random() * 1400, 300 + Math.random() * 1500, Math.random() * Math.PI);
 			}
 			break;
@@ -437,10 +544,21 @@
 }
 function updateAimLine() {
 	aimLine.update(turret.angle, 200);
 }
-// Initialize the game
-initGame();
+// Load previously selected difficulty if available
+var savedDifficulty = storage.getItem('bulletBounce_difficulty');
+if (savedDifficulty) {
+	gameDifficulty = savedDifficulty;
+}
+// Create difficulty selector
+difficultySelector = new Difficulty();
+difficultySelector.x = 2048 / 2;
+difficultySelector.y = 2732 / 2;
+game.addChild(difficultySelector);
+// If we just want to start the game directly with saved difficulty, uncomment this:
+// difficultySelector.visible = false;
+// initGame();
 // Event handlers
 game.down = function (x, y, obj) {
 	isDragging = true;
 	dragStartX = x;