===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,650 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	currentLevel: 1,
+	highestLevel: 1
+});
+
+/**** 
+* Classes
+****/ 
+var Car = Container.expand(function () {
+	var self = Container.call(this);
+	var carGraphics = self.attachAsset('car', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 0;
+	self.maxSpeed = 5;
+	self.rotationSpeed = 0;
+	self.maxRotationSpeed = 0.05;
+	self.friction = 0.95;
+	self.collided = false;
+	self.accelerate = function (amount) {
+		self.speed += amount;
+		if (self.speed > self.maxSpeed) {
+			self.speed = self.maxSpeed;
+		}
+		if (self.speed < -self.maxSpeed) {
+			self.speed = -self.maxSpeed;
+		}
+	};
+	self.rotate = function (amount) {
+		self.rotationSpeed += amount;
+		if (self.rotationSpeed > self.maxRotationSpeed) {
+			self.rotationSpeed = self.maxRotationSpeed;
+		}
+		if (self.rotationSpeed < -self.maxRotationSpeed) {
+			self.rotationSpeed = -self.maxRotationSpeed;
+		}
+	};
+	self.update = function () {
+		if (self.collided) {
+			return;
+		}
+		// Apply rotation
+		self.rotation += self.rotationSpeed;
+		self.rotationSpeed *= self.friction;
+		// Apply movement in direction of rotation
+		var dx = Math.sin(self.rotation) * self.speed;
+		var dy = -Math.cos(self.rotation) * self.speed;
+		self.x += dx;
+		self.y += dy;
+		// Apply friction
+		self.speed *= self.friction;
+		// Keep car within bounds
+		if (self.x < 100) {
+			self.x = 100;
+		}
+		if (self.x > 2048 - 100) {
+			self.x = 2048 - 100;
+		}
+		if (self.y < 100) {
+			self.y = 100;
+		}
+		if (self.y > 2732 - 100) {
+			self.y = 2732 - 100;
+		}
+	};
+	self.checkCollision = function (object) {
+		return self.intersects(object);
+	};
+	self.handleCollision = function () {
+		if (!self.collided) {
+			self.collided = true;
+			LK.getSound('crash').play();
+			LK.effects.flashObject(self, 0xff0000, 500);
+			tween(self, {
+				alpha: 0.5
+			}, {
+				duration: 300
+			});
+			// Reset player after a delay
+			LK.setTimeout(function () {
+				self.resetPosition();
+			}, 1000);
+		}
+	};
+	self.resetPosition = function () {
+		self.x = currentLevel.playerStartX;
+		self.y = currentLevel.playerStartY;
+		self.rotation = currentLevel.playerStartRotation || 0;
+		self.speed = 0;
+		self.rotationSpeed = 0;
+		self.collided = false;
+		tween(self, {
+			alpha: 1
+		}, {
+			duration: 300
+		});
+	};
+	return self;
+});
+var MovingObstacle = Container.expand(function () {
+	var self = Container.call(this);
+	var obstacleGraphics = self.attachAsset('movingObstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.speed = 2;
+	self.direction = {
+		x: 1,
+		y: 0
+	};
+	self.waypoints = [];
+	self.currentWaypoint = 0;
+	self.setWaypoints = function (points) {
+		self.waypoints = points;
+		if (self.waypoints.length > 0) {
+			self.x = self.waypoints[0].x;
+			self.y = self.waypoints[0].y;
+		}
+	};
+	self.update = function () {
+		if (self.waypoints.length < 2) {
+			return;
+		}
+		var target = self.waypoints[self.currentWaypoint];
+		var dx = target.x - self.x;
+		var dy = target.y - self.y;
+		var distToTarget = Math.sqrt(dx * dx + dy * dy);
+		if (distToTarget < self.speed) {
+			// Reached waypoint, move to next
+			self.currentWaypoint = (self.currentWaypoint + 1) % self.waypoints.length;
+		} else {
+			// Move towards waypoint
+			self.x += dx / distToTarget * self.speed;
+			self.y += dy / distToTarget * self.speed;
+		}
+	};
+	return self;
+});
+var Obstacle = Container.expand(function () {
+	var self = Container.call(this);
+	var obstacleGraphics = self.attachAsset('obstacle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	return self;
+});
+var ParkingSpot = Container.expand(function () {
+	var self = Container.call(this);
+	var spotGraphics = self.attachAsset('parkingSpot', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		alpha: 0.5
+	});
+	self.isOccupied = false;
+	self.blinkInterval = null;
+	self.highlight = function () {
+		if (self.blinkInterval) {
+			LK.clearInterval(self.blinkInterval);
+		}
+		var blinkState = false;
+		self.blinkInterval = LK.setInterval(function () {
+			spotGraphics.alpha = blinkState ? 0.7 : 0.3;
+			blinkState = !blinkState;
+		}, 300);
+	};
+	self.stopHighlight = function () {
+		if (self.blinkInterval) {
+			LK.clearInterval(self.blinkInterval);
+			self.blinkInterval = null;
+		}
+		spotGraphics.alpha = 0.5;
+	};
+	self.checkParking = function (car) {
+		if (!car.collided && self.intersects(car)) {
+			// Check if car is mostly within the parking spot and has a similar rotation
+			var dx = Math.abs(car.x - self.x);
+			var dy = Math.abs(car.y - self.y);
+			var angleDiff = Math.abs((car.rotation % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2) - (self.rotation % (Math.PI * 2) + Math.PI * 2) % (Math.PI * 2));
+			if (angleDiff > Math.PI) {
+				angleDiff = Math.PI * 2 - angleDiff;
+			}
+			if (dx < 30 && dy < 30 && angleDiff < 0.3) {
+				self.isOccupied = true;
+				return true;
+			}
+		}
+		return false;
+	};
+	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: 0x333333
+});
+
+/**** 
+* Game Code
+****/ 
+// Game variables
+var car;
+var parkingSpot;
+var obstacles = [];
+var walls = [];
+var movingObstacles = [];
+var currentLevel = {
+	num: 1
+};
+var isLevelComplete = false;
+var isGameOver = false;
+var touchControls = {
+	active: false,
+	startX: 0,
+	startY: 0
+};
+// Load the current level from storage
+var loadedLevel = storage.currentLevel || 1;
+var highestLevel = storage.highestLevel || 1;
+// Setup UI elements
+var levelText = new Text2('Level ' + loadedLevel, {
+	size: 80,
+	fill: 0xFFFFFF
+});
+levelText.anchor.set(0.5, 0);
+LK.gui.top.addChild(levelText);
+var instructionText = new Text2('Park in the green spot!', {
+	size: 50,
+	fill: 0xFFFFFF
+});
+instructionText.anchor.set(0.5, 0);
+instructionText.y = 100;
+LK.gui.top.addChild(instructionText);
+// Control UI
+var leftBtn = LK.getAsset('obstacle', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 150,
+	y: 2732 - 150,
+	tint: 0x0088ff,
+	alpha: 0.7
+});
+var rightBtn = LK.getAsset('obstacle', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 300,
+	y: 2732 - 150,
+	tint: 0x0088ff,
+	alpha: 0.7
+});
+var upBtn = LK.getAsset('obstacle', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 2048 - 150,
+	y: 2732 - 300,
+	tint: 0x0088ff,
+	alpha: 0.7
+});
+var downBtn = LK.getAsset('obstacle', {
+	anchorX: 0.5,
+	anchorY: 0.5,
+	x: 2048 - 150,
+	y: 2732 - 150,
+	tint: 0x0088ff,
+	alpha: 0.7
+});
+game.addChild(leftBtn);
+game.addChild(rightBtn);
+game.addChild(upBtn);
+game.addChild(downBtn);
+// Define key press states
+var keyState = {
+	up: false,
+	down: false,
+	left: false,
+	right: false
+};
+// Level definitions
+function defineLevel(levelNum) {
+	var level = {
+		num: levelNum,
+		playerStartX: 1024,
+		playerStartY: 2200,
+		playerStartRotation: 0,
+		parkingSpotX: 1024,
+		parkingSpotY: 500,
+		parkingSpotRotation: Math.PI,
+		obstacles: [],
+		walls: [],
+		movingObstacles: []
+	};
+	// Add level-specific configurations
+	switch (levelNum) {
+		case 1:
+			// Simple first level - just park
+			instructionText.setText('Park in the green spot!');
+			break;
+		case 2:
+			// Add some static obstacles
+			level.obstacles = [{
+				x: 1024,
+				y: 1200,
+				width: 300,
+				height: 100
+			}];
+			break;
+		case 3:
+			// Moving obstacle
+			level.movingObstacles = [{
+				x: 1024,
+				y: 1500,
+				waypoints: [{
+					x: 700,
+					y: 1500
+				}, {
+					x: 1350,
+					y: 1500
+				}]
+			}];
+			break;
+		case 4:
+			// More complex layout
+			level.obstacles = [{
+				x: 800,
+				y: 1200,
+				width: 100,
+				height: 400
+			}, {
+				x: 1250,
+				y: 1500,
+				width: 100,
+				height: 400
+			}];
+			level.parkingSpotX = 800;
+			break;
+		case 5:
+			// Maze-like level
+			level.walls = [{
+				x: 600,
+				y: 1300,
+				rotation: 0
+			}, {
+				x: 800,
+				y: 1000,
+				rotation: Math.PI / 2
+			}, {
+				x: 1200,
+				y: 1000,
+				rotation: Math.PI / 2
+			}, {
+				x: 1400,
+				y: 1300,
+				rotation: 0
+			}, {
+				x: 1000,
+				y: 1700,
+				rotation: Math.PI / 2
+			}];
+			break;
+		default:
+			// For levels beyond 5, generate procedurally more complex layouts
+			var obstacleCount = Math.min(10, Math.floor(levelNum / 2) + 2);
+			for (var i = 0; i < obstacleCount; i++) {
+				var x = 300 + Math.random() * (2048 - 600);
+				var y = 300 + Math.random() * (2732 - 1000);
+				// Don't place obstacles near the start or parking spot
+				if (distance(x, y, level.playerStartX, level.playerStartY) > 300 && distance(x, y, level.parkingSpotX, level.parkingSpotY) > 300) {
+					level.obstacles.push({
+						x: x,
+						y: y,
+						width: 100,
+						height: 100
+					});
+				}
+			}
+			// Add some moving obstacles for higher levels
+			if (levelNum > 7) {
+				var movingCount = Math.min(3, Math.floor((levelNum - 7) / 5) + 1);
+				for (var j = 0; j < movingCount; j++) {
+					var startX = 300 + Math.random() * (2048 - 600);
+					var startY = 300 + Math.random() * (2732 - 1000);
+					var endX = 300 + Math.random() * (2048 - 600);
+					var endY = 300 + Math.random() * (2732 - 1000);
+					level.movingObstacles.push({
+						x: startX,
+						y: startY,
+						waypoints: [{
+							x: startX,
+							y: startY
+						}, {
+							x: endX,
+							y: endY
+						}]
+					});
+				}
+			}
+			instructionText.setText('Level ' + levelNum + ': Navigate the maze!');
+	}
+	return level;
+}
+function distance(x1, y1, x2, y2) {
+	var dx = x2 - x1;
+	var dy = y2 - y1;
+	return Math.sqrt(dx * dx + dy * dy);
+}
+function loadLevel(levelNum) {
+	// Clear previous level objects
+	clearLevel();
+	// Get level definition
+	currentLevel = defineLevel(levelNum);
+	// Update level text
+	levelText.setText('Level ' + levelNum);
+	// Create car
+	car = new Car();
+	car.x = currentLevel.playerStartX;
+	car.y = currentLevel.playerStartY;
+	car.rotation = currentLevel.playerStartRotation;
+	game.addChild(car);
+	// Create parking spot
+	parkingSpot = new ParkingSpot();
+	parkingSpot.x = currentLevel.parkingSpotX;
+	parkingSpot.y = currentLevel.parkingSpotY;
+	parkingSpot.rotation = currentLevel.parkingSpotRotation || 0;
+	game.addChild(parkingSpot);
+	parkingSpot.highlight();
+	// Create obstacles
+	if (currentLevel.obstacles) {
+		for (var i = 0; i < currentLevel.obstacles.length; i++) {
+			var obsData = currentLevel.obstacles[i];
+			var obstacle = new Obstacle();
+			obstacle.x = obsData.x;
+			obstacle.y = obsData.y;
+			if (obsData.width && obsData.height) {
+				obstacle.scale.x = obsData.width / 100;
+				obstacle.scale.y = obsData.height / 100;
+			}
+			game.addChild(obstacle);
+			obstacles.push(obstacle);
+		}
+	}
+	// Create walls
+	if (currentLevel.walls) {
+		for (var j = 0; j < currentLevel.walls.length; j++) {
+			var wallData = currentLevel.walls[j];
+			var wall = new Wall();
+			wall.x = wallData.x;
+			wall.y = wallData.y;
+			wall.rotation = wallData.rotation || 0;
+			game.addChild(wall);
+			walls.push(wall);
+		}
+	}
+	// Create moving obstacles
+	if (currentLevel.movingObstacles) {
+		for (var k = 0; k < currentLevel.movingObstacles.length; k++) {
+			var mobData = currentLevel.movingObstacles[k];
+			var movingObstacle = new MovingObstacle();
+			movingObstacle.x = mobData.x;
+			movingObstacle.y = mobData.y;
+			if (mobData.waypoints) {
+				movingObstacle.setWaypoints(mobData.waypoints);
+			}
+			game.addChild(movingObstacle);
+			movingObstacles.push(movingObstacle);
+		}
+	}
+	// Reset game state
+	isLevelComplete = false;
+	isGameOver = false;
+	// Play background music
+	LK.playMusic('bgmusic');
+}
+function clearLevel() {
+	// Remove car
+	if (car) {
+		car.destroy();
+		car = null;
+	}
+	// Remove parking spot
+	if (parkingSpot) {
+		parkingSpot.stopHighlight();
+		parkingSpot.destroy();
+		parkingSpot = null;
+	}
+	// Remove obstacles
+	for (var i = 0; i < obstacles.length; i++) {
+		obstacles[i].destroy();
+	}
+	obstacles = [];
+	// Remove walls
+	for (var j = 0; j < walls.length; j++) {
+		walls[j].destroy();
+	}
+	walls = [];
+	// Remove moving obstacles
+	for (var k = 0; k < movingObstacles.length; k++) {
+		movingObstacles[k].destroy();
+	}
+	movingObstacles = [];
+}
+function completeLevel() {
+	if (!isLevelComplete) {
+		isLevelComplete = true;
+		// Play success sound
+		LK.getSound('success').play();
+		// Flash screen green
+		LK.effects.flashScreen(0x00ff00, 500);
+		// Update progress
+		if (currentLevel.num >= highestLevel) {
+			highestLevel = currentLevel.num + 1;
+			storage.highestLevel = highestLevel;
+		}
+		// Save current level
+		storage.currentLevel = currentLevel.num + 1;
+		// Show level complete message
+		instructionText.setText("Level Complete!");
+		// Load next level after delay
+		LK.setTimeout(function () {
+			if (currentLevel.num >= 50) {
+				// Game complete!
+				instructionText.setText("Congratulations! You completed all levels!");
+				LK.showYouWin();
+			} else {
+				loadLevel(currentLevel.num + 1);
+			}
+		}, 2000);
+	}
+}
+// Handle control button events
+leftBtn.interactive = true;
+leftBtn.down = function () {
+	keyState.left = true;
+};
+leftBtn.up = function () {
+	keyState.left = false;
+};
+rightBtn.interactive = true;
+rightBtn.down = function () {
+	keyState.right = true;
+};
+rightBtn.up = function () {
+	keyState.right = false;
+};
+upBtn.interactive = true;
+upBtn.down = function () {
+	keyState.up = true;
+};
+upBtn.up = function () {
+	keyState.up = false;
+};
+downBtn.interactive = true;
+downBtn.down = function () {
+	keyState.down = true;
+};
+downBtn.up = function () {
+	keyState.down = false;
+};
+// Handle touch input for the game area
+game.down = function (x, y, obj) {
+	// Only respond to touches not on control buttons
+	if (obj !== leftBtn && obj !== rightBtn && obj !== upBtn && obj !== downBtn) {
+		touchControls.active = true;
+		touchControls.startX = x;
+		touchControls.startY = y;
+	}
+};
+game.up = function (x, y, obj) {
+	touchControls.active = false;
+};
+game.move = function (x, y, obj) {
+	if (touchControls.active) {
+		var dx = x - touchControls.startX;
+		var dy = y - touchControls.startY;
+		// Reset if drag is too large
+		if (Math.abs(dx) > 100 || Math.abs(dy) > 100) {
+			touchControls.startX = x;
+			touchControls.startY = y;
+		}
+		// Apply car control based on drag direction
+		if (dx < -10) {
+			car.rotate(-0.01);
+		} else if (dx > 10) {
+			car.rotate(0.01);
+		}
+		if (dy < -10) {
+			car.accelerate(0.1);
+		} else if (dy > 10) {
+			car.accelerate(-0.1);
+		}
+	}
+};
+// Game update loop
+game.update = function () {
+	if (isLevelComplete || isGameOver || !car) {
+		return;
+	}
+	// Handle keyboard-style controls
+	if (keyState.left) {
+		car.rotate(-0.01);
+	}
+	if (keyState.right) {
+		car.rotate(0.01);
+	}
+	if (keyState.up) {
+		car.accelerate(0.1);
+	}
+	if (keyState.down) {
+		car.accelerate(-0.1);
+	}
+	// Update moving obstacles
+	for (var i = 0; i < movingObstacles.length; i++) {
+		movingObstacles[i].update();
+		// Check collision with car
+		if (car && !car.collided && car.checkCollision(movingObstacles[i])) {
+			car.handleCollision();
+		}
+	}
+	// Check collisions with static obstacles
+	for (var j = 0; j < obstacles.length; j++) {
+		if (car && !car.collided && car.checkCollision(obstacles[j])) {
+			car.handleCollision();
+		}
+	}
+	// Check collisions with walls
+	for (var k = 0; k < walls.length; k++) {
+		if (car && !car.collided && car.checkCollision(walls[k])) {
+			car.handleCollision();
+		}
+	}
+	// Check if car is in parking spot
+	if (parkingSpot && car && !car.collided && parkingSpot.checkParking(car)) {
+		completeLevel();
+	}
+};
+// Load the initial level
+loadLevel(loadedLevel);
\ No newline at end of file