@starktma/minecraft-utils 1.2.1 → 1.2.3

package/src/database/database.ts

@@ -1,271 +0,0 @@
-import { Entity, world, World } from "@minecraft/server";
-import { SimpleObject } from "./interfaces";
-
-//@ts-ignore
-import { NAMESPACE } from "./constants";
-
-/**
- * DatabaseManager is a class that manages databases stored in Minecraft's world properties.
- * Currently only supports JSON databases.
- */
-class DatabaseManager {
-	private static readonly DYNAMIC_PROP_MAX_LENGTH = 32767;
-	private static readonly CHUNK_KEY = "__SPLIT__";
-
-	private target: Entity | World;
-
-	constructor(target: Entity | undefined) {
-		if (target instanceof Entity) {
-			this.target = target;
-		} else {
-			this.target = world;
-		}
-	}
-
-	/**
-	 * Checks if a JSON database with the given name exists.
-	 * @param databaseName The name of the database.
-	 * @returns True if the database exists, false otherwise.
-	 */
-	hasJSONDatabase(databaseName: string) {
-		return this.target.getDynamicProperty(NAMESPACE + ":" + databaseName) !== undefined;
-	}
-
-	/**
-	 * Adds a new JSON database with the given name and data.
-	 * @param databaseName The name of the database.
-	 * @param database The data to be stored in the database.
-	 */
-	addJSONDatabase(databaseName: string, database: object) {
-		const propertyName = `${NAMESPACE}:${databaseName}`;
-		const jsonString = JSON.stringify(database);
-		const existingProp = this.target.getDynamicProperty(propertyName) as string | undefined;
-		let existingChunks = 0;
-
-		if (existingProp) {
-			try {
-				const propObj = JSON.parse(existingProp);
-				if (propObj && typeof propObj === "object" && DatabaseManager.CHUNK_KEY in propObj) {
-					existingChunks = propObj[DatabaseManager.CHUNK_KEY];
-				}
-			} catch {}
-		}
-		if (jsonString.length <= DatabaseManager.DYNAMIC_PROP_MAX_LENGTH || jsonString.length === 0) {
-			if (existingChunks > 0) {
-				for (let i = 0; i < existingChunks; i++) {
-					const partName = `${propertyName}_${i}`;
-					this.target.setDynamicProperty(partName, undefined);
-				}
-			}
-			this.target.setDynamicProperty(propertyName, jsonString);
-		} else {
-			const chunkSize = DatabaseManager.DYNAMIC_PROP_MAX_LENGTH;
-			const chunkCount = Math.ceil(jsonString.length / chunkSize);
-			if (existingChunks > 0) {
-				for (let i = 0; i < existingChunks; i++) {
-					const oldPartName = `${propertyName}_${i}`;
-					this.target.setDynamicProperty(oldPartName, undefined);
-				}
-			}
-			for (let i = 0; i < chunkCount; i++) {
-				const start = i * chunkSize;
-				const end = start + chunkSize;
-				const chunk = jsonString.slice(start, end);
-				const partName = `${propertyName}_${i}`;
-				this.target.setDynamicProperty(partName, chunk);
-			}
-			const meta = { [DatabaseManager.CHUNK_KEY]: chunkCount };
-			this.target.setDynamicProperty(propertyName, JSON.stringify(meta));
-		}
-	}
-
-	/**
-	 * Removes a JSON database with the given name.
-	 * @param databaseName The name of the database.
-	 */
-	removeJSONDatabase(databaseName: string) {
-		const propertyName = `${NAMESPACE}:${databaseName}`;
-		const propString = this.target.getDynamicProperty(propertyName) as string | undefined;
-		if (propString !== undefined) {
-			try {
-				const propObj = JSON.parse(propString);
-				if (propObj && typeof propObj === "object" && DatabaseManager.CHUNK_KEY in propObj) {
-					const chunkCount = propObj[DatabaseManager.CHUNK_KEY];
-					for (let i = 0; i < chunkCount; i++) {
-						const partName = `${propertyName}_${i}`;
-						this.target.setDynamicProperty(partName, undefined);
-					}
-				}
-			} catch {}
-			this.target.setDynamicProperty(propertyName, undefined);
-		}
-	}
-
-	/**
-	 * Retrieves a JSON database with the given name.
-	 * @param databaseName The name of the database.
-	 * @returns The data stored in the database.
-	 * @throws An error if the database does not exist.
-	 */
-	getJSONDatabase(databaseName: string) {
-		const propertyName = `${NAMESPACE}:${databaseName}`;
-		const propString = this.target.getDynamicProperty(propertyName) as string | undefined;
-		if (propString === undefined) {
-			throw new Error("Database does not exist");
-		}
-		try {
-			const propObj = JSON.parse(propString);
-			if (propObj && typeof propObj === "object" && DatabaseManager.CHUNK_KEY in propObj) {
-				const chunkCount: number = propObj[DatabaseManager.CHUNK_KEY];
-				let combined = "";
-				for (let i = 0; i < chunkCount; i++) {
-					const partName = `${propertyName}_${i}`;
-					const part = this.target.getDynamicProperty(partName) as string | undefined;
-					if (typeof part === "string") {
-						combined += part;
-					} else {
-						combined += "";
-					}
-				}
-				return JSON.parse(combined);
-			} else {
-				return JSON.parse(propString);
-			}
-		} catch {
-			throw new Error("Failed to parse database JSON");
-		}
-	}
-}
-
-/**
- * SimpleDatabase is a base class for databases that store custom objects with an id property.
- * It provides methods for adding, updating, removing and retrieving objects from the database.
- * A singleton pattern is used to ensure that only one instance of the database exists.
- *
- * @example
- * class MyDatabase extends SimpleDatabase<PlayerObject> {
- * 	protected static instance: MyDatabase;
- * 	constructor() {
- * 		super("myDatabase", undefined);
- * 	}
- *
- * 	static getInstance(): MyDatabase {
- * 		if (!MyDatabase.instance) {
- * 			MyDatabase.instance = new MyDatabase();
- * 		}
- * 		return MyDatabase.instance;
- * 	}
- */
-export class SimpleDatabase<T extends SimpleObject> {
-	private mainDB: DatabaseManager;
-	private localDB: T[];
-
-	protected databaseName: string;
-
-	/**
-	 * The constructor initializes the local database and syncs it with the main database.
-	 * @param databaseName The name of the database.
-	 * @param target The target entity to store the database in. If undefined, the database is stored in the world.
-	 */
-	protected constructor(databaseName: string, target?: Entity | undefined) {
-		this.mainDB = new DatabaseManager(target);
-		this.databaseName = databaseName;
-
-		if (this.mainDB.hasJSONDatabase(this.databaseName)) {
-			this.localDB = this.getMainDB();
-		} else {
-			this.localDB = [];
-			this.updateMainDB();
-		}
-	}
-
-	/**
-	 * Updates the main database with the local database.
-	 * This method is called automatically when an object is added, updated or removed.
-	 * @private
-	 */
-	private updateMainDB() {
-		this.mainDB.addJSONDatabase(this.databaseName, this.localDB);
-	}
-
-	/**
-	 * Retrieves the main database.
-	 * @private
-	 * @returns The main database.
-	 */
-	private getMainDB() {
-		return this.mainDB.getJSONDatabase(this.databaseName);
-	}
-
-	/**
-	 * Adds an object to the local database and updates the main database.
-	 * @param object The object to be added.
-	 */
-	addObject(object: T): void {
-		this.localDB.push(object);
-		this.updateMainDB();
-	}
-
-	/**
-	 * Updates an object in the local database and the main database.
-	 * If the object does not exist, it is added.
-	 * @param object The object to be updated.
-	 */
-	updateObject(object: T): void {
-		if (this.hasObject(object.id)) {
-			this.removeObject(object.id);
-		}
-		this.addObject(object);
-	}
-
-	/**
-	 * Checks if an object with the given id exists in the local database.
-	 * @param id The id of the object.
-	 * @returns True if the object exists, false otherwise.
-	 */
-	hasObject(id: string): boolean {
-		return this.localDB.map((object) => object.id).includes(id);
-	}
-
-	/**
-	 * Retrieves an object with the given id from the local database.
-	 * @param id The id of the object.
-	 * @returns The object if it exists, undefined otherwise.
-	 */
-	getObject(id: string): T | undefined {
-		return this.localDB.filter((object) => object.id === id)[0];
-	}
-
-	/**
-	 * Removes an object with the given id from the local database and updates the main database.
-	 * @param id The id of the object.
-	 */
-	removeObject(id: string): void {
-		this.localDB = this.localDB.filter((object) => object.id !== id);
-		this.updateMainDB();
-	}
-
-	/**
-	 * Retrieves all objects from the local database.
-	 * @returns An array of all objects in the local database.
-	 */
-	getAllObjects(): T[] {
-		return this.localDB;
-	}
-
-	/**
-	 * Removes all objects from the local database and updates the main database.
-	 */
-	eraseAllObjects(): void {
-		this.localDB = [];
-		this.updateMainDB();
-	}
-
-	/**
-	 * Iterates over all objects in the local database.
-	 * @param callback The function to be called for each object.
-	 */
-	forEach(callback: (object: SimpleObject, index: number) => void): void {
-		this.localDB.forEach((object, index) => callback(object, index));
-	}
-}

