Verification with block rendering and all

2025-04-15 19:29:43 -07:00
parent 1243cb7d8b
commit 72e9b65d38
16 changed files with 251 additions and 137 deletions
@@ -1,57 +1,67 @@
 import { MolangVariableMap } from "@minecraft/server";
-import { BlockVerificationLevel } from "./BlockVerificationLevel";
+import { BlockVerificationLevel } from "./enums/BlockVerificationLevel";
 import { Vector } from "../lib/Vector";

 export class BlockVerificationLevelRender {
-    opacity = 0.5;
+    opacity = 0.2;
+    lifetime = 0;

-    constructor(dimension, globalLocation, verificationLevel) {
-        this.dimension = dimension;
-        this.location = new Vector(globalLocation.x, globalLocation.y, globalLocation.z);
+    constructor(dimensionLocation, verificationLevel, lifetime = 5) {
+        this.dimension = dimensionLocation.dimension;
+        this.location = new Vector(dimensionLocation.location.x, dimensionLocation.location.y, dimensionLocation.location.z);
        this.verificationLevel = verificationLevel;
+        this.lifetime = lifetime;
        this.renderBlock();
    }

    renderBlock() {
-        for (const [key, value] of Object.entries(this.getParticleLocations())) {
-            this.dimension.spawnParticle(key, value, this.getRGBAMolang());
+        for (const particleLocation of this.getParticleLocations()) {
+            const color = this.getRGBAMolang();
+            if (!color)
+                return;
+            color.setFloat("lifetime", this.lifetime);
+            try {
+                this.dimension.spawnParticle(particleLocation.particleType, particleLocation.location, color);
+            } catch {
+                /* pass */
+            }
        }
    }

    getParticleLocations() {
-        const bottomFace = new Vector(0, 0, 0);
-        const topFace = new Vector(0, 1, 0);
-        const leftFace = new Vector(0.5, 0.5, 0);
-        const rightFace = new Vector(-0.5, 0.5, 0);
-        const frontFace = new Vector(0, 0.5, 0.5);
-        const backFace = new Vector(0, 0.5, -0.5);
-        return {
-            "structool:blockerlay_xz": this.location.add(topFace),
-            "structool:blockerlay_xz": this.location.add(bottomFace),
-            "structool:blockerlay_yz": this.location.add(leftFace),
-            "structool:blockerlay_yz": this.location.add(rightFace),
-            "structool:blockerlay_xy": this.location.add(frontFace),
-            "structool:blockerlay_xy": this.location.add(backFace),
-        }
+        const bottomFace = new Vector(0.5, 0, 0.5);
+        const topFace = new Vector(0.5, 1, 0.5);
+        const leftFace = new Vector(1, 0.5, 0.5);
+        const rightFace = new Vector(0, 0.5, 0.5);
+        const frontFace = new Vector(0.5, 0.5, 1);
+        const backFace = new Vector(0.5, 0.5, 0);
+        return [
+            { particleType: "structool:blockoverlay_xz", location: this.location.add(topFace) },
+            { particleType: "structool:blockoverlay_xz", location: this.location.add(bottomFace) },
+            { particleType: "structool:blockoverlay_yz", location: this.location.add(leftFace) },
+            { particleType: "structool:blockoverlay_yz", location: this.location.add(rightFace) },
+            { particleType: "structool:blockoverlay_xy", location: this.location.add(frontFace) },
+            { particleType: "structool:blockoverlay_xy", location: this.location.add(backFace) }
+        ];
    }

    getRGBAMolang() {
        const rgb = this.verificationLevelToRGB();
        if (!rgb) return;
        rgb.alpha = this.opacity;
-        return new MolangVariableMap().setColorRGBA("minecraft:particle_appearance_tinting", rgb);
+        const molang = new MolangVariableMap();
+        molang.setColorRGBA("face_color", rgb);
+        return molang;
    }

    verificationLevelToRGB() {
        switch (this.verificationLevel) {
            case BlockVerificationLevel.NoMatch:
-                return [1, 0, 0];
+                return { red: 1, green: 0, blue: 0};
            case BlockVerificationLevel.TypeMatch:
-                return [1, 1, 0];
-            case BlockVerificationLevel.Match:
-                return [0, 1, 0];
+                return { red: 1, green: 1, blue: 0};
            case BlockVerificationLevel.Missing:
-                return [0, 0, 1];
+                return { red: 0, green: 0, blue: 1};
            default:
                return void 0;
        }
@@ -1,4 +1,4 @@
-import { BlockVerificationLevel } from "./BlockVerificationLevel";
+import { BlockVerificationLevel } from "./enums/BlockVerificationLevel";

 export class BlockVerifier {
    constructor(block, instance) {
@@ -1,7 +1,8 @@
 import { structureCollection } from './StructureCollection';
 import { MenuForm } from '../classes/MenuForm';
-import { InstanceEditOptions } from './InstanceEditOptions';
+import { InstanceEditOptions } from './enums/InstanceEditOptions';
 import { InstanceEditFormBuilder } from './InstanceEditFormBuilder';
+import { FormCancelationReason } from '@minecraft/server-ui';

 export class InstanceEditForm {
    instanceName;
@@ -135,7 +136,10 @@ export class InstanceEditForm {
    }

    async statisticsForm() {
-        const form = await InstanceEditFormBuilder.buildStatistics(this.instance)
-        form.show(this.player);
+        const statsForm = await InstanceEditFormBuilder.buildStatistics(this.instance)
+        statsForm.form.show(this.player).then((response) => {
+            if (response.canceled && response.cancelationReason === FormCancelationReason.UserBusy)
+                this.player.sendMessage(statsForm.stats);
+        });
    }
 }
@@ -1,7 +1,7 @@
 import { ActionFormData, ModalFormData } from '@minecraft/server-ui';
 import { MenuFormBuilder } from './MenuFormBuilder';
 import { StructureVerifier } from './StructureVerifier';
-import { BlockVerificationLevel } from './BlockVerificationLevel';
+import { StructureStatistics } from './StructureStatistics';

 export class InstanceEditFormBuilder {
    static buildInstance(instance, options) {
@@ -36,20 +36,11 @@ export class InstanceEditFormBuilder {
    static async buildStatistics(instance) {
        const buildStatisticsForm = new ActionFormData()
            .title(MenuFormBuilder.menuTitle)
-        let message = '';
-        const structureVerifier = new StructureVerifier(instance, { shouldRender: true });
-        const statistics = await structureVerifier.verifyStructure();
-        message += `§fStatistics for §a${instance.name}§f:\n`;
-        message += `§7Blocks: §2${instance.getTotalVolume() - statistics.correctlyAir}\n`;
-        message += `§7Correct: §a${this.getFormattedStatistic(statistics, BlockVerificationLevel.Match)}\n`;
-        message += `§7Block State Incorrect: §e${this.getFormattedStatistic(statistics, BlockVerificationLevel.TypeMatch)}\n`;
-        message += `§7Incorrect: §c${this.getFormattedStatistic(statistics, BlockVerificationLevel.NoMatch)}\n`;
-        message += `§7Missing: §c${this.getFormattedStatistic(statistics, BlockVerificationLevel.Missing)}\n`;
-        buildStatisticsForm.body(message);
-        return buildStatisticsForm;
-    }
-
-    static getFormattedStatistic(statistics, blockVerificationLevel) {
-        return `${statistics[blockVerificationLevel]} (${statistics.percentages[blockVerificationLevel].toFixed(2)}%%)`;
+        const structureVerifier = new StructureVerifier(instance);
+        const verification = await structureVerifier.verifyStructure();
+        const statistics = new StructureStatistics(instance, verification);
+        const statsMessage = statistics.getMessage();
+        buildStatisticsForm.body(statsMessage);
+        return { form: buildStatisticsForm, stats: statsMessage };
    }
 }
@@ -1,23 +1,21 @@
-import { system, world } from "@minecraft/server";
+import { MolangVariableMap, system, world } from "@minecraft/server";
 import { Vector } from "../lib/Vector";

-
 export class Outliner {
    dimension;
    min = new Vector();
    max = new Vector();
    drawParticle = "structool:outline";
-    drawFrequency = 20;
+    drawFrequency = 10;
    
    #drawParticles = [];
-    #runner = null;
+    #runner = void 0;

    constructor(dimension, min, max) {
        this.dimension = dimension;
        this.min = new Vector(min.x, min.y, min.z);
        this.max = new Vector(max.x, max.y, max.z);
        this.vertices = this.getVertices(min, max);
-        this.startDraw();
    }

    startDraw() {
@@ -25,18 +23,28 @@ export class Outliner {
    }

    stopDraw() {
+        if (!this.#runner)
+            return;
        system.clearRun(this.#runner);
+        this.#runner = void 0;
    }

    draw() {
-        this.#drawParticles.length = 0;
-        this.#drawParticles.push(...this.getVerticeParticleLocations());
-        this.#drawParticles.push(...this.getCubiodParticleLocations());
+        this.drawParticles(this.getVerticeParticles(), () => { 
+            return { red: 1, green: 1, blue: 1, alpha: 1 }
+        });
+        this.drawParticles(this.getCubiodEdgeParticles(), this.getNextParticleColor.bind(this));
+    }

+    drawParticles(particleLocations, colorCallback) {
+        this.#drawParticles.length = 0;
+        this.#drawParticles.push(...particleLocations);
        for (const [particleType, location] of this.#drawParticles) {
+            const molang = new MolangVariableMap();
+            molang.setColorRGBA("dot_color", colorCallback());
            try {
-                this.dimension.spawnParticle(particleType, location);
-            } catch {
+                this.dimension.spawnParticle(particleType, location, molang);
+            } catch (e) {
                /* pass */
            }
        }
@@ -62,11 +70,11 @@ export class Outliner {
        this.vertices = this.getVertices(min, max);
    }

-    getVerticeParticleLocations() {
+    getVerticeParticles() {
        return this.vertices.map((v) => [this.drawParticle, v]);
    }

-    getCubiodParticleLocations() {
+    getCubiodEdgeParticles() {
        const edges = [
            [0, 1],
            [0, 2],
@@ -97,4 +105,14 @@ export class Outliner {
        for (const location of locations)
            this.vertices.push(new Vector(location.x, location.y, location.z));
    }
+
+    getNextParticleColor() {
+        if (this.lastWasBlack) {
+            this.lastWasBlack = false;
+            return { red: 1, green: 1, blue: 0, alpha: 1 };
+        } else {
+            this.lastWasBlack = true;
+            return { red: 0.15, green: 0.15, blue: 0.15, alpha: 1 };
+        }
+    }
 }
@@ -1,6 +1,7 @@
 import { world } from "@minecraft/server";
 import { Outliner } from "./Outliner";
 import { StructureOutliner } from "./StructureOutliner";
+import { StructureVerifier } from "./StructureVerifier";

 export class StructureInstance {
    name;
@@ -15,6 +16,7 @@ export class StructureInstance {
        currentLayer: 0
    };
    outliner = void 0;
+    verifier = void 0;

    constructor(instanceName, structureId) {
        this.name = instanceName;
@@ -25,7 +27,7 @@ export class StructureInstance {
        this.#options = this.loadOptions();
        this.#options.structureId = structureId;
        this.updateOptions();
-        this.outliner = new StructureOutliner(this);
+        this.refreshBox();
    }

    loadOptions() {
@@ -102,6 +104,8 @@ export class StructureInstance {
        for (let x = 0; x < max.x; x++) {
            for (let z = 0; z < max.z; z++) {
                const blockPermutation = this.#structure.getBlockPermutation({ x, y, z });
+                if (!blockPermutation)
+                    yield void 0;
                blockPermutation.location = { x, y, z };
                yield blockPermutation;
            }
@@ -128,6 +132,14 @@ export class StructureInstance {
        return this.#structure.size.x * this.#structure.size.y * this.#structure.size.z;
    }

+    getActiveVolume() {
+        if (!this.#options.isEnabled)
+            return 0;
+        if (this.#options.currentLayer === 0)
+            return this.getTotalVolume();
+        return this.#structure.size.x * this.#structure.size.z;
+    }
+
    rename(newName) {
        world.setDynamicProperty(`structOptions:${this.name}`, void 0);
        this.name = newName;
@@ -142,20 +154,20 @@ export class StructureInstance {
    enable() {
        this.#options.isEnabled = true;
        this.updateOptions();
-        this.refreshOutliner();
+        this.refreshBox();
    }

    disable() {
        this.#options.isEnabled = false;
        this.updateOptions();
-        this.refreshOutliner();
+        this.refreshBox();
    }

    move(dimensionId, location) {
        this.#options.dimensionId = dimensionId;
        this.#options.worldLocation = { x: Math.floor(location.x), y: Math.floor(location.y), z: Math.floor(location.z) };
        this.updateOptions();
-        this.refreshOutliner();
+        this.refreshBox();
    }

    setLayer(layer) {
@@ -163,11 +175,18 @@ export class StructureInstance {
            throw new Error(`[StrucTool] Layer ${layer} is out of bounds.`);
        this.#options.currentLayer = layer;
        this.updateOptions();
-        this.refreshOutliner();
+        this.refreshBox();
    }

-    refreshOutliner() {
+    refreshBox() {
+        if (!this.hasLocation())
+            return;
+        if (!this.outliner)
+            this.outliner = new StructureOutliner(this);
+        if (!this.verifier)
+            this.verifier = new StructureVerifier(this, { shouldRender: true });
        this.outliner.refresh();
+        this.verifier.refresh();
    }

    isLocationInStructure(dimensionId, structureLocation) {
@@ -5,7 +5,6 @@ export class StructureOutliner {
        this.instance = instance;
        this.pullInstanceData();
        this.outliner = new Outliner(this.dimension, this.bounds.min, this.bounds.max);
-        this.refresh();
    }

    pullInstanceData() {
@@ -0,0 +1,64 @@
+import { BlockVerificationLevel } from './enums/BlockVerificationLevel.js';
+
+export class StructureStatistics {
+    constructor(instance, verification) {
+        this.instance = instance;
+        this.verification = verification;
+        this.parse();
+    }
+
+    init() {
+        this.statistics = {};
+        for (const verificationLevel of Object.values(BlockVerificationLevel)) {
+            this.statistics[verificationLevel] = 0;
+        }
+        this.statistics.correctlyAir = 0;
+    }
+
+    parse() {
+        this.init();
+        for (const blockVerificationLevel of Object.values(BlockVerificationLevel)) {
+            this.parseStatistic(blockVerificationLevel);
+        }
+    }
+
+    parseStatistic(blockVerificationLevel) {
+        for (const verificationlevel of Object.values(this.verification)) {
+            if (blockVerificationLevel === verificationlevel) {
+                this.statistics[verificationlevel]++;
+            }
+        }
+    }
+
+    getNonAirBlocks() {
+        return this.instance.getActiveVolume() - this.verification.correctlyAir;
+    }
+
+    getStat(blockVerificationLevel) {
+        return { num: this.statistics[blockVerificationLevel], percent: this.statistics[blockVerificationLevel] / (this.getNonAirBlocks()) * 100 };
+    }
+
+    getSkipped() {
+        return this.statistics[BlockVerificationLevel.Skipped] || 0;
+    }
+
+    getMessage() {
+        let message = '';
+        message += `§fStatistics for §a${this.instance.name}§f:`;
+        if (this.instance.isUsingLayers())
+            message += ` §7(layer ${this.instance.getLayer()})`;
+        message += `\n§7Blocks: §2${this.getNonAirBlocks()}\n`;
+        const skipped = this.getSkipped();
+        if (skipped > 0)
+            message += `§c[!] This analysis skipped ${skipped} blocks.\n`;
+        message += `§7Correct: §a${this.formatStat(this.getStat(BlockVerificationLevel.Match))}\n`;
+        message += `§7Block State Incorrect: §e${this.formatStat(this.getStat(BlockVerificationLevel.TypeMatch))}\n`;
+        message += `§7Incorrect: §c${this.formatStat(this.getStat(BlockVerificationLevel.NoMatch))}\n`;
+        message += `§7Missing: §3${this.formatStat(this.getStat(BlockVerificationLevel.Missing))}\n`;
+        return message;
+    }
+
+    formatStat(stat) {
+        return `${stat.num} (${stat.percent.toFixed(2)}%%)`;
+    }
+}
@@ -1,97 +1,85 @@
 import { BlockVerifier } from "./BlockVerifier";
-import { BlockVerificationLevel } from "./BlockVerificationLevel";
+import { BlockVerificationLevel } from "./enums/BlockVerificationLevel";
 import { BlockVerificationLevelRender } from "./BlockVerificationLevelRender";
+import { system, TicksPerSecond } from "@minecraft/server";

 export class StructureVerifier {
    shouldRender;
    isComplete;
+    interval = 5*20;
+    #runner;

    constructor(instance, { shouldRender = false } = {}) {
+        this.shouldRender = shouldRender;
        this.instance = instance;
-        this.blockVerificationLevels = {};
-        this.statistics = {};
+        this.interval = Math.max(instance.getActiveVolume() / 50, 20);
+    }
+
+    startContinuousVerification() {
+        this.#runner = system.runInterval(() => {
+            this.verifyStructure();
+        }, this.interval);
+    }
+
+    stopContinuousVerification() {
+        if (!this.#runner)
+            return;
+        system.clearRun(this.#runner);
+        this.#runner = void 0;
+    }
+
+    refresh() {
+        this.stopContinuousVerification();
+        if (!this.instance.isEnabled())
+            return;
+        this.startContinuousVerification();
+    }
+
+    init(shouldRender) {
+        this.blockVerificationLevels = { correctlyAir: 0 };
        this.shouldRender = shouldRender;
        this.isComplete = false;
-        this.initStatistics();
    }

    async verifyStructure() {
-        await this.runVerifier();
-        this.parseStatistics();
-        return this.statistics;
-    }
-
-    async runVerifier() {
+        this.init(this.shouldRender);
        return new Promise((resolve) => {
-            system.runJob(this.verifyBlocks);
+            if (this.instance.isUsingLayers())
+                system.runJob(this.verifyBlocks(this.instance.getLayerBlocks(this.instance.getLayer()-1)));
+            else
+                system.runJob(this.verifyBlocks(this.instance.getBlocks()));
            const checker = system.runInterval(() => {
                if (this.isComplete) {
                    system.clearRun(checker);
-                    resolve();
+                    resolve(this.blockVerificationLevels);
                }
            }, 1);
        });
    }
    
-    *verifyBlocks() {
-        for (const block of this.instance.getBlocks()) {
+    *verifyBlocks(blocks) {
+        for (const block of blocks) {
            const verificationLevel = this.verifyBlock(block.location);
-            if (verificationLevel !== BlockVerificationLevel.Air)
+            if (verificationLevel === BlockVerificationLevel.Air) {
+                this.blockVerificationLevels.correctlyAir++;
+            } else {
                this.blockVerificationLevels[JSON.stringify(block.location)] = verificationLevel;
-            else
-                this.statistics.correctlyAir++;
-            if (this.shouldRender)
-                new BlockVerificationLevelRender(this.instance.getDimension(), this.instance.toGlobalCoords(block.location), verificationLevel);
-            yield;
+                if (this.shouldRender) {
+                    const dimensionLocation = { dimension: this.instance.getDimension(), location: this.instance.toGlobalCoords(block.location) };
+                    new BlockVerificationLevelRender(dimensionLocation, verificationLevel, this.interval/TicksPerSecond);
+                }
+            }
+            yield void 0;
        }
        this.isComplete = true;
    }

-    // async runVerifier() {
-    //     return new Promise((resolve) => {
-    //         this.verifyBlocks();
-    //         resolve();
-    //     });
-    // }
-
-    // verifyBlocks() {
-    //     for (const block of this.instance.getBlocks()) {
-    //     const verificationLevel = this.verifyBlock(block.location);
-    //     if (verificationLevel !== BlockVerificationLevel.Air)
-    //         this.blockVerificationLevels[JSON.stringify(block.location)] = verificationLevel;
-    //     else
-    //         this.statistics.correctlyAir++;
-    //     }
-    // }
-
    verifyBlock(location) {
        const worldBlock = this.instance.getDimension().getBlock(this.instance.toGlobalCoords(location));
-        if (!worldBlock)
-            throw new Error(`Block at ${JSON.stringify(location)} could not be accessed.`);
+        if (!worldBlock) {
+            return BlockVerificationLevel.Skipped;
+        }
        const blockVerifier = new BlockVerifier(worldBlock, this.instance);
        return blockVerifier.verify();
    }
-
-    initStatistics() {
-        for (const verificationlevel of Object.values(BlockVerificationLevel)) {
-            this.statistics[verificationlevel] = 0;
-        }
-        this.statistics.percentages = {};
-        this.statistics.correctlyAir = 0;
-    }
-
-    parseStatistics() {
-        for (const blockVerificationLevel of Object.values(BlockVerificationLevel)) {
-            this.parseStatistic(blockVerificationLevel);
-        }
-    }
-
-    parseStatistic(blockVerificationLevel) {
-        for (const verificationlevel of Object.values(this.blockVerificationLevels)) {
-            if (blockVerificationLevel === verificationlevel) {
-                this.statistics[verificationlevel]++;
-            }
-        }
-        this.statistics.percentages[blockVerificationLevel] = this.statistics[blockVerificationLevel] / (this.instance.getTotalVolume() - this.statistics.correctlyAir) * 100;
-    }
 }
@@ -4,5 +4,6 @@ export const BlockVerificationLevel = Object.freeze({
    TypeMatch: 2,
    Match: 3,
    Missing: 4,
-    Air: 5
+    Air: 5,
+    Skipped: 6
 });
@@ -17,14 +17,19 @@
 			},
 			"minecraft:emitter_shape_point": {},
 			"minecraft:particle_lifetime_expression": {
-				"max_lifetime": 1
+				"max_lifetime": "variable.lifetime"
 			},
 			"minecraft:particle_appearance_billboard": {
 				"size": [0.5, 0.5],
 				"facing_camera_mode": "emitter_transform_xy"
 			},
 			"minecraft:particle_appearance_tinting": {
-				"color": [0, 0, 0, 0.5]
+				"color": [
+					"variable.face_color.r", 
+					"variable.face_color.g", 
+					"variable.face_color.b", 
+					"variable.face_color.a"
+				]
 			}
 		}
 	}
@@ -17,14 +17,19 @@
 			},
 			"minecraft:emitter_shape_point": {},
 			"minecraft:particle_lifetime_expression": {
-				"max_lifetime": 1
+				"max_lifetime": "variable.lifetime"
 			},
 			"minecraft:particle_appearance_billboard": {
 				"size": [0.5, 0.5],
 				"facing_camera_mode": "emitter_transform_xz"
 			},
 			"minecraft:particle_appearance_tinting": {
-				"color": [0, 0, 0, 0.5]
+				"color": [
+					"variable.face_color.r", 
+					"variable.face_color.g", 
+					"variable.face_color.b", 
+					"variable.face_color.a"
+				]
 			}
 		}
 	}
@@ -17,14 +17,19 @@
 			},
 			"minecraft:emitter_shape_point": {},
 			"minecraft:particle_lifetime_expression": {
-				"max_lifetime": 1
+				"max_lifetime": "variable.lifetime"
 			},
 			"minecraft:particle_appearance_billboard": {
 				"size": [0.5, 0.5],
 				"facing_camera_mode": "emitter_transform_yz"
 			},
 			"minecraft:particle_appearance_tinting": {
-				"color": [0, 0, 0, 0.5]
+				"color": [
+					"variable.face_color.r",
+					"variable.face_color.g",
+					"variable.face_color.b",
+					"variable.face_color.a"
+				]
 			}
 		}
 	}
@@ -4,7 +4,7 @@
 		"description": {
 			"identifier": "structool:outline",
 			"basic_render_parameters": {
-				"material": "particles_blend",
+				"material": "particles_alpha",
 				"texture": "textures/particle/particles"
 			}
 		},
@@ -30,7 +30,12 @@
 				}
 			},
 			"minecraft:particle_appearance_tinting": {
-				"color": [0, 0.66667, 0, 1]
+				"color": [
+					"variable.dot_color.r", 
+					"variable.dot_color.g", 
+					"variable.dot_color.b",
+					"variable.dot_color.a"
+				]
 			}
 		}
 	}