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

/**** 
* Classes
****/ 
var ControlPanel = Container.expand(function () {
	var self = Container.call(this);
	// Size controls
	self.sizeUpBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 0
	});
	self.sizeDownBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 60
	});
	// Color controls
	self.colorBtn1 = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 120,
		tint: 0x32CD32
	});
	self.colorBtn2 = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 180,
		tint: 0xFF6B35
	});
	self.colorBtn3 = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 240,
		tint: 0x9B59B6
	});
	// Leaf count controls
	self.leafUpBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 300
	});
	self.leafDownBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 360
	});
	// Lamp color controls
	self.lampGreenBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 420,
		tint: 0x32cd32
	});
	self.lampYellowBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 480,
		tint: 0xffd700
	});
	self.lampPurpleBtn = self.attachAsset('controlButton', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: 540,
		tint: 0x9932cc
	});
	self.onSizeUp = null;
	self.onSizeDown = null;
	self.onColorChange = null;
	self.onLeafUp = null;
	self.onLeafDown = null;
	self.onLampColorChange = null;
	self.sizeUpBtn.down = function () {
		if (self.onSizeUp) self.onSizeUp();
	};
	self.sizeDownBtn.down = function () {
		if (self.onSizeDown) self.onSizeDown();
	};
	self.colorBtn1.down = function () {
		if (self.onColorChange) self.onColorChange(0x32CD32);
	};
	self.colorBtn2.down = function () {
		if (self.onColorChange) self.onColorChange(0xFF6B35);
	};
	self.colorBtn3.down = function () {
		if (self.onColorChange) self.onColorChange(0x9B59B6);
	};
	self.leafUpBtn.down = function () {
		if (self.onLeafUp) self.onLeafUp();
	};
	self.leafDownBtn.down = function () {
		if (self.onLeafDown) self.onLeafDown();
	};
	self.lampGreenBtn.down = function () {
		if (self.onLampColorChange) self.onLampColorChange(0x32cd32);
	};
	self.lampYellowBtn.down = function () {
		if (self.onLampColorChange) self.onLampColorChange(0xffd700);
	};
	self.lampPurpleBtn.down = function () {
		if (self.onLampColorChange) self.onLampColorChange(0x9932cc);
	};
	return self;
});
var LightSlider = Container.expand(function () {
	var self = Container.call(this);
	self.value = 0;
	self.isDragging = false;
	var track = self.attachAsset('sliderTrack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.handle = self.attachAsset('sliderHandle', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -180
	});
	self.lightBulb = self.attachAsset('lightBulb', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -220,
		y: 0
	});
	self.updateHandle = function () {
		self.handle.x = -180 + self.value * 360;
		// Update light bulb brightness based on value
		var brightness = 0.3 + self.value * 0.7;
		self.lightBulb.alpha = brightness;
		tween(self.lightBulb, {
			scaleX: 1 + self.value * 0.3,
			scaleY: 1 + self.value * 0.3
		}, {
			duration: 200
		});
	};
	self.setValue = function (value) {
		self.value = Math.max(0, Math.min(1, value));
		self.updateHandle();
	};
	self.down = function (x, y, obj) {
		self.isDragging = true;
		var localX = x + 180;
		self.setValue(localX / 360);
	};
	self.onValueChange = null;
	self.update = function () {
		if (self.isDragging && self.onValueChange) {
			self.onValueChange(self.value);
		}
	};
	return self;
});
var Plant = Container.expand(function (isAutomatic) {
	var self = Container.call(this);
	// Plant properties
	self.isAutomatic = isAutomatic || false;
	self.waterLevel = 0;
	self.lightLevel = 0;
	self.size = 1;
	self.leafColor = 0x32CD32;
	self.leafCount = 2;
	self.lampColor = 0xffd700; // Default yellow
	// Create plant components with shadow and realistic details
	self.potShadow = self.attachAsset('pot', {
		anchorX: 0.5,
		anchorY: 1,
		tint: 0x000000,
		alpha: 0.3,
		x: 5,
		y: 5
	});
	var pot = self.attachAsset('pot', {
		anchorX: 0.5,
		anchorY: 1,
		tint: 0xA0522D
	});
	var potRim = self.attachAsset('potRim', {
		anchorX: 0.5,
		anchorY: 1,
		y: -240,
		tint: 0x8B4513
	});
	var soil = self.attachAsset('soil', {
		anchorX: 0.5,
		anchorY: 1,
		y: -30,
		tint: 0x8B4513
	});
	self.stem = self.attachAsset('stem', {
		anchorX: 0.5,
		anchorY: 1,
		y: -100,
		tint: 0x228B22
	});
	self.leaves = [];
	// Add table lamp
	self.tableLamp = self.addChild(new TableLamp());
	self.tableLamp.x = -200;
	self.tableLamp.y = -100;
	self.createLeaves = function () {
		// Remove existing leaves
		for (var i = 0; i < self.leaves.length; i++) {
			self.leaves[i].destroy();
		}
		self.leaves = [];
		// Create new leaves with proper botanical arrangement
		for (var i = 0; i < self.leafCount; i++) {
			var leaf = self.attachAsset('leaf', {
				anchorX: 0.5,
				anchorY: 0.8,
				tint: self.leafColor || 0x228B22
			});
			// Create proper leaf arrangement with spiral phyllotaxis pattern
			var side = i % 2 === 0 ? 1 : -1;
			var leafIndex = Math.floor(i / 2); // Pair leaves at each node
			var height = leafIndex * 40 + 60; // Proper vertical spacing between nodes
			var baseOffset = 25; // Base horizontal distance from stem
			var heightVariation = i * 5; // Slight height variation for realism
			// Alternate leaves on opposite sides of the stem at each node
			if (i % 2 === 0) {
				leaf.x = baseOffset + Math.random() * 5; // Right side with small variation
			} else {
				leaf.x = -baseOffset - Math.random() * 5; // Left side with small variation
			}
			leaf.y = -height - heightVariation;
			// Set natural leaf angles - leaves point slightly upward and outward
			leaf.rotation = side * (Math.PI / 12 + Math.random() * Math.PI / 24);
			// Vary leaf sizes naturally - upper leaves tend to be smaller
			var sizeFactor = Math.max(0.6, 1.0 - leafIndex * 0.1);
			leaf.scaleX = sizeFactor * (0.9 + Math.random() * 0.2);
			leaf.scaleY = sizeFactor * (0.9 + Math.random() * 0.2);
			// Store original position data for carrying with plant transformations
			leaf.baseX = leaf.x; // Store base horizontal offset from stem
			leaf.baseY = leaf.y; // Store base vertical offset from stem base
			leaf.leafIndex = leafIndex; // Store which node pair this leaf belongs to
			leaf.nodeHeight = height; // Store the node height for proper scaling
			leaf.baseRotation = leaf.rotation; // Store original rotation for animations
			self.leaves.push(leaf);
		}
	};
	self.createLeaves();
	self.updatePlant = function () {
		if (self.isAutomatic) {
			// Growth based on proportional water and light levels - if either is 0, no growth
			var growthFactor = self.waterLevel * self.lightLevel;
			var targetSize = 0.3;
			// Determine size based on lamp color
			if (self.lampColor === 0x32cd32) {
				// Green
				targetSize = 0.5 + growthFactor * 0.8; // Small
				self.tableLamp.setLampColor(0x32cd32);
			} else if (self.lampColor === 0xffd700) {
				// Yellow
				targetSize = 0.8 + growthFactor * 1.2; // Medium
				self.tableLamp.setLampColor(0xffd700);
			} else if (self.lampColor === 0x9932cc) {
				// Purple
				targetSize = 1.2 + growthFactor * 1.5; // Large
				self.tableLamp.setLampColor(0x9932cc);
			}
			// Smooth transition to new size with tween
			tween(self, {
				size: targetSize
			}, {
				duration: 500,
				easing: tween.easeOut
			});
		}
		self.stem.scaleY = self.size;
		self.stem.scaleX = Math.max(0.5, self.size * 0.8);
		for (var i = 0; i < self.leaves.length; i++) {
			var leaf = self.leaves[i];
			// Maintain proper leaf sizing based on plant growth
			var sizeFactor = Math.max(0.6, 1.0 - leaf.leafIndex * 0.1);
			leaf.scaleX = self.size * sizeFactor * (0.9 + Math.random() * 0.2);
			leaf.scaleY = self.size * sizeFactor * (0.9 + Math.random() * 0.2);
			leaf.tint = self.leafColor;
			// Properly carry leaves with plant - maintain relative positioning to stem
			// Scale the leaf position based on plant size while keeping botanical arrangement
			var stemScaleY = Math.max(0.5, self.size * 0.8);
			leaf.x = leaf.baseX * self.size; // Horizontal scaling with plant size
			leaf.y = leaf.baseY * stemScaleY; // Vertical scaling matches stem growth
			// Ensure leaves stay attached to stem at proper node positions
			var nodeHeight = Math.floor(i / 2) * 40 * stemScaleY; // Scale node spacing
			var heightVariation = i * 5 * self.size; // Scale height variation
			leaf.y = -nodeHeight - 60 * stemScaleY - heightVariation;
			// Add subtle leaf sway animation that respects the natural position
			var baseRotation = leaf.rotation;
			tween(leaf, {
				rotation: baseRotation + (Math.random() - 0.5) * 0.15
			}, {
				duration: 1500 + Math.random() * 1000,
				easing: tween.easeInOut,
				onFinish: function onFinish() {
					// Return to base rotation
					tween(leaf, {
						rotation: baseRotation
					}, {
						duration: 1500 + Math.random() * 1000,
						easing: tween.easeInOut
					});
				}
			});
		}
	};
	self.setWaterLevel = function (level) {
		self.waterLevel = Math.max(0, Math.min(1, level));
		self.updatePlant();
	};
	self.setLightLevel = function (level) {
		self.lightLevel = Math.max(0, Math.min(1, level));
		self.updatePlant();
	};
	self.setSize = function (size) {
		if (!self.isAutomatic) {
			self.size = Math.max(0.3, Math.min(3, size));
			self.updatePlant();
		}
	};
	self.setLeafColor = function (color) {
		if (!self.isAutomatic) {
			self.leafColor = color;
			self.updatePlant();
		}
	};
	self.setLeafCount = function (count) {
		if (!self.isAutomatic) {
			self.leafCount = Math.max(1, Math.min(8, count));
			self.createLeaves();
			self.updatePlant();
		}
	};
	self.setLampColor = function (color) {
		self.lampColor = color;
		if (self.tableLamp) {
			self.tableLamp.setLampColor(color);
		}
		self.updatePlant();
	};
	return self;
});
var TableLamp = Container.expand(function () {
	var self = Container.call(this);
	// Create realistic lamp components
	self.base = self.attachAsset('lampBase', {
		anchorX: 0.5,
		anchorY: 1
	});
	self.lamp = self.attachAsset('tableLamp', {
		anchorX: 0.5,
		anchorY: 1,
		y: -40
	});
	// Add light glow effect
	self.lightGlow = LK.getAsset('lightBulb', {
		anchorX: 0.5,
		anchorY: 0.5,
		y: -80,
		alpha: 0.3,
		scaleX: 1.5,
		scaleY: 1.5
	});
	self.addChild(self.lightGlow);
	self.setLampColor = function (color) {
		tween(self.lamp, {
			tint: color
		}, {
			duration: 500,
			easing: tween.easeOut
		});
		// Also tint the glow effect
		tween(self.lightGlow, {
			tint: color,
			alpha: 0.4
		}, {
			duration: 500,
			easing: tween.easeOut
		});
	};
	return self;
});
var WaterSlider = Container.expand(function () {
	var self = Container.call(this);
	self.value = 0;
	self.isDragging = false;
	var track = self.attachAsset('sliderTrack', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.handle = self.attachAsset('sliderHandle', {
		anchorX: 0.5,
		anchorY: 0.5,
		x: -180
	});
	self.updateHandle = function () {
		self.handle.x = -180 + self.value * 360;
	};
	self.setValue = function (value) {
		self.value = Math.max(0, Math.min(1, value));
		self.updateHandle();
	};
	self.down = function (x, y, obj) {
		self.isDragging = true;
		var localX = x + 180;
		self.setValue(localX / 360);
	};
	self.onValueChange = null;
	self.update = function () {
		if (self.isDragging && self.onValueChange) {
			self.onValueChange(self.value);
		}
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x87CEEB
});

/**** 
* Game Code
****/ 
// No laws button found to remove - the code remains unchanged
var automaticPlant = new Plant(true);
automaticPlant.x = 600;
automaticPlant.y = 1800;
game.addChild(automaticPlant);
var controlledPlant = new Plant(false);
controlledPlant.x = 1400;
controlledPlant.y = 1800;
// Set second plant to maximum size with optimal conditions
controlledPlant.setWaterLevel(1.0); // Maximum water
controlledPlant.setLightLevel(1.0); // Maximum light
controlledPlant.setSize(3.0); // Set to largest possible size
game.addChild(controlledPlant);
// Create water slider
var waterSlider = new WaterSlider();
waterSlider.x = 1024;
waterSlider.y = 2200;
game.addChild(waterSlider);
// Create light slider
var lightSlider = new LightSlider();
lightSlider.x = 1024;
lightSlider.y = 2450;
game.addChild(lightSlider);
// Create control panel for second plant
var controlPanel = new ControlPanel();
controlPanel.x = 1750;
controlPanel.y = 1200;
game.addChild(controlPanel);
// Create labels
var titleText = new Text2('Plant Growth Experiment', {
	size: 80,
	fill: 0x2C3E50
});
titleText.anchor.set(0.5, 0);
titleText.x = 1024;
titleText.y = 100;
game.addChild(titleText);
var autoLabel = new Text2('Automatic Plant', {
	size: 50,
	fill: 0x27AE60
});
autoLabel.anchor.set(0.5, 0);
autoLabel.x = 600;
autoLabel.y = 1850;
game.addChild(autoLabel);
var controlLabel = new Text2('Controlled Plant', {
	size: 50,
	fill: 0xE67E22
});
controlLabel.anchor.set(0.5, 0);
controlLabel.x = 1400;
controlLabel.y = 1850;
game.addChild(controlLabel);
var waterLabel = new Text2('Water Level', {
	size: 40,
	fill: 0x34495E
});
waterLabel.anchor.set(0.5, 0);
waterLabel.x = 1024;
waterLabel.y = 2300;
game.addChild(waterLabel);
var lightLabel = new Text2('Light Level', {
	size: 40,
	fill: 0x34495E
});
lightLabel.anchor.set(0.5, 0);
lightLabel.x = 1024;
lightLabel.y = 2550;
game.addChild(lightLabel);
var controlsLabel = new Text2('Controls', {
	size: 40,
	fill: 0x34495E
});
controlsLabel.anchor.set(0.5, 0);
controlsLabel.x = 1750;
controlsLabel.y = 1000;
game.addChild(controlsLabel);
// Button labels
var sizeUpLabel = new Text2('+Size', {
	size: 25,
	fill: 0xFFFFFF
});
sizeUpLabel.anchor.set(0.5, 0.5);
sizeUpLabel.x = 1750;
sizeUpLabel.y = 1200;
game.addChild(sizeUpLabel);
var sizeDownLabel = new Text2('-Size', {
	size: 25,
	fill: 0xFFFFFF
});
sizeDownLabel.anchor.set(0.5, 0.5);
sizeDownLabel.x = 1750;
sizeDownLabel.y = 1260;
game.addChild(sizeDownLabel);
var leafUpLabel = new Text2('+Leaves', {
	size: 20,
	fill: 0xFFFFFF
});
leafUpLabel.anchor.set(0.5, 0.5);
leafUpLabel.x = 1750;
leafUpLabel.y = 1500;
game.addChild(leafUpLabel);
var leafDownLabel = new Text2('-Leaves', {
	size: 20,
	fill: 0xFFFFFF
});
leafDownLabel.anchor.set(0.5, 0.5);
leafDownLabel.x = 1750;
leafDownLabel.y = 1560;
game.addChild(leafDownLabel);
var lampGreenLabel = new Text2('Green', {
	size: 18,
	fill: 0xFFFFFF
});
lampGreenLabel.anchor.set(0.5, 0.5);
lampGreenLabel.x = 1750;
lampGreenLabel.y = 1620;
game.addChild(lampGreenLabel);
var lampYellowLabel = new Text2('Yellow', {
	size: 18,
	fill: 0xFFFFFF
});
lampYellowLabel.anchor.set(0.5, 0.5);
lampYellowLabel.x = 1750;
lampYellowLabel.y = 1680;
game.addChild(lampYellowLabel);
var lampPurpleLabel = new Text2('Purple', {
	size: 18,
	fill: 0xFFFFFF
});
lampPurpleLabel.anchor.set(0.5, 0.5);
lampPurpleLabel.x = 1750;
lampPurpleLabel.y = 1740;
game.addChild(lampPurpleLabel);
// Water level display
var waterLevelText = new Text2('100%', {
	size: 60,
	fill: 0x2980B9
});
waterLevelText.anchor.set(0.5, 0);
waterLevelText.x = 1024;
waterLevelText.y = 2350;
game.addChild(waterLevelText);
// Light level display
var lightLevelText = new Text2('100%', {
	size: 60,
	fill: 0xFFD700
});
lightLevelText.anchor.set(0.5, 0);
lightLevelText.x = 1024;
lightLevelText.y = 2600;
game.addChild(lightLevelText);
// Initialize sliders to maximum position
waterSlider.setValue(1.0);
lightSlider.setValue(1.0);
// Set initial plant states to maximum
automaticPlant.setWaterLevel(1.0);
automaticPlant.setLightLevel(1.0);
automaticPlant.setLampColor(0x32cd32); // Start with green lamp for small size
controlledPlant.setLampColor(0x9932cc); // Set controlled plant lamp to purple
// Variables for tracking
var dragNode = null;
var currentWaterLevel = 1.0; // Start with maximum water
var currentLightLevel = 1.0; // Start with maximum light
// Event handlers
waterSlider.onValueChange = function (value) {
	currentWaterLevel = value;
	automaticPlant.setWaterLevel(value);
	controlledPlant.setWaterLevel(value);
	waterLevelText.setText(Math.round(value * 100) + '%');
};
lightSlider.onValueChange = function (value) {
	currentLightLevel = value;
	automaticPlant.setLightLevel(value);
	controlledPlant.setLightLevel(value);
	lightLevelText.setText(Math.round(value * 100) + '%');
};
controlPanel.onSizeUp = function () {
	controlledPlant.setSize(controlledPlant.size + 0.2);
};
controlPanel.onSizeDown = function () {
	controlledPlant.setSize(controlledPlant.size - 0.2);
};
controlPanel.onColorChange = function (color) {
	controlledPlant.setLeafColor(color);
};
controlPanel.onLeafUp = function () {
	controlledPlant.setLeafCount(controlledPlant.leafCount + 1);
};
controlPanel.onLeafDown = function () {
	controlledPlant.setLeafCount(controlledPlant.leafCount - 1);
};
controlPanel.onLampColorChange = function (color) {
	automaticPlant.setLampColor(color);
};
// Game move handler for slider dragging
game.move = function (x, y, obj) {
	if (waterSlider.isDragging) {
		var localPos = waterSlider.toLocal({
			x: x,
			y: y
		});
		var newValue = (localPos.x + 180) / 360;
		waterSlider.setValue(newValue);
		waterSlider.onValueChange(waterSlider.value);
	}
	if (lightSlider.isDragging) {
		var localPos = lightSlider.toLocal({
			x: x,
			y: y
		});
		var newValue = (localPos.x + 180) / 360;
		lightSlider.setValue(newValue);
		lightSlider.onValueChange(lightSlider.value);
	}
};
game.up = function (x, y, obj) {
	waterSlider.isDragging = false;
	lightSlider.isDragging = false;
};
// Create some water drops for visual effect
var waterDrops = [];
var dropTimer = 0;
game.update = function () {
	dropTimer++;
	// Create water drops periodically if water level > 0
	if (currentWaterLevel > 0 && dropTimer % 60 == 0) {
		for (var i = 0; i < 3; i++) {
			var drop = LK.getAsset('waterDrop', {
				anchorX: 0.5,
				anchorY: 0.5,
				x: 800 + Math.random() * 500,
				y: 400 + Math.random() * 200
			});
			drop.speedY = 2 + Math.random() * 3;
			drop.alpha = 0.7;
			waterDrops.push(drop);
			game.addChild(drop);
			// Fade and animate the drop
			tween(drop, {
				y: drop.y + 200,
				alpha: 0
			}, {
				duration: 2000,
				onFinish: function onFinish() {
					drop.destroy();
				}
			});
		}
		// Clean up old drops
		for (var j = waterDrops.length - 1; j >= 0; j--) {
			if (waterDrops[j].alpha <= 0) {
				waterDrops.splice(j, 1);
			}
		}
	}
};

===================================================================
--- original.js
+++ change.js
@@ -232,12 +232,14 @@
 			// Vary leaf sizes naturally - upper leaves tend to be smaller
 			var sizeFactor = Math.max(0.6, 1.0 - leafIndex * 0.1);
 			leaf.scaleX = sizeFactor * (0.9 + Math.random() * 0.2);
 			leaf.scaleY = sizeFactor * (0.9 + Math.random() * 0.2);
-			// Store original position data for growth animations
-			leaf.baseX = leaf.x;
-			leaf.baseY = leaf.y;
-			leaf.leafIndex = leafIndex;
+			// Store original position data for carrying with plant transformations
+			leaf.baseX = leaf.x; // Store base horizontal offset from stem
+			leaf.baseY = leaf.y; // Store base vertical offset from stem base
+			leaf.leafIndex = leafIndex; // Store which node pair this leaf belongs to
+			leaf.nodeHeight = height; // Store the node height for proper scaling
+			leaf.baseRotation = leaf.rotation; // Store original rotation for animations
 			self.leaves.push(leaf);
 		}
 	};
 	self.createLeaves();
