Now is standalone from Canopy

2025-04-20 02:06:55 -07:00
parent d6c9acdaab
commit 1ca91a0993
28 changed files with 256 additions and 151 deletions
@@ -1,7 +1,7 @@
-import { structureCollection } from './StructureCollection';
+import { structureCollection } from '../Structure/StructureCollection';
 import { MenuForm } from '../MenuForm';
 import { forceShow } from '../../utils';
-import { InstanceButtons } from '../enums/InstanceButtons';
+import { InstanceButtons } from '../Enums/InstanceButtons';
 import { InstanceFormBuilder } from './InstanceFormBuilder';
 import { FormCancelationReason } from '@minecraft/server-ui';

@@ -11,12 +11,11 @@ export class InstanceForm {
        isEnabled: [
            InstanceButtons.NextLayer,
            InstanceButtons.PreviousLayer,
-            InstanceButtons.SetLayer,
            InstanceButtons.Move,
            InstanceButtons.Statistics,
            InstanceButtons.Settings,
            InstanceButtons.Rename,
-            InstanceButtons.Disable,
+            InstanceButtons.Disable
        ],
        isNotEnabledAndIsNotPlaced: [
            InstanceButtons.Place,
@@ -149,7 +148,11 @@ export class InstanceForm {
            if (response.canceled)
                return;
            this.instance.setVerifierEnabled(response.formValues[0]);
-            this.instance.setLayer(parseInt(response.formValues[1]));
+            if (response.formValues[1])
+                this.instance.setVerifierDistance(5);
+            else
+                this.instance.setVerifierDistance(0);
+            this.instance.setLayer(parseInt(response.formValues[2]));
        });
    }
 }
@@ -1,7 +1,7 @@
 import { ActionFormData, ModalFormData } from '@minecraft/server-ui';
 import { MenuFormBuilder } from '../MenuFormBuilder';
