mc-assets 0.2.34 → 0.2.35

package/dist/assetsParser.d.ts

@@ -18,6 +18,9 @@ export declare class AssetsParser {
     parseProperties(properties: string): Record<string, string | boolean>;
     getElements(queriedBlock: Omit<QueriedBlock, 'stateId'>, fallbackVariant?: boolean): 0 | 1 | BlockElement[];
     private resolvedModel;
+    issues: string[];
+    matchedModels: string[];
+    matchedConditions: string[];
     private getModelsByBlock;
     getResolvedModelsByModel(model: string, debugQueryName?: string, clearModel?: boolean): {
         resolvedModel: Pick<BlockModel, "textures" | "ao" | "elements"> & {

package/dist/assetsParser.js

@@ -1,3 +1,11 @@
+const getNamespace = (name) => {
+    const parts = name.split(':');
+    if (parts.length === 1)
+        return 'minecraft';
+    if (parts.length === 2)
+        return parts[0];
+    return parts.slice(0, -1).join(':');
+};
 export class AssetsParser {
     version;
     blockStatesStore;
@@ -43,7 +51,12 @@ export class AssetsParser {
     }
     // looks like workaround
     resolvedModel = {};
+    issues = [];
+    matchedModels = [];
+    matchedConditions = [];
     getModelsByBlock(queriedBlock, fallbackVariant, multiOptim) {
+        this.matchedModels = [];
+        this.matchedConditions = [];
         const matchProperties = (block, /* to match against */ properties) => {
             if (!properties) {
                 return true;
@@ -69,9 +82,12 @@ export class AssetsParser {
         };
         let applyModels = [];
         const blockStates = this.blockStatesStore.get(this.version, queriedBlock.name);
-        if (!blockStates)
+        if (!blockStates) {
+            this.issues.push(`Block ${queriedBlock.name} not found in all registered blockstates. Place it into assets/${getNamespace(queriedBlock.name)}/blockstates/${queriedBlock.name}.json`);
             return;
+        }
         const states = blockStates.variants;
+        let stateMatched = false;
         if (states) {
             let state = states[''] || states['normal'];
             for (const key in states) {
@@ -82,9 +98,15 @@ export class AssetsParser {
                     break;
                 }
             }
+            if (state) {
+                const matchedStateName = Object.entries(states).find(([key]) => state === states[key])?.[0];
+                this.matchedConditions.push(`variant:${matchedStateName}`);
+            }
             if (!state) {
                 if (fallbackVariant) {
-                    state = states[Object.keys(states)[0]];
+                    const firstKey = Object.keys(states)[0];
+                    state = states[firstKey];
+                    this.matchedConditions.push(`fallback:${firstKey}`);
                 }
                 else {
                     return;
@@ -92,12 +114,14 @@ export class AssetsParser {
             }
             if (state) {
                 applyModels.push(state);
+                stateMatched = true;
             }
         }
         if (blockStates.multipart) {
             for (const { when, apply } of blockStates.multipart) {
                 if (!when || matchProperties(queriedBlock, when)) {
                     applyModels.push(apply);
+                    this.matchedConditions.push(when ? `multipart:${JSON.stringify(when)}` : 'multipart:always');
                 }
             }
             if (!applyModels.length && fallbackVariant) {
@@ -105,11 +129,22 @@ export class AssetsParser {
                 const apply = multipartWithWhen[0]?.apply;
                 if (apply) {
                     applyModels.push(apply);
+                    this.matchedConditions.push('multipart:fallback');
                 }
             }
         }
-        if (!applyModels.length)
+        if (!applyModels.length) {
+            if (!stateMatched) {
+                const blockstatesCount = Object.keys(states ?? {}).length;
+                if (blockstatesCount) {
+                    this.issues.push(`Block did not match any possible state (${blockstatesCount} possible states)`);
+                }
+                else {
+                    this.issues.push(`Blockstates for ${queriedBlock.name} are not defined`);
+                }
+            }
             return;
+        }
         const modelsResolved = [];
         let part = 0;
         for (const model of applyModels) {
@@ -141,8 +176,11 @@ export class AssetsParser {
             this.resolvedModel = {};
         }
         const modelData = this.blockModelsStore.get(this.version, model);
-        if (!modelData)
+        if (!modelData) {
+            this.issues.push(`Model ${model} not found. Ensure it is present in assets/${getNamespace(model)}/models/${model}.json`);
             return;
+        }
+        this.matchedModels.push(model);
         return this.getResolvedModelsByModelData(modelData, debugQueryName, clearModel);
     }
     getResolvedModelsByModelData(modelData, debugQueryName, clearModel = true) {
@@ -154,8 +192,11 @@ export class AssetsParser {
             collectedParentModels.push(model);
             if (model.parent) {
                 const parent = this.blockModelsStore.get(this.version, model.parent);
-                if (!parent)
+                if (!parent) {
+                    this.issues.push(`Parent model ${model.parent} not found for ${debugQueryName}`);
                     return;
+                }
+                this.matchedModels.push(`parent:${model.parent}`);
                 collectModels(parent);
             }
         };
@@ -192,14 +233,12 @@ export class AssetsParser {
                 originalTexturePath = originalTexturePath.split('/').at(-1).replace('#', '');
                 this.resolvedModel.textures ??= {};
                 if (chain.includes(originalTexturePath)) {
-                    console.warn(`${debugQueryName}: Circular texture reference detected: ${chain.join(' -> ')}`);
+                    this.issues.push(`${debugQueryName}: Circular texture reference detected: ${chain.join(' -> ')}`);
                     return;
                 }
                 const existingKey = this.resolvedModel.textures[originalTexturePath];
                 if (!existingKey) {
-                    // todo this also needs to be done at the validation stage
-                    // throw new Error(`Cannot resolve texture ${key} to ${value} because it is not defined`)
-                    console.warn(`${debugQueryName}: Cannot resolve texture ${originalTexturePath} for ${_originalKey} because it is not defined`);
+                    this.issues.push(`${debugQueryName}: Cannot resolve texture ${originalTexturePath} for ${_originalKey} because it is not defined`);
                     return;
                 }
                 else {

package/dist/worldBlockProvider.d.ts

@@ -1,7 +1,7 @@
 import { QueriedBlock } from './assetsParser';
 import { BlockModel } from './types';
 export default function worldBlockProvider(blockstatesModels: any, blocksAtlas: any, version: string): {
-    getAllResolvedModels0_1(block: Omit<QueriedBlock, "stateId">, fallbackVariant?: boolean): ({
+    getAllResolvedModels0_1(block: Omit<QueriedBlock, "stateId">, fallbackVariant?: boolean, possibleIssues?: string[], matchedModels?: string[], matchedConditions?: string[]): (({
         elements: {
             faces: {
                 [k: string]: {
@@ -34,7 +34,7 @@ export default function worldBlockProvider(blockstatesModels: any, blocksAtlas:
         z?: number;
         uvlock?: boolean;
         weight?: number;
-    }, "textures" | "elements">)[][];
+    }, "textures" | "elements">) | null)[][];
     transformModel: <T extends BlockModel | (Pick<BlockModel, "textures" | "ao" | "elements"> & {
         x?: number;
         y?: number;

package/dist/worldBlockProvider.js

@@ -57,15 +57,50 @@ export default function worldBlockProvider(blockstatesModels, blocksAtlas, versi
         };
     };
     return {
-        getAllResolvedModels0_1(block, fallbackVariant = false) {
+        getAllResolvedModels0_1(block, fallbackVariant = false, possibleIssues = [], matchedModels = [], matchedConditions = []) {
+            assetsParser.issues = [];
+            assetsParser.matchedModels = [];
+            assetsParser.matchedConditions = [];
             const modelsParts = assetsParser.getAllResolvedModels(block, fallbackVariant) ?? [];
+            possibleIssues.push(...assetsParser.issues);
+            matchedModels.push(...assetsParser.matchedModels);
+            matchedConditions.push(...assetsParser.matchedConditions);
+            if (!modelsParts.length) {
+                possibleIssues.push(`No models found for block ${block.name}`);
+                return [];
+            }
             const interestedFaces = ['north', 'east', 'south', 'west', 'up', 'down'];
-            return modelsParts.map(modelVariants => {
-                return modelVariants.map(model => {
-                    return transformModel(model, block);
-                }).filter(a => a.elements?.length);
-            }).filter(a => a.length);
+            try {
+                const result = modelsParts.map(modelVariants => {
+                    return modelVariants.map(model => {
+                        try {
+                            return transformModel(model, block);
+                        }
+                        catch (e) {
+                            possibleIssues.push(`Error transforming model for ${block.name}: ${e.message}`);
+                            return null;
+                        }
+                    }).filter(a => a?.elements?.length);
+                }).filter(a => a.length);
+                if (!result.length) {
+                    possibleIssues.push(`No valid models after transformation for block ${block.name}`);
+                }
+                return result;
+            }
+            catch (e) {
+                possibleIssues.push(`Fatal error processing models for ${block.name}: ${e.message}`);
+                return [];
+            }
         },
+        // getResolvedModels0_1(block: Omit<QueriedBlock, 'stateId'>, fallbackVariant = false) {
+        //     const modelsParts = assetsParser.getAllResolvedModels(block, fallbackVariant) ?? []
+        //     const interestedFaces = ['north', 'east', 'south', 'west', 'up', 'down']
+        //     return modelsParts.map(modelVariants => {
+        //         return modelVariants.map(model => {
+        //             return transformModel(model, block);
+        //         }).filter(a => a.elements?.length)
+        //     }).filter(a => a.length)
+        // },
         transformModel,
         getTextureInfo
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mc-assets",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "author": "Vitaly Turovsky <vital2580@icloud.com>",
   "license": "MIT",
   "files": [