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

/**** 
* Classes
****/ 
var DataPacket = Container.expand(function () {
	var self = Container.call(this);
	// Color constants
	var COLORS = [0x3498db, 0xe74c3c, 0xf39c12, 0x2ecc71, 0x9b59b6];
	var COLOR_NAMES = ['blue', 'red', 'orange', 'green', 'purple'];
	// Properties
	self.colorIndex = 0;
	self.colorName = '';
	self.isBeingDragged = false;
	self.lastX = 0;
	self.lastY = 0;
	self.lastWasIntersecting = false;
	self.matchedNode = null;
	// Create packet graphic
	var packetGraphic = self.attachAsset('dataPacket', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set random color
	self.setRandomColor = function () {
		self.colorIndex = Math.floor(Math.random() * COLORS.length);
		self.colorName = COLOR_NAMES[self.colorIndex];
		packetGraphic.tint = COLORS[self.colorIndex];
	};
	// Down event for dragging
	self.down = function (x, y, obj) {
		self.isBeingDragged = true;
		// Bring to front
		if (self.parent) {
			self.parent.removeChild(self);
			self.parent.addChild(self);
		}
	};
	// Update method called every tick
	self.update = function () {
		// Track position for intersection detection
		self.lastX = self.x;
		self.lastY = self.y;
	};
	// Initialize with random color
	self.setRandomColor();
	return self;
});
var ErrorBlock = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.lifespan = 10 * 60; // 10 seconds at 60fps
	// Create block graphic
	var blockGraphic = self.attachAsset('errorBlock', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Update method
	self.update = function () {
		self.lifespan--;
		// Fade out near end of lifespan
		if (self.lifespan < 60) {
			self.alpha = self.lifespan / 60;
		}
		// Rotate slowly
		self.rotation += 0.01;
	};
	return self;
});
var PowerUp = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.type = 'slowTime'; // Default type
	self.isBeingDragged = false;
	self.lastX = 0;
	self.lastY = 0;
	self.lastWasIntersecting = false;
	// Create power-up graphic
	var powerUpGraphic = self.attachAsset('powerUp', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Power-up types and their colors
	var TYPES = ['slowTime', 'clearPath', 'stabilityBoost'];
	var TYPE_COLORS = [0xf39c12, 0x9b59b6, 0x3498db];
	// Set type
	self.setType = function (typeIndex) {
		self.type = TYPES[typeIndex];
		powerUpGraphic.tint = TYPE_COLORS[typeIndex];
	};
	// Down event for dragging
	self.down = function (x, y, obj) {
		self.isBeingDragged = true;
		// Bring to front
		if (self.parent) {
			self.parent.removeChild(self);
			self.parent.addChild(self);
		}
	};
	// Update method
	self.update = function () {
		// Pulse effect
		var pulseAmount = Math.sin(LK.ticks * 0.1) * 0.1 + 1;
		self.scale.set(pulseAmount, pulseAmount);
		// Track position
		self.lastX = self.x;
		self.lastY = self.y;
	};
	// Set random type
	self.setType(Math.floor(Math.random() * TYPES.length));
	return self;
});
var SemibotPlayer = Container.expand(function () {
	var self = Container.call(this);
	// Bot properties
	self.active = true;
	self.intelligence = 0.7; // 0-1 scale of bot intelligence
	self.lastActionTime = 0;
	self.actionDelay = 60; // Frames between actions
	self.target = null;
	// Toggle bot activity
	self.toggle = function () {
		self.active = !self.active;
		return self.active;
	};
	// Find optimal move - returns best packet and target node
	self.findOptimalMove = function () {
		if (!packets.length || !storageNodes.length) return null;
		// Only act if we have a good match
		var bestMatch = null;
		var highestScore = -1;
		for (var i = 0; i < packets.length; i++) {
			var packet = packets[i];
			// Skip packets being dragged by player
			if (packet.isBeingDragged) continue;
			for (var j = 0; j < storageNodes.length; j++) {
				var node = storageNodes[j];
				var score = 0;
				// Color match is most important
				if (packet.colorIndex === node.colorIndex) {
					score += 100;
					// Prioritize continuing chains
					if (lastSuccessfulChain === packet.colorIndex) {
						score += 50 * chainCount;
					}
					// Adjust for difficulty based on distance and position
					score -= Math.abs(packet.x - node.x) * 0.05;
					score -= packet.y * 0.1; // Prioritize packets farther down
					// Apply intelligence factor - sometimes make suboptimal choices
					if (Math.random() > self.intelligence) {
						score *= Math.random() * 0.5;
					}
					if (score > highestScore) {
						highestScore = score;
						bestMatch = {
							packet: packet,
							node: node
						};
					}
				}
			}
		}
		return bestMatch;
	};
	// Move a packet toward a node
	self.movePacketToNode = function (packet, node) {
		if (!packet || packet.isBeingDragged) return false;
		// Release current target if we have one
		if (self.target && self.target.isBeingDragged) {
			self.target.isBeingDragged = false;
		}
		// Set target packet as being dragged by bot
		self.target = packet;
		packet.isBeingDragged = true;
		// Move packet toward node with tweening for smooth movement
		tween(packet, {
			x: node.x,
			y: node.y - 20
		}, {
			duration: 500,
			easing: tween.easeOutQuad,
			onFinish: function onFinish() {
				// Release packet when it reaches the node
				packet.isBeingDragged = false;
				self.target = null;
				// Check for match at destination
				for (var i = 0; i < storageNodes.length; i++) {
					if (checkNodeMatch(packet, storageNodes[i])) {
						break;
					}
				}
			}
		});
		return true;
	};
	// Update method
	self.update = function () {
		if (!self.active || !gameRunning) return;
		// Only act periodically to allow player to also interact
		if (LK.ticks - self.lastActionTime < self.actionDelay) return;
		// Skip action randomly to make bot feel more human
		if (Math.random() > 0.8) return;
		// Check if we need to handle power-ups when stability is low
		if (stabilityBar.stability < 30 && powerUps.length > 0) {
			for (var i = 0; i < powerUps.length; i++) {
				var powerUp = powerUps[i];
				if (!powerUp.isBeingDragged && powerUp.y > 300) {
					// Move power-up to center to activate it
					tween(powerUp, {
						x: 2048 / 2,
						y: 2732 / 2
					}, {
						duration: 300,
						easing: tween.easeOutQuad,
						onFinish: function onFinish() {
							activatePowerUp(powerUp);
							var index = powerUps.indexOf(powerUp);
							if (index !== -1) {
								powerUps.splice(index, 1);
							}
							powerUp.destroy();
						}
					});
					self.lastActionTime = LK.ticks;
					return;
				}
			}
		}
		// Find and execute optimal move
		var move = self.findOptimalMove();
		if (move) {
			self.movePacketToNode(move.packet, move.node);
			self.lastActionTime = LK.ticks;
		}
	};
	return self;
});
// Down event for dragging
var StabilityBar = Container.expand(function () {
	var self = Container.call(this);
	// Properties
	self.stability = 50; // Start at 50%
	self.maxStability = 100;
	self.warningLevel = 25;
	self.criticalLevel = 10;
	// Create background
	var barBg = self.attachAsset('stabilityBarBg', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Create bar
	var bar = self.attachAsset('stabilityBar', {
		anchorX: 0.5,
		anchorY: 1.0
	});
	// Position the bar
	bar.y = barBg.height / 2;
	// Set stability amount (0-100)
	self.setStability = function (amount) {
		self.stability = Math.max(0, Math.min(self.maxStability, amount));
		// Update bar height
		var heightPercentage = self.stability / self.maxStability;
		bar.scaleY = heightPercentage;
		// Update bar color based on stability
		if (self.stability <= self.criticalLevel) {
			bar.tint = 0xe74c3c; // Critical - red
		} else if (self.stability <= self.warningLevel) {
			bar.tint = 0xf39c12; // Warning - orange
		} else {
			bar.tint = 0x27ae60; // Normal - green
		}
	};
	// Change stability
	self.changeStability = function (delta) {
		self.setStability(self.stability + delta);
		return self.stability;
	};
	// Initialize
	self.setStability(self.stability);
	return self;
});
// Game variables
var StorageNode = Container.expand(function () {
	var self = Container.call(this);
	// Color constants
	var COLORS = [0x3498db, 0xe74c3c, 0xf39c12, 0x2ecc71, 0x9b59b6];
	var COLOR_NAMES = ['blue', 'red', 'orange', 'green', 'purple'];
	// Properties
	self.colorIndex = 0;
	self.colorName = '';
	self.lastPacketsStored = 0;
	self.packetsStored = 0;
	// Create node graphic
	var nodeGraphic = self.attachAsset('storageNode', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Set color
	self.setColor = function (index) {
		self.colorIndex = index;
		self.colorName = COLOR_NAMES[index];
		nodeGraphic.tint = COLORS[index];
	};
	// Handle packet storage
	self.storePacket = function () {
		self.packetsStored++;
		// Visual feedback
		tween(self, {
			scaleX: 1.2,
			scaleY: 1.2
		}, {
			duration: 200,
			onFinish: function onFinish() {
				tween(self, {
					scaleX: 1,
					scaleY: 1
				}, {
					duration: 200
				});
			}
		});
	};
	// Update method
	self.update = function () {
		self.lastPacketsStored = self.packetsStored;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game variables
// Game assets
// Tween library for animations
var packetSpawnInterval = 3 * 60; // Spawn every 3 seconds at 60fps
var nextPacketSpawn = packetSpawnInterval;
var stabilityDecayRate = 0.05; // Stability decay per tick
var packets = [];
var storageNodes = [];
var errorBlocks = [];
var powerUps = [];
var level = 1;
var score = 0;
var stabilityBar;
var scoreText;
var levelText;
var botStatusText;
var draggedObject = null;
var gameRunning = true;
var lastSuccessfulChain = 0;
var chainCount = 0;
var semibot; // AI assistant player
// UI text setup
scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0xFFFFFF
});
scoreText.anchor.set(0, 0);
scoreText.x = 50;
scoreText.y = 50;
LK.gui.topLeft.addChild(scoreText);
levelText = new Text2('Level: 1', {
	size: 60,
	fill: 0xFFFFFF
});
levelText.anchor.set(1, 0);
levelText.x = -50;
levelText.y = 50;
LK.gui.topRight.addChild(levelText);
// Bot status text
botStatusText = new Text2('Bot: Active', {
	size: 60,
	fill: 0x00FF00
});
botStatusText.anchor.set(0.5, 0);
botStatusText.x = 0;
botStatusText.y = 50;
LK.gui.top.addChild(botStatusText);
// Create toggle button
var toggleBotBtn = new Text2('Toggle Bot', {
	size: 60,
	fill: 0xFFFFFF
});
toggleBotBtn.anchor.set(0.5, 0);
toggleBotBtn.x = 0;
toggleBotBtn.y = 120;
toggleBotBtn.interactive = true;
toggleBotBtn.hitArea = new Rectangle(-150, 0, 300, 60);
// Toggle bot event
toggleBotBtn.down = function () {
	if (semibot) {
		var isActive = semibot.toggle();
		botStatusText.setText('Bot: ' + (isActive ? 'Active' : 'Paused'));
		botStatusText.style.fill = isActive ? 0x00FF00 : 0xFF0000;
	}
};
LK.gui.top.addChild(toggleBotBtn);
// Initialize stability bar
stabilityBar = new StabilityBar();
stabilityBar.x = 80;
stabilityBar.y = 2732 / 2;
game.addChild(stabilityBar);
// Create storage nodes
function createStorageNodes() {
	// Clear existing nodes
	storageNodes.forEach(function (node) {
		node.destroy();
	});
	storageNodes = [];
	var numNodes = Math.min(5, 2 + Math.floor(level / 2)); // Increase nodes with level
	var spacing = 2048 / (numNodes + 1);
	for (var i = 0; i < numNodes; i++) {
		var node = new StorageNode();
		node.setColor(i % 5);
		node.x = spacing * (i + 1);
		node.y = 2732 - 300;
		game.addChild(node);
		storageNodes.push(node);
	}
}
// Create a new data packet
function createDataPacket() {
	var packet = new DataPacket();
	packet.x = Math.random() * (2048 - 200) + 100;
	packet.y = -100;
	game.addChild(packet);
	packets.push(packet);
	// Random vertical speed based on level
	packet.speedY = 1 + Math.random() * level * 0.5;
	return packet;
}
// Create power-up
function createPowerUp() {
	var powerUp = new PowerUp();
	powerUp.x = Math.random() * (2048 - 200) + 100;
	powerUp.y = -100;
	game.addChild(powerUp);
	powerUps.push(powerUp);
	// Set vertical speed
	powerUp.speedY = 1 + Math.random() * 0.5;
	return powerUp;
}
// Create error block obstacle
function createErrorBlock(x, y) {
	var block = new ErrorBlock();
	block.x = x;
	block.y = y;
	game.addChild(block);
	errorBlocks.push(block);
	return block;
}
// Handle power-up effect
function activatePowerUp(powerUp) {
	LK.getSound('powerup').play();
	switch (powerUp.type) {
		case 'slowTime':
			// Slow down all packets
			packets.forEach(function (packet) {
				packet.speedY *= 0.5;
			});
			break;
		case 'clearPath':
			// Remove all error blocks
			errorBlocks.forEach(function (block) {
				block.destroy();
			});
			errorBlocks = [];
			break;
		case 'stabilityBoost':
			// Boost stability
			stabilityBar.changeStability(25);
			break;
	}
	// Visual feedback
	LK.effects.flashScreen(0xf39c12, 500);
}
// Check if a packet matches a storage node
function checkNodeMatch(packet, node) {
	if (packet.colorIndex === node.colorIndex && packet.intersects(node)) {
		// Match found
		LK.getSound('match').play();
		// Update score based on chain
		if (lastSuccessfulChain === packet.colorIndex) {
			chainCount++;
			score += 10 * chainCount;
		} else {
			chainCount = 1;
			score += 10;
		}
		lastSuccessfulChain = packet.colorIndex;
		// Update score display
		LK.setScore(score);
		scoreText.setText('Score: ' + score);
		// Increase stability
		stabilityBar.changeStability(5);
		// Visual feedback
		node.storePacket();
		// Remove packet
		var index = packets.indexOf(packet);
		if (index !== -1) {
			packets.splice(index, 1);
		}
		packet.destroy();
		// Level up check
		if (score >= level * 100) {
			levelUp();
		}
		return true;
	}
	return false;
}
// Handle level up
function levelUp() {
	level++;
	levelText.setText('Level: ' + level);
	// Increase difficulty
	packetSpawnInterval = Math.max(60, packetSpawnInterval - 15);
	stabilityDecayRate += 0.01;
	// Create new node layout
	createStorageNodes();
	// Visual feedback
	LK.effects.flashScreen(0x2ecc71, 500);
}
// Initialize semibot player
semibot = new SemibotPlayer();
game.addChild(semibot);
// Initialize game
createStorageNodes();
// Game touch/mouse events
game.down = function (x, y, obj) {
	// Check if we're clicking on a packet or power-up
	var foundObject = false;
	// Check packets first (in reverse to get top-most)
	for (var i = packets.length - 1; i >= 0; i--) {
		var packet = packets[i];
		if (packet.getBounds().contains(x, y)) {
			draggedObject = packet;
			packet.down(x, y, obj);
			foundObject = true;
			break;
		}
	}
	// Check power-ups if no packet was found
	if (!foundObject) {
		for (var i = powerUps.length - 1; i >= 0; i--) {
			var powerUp = powerUps[i];
			if (powerUp.getBounds().contains(x, y)) {
				draggedObject = powerUp;
				powerUp.down(x, y, obj);
				foundObject = true;
				break;
			}
		}
	}
};
game.move = function (x, y, obj) {
	if (draggedObject && draggedObject.isBeingDragged) {
		draggedObject.x = x;
		draggedObject.y = y;
	}
};
game.up = function (x, y, obj) {
	if (draggedObject) {
		// Check for matches with storage nodes
		if (draggedObject instanceof DataPacket) {
			var matched = false;
			for (var i = 0; i < storageNodes.length; i++) {
				if (checkNodeMatch(draggedObject, storageNodes[i])) {
					matched = true;
					break;
				}
			}
			// Create error block if no match
			if (!matched) {
				LK.getSound('error').play();
				createErrorBlock(draggedObject.x, draggedObject.y);
				stabilityBar.changeStability(-10);
				// Remove the mismatched packet
				var index = packets.indexOf(draggedObject);
				if (index !== -1) {
					packets.splice(index, 1);
				}
				draggedObject.destroy();
			}
		}
		// Check if it's a power-up
		else if (draggedObject instanceof PowerUp) {
			activatePowerUp(draggedObject);
			// Remove the used power-up
			var index = powerUps.indexOf(draggedObject);
			if (index !== -1) {
				powerUps.splice(index, 1);
			}
			draggedObject.destroy();
		}
		draggedObject = null;
	}
};
// Main game update loop
game.update = function () {
	if (!gameRunning) return;
	// Update semibot if active
	if (semibot) {
		semibot.update();
	}
	// Update all game objects
	for (var i = packets.length - 1; i >= 0; i--) {
		var packet = packets[i];
		packet.update();
		// Move non-dragged packets down
		if (!packet.isBeingDragged) {
			packet.y += packet.speedY;
		}
		// Check if packet is out of bounds
		if (packet.y > 2732 + 100) {
			// Missed packet - penalty
			stabilityBar.changeStability(-15);
			LK.getSound('error').play();
			// Remove packet
			packets.splice(i, 1);
			packet.destroy();
			continue;
		}
	}
	// Update power-ups
	for (var i = powerUps.length - 1; i >= 0; i--) {
		var powerUp = powerUps[i];
		powerUp.update();
		// Move non-dragged power-ups down
		if (!powerUp.isBeingDragged) {
			powerUp.y += powerUp.speedY;
		}
		// Remove if out of bounds
		if (powerUp.y > 2732 + 100) {
			powerUps.splice(i, 1);
			powerUp.destroy();
		}
	}
	// Update error blocks
	for (var i = errorBlocks.length - 1; i >= 0; i--) {
		var block = errorBlocks[i];
		block.update();
		// Remove expired blocks
		if (block.lifespan <= 0) {
			errorBlocks.splice(i, 1);
			block.destroy();
		}
	}
	// Update storage nodes
	for (var i = 0; i < storageNodes.length; i++) {
		storageNodes[i].update();
	}
	// Spawn new packets
	nextPacketSpawn--;
	if (nextPacketSpawn <= 0) {
		createDataPacket();
		nextPacketSpawn = packetSpawnInterval;
		// Occasionally spawn power-ups (5% chance)
		if (Math.random() < 0.05) {
			createPowerUp();
		}
	}
	// Decrease stability over time
	stabilityBar.changeStability(-stabilityDecayRate);
	// Warning when stability is low
	if (stabilityBar.stability <= stabilityBar.warningLevel && LK.ticks % 60 === 0) {
		LK.getSound('warning').play();
	}
	// Check for game over
	if (stabilityBar.stability <= 0) {
		gameRunning = false;
		LK.effects.flashScreen(0xe74c3c, 1000);
		LK.showGameOver();
	}
};
// Set background color to dark blue/grey for tech theme
game.setBackgroundColor(0x2c3e50);

===================================================================
--- original.js
+++ change.js
@@ -112,8 +112,134 @@
 	// Set random type
 	self.setType(Math.floor(Math.random() * TYPES.length));
 	return self;
 });
+var SemibotPlayer = Container.expand(function () {
+	var self = Container.call(this);
+	// Bot properties
+	self.active = true;
+	self.intelligence = 0.7; // 0-1 scale of bot intelligence
+	self.lastActionTime = 0;
+	self.actionDelay = 60; // Frames between actions
+	self.target = null;
+	// Toggle bot activity
+	self.toggle = function () {
+		self.active = !self.active;
+		return self.active;
+	};
+	// Find optimal move - returns best packet and target node
+	self.findOptimalMove = function () {
+		if (!packets.length || !storageNodes.length) return null;
+		// Only act if we have a good match
+		var bestMatch = null;
+		var highestScore = -1;
+		for (var i = 0; i < packets.length; i++) {
+			var packet = packets[i];
+			// Skip packets being dragged by player
+			if (packet.isBeingDragged) continue;
+			for (var j = 0; j < storageNodes.length; j++) {
+				var node = storageNodes[j];
+				var score = 0;
+				// Color match is most important
+				if (packet.colorIndex === node.colorIndex) {
+					score += 100;
+					// Prioritize continuing chains
+					if (lastSuccessfulChain === packet.colorIndex) {
+						score += 50 * chainCount;
+					}
+					// Adjust for difficulty based on distance and position
+					score -= Math.abs(packet.x - node.x) * 0.05;
+					score -= packet.y * 0.1; // Prioritize packets farther down
+					// Apply intelligence factor - sometimes make suboptimal choices
+					if (Math.random() > self.intelligence) {
+						score *= Math.random() * 0.5;
+					}
+					if (score > highestScore) {
+						highestScore = score;
+						bestMatch = {
+							packet: packet,
+							node: node
+						};
+					}
+				}
+			}
+		}
+		return bestMatch;
+	};
+	// Move a packet toward a node
+	self.movePacketToNode = function (packet, node) {
+		if (!packet || packet.isBeingDragged) return false;
+		// Release current target if we have one
+		if (self.target && self.target.isBeingDragged) {
+			self.target.isBeingDragged = false;
+		}
+		// Set target packet as being dragged by bot
+		self.target = packet;
+		packet.isBeingDragged = true;
+		// Move packet toward node with tweening for smooth movement
+		tween(packet, {
+			x: node.x,
+			y: node.y - 20
+		}, {
+			duration: 500,
+			easing: tween.easeOutQuad,
+			onFinish: function onFinish() {
+				// Release packet when it reaches the node
+				packet.isBeingDragged = false;
+				self.target = null;
+				// Check for match at destination
+				for (var i = 0; i < storageNodes.length; i++) {
+					if (checkNodeMatch(packet, storageNodes[i])) {
+						break;
+					}
+				}
+			}
+		});
+		return true;
+	};
+	// Update method
+	self.update = function () {
+		if (!self.active || !gameRunning) return;
+		// Only act periodically to allow player to also interact
+		if (LK.ticks - self.lastActionTime < self.actionDelay) return;
+		// Skip action randomly to make bot feel more human
+		if (Math.random() > 0.8) return;
+		// Check if we need to handle power-ups when stability is low
+		if (stabilityBar.stability < 30 && powerUps.length > 0) {
+			for (var i = 0; i < powerUps.length; i++) {
+				var powerUp = powerUps[i];
+				if (!powerUp.isBeingDragged && powerUp.y > 300) {
+					// Move power-up to center to activate it
+					tween(powerUp, {
+						x: 2048 / 2,
+						y: 2732 / 2
+					}, {
+						duration: 300,
+						easing: tween.easeOutQuad,
+						onFinish: function onFinish() {
+							activatePowerUp(powerUp);
+							var index = powerUps.indexOf(powerUp);
+							if (index !== -1) {
+								powerUps.splice(index, 1);
+							}
+							powerUp.destroy();
+						}
+					});
+					self.lastActionTime = LK.ticks;
+					return;
+				}
+			}
+		}
+		// Find and execute optimal move
+		var move = self.findOptimalMove();
+		if (move) {
+			self.movePacketToNode(move.packet, move.node);
+			self.lastActionTime = LK.ticks;
+		}
+	};
+	return self;
+});
+// Down event for dragging
 var StabilityBar = Container.expand(function () {
 	var self = Container.call(this);
 	// Properties
 	self.stability = 50; // Start at 50%
@@ -181,15 +307,19 @@
 	// Handle packet storage
 	self.storePacket = function () {
 		self.packetsStored++;
 		// Visual feedback
-		tween.to(self, 0.2, {
+		tween(self, {
 			scaleX: 1.2,
-			scaleY: 1.2,
-			onComplete: function onComplete() {
-				tween.to(self, 0.2, {
+			scaleY: 1.2
+		}, {
+			duration: 200,
+			onFinish: function onFinish() {
+				tween(self, {
 					scaleX: 1,
 					scaleY: 1
+				}, {
+					duration: 200
 				});
 			}
 		});
 	};
@@ -224,12 +354,14 @@
 var score = 0;
 var stabilityBar;
 var scoreText;
 var levelText;
+var botStatusText;
 var draggedObject = null;
 var gameRunning = true;
 var lastSuccessfulChain = 0;
 var chainCount = 0;
+var semibot; // AI assistant player
 // UI text setup
 scoreText = new Text2('Score: 0', {
 	size: 60,
 	fill: 0xFFFFFF
@@ -245,8 +377,36 @@
 levelText.anchor.set(1, 0);
 levelText.x = -50;
 levelText.y = 50;
 LK.gui.topRight.addChild(levelText);
+// Bot status text
+botStatusText = new Text2('Bot: Active', {
+	size: 60,
+	fill: 0x00FF00
+});
+botStatusText.anchor.set(0.5, 0);
+botStatusText.x = 0;
+botStatusText.y = 50;
+LK.gui.top.addChild(botStatusText);
+// Create toggle button
+var toggleBotBtn = new Text2('Toggle Bot', {
+	size: 60,
+	fill: 0xFFFFFF
+});
+toggleBotBtn.anchor.set(0.5, 0);
+toggleBotBtn.x = 0;
+toggleBotBtn.y = 120;
+toggleBotBtn.interactive = true;
+toggleBotBtn.hitArea = new Rectangle(-150, 0, 300, 60);
+// Toggle bot event
+toggleBotBtn.down = function () {
+	if (semibot) {
+		var isActive = semibot.toggle();
+		botStatusText.setText('Bot: ' + (isActive ? 'Active' : 'Paused'));
+		botStatusText.style.fill = isActive ? 0x00FF00 : 0xFF0000;
+	}
+};
+LK.gui.top.addChild(toggleBotBtn);
 // Initialize stability bar
 stabilityBar = new StabilityBar();
 stabilityBar.x = 80;
 stabilityBar.y = 2732 / 2;
@@ -371,8 +531,11 @@
 	createStorageNodes();
 	// Visual feedback
 	LK.effects.flashScreen(0x2ecc71, 500);
 }
+// Initialize semibot player
+semibot = new SemibotPlayer();
+game.addChild(semibot);
 // Initialize game
 createStorageNodes();
 // Game touch/mouse events
 game.down = function (x, y, obj) {
@@ -446,8 +609,12 @@
 };
 // Main game update loop
 game.update = function () {
 	if (!gameRunning) return;
+	// Update semibot if active
+	if (semibot) {
+		semibot.update();
+	}
 	// Update all game objects
 	for (var i = packets.length - 1; i >= 0; i--) {
 		var packet = packets[i];
 		packet.update();