Jump to content

[HOW-TO] Spigot Plugins programmieren - 2.0


Baustein
 Share

Recommended Posts

Hier eine neuere, aktuellere, vielleicht auch bessere Version des [HOW-TO] Bukkit Plugins programmieren von vor einiger Zeit.

Zielsetzung bezogen auf die alte Version: etwas trockenere, seriösere Überbringung der Materie. Des Weiteren wird diese Reihe nicht direkt auf Bukkit, sondern auf Spigot aufbauen. Unterscheidet sich aus gegebenen Gründen nicht allzu viel, aber dazu später eventuell mehr.

Wie immer gilt: Anregungen sind stets willkommen. Wenn Fragen offen sind, so ist hier natürlich der richtige Ort, ihnen Platz zu schaffen. Bitte jedoch dabei immer darauf achten, dass sie sich auf das [HOW-TO] beziehen, und nicht irgendwelche Fragen zur Programmierung von Plugins sind. Diese vom [HOW-TO] unabhängigen Fragen bitte weiterhin extern posten. Themenvorstellungen nehme ich natürlich auch immer gerne an.

 

 

#0 - Voraussetzungen

Ich setze ein gewisses Verständnis von Programmiersprachen voraus. Hin und wieder werde ich mit Sicherheit auf Grundlagen, die ich verwende, wie Schleifen, Abfragen o.Ä., eingehen. Jedoch handelt diese Reihe von der Erstellung von Spigot-Plugins, und nicht von der Aneignung von Wissen bezüglich Java.

 

#1 - Die Einrichtung

Bevor die Programmierung der Plugins starten kann, muss einiges eingerichtet werden.

 

Gliederung:

  1. Auswahl und Einrichtung einer IDE (Integrated Development Environment)
  2. Einrichtung von Java
  3. Die Spigot-API und was sie bedeutet
  4. Zusammenfassung

 

1. Auswahl und Einrichtung einer IDE (Integrated Development Environment)

Deine IDE ist dein Arbeitsplatz. In ihr wirst du deinen gesamten Code verfassen. Daher gilt es, sie gut auszusuchen. Programme in Java müssen kompiliert werden, damit sie ausgeführt werden können. Das heißt, du könntest theoretisch auch den MS Editor als IDE verwenden, und dazu einen Compiler aus Drittquelle nutzen, mit dem du immer bei jedem Export dein Projekt kompilierst. Das impliziert jedoch eine Menge Arbeit und ist dank moderner Software obsolet. So haben die meisten IDEs heutzutage einen integrierten Compiler. Ich empfehle dir, eine solche IDE zu verwenden.

Ein weiteres Feature von modernen IDEs wird dir in die Hände spielen: das Hervorheben bestimmten Codes. So sieht eine einfache Methode im MS Editor beispielsweise so aus

Wednesday_25_11_2015_21:24:03.png

in Eclipse (der IDE, die ich im weiteren Verlauf des [HOW-TO] benutzen werde) jedoch so:

Wednesday_25_11_2015_21:25:10.png

Sehr viel übersichtlicher. Sehr lohnenswert.

 

Trotzdem gibt es eine breite Auswahl an IDEs, darunter Netbeans, IntelliJ, Eclipse, usw.

Im Folgenden werde ich jedoch Eclipse verwenden, einfach, weil ich den Umgang mit dieser IDE schon gewohnt bin, und bisher nur sehr komfortable Erfahrungen gemacht habe.

 

Die IDE deiner Wahl kannst du dir einfach auf der jeweiligen Anbieterseite herunterladen und ganz normal installieren.

 

 

2. Einrichtung von Java

Wer Minecraft spielt sollte bereits Java installiert haben. Falls nicht, so ist Download der kostenlosen Java-Software die richtige Anlaufstelle. Für die Programmierung mit Java ist jedoch auch das JDK, das Java Development Kit, notwendig. Du kannst es dir hier herunterladen. Einfach die entsprechende Version deines Betriebssystemes auswählen, herunterladen, und den Installations-Wizard durchlaufen lassen.

 

