So erstellen Sie auf verschiedene Arten einen Mod für Minecraft.

12.08.2019 Essen und Trinken

Heute starten wir eine Reihe von Artikeln für Anfänger, die ihnen helfen sollen, das Minecraft-Modding zu meistern und es vor allem so schnell und sinnvoll wie möglich zu machen. Im Prinzip kann jeder von uns Lektionen finden und mit der Erstellung von Mods beginnen, denn nach dem Zufallsprinzip kann man fast alles machen, auch wenn es nicht ganz richtig und schön ist. Dieses Tutorial schützt Sie davor, auf einen Rechen zu treten und hilft Ihnen, so schnell und bequem wie möglich loszulegen.

Einführung in Minecraft Modding

Es ist darauf hinzuweisen, dass Minecraft-Mods sind in Java geschrieben. Hier wird es keine praktischen Editoren geben. Sie müssen mindestens über minimale Java-Kenntnisse oder Erfahrung mit anderen Programmiersprachen und deren Grundlagen verfügen. Als letzten Ausweg besteht ein großer Wunsch, all dies zu lernen. Wenn Sie nicht dumm Beispiele kopieren, sondern versuchen zu verstehen, wie es funktioniert, dann wird Sie der Erfolg auf jeden Fall erwarten.

Fast jeder, der jemals Minecraft-Mods installiert hat, ist mit der Forge-Modifikation vertraut, da die meisten Mods ihre Anwesenheit in Ihrem Spiel erfordern. In diesem Artikel erstellen wir Mods speziell für Forge.

Warum Schmieden? Stellen Sie sich vor, Sie müssten Ihren Fernseher/Computer/iPhone/Large Hadron Collider reparieren (Zutreffendes unterstreichen), haben aber nur einen Hammer und Nägel zur Hand. Natürlich holen wir einen verstaubten Werkzeugkasten hervor, der Zangen, Pinzetten und eigentlich alles andere enthält, was das Herz begehrt. In unserem Fall ist Forge die gewünschte Toolbox.

Lass uns zur Arbeit gehen

Zuerst müssen wir das JDK (Java Development Kit) herunterladen.

Der Artikel ist exklusiv für die Website verfügbar. Das Kopieren und Nachdrucken von Informationen ist nur mit schriftlicher Zustimmung des Autors gestattet.


