===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,506 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1", {
+	currentLevel: 1,
+	highestLevel: 1
+});
+
+/**** 
+* Classes
+****/ 
+var DataPacket = Container.expand(function (color, speed) {
+	var self = Container.call(this);
+	self.packetColor = color || 0xFFFFFF;
+	self.targetNodeId = null;
+	self.speed = speed || 3;
+	self.isDragging = false;
+	self.isMatched = false;
+	var packetGraphics = self.attachAsset('dataPacket', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		tint: self.packetColor
+	});
+	self.down = function (x, y, obj) {
+		self.isDragging = true;
+		game.draggedPacket = self;
+	};
+	self.up = function (x, y, obj) {
+		self.isDragging = false;
+		if (game.draggedPacket === self) {
+			game.draggedPacket = null;
+		}
+	};
+	self.match = function (storageNode) {
+		self.isMatched = true;
+		self.targetNodeId = storageNode.id;
+		tween(self, {
+			x: storageNode.x,
+			y: storageNode.y,
+			width: 0,
+			height: 0,
+			alpha: 0
+		}, {
+			duration: 500,
+			easing: tween.easeIn,
+			onFinish: function onFinish() {
+				self.destroy();
+				storageNode.processPacket();
+				game.removePacket(self);
+				game.score += 10;
+				LK.setScore(game.score);
+				LK.getSound('packet_match').play();
+			}
+		});
+	};
+	self.setColor = function (color) {
+		self.packetColor = color;
+		packetGraphics.tint = color;
+	};
+	self.update = function () {
+		if (self.isMatched) return;
+		if (!self.isDragging && !game.isPaused) {
+			// Move packet toward center when not dragging
+			var dx = game.dataCore.x - self.x;
+			var dy = game.dataCore.y - self.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance > 5) {
+				self.x += dx / distance * self.speed;
+				self.y += dy / distance * self.speed;
+			} else {
+				// Packet reached the core (game over condition)
+				if (!game.isGameOver) {
+					game.takeDamage();
+				}
+				game.removePacket(self);
+				self.destroy();
+			}
+		}
+	};
+	return self;
+});
+var Firewall = Container.expand(function (x, y, width, rotation) {
+	var self = Container.call(this);
+	self.x = x;
+	self.y = y;
+	var firewallGraphics = self.attachAsset('firewall', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		width: width || 200,
+		height: 40
+	});
+	if (rotation) {
+		self.rotation = rotation * Math.PI / 180;
+	}
+	self.update = function () {
+		// Optional: Add movement patterns for firewalls in higher levels
+	};
+	return self;
+});
+var ProgressBar = Container.expand(function () {
+	var self = Container.call(this);
+	var background = self.attachAsset('progressBar', {
+		anchorX: 0,
+		anchorY: 0.5
+	});
+	var fill = self.attachAsset('progressFill', {
+		anchorX: 0,
+		anchorY: 0.5
+	});
+	fill.width = 0;
+	self.setProgress = function (percentage) {
+		var targetWidth = Math.min(Math.max(percentage, 0), 1) * background.width;
+		tween(fill, {
+			width: targetWidth
+		}, {
+			duration: 300,
+			easing: tween.easeOut
+		});
+	};
+	return self;
+});
+var StorageNode = Container.expand(function (id, color) {
+	var self = Container.call(this);
+	self.id = id;
+	self.nodeColor = color;
+	self.packetsProcessed = 0;
+	self.maxPackets = 5;
+	var nodeGraphics = self.attachAsset('storageNode', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		tint: self.nodeColor
+	});
+	var countText = new Text2('0/' + self.maxPackets, {
+		size: 40,
+		fill: 0xFFFFFF
+	});
+	countText.anchor.set(0.5, 0.5);
+	self.addChild(countText);
+	self.processPacket = function () {
+		self.packetsProcessed++;
+		countText.setText(self.packetsProcessed + '/' + self.maxPackets);
+		// Check if this node is full
+		if (self.packetsProcessed >= self.maxPackets) {
+			tween(nodeGraphics, {
+				tint: 0xFFFFFF
+			}, {
+				duration: 300,
+				easing: tween.easeOut
+			});
+			// Check if all nodes are full
+			game.checkLevelComplete();
+		}
+	};
+	self.reset = function () {
+		self.packetsProcessed = 0;
+		countText.setText(self.packetsProcessed + '/' + self.maxPackets);
+		nodeGraphics.tint = self.nodeColor;
+	};
+	self.update = function () {
+		// Node pulsing animation if not full
+		if (self.packetsProcessed < self.maxPackets && !game.isPaused) {
+			var pulse = Math.sin(game.ticks * 0.05) * 0.1 + 0.9;
+			self.scale.set(pulse, pulse);
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x000022
+});
+
+/**** 
+* Game Code
+****/ 
+// Game configuration
+var COLORS = [0xFF4444, 0x44FF44, 0x4444FF, 0xFFFF44, 0xFF44FF, 0x44FFFF];
+var LEVELS = [{
+	packetSpeed: 2,
+	spawnRate: 120,
+	nodeCount: 3,
+	firewalls: 0,
+	maxHealth: 3
+}, {
+	packetSpeed: 2,
+	spawnRate: 100,
+	nodeCount: 3,
+	firewalls: 2,
+	maxHealth: 3
+}, {
+	packetSpeed: 3,
+	spawnRate: 90,
+	nodeCount: 4,
+	firewalls: 3,
+	maxHealth: 3
+}, {
+	packetSpeed: 3,
+	spawnRate: 80,
+	nodeCount: 4,
+	firewalls: 4,
+	maxHealth: 2
+}, {
+	packetSpeed: 4,
+	spawnRate: 70,
+	nodeCount: 5,
+	firewalls: 5,
+	maxHealth: 2
+}];
+// Game state variables
+game.level = storage.currentLevel || 1;
+game.score = 0;
+game.health = 0;
+game.maxHealth = 0;
+game.isPaused = false;
+game.isGameOver = false;
+game.levelComplete = false;
+game.packets = [];
+game.storageNodes = [];
+game.firewalls = [];
+game.draggedPacket = null;
+game.ticks = 0;
+// Initialize UI elements
+var scoreTxt = new Text2('Score: 0', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+scoreTxt.anchor.set(1, 0);
+LK.gui.topRight.addChild(scoreTxt);
+var levelTxt = new Text2('Level: 1', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+levelTxt.anchor.set(0, 0);
+LK.gui.topLeft.addChild(levelTxt);
+levelTxt.x = 120; // Move away from the top left corner platform menu icon
+var healthTxt = new Text2('System Health: 3/3', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+healthTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(healthTxt);
+var levelProgress = new ProgressBar();
+levelProgress.x = 2048 / 2 - 400;
+levelProgress.y = 100;
+LK.gui.addChild(levelProgress);
+// Initialize game elements
+function initializeLevel() {
+	// Clear existing elements
+	game.packets.forEach(function (packet) {
+		packet.destroy();
+	});
+	game.packets = [];
+	game.storageNodes.forEach(function (node) {
+		node.destroy();
+	});
+	game.storageNodes = [];
+	game.firewalls.forEach(function (firewall) {
+		firewall.destroy();
+	});
+	game.firewalls = [];
+	// Get level configuration
+	var levelIndex = Math.min(game.level - 1, LEVELS.length - 1);
+	var levelConfig = LEVELS[levelIndex];
+	// Set health
+	game.maxHealth = levelConfig.maxHealth;
+	game.health = levelConfig.maxHealth;
+	healthTxt.setText('System Health: ' + game.health + '/' + game.maxHealth);
+	// Update level text
+	levelTxt.setText('Level: ' + game.level);
+	// Reset progress bar
+	levelProgress.setProgress(0);
+	// Create data core
+	var coreBackground = LK.getAsset('dataCoreBackground', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	game.addChild(coreBackground);
+	coreBackground.x = 2048 / 2;
+	coreBackground.y = 2732 / 2;
+	game.dataCore = LK.getAsset('dataCore', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	game.addChild(game.dataCore);
+	game.dataCore.x = 2048 / 2;
+	game.dataCore.y = 2732 / 2;
+	// Create storage nodes in a circle around core
+	var nodeColors = [];
+	for (var i = 0; i < levelConfig.nodeCount; i++) {
+		nodeColors.push(COLORS[i % COLORS.length]);
+	}
+	for (var i = 0; i < levelConfig.nodeCount; i++) {
+		var angle = i * 2 * Math.PI / levelConfig.nodeCount;
+		var distance = 550;
+		var x = 2048 / 2 + Math.cos(angle) * distance;
+		var y = 2732 / 2 + Math.sin(angle) * distance;
+		var storageNode = new StorageNode(i, nodeColors[i]);
+		storageNode.x = x;
+		storageNode.y = y;
+		game.addChild(storageNode);
+		game.storageNodes.push(storageNode);
+	}
+	// Create firewalls
+	for (var i = 0; i < levelConfig.firewalls; i++) {
+		var angle = i * 2 * Math.PI / levelConfig.firewalls + Math.PI / levelConfig.firewalls;
+		var distance = 350;
+		var x = 2048 / 2 + Math.cos(angle) * distance;
+		var y = 2732 / 2 + Math.sin(angle) * distance;
+		var firewall = new Firewall(x, y, 300, angle * 180 / Math.PI + 90);
+		game.addChild(firewall);
+		game.firewalls.push(firewall);
+	}
+	// Reset game state
+	game.isPaused = false;
+	game.isGameOver = false;
+	game.levelComplete = false;
+	// Play music
+	LK.playMusic('gameplay_music');
+}
+// Spawn a new data packet
+function spawnPacket() {
+	var levelIndex = Math.min(game.level - 1, LEVELS.length - 1);
+	var levelConfig = LEVELS[levelIndex];
+	// Determine spawn position (random position along edge)
+	var side = Math.floor(Math.random() * 4);
+	var x, y;
+	switch (side) {
+		case 0:
+			// Top
+			x = Math.random() * 2048;
+			y = 100;
+			break;
+		case 1:
+			// Right
+			x = 2048 - 100;
+			y = Math.random() * 2732;
+			break;
+		case 2:
+			// Bottom
+			x = Math.random() * 2048;
+			y = 2732 - 100;
+			break;
+		case 3:
+			// Left
+			x = 100;
+			y = Math.random() * 2732;
+			break;
+	}
+	// Only use colors that match existing nodes
+	var nodeColors = game.storageNodes.map(function (node) {
+		return node.nodeColor;
+	});
+	var packetColor = nodeColors[Math.floor(Math.random() * nodeColors.length)];
+	var packet = new DataPacket(packetColor, levelConfig.packetSpeed);
+	packet.x = x;
+	packet.y = y;
+	game.addChild(packet);
+	game.packets.push(packet);
+}
+// Check if the level is complete
+game.checkLevelComplete = function () {
+	var allNodesFull = true;
+	for (var i = 0; i < game.storageNodes.length; i++) {
+		if (game.storageNodes[i].packetsProcessed < game.storageNodes[i].maxPackets) {
+			allNodesFull = false;
+			break;
+		}
+	}
+	if (allNodesFull && !game.levelComplete) {
+		game.levelComplete = true;
+		// Calculate progress for next level
+		game.level++;
+		if (game.level > storage.highestLevel) {
+			storage.highestLevel = game.level;
+		}
+		storage.currentLevel = game.level;
+		// Play level complete sound
+		LK.getSound('level_complete').play();
+		// Show level complete message and start next level
+		var levelCompleteTxt = new Text2('Level Complete!', {
+			size: 100,
+			fill: 0xFFFFFF
+		});
+		levelCompleteTxt.anchor.set(0.5, 0.5);
+		levelCompleteTxt.x = 2048 / 2;
+		levelCompleteTxt.y = 2732 / 2;
+		game.addChild(levelCompleteTxt);
+		LK.setTimeout(function () {
+			levelCompleteTxt.destroy();
+			initializeLevel();
+		}, 2000);
+	}
+};
+// Remove a packet from the game
+game.removePacket = function (packet) {
+	var index = game.packets.indexOf(packet);
+	if (index !== -1) {
+		game.packets.splice(index, 1);
+	}
+};
+// Handle damage to the system
+game.takeDamage = function () {
+	game.health--;
+	healthTxt.setText('System Health: ' + game.health + '/' + game.maxHealth);
+	LK.effects.flashScreen(0xFF0000, 500);
+	LK.getSound('packet_error').play();
+	if (game.health <= 0) {
+		game.isGameOver = true;
+		LK.showGameOver();
+	}
+};
+// Event Handlers
+game.down = function (x, y, obj) {
+	// Check if we clicked directly on a packet
+	for (var i = 0; i < game.packets.length; i++) {
+		var packet = game.packets[i];
+		var localPoint = packet.toLocal({
+			x: x,
+			y: y
+		});
+		if (Math.abs(localPoint.x) < packet.width / 2 && Math.abs(localPoint.y) < packet.height / 2) {
+			packet.down(x, y, obj);
+			return;
+		}
+	}
+};
+game.up = function (x, y, obj) {
+	if (game.draggedPacket) {
+		// Check if packet is dropped on matching storage node
+		for (var i = 0; i < game.storageNodes.length; i++) {
+			var node = game.storageNodes[i];
+			var distance = Math.sqrt(Math.pow(node.x - game.draggedPacket.x, 2) + Math.pow(node.y - game.draggedPacket.y, 2));
+			if (distance < 100 && node.nodeColor === game.draggedPacket.packetColor && node.packetsProcessed < node.maxPackets) {
+				game.draggedPacket.match(node);
+				break;
+			}
+		}
+		game.draggedPacket.up(x, y, obj);
+	}
+};
+game.move = function (x, y, obj) {
+	if (game.draggedPacket) {
+		game.draggedPacket.x = x;
+		game.draggedPacket.y = y;
+		// Check for firewall collisions while dragging
+		for (var i = 0; i < game.firewalls.length; i++) {
+			var firewall = game.firewalls[i];
+			var localPoint = firewall.toLocal({
+				x: game.draggedPacket.x,
+				y: game.draggedPacket.y
+			});
+			// Rotate the point back to check collision with non-rotated firewall
+			var rotatedX = localPoint.x * Math.cos(-firewall.rotation) - localPoint.y * Math.sin(-firewall.rotation);
+			var rotatedY = localPoint.x * Math.sin(-firewall.rotation) + localPoint.y * Math.cos(-firewall.rotation);
+			if (Math.abs(rotatedX) < firewall.getChildAt(0).width / 2 && Math.abs(rotatedY) < firewall.getChildAt(0).height / 2) {
+				// If colliding with firewall, move the packet away
+				var angle = Math.atan2(game.draggedPacket.y - firewall.y, game.draggedPacket.x - firewall.x);
+				game.draggedPacket.x = firewall.x + Math.cos(angle) * 60;
+				game.draggedPacket.y = firewall.y + Math.sin(angle) * 60;
+				// Visual feedback
+				LK.effects.flashObject(firewall, 0xFFFFFF, 200);
+				break;
+			}
+		}
+	}
+};
+// Game update loop
+game.update = function () {
+	game.ticks++;
+	if (game.isGameOver || game.levelComplete || game.isPaused) {
+		return;
+	}
+	// Update all game elements
+	for (var i = 0; i < game.packets.length; i++) {
+		if (game.packets[i]) {
+			game.packets[i].update();
+		}
+	}
+	for (var i = 0; i < game.storageNodes.length; i++) {
+		game.storageNodes[i].update();
+	}
+	for (var i = 0; i < game.firewalls.length; i++) {
+		game.firewalls[i].update();
+	}
+	// Spawn new packets based on level
+	var levelIndex = Math.min(game.level - 1, LEVELS.length - 1);
+	var levelConfig = LEVELS[levelIndex];
+	if (game.ticks % levelConfig.spawnRate === 0) {
+		spawnPacket();
+	}
+	// Update progress bar based on filled nodes
+	var totalNeeded = game.storageNodes.length * game.storageNodes[0].maxPackets;
+	var totalFilled = 0;
+	for (var i = 0; i < game.storageNodes.length; i++) {
+		totalFilled += game.storageNodes[i].packetsProcessed;
+	}
+	levelProgress.setProgress(totalFilled / totalNeeded);
+	// Update score display
+	scoreTxt.setText('Score: ' + LK.getScore());
+};
+// Initialize the first level
+initializeLevel();
\ No newline at end of file