-import { StructureVerifier } from './StructureVerifier';
-import { StructureStatistics } from './StructureStatistics';
+import { StructureVerifier } from '../Verifier/StructureVerifier';
+import { StructureStatistics } from '../Structure/StructureStatistics';
 import { TicksPerSecond } from '@minecraft/server';

 export class InstanceFormBuilder {
@@ -29,7 +29,7 @@ export class InstanceFormBuilder {
    static async buildStatistics(instance) {
        const buildStatisticsForm = new ActionFormData()
            .title(MenuFormBuilder.menuTitle)
-        const structureVerifier = new StructureVerifier(instance, { isEnabled: true, trackPlayerDistance: 0, intervalOrLifetime: 30 * TicksPerSecond });
+        const structureVerifier = new StructureVerifier(instance, { isEnabled: true, trackPlayerDistance: 0, intervalOrLifetime: 30 * TicksPerSecond, isStandalone: true });
        const verification = await structureVerifier.verifyStructure();
        const statistics = new StructureStatistics(instance, verification);
        const statsMessage = statistics.getMessage();
@@ -39,10 +39,11 @@ export class InstanceFormBuilder {

    static buildSettings(instance) {
        return new ModalFormData()
-        .title(MenuFormBuilder.menuTitle)
+            .title(MenuFormBuilder.menuTitle)
            .label('Use the slider to select the layer. Use 0 for all layers.')
            .toggle('Block Validation', instance.options.verifier.isEnabled)
-            .slider("Layer", 0, maxLayer, 1, currentLayer)
-            .submitButton('§aApply');
+            .toggle('Distance-Based Block Validation', instance.verifier.getTrackPlayerDistance() !== 0)
+            .slider("Layer", 0, instance.getMaxLayer(), 1, instance.getLayer())
+            .submitButton('§2Apply');
    }
 }
@@ -22,6 +22,7 @@ export class InstanceOptions extends Option {
    }

    constructor(instanceName, structureId) {
+        super();
        this.instanceName = instanceName;
        this.structureId = structureId;
        this.load();
@@ -0,0 +1,232 @@
+import { Vector } from "../../lib/Vector";
+import { StructureOutliner } from "../Structure/StructureOutliner";
+import { StructureVerifier } from "../Verifier/StructureVerifier";
+import { Structure } from "../Structure/Structure";
+import { InstanceOptions } from "./InstanceOptions";
+import { TicksPerSecond } from "@minecraft/server";
+
+export class StructureInstance {
+    options;
+    structure = void 0;
+    verifier = void 0;
+    outliner = void 0;
+
+    constructor(instanceName, structureId) {
+        this.structure = new Structure(structureId);
+        this.options = new InstanceOptions(instanceName, structureId);
+        this.refreshBox();
+    }
+
+    delete() {
+        this.disable();
+        this.options.clear();
+        delete this.options;
+        delete this.structure;
+        delete this.outliner;
+        delete this.verifier;
+    }
+
+    refreshBox() {
+        if (!this.hasLocation())
+            return;
+        if (!this.outliner)
+            this.outliner = new StructureOutliner(this);
+        if (!this.verifier)
+            this.verifier = new StructureVerifier(this, { isEnabled: this.options.verifier.isEnabled, trackPlayerDistance: this.options.verifier.trackPlayerDistance });
+        this.outliner.refresh();
+        this.verifier.refresh();
+    }
+
+    getName() {
+        return this.options.instanceName;
+    }
+
+    getStructureId() {
+        return this.options.structureId;
+    }
+
+    getLocation() {
+        return { dimensionId: this.options.dimensionId, location: this.options.worldLocation };
+    }
+
+    getDimension() {
+        return this.options.getDimension();
+    }
+    
+    getLayer() {
+        return this.options.currentLayer;
+    }
+
+    getMaxLayer() {
+        return this.structure.getHeight();
+    }
+
+    getBounds() {
+        return {
+            min: this.structure.getMin(),
+            max: this.structure.getMax()
+        }
+    }
+
+    getActiveBounds() {
+        if (!this.options.isEnabled)
+            throw new Error(`[Construct] Instance '${this.options.instanceName}' is not placed.`);
+        if (this.hasLayerSelected())
+            return this.getLayerBounds(this.getLayer());
+        return this.getBounds();
+    }
+
+    getLayerBounds(layer) {
+        if (!this.options.isEnabled)
+            throw new Error(`[Construct] Instance '${this.options.instanceName}' is not placed.`);
+        const min = this.structure.getMin();
+        const max = this.structure.getMax();
+        return {
+            min: new Vector(min.x, layer - 1, min.z),
+            max: new Vector(max.x, layer, max.z)
+        };
+    }
+
+    getBlock(structureLocation) {
+        return this.structure.getBlock(structureLocation);
+    }
+
+    getBlocks(structureLocations) {
+        return this.structure.getBlocks(structureLocations);
+    }
+
+    getLayerBlocks(layer) {
+        return this.structure.getLayerBlocks(layer);
+    }
+
+    getAllBlocks() {
+        return this.structure.getAllBlocks();
+    }
+
+    getActiveBlocks() {
+        if (!this.options.isEnabled)
+            throw new Error(`[Construct] Instance '${this.options.instanceName}' is not placed.`);
+        if (this.hasLayerSelected())
+            return this.getLayerBlocks(this.getLayer());
+        return this.getAllBlocks();
+    }
+
+    isLocationActive(dimensionId, structureLocation, { useActiveLayer = true } = {}) {
+        if (!this.options.isEnabled || this.options.dimensionId !== dimensionId)
+            return false;
+        let bounds;
+        if (useActiveLayer)
+            bounds = this.getActiveBounds();
+        else
+            bounds = this.getBounds();
+        return structureLocation.x >= bounds.min.x && structureLocation.x < bounds.max.x
+            && structureLocation.y >= bounds.min.y && structureLocation.y < bounds.max.y
+            && structureLocation.z >= bounds.min.z && structureLocation.z < bounds.max.z;
+    }
+
+    getAllActiveLocations() {
+        if (!this.options.isEnabled)
+            throw new Error(`[Construct] Instance '${this.options.instanceName}' is not placed.`);
+        if (this.hasLayerSelected())
+            return this.structure.getLayerLocations(this.getLayer()-1);
+        else
+            return this.structure.getAllLocations();
+    }
+
+    isEnabled() {
+        return this.options.isEnabled;
+    }
+
+    hasLocation() {
+        return this.options.dimensionId && this.options.worldLocation.x !== 0 && this.options.worldLocation.y !== 0 && this.options.worldLocation.z !== 0;
+    }
+
+    hasLayers() {
+        return this.getMaxLayer() > 1;
+    }
+
+    hasLayerSelected() {
+        return this.hasLayers() && this.options.currentLayer !== 0;
+    }
+
+    hasWholeStructureSelected() {
+        return this.hasLocation() && this.options.currentLayer === 0;
+    }
+
+    isAtMaxLayer() {
+        return !this.hasLayers || this.options.currentLayer >= this.getMaxLayer();
+    }
+
+    isAtMinLayer() {
+        return !this.hasLayers || this.options.currentLayer <= 0;
+    }
+
+    enable() {
+        this.options.enable();
+        this.refreshBox();
+    }
+
+    disable() {
+        this.options.disable();
+        this.refreshBox();
+    }
+
+    rename(newName) {
+        this.options.rename(newName);
+    }
+
+    place(dimensionId, worldLocation) {
+        this.move(dimensionId, worldLocation);
+        this.enable();
+    }
+
+    move(dimensionId, worldLocation) {
+        this.options.move(dimensionId, worldLocation);
+        this.refreshBox();
+    }
+
+    setLayer(layer) {
+        if (layer < 0 || layer > this.getMaxLayer())
+            throw new Error(`[Construct] Layer ${layer} is out of bounds.`);
+        this.options.setLayer(layer);
+        this.refreshBox();
+    }
+
+    setVerifierEnabled(enable) {
+        this.options.setVerifierEnabled(enable);
+        this.verifier.refresh();
+    }
+
+    setVerifierDistance(distance) {
+        this.options.setVerifierDistance(distance);
+        if (this.options.verifier.trackPlayerDistance === 0) {
+            const bounds = this.getBounds();
+            this.options.verifier.intervalOrLifetime = Math.max(bounds.min.volume(bounds.max) / TicksPerSecond, 2*TicksPerSecond);
+        } else {
+            this.options.verifier.intervalOrLifetime = 10;
+        }
+        this.verifier.refresh();
+    }
+
+    increaseLayer() {
+        if (this.isAtMaxLayer())
+            this.setLayer(0);
+        else
+            this.setLayer(this.options.currentLayer + 1);
+    }
+
+    decreaseLayer() {
+        if (this.isAtMinLayer())
+            this.setLayer(this.getMaxLayer());
+        else
+            this.setLayer(this.options.currentLayer - 1);
+    }
+
+    toGlobalCoords(structureLocation) {
+        return Vector.from(structureLocation).add(this.options.worldLocation);
+    }
+
+    toStructureCoords(worldLocation) {
+        return Vector.from(worldLocation).subtract(this.options.worldLocation);
+    }
+}