===================================================================
--- original.js
+++ change.js
@@ -1,6 +1,612 @@
-/****
+/**** 
+* Plugins
+****/ 
+var tween = LK.import("@upit/tween.v1");
+var storage = LK.import("@upit/storage.v1");
+
+/**** 
+* Classes
+****/ 
+var PhysicsObject = Container.expand(function (type, properties) {
+	var self = Container.call(this);
+	self.type = type || 'block';
+	// Default properties
+	self.mass = (properties === null || properties === void 0 ? void 0 : properties.mass) || 1;
+	self.friction = (properties === null || properties === void 0 ? void 0 : properties.friction) || 0.1;
+	self.restitution = (properties === null || properties === void 0 ? void 0 : properties.restitution) || 0.5;
+	self.isStatic = (properties === null || properties === void 0 ? void 0 : properties.isStatic) || false;
+	// Physics variables
+	self.velocityX = 0;
+	self.velocityY = 0;
+	self.rotation = 0;
+	self.angularVelocity = 0;
+	// Create visual representation
+	var visual = self.attachAsset(type, {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	if (type === 'triangle') {
+		// Make the triangle shape by scaling
+		visual.scaleY = 0.5;
+		visual.y = visual.height / 4;
+	}
+	self.visual = visual;
+	// Visual feedback for static objects
+	if (self.isStatic) {
+		visual.alpha = 0.7;
+	}
+	// Modify the color based on mass
+	var color = visual.tint;
+	if (self.mass > 1) {
+		// Darken for heavier objects
+		visual.tint = darkenColor(color, 0.2 * (self.mass - 1));
+	} else if (self.mass < 1) {
+		// Lighten for lighter objects
+		visual.tint = lightenColor(color, 0.2 * (1 - self.mass));
+	}
+	// Handle interaction
+	self.down = function (x, y, obj) {
+		// Only allow dragging if we're in edit mode
+		if (currentMode === 'edit') {
+			isDragging = true;
+			draggedObject = self;
+			// Store offset for dragging
+			dragOffsetX = self.x - x;
+			dragOffsetY = self.y - y;
+		}
+	};
+	return self;
+});
+var UIButton = Container.expand(function (label, width, height, color) {
+	var self = Container.call(this);
+	// Create button background
+	var background = self.attachAsset('block', {
+		anchorX: 0.5,
+		anchorY: 0.5
+	});
+	background.tint = color || 0x4d90ff;
+	background.width = width || 150;
+	background.height = height || 80;
+	// Create button label
+	var labelText = new Text2(label, {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	labelText.anchor.set(0.5, 0.5);
+	self.addChild(labelText);
+	// Handle button press
+	self.down = function (x, y, obj) {
+		tween(background, {
+			alpha: 0.7
+		}, {
+			duration: 100
+		});
+	};
+	self.up = function (x, y, obj) {
+		tween(background, {
+			alpha: 1
+		}, {
+			duration: 100
+		});
+		if (self.onPress) {
+			self.onPress();
+		}
+	};
+	return self;
+});
+
+/**** 
 * Initialize Game
-****/
+****/ 
 var game = new LK.Game({
-	backgroundColor: 0x000000
-});
\ No newline at end of file
+	backgroundColor: 0x87CEEB // Sky blue background
+});
+
+/**** 
+* Game Code
+****/ 
+// Physics constants
+var GRAVITY = 0.5;
+var DRAG = 0.02;
+var GROUND_Y = 2500;
+// Game state
+var currentMode = 'edit'; // 'edit' or 'simulation'
+var selectedObjectType = 'block';
+var selectedProperties = {
+	mass: 1,
+	friction: 0.1,
+	restitution: 0.5,
+	isStatic: false
+};
+var isDragging = false;
+var draggedObject = null;
+var dragOffsetX = 0;
+var dragOffsetY = 0;
+var physicsObjects = [];
+var isSimulating = false;
+// Create the ground
+var ground = new PhysicsObject('ground', {
+	isStatic: true
+});
+ground.x = 2048 / 2;
+ground.y = GROUND_Y;
+game.addChild(ground);
+physicsObjects.push(ground);
+// Create GUI Elements
+createUI();
+// Helper method to handle object dragging
+function handleMove(x, y, obj) {
+	if (isDragging && draggedObject && currentMode === 'edit') {
+		draggedObject.x = x + dragOffsetX;
+		draggedObject.y = y + dragOffsetY;
+	}
+}
+// Handle pressing down on the game area
+game.down = function (x, y, obj) {
+	// If in edit mode and not dragging an object, create a new one
+	if (currentMode === 'edit' && !isDragging && y < GROUND_Y - 100) {
+		createPhysicsObject(x, y);
+	}
+};
+// Handle moving across the game area
+game.move = handleMove;
+// Handle releasing on the game area
+game.up = function (x, y, obj) {
+	isDragging = false;
+	draggedObject = null;
+};
+// Update physics in the game loop
+game.update = function () {
+	if (isSimulating) {
+		updatePhysics();
+	}
+};
+// Create a new physics object at specified position
+function createPhysicsObject(x, y) {
+	var newObject = new PhysicsObject(selectedObjectType, selectedProperties);
+	newObject.x = x;
+	newObject.y = y;
+	game.addChild(newObject);
+	physicsObjects.push(newObject);
+	// Play place sound
+	LK.getSound('place').play();
+	return newObject;
+}
+// Update physics for all objects
+function updatePhysics() {
+	for (var i = 0; i < physicsObjects.length; i++) {
+		var obj = physicsObjects[i];
+		if (!obj.isStatic) {
+			// Apply gravity
+			obj.velocityY += GRAVITY * obj.mass;
+			// Apply drag
+			obj.velocityX *= 1 - DRAG;
+			obj.velocityY *= 1 - DRAG;
+			obj.angularVelocity *= 1 - DRAG;
+			// Update position
+			obj.x += obj.velocityX;
+			obj.y += obj.velocityY;
+			// Update rotation
+			obj.rotation += obj.angularVelocity;
+			obj.visual.rotation = obj.rotation;
+			// Check boundaries
+			checkBoundaries(obj);
+			// Check collisions with other objects
+			for (var j = 0; j < physicsObjects.length; j++) {
+				if (i !== j) {
+					checkCollision(obj, physicsObjects[j]);
+				}
+			}
+		}
+	}
+}
+// Check if an object is out of bounds
+function checkBoundaries(obj) {
+	// Left boundary
+	if (obj.x - obj.visual.width / 2 < 0) {
+		obj.x = obj.visual.width / 2;
+		obj.velocityX = -obj.velocityX * obj.restitution;
+	}
+	// Right boundary
+	if (obj.x + obj.visual.width / 2 > 2048) {
+		obj.x = 2048 - obj.visual.width / 2;
+		obj.velocityX = -obj.velocityX * obj.restitution;
+	}
+	// Bottom boundary
+	if (obj.y + obj.visual.height / 2 > GROUND_Y - ground.visual.height / 2) {
+		obj.y = GROUND_Y - ground.visual.height / 2 - obj.visual.height / 2;
+		obj.velocityY = -obj.velocityY * obj.restitution;
+		// Apply friction
+		obj.velocityX *= 1 - obj.friction;
+		// Play bounce sound if the impact is significant
+		if (Math.abs(obj.velocityY) > 3) {
+			LK.getSound('bounce').play();
+		}
+	}
+}
+// Simple collision detection and response
+function checkCollision(obj1, obj2) {
+	if (obj1.intersects(obj2)) {
+		// Only process if not already processed in reverse
+		if (obj1.isStatic && obj2.isStatic) {
+			return; // Two static objects don't interact
+		}
+		// Calculate collision vector
+		var dx = obj2.x - obj1.x;
+		var dy = obj2.y - obj1.y;
+		var distance = Math.sqrt(dx * dx + dy * dy);
+		// Normalize collision vector
+		var nx = dx / distance;
+		var ny = dy / distance;
+		// Calculate minimum translation distance
+		var minDist = obj1.visual.width / 2 + obj2.visual.width / 2;
+		var mtd = minDist - distance;
+		// Resolve collision
+		if (!obj1.isStatic && !obj2.isStatic) {
+			// Both objects move
+			var totalMass = obj1.mass + obj2.mass;
+			var obj1Ratio = obj1.mass / totalMass;
+			var obj2Ratio = obj2.mass / totalMass;
+			obj1.x -= nx * mtd * obj2Ratio;
+			obj1.y -= ny * mtd * obj2Ratio;
+			obj2.x += nx * mtd * obj1Ratio;
+			obj2.y += ny * mtd * obj1Ratio;
+			// Calculate relative velocity
+			var vrx = obj2.velocityX - obj1.velocityX;
+			var vry = obj2.velocityY - obj1.velocityY;
+			// Calculate impulse
+			var impulse = -(1 + Math.min(obj1.restitution, obj2.restitution)) * (vrx * nx + vry * ny) / (1 / obj1.mass + 1 / obj2.mass);
+			// Apply impulse
+			obj1.velocityX -= impulse * nx / obj1.mass;
+			obj1.velocityY -= impulse * ny / obj1.mass;
+			obj2.velocityX += impulse * nx / obj2.mass;
+			obj2.velocityY += impulse * ny / obj2.mass;
+			// Add angular velocity based on off-center collision
+			var impact = Math.abs(impulse);
+			obj1.angularVelocity += impact * 0.01 * (Math.random() - 0.5);
+			obj2.angularVelocity += impact * 0.01 * (Math.random() - 0.5);
+			// Play bounce sound if the impact is significant
+			if (impact > 3) {
+				LK.getSound('bounce').play();
+			}
+		} else {
+			// One object is static
+			var movingObj, staticObj;
+			if (obj1.isStatic) {
+				movingObj = obj2;
+				staticObj = obj1;
+				nx = -nx;
+				ny = -ny;
+			} else {
+				movingObj = obj1;
+				staticObj = obj2;
+			}
+			// Move the moving object
+			movingObj.x += nx * mtd;
+			movingObj.y += ny * mtd;
+			// Calculate new velocity
+			var dot = movingObj.velocityX * nx + movingObj.velocityY * ny;
+			movingObj.velocityX -= (1 + movingObj.restitution) * dot * nx;
+			movingObj.velocityY -= (1 + movingObj.restitution) * dot * ny;
+			// Apply friction
+			var tangentX = -ny;
+			var tangentY = nx;
+			var tangentDot = movingObj.velocityX * tangentX + movingObj.velocityY * tangentY;
+			movingObj.velocityX -= tangentDot * tangentX * staticObj.friction;
+			movingObj.velocityY -= tangentDot * tangentY * staticObj.friction;
+			// Add angular velocity
+			movingObj.angularVelocity += dot * 0.02 * (Math.random() - 0.5);
+			// Play bounce sound if the impact is significant
+			if (Math.abs(dot) > 3) {
+				LK.getSound('bounce').play();
+			}
+		}
+	}
+}
+// Start simulation
+function startSimulation() {
+	currentMode = 'simulation';
+	isSimulating = true;
+	playButton.visible = false;
+	pauseButton.visible = true;
+	editButton.visible = true;
+	objectPanel.visible = false;
+	propertiesPanel.visible = false;
+	eraser.visible = false;
+}
+// Pause simulation
+function pauseSimulation() {
+	isSimulating = false;
+	playButton.visible = true;
+	pauseButton.visible = false;
+}
+// Reset to edit mode
+function switchToEditMode() {
+	currentMode = 'edit';
+	isSimulating = false;
+	// Reset all objects except the ground
+	for (var i = physicsObjects.length - 1; i >= 0; i--) {
+		var obj = physicsObjects[i];
+		if (obj !== ground) {
+			// Reset velocities if we're keeping the objects
+			obj.velocityX = 0;
+			obj.velocityY = 0;
+			obj.angularVelocity = 0;
+			obj.visual.rotation = 0;
+			obj.rotation = 0;
+		}
+	}
+	// Update UI
+	playButton.visible = true;
+	pauseButton.visible = false;
+	editButton.visible = false;
+	objectPanel.visible = true;
+	propertiesPanel.visible = true;
+	eraser.visible = true;
+}
+// Clear all objects except ground
+function clearAll() {
+	for (var i = physicsObjects.length - 1; i >= 0; i--) {
+		var obj = physicsObjects[i];
+		if (obj !== ground) {
+			game.removeChild(obj);
+			physicsObjects.splice(i, 1);
+		}
+	}
+	LK.getSound('delete').play();
+}
+// Create UI elements
+function createUI() {
+	// Create button to start simulation
+	var playButton = new UIButton("Play", 150, 80, 0x28a745);
+	playButton.x = 2048 - 100;
+	playButton.y = 100;
+	playButton.onPress = startSimulation;
+	LK.gui.addChild(playButton);
+	// Create button to pause simulation
+	var pauseButton = new UIButton("Pause", 150, 80, 0xffc107);
+	pauseButton.x = 2048 - 100;
+	pauseButton.y = 100;
+	pauseButton.visible = false;
+	pauseButton.onPress = pauseSimulation;
+	LK.gui.addChild(pauseButton);
+	// Create button to return to edit mode
+	var editButton = new UIButton("Edit", 150, 80, 0x4d90ff);
+	editButton.x = 2048 - 100;
+	editButton.y = 200;
+	editButton.visible = false;
+	editButton.onPress = switchToEditMode;
+	LK.gui.addChild(editButton);
+	// Create button to clear all objects
+	var clearButton = new UIButton("Clear", 150, 80, 0xdc3545);
+	clearButton.x = 2048 - 100;
+	clearButton.y = 300;
+	clearButton.onPress = clearAll;
+	LK.gui.addChild(clearButton);
+	// Create object panel for selecting object types
+	var objectPanel = new Container();
+	LK.gui.addChild(objectPanel);
+	// Title for object panel
+	var objectTitle = new Text2("Objects", {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	objectTitle.anchor.set(0.5, 0);
+	objectTitle.x = 100;
+	objectTitle.y = 50;
+	objectPanel.addChild(objectTitle);
+	// Create object selection buttons
+	var blockButton = new UIButton("Block", 130, 70, 0x4d90ff);
+	blockButton.x = 100;
+	blockButton.y = 120;
+	blockButton.onPress = function () {
+		selectedObjectType = 'block';
+		updateButtonSelection();
+	};
+	objectPanel.addChild(blockButton);
+	var circleButton = new UIButton("Circle", 130, 70, 0xf25c54);
+	circleButton.x = 100;
+	circleButton.y = 200;
+	circleButton.onPress = function () {
+		selectedObjectType = 'circle';
+		updateButtonSelection();
+	};
+	objectPanel.addChild(circleButton);
+	var triangleButton = new UIButton("Triangle", 130, 70, 0x70ae6e);
+	triangleButton.x = 100;
+	triangleButton.y = 280;
+	triangleButton.onPress = function () {
+		selectedObjectType = 'triangle';
+		updateButtonSelection();
+	};
+	objectPanel.addChild(triangleButton);
+	// Eraser button as a special tool
+	var eraser = new PhysicsObject('eraser');
+	eraser.x = 100;
+	eraser.y = 360;
+	eraser.visual.tint = 0xff0000;
+	eraser.down = function (x, y, obj) {
+		// Don't allow dragging the eraser
+	};
+	var eraserText = new Text2("Eraser", {
+		size: 25,
+		fill: 0xFFFFFF
+	});
+	eraserText.anchor.set(0.5, 0);
+	eraserText.x = 100;
+	eraserText.y = 400;
+	objectPanel.addChild(eraser);
+	objectPanel.addChild(eraserText);
+	// Create properties panel
+	var propertiesPanel = new Container();
+	LK.gui.addChild(propertiesPanel);
+	// Title for properties panel
+	var propsTitle = new Text2("Properties", {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	propsTitle.anchor.set(0.5, 0);
+	propsTitle.x = 100;
+	propsTitle.y = 470;
+	propertiesPanel.addChild(propsTitle);
+	// Mass property buttons
+	var massLabel = new Text2("Mass:", {
+		size: 25,
+		fill: 0xFFFFFF
+	});
+	massLabel.anchor.set(0, 0.5);
+	massLabel.x = 40;
+	massLabel.y = 520;
+	propertiesPanel.addChild(massLabel);
+	var massDecBtn = new UIButton("-", 40, 40, 0x6c757d);
+	massDecBtn.x = 120;
+	massDecBtn.y = 520;
+	massDecBtn.onPress = function () {
+		if (selectedProperties.mass > 0.5) {
+			selectedProperties.mass -= 0.5;
+			updatePropertiesDisplay();
+		}
+	};
+	propertiesPanel.addChild(massDecBtn);
+	var massIncBtn = new UIButton("+", 40, 40, 0x6c757d);
+	massIncBtn.x = 180;
+	massIncBtn.y = 520;
+	massIncBtn.onPress = function () {
+		if (selectedProperties.mass < 3) {
+			selectedProperties.mass += 0.5;
+			updatePropertiesDisplay();
+		}
+	};
+	propertiesPanel.addChild(massIncBtn);
+	// Bounce property buttons
+	var bounceLabel = new Text2("Bounce:", {
+		size: 25,
+		fill: 0xFFFFFF
+	});
+	bounceLabel.anchor.set(0, 0.5);
+	bounceLabel.x = 40;
+	bounceLabel.y = 580;
+	propertiesPanel.addChild(bounceLabel);
+	var bounceDecBtn = new UIButton("-", 40, 40, 0x6c757d);
+	bounceDecBtn.x = 120;
+	bounceDecBtn.y = 580;
+	bounceDecBtn.onPress = function () {
+		if (selectedProperties.restitution > 0.1) {
+			selectedProperties.restitution -= 0.1;
+			updatePropertiesDisplay();
+		}
+	};
+	propertiesPanel.addChild(bounceDecBtn);
+	var bounceIncBtn = new UIButton("+", 40, 40, 0x6c757d);
+	bounceIncBtn.x = 180;
+	bounceIncBtn.y = 580;
+	bounceIncBtn.onPress = function () {
+		if (selectedProperties.restitution < 0.9) {
+			selectedProperties.restitution += 0.1;
+			updatePropertiesDisplay();
+		}
+	};
+	propertiesPanel.addChild(bounceIncBtn);
+	// Static toggle button
+	var staticButton = new UIButton("Static: OFF", 140, 60, 0x6c757d);
+	staticButton.x = 100;
+	staticButton.y = 640;
+	staticButton.onPress = function () {
+		selectedProperties.isStatic = !selectedProperties.isStatic;
+		updatePropertiesDisplay();
+	};
+	propertiesPanel.addChild(staticButton);
+	// Create property value displays
+	var massValue = new Text2(selectedProperties.mass.toFixed(1), {
+		size: 25,
+		fill: 0xFFFFFF
+	});
+	massValue.anchor.set(0.5, 0.5);
+	massValue.x = 150;
+	massValue.y = 520;
+	propertiesPanel.addChild(massValue);
+	var bounceValue = new Text2(selectedProperties.restitution.toFixed(1), {
+		size: 25,
+		fill: 0xFFFFFF
+	});
+	bounceValue.anchor.set(0.5, 0.5);
+	bounceValue.x = 150;
+	bounceValue.y = 580;
+	propertiesPanel.addChild(bounceValue);
+	// Add instructions
+	var instructions = new Text2("Tap to create objects\nDrag to move them", {
+		size: 30,
+		fill: 0xFFFFFF
+	});
+	instructions.anchor.set(0.5, 0);
+	instructions.x = 2048 / 2;
+	instructions.y = 50;
+	LK.gui.addChild(instructions);
+	// Store references to buttons that need to be toggled
+	this.playButton = playButton;
+	this.pauseButton = pauseButton;
+	this.editButton = editButton;
+	this.objectPanel = objectPanel;
+	this.propertiesPanel = propertiesPanel;
+	this.blockButton = blockButton;
+	this.circleButton = circleButton;
+	this.triangleButton = triangleButton;
+	this.staticButton = staticButton;
+	this.massValue = massValue;
+	this.bounceValue = bounceValue;
+	this.eraser = eraser;
+	// Initialize highlighting for the selected button
+	updateButtonSelection();
+	updatePropertiesDisplay();
+}
+// Update button selection highlighting
+function updateButtonSelection() {
+	blockButton.children[0].tint = selectedObjectType === 'block' ? 0x0066cc : 0x4d90ff;
+	circleButton.children[0].tint = selectedObjectType === 'circle' ? 0xd32f2f : 0xf25c54;
+	triangleButton.children[0].tint = selectedObjectType === 'triangle' ? 0x388e3c : 0x70ae6e;
+}
+// Update properties display
+function updatePropertiesDisplay() {
+	massValue.setText(selectedProperties.mass.toFixed(1));
+	bounceValue.setText(selectedProperties.restitution.toFixed(1));
+	staticButton.children[1].setText("Static: " + (selectedProperties.isStatic ? "ON" : "OFF"));
+	staticButton.children[0].tint = selectedProperties.isStatic ? 0x28a745 : 0x6c757d;
+}
+// Helper function to darken a color
+function darkenColor(color, percent) {
+	var r = color >> 16 & 0xFF;
+	var g = color >> 8 & 0xFF;
+	var b = color & 0xFF;
+	r = Math.floor(r * (1 - percent));
+	g = Math.floor(g * (1 - percent));
+	b = Math.floor(b * (1 - percent));
+	return r << 16 | g << 8 | b;
+}
+// Helper function to lighten a color
+function lightenColor(color, percent) {
+	var r = color >> 16 & 0xFF;
+	var g = color >> 8 & 0xFF;
+	var b = color & 0xFF;
+	r = Math.floor(r + (255 - r) * percent);
+	g = Math.floor(g + (255 - g) * percent);
+	b = Math.floor(b + (255 - b) * percent);
+	return r << 16 | g << 8 | b;
+}
+// Check for eraser collisions
+game.update = function () {
+	if (isSimulating) {
+		updatePhysics();
+	} else if (currentMode === 'edit') {
+		// Check for eraser collision with physics objects
+		for (var i = physicsObjects.length - 1; i >= 0; i--) {
+			var obj = physicsObjects[i];
+			if (obj !== ground && eraser.intersects(obj)) {
+				game.removeChild(obj);
+				physicsObjects.splice(i, 1);
+				LK.getSound('delete').play();
+			}
+		}
+	}
+};
+// Play background music
+LK.playMusic('bgmusic');
\ No newline at end of file