Hinweis: Der folgende Absatz beruht auf meinen Erfahrungen mit Windows. Ich weiß nicht, wie das Verfahren bei anderen Betriebssystemen ist.

Damit ist häufig nicht genug getan. Es müssen womöglich noch Umgebungsvariablen gesetzt werden. Dafür öffnest du die Suche - bei Windows 7, indem du in der Taskleiste auf das Start-Symbol klickst, bei Windows 8 per Windows-Taste und Klick auf die Lupe oben rechts - und gibst "Systemumgebungsvariablen bearbeiten" ein. Es sollte nur ein Suchergebnis resultieren. Auf dieses klickst du. Es öffnet sich ein Fenster der folgenden Art:

Wednesday_25_11_2015_21:40:45.png

Hier klickst du unten rechts auf "Umgebungsvariablen...". Es öffnet sich ein neues Fenster. Im unteren Bereich "Systemvariablen" musst du nach "PATH" suchen, die Zeile markieren und auf "Bearbeiten..." klicken. An den "Wert der Variablen" hängst du nun mit einem Semikolon vom bisherigen Inhalt abgetrennten Inhalt die absoluten Dateipfade zu deinem bin-Ordner im Java Runtime Environment und nach einem weiteren Semikolon zu deinem bin-Ordner des JDK an. Danach alle Fenster bestätigend schließen.

 

3. Die Spigot-API und was sie bedeutet

Mit dem, was du bisher installiert hast, bist du fähig, Java-Programme zu schreiben. Damit du Plugins, also ergänzende Elemente zu Spigot programmieren kannst, benötigst du eine Ausgangsbasis von Spigot - beziehungsweise es ist wärmstens zu empfehlen. Die API bietet dir alle notwendigen Funktionen, wie Informationen über Spieler, Welten, Aktionen, und vieles mehr, abzufragen und zu modifizieren. Sie wird dein allgegenwärtiger Partner im Zusammenspiel mit Spigot.

Ich werde hier nicht weiter darauf eingehen, wie du die Spigot-API bekommst. Ich gebe dir nur den Link zum Github Repository. Wie du die API kompilierst wird dort erklärt.

Außerdem wirst du einen Spigot-Server benötigen. Dafür lädst du dir am besten BuildTools herunter und lässt es komplett durchlaufen, um die aktuellste Version Spigots zu bekommen. Mehr dazu hier.

 

4. Zusammenfassung

Du solltest nun alles Nötige bereit haben, um deine ersten Plugins zu programmieren. Du hast eine Arbeitsumgebung, in der du deine Projekte verwalten kannst, sowie die nötigen Komponenten von Java und Spigot. In den nächsten Teilen des [HOW-TO] wird es um die tatsächliche Erstellung der Plugins gehen. Nur Mut, auch wenn der Anfang relativ kompliziert und ertraglos scheint, so wirst du schnell merken (falls du noch nicht eh schon auf diesem Wissensstand bist), was Java doch für eine einfache Programmiersprache ist, und wirst deine Ideen schnell in die Tat umsetzen können. Wenn einmal dein erstes eigenes Plugin auf deinem Server läuft, und sich bei dir meldet, dann wird das Glücksgefühl garantiert weit größer sein, als bei einer erfolgreichen Installation eines weiteren Programms.

 

 

Liebe Grüße,

Baustein

  • Thanks 1
Link to comment
Share on other sites

#2 - Das erste Plugin

Hier erstellst du dein erstes Plugin. Die Funktionsweise ist recht schnell erklärt; es wird sich in der Konsole melden, wenn der Server startet.

 

Gliederung:

  1. Erstellung des Projekts (am Beispiel von Eclipse)
  2. Verfassen des Codes
  3. plugin.yml
  4. Testen des Plugins
  5. Hausaufgabe

 

1. Erstellung des Projekts (am Beispiel von Eclipse)

