l10n: 26w12a (FabricMC#533)

Co-authored-by: Fabric Bot <159731069+FabricMCBot@users.noreply.github.com>

Author: github-actions[bot]

translated/de_de/develop/blocks/block-containers.md

@@ -84,3 +84,7 @@ Außerdem sollten wir die Methode `useItemOn` von `DuplicatorBlock` ändern, um
 Wenn wir nun versuchen, Items von der Seite statt von oben einzufügen, funktioniert das nicht!
 
 <VideoPlayer src="/assets/develop/blocks/container_3.webm">Der Duplizierer wird nur aktiviert, wenn man mit seiner Oberseite interagiert.</VideoPlayer>
+
+## Menüs {#menus}
+
+Um über ein Menü auf den neuen Containerblock zuzugreifen, so wie du es bei einer Truhe tust, lies bitte den Leitfaden [Containermenüs](./container-menus).

translated/de_de/develop/blocks/container-menus.md

@@ -0,0 +1,92 @@
+---
+title: Containermenüs
+description: Ein Leitfaden, in der erklärt wird, wie man ein einfaches Menü für einen Containerblock erstellt.
+authors:
+  - Tenneb22
+---
+
+<!---->
+
+:::info VORAUSSETZUNGEN
+
+Du solltest zunächst den Abschnitt [Blockcontainer](./block-containers) lesen, um dich mit der Erstellung einer Containerblock-Entität vertraut zu machen.
+
+:::
+
+Wenn man einen Container, wie zum Beispiel eine Truhe, öffnet, sind hauptsächlich zwei Dinge erforderlich, um dessen Inhalt anzuzeigen:
+
+- ein `Screen`, der für das Rendering des Inhalts und des Hintergrunds auf dem Bildschirm zuständig ist.
+- ein `Menu`, das die Shift-Klick-Logik und die Synchronisation zwischen Server und Client handhabt.
+
+In diesem Leitfaden erstellen wir eine Erdkiste mit einem 3x3-Container, auf den man durch einen Rechtsklick und das Öffnen einer Oberfläche zugreifen kann.
+
+## Den Block erstellen {#creating-the-block}
+
+Zunächst möchten wir einen Block und eine Block-Entität erstellen; weitere Informationen findest du im Leitfaden [Blockcontainer](./block-containers#creating-the-block).
+
+@[code transcludeWith=:::block](@/reference/latest/src/main/java/com/example/docs/block/custom/DirtChestBlock.java)
+
+@[code transcludeWith=:::be](@/reference/latest/src/main/java/com/example/docs/block/entity/custom/DirtChestBlockEntity.java)
+
+::: info
+
+Da wir einen 3x3-Container wollen, müssen wir die Größe der Elemente auf 9 festlegen.
+
+:::
+
+### Das Menü öffnen {#opening-the-screen}
+
+Wir möchten das Menü irgendwie öffnen können, daher werden wir das innerhalb der Methode `useWithoutItem` umsetzen:
+
+@[code transcludeWith=:::use](@/reference/latest/src/main/java/com/example/docs/block/custom/DirtChestBlock.java)
+
+### Den MenuProvider implementieren {#implementing-menuprovider}
+
+Um die Menü-Funktionalität hinzuzufügen, müssen wir nun `MenuProvider` in der Block-Entität implementieren:
+
+@[code transcludeWith=:::menu](@/reference/latest/src/main/java/com/example/docs/block/entity/custom/DirtChestBlockEntity.java)
+
+Die Methode `getDisplayName` gibt den Namen des Blocks zurück, der oben auf der Oberfläche angezeigt wird.
+
+## Das Menü erstellen {#creating-the-menu}
+
+`createMenu` erwartet, dass wir ein Menü zurückgeben, aber wir haben noch keines für unseren Block erstellt. Um dies zu tun, werden wir eine Klasse `DirtChestMenu` erstellen, welche von `AbstractContainerMenu` erbt:
+
+@[code transcludeWith=:::menu](@/reference/latest/src/main/java/com/example/docs/menu/custom/DirtChestMenu.java)
+
+Der clientseitige Konstruktor wird auf dem Client aufgerufen, wenn der Server möchte, dass dort ein Menü geöffnet wird. Es erstellt einen leeren Container, der dann automatisch mit dem tatsächlichen Container auf dem Server synchronisiert wird.
+
+Der serverseitige Konstruktor wird auf dem Server aufgerufen, und da er den Inhalt des Containers kennt, kann er diesen direkt als Argument übergeben.
+
+`quickMoveStack` übernimmt den Shift-Klick auf Items innerhalb des Menüs. Dieses Beispiel bildet das Verhalten von Vanilla Menüs wie Truhen und Spendern nach.
+
+Zuerst müssen wir das Menü in einer neuen Klasse `ModMenuType` registrieren:
+
+@[code transcludeWith=:::registerMenu](@/reference/latest/src/main/java/com/example/docs/menu/ModMenuType.java)
+
+Wir können jetzt den Rückgabewert von `createMenu` in der Block-Entität setzen, um unser Menü zu verwenden:
+
+@[code transcludeWith=:::providerImplemented](@/reference/latest/src/main/java/com/example/docs/block/entity/custom/DirtChestBlockEntity.java)
+
+::: info
+
+Die Methode `createMenu` wird nur auf dem Server aufgerufen, daher rufen wir den serverseitigen Konstruktor auf und übergeben `this` (die Block-Entität) als Container-Parameter.
+
+:::
+
+## Die Oberfläche erstellen {#creating-the-screen}
+
+Um tatsächlich den Inhalt des Containers auf dem Client anzuzeigen, müssen wir außerdem eine Oberfläche für unser Menü erstellen.
+Wir werden eine neue Klasse erstellen, welche von `AbstractContainerScreen` erbt:
+
+@[code transcludeWith=:::screen](@/reference/latest/src/client/java/com/example/docs/rendering/screens/inventory/DirtChestScreen.java)
+
+Als Hintergrund für diese Oberfläche verwenden wir einfach die Standardtextur der Werfer-Oberfläche, da unsere Erdkiste dasselbe Slot-Layout verwendet. Du könntest alternativ deine eigene Textur für `CONTAINER_TEXTURE` bereitstellen.
+
+Da es sich hierbei um eine Oberfläche für ein Menü handelt, müssen wir es außerdem auf dem Client mit der Methode `MenuScreens#register()` registrieren:
+
+@[code transcludeWith=:::registerScreens](@/reference/latest/src/client/java/com/example/docs/ExampleModScreens.java)
+
+Wenn du dein Spiel geladen hast, solltest du nun eine Erdkiste haben, die du mit einem Rechtsklick öffnen kannst, um ein Menü aufzurufen und Items darin zu verstauen.
+
+![Menü einer Erdkiste im Spiel](/assets/develop/blocks/container_menus_0.png)

translated/de_de/develop/data-generation/translations.md

@@ -39,7 +39,7 @@ Um die Einrichtung abzuschließen, füge den Provider zu deinem `DataGeneratorEn
 
 ## Erstellen von Übersetzungen {#creating-translations}
 
-Neben der Erstellung von Rohübersetzungen, Übersetzungen aus einem `Identifier` und dem Kopieren aus einer bereits existierenden Datei (durch die Übergabe eines `Path`), gibt es Hilfsmethoden für die Übersetzung von Items, Blöcken, Tags, Statistiken, Entitäten, Statuseffekten, Kreativtabs, Entitätsattributen und Verzauberungen. Rufe einfach `add` beim `translationBuilder` auf und gebe an, was du übersetzen willst und in zu was es übersetzt werden soll:
+Neben der Erstellung von Rohübersetzungen, Übersetzungen aus einem `Identifier`en und dem Kopieren aus einer bereits existierenden Datei (durch die Übergabe eines `Path`), gibt es Hilfsmethoden für die Übersetzung von Items, Blöcken, Tags, Statistiken, Entitäten, Mobeffekten, Kreativtabs, Entitätsattributen und Verzauberungen. Rufe einfach `add` beim `translationBuilder` auf und gebe an, was du übersetzen willst und in zu was es übersetzt werden soll:
 
 @[code lang=java transcludeWith=:::datagen-translations:build](@/reference/latest/src/client/java/com/example/docs/datagen/ExampleModEnglishLangProvider.java)
 

translated/de_de/develop/entities/effects.md

@@ -67,8 +67,7 @@ effect give @p example-mod:tater
 
 :::
 
-Um einen Effekt intern anzuwenden, sollte man die Methode `LivingEntity#addEffect` verwenden, die eine
-eine `MobEffectInstance` entgegennimmt und einen boolean zurückgibt, der angibt, ob der Effekt erfolgreich angewendet wurde.
+Um einen Effekt intern anzuwenden, solltest du die Methode `LivingEntity#addEffect` verwenden, die eine `MobEffectInstance` entgegennimmt und einen boolean zurückgibt, der angibt, ob der Effekt erfolgreich angewendet wurde.
 
 @[code lang=java transcludeWith=:::1](@/reference/latest/src/main/java/com/example/docs/ReferenceMethods.java)
 

translated/de_de/develop/game-rules.md

@@ -0,0 +1,81 @@
+---
+title: Spielregeln
+description: Ein Leitfaden zum Hinzufügen benutzerdefinierter Spielregeln.
+authors:
+  - cassiancc
+  - Jummit
+  - modmuss50
+  - Wind292
+authors-nogithub:
+  - mysterious_dev
+  - solacekairos
+---
+
+<!---->
+
+:::info VORAUSSETZUNGEN
+
+Möglicherweise möchtest du zunächst die [Generierung von Übersetzungen](./data-generation/translations) abschließen, dies ist jedoch nicht erforderlich.
+
+:::
+
+Spielregeln verhalten sich wie weltenspezifische Konfigurationsoptionen, die der Spieler während des Spiels mit einem Befehl ändern kann. Diese Variablen steuern in der Regel bestimmte Funktionen der Welt, zum Beispiel steuern `pvp`, `spawn_monsters` und `advance_time`, ob PvP aktiviert ist, Monster erscheinen und ob die Zeit verstreicht.
+
+## Eine Spielregel erstellen {#creating-a-game-rule}
+
+Um eine benutzerdefinierte Spielregel zu erstellen, erstelle zunächst eine Klasse `GameRules`; dort werden wir unsere Spielregeln definieren. In dieser Klasse, deklariere zwei Konstanten: Eine Bezeichnung für die Spielregel und die Regel selbst.
+
+@[code lang=java transcludeWith=:::gameruleClass](@/reference/latest/src/main/java/com/example/docs/gamerule/ExampleModGameRules.java)
+
+Das Argument der Kategorie (`.category(GameRuleCategory.MISC)`) legt fest, unter welche Kategorie die Spielregel in der Oberfläche zur Welterstellung fällt. Dieses Beispiel verwendet die durch Vanilla bereitgestellte Kategorie Verschiedenes, aber zusätzliche Kategorien können über `GameRuleCategory.register` hinzugefügt werden. In diesem Beispiel haben wir eine boolsche Spielregel mit dem Standardwert `false` und der ID `bad_vision` erstellt. Die in Spielregeln gespeicherten Werte sind nicht auf boolesche Werte beschränkt; weitere zulässige Typen sind `Double`s, `Integer`s und `Enum`s.
+
+Beispiel einer Spielregel, die einen double speichert:
+
+@[code lang=java transcludeWith=:::double](@/reference/latest/src/main/java/com/example/docs/gamerule/ExampleModGameRules.java)
+
+## Auf eine Spielregel zugreifen {#accessing-a-game-rule}
+
+Da wir jetzt eine Spielregel und deren `Identifier` haben, kannst du überall mit der Methode `serverLevel.getGameRules().get(GAMERULE)` darauf zugreifen, wobei das Argument für `.get()` deine Spielregelkonstante ist und nicht die ID der Spielregel.
+
+@[code lang=java transclude={44-44}](@/reference/latest/src/main/java/com/example/docs/gamerule/ExampleModGameRules.java)
+
+Du kannst dies auch verwenden, um auf die Werte von Vanilla Spielregeln zuzugreifen:
+
+@[code lang=java transcludeWith=:::vanilla](@/reference/latest/src/main/java/com/example/docs/gamerule/ExampleModGameRules.java)
+
+Beispielsweise würde die Implementierung für eine Regel, die bei dem Wert true allen Spielern Blindheit gibt, wie folgt aussehen:
+
+@[code lang=java transcludeWith=:::badvision](@/reference/latest/src/main/java/com/example/docs/gamerule/ExampleModGameRules.java)
+
+## Übersetzungen {#translations}
+
+Jetzt müssen wir unserer Spielregel einen Anzeigenamen geben, damit sie in der Oberfläche für Spielregeln leicht verständlich ist. Um dies über die Datengenerierung zu erledigen, füge die folgenden Zeilen zu deinem Sprach-Provider hinzu:
+
+@[code lang=java transcludeWith=:::gamerule-name](@/reference/latest/src/client/java/com/example/docs/datagen/ExampleModEnglishLangProvider.java)
+
+Zuletzt müssen wir unserer Spielregel eine Beschreibung hinzufügen. Um dies über die Datengenerierung zu erledigen, füge die folgenden Zeilen zu deinem Sprach-Provider hinzu:
+
+@[code lang=java transcludeWith=:::gamerule-description](@/reference/latest/src/client/java/com/example/docs/datagen/ExampleModEnglishLangProvider.java)
+
+::: info
+
+Diese Übersetzungsschlüssel werden bei der Anzeige von Text in der Oberfläche für Spielregeln verwendet. Wenn du die automatische Datengenerierung nicht verwendest, kannst du diese auch manuell in deiner Datei `assets/example-mod/lang/en_us.json` eintragen.
+
+```json
+"example-mod.bad_vision": "Bad Vision",
+"gamerule.example-mod.bad_vision": "Gives every player the blindness effect",
+```
+
+:::
+
+## Spielregeln im Spiel ändern {#changing-game-rules-in-game}
+
+Jetzt solltest du in der Lage sein, den Wert deiner Regel im Spiel mit dem Befehl `/gamerule` wie folgt zu ändern:
+
+```mcfunction
+/gamerule example-mod:bad_vision true
+```
+
+Die Spielregel wird nun auch in der Kategorie Verschiedenes in der Oberfläche Spielregeln bearbeiten angezeigt.
+
+![Die Oberfläche zur Welterstellung mit der Spielregel Bad Vision](/assets/develop/game-rules/world-creation.png)

translated/de_de/develop/getting-started/vscode/tips-and-tricks.md

@@ -9,7 +9,7 @@ prev:
 next: false
 ---
 
-Es ist wichtig zu lernen, wie man die Generierung des Quellcodes durchläuft, damit du debuggen und ein Verständnis für die inneren Abläufe von Minecraft entwickeln kannst. Hier beschreiben wir einige gängige Anwendungen der Entwicklungsumgebung.
+Es ist wichtig zu lernen, wie man die generierten Quellen durchläuft, damit man Debuggen und ein Verständnis für die inneren Abläufe von Minecraft entwickeln kann. Hier beschreiben wir einige gängige Anwendungen der Entwicklungsumgebung.
 
 ## Nach einer Minecraft-Klasse suchen {#searching-for-a-minecraft-class}
 

translated/de_de/develop/items/food.md

@@ -33,7 +33,7 @@ Die Klasse `FoodProperties.Builder` hat einige Methoden, mit denen du ändern ka
 
 Wenn du den Builder nach deinen Wünschen verändert hast, kannst du die Methode `build()` aufrufen, um den `FoodProperties` zu erhalten.
 
-Wenn du dem Spieler Statuseffekte hinzufügen möchtest, wenn er dein Essen isst, musst du die Klasse `Consumable` neben der Klasse `FoodProperties` verwenden, wie im folgenden Beispiel zu sehen ist:
+Wenn du dem Spieler Mobeffekte hinzufügen möchtest, wenn er dein Essen isst, musst du die Komponente `Consumable` neben der Komponente `FoodProperties` hinzufügen, wie im folgenden Beispiel zu sehen ist:
 
 @[code transcludeWith=:::5](@/reference/latest/src/main/java/com/example/docs/item/ModItems.java)
 

translated/de_de/develop/loom/tasks.md

@@ -63,9 +63,9 @@ tasks.register("enigma", net.fabricmc.loom.task.tool.ModEnigmaTask) {
 Der `net.fabricmc.loom.task.ValidateMixinNameTask` ist eine Aufgabe, die verwendet werden kann, um zu überprüfen, ob der Name der Mixin-Klasse mit dem Namen der Zielklasse übereinstimmt.
 
 ```groovy
-    tasks.register('validateMixinNames', net.fabricmc.loom.task.ValidateMixinNameTask) {
-        source(sourceSets.main.output)
-    }
+tasks.register('validateMixinNames', net.fabricmc.loom.task.ValidateMixinNameTask) {
+    source(sourceSets.main.output)
+}
 
-    check.dependsOn "validateMixinNames"
+check.dependsOn "validateMixinNames"
 ```

translated/de_de/develop/networking.md

@@ -89,7 +89,7 @@ Eine ähnliche Methode existiert, um Client-to-Server Payloads zu registrieren:
 
 ### Senden eines Pakets an den Client {#sending-a-packet-to-the-client}
 
-Um ein Paket mit unserem benutzerdefinierten Payload zu senden, können wir `ServerPlayNetworking.send` verwenden, das eine `ServerPlayerEntity` und einen `CustomPayload` entgegennimmt.
+Um ein Paket mit unserem benutzerdefinierten Payload zu senden, können wir `ServerPlayNetworking.send` verwenden, das einen `ServerPlayer` und einen `CustomPayload` entgegennimmt.
 
 Beginnen wir mit der Erstellung unseres Blitz-Kartoffel-Item. Du kannst `use` überschreiben, um eine Aktion auszulösen, wenn das Item verwendet wird.
 In diesem Fall, lasst uns Pakete an die Spieler in den Serverlevel senden.

translated/de_de/sidebar_translations.json

@@ -28,6 +28,7 @@
   "develop.blocks.block_entities": "Block Entitäten",
   "develop.blocks.block_entity_renderer": "Block Entität Renderer",
   "develop.blocks.block_containers": "Blockcontainer",
+  "develop.blocks.container_menus": "Containermenüs",
   "develop.blocks.transparency_and_tinting": "Transparenz und Färbung",
   "develop.entities": "Entitäten",
   "develop.entities.effects": "Mobeffekte",
@@ -71,6 +72,7 @@
   "develop.misc.codecs": "Codecs",
   "develop.misc.data_attachments": "Datenanhänge",
   "develop.misc.events": "Events",
+  "develop.misc.game_rules": "Spielregeln",
   "develop.misc.networking": "Networking",
   "develop.misc.key_mappings": "Tastenbelegung",
   "develop.misc.saved_data": "Gespeicherte Daten",