Willkommen, liebe Minecraft-Enthusiasten und angehende Modder! In diesem ultimativen Guide tauchen wir tief in die Welt von Minecraft Fabric 1.21.5 ein und lernen, wie man eine einfache, aber dennoch coole Funktion implementiert: das Zeichnen einer diagonalen Linie im Spiel. Ob für dekorative Zwecke, zur Wegfindung oder einfach nur zum Spaß, die Möglichkeit, Linien zu ziehen, eröffnet unzählige neue Möglichkeiten für deine Mods. Keine Sorge, wir führen dich Schritt für Schritt durch den Prozess, auch wenn du noch neu im Modding bist. Legen wir los!
Was du benötigst
Bevor wir loslegen, stelle sicher, dass du folgende Voraussetzungen erfüllst:
- Eine installierte Version von Minecraft 1.21.5.
- Die neueste Version von Fabric Loader und Fabric API.
- Eine IDE (Integrierte Entwicklungsumgebung) wie IntelliJ IDEA oder Eclipse.
- Grundlegende Kenntnisse in Java.
- Ein Verständnis der Minecraft-Modding-Grundlagen (falls du ein Anfänger bist, gibt es viele großartige Tutorials online!).
Projekt aufsetzen: Dein erstes Fabric Mod
Falls du noch kein Fabric-Mod-Projekt hast, müssen wir eines erstellen. Folge diesen Schritten:
- Erstelle ein neues Java-Projekt in deiner IDE.
- Füge Fabric API als Abhängigkeit hinzu. Dies geschieht in der Regel über dein Build-Tool (z.B. Gradle oder Maven). Überprüfe die Fabric-Dokumentation für die genauen Abhängigkeits-Definitionen für deine IDE und dein Build-System.
- Erstelle eine `fabric.mod.json`-Datei im Stammverzeichnis deines Projekts. Diese Datei enthält Metadaten über deine Mod, wie z.B. den Namen, die ID und die unterstützten Minecraft-Versionen. Hier ist ein Beispiel:
{
"schemaVersion": 1,
"id": "diagonalline",
"version": "${version}",
"name": "Diagonal Line Mod",
"description": "Adds the ability to draw diagonal lines in Minecraft.",
"authors": [
"YourName"
],
"contact": {
"homepage": "https://example.com/",
"sources": "https://github.com/YourGithub/DiagonalLineMod"
},
"license": "MIT",
"icon": "assets/diagonalline/icon.png",
"environment": "*",
"entrypoints": {
"main": [
"com.example.diagonalline.DiagonalLineMod"
]
},
"mixins": [
"diagonalline.mixins.json"
],
"depends": {
"fabricloader": ">=0.14.0",
"fabric-api": "*",
"minecraft": "~1.21.5"
},
"suggests": {
"another-mod": "*"
}
}
- Erstelle eine Hauptklasse (z.B. `com.example.diagonalline.DiagonalLineMod`), die das `ModInitializer`-Interface implementiert. Diese Klasse enthält den Code, der beim Laden deiner Mod ausgeführt wird.
package com.example.diagonalline;
import net.fabricmc.api.ModInitializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DiagonalLineMod implements ModInitializer {
public static final String MOD_ID = "diagonalline";
public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
@Override
public void onInitialize() {
LOGGER.info("Diagonal Line Mod initializing!");
// Hier kommt später unser Code zum Zeichnen der Linie hin.
}
}
Den Code schreiben: Die diagonale Linie zeichnen
Nun zum spannenden Teil: dem Code! Wir werden eine einfache Möglichkeit verwenden, eine diagonale Linie zu zeichnen, indem wir Blöcke zwischen zwei Punkten platzieren. Dafür nutzen wir ein einfaches Algorithmus, der die X- und Z-Koordinaten schrittweise verändert. Wir werden dies an einen Befehl knüpfen, den der Spieler im Spiel eingeben kann.
- Befehl registrieren: Wir verwenden die Fabric Command API, um einen neuen Befehl zu registrieren. Dieser Befehl nimmt zwei Koordinaten (x1, z1, x2, z2) als Argumente entgegen, die die Endpunkte der Linie definieren.
package com.example.diagonalline;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.arguments.IntegerArgumentType;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.minecraft.server.command.CommandManager;
import net.minecraft.server.command.ServerCommandSource;
import net.minecraft.text.Text;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.block.Blocks;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DiagonalLineMod implements ModInitializer {
public static final String MOD_ID = "diagonalline";
public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
@Override
public void onInitialize() {
LOGGER.info("Diagonal Line Mod initializing!");
CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
dispatcher.register(CommandManager.literal("drawdiagonal")
.requires(source -> source.hasPermissionLevel(2)) //Benötigt Operator-Rechte
.then(CommandManager.argument("x1", IntegerArgumentType.integer())
.then(CommandManager.argument("z1", IntegerArgumentType.integer())
.then(CommandManager.argument("x2", IntegerArgumentType.integer())
.then(CommandManager.argument("z2", IntegerArgumentType.integer())
.executes(context -> {
int x1 = IntegerArgumentType.getInteger(context, "x1");
int z1 = IntegerArgumentType.getInteger(context, "z1");
int x2 = IntegerArgumentType.getInteger(context, "x2");
int z2 = IntegerArgumentType.getInteger(context, "z2");
ServerCommandSource source = context.getSource();
BlockPos pos = source.getBlockPos();
World world = source.getWorld();
int y = pos.getY(); // Höhe des Spielers verwenden
drawDiagonalLine(world, x1, y, z1, x2, y, z2);
source.sendFeedback(() -> Text.literal("Diagonale Linie gezeichnet!"), false);
return 1;
})
)
)
)
)
);
});
}
private void drawDiagonalLine(World world, int x1, int y1, int z1, int x2, int y2, int z2) {
int dx = Math.abs(x2 - x1);
int dz = Math.abs(z2 - z1);
int sx = x1 < x2 ? 1 : -1;
int sz = z1 -dz) {
err -= dz;
x1 += sx;
}
if (e2 < dx) {
err += dx;
z1 += sz;
}
}
}
}
- Die `drawDiagonalLine`-Methode: Diese Methode implementiert den Bresenham-Algorithmus (oder eine vereinfachte Variante), um die Blöcke entlang der diagonalen Linie zu platzieren. Der Algorithmus wählt die Blöcke aus, die der idealen Linie am nächsten liegen. Wir verwenden hier `Blocks.DIAMOND_BLOCK`, du kannst dies aber nach Belieben ändern.
- Bauen und Testen: Baue dein Mod-Projekt mit deinem Build-Tool (z.B. `./gradlew build`). Kopiere die resultierende JAR-Datei in den `mods`-Ordner deiner Minecraft-Installation.
- Starte Minecraft: Starte Minecraft mit dem Fabric-Profil. Gehe in eine Welt (im Kreativmodus) und öffne die Konsole.
- Befehl ausführen: Gib den Befehl `/drawdiagonal x1 z1 x2 z2` ein, wobei du `x1`, `z1`, `x2` und `z2` durch die gewünschten Koordinaten ersetzt. Zum Beispiel: `/drawdiagonal 10 10 20 20`.
- Ergebnis: Du solltest nun eine diagonale Linie aus Diamantblöcken zwischen den angegebenen Koordinaten sehen!
Erklärungen zum Code
- Command Registration: Der Code registriert den neuen Befehl „drawdiagonal” mit der Fabric Command API. Der Befehl erfordert Operator-Rechte (permission level 2), um Missbrauch zu verhindern.
- Argumente: Der Befehl nimmt vier Integer-Argumente entgegen: x1, z1, x2 und z2. Diese Argumente definieren die Start- und Endkoordinaten der diagonalen Linie.
- Bresenham-Algorithmus (vereinfacht): Die `drawDiagonalLine`-Methode implementiert eine vereinfachte Version des Bresenham-Algorithmus. Dieser Algorithmus bestimmt, welche Blöcke am besten eine gerade Linie zwischen zwei Punkten annähern. Er ist effizient und vermeidet die Verwendung von Gleitkommazahlen.
- Blockplatzierung: Innerhalb der `drawDiagonalLine`-Methode wird für jede Koordinate auf der Linie ein Diamantblock platziert. Du kannst den Blocktyp leicht ändern, indem du `Blocks.DIAMOND_BLOCK` durch einen anderen Blocktyp aus der `Blocks`-Klasse ersetzt.
- Fehlerbehandlung: Dieser einfache Code hat keine explizite Fehlerbehandlung. In einer produktionsreifen Mod solltest du Eingabeprüfungen hinzufügen, um sicherzustellen, dass die Koordinaten gültig sind und nicht außerhalb des Weltbereichs liegen.
Verbesserungen und Erweiterungen
Dies ist nur der Anfang! Hier sind einige Ideen, wie du deine Mod verbessern kannst:
- Blockauswahl: Erlaube dem Benutzer, den Blocktyp für die Linie anzugeben (z.B. über ein weiteres Befehlsargument).
- 3D-Linien: Erweitere den Code, um 3D-Linien zu unterstützen (füge ein y1 und y2 Argument hinzu).
- Linienstärke: Füge eine Option hinzu, um die Dicke der Linie zu steuern.
- Muster: Implementiere verschiedene Muster für die Linie (z.B. eine gepunktete Linie).
- Benutzeroberfläche: Erstelle eine grafische Benutzeroberfläche (GUI) für die Linienzeichnung.
Fazit
Herzlichen Glückwunsch! Du hast erfolgreich eine diagonale Linie in Minecraft Fabric 1.21.5 codiert. Dieses einfache Projekt ist ein großartiger Einstieg in die Welt des Minecraft-Moddings. Experimentiere mit den verschiedenen Erweiterungen und lass deiner Kreativität freien Lauf. Viel Spaß beim Modden!
Denke daran: Übung macht den Meister. Je mehr du mit dem Code spielst und experimentierst, desto besser wirst du im Modding. Und vergiss nicht, die umfangreiche Dokumentation der Fabric API zu nutzen – sie ist deine beste Freundin!