package/src/minecraft/index.ts

@@ -1,210 +0,0 @@
-import {
-	Player,
-	Entity,
-	Block,
-	Vector3,
-	world,
-	StructureRotation,
-	Vector2,
-	BlockInventoryComponent,
-	BlockPermutation,
-	EntityEquippableComponent,
-	EntityInventoryComponent,
-	EquipmentSlot,
-	ItemStack,
-} from "@minecraft/server";
-import { calculateDistance, toRadians, toSigned, 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;
-	// Round to nearest grid step, then normalize into [0, 360)
-	const snapped = Math.round(toUnsigned(angle) / gridSize) * gridSize;
-	return ((snapped % 360) + 360) % 360;
-}
-
-/**
- * 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, offset?: number): StructureRotation {
-	const diff = snapYawToGrid(toUnsigned(angle - (offset ?? 0)));
-	console.log(diff);
-
-	if (Math.abs(diff - 90) < Number.EPSILON) return StructureRotation.Rotate90;
-	if (Math.abs(diff - 180) < Number.EPSILON) return StructureRotation.Rotate180;
-	if (Math.abs(diff - 270) < Number.EPSILON) 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/index.ts

@@ -1,184 +0,0 @@
-import {
-	system,
-	world,
-	Player,
-	ButtonState,
-	EntityEquippableComponent,
-	EntityInventoryComponent,
-	EquipmentSlot,
-	InputButton,
-	ItemStack,
-} from "@minecraft/server";
-
-type EventCallback<T = CustomPlayer> = (player: T) => void;
-type PlayerEventType = CustomPlayerEvents | string;
-
-enum CustomPlayerEvents {
-	Tick = "tick",
-	JumpStart = "jumpStart",
-	JumpHold = "jumpHold",
-	JumpEnd = "jumpEnd",
-	SneakStart = "sneakStart",
-	SneakHold = "sneakHold",
-	SneakEnd = "sneakEnd",
-}
-
-class EventGroup<T = CustomPlayer> {
-	private callbacks = new Map<PlayerEventType, EventCallback<T>[]>();
-
-	constructor() {
-		// Initialize with core events
-		Object.values(CustomPlayerEvents).forEach((event) => {
-			this.callbacks.set(event, []);
-		});
-	}
-
-	private run(callbacks: EventCallback<T>[], player: T) {
-		for (const cb of callbacks) cb(player);
-	}
-
-	trigger(type: PlayerEventType, player: T) {
-		const callbacks = this.callbacks.get(type);
-		if (callbacks) {
-			this.run(callbacks, player);
-		}
-	}
-
-	on(type: PlayerEventType, callback: EventCallback<T>) {
-		if (!this.callbacks.has(type)) {
-			this.callbacks.set(type, []);
-		}
-		this.callbacks.get(type)!.push(callback);
-	}
-
-	// Simple way to remove listeners
-	off(type: PlayerEventType, callback: EventCallback<T>) {
-		const callbacks = this.callbacks.get(type);
-		if (callbacks) {
-			const index = callbacks.indexOf(callback);
-			if (index > -1) {
-				callbacks.splice(index, 1);
-			}
-		}
-	}
-}
-
-class CustomPlayer {
-	player: Player;
-	stateTick = 0;
-	JumpTick = 0;
-	SneakTick = 0;
-
-	constructor(player: Player) {
-		this.player = player;
-		this.reset();
-	}
-
-	get equippableComponent() {
-		return this.player.getComponent(EntityEquippableComponent.componentId) as EntityEquippableComponent;
-	}
-
-	get inventoryComponent() {
-		return this.player.getComponent(EntityInventoryComponent.componentId) as EntityInventoryComponent;
-	}
-
-	getEquippedItem(): ItemStack | undefined {
-		return this.equippableComponent.getEquipment(EquipmentSlot.Mainhand);
-	}
-
-	reset() {
-		this.stateTick = 0;
-		this.JumpTick = 0;
-		this.player.camera.clear();
-	}
-
-	tick() {
-		this.stateTick++;
-		
-		if (this.player.inputInfo.getButtonState(InputButton.Jump) === ButtonState.Pressed) {
-			this.JumpTick++;
-		} else if (this.JumpTick > 0) {
-			this.JumpTick = -1;
-		} else {
-			this.JumpTick = 0;
-		}
-
-		if (this.player.inputInfo.getButtonState(InputButton.Sneak) === ButtonState.Pressed) {
-			this.SneakTick++;
-		} else if (this.SneakTick > 0) {
-			this.SneakTick = -1;
-		} else {
-			this.SneakTick = 0;
-		}
-	}
-}
-
-class PlayerManager<T extends CustomPlayer = CustomPlayer> {
-	private players = new Map<string, T>();
-	private events = new Map<string, EventGroup<T>>();
-
-	protected constructor() {
-		world.afterEvents.playerSpawn.subscribe(({ player, initialSpawn }) => {
-			const id = player.id;
-			const existing = this.getPlayer(id);
-
-			if (initialSpawn || !existing) {
-				this.addPlayer(player);
-			} else {
-				existing.reset();
-			}
-		});
-
-		world.afterEvents.playerLeave.subscribe(({ playerId }) => {
-			this.removePlayer(playerId);
-		});
-
-		world.afterEvents.worldLoad.subscribe(() => {
-			world.getAllPlayers().forEach((player) => this.addPlayer(player));
-			system.runInterval(() => {
-				this.tick();
-			});
-		});
-	}
-
-	protected createPlayerManager(player: Player): T {
-		return new CustomPlayer(player) as T;
-	}
-
-	getPlayer(id: string) {
-		return this.players.get(id);
-	}
-
-	removePlayer(id: string) {
-		this.players.delete(id);
-	}
-
-	addPlayer(player: Player) {
-		if (this.players.has(player.id)) return;
-		this.players.set(player.id, this.createPlayerManager(player));
-	}
-
-	registerEvents(eventID: string) {
-		const eventGroup = new EventGroup<T>();
-		this.events.set(eventID, eventGroup);
-		return { event: eventGroup };
-	}
-
-	getEvents(eventID: string) {
-		return this.events.get(eventID);
-	}
-
-	tick() {
-		for (const manager of this.players.values()) {
-			const { player } = manager;
-			if (!player.isValid) continue;
-
-			manager.tick();
-			this.events.forEach((eventGroup) => {
-				eventGroup.trigger(CustomPlayerEvents.Tick, manager);
-			});
-		}
-	}
-}
-
-export { CustomPlayerEvents, CustomPlayer, PlayerManager };

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-	"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"
-	}
-}