===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,328 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+
+/**** 
+* Classes
+****/ 
+var Obstacle = Container.expand(function (type) {
+	var self = Container.call(this);
+	// Type can be "harmful" or "collectible"
+	self.type = type || "harmful";
+	// Set properties based on type
+	if (self.type === "harmful") {
+		var obstacleGraphics = self.attachAsset('Shape', {
+			width: 80,
+			height: 80,
+			shape: 'box',
+			color: 0xFF0000,
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	} else {
+		var obstacleGraphics = self.attachAsset('Shape', {
+			width: 60,
+			height: 60,
+			shape: 'ellipse',
+			color: 0x00FF00,
+			anchorX: 0.5,
+			anchorY: 0.5
+		});
+	}
+	// Movement properties
+	self.speedX = 0;
+	self.speedY = 0;
+	self.lastX = 0;
+	self.lastY = 0;
+	// Update position and check boundaries
+	self.update = function () {
+		// Store last position
+		self.lastX = self.x;
+		self.lastY = self.y;
+		// Move obstacle
+		self.x += self.speedX;
+		self.y += self.speedY;
+		// Check if off-screen
+		if (self.x < -100 || self.x > 2148 || self.y < -100 || self.y > 2832) {
+			return true; // Return true to indicate this obstacle should be removed
+		}
+		return false;
+	};
+	return self;
+});
+// Set background color
+var SlimePhysics = Container.expand(function () {
+	var self = Container.call(this);
+	// State variables for slime physics
+	self.baseY = 0;
+	self.jumping = false;
+	self.deforming = false;
+	self.defaultRadius = 100;
+	self.currentRadius = self.defaultRadius;
+	self.pulseAmount = 0;
+	self.pulseDirection = 1;
+	self.lastIntersecting = false;
+	// Create the slime body
+	var slimeBody = self.attachAsset('Slime', {
+		anchorX: 0.5,
+		anchorY: 0.5,
+		scaleX: 1,
+		scaleY: 1,
+		alpha: 0.9
+	});
+	// Reference to body for animations
+	self.body = slimeBody;
+	// Apply initial deformation for idle state
+	self.pulseIdle = function () {
+		if (!self.deforming && !self.jumping) {
+			self.pulseAmount += 0.005 * self.pulseDirection;
+			if (self.pulseAmount > 0.1 || self.pulseAmount < -0.05) {
+				self.pulseDirection *= -1;
+			}
+			// Apply subtle breathing deformation
+			self.body.scaleX = 1 + self.pulseAmount;
+			self.body.scaleY = 1 - self.pulseAmount;
+		}
+	};
+	// Jump method with deformation
+	self.jump = function () {
+		if (!self.jumping) {
+			self.jumping = true;
+			// Squish before jumping
+			tween(self.body, {
+				scaleY: 0.7,
+				scaleX: 1.3
+			}, {
+				duration: 200,
+				easing: tween.easeOut,
+				onFinish: function onFinish() {
+					// Start actual jump
+					tween(self, {
+						y: self.baseY - 300
+					}, {
+						duration: 600,
+						easing: tween.easeOutQuad,
+						onFinish: function onFinish() {
+							// Start falling
+							tween(self, {
+								y: self.baseY
+							}, {
+								duration: 600,
+								easing: tween.easeInQuad,
+								onFinish: function onFinish() {
+									// Land with impact deformation
+									tween(self.body, {
+										scaleY: 0.6,
+										scaleX: 1.4
+									}, {
+										duration: 200,
+										easing: tween.easeOut,
+										onFinish: function onFinish() {
+											// Return to normal shape
+											tween(self.body, {
+												scaleY: 1,
+												scaleX: 1
+											}, {
+												duration: 400,
+												easing: tween.elasticOut,
+												onFinish: function onFinish() {
+													self.jumping = false;
+												}
+											});
+										}
+									});
+								}
+							});
+							// While in air, stretch vertically
+							tween(self.body, {
+								scaleY: 1.2,
+								scaleX: 0.9
+							}, {
+								duration: 300,
+								easing: tween.easeInOut
+							});
+						}
+					});
+				}
+			});
+		}
+	};
+	// React to approaching objects
+	self.reactToObject = function (objectX, objectY) {
+		if (!self.deforming && !self.jumping) {
+			// Calculate which direction to deform based on object position
+			var dx = objectX - self.x;
+			var dy = objectY - self.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			if (distance < 300) {
+				self.deforming = true;
+				// Deform away from the approaching object
+				var deformX = 1 - Math.abs(dx) / 500;
+				var deformY = 1 - Math.abs(dy) / 500;
+				if (dx > 0) {
+					deformX = 1 / deformX;
+				}
+				if (dy > 0) {
+					deformY = 1 / deformY;
+				}
+				// Apply deformation
+				tween(self.body, {
+					scaleX: deformX,
+					scaleY: deformY
+				}, {
+					duration: 200,
+					easing: tween.easeOut,
+					onFinish: function onFinish() {
+						// Return to normal shape
+						tween(self.body, {
+							scaleX: 1,
+							scaleY: 1
+						}, {
+							duration: 400,
+							easing: tween.elasticOut,
+							onFinish: function onFinish() {
+								self.deforming = false;
+							}
+						});
+					}
+				});
+			}
+		}
+	};
+	// Down handler for jumping
+	self.down = function (x, y, obj) {
+		self.jump();
+	};
+	// Update method called automatically by LK
+	self.update = function () {
+		self.pulseIdle();
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
 	backgroundColor: 0x000000
-});
\ No newline at end of file
+});
+
+/**** 
+* Game Code
+****/ 
+// Set background color
+game.setBackgroundColor(0x2C3E50);
+// Create score text
+var scoreTxt = new Text2('0', {
+	size: 100,
+	fill: 0xFFFFFF
+});
+scoreTxt.anchor.set(0.5, 0);
+LK.gui.top.addChild(scoreTxt);
+// Create slime character
+var slime = new SlimePhysics();
+slime.x = 2048 / 2;
+slime.y = 2732 - 300;
+slime.baseY = slime.y;
+game.addChild(slime);
+// Create arrays to track game objects
+var obstacles = [];
+var score = 0;
+// Spawn obstacles on a timer
+var obstacleTimer = LK.setInterval(function () {
+	var type = Math.random() > 0.3 ? "harmful" : "collectible"; // 70% harmful, 30% collectible
+	var obstacle = new Obstacle(type);
+	// Position on random edge of screen with direction toward slime
+	var side = Math.floor(Math.random() * 4); // 0: top, 1: right, 2: bottom, 3: left
+	switch (side) {
+		case 0:
+			// top
+			obstacle.x = Math.random() * 2048;
+			obstacle.y = -50;
+			obstacle.speedY = 3 + Math.random() * 2;
+			obstacle.speedX = (slime.x - obstacle.x) / 200;
+			break;
+		case 1:
+			// right
+			obstacle.x = 2148;
+			obstacle.y = Math.random() * 2732;
+			obstacle.speedX = -3 - Math.random() * 2;
+			obstacle.speedY = (slime.y - obstacle.y) / 200;
+			break;
+		case 2:
+			// bottom
+			obstacle.x = Math.random() * 2048;
+			obstacle.y = 2832;
+			obstacle.speedY = -3 - Math.random() * 2;
+			obstacle.speedX = (slime.x - obstacle.x) / 200;
+			break;
+		case 3:
+			// left
+			obstacle.x = -50;
+			obstacle.y = Math.random() * 2732;
+			obstacle.speedX = 3 + Math.random() * 2;
+			obstacle.speedY = (slime.y - obstacle.y) / 200;
+			break;
+	}
+	obstacle.lastX = obstacle.x;
+	obstacle.lastY = obstacle.y;
+	obstacle.lastIntersecting = false;
+	obstacles.push(obstacle);
+	game.addChild(obstacle);
+}, 1000);
+// Game update loop
+game.update = function () {
+	// Update obstacles and check collisions
+	for (var i = obstacles.length - 1; i >= 0; i--) {
+		var obstacle = obstacles[i];
+		// Update obstacle and check if it's gone off-screen
+		if (obstacle.update()) {
+			obstacle.destroy();
+			obstacles.splice(i, 1);
+			continue;
+		}
+		// Check for intersections with slime
+		var currentIntersecting = obstacle.intersects(slime);
+		if (!obstacle.lastIntersecting && currentIntersecting) {
+			// We just started intersecting
+			if (obstacle.type === "harmful") {
+				// Harmful object collision
+				LK.effects.flashScreen(0xFF0000, 500);
+				LK.getSound('Shut').play();
+				// Game over after a brief delay
+				LK.setTimeout(function () {
+					LK.showGameOver();
+				}, 500);
+			} else {
+				// Collectible object collision
+				LK.getSound('Bonus').play();
+				score += 10;
+				scoreTxt.setText(score);
+				// Flash slime with green tint
+				LK.effects.flashObject(slime, 0x00FF00, 500);
+				// Remove collectible
+				obstacle.destroy();
+				obstacles.splice(i, 1);
+			}
+			continue;
+		}
+		// Update lastIntersecting state
+		obstacle.lastIntersecting = currentIntersecting;
+		// Make slime react to close obstacles
+		if (obstacle.type === "harmful") {
+			// Calculate distance to slime
+			var dx = obstacle.x - slime.x;
+			var dy = obstacle.y - slime.y;
+			var distance = Math.sqrt(dx * dx + dy * dy);
+			// React when obstacle gets close
+			if (distance < 300) {
+				slime.reactToObject(obstacle.x, obstacle.y);
+			}
+		}
+	}
+};
+// Handle touch/mouse events for the game
+game.down = function (x, y, obj) {
+	slime.jump();
+};
\ No newline at end of file