/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var DraggableButton = Container.expand(function () {
	var self = Container.call(this);
	// Create visual representation
	var circleButton = self.attachAsset('circle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Add a label
	var label = new Text2("Create", {
		size: 24,
		fill: 0xFFFFFF
	});
	label.anchor.set(0.5, 0.5);
	self.addChild(label);
	// Track if we're currently creating an object
	self.isCreating = false;
	self.currentObject = null;
	// Handle touch/click down
	self.down = function (x, y, obj) {
		self.isCreating = true;
		// Create a new physics circle that follows the pointer
		self.currentObject = new PhysicsObject('circle', {
			mass: 1,
			restitution: 0.7,
			friction: 0.1
		});
		// Position at pointer
		self.currentObject.x = x;
		self.currentObject.y = y;
		// Add to game
		game.addChild(self.currentObject);
		// Visual feedback
		tween(circleButton, {
			alpha: 0.7,
			scaleX: 0.9,
			scaleY: 0.9
		}, {
			duration: 100
		});
	};
	// Handle movement
	self.move = function (x, y, obj) {
		if (self.isCreating && self.currentObject) {
			// Update the position to follow pointer
			self.currentObject.x = x;
			self.currentObject.y = y;
		}
	};
	// Handle release
	self.up = function (x, y, obj) {
		if (self.isCreating && self.currentObject) {
			// Add physics to the object
			physicsObjects.push(self.currentObject);
			// Set initial velocity based on recent movement
			if (chaosMode) {
				// More chaotic initial velocity in chaos mode
				self.currentObject.velocityX = Math.random() * 30 - 15;
				self.currentObject.velocityY = Math.random() * -20 - 5;
				self.currentObject.angularVelocity = Math.random() * 0.3 - 0.15;
				// Sometimes create multiple balls when in chaos mode
				if (Math.random() < 0.3) {
					for (var i = 0; i < 3; i++) {
						createPhysicsObject(x + Math.random() * 100 - 50, y + Math.random() * 100 - 50, 'circle', {
							mass: 0.5 + Math.random(),
							restitution: 0.8,
							friction: 0.05
						});
					}
				}
			} else {
				// Normal initial velocity
				self.currentObject.velocityX = Math.random() * 10 - 5;
				self.currentObject.velocityY = -10; // Initial upward velocity
			}
			// Reset state
			self.isCreating = false;
			self.currentObject = null;
			// Play sound
			LK.getSound('place').play();
		}
		// Visual feedback
		tween(circleButton, {
			alpha: 1,
			scaleX: 1,
			scaleY: 1
		}, {
			duration: 100
		});
	};
	return self;
});
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: 0x87CEEB // Sky blue background
});

