InexactCIT

Restoring pattern-based conditional item models.

Purpose

The Custom Item Textures (CIT) mod, originally part of McPatcher and then Optifine, allowed the replacement of item textures (and models) whose metadata matched inexact patterns. We now have near-equivalent item-texture replacement in standard Minecraft with conditional client item types, though inexact matching is no longer possible. This mod adds CIT replacement with regular expressions to the new standard conditional item definition system.

Compatibility and Dependencies

• Minecraft: 1.21.8
• Loader: Fabric 0.136.1

Fabric API not required.

Installation

Add the mod JAR to your Fabric mods folder.

Usage (Players)

This mod adds a feature to item model definitions which can be used by resource pack designers. It is always active when the mod is installed.

Resource Pack Integration (Pack Authors)

The JSON files found at assets/minecraft/item are item definitions. These are not necessarily the model file used to render an item (i.e. an item model), which are found at assets/minecraft/models/item.

In an item definition file, the JSON object in the "model" field determines which model file is used to render an item. Typically, a single item type is always rendered with the same model, so this object has its "type" set to minecraft:model. But different models can be used for the same item in different contexts by using "model" objects with other types, such as minecraft:condition and minecraft:select.

This mod adds the inexactcit:match item definition model type. It is similar to the built-in select type in that it contains a list of models with associated conditions, and when one condition matches, its associated model is used to render the item. Unlike Select, the Match conditions are potentially-inexact regular expressions.

Match item definition models use the same fields as Select, particularly "property", "component", "cases", and "fallback".

Labeled Field Structure

    { "model":
      { "type": "inexactcit:match"
      , "property":  ...     # Probably always minecraft:component
      , "component": ...     # Name of component to target
      , "cases":
        [ { "regex": ...     # Regular expression for this case
          , "model": { ... } # Item def'n. model used when regexp matches
          }
        , ...                # Another case, as above
        , ...                # Any number of additional cases
        ]
      , "fallback": { ... }  # Item def'n. model used when no case matches
      }
    }

Required Fields

Regular expression matching is intended for text metadata, so the "property" field will be minecraft:component. Behavior when "property" is not minecraft:component is as yet untested.

The "component" field should be set to the namespaced ID for the component that will be tested by the condition, e.g. minecraft:lore, minecraft:custom_name.

The "cases" field must contain a list of JSON objects. Each object is to contain a "regex" field and corresponding "model" field. These must be a (Java-flavored) regular expression and an item definition model, respectively. When the regular expression matches against the contents of the component named in the "component" field, the corresponding model is used for that item.

The "fallback" field gives a model that is used when none of the "case" objects match, same as the standard Select.

Example

The following is an example of a Match item definition. It replaces all wooden hoes whose names include the word "Quarterstaff" with the model at pixelatedvolume:item/quarterstaff.

    { "model":
      { "type": "inexactcit:match"
      , "property": "minecraft:component"
      , "component": "minecraft:custom_name"
      , "cases":
        [ { "model":
            { "model": "pixelatedvolume:item/quarterstaff"
            , "type": "minecraft:model"
            }
          , "regex": ".*Quarterstaff.*"
          }
        ]
      , "fallback":
        { "model": "minecraft:item/wooden_hoe"
        , "type": "minecraft:model"
        }
      }
      , "oversized_in_gui": true
    }

Text Comparison

The contents of the field being examined is serialized with toString. Text-component (JSON) features, section-code formatting, etc, is all pushed into this comparison string, so there is no way of telling what might come before or after the text that is visible in-game, or what happens between lines of multiline compontents.

Regular Expression or Model Errors

An item definition file with a malformed regular expression cannot be read so the item will appear with the default model (margenta-and-black cube). The failure (with the faulty file) is logged as an Error at pack-load time.

Multiple Target Components

To give one item multiple replacement rules that use different components (e.g. one set of rules for lore and one set for custom_name), set the fallback model to a new Match client item model that selects the second component.

Status

The ability to match properties other than minecraft:component will be added eventually. Currently, such matches are accepted without error, but they have no effect.