studyup 0.0.0-stage → 1.0.0

package/sandboxels-package/sandboxels-1.13.2/mods/worldEdit.js

@@ -0,0 +1,441 @@
+"use strict";
+// WorldEdit.js (compiled)
+// Version: 1.2.0
+// Constants
+const w_accentColor = "#7cff62";
+const w_style = {
+	strokeWidth: 1,
+	selectFill: "#57b64530",
+	selectStroke: w_accentColor,
+	selectDash: true,
+	pasteFill: "#00FFFF40",
+	pasteStroke: "#00FFFF",
+	pastePixelColor: "#00FFFF44"
+};
+// Global variables
+let worldEditElements = {};
+let pastePreviewCanvas;
+let w_state = {
+	firstSelectionPos: {x: 0, y: 0},
+	selection: null,
+	clipboard: null,
+	lastNonWorldEditElement: "unknown"
+};
+// Define settings
+let w_settingsTab;
+let w_deselectOnResetSetting;
+dependOn("betterSettings.js", () => {
+	w_settingsTab = new SettingsTab("WorldEdit");
+	w_deselectOnResetSetting = new Setting("Deselect on reset", "deselectOnReset", settingType.BOOLEAN, false, true);
+	w_settingsTab.registerSettings("Selection", w_deselectOnResetSetting);
+	settingsManager.registerTab(w_settingsTab);
+}, true);
+
+// Classes
+class Rect {
+	constructor(x, y, w, h) {
+		this.x = x;
+		this.y = y;
+		this.w = w;
+		this.h = h;
+	}
+
+	static fromCorners(start, end) {
+		return new Rect(start.x, start.y, end.x - start.x, end.y - start.y);
+	}
+
+	static fromCornersXYXY(x, y, x2, y2) {
+		return new Rect(x, y, x2 - x, y2 - y);
+	}
+
+	static fromGrid(grid, origin = {x: 0, y: 0}) {
+		return new Rect(origin.x, origin.y, grid[0].length, grid.length);
+	}
+
+	get area() {
+		return this.w * this.h;
+	}
+
+	get x2() {
+		return this.x + this.w;
+	}
+
+	get y2() {
+		return this.y + this.h;
+	}
+
+	set x2(val) {
+		this.w = val - this.x;
+	}
+
+	set y2(val) {
+		this.h = val - this.y;
+	}
+
+	copy() {
+		return new Rect(this.x, this.y, this.w, this.h);
+	}
+
+	normalized() {
+		return Rect.fromCornersXYXY(Math.min(this.x, this.x2), Math.min(this.y, this.y2), Math.max(this.x, this.x2), Math.max(this.y, this.y2));
+	}
+}
+
+// Functions
+function reverseString(str) {
+	return [...str].reverse().join("");
+}
+
+function isPointInWorld(point) {
+	return point.x >= 0 && point.x <= width && point.y >= 0 && point.y <= height;
+}
+
+function limitPointToWorld(point) {
+	return {
+		x: Math.max(0, Math.min(point.x, width)),
+		y: Math.max(0, Math.min(point.y, height))
+	};
+}
+
+function mousePosToWorldPos(pos) {
+	const rect = canvas.getBoundingClientRect();
+	let x = pos.x - rect.left;
+	let y = pos.y - rect.top;
+	x = Math.floor((x / canvas.clientWidth) * (width + 1));
+	y = Math.floor((y / canvas.clientHeight) * (height + 1));
+	return {x: x, y: y};
+}
+
+function updatePastePreviewCanvas() {
+	const clipboard = w_state.clipboard;
+	if (!clipboard)
+		return;
+	const clipboardRect = Rect.fromGrid(clipboard);
+	// Create canvas
+	pastePreviewCanvas = new OffscreenCanvas(clipboardRect.w, clipboardRect.h);
+	const pastePreviewCtx = pastePreviewCanvas.getContext("2d");
+	const imageData = pastePreviewCtx.createImageData(clipboardRect.w, clipboardRect.h);
+	const buffer = new Uint32Array(imageData.data.buffer);
+	buffer.fill(0x00000000);
+	const pixelColorBinary = parseInt(reverseString(w_style.pastePixelColor.slice(1)), 16);
+	for (let y = 0; y < clipboardRect.h; y++) {
+		for (let x = 0; x < clipboardRect.w; x++) {
+			if (clipboard[y][x])
+				buffer[y * clipboardRect.w + x] = pixelColorBinary;
+		}
+	}
+	pastePreviewCtx.putImageData(imageData, 0, 0);
+}
+
+function renderSelection(ctx) {
+	const selection = w_state.selection;
+	if (!selection)
+		return;
+	const isSelecting = (mouseIsDown &&
+		(mouseType !== "middle" && mouseType !== "right") &&
+		currentElement === "w_select");
+	ctx.globalAlpha = 1.0;
+	// Fill
+	if (!isSelecting) {
+		ctx.fillStyle = w_style.selectFill;
+		ctx.fillRect(selection.x * pixelSize, selection.y * pixelSize, selection.w * pixelSize, selection.h * pixelSize);
+	}
+	// Dash if selection is big enough
+	if (w_style.selectDash && selection.w >= 2 && selection.h >= 2)
+		ctx.setLineDash([pixelSize, pixelSize]);
+	// Stroke
+	ctx.strokeStyle = w_style.selectStroke;
+	ctx.lineWidth = w_style.strokeWidth;
+	ctx.strokeRect(selection.x * pixelSize, selection.y * pixelSize, selection.w * pixelSize, selection.h * pixelSize);
+	ctx.setLineDash([]);
+}
+
+function renderPastePreview(ctx) {
+	if (currentElement !== 'w_paste')
+		return;
+	const clipboard = w_state.clipboard;
+	if (!clipboard)
+		return;
+	const clipboardRect = Rect.fromGrid(clipboard, mousePos);
+	ctx.globalAlpha = 1.0;
+	// Fill
+	ctx.fillStyle = w_style.pasteFill;
+	ctx.fillRect(clipboardRect.x * pixelSize, clipboardRect.y * pixelSize, clipboardRect.w * pixelSize, clipboardRect.h * pixelSize);
+	// Stroke
+	ctx.strokeStyle = w_style.pasteStroke;
+	ctx.lineWidth = w_style.strokeWidth;
+	ctx.strokeRect(clipboardRect.x * pixelSize, clipboardRect.y * pixelSize, clipboardRect.w * pixelSize, clipboardRect.h * pixelSize);
+	if (pastePreviewCanvas)
+		ctx.drawImage(pastePreviewCanvas, mousePos.x * pixelSize, mousePos.y * pixelSize, clipboardRect.w * pixelSize, clipboardRect.h * pixelSize);
+}
+
+function addWorldEditKeybinds() {
+	keybinds.w = () => {
+		selectCategory("worldEdit");
+	};
+	keybinds.d = () => {
+		elements.w_deselect.rawOnSelect();
+	};
+	keybinds.a = () => {
+		elements.w_select_all.rawOnSelect();
+	};
+	keybinds.s = () => {
+		selectElement("w_select");
+		selectCategory("worldEdit");
+	};
+	keybinds.c = () => {
+		elements.w_copy.rawOnSelect();
+	};
+	keybinds.v = () => {
+		selectElement("w_paste");
+		selectCategory("worldEdit");
+	};
+	keybinds.x = () => {
+		elements.w_cut.rawOnSelect();
+	};
+	keybinds.Delete = () => {
+		elements.w_delete.rawOnSelect();
+	};
+	keybinds.g = () => {
+		elements.w_fill.rawOnSelect();
+	};
+}
+
+function modifySelectElement() {
+	const originalSelectElement = selectElement;
+	// @ts-ignore
+	selectElement = (element) => {
+		// Keep track of last non-worldEdit element
+		if (!worldEditElements.hasOwnProperty(element))
+			w_state.lastNonWorldEditElement = element;
+		originalSelectElement(element);
+	};
+}
+
+function addWorldEditElements(elementsToAdd) {
+	for (const elementName in elementsToAdd) {
+		const element = elementsToAdd[elementName];
+		elements[elementName] = element;
+		// Apply base settings for every worldEdit element
+		element.category ?? (element.category = "worldEdit");
+		element.color ?? (element.color = w_accentColor);
+		element.tool ?? (element.tool = () => null);
+		element.maxSize ?? (element.maxSize = 1);
+		// Some elements will auto-deselect themselves
+		if (!element.shouldStaySelected) {
+			const originalOnSelect = element.onSelect;
+			element.rawOnSelect = originalOnSelect;
+			element.onSelect = function (...args) {
+				originalOnSelect(...args);
+				selectElement(w_state.lastNonWorldEditElement);
+			};
+		}
+	}
+}
+
+// Elements
+worldEditElements.w_deselect = {
+	onSelect: function () {
+		w_state.selection = null;
+		if (pixelTicks != 0)
+			logMessage("Deselected area.");
+	}
+};
+worldEditElements.w_select_all = {
+	onSelect: function () {
+		w_state.selection = new Rect(0, 0, width + 1, height + 1);
+		logMessage("Selected everything.");
+	}
+};
+worldEditElements.w_select = {
+	onPointerDown: function (e) {
+		const pos = mousePosToWorldPos({x: e.clientX, y: e.clientY});
+		if (showingMenu)
+			return;
+		if (!isPointInWorld(pos))
+			return;
+		if (e.button === 1 || e.button === 2)
+			return;
+		w_state.firstSelectionPos = pos;
+	},
+	onPointerMoveAnywhere: function (e) {
+		const pos = mousePosToWorldPos({x: e.clientX, y: e.clientY});
+		if (!mouseIsDown)
+			return;
+		if (showingMenu)
+			return;
+		if (e.button === 1 || e.button === 2)
+			return;
+		if (currentElement !== "w_select")
+			return;
+		const rect = Rect.fromCorners(w_state.firstSelectionPos, limitPointToWorld(pos)).normalized();
+		rect.x2 += 1;
+		rect.y2 += 1;
+		w_state.selection = rect;
+	},
+	shouldStaySelected: true
+};
+worldEditElements.w_copy = {
+	onSelect: function () {
+		const selection = w_state.selection;
+		if (!selection) {
+			logMessage("Error: Nothing is selected.");
+			return;
+		}
+		// Copy pixels
+		w_state.clipboard = [];
+		let clipboard = w_state.clipboard;
+		for (let y = selection.y; y < selection.y2; y++) {
+			const row = [];
+			for (let x = selection.x; x < selection.x2; x++) {
+				row.push(structuredClone(pixelMap[x][y]));
+			}
+			clipboard.push(row);
+		}
+		updatePastePreviewCanvas();
+		logMessage(`Copied ${selection.w}x${selection.h}=${selection.area} pixel area.`);
+	}
+};
+worldEditElements.w_paste = {
+	onPointerDown: function (e) {
+		if (showingMenu)
+			return;
+		if (!isPointInWorld(mousePos))
+			return;
+		if (e.button === 1 || e.button === 2)
+			return;
+		const clipboard = w_state.clipboard;
+		if (!clipboard) {
+			logMessage("Error: Nothing in clipboard.");
+			return;
+		}
+		const pasteOrigin = mousePos;
+		// Paste pixels
+		for (let y = 0; y < clipboard.length; y++) {
+			for (let x = 0; x < clipboard[0].length; x++) {
+				const clipboardPixel = clipboard[y][x];
+				const dest = {x: pasteOrigin.x + x, y: pasteOrigin.y + y};
+				if (!isPointInWorld(dest))
+					continue; // Skip if out of bounds
+				if (pixelMap[dest.x][dest.y])
+					continue; // Skip if pixel already there
+				if (!clipboardPixel)
+					continue; // Skip if new pixel is air
+				// Create pixel
+				const newPixel = structuredClone(clipboardPixel);
+				Object.assign(newPixel, dest);
+				pixelMap[dest.x][dest.y] = newPixel;
+				currentPixels.push(newPixel);
+			}
+		}
+		const area = Rect.fromGrid(clipboard).area;
+		logMessage(`Pasted ${clipboard[0].length}x${clipboard.length}=${area} pixel area.`);
+	},
+	shouldStaySelected: true
+};
+worldEditElements.w_cut = {
+	onSelect: function () {
+		const selection = w_state.selection;
+		if (!selection) {
+			logMessage("Error: Nothing is selected.");
+			return;
+		}
+		// Cut pixels
+		w_state.clipboard = [];
+		let clipboard = w_state.clipboard;
+		for (let y = selection.y; y < selection.y2; y++) {
+			const row = [];
+			for (let x = selection.x; x < selection.x2; x++) {
+				row.push(structuredClone(pixelMap[x][y]));
+				const pixel = pixelMap[x][y];
+				const index = currentPixels.indexOf(pixel);
+				if (index !== -1)
+					currentPixels.splice(index, 1);
+				if (pixel) {
+					delete pixelMap[x][y];
+				}
+			}
+			clipboard.push(row);
+		}
+		updatePastePreviewCanvas();
+		logMessage(`Cut ${selection.w}x${selection.h}=${selection.area} pixel area.`);
+	}
+};
+worldEditElements.w_delete = {
+	onSelect: function () {
+		const selection = w_state.selection;
+		if (!selection) {
+			logMessage("Error: Nothing is selected.");
+			return;
+		}
+		// Delete pixels
+		for (let y = selection.y; y < selection.y2; y++) {
+			for (let x = selection.x; x < selection.x2; x++) {
+				const pixel = pixelMap[x][y];
+				const index = currentPixels.indexOf(pixel);
+				if (index !== -1)
+					currentPixels.splice(index, 1);
+				if (pixel) {
+					delete pixelMap[x][y];
+				}
+			}
+		}
+		logMessage(`Deleted ${selection.w}x${selection.h}=${selection.area} pixel area.`);
+	}
+};
+worldEditElements.w_fill = {
+	onSelect: function () {
+		const selection = w_state.selection;
+		const fillElement = w_state.lastNonWorldEditElement;
+		if (!selection) {
+			logMessage("Error: Nothing is selected.");
+			return;
+		}
+		// Fill area
+		for (let y = selection.y; y < selection.y2; y++) {
+			for (let x = selection.x; x < selection.x2; x++) {
+				if (pixelMap[x][y])
+					continue;
+				const placed = currentPixels.push(new Pixel(x, y, fillElement));
+				if (!placed)
+					continue;
+				if (currentPixels.length > maxPixelCount || !fillElement) {
+					currentPixels[currentPixels.length - 1].del = true;
+				} else if (elements[fillElement] && elements[fillElement].onPlace !== undefined) {
+					elements[fillElement].onPlace(currentPixels[currentPixels.length - 1]);
+				}
+			}
+		}
+		logMessage(`Filled in ${selection.w}x${selection.h}=${selection.area} pixel area.`);
+	}
+};
+// Setup and hooks
+modifySelectElement();
+addWorldEditElements(worldEditElements);
+addWorldEditKeybinds();
+runAfterReset(() => {
+	if (w_deselectOnResetSetting.value)
+		w_state.selection = null;
+});
+runAfterReset(updatePastePreviewCanvas);
+renderPostPixel(renderSelection);
+renderPostPixel(renderPastePreview);
+// Mobile support
+let addedCustomEventListeners = false;
+runAfterReset(() => {
+	if (addedCustomEventListeners)
+		return;
+	gameCanvas.addEventListener("pointerdown", (e) => {
+		if (elements[currentElement] && elements[currentElement].onPointerDown)
+			elements[currentElement].onPointerDown(e);
+	}, {passive: false});
+	gameCanvas.addEventListener("pointermove", (e) => {
+		if (elements[currentElement] && elements[currentElement].onPointerMove)
+			elements[currentElement].onPointerMove(e);
+	}, {passive: false});
+	document.addEventListener("pointermove", (e) => {
+		if (elements[currentElement] && elements[currentElement].onPointerMoveAnywhere)
+			elements[currentElement].onPointerMoveAnywhere(e);
+	});
+	addedCustomEventListeners = true;
+});