/**** 
* Game Code
****/ 
// Physics constants
var GRAVITY = 0.5;
var DRAG = 0.02;
var GROUND_Y = 2500;
// Game state
var physicsObjects = [];
var isSimulating = true;
var currentMode = 'edit'; // Define currentMode variable
var isDragging = false;
var draggedObject = null;
var dragOffsetX = 0;
var dragOffsetY = 0;
// 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 a draggable button that creates physics objects
var circleCreator = new DraggableButton();
circleCreator.x = 200;
circleCreator.y = 200;
LK.gui.addChild(circleCreator);
// Create a title
var title = new Text2("Physics Playground", {
	size: 50,
	fill: 0xFFFFFF
});
title.anchor.set(0.5, 0);
title.x = 2048 / 2;
title.y = 50;
LK.gui.addChild(title);
// Instructions
var instructions = new Text2("Drag from the circle to create\nobjects that bounce with physics", {
	size: 30,
	fill: 0xFFFFFF
});
instructions.anchor.set(0.5, 0);
instructions.x = 2048 / 2;
instructions.y = 120;
LK.gui.addChild(instructions);
// Ball counter
var ballCountText = new Text2("Balls: 0", {
	size: 30,
	fill: 0xFFFFFF
});
ballCountText.anchor.set(0, 0);
ballCountText.x = 50;
ballCountText.y = 50;
LK.gui.addChild(ballCountText);
// Easter egg hint
var easterEggHint = new Text2("What happens at 100?", {
	size: 20,
	fill: 0xCCCCCC
});
easterEggHint.anchor.set(0, 0);
easterEggHint.x = 50;
easterEggHint.y = 90;
easterEggHint.alpha = 0.7;
LK.gui.addChild(easterEggHint);
// Game area doesn't need specific event handlers since
// the DraggableButton handles its own events
game.down = function (x, y, obj) {};
game.move = function (x, y, obj) {};
game.up = function (x, y, obj) {};
// Track total balls spawned and chaos mode
var totalBallsSpawned = 0;
var chaosMode = false;
// Update physics in the game loop
game.update = function () {
	if (isSimulating) {
		updatePhysics();
		// Chaos mode effects
		if (chaosMode) {
			// Make UI elements shake
			title.x = 2048 / 2 + Math.random() * 50 - 25;
			title.y = 50 + Math.random() * 30 - 15;
			title.rotation = Math.random() * 0.2 - 0.1;
			// Shake instructions
			instructions.x = 2048 / 2 + Math.random() * 40 - 20;
			instructions.y = 120 + Math.random() * 20 - 10;
			instructions.rotation = Math.random() * 0.15 - 0.075;
			// Shake clear button
			clearButton.x = 2048 - 100 + Math.random() * 30 - 15;
			clearButton.y = 300 + Math.random() * 30 - 15;
			// Add random velocity to physics objects
			if (Math.random() < 0.2) {
				for (var i = 0; i < physicsObjects.length; i++) {
					var obj = physicsObjects[i];
					if (!obj.isStatic) {
						obj.velocityX += Math.random() * 10 - 5;
						obj.velocityY += Math.random() * 10 - 5;
						obj.angularVelocity += Math.random() * 0.5 - 0.25;
					}
				}
			}
		}
	}
};
// Create a new physics object at specified position
function createPhysicsObject(x, y, type, properties) {
	var newObject = new PhysicsObject(type || 'circle', properties || {
		mass: 1,
		friction: 0.1,
		restitution: 0.7
	});
	newObject.x = x;
	newObject.y = y;
	game.addChild(newObject);
	physicsObjects.push(newObject);
	// Track ball count and trigger chaos mode at 100
	if (type === 'circle' || !type) {
		totalBallsSpawned++;
		// Show count
		if (ballCountText) {
			ballCountText.setText("Balls: " + totalBallsSpawned);
		}
		// Check for chaos threshold
		if (totalBallsSpawned >= 100 && !chaosMode) {
			chaosMode = true;
			// Flash screen
			LK.effects.flashScreen(0xFF0000, 500);
			// Create visual ball explosion
			for (var i = 0; i < 20; i++) {
				var angle = Math.random() * Math.PI * 2;
				var speed = 20 + Math.random() * 20;
				var ball = new PhysicsObject('circle', {
					mass: 0.5 + Math.random(),
					restitution: 0.9,
					friction: 0.05
				});
				ball.x = x;
				ball.y = y;
				ball.velocityX = Math.cos(angle) * speed;
				ball.velocityY = Math.sin(angle) * speed;
				ball.angularVelocity = Math.random() * 0.2 - 0.1;
				game.addChild(ball);
				physicsObjects.push(ball);
			}
		}
	}
	// 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;
			// In chaos mode, objects can sometimes teleport
			if (chaosMode && Math.random() < 0.01) {
				obj.x = Math.random() * 2048;
				obj.y = Math.random() * GROUND_Y * 0.7;
				obj.velocityX *= -1.5;
				obj.velocityY *= -1.5;
				obj.visual.alpha = 0.7;
				tween(obj.visual, {
					alpha: 1,
					scaleX: 1 + Math.random() * 0.5,
					scaleY: 1 + Math.random() * 0.5
				}, {
					duration: 300,
					easing: "easeOutElastic"
				});
			}
			// Update rotation with extra spin in chaos mode
			obj.rotation += obj.angularVelocity * (chaosMode && Math.random() < 0.1 ? 3 : 1);
			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();
			}
		}
	}
}
// 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();
}
// Add a clear button
var clearButton = new UIButton("Clear", 150, 80, 0xdc3545);
clearButton.x = 2048 - 100;
clearButton.y = 300;
clearButton.onPress = clearAll;
LK.gui.addChild(clearButton);
// 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 () {
	updatePhysics();
};
// Play background music
LK.playMusic('bgmusic');

===================================================================
--- original.js
+++ change.js
@@ -202,8 +202,13 @@
 var GROUND_Y = 2500;
 // Game state
 var physicsObjects = [];
 var isSimulating = true;
+var currentMode = 'edit'; // Define currentMode variable
+var isDragging = false;
+var draggedObject = null;
+var dragOffsetX = 0;
+var dragOffsetY = 0;
 // Create the ground
 var ground = new PhysicsObject('ground', {
 	isStatic: true
 });