Um mit deinem ersten Plugin zu beginnen, startest du erstmal deine IDE. In meinem Fall ist das Eclipse. Du erstellst ein neues Projekt, indem du links im Project Explorer einen Rechtsklick auf eine leere Fläche machst, und New --> Project auswählst.

Thursday_26_11_2015_12:43:37.png

Als Wizard wählst du Java Project. Es öffnet sich ein neues Fenster, in dem du die nötigen Informationen für die Erstellung des Projektes angeben musst.Thursday_26_11_2015_12:45:06.png

Als Namen des Projektes kannst du dir selbst etwas aussuchen. Den Rest der Informationen kannst du im Normalfall bei den Standard-Einstellungen lassen. Wenn du nun auf "Finish" klickst, sollte das Projekt erstellt werden. Du siehst es nun links in deinem Project Explorer. Mit einem Doppelklick öffnest du die darin enthaltenen Ordner / Klassen / usw.; in "src" wirst du sämtlichen Code verfassen.

Das Projekt kannst du dir vorstellen wie deinen Computer. Es umfasst alles und kann dabei auf externe Datenträger wie USB-Sticks, im Falle deines Plugins das JDK und die Spigot-API, zugreifen.

Damit das Projekt diese "Datenträger" findet, müssen wir ihm allerdings sagen, wo sie sind. Schlauerweise sollte deine IDE Java bereits gefunden haben, es fehlt also noch die Spigot-API. Mache einen Rechtsklick auf dein Projekt und klicke auf "Properties". Wähle die Kategorie "Java Build Path", die Registerkarte "Libraries" und klicke auf den Button "Add External JARs".

Thursday_26_11_2015_12:54:40.png

Nun suchst du deine heruntergeladene Spigot-API-Jar-Datei und gibst diese an. Danach kannst du alle Fenster bestätigend schließen, die IDE hat "den Stick" jetzt gefunden und du kannst die Daten darauf verwenden.

Auf deinem Computer hast du jedoch viele verschiedene Ordner. Die sind vergleichbar mit den sogenannten "Package"s. Deine Dateien sind darin viel besser aufgehoben, als lose herumfliegend.

Daher erstellst du nun in "src" ein neues Package. Dafür machst du einfach einen Rechtsklick auf "src" und gehst auf New ==> Package. Es öffnet sich ein neues Fenster, in dem du deinem Package einen Namen verleihen kannst. Packages werden normalerweise nach einem bestimmten Prinzip benannt. Wenn du eine Website hast, ist es "TopLevelDomain.Domain.Projektname". In meinem Fall, ich habe das Projekt "Erstes Plugin" genannt, wäre es also "de.minecraftforum.Erstes Plugin". Da jedoch keine Leerzeichen in Package-Namen erlaubt sind, ersetze ich dieses durch einen Unterstrich: "de.minecraftforum.Erstes_Plugin".

In deinem "Ordner" kannst du nun Klassen anlegen. Und in denen startet dann tatsächlich das Coden. Also, nichts wie ran. Erstelle eine neue Klasse, indem du einen Rechtsklick auf dein neu kreiertes Package machst, und klicke auf New ==> Class. Es öffnet sich eines der vielen Fenster. Hier gibst du alles über die zu erstellende Klasse an.

Thursday_26_11_2015_12:58:15.png

Als Name kannst du dir irgendetwas aussuchen. Du solltest dir jedoch angewöhnen, deinen Klassen einen repräsentativen Namen zu geben, sodass du später allein vom Draufgucken weißt, worum es in ihr ging. Der Anfangsbuchstabe einer Klasse ist normalerweise groß geschrieben. Wenn etwas mit dem Namen nicht passt, dürfte deine IDE (Eclipse tut es zumindest) aber auch im oberen Bereich des Fensters anfangen, zu meckern.

Ich nenne meine erste Klasse gerne "Main". Das hat damit zu tun, dass dies die Hauptklasse des Plugins wird, quasi die Schaltzentrale.

