@starktma/minecraft-utils 1.0.1 → 1.2.0

package/src/math/index.ts

@@ -1,129 +1,132 @@
-import { Vector3 } from "@minecraft/server";
-
-/**
- * Converts an angle in degrees to radians.
- *
- * @param degrees - The angle in degrees to be converted.
- * @returns The angle in radians.
- */
-export function toRadians(degrees: number): number {
-	return degrees * (Math.PI / 180);
-}
-
-/**
- * Converts an angle in radians to degrees.
- *
- * @param radians - The angle in radians to be converted.
- * @returns The angle in degrees.
- */
-export function calculateDistance(position1: Vector3, position2: Vector3): number {
-	return Math.sqrt(
-		Math.sqrt(Math.pow(position1.x - position2.x, 2) + Math.pow(position1.y - position2.y, 2)) + Math.pow(position1.z - position2.z, 2)
-	);
-}
-
-/**
- * Converts an angle in radians to degrees.
- *
- * @param radians - The angle in radians to be converted.
- * @returns The angle in degrees.
- */
-export function toDegrees(radians: number): number {
-	return radians * (180 / Math.PI);
-}
-
-/**
- * Converts a hex color string to an RGBA object.
- *
- * @param hex - The hex color string, which can be in the formats #RGB, #RGBA, #RRGGBB, or #RRGGBBAA.
- * @returns An object containing the red, green, blue, and alpha components as numbers between 0 and 1.
- * @throws Error if the hex string is invalid.
- */
-export function hexToRgba(hex: string): { red: number; green: number; blue: number; alpha: number } {
-	if (!/^#([a-fA-F0-9]{4}|[a-fA-F0-9]{8}|[a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/.test(hex)) {
-		throw new Error("Invalid hex color");
-	}
-
-	let normalized = hex.slice(1);
-	if (normalized.length === 3 || normalized.length === 4) {
-		normalized = normalized
-			.split("")
-			.map((c) => c + c)
-			.join("");
-	}
-
-	const red = parseInt(normalized.substring(0, 2), 16) / 255;
-	const green = parseInt(normalized.substring(2, 4), 16) / 255;
-	const blue = parseInt(normalized.substring(4, 6), 16) / 255;
-	const alpha = (normalized.length === 8 ? parseInt(normalized.substring(6, 8), 16) : 255) / 255;
-
-	return { red, green, blue, alpha };
-}
-
-/**
- * Clamps a value between a minimum and maximum range.
- *
- * @param value - The value to be clamped.
- * @param min - The minimum value of the range.
- * @param max - The maximum value of the range.
- * @returns The clamped value, which will be between `min` and `max`.
- */
-export function clamp(value: number, min: number, max: number): number {
-	return Math.max(min, Math.min(max, value));
-}
-
-/**
- * Converts an angle in degrees to its signed equivalent in the range [-180, 180].
- *
- * @param angle - The angle in degrees to be converted.
- * @returns The signed angle in degrees, normalized to the range [-180, 180].
- */
-export function toSigned(angle: number): number {
-	const wrapped = ((angle % 360) + 360) % 360;
-	return wrapped > 180 ? wrapped - 360 : wrapped;
-}
-
-/**
- * Converts an angle in degrees to its unsigned equivalent in the range [0, 360].
- *
- * @param angle - The angle in degrees to be converted.
- * @returns The unsigned angle in degrees, normalized to the range [0, 360].
- */
-export function toUnsigned(angle: number): number {
-	return ((angle % 360) + 360) % 360;
-}
-
-/**
- * Calculates the shortest signed arc between two angles in degrees.
- *
- * @param from - The starting angle in degrees.
- * @param to - The target angle in degrees.
- * @returns The shortest arc in degrees from `from` to `to`.
- */
-export function shortestArc(from: number, to: number): number {
-	return -toSigned((to - from + 360) % 360);
-}
-
-/**
- * Checks if two positions are equal within a specified tolerance.
- *
- * @param a - The first position.
- * @param b - The second position.
- * @param tolerance - The tolerance for comparison (default is 0.5).
- * @returns `true` if the positions are equal within the tolerance, otherwise `false`.
- */
-export function positionsEqual(a: Vector3, b: Vector3, tolerance: number = 0.5): boolean {
-	return Math.abs(a.x - b.x) < tolerance && Math.abs(a.y - b.y) < tolerance && Math.abs(a.z - b.z) < tolerance;
-}
-
-/**
- * Checks if a value is within a specified range.
- *
- * @param value - The value to check.
- * @param min - The minimum value of the range.
- * @param max - The maximum value of the range.
- * @returns `true` if the value is within the range [min, max], otherwise `false`.
- */
-export function inRange(value: number, min: number, max: number): boolean {
-	return value >= min && value <= max;
-}
+import { RGB, RGBA, Vector3 } from "@minecraft/server";
+
+/**
+ * Converts an angle in degrees to radians.
+ *
+ * @param degrees - The angle in degrees to be converted.
+ * @returns The angle in radians.
+ */
+export function toRadians(degrees: number): number {
+	return degrees * (Math.PI / 180);
+}
+
+/**
+ * Converts an angle in radians to degrees.
+ *
+ * @param radians - The angle in radians to be converted.
+ * @returns The angle in degrees.
+ */
+export function calculateDistance(position1: Vector3, position2: Vector3): number {
+	return Math.sqrt(
+		Math.pow(position1.x - position2.x, 2) + Math.pow(position1.y - position2.y, 2) + Math.pow(position1.z - position2.z, 2)
+	);
+}
+
+/**
+ * Converts an angle in radians to degrees.
+ *
+ * @param radians - The angle in radians to be converted.
+ * @returns The angle in degrees.
+ */
+export function toDegrees(radians: number): number {
+	return radians * (180 / Math.PI);
+}
+
+/**
+ * Converts a hex color string to an RGBA object.
+ *
+ * @param hex - The hex color string, which can be in the formats #RGB, #RGBA, #RRGGBB, or #RRGGBBAA.
+ * @returns An object containing the red, green, blue, and alpha components as numbers between 0 and 1.
+ * @throws Error if the hex string is invalid.
+ */
+export function hexToRgba(hex: string, stripAlpha: boolean = false): RGB | RGBA {
+	if (!/^#([a-fA-F0-9]{4}|[a-fA-F0-9]{8}|[a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/.test(hex)) {
+		throw new Error("Invalid hex color");
+	}
+
+	let normalized = hex.slice(1);
+	if (normalized.length === 3 || normalized.length === 4) {
+		normalized = normalized
+			.split("")
+			.map((c) => c + c)
+			.join("");
+	}
+
+	const red = parseInt(normalized.substring(0, 2), 16) / 255;
+	const green = parseInt(normalized.substring(2, 4), 16) / 255;
+	const blue = parseInt(normalized.substring(4, 6), 16) / 255;
+	const alpha = (normalized.length === 8 ? parseInt(normalized.substring(6, 8), 16) : 255) / 255;
+
+	if (stripAlpha) {
+		return { red, green, blue };
+	}
+	return { red, green, blue, alpha };
+}
+
+/**
+ * Clamps a value between a minimum and maximum range.
+ *
+ * @param value - The value to be clamped.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @returns The clamped value, which will be between `min` and `max`.
+ */
+export function clamp(value: number, min: number, max: number): number {
+	return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Converts an angle in degrees to its signed equivalent in the range [-180, 180].
+ *
+ * @param angle - The angle in degrees to be converted.
+ * @returns The signed angle in degrees, normalized to the range [-180, 180].
+ */
+export function toSigned(angle: number): number {
+	const wrapped = ((angle % 360) + 360) % 360;
+	return wrapped > 180 ? wrapped - 360 : wrapped;
+}
+
+/**
+ * Converts an angle in degrees to its unsigned equivalent in the range [0, 360].
+ *
+ * @param angle - The angle in degrees to be converted.
+ * @returns The unsigned angle in degrees, normalized to the range [0, 360].
+ */
+export function toUnsigned(angle: number): number {
+	return ((angle % 360) + 360) % 360;
+}
+
+/**
+ * Calculates the shortest signed arc between two angles in degrees.
+ *
+ * @param from - The starting angle in degrees.
+ * @param to - The target angle in degrees.
+ * @returns The shortest arc in degrees from `from` to `to`.
+ */
+export function shortestArc(from: number, to: number): number {
+	return -toSigned((to - from + 360) % 360);
+}
+
+/**
+ * Checks if two positions are equal within a specified tolerance.
+ *
+ * @param a - The first position.
+ * @param b - The second position.
+ * @param tolerance - The tolerance for comparison (default is 0.5).
+ * @returns `true` if the positions are equal within the tolerance, otherwise `false`.
+ */
+export function positionsEqual(a: Vector3, b: Vector3, tolerance: number = 0.5): boolean {
+	return Math.abs(a.x - b.x) < tolerance && Math.abs(a.y - b.y) < tolerance && Math.abs(a.z - b.z) < tolerance;
+}
+
+/**
+ * Checks if a value is within a specified range.
+ *
+ * @param value - The value to check.
+ * @param min - The minimum value of the range.
+ * @param max - The maximum value of the range.
+ * @returns `true` if the value is within the range [min, max], otherwise `false`.
+ */
+export function inRange(value: number, min: number, max: number): boolean {
+	return value >= min && value <= max;
+}

package/src/minecraft/index.ts

@@ -1,62 +1,207 @@
-import { Player, Entity, Block, Vector3, world } from "@minecraft/server";
-import { calculateDistance, toUnsigned } from "../math";
-
-export function getBlocksInASphere(centerBlock: Block | Entity, radius: number, innerRadius?: number) {
-	if (centerBlock) {
-		if (centerBlock instanceof Block && !centerBlock.isValid) return [];
-		let center = centerBlock.location;
-		let blocks: Block[] = [];
-		for (let x = center.x - radius; x < center.x + radius; x++) {
-			for (let y = center.y - radius; y < center.y + radius; y++) {
-				for (let z = center.z - radius; z < center.z + radius; z++) {
-					try {
-						let block = centerBlock.dimension.getBlock({ x: x, y: y, z: z });
-						if (
-							block &&
-							block.isValid &&
-							!block.isAir &&
-							!block.permutation.matches("minecraft:bedrock") &&
-							!block.permutation.matches("minecraft:barrier") &&
-							calculateDistance(center, block.location) <= radius &&
-							(!innerRadius || calculateDistance(center, block.location) >= innerRadius)
-						) {
-							blocks.push(block);
-						}
-					} catch (e) {}
-				}
-			}
-		}
-		return blocks;
-	}
-	return [];
-}
-
-export function displayActionbar(player: Player | undefined, ...message: any) {
-	const text = message.join(" ");
-	let target;
-	let selector;
-	target = player && player.isValid ? player : world.getDimension("overworld");
-	selector = player ? `@s` : `@a`;
-	target.runCommand(`title @s actionbar ${JSON.stringify(text)}`);
-}
-
-/**
- * Snaps an angle to the nearest grid size.
- *
- * @param angle - The angle in degrees to be snapped.
- * @returns The snapped unsigned angle in degrees.
- */
-export function snapRotationToGrid(angle: number): number {
-	const gridSize = 90;
-	return Math.round(toUnsigned(angle) / gridSize) * gridSize;
-}
-
-/**
- * Snaps a vector to the nearest integer coordinates.
- *
- * @param v - The vector to be snapped.
- * @returns A new vector with each component rounded to the nearest integer.
- */
-export function snapLocationToGrid(v: Vector3): Vector3 {
-	return { x: Math.round(v.x), y: Math.floor(v.y), z: Math.round(v.z) };
-}
+import {
+	Player,
+	Entity,
+	Block,
+	Vector3,
+	world,
+	StructureRotation,
+	Vector2,
+	BlockInventoryComponent,
+	BlockPermutation,
+	EntityEquippableComponent,
+	EntityInventoryComponent,
+	EquipmentSlot,
+	ItemStack,
+} from "@minecraft/server";
+import { calculateDistance, toRadians, toUnsigned } from "../math";
+
+export function getBlocksInASphere(centerBlock: Block | Entity, radius: number, innerRadius?: number) {
+	if (centerBlock) {
+		if (centerBlock instanceof Block && !centerBlock.isValid) return [];
+		let center = centerBlock.location;
+		let blocks: Block[] = [];
+		for (let x = center.x - radius; x < center.x + radius; x++) {
+			for (let y = center.y - radius; y < center.y + radius; y++) {
+				for (let z = center.z - radius; z < center.z + radius; z++) {
+					try {
+						let block = centerBlock.dimension.getBlock({ x: x, y: y, z: z });
+						if (
+							block &&
+							block.isValid &&
+							!block.isAir &&
+							!block.permutation.matches("minecraft:bedrock") &&
+							!block.permutation.matches("minecraft:barrier") &&
+							calculateDistance(center, block.location) <= radius &&
+							(!innerRadius || calculateDistance(center, block.location) >= innerRadius)
+						) {
+							blocks.push(block);
+						}
+					} catch (e) {}
+				}
+			}
+		}
+		return blocks;
+	}
+	return [];
+}
+
+export function displayActionbar(player: Player | undefined, ...message: any) {
+	const text = message.join(" ");
+	let target;
+	let selector;
+	target = player && player.isValid ? player : world.getDimension("overworld");
+	selector = player ? `@s` : `@a`;
+	target.runCommand(`title ${selector} actionbar ${JSON.stringify(text)}`);
+}
+
+/**
+ * Snaps an angle to the nearest grid size.
+ *
+ * @param angle - The angle in degrees to be snapped.
+ * @returns The snapped unsigned angle in degrees.
+ */
+export function snapYawToGrid(angle: number): number {
+	const gridSize = 90;
+	return Math.round(toUnsigned(angle) / gridSize) * gridSize;
+}
+
+/**
+ * Snaps a vector to the nearest integer coordinates.
+ *
+ * @param v - The vector to be snapped.
+ * @returns A new vector with each component rounded to the nearest integer.
+ */
+export function snapLocationToGrid(location: Vector3, yaw: Vector2, gridSize: number = 1): Vector3 {
+	const snappedYaw = snapYawToGrid(yaw.y);
+	const dx = Math.round(Math.sin(snappedYaw));
+	const dz = Math.round(Math.cos(snappedYaw));
+
+	return {
+		x: Math.floor(location.x / gridSize) * gridSize,
+		y: Math.floor(location.y / gridSize) * gridSize,
+		z: Math.floor(location.z / gridSize) * gridSize,
+	};
+}
+
+export function getStructureRotationEnum(angle: number, saveYaw?: number): StructureRotation {
+	const EPS = 1e-4;
+	const diff = snapYawToGrid(angle) - snapYawToGrid(saveYaw ?? 0);
+	if (Math.abs(diff - 90) < EPS) return StructureRotation.Rotate90;
+	if (Math.abs(diff - 180) < EPS) return StructureRotation.Rotate180;
+	if (Math.abs(diff - 270) < EPS) return StructureRotation.Rotate270;
+	return StructureRotation.None;
+}
+
+export function getRelativeMovementDirection(player: Player, round: boolean): Vector3 {
+	const playerYaw = toRadians(player.getRotation().y);
+	const { sin, cos } = { sin: Math.sin(playerYaw), cos: Math.cos(playerYaw) };
+
+	const playerMovement = player.inputInfo.getMovementVector();
+
+	const dx = -sin * playerMovement.y + cos * playerMovement.x;
+	const dz = cos * playerMovement.y + sin * playerMovement.x;
+
+	if (round) {
+		return { x: Math.round(dx), y: 0, z: Math.round(dz) };
+	}
+	return { x: dx, y: 0, z: dz };
+}
+
+export function restoreInventory(entity: Entity, id: string) {
+	const blockLocation = entity.dimension.getBlockFromRay(entity.location, { x: 0, y: -1, z: 0 })!.block.location;
+	blockLocation.y++;
+	const blockLocation2 = { ...blockLocation, y: blockLocation.y + 1 };
+
+	const savedStructure = world.structureManager.get(id);
+	if (savedStructure) world.structureManager.place(savedStructure, entity.dimension, blockLocation);
+	world.structureManager.delete(id);
+
+	const block = entity.dimension.getBlock(blockLocation)!;
+	const block2 = entity.dimension.getBlock(blockLocation2)!;
+
+	const equipment = entity.getComponent(EntityEquippableComponent.componentId) as EntityEquippableComponent;
+	const invComponent = entity.getComponent(EntityInventoryComponent.componentId) as EntityInventoryComponent;
+	const blockInventory = block.getComponent(BlockInventoryComponent.componentId) as BlockInventoryComponent;
+	const blockInventory2 = block2.getComponent(BlockInventoryComponent.componentId) as BlockInventoryComponent;
+
+	const slots = Object.values(EquipmentSlot);
+	slots.forEach((slot) => {
+		equipment.setEquipment(slot, blockInventory.container!.getItem(slots.indexOf(slot))!);
+	});
+
+	Array(41)
+		.fill(0)
+		.forEach((_, i) => {
+			if (i < invComponent.container!.size) {
+				if (i < 9) {
+					// First chest: starts filling from slot 5
+					blockInventory.container!.moveItem(i + 5, i, invComponent.container!);
+				} else {
+					// Second chest: adjusts index for 0-26 range starting from slot 0
+					blockInventory2.container!.moveItem(i - 9, i, invComponent.container!);
+				}
+			}
+		});
+
+	blockInventory.container!.clearAll();
+	blockInventory2.container!.clearAll();
+	block.setPermutation(BlockPermutation.resolve("minecraft:air"));
+	block2.setPermutation(BlockPermutation.resolve("minecraft:air"));
+}
+
+export function saveInventory(entity: Entity, id: string, clearAll: boolean = false): number {
+	const blockLocation = entity.dimension.getTopmostBlock(entity.location)!.location;
+	blockLocation.y++;
+	const blockLocation2 = { ...blockLocation, y: blockLocation.y + 1 };
+
+	const block = entity.dimension.getBlock(blockLocation)!;
+	const block2 = entity.dimension.getBlock(blockLocation2)!;
+
+	block.setPermutation(BlockPermutation.resolve("minecraft:chest"));
+	block2.setPermutation(BlockPermutation.resolve("minecraft:chest"));
+
+	const equipment = entity.getComponent(EntityEquippableComponent.componentId) as EntityEquippableComponent;
+	const invComponent = entity.getComponent(EntityInventoryComponent.componentId) as EntityInventoryComponent;
+	const blockInventory = block.getComponent(BlockInventoryComponent.componentId) as BlockInventoryComponent;
+	const blockInventory2 = block2.getComponent(BlockInventoryComponent.componentId) as BlockInventoryComponent;
+
+	const itemCount = invComponent.container!.size - invComponent.container!.emptySlotsCount;
+
+	Object.values(EquipmentSlot).forEach((slot) => {
+		if (clearAll) {
+			equipment.setEquipment(slot);
+		}
+		blockInventory.container!.addItem(equipment.getEquipment(slot) ?? new ItemStack("minecraft:air", 1));
+	});
+
+	if (clearAll) {
+	}
+
+	Array(41)
+		.fill(0)
+		.forEach((_, i) => {
+			if (i < invComponent.container!.size) {
+				if (i < 9) {
+					// First chest: starts filling from slot 5
+					invComponent.container!.moveItem(i, 5 + i, blockInventory.container!);
+				} else {
+					// Second chest: adjusts index for 0-26 range starting from slot 0
+					invComponent.container!.moveItem(i, i - 9, blockInventory2.container!);
+				}
+				if (clearAll) {
+					invComponent.container!.setItem(i);
+				}
+			}
+		});
+
+	world.structureManager.delete(id);
+	world.structureManager.createFromWorld(id, entity.dimension, blockLocation, blockLocation2);
+
+	blockInventory.container!.clearAll();
+	blockInventory2.container!.clearAll();
+
+	block.setPermutation(BlockPermutation.resolve("minecraft:air"));
+	block2.setPermutation(BlockPermutation.resolve("minecraft:air"));
+
+	return itemCount;
+}

package/src/player-event/constants.ts

@@ -0,0 +1 @@
+export const NAMESPACE = 'player-event';