VanillaTemplate pulls in default model settings

Author: SpecialBuilder32

gm4/plugins/resource_pack.py

@@ -332,9 +332,6 @@ def beet_default(ctx: Context):
     VanillaTemplate.vanilla = Vanilla(ctx)
     VanillaTemplate.vanilla.minecraft_version = '1.21.5'
     VanillaTemplate.vanilla_jar = VanillaTemplate.vanilla.mount("assets/minecraft/items")
-    AdvancementIconTemplate.vanilla = Vanilla(ctx)
-    AdvancementIconTemplate.vanilla.minecraft_version = '1.21.4'
-    AdvancementIconTemplate.vanilla_jar = AdvancementIconTemplate.vanilla.mount("assets/minecraft/items")
 
     yield
     tl.warn_unused_translations()
@@ -891,34 +888,71 @@ class VanillaTemplate(TemplateOptions):
 
     def create_models(self, config: ModelData, models_container: NamespaceProxy[Model]):
         model_names = config.model.entries()
-        if any([isinstance(m, list) for m in model_names]):
-            raise InvalidOptions("gm4.model_data", f"{config.reference}; Template 'vanilla' does not support predicate override 'model' fields.")
         if len(set(model_names)) == 1 and len(config.item.entries()) > 1:
             model_names = [f"{model_names[0]}_{item}" for item in config.item.entries()] # if only one model name given, make one model per item id
 
-        model_def_entries = [
-            {
-                "type": "minecraft:model",
-                "model": m
-            }
-        for m in model_names]
+        model_def_map: dict[str,JsonType] = {}
 
         ret_list: list[Model] = []
         for item, model_name in zip(config.item.entries(), model_names):
             model_compound = self.vanilla_jar.assets.item_models[add_namespace(item, "minecraft")].data.get("model", {})
             if model_compound["type"] == "minecraft:special": # uses some special handling
                 vanilla_model_path: str = model_compound["base"] # covers player_head use case. Others may not be handled properly yet.
+                special_model = True
             else:
                 vanilla_model_path: str = model_compound.get("model", "")
+                special_model = False
             m = models_container[model_name] = Model({
                 "parent": vanilla_model_path
             })
             ret_list.append(m)
-        self._item_def_map.update(dict(zip(config.item.entries(), model_def_entries)))
+            model_def_map[item] = {
+                "type": "minecraft:special" if special_model else "minecraft:model",
+                "model": model_compound["model"] if special_model else model_name
+            } | (
+                {"tints": t if (t:=model_compound.get("tints")) else {}}
+            )
+        self._item_def_map.update(model_def_map)
         return ret_list
 
     def get_item_def_entry(self, config: ModelData, item: str):
-        return 
+        return self._item_def_map.get(item)
+
+class AdvancementIconTemplate(VanillaTemplate, TemplateOptions): # TODO make this inheritance work properly. Treat as single-vanilla forward or create new where needed
+    name = "advancement"
+    forward: Optional[str]
+    tints: Optional[ListOption[int|tuple[float,float,float]]] # optional constant tints to apply to the item model
+
+    # NOTE since advancements are all in the gm4 namespace, so are these models. This template ignores the 'model' field of ModelData
+    def create_models(self, config: ModelData, models_container: NamespaceProxy[Model]) -> list[Model]:
+        advancement_name = config.reference.split("/")[-1]
+        if not self.forward:
+            item = config.item.entries()[0]
+            self.forward = self.vanilla_jar.assets.item_models[add_namespace(item, "minecraft")].data.get("model", {}).get("model", "") # type: ignore ; json access is string
+
+        m = models_container[f"gm4:gui/advancements/{advancement_name}"] = Model({
+            "parent": self.forward
+        })
+        config.model = MapOption(__root__={config.item.entries()[0]: f"gm4:gui/advancements/{advancement_name}"})
+        return [m]
+    
+    def get_item_def_entry(self, config: ModelData, item: str):
+        if self.tints:
+            return {
+                "type": "model",
+                "model": config.model.entries()[0],
+                "tints": [
+                    {
+                        "type": "minecraft:constant",
+                        "value": tint
+                    }
+                    for tint in self.tints.entries()
+                ]
+            }
+        return None
+    
+    def add_namespace(self, namespace: str):
+        return self.dict() | ({"forward": add_namespace(self.forward, namespace)} if self.forward else {})
 
 class BlockTemplate(TemplateOptions):
     name = "block"
@@ -938,7 +972,7 @@ def create_models(self, config: ModelData, models_container: NamespaceProxy[Mode
             }
         })
         return [m]
-
+    
 class ConditionTemplate(BlankTemplate, TemplateOptions):
     """Custom models using boolean condition variants (ie. broken/repaired elytra, cast/uncast fishing rods...)"""
     name = "condition"
@@ -964,45 +998,6 @@ def add_namespace(self, namespace: str):
         return self.dict() | {"on_true": add_namespace(self.on_true, namespace),
                               "on_false": add_namespace(self.on_false, namespace)}
 
-
-class AdvancementIconTemplate(TemplateOptions):
-    name = "advancement"
-    forward: Optional[str]
-    tints: Optional[ListOption[int|tuple[float,float,float]]] # optional constant tints to apply to the item model
-    vanilla: ClassVar[Vanilla] # mounted to by beet plugin since it requires context access
-    vanilla_jar: ClassVar[ClientJar]
-
-    # NOTE since advancements are all in the gm4 namespace, so are these models. This template ignores the 'model' field of ModelData
-    def create_models(self, config: ModelData, models_container: NamespaceProxy[Model]) -> list[Model]:
-        advancement_name = config.reference.split("/")[-1]
-        if not self.forward:
-            item = config.item.entries()[0]
-            self.forward = self.vanilla_jar.assets.item_models[add_namespace(item, "minecraft")].data.get("model", {}).get("model", "") # type: ignore ; json access is string
-
-        m = models_container[f"gm4:gui/advancements/{advancement_name}"] = Model({
-            "parent": self.forward
-        })
-        config.model = MapOption(__root__={config.item.entries()[0]: f"gm4:gui/advancements/{advancement_name}"})
-        return [m]
-    
-    def get_item_def_entry(self, config: ModelData, item: str):
-        if self.tints:
-            return {
-                "type": "model",
-                "model": config.model.entries()[0],
-                "tints": [
-                    {
-                        "type": "minecraft:constant",
-                        "value": tint
-                    }
-                    for tint in self.tints.entries()
-                ]
-            }
-        return None
-    
-    def add_namespace(self, namespace: str):
-        return self.dict() | ({"forward": add_namespace(self.forward, namespace)} if self.forward else {})
-
 class ItemDisplayModel(TransformOptions):
     """Calculates the model transform for an item_display entity, located at the specified origin, facing south, for the model to align with the block-grid"""
     origin: list[float] = Field(..., max_items=3, min_items=3)