Die restlichen Einstellungen kannst du im Grunde so lassen, wie sie sind. Wichtig ist höchstens, dass du, um dich nicht zu verwirren, den Haken bei "public static void main(String[] args)" entfernst. Wenn der Haken gesetzt ist wird eine Methode automatisch erstellt, die beim Starten des Java-Programms ausgeführt wird. Hier handelt es sich jedoch nicht um ein javabasiertes Standalone, sondern um ein Plugin. Wie der Server später weiß, wo er bei dir im Code beginnen soll, klären wir später.

 

2. Verfassen des Codes

Wenn du alles bestätigst dürfte der Inhalt deines Code-Fensters in etwa so aussehen:

Thursday_26_11_2015_13:02:47.png

 

Hier kommen wir an einen Punkt, an dem ich dir erstmal eine Information gebe, die du so schlucken musst, weil es jetzt den Rahmen sprengen würde, sie näher zu erläutern. Du musst nach deinem Klassennamen - hier momentan in Zeile 3 - in der Hauptklasse "extends JavaPlugin" anfügen.

Thursday_26_11_2015_13:05:12.png

Hier siehst du eine fantastische Funktion von modernen IDEs: sie schwärzen dich sofort an, wenn du einen Fehler machst. Hier ist das "JavaPlugin" unterstrichen. Wenn du mit der Maus auf das rot unterstrichene Element gehst, so bekommst du eine Beschreibung des Fehlers, meist sogar mit einigen Lösungsvorschlägen.

Thursday_26_11_2015_13:06:34.png

Dies ist ein "Fehler", dem du sehr häufig begegnen wirst. Wenn du aus externen Libraries Code verwendest musst du die entsprechenden Teile importieren. Hier wird dir das auch schon vorgeschlagen. Klicke einfach auf "Import 'JavaPlugin' [...]" und der Fehler ist behoben. Da du häufig etwas importieren werden musst, gebe ich dir schon jetzt die Erleichterung, sodass du nicht immer den Weg per Maus hinter dich bringen musst: mit der Tastenkombination Strg + Shift + O managest du sofort sämtliche Imports; Benötigte werden hinzugefügt, Unnötige entfernt.

 

Nun erstellst du deine erste Methode. Methoden sind Code-Teile, die einzeln angesteuert werden können. Bestimmte Methoden kennt Spigot bereits. So unter anderem die Methode "onEnable". Wie der Name schon verrät, wird diese Methode beim Start des Servers durchgeführt, insofern sie in der Hauptklasse des Plugins vorhanden ist.

Thursday_26_11_2015_13:10:37.png

So in etwa sollte deine onEnable-Methode aussehen, denn so in etwa sieht jede Methode aus. Gehen wir es einmal durch.

"public" beschreibt die Zugriffsrechte auf die Methode. "public" hieße, dass man von jeder anderen Klasse auf diese Methode zugreifen darf, vorausgesetzt, es existiert eine Instanz der Klasse, in der die Methode ist.

"void" ist, was die Methode zurückgibt. Einige Methoden geben eine Zahl zurück, so beispielsweise die Exempel-Methode aus "#1 - Die Einrichtung". Methoden haben nämlich den Sinn, dass du sie meist mit einer Information fütterst, sie verarbeitet sie, und gibt eine andere, daraus resultierende Information zurück.

Die onEnable-Methode jedoch gibt nichts zurück. Wenn eine Methode nichts zurückgibt, so wählen wir "void" als Rückgabewert. Zu Methode, die etwas zurückgeben, kommen wir später.

Danach kommt der Name der Methode, hier "onEnable". Dieser ist frei wählbar, jedoch nicht unbedingt bei dieser speziellen Methode, da die Serversoftware gezielt nach ihr sucht, wenn der Server startet. Wenn du die Methode anders benennst, dann wird sie sie nicht finden können.

