Material counter and cleanup

scripts/classes/MaterialCounter.js

@@ -0,0 +1,73 @@
+import { structureCollection } from '../classes/StructureCollection';
+
+class MaterialCounter {
+    static getAll(name) {
+        const structure = structureCollection.get(name);
+        const materials = {};
+        for (const block of structure.getBlocks()) {
+            const typeId = block?.getItemStack()?.typeId.replace('minecraft:', '');
+            if (!typeId) continue;
+            if (!materials[typeId]) {
+                materials[typeId] = 0;
+            }
+            materials[typeId]++;
+        }
+        return materials;
+    }
+
+    static getLayer(name, layer) {
+        const structure = structureCollection.get(name);
+        const materials = {};
+        for (const block of structure.getLayerBlocks(layer)) {
+            const typeId = block?.getItemStack()?.typeId.replace('minecraft:', '');
+            if (!typeId) continue;
+            if (!materials[typeId]) {
+                materials[typeId] = 0;
+            }
+            materials[typeId]++;
+        }
+        return materials;
+    }
+
+    static getPrintable(name) {
+        const structure = structureCollection.get(name);
+        const materials = {};
+        for (const block of structure.getBlocks()) {
+            const itemStack = block?.getItemStack();
+            const typeId = itemStack?.typeId.replace('minecraft:', '');
+            if (!typeId) continue;
+            if (!materials[typeId]) {
+                materials[typeId] = { count: 0, maxStack: itemStack.maxAmount };
+            }
+            materials[typeId].count++;
+        }
+        let message = [];
+        for (const blockType in materials) {
+            let count = materials[blockType].count;
+            let countStr = '';
+            const maxStack = materials[blockType].maxStack;
+            const fullShulker = 27 * maxStack;
+            if (count >= fullShulker) {
+                countStr = `${Math.floor(count / fullShulker)} sb`;
+            }
+            if (count > fullShulker) {
+                countStr += ' + ';
+            }
+            count %= fullShulker;
+            if (count >= maxStack) {
+                countStr += `${Math.floor(count / maxStack)} stack`;
+            }
+            if (count > maxStack) {
+                countStr += ' + ';
+            }
+            count %= maxStack;
+            if (count > 0) {
+                countStr += count;
+            }
+            message.push(`  ${blockType}: ${countStr}`);
+        }
+        return message.sort().join('\n');
+    }
+}
+
+export { MaterialCounter };

scripts/classes/Outliner.js

@@ -1,4 +1,4 @@
-import { MolangVariableMap, system, world } from "@minecraft/server";
+import { system, world } from "@minecraft/server";
 import { Vector } from "../lib/Vector";
 
 const drawFrequency = 8;
