===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,380 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var InterferenceField = Container.expand(function () {
+	var self = Container.call(this);
+	var fieldGraphics = self.attachAsset('interferenceField', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.dimension = 0;
+	self.pulseDirection = 1;
+	self.setDimension = function (dim) {
+		self.dimension = dim;
+		self.alpha = dim === currentDimension ? 0.8 : 0.2;
+	};
+	self.update = function () {
+		self.alpha += self.pulseDirection * 0.02;
+		if (self.alpha > 1.0) {
+			self.alpha = 1.0;
+			self.pulseDirection = -1;
+		} else if (self.alpha < 0.3) {
+			self.alpha = 0.3;
+			self.pulseDirection = 1;
+		}
+		if (self.dimension !== currentDimension) {
+			self.alpha = 0.2;
+		}
+	};
+	return self;
+});
+var Particle = Container.expand(function () {
+	var self = Container.call(this);
+	var particleGraphics = self.attachAsset('particle', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.dimension = 0;
+	self.originalPosition = {
+		x: 0,
+		y: 0
+	};
+	self.isBeingDragged = false;
+	self.isCollected = false;
+	self.entangledWith = null;
+	self.setDimension = function (dim) {
+		self.dimension = dim;
+		self.alpha = dim === currentDimension ? 1.0 : 0.3;
+	};
+	self.startDrag = function () {
+		self.isBeingDragged = true;
+		tween(particleGraphics, {
+			scaleX: 1.2,
+			scaleY: 1.2
+		}, {
+			duration: 200
+		});
+	};
+	self.stopDrag = function () {
+		self.isBeingDragged = false;
+		tween(particleGraphics, {
+			scaleX: 1.0,
+			scaleY: 1.0
+		}, {
+			duration: 200
+		});
+	};
+	self.collect = function () {
+		self.isCollected = true;
+		tween(self, {
+			alpha: 0,
+			scaleX: 0.1,
+			scaleY: 0.1
+		}, {
+			duration: 300,
+			onFinish: function onFinish() {
+				self.visible = false;
+			}
+		});
+	};
+	self.update = function () {
+		if (self.isCollected) return;
+		// Check collision with quantum core
+		if (self.dimension === currentDimension && self.intersects(quantumCore)) {
+			self.collect();
+			LK.getSound('collectSound').play();
+			particlesCollected++;
+			checkWinCondition();
+		}
+		// Check collision with interference fields
+		for (var i = 0; i < interferenceFields.length; i++) {
+			var field = interferenceFields[i];
+			if (field.dimension === self.dimension && self.intersects(field)) {
+				resetLevel();
+				return;
+			}
+		}
+		// Handle entanglement
+		if (self.entangledWith && !self.isBeingDragged && self.entangledWith.isBeingDragged) {
+			self.x = self.entangledWith.x + 150;
+			self.y = self.entangledWith.y;
+		}
+	};
+	self.down = function (x, y, obj) {
+		if (self.dimension === currentDimension) {
+			draggedParticle = self;
+			self.startDrag();
+			dragOffset.x = x - self.x;
+			dragOffset.y = y - self.y;
+		}
+	};
+	return self;
+});
+var Portal = Container.expand(function () {
+	var self = Container.call(this);
+	var portalGraphics = self.attachAsset('portal', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	self.dimension = 0;
+	self.targetDimension = 1;
+	self.setDimension = function (dim) {
+		self.dimension = dim;
+		self.alpha = dim === currentDimension ? 1.0 : 0.2;
+	};
+	self.update = function () {
+		portalGraphics.rotation += 0.02;
+		// Check if particles are transported through portal
+		for (var i = 0; i < particles.length; i++) {
+			var particle = particles[i];
+			if (particle.dimension === self.dimension && self.intersects(particle) && !particle.isBeingDragged) {
+				particle.setDimension(self.targetDimension);
+				LK.getSound('portalSound').play();
+				LK.effects.flashObject(self, 0xffffff, 300);
+			}
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x000033
+});
+
+/**** 
+* Game Code
+****/ 
+var currentDimension = 0;
+var totalDimensions = 2;
+var particles = [];
+var portals = [];
+var interferenceFields = [];
+var quantumCore;
+var draggedParticle = null;
+var dragOffset = {
+	x: 0,
+	y: 0
+};
+var particlesCollected = 0;
+var totalParticles = 0;
+var level = 1;
+// UI Elements
+var dimensionText = new Text2('Dimension: 0', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+dimensionText.anchor.set(0.5, 0);
+LK.gui.top.addChild(dimensionText);
+var levelText = new Text2('Level: 1', {
+	size: 50,
+	fill: 0xFFFFFF
+});
+levelText.anchor.set(0, 0);
+levelText.x = 150;
+levelText.y = 50;
+LK.gui.topLeft.addChild(levelText);
+var instructionText = new Text2('Tap to switch dimensions', {
+	size: 40,
+	fill: 0xCCCCCC
+});
+instructionText.anchor.set(0.5, 1);
+LK.gui.bottom.addChild(instructionText);
+// Create dimension indicators
+var dimensionIndicators = [];
+for (var d = 0; d < totalDimensions; d++) {
+	var indicator = LK.getAsset('dimensionIndicator', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 1024 + d * 60,
+		y: 150
+	});
+	dimensionIndicators.push(indicator);
+	LK.gui.addChild(indicator);
+}
+function initializeLevel() {
+	// Clear existing elements
+	for (var i = 0; i < particles.length; i++) {
+		particles[i].destroy();
+	}
+	for (var i = 0; i < portals.length; i++) {
+		portals[i].destroy();
+	}
+	for (var i = 0; i < interferenceFields.length; i++) {
+		interferenceFields[i].destroy();
+	}
+	particles = [];
+	portals = [];
+	interferenceFields = [];
+	particlesCollected = 0;
+	currentDimension = 0;
+	// Create quantum core
+	if (quantumCore) {
+		quantumCore.destroy();
+	}
+	quantumCore = game.addChild(LK.getAsset('quantumCore', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		x: 1024,
+		y: 400
+	}));
+	// Level 1 setup
+	if (level === 1) {
+		// Simple particles in different dimensions
+		var particle1 = game.addChild(new Particle());
+		particle1.x = 300;
+		particle1.y = 1000;
+		particle1.setDimension(0);
+		particles.push(particle1);
+		var particle2 = game.addChild(new Particle());
+		particle2.x = 1700;
+		particle2.y = 1000;
+		particle2.setDimension(1);
+		particles.push(particle2);
+		// Portal to connect dimensions
+		var portal1 = game.addChild(new Portal());
+		portal1.x = 1024;
+		portal1.y = 1000;
+		portal1.dimension = 0;
+		portal1.targetDimension = 1;
+		portal1.setDimension(0);
+		portals.push(portal1);
+		totalParticles = 2;
+	} else {
+		// Progressive levels with more complexity
+		var numParticles = Math.min(level + 1, 4);
+		var numFields = Math.min(level - 1, 3);
+		for (var i = 0; i < numParticles; i++) {
+			var particle = game.addChild(new Particle());
+			particle.x = 200 + i * 300;
+			particle.y = 1200 + i % 2 * 300;
+			particle.setDimension(i % totalDimensions);
+			particles.push(particle);
+		}
+		// Create entangled pairs for higher levels
+		if (level >= 3 && particles.length >= 2) {
+			particles[0].entangledWith = particles[1];
+			particles[1].entangledWith = particles[0];
+		}
+		// Create portals
+		for (var i = 0; i < 2; i++) {
+			var portal = game.addChild(new Portal());
+			portal.x = 500 + i * 1000;
+			portal.y = 800;
+			portal.dimension = i;
+			portal.targetDimension = (i + 1) % totalDimensions;
+			portal.setDimension(i);
+			portals.push(portal);
+		}
+		// Create interference fields
+		for (var i = 0; i < numFields; i++) {
+			var field = game.addChild(new InterferenceField());
+			field.x = 400 + i * 400;
+			field.y = 600;
+			field.setDimension(i % totalDimensions);
+			interferenceFields.push(field);
+		}
+		totalParticles = numParticles;
+	}
+	updateDimensionDisplay();
+	levelText.setText('Level: ' + level);
+}
+function updateDimensionDisplay() {
+	dimensionText.setText('Dimension: ' + currentDimension);
+	for (var i = 0; i < dimensionIndicators.length; i++) {
+		var indicator = dimensionIndicators[i];
+		indicator.alpha = i === currentDimension ? 1.0 : 0.3;
+		indicator.scaleX = i === currentDimension ? 1.5 : 1.0;
+		indicator.scaleY = i === currentDimension ? 1.5 : 1.0;
+	}
+	// Update all objects for dimension visibility
+	for (var i = 0; i < particles.length; i++) {
+		particles[i].setDimension(particles[i].dimension);
+	}
+	for (var i = 0; i < portals.length; i++) {
+		portals[i].setDimension(portals[i].dimension);
+	}
+	for (var i = 0; i < interferenceFields.length; i++) {
+		interferenceFields[i].setDimension(interferenceFields[i].dimension);
+	}
+}
+function switchDimension() {
+	currentDimension = (currentDimension + 1) % totalDimensions;
+	updateDimensionDisplay();
+	LK.getSound('dimensionShift').play();
+	LK.effects.flashScreen(0x440088, 200);
+}
+function checkWinCondition() {
+	if (particlesCollected >= totalParticles) {
+		level++;
+		LK.setTimeout(function () {
+			if (level > 5) {
+				LK.showYouWin();
+			} else {
+				initializeLevel();
+			}
+		}, 1000);
+	}
+}
+function resetLevel() {
+	LK.effects.flashScreen(0xff0000, 500);
+	LK.setTimeout(function () {
+		initializeLevel();
+	}, 600);
+}
+// Event handlers
+game.down = function (x, y, obj) {
+	var hitParticle = false;
+	for (var i = 0; i < particles.length; i++) {
+		var particle = particles[i];
+		if (particle.dimension === currentDimension) {
+			var dx = x - particle.x;
+			var dy = y - particle.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance < 50) {
+				draggedParticle = particle;
+				particle.startDrag();
+				dragOffset.x = x - particle.x;
+				dragOffset.y = y - particle.y;
+				hitParticle = true;
+				break;
+			}
+		}
+	}
+	if (!hitParticle) {
+		switchDimension();
+	}
+};
+game.move = function (x, y, obj) {
+	if (draggedParticle) {
+		draggedParticle.x = x - dragOffset.x;
+		draggedParticle.y = y - dragOffset.y;
+		// Keep particle within bounds
+		draggedParticle.x = Math.max(50, Math.min(1998, draggedParticle.x));
+		draggedParticle.y = Math.max(50, Math.min(2682, draggedParticle.y));
+	}
+};
+game.up = function (x, y, obj) {
+	if (draggedParticle) {
+		draggedParticle.stopDrag();
+		draggedParticle = null;
+	}
+};
+game.update = function () {
+	// Animate quantum core
+	if (quantumCore) {
+		quantumCore.rotation += 0.01;
+		var pulse = Math.sin(LK.ticks * 0.1) * 0.2 + 1.0;
+		quantumCore.scaleX = pulse;
+		quantumCore.scaleY = pulse;
+	}
+};
+// Initialize first level
+initializeLevel();
\ No newline at end of file