Understudy

Canopy[BP]/manifest.json

@@ -52,6 +52,10 @@
 			"module_name": "@minecraft/debug-utilities",
 			"version": "1.0.0-beta"
 		},
+		{
+			"module_name": "@minecraft/server-gametest",
+			"version": "1.0.0-beta"
+		},
 		{
 			"uuid": "bcf34368-ed0c-4cf7-938e-582cccf9950d",
 			"version": [

Canopy[BP]/scripts/lib/SRCItemDatabase/ItemDatabase.js

@@ -13,10 +13,21 @@ class AsyncQueue {
         this.processing = false;
     }
     enqueue(callback) {
-        this.queue.push(callback);
-        if (!this.processing) {
-            this.dequeue();
-        }
+        return new Promise((resolve, reject) => {
+            this.queue.push(async () => {
+                try {
+                    const result = await callback();
+                    resolve(result);
+                    return result;
+                } catch (error) {
+                    reject(error);
+                    throw error;
+                }
+            });
+            if (!this.processing) {
+                this.dequeue();
+            }
+        });
     }
     async dequeue() {
         if (this.processing || this.queue.length === 0) return;
@@ -78,8 +89,7 @@ class SRCItemDatabase {
     async set(key, itemStack) {
         if (key.length > 12)
             throw new Error(`The provided key "${key}" exceeds the maximum allowed length of 12 characters (actual length: ${key.length}).`);
-        let success = false;
-        this.asyncQueue.enqueue(() => {
+        return this.asyncQueue.enqueue(() => {
             const newId = this.table + key, existingStructure = world.structureManager.get(newId), location = SRCItemDatabase.location;
             if (existingStructure) {
                 world.structureManager.delete(newId);
@@ -98,9 +108,8 @@ class SRCItemDatabase {
             const structureIds = Array.from(Databases.structureIds.get(this.table) ?? []);
             structureIds.push(newId);
             Databases.structureIds.set(this.table, structureIds);
-            success = true;
+            return true;
         });
-        return success;
     };
     setMany(items) { return items.map(item => this.set(item.key, item.item)) };
     getAsync(key) {
@@ -139,7 +148,6 @@ class SRCItemDatabase {
     setItems(key, items) {
         if (key.length > 12)
             throw new Error(`The provided key "${key}" exceeds the maximum allowed length of 12 characters (actual length: ${key.length}).`);
-        let success = false;
         return this.asyncQueue.enqueue(() => {
             const newId = this.table + key, existingStructure = world.structureManager.get(newId);
             if (existingStructure) {
@@ -157,21 +165,21 @@ class SRCItemDatabase {
                 saveMode: this.saveMode
             });
             itemMemory.set(newId, items);
-            Databases.structureIds.set(this.table, Array.from(Databases.structureIds.get(this.table) ?? []).push(newId));
-            success = true;
-            return success;
+            const structureIds = Array.from(Databases.structureIds.get(this.table) ?? []).filter(id => id !== newId);
+            structureIds.push(newId);
+            Databases.structureIds.set(this.table, structureIds);
+            return true;
         });
     }
     getItems(key) {
         if (key.length > 12)
             throw new Error(`The provided key "${key}" exceeds the maximum allowed length of 12 characters (actual length: ${key.length}).`);
         const newId = this.table + key, location = SRCItemDatabase.location;
-        if (!itemMemory.get(newId)) return [];
         if (!world.structureManager.get(newId)) return [];
         SRCItemDatabase.dimension.getEntities({ type: 'minecraft:item', location, maxDistance: 3 }).forEach(item => item.remove())
         world.structureManager.place(newId, SRCItemDatabase.dimension, location, { includeBlocks: false, includeEntities: true });
         const items = SRCItemDatabase.dimension.getEntities({ type: 'minecraft:item', location: location, maxDistance: 3 });
-        if (items.length === 0) return undefined;
+        if (items.length === 0) return [];
         const itemStacksArray = [];
         for (const item of items) {
             itemStacksArray.push(item.getComponent(EntityItemComponent.componentId).itemStack);

Canopy[BP]/scripts/main.js

@@ -35,6 +35,22 @@ import './src/commands/lifetimequery'
 import './src/commands/lifetimequeryitem'
 import './src/commands/velocity'
 
+// Simulated Player Commands
+import './src/commands/simplayer/playerjoin'
+import './src/commands/simplayer/playerleave'
+import './src/commands/simplayer/playerrejoin'
+import './src/commands/simplayer/playertp'
+import './src/commands/simplayer/playerlook'
+import './src/commands/simplayer/playermove'
+import './src/commands/simplayer/playerselect'
+import './src/commands/simplayer/playersprint'
+import './src/commands/simplayer/playersneak'
+import './src/commands/simplayer/playerstop'
+import './src/commands/simplayer/playerswapheld'
+import './src/commands/simplayer/playerinventory'
+import './src/commands/simplayer/playerprefix'
+import './src/commands/simplayer/playeraction'
+
 // Script Events
 import './src/commands/scriptevents/counter'
 import './src/commands/scriptevents/spawn'
@@ -81,6 +97,10 @@ import './src/rules/entitySeparation'
 import './src/rules/enderPearlChunkLoading'
 import './src/rules/renderEndGatewayExits'
 
+// Simulated Player Rules
+import './src/rules/simplayer/simplayerSaving'
+import './src/rules/simplayer/simplayerRejoining'
+
 // Load Time Processes
 import './src/onStart'
 import './src/onReload'

Canopy[BP]/scripts/src/classes/errors/UnderstudyConnectedError.js

@@ -0,0 +1,6 @@
+export class UnderstudyConnectedError extends Error {
+    constructor(name) {
+        super(`[Canopy] Simulated player '${name}' is already connected.`);
+        this.name = 'UnderstudyConnectedError';
+    }
+}

Canopy[BP]/scripts/src/classes/errors/UnderstudyNotConnectedError.js

@@ -0,0 +1,6 @@
+export class UnderstudyNotConnectedError extends Error {
+    constructor(name) {
+        super(`[Canopy] Simulated player '${name}' is not connected.`);
+        this.name = 'UnderstudyNotConnectedError';
+    }
+}

Canopy[BP]/scripts/src/classes/errors/UnderstudySaveInfoError.js

@@ -0,0 +1,6 @@
+export class UnderstudySaveInfoError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'UnderstudySaveInfoError';
+    }
+}

Canopy[BP]/scripts/src/classes/errors/UnknownRepeatingActionError.js

@@ -0,0 +1,6 @@
+export class UnknownRepeatingActionError extends Error {
+    constructor(name, type) {
+        super(`[Canopy] Unknown repeating action '${type}' for simulated player '${name}'.`);
+        this.name = 'UnknownRepeatingActionError';
+    }
+}

Canopy[BP]/scripts/src/classes/simplayer/Actions.js

@@ -0,0 +1,55 @@
+import { system } from "@minecraft/server";
+import { RepeatableAction } from "./RepeatableAction";
+
+export class Actions {
+    #singleActions = [];
+    #repeatingActions = [];
+
+    constructor(understudy) {
+        this.understudy = understudy;
+    }
+
+    onTick() {
+        for (const singleAction of this.#singleActions)
+            singleAction.perform();
+        this.#singleActions.length = 0;
+        for (const repeatingAction of this.#repeatingActions)
+            repeatingAction.onTick();
+    }
+
+    once(type, afterTicks = void 0) {
+        const repeatableAction = new RepeatableAction(this.understudy, type);
+        if (afterTicks === void 0)
+            this.#singleActions.push(repeatableAction);
+        else
+            system.runTimeout(() => this.#singleActions.push(repeatableAction), afterTicks);
+    }
+
+    repeat(type, intervalTicks = 0) {
+        if (this.has(type))
+            this.remove(type);
+        const repeatingAction = new RepeatableAction(this.understudy, type, intervalTicks);
+        this.#repeatingActions.push(repeatingAction);
+    }
+
+    get(type) {
+        return this.#repeatingActions.find(action => action.type === type);
+    }
+
+    has(type) {
+        return this.#repeatingActions.some(action => action.type === type);
+    }
+
+    isEmpty() {
+        return this.#singleActions.length === 0 && this.#repeatingActions.length === 0;
+    }
+
+    remove(type) {
+        this.#repeatingActions = this.#repeatingActions.filter(action => action.type !== type);
+    }
+
+    clear() {
+        this.#repeatingActions.length = 0;
+        this.#singleActions.length = 0;
+    }
+}

Canopy[BP]/scripts/src/classes/simplayer/PlayerInfoSaver.js

@@ -0,0 +1,94 @@
+import { world, system, DimensionTypes, TicksPerSecond, EntityComponentTypes } from "@minecraft/server";
+import { UnderstudyInventorySaver } from "./UnderstudyInventorySaver";
+import { simplayerSaving } from "../../rules/simplayer/simplayerSaving";
+import { UnderstudySaveInfoError } from "../errors/UnderstudySaveInfoError";
+import { UnderstudyNotConnectedError } from "../errors/UnderstudyNotConnectedError";
+
+export class PlayerInfoSaver {
+    saveInterval = 600;
+    #understudy;
+    #inventory;
+
+    constructor(understudy) {
+        this.#understudy = understudy;
+        this.#inventory = new UnderstudyInventorySaver(understudy);
+    }
+
+    onConnectedTick() {
+        this.#saveOnInterval();
+    }
+
+    #saveOnInterval() {
+        if (!simplayerSaving.getNativeValue())
+            return;
+        if ((system.currentTick - this.#understudy.createdTick) % this.saveInterval === 0) {
+            this.save();
+            return;
+        }
+        if (!this.#understudy.actions.isEmpty()) {
+            if ((system.currentTick - this.#understudy.createdTick) % (TicksPerSecond * 5) === 0)
+                this.save();
+            else
+                this.#inventory.saveWithoutNBT();
+        }
+    }
+
+    get() {
+        if (!simplayerSaving.getNativeValue())
+            throw new UnderstudySaveInfoError(`Player ${this.#understudy.name} has no player info saved due to '${simplayerSaving.getID()}' rule being disabled.`);
+        let playerInfo;
+        try {
+            playerInfo = JSON.parse(world.getDynamicProperty(`${this.#understudy.name}:playerinfo`));
+        } catch (error) {
+            if (error.name === 'SyntaxError')
+                throw new UnderstudySaveInfoError(`Player ${this.#understudy.name} has corrupted player info saved, unable to parse player info.`);
+            throw error;
+        }
+        return playerInfo;
+    }
+
+    save() {
+        if (!simplayerSaving.getNativeValue())
+            return;
+        if (!this.#understudy.isConnected())
+            throw new UnderstudyNotConnectedError();
+        const simulatedPlayer = this.#understudy.simulatedPlayer;
+        const playerInfo = {
+            location: simulatedPlayer.location,
+            rotation: this.#understudy.headRotation,
+            dimensionId: simulatedPlayer.dimension.id,
+            gameMode: simulatedPlayer.getGameMode(),
+            projectileIds: this.#findOwnedProjectileIds()
+        };
+        world.setDynamicProperty(`${this.#understudy.name}:playerinfo`, JSON.stringify(playerInfo));
+        this.#inventory.save();
+    }
+
+    #findOwnedProjectileIds() {
+        let projectileIds = [];
+        for (const dimensionType of DimensionTypes.getAll()) {
+            const dimension = world.getDimension(dimensionType.typeId);
+            const projectiles = dimension.getEntities().filter(entity => {
+                const projectileComponent = entity.getComponent(EntityComponentTypes.Projectile);
+                return projectileComponent?.owner === this.#understudy.simulatedPlayer;
+            });
+            projectileIds = projectileIds.concat(projectiles.map(projectile => projectile.id));
+        }
+        return projectileIds;
+    }
+
+    loadInventoryAndProjectileOwnership() {
+        const playerInfo = this.get();
+        this.#claimProjectileIds(playerInfo.projectileIds);
+        this.#inventory.load();
+    }
+
+    #claimProjectileIds(projectileIds) {
+        projectileIds?.forEach(projectileId => {
+            const projectile = world.getEntity(projectileId);
+            const projectileComponent = projectile?.getComponent(EntityComponentTypes.Projectile);
+            if (projectileComponent)
+                projectileComponent.owner = this.#understudy.simulatedPlayer;
+        });
+    }
+}