@holoscript/core 8.0.8 → 8.0.9

package/dist/chunk-ZVQMKUGJ.js

@@ -0,0 +1,443 @@
+// src/traits/visual/types.ts
+var VISUAL_LAYER_PRIORITY = {
+  base_material: 0,
+  surface: 1,
+  condition: 2,
+  physical: 3,
+  scale: 4,
+  lighting: 5,
+  visual_effect: 6,
+  environmental: 7,
+  mood: 8
+};
+
+// src/traits/visual/TraitVisualRegistry.ts
+var TraitVisualRegistry = class _TraitVisualRegistry {
+  constructor() {
+    this.configs = /* @__PURE__ */ new Map();
+  }
+  /** Get the singleton instance. */
+  static getInstance() {
+    if (!_TraitVisualRegistry.instance) {
+      _TraitVisualRegistry.instance = new _TraitVisualRegistry();
+    }
+    return _TraitVisualRegistry.instance;
+  }
+  /** Register a single trait's visual configuration. */
+  register(traitName, config) {
+    this.configs.set(traitName, config);
+  }
+  /** Register multiple trait visual configs at once. */
+  registerBatch(entries) {
+    for (const [name, config] of Object.entries(entries)) {
+      this.configs.set(name, config);
+    }
+  }
+  /** Look up a trait's visual config. Returns undefined if not registered. */
+  get(traitName) {
+    return this.configs.get(traitName);
+  }
+  /** Check if a trait has a registered visual config. */
+  has(traitName) {
+    return this.configs.has(traitName);
+  }
+  /** Get all registered configs (read-only). */
+  getAll() {
+    return this.configs;
+  }
+  /** Number of registered trait visuals. */
+  get size() {
+    return this.configs.size;
+  }
+  /** Reset the registry (primarily for testing). */
+  reset() {
+    this.configs.clear();
+  }
+};
+
+// src/traits/visual/composition-rules.ts
+var COMPOSITION_RULES = [
+  // ══════════════════════════════════════════════════════════════════
+  // REQUIREMENT RULES — trait only applies if another trait provides
+  // the required tag (a trait cannot self-satisfy its own requirement)
+  // ══════════════════════════════════════════════════════════════════
+  // Corrosion traits only apply to objects with a metallic base
+  { trait: "rusted", requires: { tags: ["metallic"] } },
+  { trait: "tarnished", requires: { tags: ["metallic"] } },
+  { trait: "corroded", requires: { tags: ["metallic"] } },
+  // Metal finishing requires a metallic base
+  { trait: "brushed", requires: { tags: ["metallic"] } },
+  { trait: "hammered", requires: { tags: ["metallic"] } },
+  // Organic overgrowth requires an organic or mineral base
+  { trait: "moss_covered", requires: { tags: ["organic", "mineral", "stone"] } },
+  { trait: "vine_covered", requires: { tags: ["organic", "mineral", "stone"] } },
+  // Biological processes require organic base
+  { trait: "decayed", requires: { tags: ["organic"] } },
+  { trait: "fossilized", requires: { tags: ["organic"] } },
+  { trait: "witherable", requires: { tags: ["organic"] } },
+  { trait: "bloomable", requires: { tags: ["organic"] } },
+  // ══════════════════════════════════════════════════════════════════
+  // SUPPRESSION RULES — trait removes listed traits from consideration
+  // ══════════════════════════════════════════════════════════════════
+  // Pristine/brand_new suppress all damage/wear states
+  {
+    trait: "pristine",
+    suppresses: [
+      "rusted",
+      "worn",
+      "weathered",
+      "decayed",
+      "tarnished",
+      "corroded",
+      "crumbling",
+      "faded",
+      "stained",
+      "scratched",
+      "dented",
+      "chipped",
+      "cracked",
+      "shattered",
+      "battle_scarred",
+      "charred",
+      "tattered",
+      "dust_covered",
+      "moss_covered",
+      "vine_covered"
+    ]
+  },
+  {
+    trait: "brand_new",
+    suppresses: [
+      "rusted",
+      "worn",
+      "weathered",
+      "decayed",
+      "tarnished",
+      "corroded",
+      "faded",
+      "stained",
+      "scratched",
+      "dented",
+      "chipped",
+      "antique",
+      "dust_covered"
+    ]
+  },
+  // Restored suppresses active decay (but not cosmetic scars)
+  {
+    trait: "restored",
+    suppresses: ["decayed", "crumbling", "corroded", "rusted"]
+  },
+  // Mirrored overrides surface textures
+  {
+    trait: "mirrored",
+    suppresses: ["matte_surface", "frosted_surface", "brushed"]
+  },
+  // Temperature conflicts — fire and ice cancel each other
+  {
+    trait: "frozen_liquid",
+    suppresses: ["fiery", "elemental_fire", "volcanic_eruption", "boiling", "charred"]
+  },
+  {
+    trait: "elemental_fire",
+    suppresses: ["frozen_liquid", "elemental_ice", "frosted_surface"]
+  },
+  // Visibility — invisible/cloaking suppress visual effects
+  {
+    trait: "invisible",
+    suppresses: ["glowing", "neon_glow", "luminous", "bioluminescent", "holographic", "outlined"]
+  },
+  {
+    trait: "cloaking",
+    suppresses: ["glowing", "neon_glow", "holographic", "outlined"]
+  },
+  // Petrification/fossilization suppress living traits
+  {
+    trait: "petrified",
+    suppresses: ["growable", "bloomable", "photosynthetic", "witherable"]
+  },
+  {
+    trait: "fossilized",
+    suppresses: ["growable", "bloomable", "bioluminescent", "photosynthetic"]
+  },
+  // Crystallization suppresses soft surface textures
+  {
+    trait: "crystallized",
+    suppresses: ["furry", "velvety", "woolly", "silky"]
+  },
+  // Magic conflicts — blessed and cursed cancel each other
+  { trait: "cursed", suppresses: ["blessed"] },
+  { trait: "blessed", suppresses: ["cursed"] },
+  // Environmental conflicts
+  {
+    trait: "drought",
+    suppresses: ["leaking", "overflowing", "moss_covered"]
+  },
+  {
+    trait: "flood",
+    suppresses: ["drought", "dust_covered", "sandstorm"]
+  },
+  {
+    trait: "underwater",
+    suppresses: ["fiery", "elemental_fire"]
+  },
+  // ══════════════════════════════════════════════════════════════════
+  // ADDITIVE RULES — extra properties blended on top
+  // ══════════════════════════════════════════════════════════════════
+  // Frozen adds blue tint
+  { trait: "frozen_liquid", additive: { color: "#D6EAF8" } },
+  // Enchanted adds a subtle purple shimmer
+  { trait: "enchanted", additive: { emissive: "#9966FF", emissiveIntensity: 0.3 } },
+  // Ghostly adds transparency
+  { trait: "ghostly", additive: { opacity: 0.3, transparent: true } },
+  // Electric adds blue-white emissive
+  { trait: "electric_arc", additive: { emissive: "#00BFFF", emissiveIntensity: 0.5 } },
+  // Bioluminescence adds green glow
+  { trait: "bioluminescent", additive: { emissive: "#00FFAA", emissiveIntensity: 0.4 } },
+  // Iridescent/pearlescent add color-shift sheen
+  { trait: "iridescent", additive: { iridescence: 0.5 } },
+  { trait: "pearlescent", additive: { iridescence: 0.8 } },
+  // ══════════════════════════════════════════════════════════════════
+  // MULTI-TRAIT MERGE RULES — when all listed traits are present,
+  // override merged material with these values (applied last)
+  // ══════════════════════════════════════════════════════════════════
+  // ── Metal synergies ─────────────────────────────────────────────
+  // Iron + rusted = corroded bronze appearance
+  {
+    traits: ["rusted", "iron_material"],
+    merge: { color: "#6B3A1F", roughness: 0.9, metalness: 0.5 }
+  },
+  // Copper + rusted = verdigris patina
+  {
+    traits: ["rusted", "copper_material"],
+    merge: { color: "#5C8A7A", roughness: 0.7, metalness: 0.6 }
+  },
+  // Gold + polished = high-shine gold
+  {
+    traits: ["gold_material", "polished"],
+    merge: { roughness: 0.05, envMapIntensity: 2 }
+  },
+  // ── Elemental synergies ─────────────────────────────────────────
+  // Water + frozen = deep ice
+  {
+    traits: ["elemental_water", "frozen_liquid"],
+    merge: { color: "#B0D4E8", transmission: 0.85, roughness: 0.05 }
+  },
+  // Fire + angry = rage inferno
+  {
+    traits: ["elemental_fire", "angry"],
+    merge: { emissive: "#FF1100", emissiveIntensity: 3.5 }
+  },
+  // Lightning + thunderstorm = storm energy
+  {
+    traits: ["elemental_lightning", "thunderstorm"],
+    merge: { emissive: "#FFFFFF", emissiveIntensity: 4.5 }
+  },
+  // Earth + ancient = primordial stone
+  {
+    traits: ["elemental_earth", "ancient"],
+    merge: { roughness: 1, color: "#5A4A3A" }
+  },
+  // ── Magic synergies ─────────────────────────────────────────────
+  // Enchanted + ancient = magical artifact
+  {
+    traits: ["enchanted", "ancient"],
+    merge: { emissive: "#9966FF", emissiveIntensity: 0.5, color: "#8B6914" }
+  },
+  // Blessed + gold = holy golden artifact
+  {
+    traits: ["blessed", "gold_material"],
+    merge: { emissive: "#FFFACD", emissiveIntensity: 0.8, envMapIntensity: 2 }
+  },
+  // Enchanted + diamond = spellbound gem
+  {
+    traits: ["enchanted", "diamond_gem"],
+    merge: { emissive: "#CC88FF", emissiveIntensity: 0.6, iridescence: 1 }
+  },
+  // Crystal + enchanted = magical crystal
+  {
+    traits: ["crystal_gem", "enchanted"],
+    merge: { emissive: "#CC88FF", emissiveIntensity: 1, iridescence: 1 }
+  },
+  // Cursed + blood stained = profane artifact
+  {
+    traits: ["cursed", "blood_stained"],
+    merge: { emissive: "#660000", emissiveIntensity: 0.8, color: "#4A0000" }
+  },
+  // ── Age + condition synergies ───────────────────────────────────
+  // Ancient + weathered = time-worn relic
+  {
+    traits: ["ancient", "weathered"],
+    merge: { roughness: 0.95, color: "#6B5A4A" }
+  },
+  // Ancient + moss = ancient overgrown ruins
+  {
+    traits: ["ancient", "moss_covered"],
+    merge: { roughness: 0.95, color: "#3A6A2F" }
+  },
+  // Pristine + crystal = flawless crystal
+  {
+    traits: ["pristine", "crystal_gem"],
+    merge: { roughness: 0, transmission: 0.98, envMapIntensity: 2.5 }
+  },
+  // ── Nature synergies ────────────────────────────────────────────
+  // Bioluminescent + aquatic = glowing sea creature
+  {
+    traits: ["bioluminescent", "aquatic"],
+    merge: { emissive: "#00CCAA", emissiveIntensity: 1.2 }
+  },
+  // Venomous + glowing = toxic glow
+  {
+    traits: ["venomous", "glowing"],
+    merge: { emissive: "#00FF00", emissiveIntensity: 0.8, color: "#3A5A1A" }
+  },
+  // Wildfire + wooden = burning wood
+  {
+    traits: ["wildfire", "wooden"],
+    merge: { emissive: "#FF4500", emissiveIntensity: 2.5, roughness: 0.9 }
+  },
+  // ── Visual effect synergies ─────────────────────────────────────
+  // Emissive + angry mood = intense red emissive
+  {
+    traits: ["emissive", "angry"],
+    merge: { emissive: "#FF2200", emissiveIntensity: 2.5 }
+  },
+  // Holographic + ghostly = spectral hologram
+  {
+    traits: ["holographic", "ghostly"],
+    merge: { opacity: 0.2, emissive: "#88BBFF", emissiveIntensity: 1.5 }
+  },
+  // Holographic + neon = vibrant holographic display
+  {
+    traits: ["holographic", "neon_glow"],
+    merge: { emissive: "#00FFFF", emissiveIntensity: 2, opacity: 0.5 }
+  },
+  // Frozen + crystalline = ice crystal formation
+  {
+    traits: ["frozen_liquid", "crystalline"],
+    merge: { transmission: 0.9, ior: 1.31, iridescence: 0.7 }
+  },
+  // Eerie + ghostly = spectral haunting
+  {
+    traits: ["eerie", "ghostly"],
+    merge: { emissive: "#6633AA", emissiveIntensity: 0.5, opacity: 0.25 }
+  },
+  // ── Sci-fi synergies ────────────────────────────────────────────
+  // Plasma + force field = plasma barrier
+  {
+    traits: ["plasma", "force_field"],
+    merge: { emissive: "#FF00FF", emissiveIntensity: 2.5, opacity: 0.4 }
+  }
+];
+
+// src/traits/visual/TraitCompositor.ts
+var TraitCompositor = class {
+  constructor(registry, rules) {
+    this.registry = registry ?? TraitVisualRegistry.getInstance();
+    this.rules = rules ?? COMPOSITION_RULES;
+  }
+  /**
+   * Compose multiple trait visuals into a single material config.
+   * Returns only the properties that were explicitly set by at least one trait.
+   */
+  compose(traitNames) {
+    const entries = [];
+    for (const name of traitNames) {
+      const config = this.registry.get(name);
+      if (!config) continue;
+      const layer = config.layer ?? "visual_effect";
+      const priority = VISUAL_LAYER_PRIORITY[layer];
+      entries.push({ name, config, priority });
+    }
+    const suppressedTraits = this.getSuppressedTraits(traitNames);
+    const activeEntries = entries.filter((e) => !suppressedTraits.has(e.name));
+    const tagProviders = /* @__PURE__ */ new Map();
+    for (const entry of activeEntries) {
+      if (entry.config.tags) {
+        for (const tag of entry.config.tags) {
+          if (!tagProviders.has(tag)) tagProviders.set(tag, /* @__PURE__ */ new Set());
+          tagProviders.get(tag).add(entry.name);
+        }
+      }
+    }
+    const filteredEntries = activeEntries.filter((e) => {
+      return this.meetsRequirements(e.name, tagProviders);
+    });
+    filteredEntries.sort((a, b) => a.priority - b.priority);
+    const merged = {};
+    for (const entry of filteredEntries) {
+      if (entry.config.material) {
+        Object.assign(merged, entry.config.material);
+      }
+      if (entry.config.emissive) {
+        merged.emissive = entry.config.emissive.color;
+        merged.emissiveIntensity = entry.config.emissive.intensity;
+      }
+      if (entry.config.opacity !== void 0) {
+        merged.opacity = entry.config.opacity;
+        merged.transparent = entry.config.opacity < 1;
+      }
+    }
+    const activeTraitNames = filteredEntries.map((e) => e.name);
+    const activeTags = /* @__PURE__ */ new Set();
+    for (const entry of filteredEntries) {
+      if (entry.config.tags) {
+        for (const tag of entry.config.tags) {
+          activeTags.add(tag);
+        }
+      }
+    }
+    this.applyAdditiveRules(activeTraitNames, activeTags, merged);
+    return merged;
+  }
+  /** Get set of trait names suppressed by other active traits. */
+  getSuppressedTraits(traitNames) {
+    const suppressed = /* @__PURE__ */ new Set();
+    const nameSet = new Set(traitNames);
+    for (const rule of this.rules) {
+      if ("suppresses" in rule && rule.suppresses && nameSet.has(rule.trait)) {
+        for (const s of rule.suppresses) {
+          suppressed.add(s);
+        }
+      }
+    }
+    return suppressed;
+  }
+  /** Check if a trait's requirement rules are satisfied by OTHER traits' tags. */
+  meetsRequirements(traitName, tagProviders) {
+    for (const rule of this.rules) {
+      if (!("requires" in rule) || rule.trait !== traitName || !rule.requires) continue;
+      if (rule.requires.tags) {
+        const hasRequired = rule.requires.tags.some((tag) => {
+          const providers = tagProviders.get(tag);
+          if (!providers) return false;
+          for (const provider of providers) {
+            if (provider !== traitName) return true;
+          }
+          return false;
+        });
+        if (!hasRequired) return false;
+      }
+    }
+    return true;
+  }
+  /** Apply additive rules and multi-trait merge overrides. */
+  applyAdditiveRules(traitNames, allTags, merged) {
+    const nameSet = new Set(traitNames);
+    for (const rule of this.rules) {
+      if ("additive" in rule && rule.additive && nameSet.has(rule.trait)) {
+        Object.assign(merged, rule.additive);
+      }
+      if ("traits" in rule && rule.traits && "merge" in rule && rule.merge) {
+        const allPresent = rule.traits.every((t) => nameSet.has(t));
+        if (allPresent) {
+          Object.assign(merged, rule.merge);
+        }
+      }
+    }
+  }
+};
+
+export { COMPOSITION_RULES, TraitCompositor, TraitVisualRegistry, VISUAL_LAYER_PRIORITY };
+//# sourceMappingURL=chunk-ZVQMKUGJ.js.map
+//# sourceMappingURL=chunk-ZVQMKUGJ.js.map