Die Klammern schließen Parameter ein. Parameter sind die Informationen, die die Methode benötigt, um zu funktionieren, also das, was die Methode haben will. Die onEnable-Methode funktioniert komplett autark, daher sind die Klammern leer.

Zwischen den geschweiften Klammern wird die Methode nun gefüllt.

 

Folgenden Code wirst du vorerst in die Methode schreiben:

System.out.println();

Gehen wir auch das nochmal durch. Das "System" am Anfang beschreibt die Klasse (hier aus der Java-Bibliothek), auf die wir zugreifen. In ihr befindet sich nämlich die Methode, auf die ich abziele. In ihr befindet sich eine Variable namens "out", die es uns u.A. ermöglicht, Nachrichten an die Außenwelt zu schicken. Eine Methode, die in der Klasse des Variablentypes von "out" dafür sorgt, dass eine Nachricht geschrieben wird, nennt sich "println". Zu Variablen, Variablentypen usw. später mehr.

Du steuerst also bloß eine weitere Methode an, die irgendwo im Code von Java steht.

Im Gegensatz zur onEnable-Methode benötigt diese Methode jedoch Parameter. In diesem Falle einen String - zu Deutsch: eine Zeichenkette, also eine Aneinanderreihung von Zeichen, im Volksmund auch Text genannt. Gib ihr eine Nachricht! Strings müssen immer in Anführungsstrichen festgelegt werden. So sähe die Methode nun demnach so aus:
Thursday_26_11_2015_13:21:43.png

Das Ende einer Zeile, die eine Aktion durchführt, wird durch ein Semikolon markiert. Solltest du es einmal vergessen, so wird dich deine IDE mit Sicherheit freundlich darauf hinweisen.

 

3. plugin.yml

Damit wäre das Plugin bereits fertig geschrieben. Wenn du es in dieser Form nun exportieren und laufen lassen würdest, dann würde es jedoch nicht funktionieren. Das liegt daran, dass Spigot nicht weiß, was es mit dem Plugin anfangen soll. Du musst einige Informationen angeben.

Klicke links im Project Explorer auf dein Projekt und wähle New ==> File. Als Name wählst du - und das kannst du dir nicht aussuchen - "plugin.yml". Es öffnet sich im Code-Bereich eine neue leere Region. Hier legst du die Informationen für Spigot fest.

 

Ich erstelle hier mal eine einfache plugin.yml:

Thursday_26_11_2015_13:26:10.png

Das sind die wichtigsten Angaben, die in deiner plugin.yml stehen müssen. Bis auf "author" ist auch jede der obigen Angaben verpflichten, damit das Plugin anständig läuft.

Ich denke, dass sich alles bis auf "main" selbst erklärt. "main" gibt den Pfad zu deiner Hauptklasse an, also zu der Klasse, aus der das Plugin "gesteuert" wird. Das wäre zuerst der vollständige Name des Packages und danach der Name der Klasse (ohne die Dateiendung .java). In meinem Falle also "de.minecraftforum.Erstes_Plugin.Main".

Später, wenn du auch noch Kommandos zu deinen Plugins hinzufügst, musst du diese ebenfalls in der plugin.yml angeben. Außerdem gibt es noch einige sehr interessante Attributmöglichkeiten, auf die ich aber später eingehen werde.

 

4. Testen des Plugins

Nun lassen wir das Plugin doch mal auf einem Server laufen. Dafür musst du es zuerst exportieren. Mache einen Rechtsklick auf dein Projekt im Project Explorer, und klicke auf "Export". In dem sich öffnenden Fenster wählst du "JAR file".

Friday_27_11_2015_19:10:06.png

Nun kannst du das Export-Ziel festlegen. Entferne in dem rechten Bereich übrigens die Haken bei .classpath und .project, da diese Dateien nicht benötigt werden.

Wenn du das exportierte Plugin in den plugins-Ordner deines Servers geladen hast, dann kannst du den Server nun starten.

 

