Bukkit - Erste Schritte zur Plugin-programmierung
Was brauchen wir, um ein Plugin zu schreiben?
*Eclipse:
Dies ist die Programmierumgebung. Hier werden euch sofort Syntax-Fehler angezeigt und die dazu gehörenden Problembehandlungsmöglichkeiten.
*CraftBukkit devBuild:
Dies ist die Craftbukkit.jar welche wir in Eclipse einbinden müssen um die dazu gehörenden Methoden verwenden zu können. Dazu später mehr.
Fangen wir an:
Wie ihr euch sicherlich denken könnt, ist es ratsam als aller erstes Eclipse zu starten, denn in diesem Programm schreiben wir unsere Java-Anwendungen.
(Wenn ihr der Sprache Java nicht mächtig seid, so solltet ihr erst ein mal die Grundlagen von Java kennen lernen:
)Wenn wir das geschafft haben, wartet erst einmal ein Begrüßungs-bildschirm auf euch, so fern ihr Eclipse nicht schon ein mal gestartet habt.
Diesen klicken wir einfach weg.
Links im Programm seht ihr eine Spalte, in der euch eure ganzen Projekte,klassen und pakete angezeigt werden. Mit Hilfe dieser Liste könnt ihr euch wunderbar zwischen euren Projekten hin und her bewegen, ganz ohne großen Aufwand zu betreiben.
Als nächstes möchten wir ein neues Projekt erstellen.
Also klicken wir oben links auf 'File' anschließend auf 'New' und wählen:
'Java Project'.
Nun könnt ihr einen Namen für euer Plugin aussuchen.
In diesem Tutorial verwende ich den simplen Namen 'PluginBasics'.
Wir können uns nun den Inhalt des JavaProjekts anzeigen, indem wir auf das kleine '+'-Zeichen klicken, welches links von unserem Projektordner ist.
Innerhalb unseres Projektes befindet sich ein 'src'-Ordner und die JRE System library. Für unser Plugin benötigen wir nun ein Paket(Im englischen 'Package').
In diesem Paket befinden sich all unsere Klassen (Mainclass,Listener etc...).
Also klicken wir mit der rechten Maustaste auf den Ordner 'src' und gehen nun wieder auf 'New' und wählen den Reiter 'Package'.
Bei 'Name' müsst ihr folgendes Format verwenden:
me.EuerName(zum Beispiel: joshi2122).PluginBasics(Also euer Pluginname)
In meinem Fall wäre das: me.joshi2122.PluginBasics
Wie ihr sehen könnt, befindet sich in diesem Paket noch nichts.
Dies ändern wir auch sofort, allerdings müssen wir erst ein mal die Bukkit-Library importieren, welche wir ganz am Anfang herunter geladen haben.
Dies ist notwendig, damit wir die Methoden verwenden können.
Also klicken wir mit der rechten Maustaste auf unser Projekt.
Gehen anschließend auf: Properties -> Java Built path, wählen oben im Menü den Reiter 'Libraries' und gehen anschließend auf Add External Jars.
Nun öffnet sich euch ein Dialog, in dem ihr eine .Jar-Datei wählen sollt.
Hier wählen wir unsere am Anfang heruntergeladene, Bukkit.jar (Welche im Ursprungszustand folgender Maßen heisst: bukkit-1.0.1-R2-SNAPSHOT.jar(Kann abweichen)).
Nun klicken wir auf 'OK'.
Dies sind wirklich nur die Standart mäßigen Bukkit-Methoden.
Sprich, Methoden aus, zum Beispiel, dem PermissionsEx-Plugin sind nicht enthalten und müssen explizit noch hin zu importiert werden.
Jetzt sind wir auch schon bereit, unser erstes Funktionierendes Plugin zu erstellen. Also klicken wir mit der rechten Maustaste auf unser Paket, welches wir vorhin erstellt haben. Gehen wieder auf 'new' und anschließend auf 'Class'. Hier könnt ihr wieder einen Namen wählen.
Ich nenne meine Hauptklasse 'PluginBasics', damit ich nicht so schnell verwirrt werde...
Wie ihr seht hat sich nun Zentral des Programmes ein wenig Code geöffnet.
Um Bukkit mit zu teilen, dass dies ein Plugin ist, müssen wir in folgender Zeile:
PHP Code:
public class PluginBasics {
PHP Code:
extends JavaPlugin
Dies ist ein Error. Um diesen zu beheben streichen wir mit der Maus über 'JavaPlugin' und warten bis uns ein kleines gelbes Fenster erscheint.
Dort steht nun die Möglichkeit, um den Fehler zu beheben, folgendes:
'Import JavaPlugin (org.bukkit.plugin.java)'. Dort klicken wir hin.
Anschließend wird uns nun der Name unserer Klasse rot unterstrichen.
Dort gehen wir auch wieder mit der Maus hin und klicken auf:
Add unimplemented methods.
Wir ihr seht befinden sich nun 2 neue Methoden in unserem Plugin.
-onDisable
-onEnable
In der Methode onDisable werden alle Dinge behandelt, welche geschehen sollen, sobald das Plugin deaktiviert wird.
Hier möchten wir einfach nur in die Konsole ausgeben, dass unser Plugin deaktiviert wurde.
Also schreiben wir:
PHP Code:
System.out.println("PluginBasics wurde deaktiviert");
Das selbe machen wir in der onEnable-methode.
Nur anstatt deaktiviert schreiben wir aktiviert. Klingt irgendwie logisch.
Wer sich nun fragt, was diese ganzen Codezeilen bedeuten, sollten wie oben schon erwähnt, erst einmal die Javabasics lernen.
Ich habe etwas weiter oben auch eine, für mich, sehr gute Videotutorial-Reihe verlinkt.
Das ganze dürfte nun so aussehen (Funktioniert nicht für Copy & paste noobs wegen den Projekt und Paketnamen)
PHP Code:
package me.joshi2122.PluginBasics;
import org.bukkit.plugin.java.JavaPlugin;
public class PluginBasics extends JavaPlugin{
@Override
public void onDisable() {
// TODO Auto-generated method stub
System.out.println("PluginBasics wurde deaktiviert");
}
@Override
public void onEnable() {
// TODO Auto-generated method stub
System.out.println("PluginBasics wurde aktiviert");
}
}
Ich möchte in meinem Beispiel-Plugin nun beispielweise folgende Befehle haben:
/hello:
Hier soll einem folgender Text erscheinen:
Willkommen auf meinem Server <Spielername>
/storm (Ein wenig komplizierter als /hello.)
Hier soll ein Blitz erzeugt werden. Und zwar an der Stelle, wo der Spieler hin schaut.
/heal
Hier wird man geheilt.
Doch dafür muss ich erst einmal die Methode onCommand erstellen.
Die sieht folgendermaßen aus:
PHP Code:
public boolean onCommand(CommandSender sender, Command cmd, String commandlabel,String[] args)
{
}
Also schreiben wir in der ersten Zeile, unter der ersten geöffneten geschweiften Klammer folgendes:
Wir deklaren eine Variable mit dem datentyp boolean. Diese heisst bei mir 'succeed'.
PHP Code:
boolean succeed = false;
Sprich wir müssen folgendes hinzufügen:
PHP Code:
return succeed;
Achtet aber bitte immer beim Importieren von Methode darauf, dass ihr auch die richtige Library wählt. In diesem Fall ist es immer eine Unterordnung von Bukkit.
Nun gut. Wir besitzen nun die Grundlage für die Methode onCommand.
Wir sind nun praktisch dazu bereit, einen Befehl her zu stellen.
Allerdings möchte ich noch auf ein paar Argumente der Methode onCommand eingehen.
CommandSender sender: Dies ist ein Spieler. Und zwar genau derjenige, der den Befehl ausgelöst hat. Es kann aber auch passieren, dass der Befehl extern ausgelöst wurde. Zum Beispiel durch ein weiteres Plugin. (Später mehr dazu)
Command cmd: Dies ist der Befehl an sich. Diesen benötigen wir später, um abzufragen, welcher Befehl überhaupt eingegeben wurde.
String[] args: Dies sind die Argumente, welche verwendet werden können. Diese werde ich in diesem Tutorial nicht weiter erläutern.
Fangen wir mit unserem ersten Befehl an. '/hello'.
Um abzufragen, ob der Befehl /hello ist, benutzen wir folgende If-Schleife:
PHP Code:
if(cmd.getName().equalsIgnoreCase("hello"))
{
//Füge hier das ein, was passieren soll
}
equalsIgnoreCase hat zu folge, dass bei dem Befehl die Groß- und Kleinschreibung keine Rolle spielt.
Würden wir beispielsweise nur 'equals' verwenden, so würde Bukkit den Befehl nicht erkenne, wenn wir auch nur einen einzigen Buchstaben anders geschrieben haben, als hier definiert.
Innerhalb dieser If-Schleife können wir nun das ausführen, was eben passieren soll. Wir erinnern uns daran, dass ich wollte, dass der Spieler den Text 'Willkommen auf meinem Server <Spielername>' sieht.
Um dies zu bewältigen, müssen wir einen String deklarieren, welcher den Namen des Spielers beinhaltet.
Dies geschieht folgender Maßen:
Als erstes müssen wir eine Player Variable erstellen.
PHP Code:
Player player = (Player) sender;
Nun kommt die eigentliche Nachricht.
Um eine Nachricht an einen bestimmten Spieler zu schreiben, verwendet man folgende Methode: 'sendMessage(String);'
in unserem Fall wäre dies folgender Code:
PHP Code:
player.sendMessage("Willkommen auf unserem Server " + player.getName());
Der Inhalt ist im Prinzip folgender "Text" + Spielername
player.getName() erklärt sich eigentlich von selbst.
Da unser Befehl erfolgreich ausgelöst wurde, müssen wir unsere Boolean Variable Succeed noch auf 'true' setzen. Dies brauche ich glaube ich nicht erklären. (Gut, okay: succeed = true; war garnicht so schwer oder?)
Glückwunsch. Du hast nun deinen ersten funktionierenden Befehl programmiert!
Als nächstes widmen wir uns einem etwas schwierigeren Befehl, welcher aber mit auch nur ein wenig Grips machbar sein sollte.
Wir starten wieder einem neuen Befehl namens heal. Wie das geht, haben wir ja grade gelernt. (Achtung ausserhalb des alten Befehls! Also unterhalb der Klammer, welche die If-Schleige schließt!)
Aus bequemlicheren Gründen verschieben wir die Player-Definierung aus den alten Befehl direkt unter die erste Klammer der Methode onCommand, damit wir die playervariable eifnacher nutzen können.
Okay. Der 'Heal'-Befehl ist ganz einfach.
Wir setzen einfach die Lebensanzahl des Spielers auf den Wert 20.
Warum ausgerechnet 20?
Ganz einfach. Jede einzelne Zahl stellt ein halbes Herz dar. Und wir wissen ja,
dass ein Spieler 10 Herzen besitzt. Einfache Mathematik.
Dies bewerkstelligen wir folgendermaßen:
PHP Code:
player.setHealth(20);
succeed = true;
Wir ihr sicherlich gemerkt habt, werden euch sobald ihr 'player.' eingibt, sofort Methoden vorgeschlagen, von denen sich die meisten von selbst erklären! Wenn ihr damit ein wenig rum probiert, könnt ihr ziemlich schnell, gute Dinge auf die Beine stellen.
Das war es auch soweit mit dem /heal Befehl. Ziemlich einfach, oder?
Zu guter Letzt kommt der schwierigste Befehl von den dreien.
Unser /storm Befehl. Dieser soll einen Blitz erzeugen, und zwar genau dort, wo der Spieler hinschaut.
Wir fangen wieder einen neuen Befehl an:
PHP Code:
if(cmd.getName().equalsIgnoreCase("storm"))
{
}
Dazu müssen wir uns erst ein mal ein Radius überlegen, in dem der Spieler einen Blitz erzeugen können soll. Als Beispiel nehme ich den Radius 50.
Der Block, auf den der Spieler schaut, gehört zum DatenTyp Block.
Also definieren wir einen neuen Block:
PHP Code:
Block targetblock = ...
PHP Code:
getTargetBlock
PHP Code:
Block targetblock = player.getTargetBlock(null,50);
Das Zweite Argument, ist der Radius. Wie schon erwähnt, wähle ich den Radius 50.
Mit dieser einen Zeile an Code, haben wir auch schon den Block heraus gefunden, auf den der Spieler schaut.
Nun wollten wir einen Blitz an der Stelle erzeugen. Dies macht man mit der Methode:
PHP Code:
targetblock.getWorld().strikeLightning()
Hier geben wir einfach nur den Standort des targetblocks an.
Also:
PHP Code:
targetblock.getWorld().strikeLightning(targetblock.getLocation());
Das war es eigentlich auch schon mit den drei Beispielbefehlen.
Im nächsten Part des Tutorials behandel ich die Listener.
In denen ihr zum Beispiels Events wie onEntityDeath aufrufen könnt.
Ich hoffe ich konnte euch helfen. Und wenn ihr irgendwelche Fehler findet, sagt mir bitte bescheid.
kompletter code
Allerdings müssen wir nun noch eine plugin.yml anlegen, damit Bukkit auch die verschiedenen Befehle lesen kann!
Dazu klicken wir mit der rechten Maustaste auf den Ordner 'src'. Wählen 'new'.
Gehen auf 'File' und geben einfach den Namen 'plugin.yml' an.
Der Inhalt sieht dann zum Beispiel so aus:
Code:
name: PluginBasics
version: 0.1
description: This is a testplugin
author: Joshi2122
website: http://beispiel.com
main: me.joshi2122.PluginBasics.Pluginbasics
commands:
hello:
description: Saying hello
usage: /<command>
heal:
description: is healing you
usage: /<command>
storm:
description: Creates a lightning!
usage: /<command>
Grüße
EDIT:
Zum Exportieren:
File -> Export -> Java -> JAR File