@@ -276,11 +278,17 @@
 			var sizeFactor = Math.max(0.6, 1.0 - leaf.leafIndex * 0.1);
 			leaf.scaleX = self.size * sizeFactor * (0.9 + Math.random() * 0.2);
 			leaf.scaleY = self.size * sizeFactor * (0.9 + Math.random() * 0.2);
 			leaf.tint = self.leafColor;
-			// Maintain proper leaf positioning during growth
-			leaf.x = leaf.baseX * self.size;
-			leaf.y = leaf.baseY * self.size;
+			// Properly carry leaves with plant - maintain relative positioning to stem
+			// Scale the leaf position based on plant size while keeping botanical arrangement
+			var stemScaleY = Math.max(0.5, self.size * 0.8);
+			leaf.x = leaf.baseX * self.size; // Horizontal scaling with plant size
+			leaf.y = leaf.baseY * stemScaleY; // Vertical scaling matches stem growth
+			// Ensure leaves stay attached to stem at proper node positions
+			var nodeHeight = Math.floor(i / 2) * 40 * stemScaleY; // Scale node spacing
+			var heightVariation = i * 5 * self.size; // Scale height variation
+			leaf.y = -nodeHeight - 60 * stemScaleY - heightVariation;
 			// Add subtle leaf sway animation that respects the natural position
 			var baseRotation = leaf.rotation;
 			tween(leaf, {
 				rotation: baseRotation + (Math.random() - 0.5) * 0.15