Wenn alles gut gelaufen ist, sollte die Konsole ungefähr so aussehen:

Friday_27_11_2015_19:15:18.png

 

Perfekt. Dein erstes Plugin hat sich beim Hochfahren des Servers in der Konsole gemeldet.

 

5. Hausaufgabe

Die Methode, die ausgeführt wird, wenn der Server gestoppt wird, nennt sich onDisable. Erstelle die Methode in deinem Plugin und lasse eine weitere Nachricht ausgeben. Im nächsten Teil werde ich einen Beispielcode für die Lösung angeben.

 

 

 

Liebe Grüße,

Baustein

Link to comment
Share on other sites

  • boomer41 pinned this topic
  • 6 months later...

#3 - Kommandos

Eine lange Zeit ist vergangen seit der letzten Stunde, ich hoffe, der Vertretungslehrer hat einen guten Job gemacht. Doch schließen wir an, wo wir aufgehört haben. Heute handelt sich der Post demnach um die Erstellung von Kommandos, die im Chat ausgeführt werden können.

 

Gliederung:

  1. Hausaufgabenbesprechung
  2. Verfassen des Codes
  3. plugin.yml
  4. Testen des Plugins
  5. Hausaufgabe


1. Hausaufgabenbesprechung
Die Hausaufgabe des letzten Posts war es, die onDisable()-Methode zu nutzen, um eine Nachricht auszugeben. Hier der dafür passende Code:

package de.minecraftforum.Erstes_Plugin;

import org.bukkit.plugin.java.JavaPlugin;

public class Main extends JavaPlugin {
	
	public void onEnable() {
		System.out.println("Hallo Welt!");
	}
	
	public void onDisable() {
		System.out.println("Es war eine tolle Zeit.");
	}
}

 

2. Verfassen des Codes
Ich erstelle eine neue Klasse, die ich als Main-Klasse verwenden werde, damit die Klassen mehrerer Teile nebeneinander bestehen bleiben können. In deinem Fall könnte der Code jedoch durchaus weiterhin in der bisherigen Main-Klasse stehen bleiben.

Diese Klasse ist demnach erstmal leer:
Saturday_18_06_2016_22:09:55.png

Damit die Serversoftware weiß, wo ein Kommando definiert wird, ist der Methodenname der Methode, die sich um das Kommando kümmert, vorgegeben  (so wie onEnable() oder onDisable()). Die Methode im Roh-Zustand heißt onCommand und sieht wie folgt aus:

@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
	
}

Ich werde nun die einzelnen Teile der Methode durchgehen.

  • @Override
    Dies ist eine sogenannte Annotation. Genau genommen hätte ich sie schon bei onEnable und onDisable nutzen sollen. Die Annotation sagt dem Compiler, dass eine Methode der Oberklasse, in dem Fall "JavaPlugin" überschrieben werden soll. Sollte es die Methode in der Oberklasse nicht geben, dann würde die IDE außerdem einen Fehler ausgeben.
  • public boolean
    Die Methode ist auch von anderen Klassen aus erreichbar und gibt eine Variable des Typs Boolean, also true oder false (ja oder nein) zurück. In diesem Fall bedeutet das, dass die Methode zurückgibt, ob das Ausführen des Kommandos geklappt hat, oder nicht.
  • CommandSender sender
    Dieser Parameter der Methode stellt den Sender des Kommandos dar. Das kann ein Spieler, aber auch die Konsole sein. Den Sender kannst du für viele verschiedene Dinge nutzen, beispielsweise um eine Nachricht zurückzuschicken.
  • Command command
    Relativ einleuchtend; mit der Variable kannst du Dinge wie die Usage, die Beschreibung oder Ähnliches abrufen. Diese Dinge werden später in der plugin.yml gesetzt.
  • String label
    Das label ist das erste Wort, das der Sender eingeben hat. Ohne eventuellen Schrägstrich am Anfang.
  • String[] args
    Die args sind die Argumente des Kommandos, also alle Worte ab dem zweiten.

 

