Ressourcenbedingungen 26.1.2

Ein Leitfaden, wie du das Laden der Daten deines Mods bedingt zulassen kannst.

Bei der Entwicklung von Integrationen mit anderen Mods ist es häufig erforderlich, festzulegen, wann die Ressourcen des eigenen Mods geladen werden sollen. Aus diesem Grund bietet die Fabric-API Ressourcenbedingungen an.

Standardmäßig kann diese API mit Rezepten, Fortschritten, Beutetabellen, Prädikaten und Itemmodifikatoren verwendet werden.

Ressourcenbedingungen können entweder über die Datengenerierung oder über manuelles Schreiben von JSON hinzugefügt werden. Weitere Informationen zum Hinzufügen von Ressourcenbedingungen über die Datengenerierung findest du in der Dokumentation zur Datengenerierung.

Die Ladebedingungen werden an den Anfang einer JSON-Datei eingefügt.

Ein Rezept mit einer Bedingung, die dafür sorgt, dass es nur geladen wird, wenn ein Tag gefüllt ist.

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:tags_populated",
      "registry": "minecraft:item",
      "values": [
        "minecraft:dirt"
      ]
    }
  ],
  "type": "minecraft:crafting_shapeless",
  "category": "building",
  "ingredients": [
    "#minecraft:sand"
  ],
  "result": {
    "id": "minecraft:sand"
  }
}

Eingebaute Bedingungen

Die Fabric-API bietet neun integrierte Bedingungen, die du in deinem Mod verwenden kannst.

Operatoren

Dies sind die gewöhnlichen Booleschen Operatoren.

Wahr

Ist immer erfolgreich:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:true"
    }
  ]
}

Falsch

Schlägt immer fehl:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:false"
    }
  ]
}

Nicht

Kehrt die in value angegebene Ladebedingung um. Beispielsweise schlägt Folgendes fehl:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:not",
      "value": {
        "condition": "fabric:true"
      }
    }
  ]
}

Oder

Erfolgreich, wenn mindestens eine der Bedingungen in values erfüllt ist. Beispielsweise ist Folgendes erfolgreich:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:or",
      "values": [
        {
          "condition": "fabric:true"
        },
        {
          "condition": "fabric:not",
          "value": {
            "condition": "fabric:true"
          }
        }
      ]
    }
  ]
}

Und

Erfolgreich, wenn alle Bedingungen in values erfüllt sind. Beispielsweise schlägt Folgendes fehl:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:and",
      "values": [
        {
          "condition": "fabric:true"
        },
        {
          "condition": "fabric:not",
          "value": {
            "condition": "fabric:true"
          }
        }
      ]
    }
  ]
}

Alle Mods geladen

Erfolgreich, wenn alle Mods in values geladen sind. Beispielsweise ist das Folgende nur erfolgreich, wenn sowohl example-mod als auch another-mod geladen sind:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:all_mods_loaded",
      "values": [
        "example-mod",
        "another-mod"
      ]
    }
  ]
}

Irgendwelche Mods geladen

Erfolgreich, wenn mindestens einer der Mods in values geladen ist. Beispielsweise ist Folgendes erfolgreich, wenn entweder example-mod oder another-mod oder beide geladen sind:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:any_mods_loaded",
      "values": [
        "example-mod",
        "another-mod"
      ]
    }
  ]
}

Tags gefüllt

Erfolgreich, wenn die angegebene registry alle Tags in values enthält. Beispielsweise ist Folgendes erfolgreich, wenn das Item-Tag example-mod:smelly_items geladen ist:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:tags_populated",
      "registry": "minecraft:item",
      "values": [
        "example-mod:smelly_items"
      ]
    }
  ]
}

Aktivierte Funktionen

Ist erfolgreich, wenn alle Funktions-Flags in features aktiviert sind. Beispielsweise ist Folgendes erfolgreich, wenn sowohl minecraft:vanilla als auch minecraft:redstone_experiments aktiviert sind:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:features_enabled",
      "features": [
        "minecraft:vanilla",
        "minecraft:minecart_improvements"
      ]
    }
  ]
}

Die Registry enthält

Ist erfolgreich, wenn die Registry alle Bezeichner in values enthält. Beispielsweise ist Folgendes erfolgreich, wenn minecraft:cobblestone in der Registry vorhanden ist:

{
  "fabric:load_conditions": [
    {
      "condition": "fabric:registry_contains",
      "registry": "minecraft:block",
      "values": [
        "minecraft:cobblestone"
      ]
    }
  ]
}

Benutzerdefinierte Bedingungen

VORAUSSETZUNGEN

Bevor du eine benutzerdefinierte Ressourcenbedingung festlegst, musst du zunächst verstehen, wie man einen Codec erstellt.