Es ist nicht erforderlich, META-INF in minecraft.jar und minecraft_server.jar zu löschen
1. Erstellen Sie einen Ordner (zum Beispiel: MCP Forge) und entpacken Sie dort den Inhalt des Archivs mit MCP.
2. Kopieren Sie den Ordner „bin“ und „resources“ vom Client in den Ordner „../MCP Forge/jars/“. Vom Server benötigen wir nur „minecraft_server.jar“.
3. Entpacken Sie das Archiv mit Forge-src in den MCP Forge-Ordner
4. Öffnen Sie den Ordner ../MCP Forge/forge/ und führen Sie die Datei install.cmd aus. Wir warten auf den Abschluss der Dekompilierung.
(P.S. Wenn Sie möchten, dass Sie bereits ein fertiges MCP mit Forge haben, zum Beispiel, wenn Sie es versehentlich gelöscht haben oder etwas anderes, dann: Wenn die Dekompilierung abgeschlossen ist, starten Sie das Spiel und lassen Sie es die Bibliothek herunterladen und dann hinzufügen dieses MCP Forge ins Archiv, zum Beispiel so (mcp Forge 1.5.1)
5. „Installieren“ und starten Sie Eclipse. Beim Start werden Sie nach dem Ordner mit dem Projekt „gefragt“, geben Sie den Pfad an: ../MCP Forge/eclipse/
6. Also haben wir das Projekt geöffnet, jetzt (normalerweise gibt es auf der linken Seite einen Paket-Explorer) schauen wir uns an, welche Bibliothek es „frisst“ (im Paket-Explorer-Fenster „Öffne das Minecraft-Projekt“ und ob es eine Zeile gibt „JRE System Library“, dann ist alles in Ordnung, aber wenn die Zeile „JRE System Library“ lautet, dann klicken Sie mit der rechten Maustaste (Rechtsklick), wählen Sie Eigenschaften, dann öffnet sich ein Fenster, in dem die Ausführungsumgebung ausgewählt wird, wählen Sie JavaSE-1.7 hinein und klicken Sie auf OK.
7. So, die Vorbereitungen sind fertig.

Wie fängt man an, einen Mod zu schreiben?

Zuerst müssen wir eine „Basis“ erstellen, also den Haupt-„Ordner“, in dem unsere „Basis“ und alles andere gespeichert werden.
1. Gehen Sie zu Eclipse, sehen Sie sich den Minecraft-Ordner im Paket-Explorer an, öffnen Sie ihn, klicken Sie mit der rechten Maustaste auf den src-Ordner und wählen Sie Neu->Paket. Im geöffneten Fenster geben wir in der Zeile „Name“ den Namen des Ordners an, in dem alles gespeichert wird (zum Beispiel: mods.testmod.src) und klicken auf „OK“.
2. Klicken Sie mit der rechten Maustaste auf unseren Ordner (mods.testmod.src) und dann auf Neu -> Klasse. Geben Sie in der Zeile „Name“ den Namen unserer Datei an (z. B. TestModBase) und klicken Sie auf „Fertig stellen“.
3. Ändern Sie den Pfad, aber entfernen Sie keine Mods, zum Beispiel mods.NewItemMod.src.
4. In neuen Versionen müssen Sie „viel“ von allem importieren. Um es in Eclipse schneller zu machen, drücken Sie „Strg + Umschalt + O“, und alles wird schnell importiert. Wenn ein Fenster erscheint, wählen Sie den gewünschten Import aus.
5. Wenn Sie nicht in Eclipse arbeiten, wird es für Sie viel schwieriger, daher ist es besser, darauf umzusteigen. Es zeigt an, wo der Fehler liegt und welche Importe erforderlich sind, und Sie müssen nicht nachfragen Blöde Fragen in Kommentaren.

Paket mods.testmod.src;

import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.Init;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.Mod.PostInit;
import cpw.mods.fml.common.Mod.PreInit;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkMod;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.common.registry.LanguageRegistry;
import cpw.mods.fml.common.network.NetworkMod.SidedPacketHandler;
import cpw.mods.fml.common.SidedProxy;
@Mod (modid = „TestMod“, Name = „Test Mod“, Version = „0.0.1“)
@NetworkMod(clientSideRequired = true, serverSideRequired = false, versionBounds = "1.0.0")

öffentliche Klasse TestModBase (

@Instance("TestModID")
öffentliche statische TestModBase-Instanz;

@Drin

{
}

@PreInit
public void preLoad(FMLPreInitializationEvent-Ereignis)
{
}

@PostInit
public void postLoad(FMLPostInitializationEvent-Ereignis)
{
}
}


In unserer TestModBase-Datei
Nach der Inschrift:
öffentliche Klasse TestModBase (
Geben Sie diese Zeile ein:
öffentlicher statischer finaler Block testBlock = new TestBlock(2020).setUnlocalizedName("testBlock");
Parsing:
öffentlicher statischer finaler Block „testBlock“ – testBlock der Name unseres Blocks im Code (nicht im Spiel)
neuer TestBlock(2020) – TestBlock der Name unseres Blocks im Code (nicht im Spiel), 2020-Block-ID
setUnlocalizedName("testBlock") - ("testBlock") der Name unseres Blocks im Code (nicht im Spiel)
Nach der Inschrift:
@Drin
öffentliches Leereladen (FMLInitializationEvent-Ereignis)
{

Geben Sie diese Zeile ein:
GameRegistry.registerBlock(testBlock);
LanguageRegistry.addName(testBlock, "Test Block");

Parsing:
(testBlock) – der Name unseres Blocks im Code (nicht im Spiel)
(testBlock, „Test Block“) – testBlock ist der Name unseres Blocks im Code (nicht im Spiel), „Test Block“ ist der Name unseres Blocks im Spiel.
Erstellen Sie eine Datei testBlock und geben Sie den folgenden Code ein:
Paket mods.testmod.src;

import net.minecraft.block.Block;
import net.minecraft.block.material.Material;

Die öffentliche Klasse TestBlock erweitert Block (

öffentlicher TestBlock(int par1)
{
super(par1, Material.ground);//Material
this.setCreativeTab(CreativeTabs.tabTools);//Zum Creative hinzufügen
}
//Registrieren Sie die Textur
@Override

{
}
}


In unserer TestModBase-Datei
Nach der Inschrift:
öffentliche Klasse TestModBase (
Geben Sie diese Zeile ein:
öffentliches statisches Element testItem = new TestItem(2021).setUnlocalizedName("testItem");
Parsing:
öffentliches statisches finales Item „testItem“ – testItem ist der Name unseres Items im Code (nicht im Spiel)
new TestItem(2021) – TestItem der Name unseres Artikels im Code (nicht im Spiel), 2021 Artikel-ID
setUnlocalizedName("testItem") - ("testItem") der Name unseres Artikels im Code (nicht im Spiel)
Nach der Inschrift:
@Drin
öffentliches Leereladen (FMLInitializationEvent-Ereignis)
{

Geben Sie diese Zeile ein:
LanguageRegistry.addName(testItem, "Test Item");
Parsing:
(testItem, „Test Item“) – testItem ist der Name unseres Artikels im Code (nicht im Spiel), „Test Item“ ist der Name unseres Artikels im Spiel.
Erstellen Sie eine Datei testItem und geben Sie den folgenden Code ein:
Paket mods.testmod.src;

import net.minecraft.item.Item;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;

Die öffentliche Klasse TestItem erweitert Item
{
öffentliches TestItem(int par1)
{
super(par1);
setCreativeTab(CreativeTabs.tabTools);
}

//Die Texturregistrierung für ein Element unterscheidet sich geringfügig von der für einen Block
@Override
öffentliches LeereregisterIcons(IconRegister par1IconRegister)
{
}
}


@Override
öffentliches LeereregisterIcons(IconRegister par1IconRegister)
{
this.blockIcon = par1IconRegister.registerIcon("testmod:testBlock");
}

(„testmod:testBlock“), testmod ist der „Name des Ordners“, in dem sich der „Ordner mit der Textur“ befinden wird, testBlock ist der Name unserer Textur. Dies ist unsere Texturplatzierung:

\Tutorial Forge 1.5.1\mcp744\src\minecraft\mods\testmod\textures\blocks\testBlock.png


@Override
öffentliches LeereregisterIcons(IconRegister par1IconRegister)
{
this.itemIcon = par1IconRegister.registerIcon("testmod:testItem");
}

(„testmod:testItem“), testmod ist der „Name des Ordners“, in dem sich der „Ordner mit der Textur“ befindet, testItem ist der Name unserer Textur. Dies ist unsere Texturplatzierung.

Wir haben also einen Ordner mit den folgenden Dateien darin:

  • build.gradle
  • gradlew (.bat und .sh)
  • Gradle-Ordner

Jetzt müssen Sie den Befehl gradlew eclipse ausführen. Wenn Sie Windows haben, können Sie mit der rechten Maustaste auf den leeren Bereich klicken innen diesen Ordner, während Sie die Umschalttaste gedrückt halten. Dann gibt es im erscheinenden Kontextmenü den Eintrag „Befehlsfenster öffnen“. Wählen Sie dieses Element aus und die Konsole wird sofort geöffnet.

Geben Sie in der Konsole gradlew eclipse ein.

Öffnen Sie nun Eclipse. Es macht keinen großen Unterschied, wo sich der Arbeitsbereich befindet. Öffnen Sie oben auf dem Bildschirm das Menü „Datei“ und wählen Sie „Importieren“. Wählen Sie in der angezeigten Liste „Gradle > Gradle-Projekt“ aus.

Überspringen Sie das Gradle-Einführungsfenster, indem Sie auf die Schaltfläche „Weiter >“ klicken, falls diese angezeigt wird.

Geben Sie im nächsten Fenster den Ordner mit den entpackten Dateien an. Klicken Sie auf „Fertig stellen“.

Gradle-Aufgaben

Öffnen Sie das Menü „Fenster“ oben auf dem Bildschirm und wählen Sie „Ansicht anzeigen > Andere ...“.

Wählen Sie im angezeigten Fenster „Gradle > Gradle-Aufgaben“ aus.

Es öffnet sich ein Fenster mit Gradle-Aufgaben. Gradle ist ein beliebtes automatisches Build-System, das vorgefertigte Programme aus Quellcode zusammenstellt und viele andere notwendige Dinge erledigt, aber Routine Geschäft Genau diese Dinge nennt man Aufgaben/Aufgaben/Aufgaben - Aufgaben. Wir haben gerade das Aufgabenfenster geöffnet.

Es sieht ungefähr so ​​aus:

Testlauf

Für einen Testlauf öffnen Sie das Menü „Ausführen“ oben auf dem Bildschirm und wählen Sie „Konfigurationen ausführen“. Öffnen Sie im links erscheinenden Fenster den Reiter „Java-Anwendung“ und wählen Sie Client oder Server aus. Klicken Sie dann auf die Schaltfläche „Ausführen“.


Heute eröffne ich die Artikelserie dieses Mal erneut. Ich werde es nicht aufgeben und sogar auf Ihre Kommentare antworten. Nun, von Worten zu Taten. Gehen!
Vorbereitung

Um unsere Plugins zu schreiben, benötigen wir:
  • Eclipse Java-Anwendungsentwicklungsumgebung;
  • Spigot-API: https://hub.spigotmc.org/nexus/content/groups/public/org/spigotmc/spigot-api/.
Darüber hinaus sind Grundkenntnisse in Java erforderlich. Wenn es keine gibt, finden Sie hier Links zum Thema „Erhöhen Sie Ihre Fähigkeiten“:
  • Java-Grundlagen für Anfänger
    Die Website richtet sich an diejenigen, die gerade erst anfangen, Java zu lernen.
  • Java-Programmier-Tutorials (Anfänger).
    Video-Tutorial zu Java, konzipiert für Anfänger (ich habe damit angefangen).
  • Java-Referenz
    Ich würde das einen Java-Spickzettel nennen
  • Java-Experte
    Und lassen Sie sich vom Namen nicht abschrecken. Hier finden Sie viele Lösungsbeispiele für diese bzw
    andere Aufgaben.
Eclipse installieren und konfigurieren
Wenn Sie bereits mit Eclipse vertraut sind oder eine andere IDE haben, überspringen Sie diesen Abschnitt.

Bei der Installation von Eclipse sollte es keine Probleme geben: Sie müssen es nur in einen beliebigen Ordner entpacken und ausführen. Unmittelbar danach werden Sie von Eclipse aufgefordert, anzugeben, welchen Arbeitsbereich Sie jetzt öffnen möchten. Dies ist der Ordner, in dem alle erstellten Projekte gespeichert werden. Wo sie abgelegt werden, ist Ihre persönliche Entscheidung. Wenn es Ihnen egal ist, dann lassen Sie alles so, wie es ist. Wenn Sie plötzlich den Arbeitsbereich ändern möchten, machen Sie sich keine Sorgen: Bei jedem Start fragt Eclipse Sie erneut nach dem Arbeitsbereich. Sie können so viele dieser Räume erstellen, wie Sie möchten, und jeder kann für bestimmte Zwecke unterschiedlich konfiguriert werden. Ich habe zum Beispiel zwei Arbeitsbereiche: zum Schreiben regulärer Java-Anwendungen und zum Schreiben von Bucket-Plugins. Wenn Sie diese Meldung plötzlich satt haben, gibt es ein Kontrollkästchen „Als Standard verwenden und nicht erneut fragen“, mit dem Sie den Arbeitsbereich als Standard festlegen können.+

Sobald Sie sich für die Standortwahl entschieden haben und Eclipse geladen wird, sehen wir einen Einladungs-Tab... den wir sofort schließen. Wir brauchen sie nicht.

Jetzt sehen wir den Arbeitsbereich des Eclipse selbst. Von all dem benötigen wir nur die folgenden Panels:

  • Paket-Explorer
    Hier werden Ihre Projekte, Pakete (dazu später mehr) und alle möglichen Dateien für unsere zukünftigen Plugins angezeigt.
  • Probleme
    Wir werden dieses Panel selten verwenden (falls wir jemals dazu kommen), aber es lohnt sich, darüber zu reden. Hier werden im Code gemachte Fehler sowie Warnmeldungen zu möglichen Fehlern oder Ungenauigkeiten angezeigt.
  • Gliederung
    Hier wird die Navigation direkt durch den Open-Source-Java-Code angezeigt.
Die letzten beiden beschriebenen Panels können vollständig zusammengeklappt werden, weil Wir werden sie selten verwenden.

Der Arbeitsplatz ist fast fertig. Es müssen nur noch zwei weitere Kästchen in den Einstellungen aktiviert werden.

Gehen Sie zum Menü „Fenster“ -> „Einstellungen“, dann entlang der Baumstruktur „Allgemein“ -> „Editor“ -> „Texteditoren“ und aktivieren Sie das Kontrollkästchen „Zeilennummern anzeigen“, um die Anzeige der Zeilennummerierung zu aktivieren. Gehen Sie nun zu Allgemein -> Arbeitsbereich und stellen Sie in der Gruppe „Textdateikodierung“ die Kodierung auf UTF-8 ein und legen Sie damit die Standardkodierung fest.

Die Installation und Konfiguration ist abgeschlossen. Jetzt erkläre ich, wie man erstellt neues Projekt für das Plugin. Dies kann auf drei Arten erfolgen:

Das Fenster „Neues Java-Projekt“ wird vor uns geöffnet. Unter Projektname geben wir den Namen unseres Projekts an

Weiter klicken.
Gehen Sie im angezeigten Fenster zur Registerkarte „Bibliotheken“, klicken Sie auf die Schaltfläche „Externe JARs hinzufügen“ und wählen Sie die heruntergeladene Bukkit-API aus

Klicken Sie auf Fertig stellen.

Links im Paket-Explorer erscheint unser Projekt mit dem Ordner src, in dem unsere Quellcodes gespeichert werden. Jetzt lasst uns erstellen neue Klasse. Dies geschieht genauso wie beim Java-Projekt.

Im Fenster „Neue Java-Klasse“ benötigen wir nur die folgenden Spalten:

  • Paket
    gibt das Paket an, in dem unsere Klasse gespeichert wird. Das Namensformat sollte etwa so aussehen: ru.dmitriymx.bukkit.tutorial.
    Kurz gesagt, Pakete in Java sind ein Namespace oder „virtuelle Ordner“, in denen Klassen abgelegt werden. Mehr dazu können Sie hier lesen: , , .
  • Name
    Geben Sie den Namen der Klasse an (bei mir ist es DmxFirstPlugin)
Lassen Sie alle anderen Elemente unverändert und klicken Sie auf Fertig stellen.

Kommen wir nun direkt zum Code.
Ein einfaches Plugin schreiben
Sobald wir eine neue Klasse erstellt haben, erscheint vor unseren Augen eine fertige leere Vorlage

Im Moment ist dies nur eine leere Klasse, die im Alltag absolut nutzlos ist. Wir werden das beheben. Lasst uns das ändern

auf das

Eclipse wird uns JavaPlugin hervorheben und auf einen Fehler im Code hinweisen. Wenn Sie mit der Maus über einen solchen unterstrichenen Code fahren, öffnet sich ein Fenster mit einer Beschreibung des Fehlers und einer Lösung. IN in diesem Fall Wir müssen die Klasse aus der Bukkit-API importieren, wofür wir den Punkt „Import ‚JavaPlugin‘(org.bukkit.plugin.java)“ auswählen.

Uns fällt sofort auf, wie die Zeile über unserem gesamten Code steht

Ein wenig theoretisches Material. Plugins verfügen über drei Hauptmethoden: onEnable(), onDisable() und onLoad(). Die ersten beiden sind für das Aktivieren und Deaktivieren des Plugins verantwortlich, und der letzte wird ausgelöst, wenn das Plugin direkt in den Serverspeicher geladen wird. Daraus folgt, dass onLoad zuerst ausgeführt wird, das Plugin selbst jedoch erst zu funktionieren beginnt, nachdem onEnable von der Serverseite aufgerufen wird. Wenn der Server ausgeschaltet oder neu gestartet wird, wird die Methode onDisable aufgerufen.

Wir haben die „Ein- und Ausstiegspunkte“ geklärt. Lassen Sie uns jetzt etwas schreiben, das mehr oder weniger praktikabel ist. Reduzieren wir den allgemeinen Klassencode auf die folgende Form:

Wer sieht den zweiten Teil nicht:
Worüber wir gerade geschrieben haben, ist ein fertiges Plugin. Er schreibt lediglich im Chat über die Ankunft und Abreise des Spielers auf dem Server. Wir werden seine Arbeit der Reihe nach verstehen (wie sonst?).
Lassen Sie mich zunächst auf die Klassendeklarationszeile achten. Wie Sie sehen, wurde unserer Klasse die Listener-Erweiterung hinzugefügt. Ohne in den Java-Dschungel einzutauchen, sage ich es einfacher: Durch die Angabe dieser Erweiterung erweitern wir damit den Umfang der Klasse nicht nur als Plugin (JavaPlugin), sondern auch als Event-Handler (Listener). Aber in der onEnable()-Methode registrieren wir unsere Klasse auf dem Server als Event-Handler (dies ist ein Verweis auf sich selbst, falls es jemand vergessen hat).

Als nächstes kommen unsere beiden Event-Handler onJoin() und onQuit(). Der erste ist für den Fall verantwortlich, dass der Spieler den Server betritt, und der zweite ist für das Verlassen des Servers verantwortlich. Mit der Methode event.getPlayer().sendMessage() können wir eine Nachricht an den Spieler senden, der dieses Ereignis verursacht hat (in unserem Fall der Spieler, der sich angemeldet hat). Die statische Klasse ChatColor speichert Farbkonstanten zum Färben. Ich denke, wie man es nutzt, lässt sich bereits am Beispiel erkennen. Außerdem benachrichtigen unsere beiden Prozessoren andere Spieler auf dem Server über aufgetretene Ereignisse, tun dies jedoch auf unterschiedliche Weise. In onJoin() ändern wir mit der Methode event.setJoinMessage() die übliche Meldung „Spieler ist dem Spiel beigetreten“ in eine beliebige andere. Und in onQuit() haben wir etwas anderes gemacht (zum Beispiel): Wir haben die Ausgabe der Exit-Nachricht entfernt und dies über die Methode getServer().broadcastMessage() gemeldet, die einfach die angegebene Nachricht an alle Spieler auf dem Server sendet. +

Jetzt müssen Sie nur noch die wichtige Datei „plugin.yml“ schreiben und alles in eine JAR-Datei packen.

Plugin.yml ist eine Plugin-Beschreibungsdatei. Es gibt den Plugin-Namen, die Hauptklasse, die Beschreibung und die für Plugins zu registrierenden Befehle an (dazu später mehr) usw. In unserem Fall sollte die Datei so aussehen:

Oh, ich habe vergessen, Ihnen zu sagen, wo sich diese Datei befinden soll. Klicken Sie mit der rechten Maustaste auf den Ordner src im PackageExplorer und wählen Sie im Menü „Neu“ die Option „Datei“. Schreiben Sie in das Feld „Dateiname“ „plugin.yml“ und klicken Sie auf „Fertig stellen“. Schreiben Sie in den sich öffnenden Texteditor, was ich oben angegeben habe. Wir speichern alles und gehen zur letzten Phase über: dem Verpacken.

Klicken Sie mit der rechten Maustaste auf den src-Ordner -> Exportieren. Öffnen Sie in der Ordnerstruktur Java, wählen Sie die JAR-Datei aus und klicken Sie auf Weiter. Von den kleinen Dingen lassen wir nur „Generierte Klassendateien und Ressourcen exportieren“ und „Inhalt der JAR-Datei komprimieren“. Im JAR-Dateifeld geben wir an, wo wir das resultierende Plugin speichern werden. Nachdem Sie auf „Fertig stellen“ geklickt haben, können Sie das Plugin im Plugins-Ordner ablegen, den Server starten und seine Funktion überprüfen.

Siehst du? Es ist ganz einfach. Mit etwas Übung werden Sie mehr Erfahrung sammeln und in der Lage sein, coolere Plugins zu erstellen, sogar so legendäre wie WorldEdit und WorldGuard.
Quelle