minerender 2.1.0-alpha.16 → 2.1.0-alpha.17

package/dist/bundle.js

@@ -79973,6 +79973,16 @@ return ${compiler2.callType("value", tagType)}
   // src/model/block/scene/BlockObject.ts
   var import_ts_deepmerge6 = __toESM(require_dist());
   var p13 = prefix("BlockObject");
+  function matchesCondition(condition, state) {
+    return Object.entries(condition).every(([key, value]) => {
+      if (Array.isArray(value)) {
+        if (key === "OR") return value.some((child) => matchesCondition(child, state));
+        if (key === "AND") return value.every((child) => matchesCondition(child, state));
+        return false;
+      }
+      return typeof value === "string" && state[key] !== void 0 && value.split("|").includes(`${state[key]}`);
+    });
+  }
   var _BlockObject = class _BlockObject extends SceneObject {
     constructor(blockState, options) {
       super(options);
@@ -80001,15 +80011,9 @@ return ${compiler2.callType("value", tagType)}
           if (this.blockState.variants) {
             await this.setState(Object.keys(this.blockState.variants)[0]);
           } else if (this.blockState.multipart) {
-            for (let part of this.blockState.multipart) {
-              if (part.when && !("OR" in part.when)) {
-                const k4 = Object.keys(part.when)[0];
-                if (k4) {
-                  await this.setState(k4, part.when[k4].split("|")[0]);
-                  break;
-                }
-              }
-            }
+            const condition = this.blockState.multipart.map((part) => part.when).find((when) => when !== void 0 && Object.values(when).every((value) => typeof value === "string"));
+            const state = Object.fromEntries(Object.entries(condition ?? {}).map(([key, value]) => [key, value.split("|")[0]]));
+            await this.setState(state);
           }
         }
       } else {
@@ -80069,52 +80073,8 @@ return ${compiler2.callType("value", tagType)}
             console.debug(p13, "Missing apply for blockState part", part);
             continue;
           }
-          if (!part.when) {
+          if (!part.when || matchesCondition(part.when, state)) {
             out.push(this.getSingleVariant(part.apply));
-          } else {
-            let matches = true;
-            if ("OR" in part.when) {
-              const or = part.when.OR;
-              let anyMatch = false;
-              for (let o4 of or) {
-                for (let k4 in o4) {
-                  const split = o4[k4].split("|");
-                  let m4 = false;
-                  for (let s4 of split) {
-                    if (`${state[k4]}` === `${s4}`) {
-                      m4 = true;
-                      break;
-                    }
-                  }
-                  if (m4) {
-                    anyMatch = true;
-                    break;
-                  }
-                }
-              }
-              if (!anyMatch) {
-                matches = false;
-              }
-            } else {
-              for (let k4 in part.when) {
-                const split = part.when[k4].split("|");
-                let m4 = false;
-                for (let s4 of split) {
-                  if (`${state[k4]}` === `${s4}`) {
-                    m4 = true;
-                    break;
-                  }
-                }
-                if (!m4) {
-                  matches = false;
-                  break;
-                }
-              }
-            }
-            if (matches) {
-              const variants = part.apply;
-              out.push(this.getSingleVariant(variants));
-            }
           }
         }
       }
@@ -80144,11 +80104,21 @@ return ${compiler2.callType("value", tagType)}
       }
     }
     getSingleVariant(variants) {
-      if (Array.isArray(variants)) {
-        return variants[0];
-      } else {
-        return variants;
+      if (!Array.isArray(variants)) return variants;
+      if (!variants.length) throw new MineRenderError("Blockstate variant arrays must not be empty");
+      const total = variants.reduce((sum, variant) => {
+        const weight = variant.weight ?? 1;
+        if (!Number.isInteger(weight) || weight < 1) {
+          throw new MineRenderError(`Invalid blockstate variant weight: ${weight}`);
+        }
+        return sum + weight;
+      }, 0);
+      let choice = Math.random() * total;
+      for (const variant of variants) {
+        choice -= variant.weight ?? 1;
+        if (choice < 0) return variant;
       }
+      return variants[variants.length - 1];
     }
     // @deprecated
     async createAVariant(variants, instanceInfo) {