Die Fabric-API bietet zudem die Flexibilität, eigene Ressourcenbedingungen zu definieren.

Um dies zu veranschaulichen, werden wir eine Bedingung erstellen, die das aktuelle Datum überprüft. Dies könnte für besonderes Verhalten an Feiertagen wie Halloween oder Aprilscherze genutzt werden.

Deine Bedingungen vorbereiten

Der Einfachheit halber erstellen wir eine Hilfsmethode, die deine Ressourcenbedingung anhand eines Namens und eines MapCodec instanziiert. Du solltest diese Methode in eine Klasse mit dem Namen ModResourceConditions (oder wie auch immer du sie nennen willst) einfügen.

TIP

Fabric macht das mit seinen eingebauten Bedingungen genauso; in der Klasse DefaultResourceConditionTypes kannst du dir dies in der Aktion ansehen.

public class ModResourceConditions {
	private static <T extends ResourceCondition> ResourceConditionType<T> createResourceConditionType(String name, MapCodec<T> codec) {
		return ResourceConditionType.create(Identifier.fromNamespaceAndPath(ExampleMod.MOD_ID, name), codec);
	}
}

Eine Bedingungen erstellen

Eine Ressourcenbedingung besteht aus drei Teilen:

• Einen Konstruktor, der Werte akzeptiert.
• Ein MapCodec, um diese Werte zu serialisieren.
• Eine Methode test, die anhand der Werte ermittelt, ob die Bedingung erfüllt sein sollte.

Wir werden eine neue Klasse für die Ressourcenbedingung mit dem Namen DateMatchesResourceCondition erstellen. Erstelle zuerst einen neuen record, der einen int-Wert für den Monat und einen int-Wert für den Tag akzeptiert:

public record DateMatchesResourceCondition(int month, int day) implements ResourceCondition {
}

Füge als Nächstes einen MapCodec hinzu, der die vom Konstruktor akzeptierten Werte widerspiegelt:

public static final MapCodec<DateMatchesResourceCondition> CODEC = RecordCodecBuilder.<DateMatchesResourceCondition>mapCodec(instance -> instance.group(
		ExtraCodecs.POSITIVE_INT.fieldOf("month").forGetter(DateMatchesResourceCondition::month),
		ExtraCodecs.POSITIVE_INT.fieldOf("day").forGetter(DateMatchesResourceCondition::day)
).apply(instance, DateMatchesResourceCondition::new)).validate(DateMatchesResourceCondition::validate);

Was ist validate?

Dieser Codec verwendet die Methode .validate, um sicherzustellen, dass das angegebene Datum existieren kann, wobei er die Logik einer ebenfalls validate genannten Hilfsmethode verwendet:

private static DataResult<DateMatchesResourceCondition> validate(DateMatchesResourceCondition o) {
	try {
		MonthDay.of(o.month(), o.day());
	} catch (DateTimeException e) {
		return DataResult.error(e::getMessage);
	}

	return DataResult.success(o);
}

Dies ist nur für genau dieses Beispiel relevant.

Als Nächstes fügen wir eine Methode test hinzu, die das aktuelle Datum überprüft. Dieses Beispiel basiert auf der Logik aus Vanilla selbst, in SpecialDates.

@Override
public boolean test(RegistryOps.@Nullable RegistryInfoLookup registryInfo) {
	var monthDay = MonthDay.of(this.month, this.day);
	return SpecialDates.dayNow().equals(monthDay);
}

Deine Bedingung registrieren

Zurück in ModResourceConditions können wir unsere Ressourcenbedingung jetzt registrieren:

public static final ResourceConditionType<DateMatchesResourceCondition> DATE_MATCHES =
		createResourceConditionType("date_matches", DateMatchesResourceCondition.CODEC);

public static void register() {
	ResourceConditions.register(DATE_MATCHES);
}

Auf diese Bedingungsart kann dann auch von DateMatchesResourceCondition aus verwiesen werden:

@Override
public ResourceConditionType<?> getType() {
	return ModResourceConditions.DATE_MATCHES;
}

Stelle sicher ModResourceConditions.register in deinem Mod-Initialisierer aufzurufen:

public class ExampleModResourceConditions implements ModInitializer {
	@Override
	public void onInitialize() {
		ModResourceConditions.register();
	}
}

Deine Bedingung verwenden

Jetzt haben wir eine Bedingung, die erfüllt ist, wenn das Systemdatum mit dem in der Ressourcenbedingung angegebenen Datum übereinstimmt. Diese Bedingung wird beispielsweise nur zu Aprilscherzen erfüllt:

{
  "fabric:load_conditions": [
    {
      "condition": "example-mod:date_matches",
      "day": 1,
      "month": 4
    }
  ]
}