robloxstudio-mcp 2.2.8 → 2.4.0

package/studio-plugin/src/modules/handlers/BuildHandlers.ts

@@ -0,0 +1,476 @@
+import Utils from "../Utils";
+import Recording from "../Recording";
+
+const MaterialService = game.GetService("MaterialService");
+
+const { getInstancePath, getInstanceByPath } = Utils;
+const { beginRecording, finishRecording } = Recording;
+
+// Material name lookup table
+const MATERIAL_NAMES: Record<string, Enum.Material> = {
+	Plastic: Enum.Material.Plastic,
+	Wood: Enum.Material.Wood,
+	WoodPlanks: Enum.Material.WoodPlanks,
+	Slate: Enum.Material.Slate,
+	Concrete: Enum.Material.Concrete,
+	CorrodedMetal: Enum.Material.CorrodedMetal,
+	DiamondPlate: Enum.Material.DiamondPlate,
+	Foil: Enum.Material.Foil,
+	Grass: Enum.Material.Grass,
+	Ice: Enum.Material.Ice,
+	Marble: Enum.Material.Marble,
+	Granite: Enum.Material.Granite,
+	Brick: Enum.Material.Brick,
+	Pebble: Enum.Material.Pebble,
+	Sand: Enum.Material.Sand,
+	Fabric: Enum.Material.Fabric,
+	SmoothPlastic: Enum.Material.SmoothPlastic,
+	Metal: Enum.Material.Metal,
+	Neon: Enum.Material.Neon,
+	Glass: Enum.Material.Glass,
+	Cobblestone: Enum.Material.Cobblestone,
+};
+
+// Shape class mapping
+const SHAPE_CLASSES: Record<string, string> = {
+	Block: "Part",
+	Wedge: "WedgePart",
+	Cylinder: "Part",
+	Ball: "Part",
+	CornerWedge: "CornerWedgePart",
+};
+
+const PALETTE_KEYS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+function roundTo(n: number, decimals: number): number {
+	const mult = 10 ** decimals;
+	return math.round(n * mult) / mult;
+}
+
+function exportBuild(requestData: Record<string, unknown>) {
+	const instancePath = requestData.instancePath as string;
+	const outputId = requestData.outputId as string;
+	const style = (requestData.style as string) ?? "misc";
+
+	if (!instancePath) {
+		return { error: "Instance path is required" };
+	}
+
+	const instance = getInstanceByPath(instancePath);
+	if (!instance) return { error: `Instance not found: ${instancePath}` };
+
+	if (!instance.IsA("Model") && !instance.IsA("Folder")) {
+		return { error: "Instance must be a Model or Folder" };
+	}
+
+	const [success, result] = pcall(() => {
+		const descendants = instance.GetDescendants();
+		const baseParts: BasePart[] = [];
+		for (const desc of descendants) {
+			if (desc.IsA("BasePart")) {
+				baseParts.push(desc);
+			}
+		}
+
+		if (baseParts.size() === 0) {
+			return { error: "No BaseParts found in instance" };
+		}
+
+		// Compute bounding box center
+		let minX = math.huge;
+		let minY = math.huge;
+		let minZ = math.huge;
+		let maxX = -math.huge;
+		let maxY = -math.huge;
+		let maxZ = -math.huge;
+
+		for (const part of baseParts) {
+			const pos = part.Position;
+			const sz = part.Size;
+			const halfX = sz.X / 2;
+			const halfY = sz.Y / 2;
+			const halfZ = sz.Z / 2;
+			minX = math.min(minX, pos.X - halfX);
+			minY = math.min(minY, pos.Y - halfY);
+			minZ = math.min(minZ, pos.Z - halfZ);
+			maxX = math.max(maxX, pos.X + halfX);
+			maxY = math.max(maxY, pos.Y + halfY);
+			maxZ = math.max(maxZ, pos.Z + halfZ);
+		}
+
+		const centerX = (minX + maxX) / 2;
+		const centerY = minY; // Use bottom as Y origin
+		const centerZ = (minZ + maxZ) / 2;
+		const boundsX = roundTo(maxX - minX, 1);
+		const boundsY = roundTo(maxY - minY, 1);
+		const boundsZ = roundTo(maxZ - minZ, 1);
+
+		// Build palette from unique (BrickColor, Material, MaterialVariant?) combos
+		const paletteMap = new Map<string, string>();
+		const palette: Record<string, [string, string] | [string, string, string]> = {};
+		let keyIndex = 0;
+
+		for (const part of baseParts) {
+			const colorName = part.BrickColor.Name;
+			const materialName = part.Material.Name;
+			const variantName = part.MaterialVariant;
+			const combo = variantName !== "" ? `${colorName}|${materialName}|${variantName}` : `${colorName}|${materialName}`;
+
+			if (!paletteMap.has(combo)) {
+				const key = PALETTE_KEYS.sub(keyIndex + 1, keyIndex + 1);
+				keyIndex++;
+				paletteMap.set(combo, key);
+				if (variantName !== "") {
+					palette[key] = [colorName, materialName, variantName];
+				} else {
+					palette[key] = [colorName, materialName];
+				}
+			}
+		}
+
+		// Build compact part arrays
+		const parts: unknown[][] = [];
+		for (const part of baseParts) {
+			const pos = part.Position;
+			const orient = part.Orientation;
+			const sz = part.Size;
+			const colorName = part.BrickColor.Name;
+			const materialName = part.Material.Name;
+			const combo = `${colorName}|${materialName}`;
+			const paletteKey = paletteMap.get(combo) ?? "a";
+
+			// Relative position to center
+			const relX = roundTo(pos.X - centerX, 1);
+			const relY = roundTo(pos.Y - centerY, 1);
+			const relZ = roundTo(pos.Z - centerZ, 1);
+			const sizeX = roundTo(sz.X, 1);
+			const sizeY = roundTo(sz.Y, 1);
+			const sizeZ = roundTo(sz.Z, 1);
+			const rotX = roundTo(orient.X, 1);
+			const rotY = roundTo(orient.Y, 1);
+			const rotZ = roundTo(orient.Z, 1);
+
+			// Determine shape
+			let shape = "Block";
+			if (part.IsA("WedgePart")) {
+				shape = "Wedge";
+			} else if (part.IsA("CornerWedgePart")) {
+				shape = "CornerWedge";
+			} else if (part.IsA("Part")) {
+				const p = part as Part;
+				if (p.Shape === Enum.PartType.Cylinder) {
+					shape = "Cylinder";
+				} else if (p.Shape === Enum.PartType.Ball) {
+					shape = "Ball";
+				}
+			}
+
+			// Build part array with optional trailing fields
+			const hasTransparency = part.Transparency > 0;
+			const hasShape = shape !== "Block";
+
+			let partArr: defined[];
+			if (hasTransparency) {
+				partArr = [relX, relY, relZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey, hasShape ? shape : "Block", roundTo(part.Transparency, 2)];
+			} else if (hasShape) {
+				partArr = [relX, relY, relZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey, shape];
+			} else {
+				partArr = [relX, relY, relZ, sizeX, sizeY, sizeZ, rotX, rotY, rotZ, paletteKey];
+			}
+
+			parts.push(partArr);
+		}
+
+		const buildId = outputId ?? `${style}/${instance.Name.lower().gsub(" ", "_")[0]}`;
+
+		return {
+			success: true,
+			buildData: {
+				id: buildId,
+				style: style,
+				bounds: [boundsX, boundsY, boundsZ],
+				palette: palette,
+				parts: parts,
+			},
+		};
+	});
+
+	if (success && result) {
+		return result;
+	} else {
+		return { error: `Failed to export build: ${result}` };
+	}
+}
+
+function importBuild(requestData: Record<string, unknown>) {
+	const buildData = requestData.buildData as Record<string, unknown>;
+	const targetPath = requestData.targetPath as string;
+	const positionOffset = (requestData.position as number[]) ?? [0, 0, 0];
+
+	if (!buildData || !targetPath) {
+		return { error: "buildData and targetPath are required" };
+	}
+
+	const parentInstance = getInstanceByPath(targetPath);
+	if (!parentInstance) return { error: `Target not found: ${targetPath}` };
+	const recordingId = beginRecording("Import build");
+
+	const [success, result] = pcall(() => {
+		const palette = buildData.palette as Record<string, [string, string, string?]>;
+		const parts = buildData.parts as unknown[][];
+		const buildId = (buildData.id as string) ?? "imported_build";
+
+		// Create model container
+		const model = new Instance("Model");
+		model.Name = buildId.match("[^/]+$")[0] as string ?? buildId;
+
+		let partCount = 0;
+
+		for (const partArr of parts) {
+			const posX = (partArr[0] as number) + (positionOffset[0] ?? 0);
+			const posY = (partArr[1] as number) + (positionOffset[1] ?? 0);
+			const posZ = (partArr[2] as number) + (positionOffset[2] ?? 0);
+			const sizeX = partArr[3] as number;
+			const sizeY = partArr[4] as number;
+			const sizeZ = partArr[5] as number;
+			const rotX = partArr[6] as number;
+			const rotY = partArr[7] as number;
+			const rotZ = partArr[8] as number;
+			const paletteKey = partArr[9] as string;
+			const shape = (partArr[10] as string) ?? "Block";
+			const transparency = (partArr[11] as number) ?? 0;
+
+			// Determine class from shape
+			const className = SHAPE_CLASSES[shape] ?? "Part";
+			const part = new Instance(className as keyof CreatableInstances) as BasePart;
+
+			// Set shape for Part instances with non-Block shapes
+			if (className === "Part" && shape !== "Block") {
+				if (shape === "Cylinder") {
+					(part as Part).Shape = Enum.PartType.Cylinder;
+				} else if (shape === "Ball") {
+					(part as Part).Shape = Enum.PartType.Ball;
+				}
+			}
+
+			part.Size = new Vector3(sizeX, sizeY, sizeZ);
+			part.Position = new Vector3(posX, posY, posZ);
+			part.Orientation = new Vector3(rotX, rotY, rotZ);
+			part.Anchored = true;
+
+			if (transparency > 0) {
+				part.Transparency = transparency;
+			}
+
+			// Apply palette
+			const paletteEntry = palette[paletteKey];
+			if (paletteEntry) {
+				const [colorName, materialName, variantName] = paletteEntry;
+				pcall(() => {
+					part.BrickColor = new BrickColor(colorName as unknown as number);
+				});
+				pcall(() => {
+					const mat = MATERIAL_NAMES[materialName];
+					if (mat) {
+						part.Material = mat;
+					}
+				});
+				// Apply MaterialVariant if specified
+				if (variantName !== undefined && variantName !== "") {
+					pcall(() => {
+						part.MaterialVariant = variantName;
+					});
+				}
+			}
+
+			part.Parent = model;
+			partCount++;
+		}
+
+		model.Parent = parentInstance;
+
+		return {
+			success: true,
+			partCount: partCount,
+			modelPath: getInstancePath(model),
+		};
+	});
+
+	if (success && result) {
+		finishRecording(recordingId, true);
+		return result;
+	} else {
+		finishRecording(recordingId, false);
+		return { error: `Failed to import build: ${result}` };
+	}
+}
+
+function importScene(requestData: Record<string, unknown>) {
+	const expandedBuilds = requestData.expandedBuilds as Record<string, unknown>[];
+	const targetPath = (requestData.targetPath as string) ?? "game.Workspace";
+
+	if (!expandedBuilds || !typeIs(expandedBuilds, "table") || (expandedBuilds as defined[]).size() === 0) {
+		return { error: "expandedBuilds array is required" };
+	}
+
+	const parentInstance = getInstanceByPath(targetPath);
+	if (!parentInstance) return { error: `Target not found: ${targetPath}` };
+	const recordingId = beginRecording("Import scene");
+
+	const [success, result] = pcall(() => {
+		let modelCount = 0;
+		let totalParts = 0;
+		const models: Record<string, unknown>[] = [];
+
+		for (const entry of expandedBuilds) {
+			const buildData = entry.buildData as Record<string, unknown>;
+			const position = (entry.position as number[]) ?? [0, 0, 0];
+			const rotation = (entry.rotation as number[]) ?? [0, 0, 0];
+			const name = (entry.name as string) ?? "SceneModel";
+
+			const palette = buildData.palette as Record<string, [string, string, string?]>;
+			const parts = buildData.parts as unknown[][];
+
+			const model = new Instance("Model");
+			model.Name = name;
+
+			const rotCF = CFrame.Angles(
+				math.rad(rotation[0] ?? 0),
+				math.rad(rotation[1] ?? 0),
+				math.rad(rotation[2] ?? 0),
+			);
+			const originCF = new CFrame(position[0] ?? 0, position[1] ?? 0, position[2] ?? 0).mul(rotCF);
+
+			let partCount = 0;
+
+			for (const partArr of parts) {
+				const localX = partArr[0] as number;
+				const localY = partArr[1] as number;
+				const localZ = partArr[2] as number;
+				const sizeX = partArr[3] as number;
+				const sizeY = partArr[4] as number;
+				const sizeZ = partArr[5] as number;
+				const rotX = partArr[6] as number;
+				const rotY = partArr[7] as number;
+				const rotZ = partArr[8] as number;
+				const paletteKey = partArr[9] as string;
+				const shape = (partArr[10] as string) ?? "Block";
+				const transparency = (partArr[11] as number) ?? 0;
+
+				const className = SHAPE_CLASSES[shape] ?? "Part";
+				const part = new Instance(className as keyof CreatableInstances) as BasePart;
+
+				if (className === "Part" && shape !== "Block") {
+					if (shape === "Cylinder") {
+						(part as Part).Shape = Enum.PartType.Cylinder;
+					} else if (shape === "Ball") {
+						(part as Part).Shape = Enum.PartType.Ball;
+					}
+				}
+
+				part.Size = new Vector3(sizeX, sizeY, sizeZ);
+
+				// Apply local rotation then world transform
+				const localRotCF = CFrame.Angles(math.rad(rotX), math.rad(rotY), math.rad(rotZ));
+				const localPosCF = new CFrame(localX, localY, localZ).mul(localRotCF);
+				const worldCF = originCF.mul(localPosCF);
+
+				part.CFrame = worldCF;
+				part.Anchored = true;
+
+				if (transparency > 0) {
+					part.Transparency = transparency;
+				}
+
+				const paletteEntry = palette[paletteKey];
+				if (paletteEntry) {
+					const [colorName, materialName, variantName] = paletteEntry;
+					pcall(() => {
+						part.BrickColor = new BrickColor(colorName as unknown as number);
+					});
+					pcall(() => {
+						const mat = MATERIAL_NAMES[materialName];
+						if (mat) {
+							part.Material = mat;
+						}
+					});
+					if (variantName !== undefined && variantName !== "") {
+						pcall(() => {
+							part.MaterialVariant = variantName;
+						});
+					}
+				}
+
+				part.Parent = model;
+				partCount++;
+			}
+
+			model.Parent = parentInstance;
+			modelCount++;
+			totalParts += partCount;
+			models.push({
+				name: name,
+				partCount: partCount,
+				modelPath: getInstancePath(model),
+			});
+		}
+
+		return {
+			success: true,
+			modelCount: modelCount,
+			totalParts: totalParts,
+			models: models,
+		};
+	});
+
+	if (success && result) {
+		finishRecording(recordingId, true);
+		return result;
+	} else {
+		finishRecording(recordingId, false);
+		return { error: `Failed to import scene: ${result}` };
+	}
+}
+
+function searchMaterials(requestData: Record<string, unknown>) {
+	const query = ((requestData.query as string) ?? "").lower();
+	const maxResults = (requestData.maxResults as number) ?? 50;
+
+	const [success, result] = pcall(() => {
+		const children = MaterialService.GetChildren();
+		const materials: Record<string, unknown>[] = [];
+
+		for (const child of children) {
+			if (!child.IsA("MaterialVariant")) continue;
+
+			const nameMatch = query === "" || child.Name.lower().find(query)[0] !== undefined;
+			if (!nameMatch) continue;
+
+			materials.push({
+				name: child.Name,
+				baseMaterial: child.BaseMaterial.Name,
+			});
+
+			if (materials.size() >= maxResults) break;
+		}
+
+		return {
+			success: true,
+			materials: materials,
+			total: materials.size(),
+		};
+	});
+
+	if (success && result) {
+		return result;
+	} else {
+		return { error: `Failed to search materials: ${result}` };
+	}
+}
+
+export = {
+	exportBuild,
+	importBuild,
+	importScene,
+	searchMaterials,
+};