Gut. Wenn du die Methode so ausfüllst, wie hier, dann wird die IDE mit Sicherheit meckern. Denn wie definiert muss die Methode ein boolean zurückgeben, tut sie aber noch nicht. Wenn in der onCommand true zurückgegeben wird, dann passiert für den Sender gar nichts. Sollte jedoch false zurückgegeben werden, dann wird die Usage, also die Weise, auf die das Kommando genutzt werden soll, ausgegeben - auf ziemlich hässliche Art. Daher ist es geläufig, dass man in der onCommand einfach immer true zurückgibt.

Als nächstes geht es daran, zu erfahren, was das Kommando war. In meinem Fall nenne ich das Kommando "tick". Daher frage ich auch in der onCommand-Methode ab, ob das label, also das erste und hier einzige Wort des Kommandos, "tick" ist. Da die Groß- und Kleinschreibung dabei egal sein soll, nutze ich die Methode equalsIgnoreCase() statt equals().

@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
	if (label.equalsIgnoreCase("tick")) {
		
	}		
	return true;
}

Nun habe ich die Möglichkeit, etwas zu machen, wenn das Kommando denn "tick" oder "TICK" oder "tIcK" oder etwas Derartiges ist. Ich entscheide mich dafür, dem Sender die Nachricht "tack" zukommen zu lassen.
Dafür nutze ich die übergebene Instanz des CommandSenders, die mir einige Methoden, unter Anderem sendMessage(String message) zur Verfügung stellt.
So sieht also die fertige Methode aus:

@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
	if (label.equalsIgnoreCase("tick")) {
		sender.sendMessage("tack");
	}		
	return true;
}

 

3. plugin.yml
Würde der Server das Plugin nun so aufgetischt bekommen, würde er das Kommando "tick" nicht erkennen. Es muss erst noch in der plugin.yml registriert werden. Die fertige plugin.yml sähe so aus:

name: Spigot Plugins programmieren
author: Baustein
version: 1.0
main: de.minecraftforum.Erstes_Plugin.Teil_003_Kommandos

commands:
  tick:
    usage: /tick
    description: Tick tack, tick tack, tick tack.

Ich habe hier den Namen und den Pfad zur Main-Klasse entsprechend meiner Projekt-Umstellung geändert, lass dich davon nicht verwirren.

Gerade in der "commands"-Sektion wird die für YAML charakteristische Baumstruktur erkenntlich. Unter "commands" werden alle Kommandos aufgelistet, die das Plugin registrieren soll. Hier gibt es nur das Kommando "tick". Dieses bekommt eine usage, also Anweisungen, wie es benutzt werden soll, und eine description, also eine Beschreibung.

4. Testen des Plugins
Doch klappt das Ganze überhaupt? Ich exportiere das Plugin und starte den Server. Wenn ich dem Server beitrete und /tick eingebe bekomme ich tatsächlich die "tack"-Nachricht. Das Kommando funktioniert sogar in der Konsole:
Saturday_18_06_2016_22:41:29.png

 

5. Hausaufgabe
Der CommandSender bietet dir eine Fülle an Methoden. Betrachten kannst du sie, wenn du "sender." eingibst und Shift+Leertaste drückst (die Tasten-Kombination mag von IDE zu IDE abweichen). Finde die Methode, die dir den Namen des Senders zurückgibt, und begrüße diesen mit Namen, wenn er "/hallo" eingibt.

 

 

Liebe Grüße,

Baustein

Link to comment
Share on other sites

#4 - BitBucket

Damit nach einem Teil des How-Tos eventuelle Unstimmigkeiten gut geklärt werden können, habe ich auf BitBucket ein Repository gegründet. In diesem werde ich nach jeder Stunde den gesamten Code hochladen.
Das Repository ist zu finden unter https://bitbucket.org/Baustein/how-to-spigot-plugins-programmieren-2.0.

 

Liebe Grüße,

Baustein

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...
B
B