@@ -17,6 +17,7 @@ export class Outliner {
         this.dimension = world.getDimension(dimension);
         this.min = new Vector(min.x, min.y, min.z);
         this.max = new Vector(max.x, max.y, max.z);
+        this.startDraw();
     }
 
     startDraw() {

scripts/classes/Structure.js

@@ -8,12 +8,16 @@ export class Structure {
         dimensionId: MinecraftDimensionTypes.overworld,
         location: { x: 0, y: 0, z: 0 },
         rotation: 0,
-        mirror: false
+        mirror: false,
+        currentLayer: 0
     };
 
     constructor(structureName) {
         this.name = structureName;
         this.#structure = world.structureManager.get(structureName);
+        if (!this.#structure) {
+            throw new Error(`[StrucTool] Structure '${structureName}' not found.`);
+        }
         this.#options = this.loadOptions();
     }
 
@@ -29,16 +33,48 @@ export class Structure {
     updateOptions() {
         world.setDynamicProperty(`structOptions:${this.name}`, JSON.stringify(this.#options));
     }
-
-    getName() {
-        return this.name;
-    }
-
+    
     getStructure() {
         return this.#structure;
     }
 
-    getOutlineLimits() {
+    getLocation() {
+        return this.#options.location;
+    }
+
+    getHeight() {
+        return this.#structure.size.y;
+    }
+
+    getLayer() {
+        return this.#options.currentLayer;
+    }
+
+    *getBlocks() {
+        const max = this.#structure.size;
+        for (let x = 0; x < max.x; x++) {
+            for (let y = 0; y < max.y; y++) {
+                for (let z = 0; z < max.z; z++) {
+                    yield this.#structure.getBlockPermutation({ x, y, z });
+                }
+            }
+        }
+    }
+
+    *getLayerBlocks(y) {
+        const max = this.#structure.size;
+        for (let x = 0; x < max.x; x++) {
+            for (let z = 0; z < max.z; z++) {
+                yield this.#structure.getBlockPermutation({ x, y, z });
+            }
+        }
+    }
+
+    getBlock(location) {
+        return this.#structure.getBlockPermutation(location);
+    }
+
+    getBounds() {
         if (!this.#options.isPlaced)
             throw new Error(`[StrucTool] Structure '${this.name}' is not placed.`);
         return {
@@ -55,6 +91,22 @@ export class Structure {
         }
     }
 
+    getLayeredBounds(useUnder = false) {
+        if (!this.#options.isPlaced)
+            throw new Error(`[StrucTool] Structure '${this.name}' is not placed.`);
+        if (useUnder) {
+            return {
+                min: { x: this.#options.location.x, y: this.#options.location.y, z: this.#options.location.z },
+                max: { x: this.#options.location.x + this.#structure.size.x, y: this.#options.location.y + this.#options.currentLayer, z: this.#options.location.z + this.#structure.size.z }
+            }
+        } else {
+            return {
+                min: { x: this.#options.location.x, y: this.#options.location.y + this.#options.currentLayer - 1,z: this.#options.location.z },
+                max: { x: this.#options.location.x + this.#structure.size.x, y: this.#options.location.y + this.#options.currentLayer, z: this.#options.location.z + this.#structure.size.z }
+            }
+        }
+    }
+
     place(dimensionId, location) {
         this.#options = {
             isPlaced: true,
@@ -62,8 +114,7 @@ export class Structure {
             location: { x: Math.floor(location.x), y: Math.floor(location.y), z: Math.floor(location.z) },
         };
         this.updateOptions();
-        this.outliner = new Outliner(dimensionId, this.getOutlineLimits().min, this.getOutlineLimits().max);
-        this.outliner.startDraw();
+        this.outliner = new Outliner(dimensionId, this.getBounds().min, this.getBounds().max);
     }
 
     remove() {
@@ -72,6 +123,14 @@ export class Structure {
         this.#options.isPlaced = false;
         this.updateOptions();
         this.outliner.stopDraw();
-        delete this.outliner;
+    }
+
+    setLayer(layer) {
+        if (layer < 1 || layer > this.#structure.size.y)
+            throw new Error(`[StrucTool] Structure '${this.name}' does not have layer ${layer}.`);
+        this.#options.currentLayer = layer;
+        this.updateOptions();
+        this.outliner.stopDraw();
+        this.outliner = new Outliner(this.#options.dimensionId, this.getLayeredBounds().min, this.getLayeredBounds().max);
     }
 }

scripts/classes/StructureCollection.js

@@ -1,4 +1,3 @@
-import { world } from '@minecraft/server';
 import { Structure } from './Structure';
 
 class StructureCollection {
@@ -9,8 +8,9 @@ class StructureCollection {
     }
 
     add(name) {
-        const struct = world.structureManager.get(name);
-        this.#structures[name] = new Structure(name, struct);
+        const structure = new Structure(name);
+        this.#structures[name] = structure;
+        return structure;
     }
 
     get(name) {
@@ -26,14 +26,6 @@ class StructureCollection {
         struct.remove();
         delete this.#structures[name];
     }
-
-    place(name, dimensionId, location) {
-        const struct = this.get(name);
-        if (!struct) {
-            throw new Error(`Structure ${name} not found.`);
-        }
-        struct.place(dimensionId, location);
-    }
 }
 
 export const structureCollection = new StructureCollection();