===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,473 @@
-/****
+/**** 
+* 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
+	});
+	self.speedX = 0;
+	self.speedY = 0;
+	self.bounces = 0;
+	self.maxBounces = 5;
+	self.isActive = true;
+	self.update = function () {
+		if (!self.isActive) {
+			return;
+		}
+		// Apply velocity
+		self.x += self.speedX;
+		self.y += self.speedY;
+		// Check for wall collisions
+		if (self.x < 0 || self.x > 2048) {
+			self.speedX *= -0.9; // Lose some energy on bounce
+			if (self.x < 0) {
+				self.x = 0;
+			}
+			if (self.x > 2048) {
+				self.x = 2048;
+			}
+			self.bounces++;
+			LK.getSound('bounce').play();
+		}
+		if (self.y < 0 || self.y > 2732) {
+			self.speedY *= -0.9; // Lose some energy on bounce
+			if (self.y < 0) {
+				self.y = 0;
+			}
+			if (self.y > 2732) {
+				self.y = 2732;
+			}
+			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 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: 0x000000
-});
\ No newline at end of file
+	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;
+// 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');
+}
+function loadLevel(level) {
+	// Clear any existing level elements
+	clearLevel();
+	// Update level display
+	levelTxt.setText('Level: ' + level);
+	// Reset shots
+	shotsRemaining = 3 + level;
+	shotsTxt.setText('Shots: ' + shotsRemaining);
+	// Different level layouts
+	switch (level) {
+		case 1:
+			// Basic level with a few targets
+			createTarget(1024, 300);
+			createTarget(1400, 600);
+			createTarget(800, 800);
+			// Add walls
+			createWall(500, 500, 0);
+			createWall(1500, 1000, Math.PI / 4);
+			break;
+		case 2:
+			// More complex level
+			createTarget(800, 400);
+			createTarget(1200, 400);
+			createTarget(1500, 800);
+			createTarget(1000, 1200);
+			createTarget(600, 1500);
+			// Add walls
+			createWall(400, 800, 0);
+			createWall(1600, 800, 0);
+			createWall(1000, 300, Math.PI / 2);
+			createWall(1000, 1500, Math.PI / 2);
+			break;
+		case 3:
+			// Advanced level
+			createTarget(300, 300);
+			createTarget(1700, 300);
+			createTarget(300, 1500);
+			createTarget(1700, 1500);
+			createTarget(1000, 900);
+			createTarget(600, 900);
+			createTarget(1400, 900);
+			// Add walls - create a maze-like structure
+			createWall(600, 600, 0);
+			createWall(1400, 600, 0);
+			createWall(600, 1200, 0);
+			createWall(1400, 1200, 0);
+			createWall(1000, 600, Math.PI / 2);
+			createWall(1000, 1200, Math.PI / 2);
+			break;
+		default:
+			// For levels beyond 3, create a procedural level with more targets and walls
+			for (var i = 0; i < level + 3; i++) {
+				createTarget(300 + Math.random() * 1400, 300 + Math.random() * 1500);
+			}
+			for (var i = 0; i < level; 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);
+}
+// Initialize the game
+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();
+};
\ No newline at end of file