@starktma/minecraft-utils 1.0.1 → 1.1.0

package/package.json

@@ -1,36 +1,36 @@
-{
-	"name": "@starktma/minecraft-utils",
-	"version": "1.0.1",
-	"description": "",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"keywords": [],
-	"author": "",
-	"license": "ISC",
-	"type": "module",
-	"scripts": {
-		"build": "npx -p typescript tsc --project tsconfig.json"
-	},
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		},
-		"./math": {
-			"import": "./dist/math/index.js",
-			"types": "./dist/math/index.d.ts"
-		},
-		"./minecraft": {
-			"import": "./dist/minecraft/index.js",
-			"types": "./dist/minecraft/index.d.ts"
-		}
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"devDependencies": {
-		"@minecraft/server": "^2.1.0",
-		"@minecraft/server-ui": "^2.0.0",
-		"typescript": "^5.9.2"
-	}
-}
+{
+	"name": "@starktma/minecraft-utils",
+	"version": "1.1.0",
+	"description": "",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"keywords": [],
+	"author": "",
+	"license": "ISC",
+	"type": "module",
+	"scripts": {
+		"build": "npx -p typescript tsc --project tsconfig.json"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./math": {
+			"import": "./dist/math/index.js",
+			"types": "./dist/math/index.d.ts"
+		},
+		"./minecraft": {
+			"import": "./dist/minecraft/index.js",
+			"types": "./dist/minecraft/index.d.ts"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@minecraft/server": "^2.1.0",
+		"@minecraft/server-ui": "^2.0.0",
+		"typescript": "^5.9.2"
+	}
+}

package/src/math/index.ts

@@ -1,129 +1,129 @@
-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 { 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;
+}

package/src/minecraft/index.ts

@@ -1,62 +1,62 @@
-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 } 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) };
+}

package/tsconfig.json

@@ -1,22 +1,22 @@
-{
-	"compilerOptions": {
-		"module": "esnext",
-		"moduleResolution": "bundler",
-		"target": "ES2022",
-		"esModuleInterop": true,
-		"sourceMap": true,
-		"strict": true,
-		"forceConsistentCasingInFileNames": true,
-		"resolveJsonModule": true,
-
-		"composite": true,
-		"declaration": true,
-		"declarationMap": true,
-		"incremental": true,
-		"skipLibCheck": true,
-		"noEmitOnError": true,
-		"typeRoots": ["./node_modules/@types"],
-		"outDir": "./dist",
-		"rootDir": "./src"
-	}
-}
+{
+	"compilerOptions": {
+		"module": "esnext",
+		"moduleResolution": "bundler",
+		"target": "ES2022",
+		"esModuleInterop": true,
+		"sourceMap": true,
+		"strict": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+
+		"composite": true,
+		"declaration": true,
+		"declarationMap": true,
+		"incremental": true,
+		"skipLibCheck": true,
+		"noEmitOnError": true,
+		"typeRoots": ["./node_modules/@types"],
+		"outDir": "./dist",
+		"rootDir": "./src"
+	}
+}