package/studio-plugin/{ts-src → src}/modules/handlers/InstanceHandlers.ts

@@ -1,8 +1,8 @@
 import Utils from "../Utils";
-
-const ChangeHistoryService = game.GetService("ChangeHistoryService");
+import Recording from "../Recording";
 
 const { getInstancePath, getInstanceByPath, convertPropertyValue } = Utils;
+const { beginRecording, finishRecording } = Recording;
 
 function createObject(requestData: Record<string, unknown>) {
 	const className = requestData.className as string;
@@ -16,6 +16,7 @@ function createObject(requestData: Record<string, unknown>) {
 
 	const parentInstance = getInstanceByPath(parentPath);
 	if (!parentInstance) return { error: `Parent instance not found: ${parentPath}` };
+	const recordingId = beginRecording(`Create ${className}`);
 
 	const [success, newInstance] = pcall(() => {
 		const instance = new Instance(className as keyof CreatableInstances);
@@ -28,11 +29,11 @@ function createObject(requestData: Record<string, unknown>) {
 		}
 
 		instance.Parent = parentInstance;
-		ChangeHistoryService.SetWaypoint(`Create ${className}`);
 		return instance;
 	});
 
 	if (success && newInstance) {
+		finishRecording(recordingId, true);
 		return {
 			success: true,
 			className,
@@ -42,6 +43,7 @@ function createObject(requestData: Record<string, unknown>) {
 			message: "Object created successfully",
 		};
 	} else {
+		finishRecording(recordingId, false);
 		return { error: `Failed to create object: ${newInstance}`, className, parent: parentPath };
 	}
 }
@@ -53,18 +55,18 @@ function deleteObject(requestData: Record<string, unknown>) {
 	const instance = getInstanceByPath(instancePath);
 	if (!instance) return { error: `Instance not found: ${instancePath}` };
 	if (instance === game) return { error: "Cannot delete the game instance" };
+	const recordingId = beginRecording(`Delete ${instance.ClassName} (${instance.Name})`);
 
 	const [success, result] = pcall(() => {
-		const name = instance.Name;
-		const className = instance.ClassName;
 		instance.Destroy();
-		ChangeHistoryService.SetWaypoint(`Delete ${className} (${name})`);
 		return true;
 	});
 
 	if (success) {
+		finishRecording(recordingId, true);
 		return { success: true, instancePath, message: "Object deleted successfully" };
 	} else {
+		finishRecording(recordingId, false);
 		return { error: `Failed to delete object: ${result}`, instancePath };
 	}
 }
@@ -78,6 +80,7 @@ function massCreateObjects(requestData: Record<string, unknown>) {
 	const results: Record<string, unknown>[] = [];
 	let successCount = 0;
 	let failureCount = 0;
+	const recordingId = beginRecording("Mass create objects");
 
 	for (const objData of objects) {
 		const className = objData.className as string;
@@ -115,7 +118,7 @@ function massCreateObjects(requestData: Record<string, unknown>) {
 		}
 	}
 
-	if (successCount > 0) ChangeHistoryService.SetWaypoint("Mass create objects");
+	finishRecording(recordingId, successCount > 0);
 	return { results, summary: { total: (objects as defined[]).size(), succeeded: successCount, failed: failureCount } };
 }
 
@@ -128,6 +131,7 @@ function massCreateObjectsWithProperties(requestData: Record<string, unknown>) {
 	const results: Record<string, unknown>[] = [];
 	let successCount = 0;
 	let failureCount = 0;
+	const recordingId = beginRecording("Mass create objects with properties");
 
 	for (const objData of objects) {
 		const className = objData.className as string;
@@ -175,11 +179,11 @@ function massCreateObjectsWithProperties(requestData: Record<string, unknown>) {
 		}
 	}
 
-	if (successCount > 0) ChangeHistoryService.SetWaypoint("Mass create objects with properties");
+	finishRecording(recordingId, successCount > 0);
 	return { results, summary: { total: (objects as defined[]).size(), succeeded: successCount, failed: failureCount } };
 }
 
-function smartDuplicate(requestData: Record<string, unknown>) {
+function performSmartDuplicate(requestData: Record<string, unknown>, useRecording = true) {
 	const instancePath = requestData.instancePath as string;
 	const count = requestData.count as number;
 	const options = (requestData.options as Record<string, unknown>) ?? {};
@@ -190,6 +194,7 @@ function smartDuplicate(requestData: Record<string, unknown>) {
 
 	const instance = getInstanceByPath(instancePath);
 	if (!instance) return { error: `Instance not found: ${instancePath}` };
+	const recordingId = useRecording ? beginRecording(`Smart duplicate ${instance.Name}`) : undefined;
 
 	const results: Record<string, unknown>[] = [];
 	let successCount = 0;
@@ -270,9 +275,7 @@ function smartDuplicate(requestData: Record<string, unknown>) {
 		}
 	}
 
-	if (successCount > 0) {
-		ChangeHistoryService.SetWaypoint(`Smart duplicate ${instance.Name} (${successCount} copies)`);
-	}
+	finishRecording(recordingId, successCount > 0);
 
 	return {
 		results,
@@ -281,6 +284,10 @@ function smartDuplicate(requestData: Record<string, unknown>) {
 	};
 }
 
+function smartDuplicate(requestData: Record<string, unknown>) {
+	return performSmartDuplicate(requestData, true);
+}
+
 function massDuplicate(requestData: Record<string, unknown>) {
 	const duplications = requestData.duplications as Record<string, unknown>[];
 	if (!duplications || !typeIs(duplications, "table") || (duplications as defined[]).size() === 0) {
@@ -290,9 +297,10 @@ function massDuplicate(requestData: Record<string, unknown>) {
 	const allResults: Record<string, unknown>[] = [];
 	let totalSuccess = 0;
 	let totalFailures = 0;
+	const recordingId = beginRecording("Mass duplicate operations");
 
 	for (const duplication of duplications) {
-		const result = smartDuplicate(duplication) as { summary?: { succeeded: number; failed: number } };
+		const result = performSmartDuplicate(duplication, false) as { summary?: { succeeded: number; failed: number } };
 		allResults.push(result as unknown as Record<string, unknown>);
 		if (result.summary) {
 			totalSuccess += result.summary.succeeded;
@@ -300,9 +308,7 @@ function massDuplicate(requestData: Record<string, unknown>) {
 		}
 	}
 
-	if (totalSuccess > 0) {
-		ChangeHistoryService.SetWaypoint(`Mass duplicate operations (${totalSuccess} objects)`);
-	}
+	finishRecording(recordingId, totalSuccess > 0);
 
 	return {
 		results: allResults,