Plugin-Erstellung/Java/Eclipse Entwicklungsumgebung

Aus Rising World Wiki
Eclipse Entwicklungsumgebung Tutorial

Erstellung eines JAVA Plugin-Projekts für Rising World in Eclipse

In diesem Tutorial wird beschrieben, wie man ein JAVA Plugin-Projekt für die Rising World Plugin-API in der Entwicklungsumgebung Eclipse erstellt. Eclipse ist eine weit verbreitete und leistungsfähige Entwicklungsumgebung, die sich ideal für Java-Projekte eignet, einschließlich der Entwicklung von Plugins für Spiele wie Rising World.


Eclipse installieren

Zuerst muss sichergestellt werden, dass Eclipse auf dem Computer installiert ist. Eclipse kann von der offiziellen Webseite eclipse.org/downloads/packages heruntergeladen werden. Für die Entwicklung von Java-Anwendungen sollte die "Eclipse IDE for Java Developers" Version ausgewählt werden.


Java Development Kit (JDK) installieren

Für die Plugin-Entwicklung ist das Java Development Kit (JDK) erforderlich. JDK 20 wird empfohlen, da es mit der Rising World Plugin-API kompatibel ist. Es ist empfehlenswert, es aus dem Spielverzeichnis zu verwenden: _New Version/Data/Java/JDK . Es kann alternativ von jdk.java.net/20 heruntergeladen werden.
Nach der Installation von der JDK muss in Eclipse der Pfad zum JDK konfiguriert werden.

Pfad zum JDK konfigurieren

Es wird empfohlen JDK aus dem Spielverzeichnis zu verwenden.
Um Pfad zum JDK in Eclipse zu konfigurieren:

  1. Öffnen der Einstellungen
    • Navigieren Sie zu "Window" (Fenster) im oberen Menü
    • Wählen Sie "Preferences" (Einstellungen) aus dem Dropdown-Menü. Dadurch wird ein neues Fenster mit den Eclipse-Einstellungen geöffnet.
  2. Suchen der Java-Einstellungen
    • Im linken Bereich des Einstellungsfensters befindet sich ein Baummenü
    • Erweitern Sie den Knoten "Java" durch einen Klick auf das Pluszeichen (+)
  3. Auswählen des Installierten JREs
    • JRE steht für "Java Runtime Environment". Es ist eine Laufzeitumgebung für Java-Anwendungen.
    • Wählen Sie "Installed JREs" (Installierte JREs) unter dem Java-Knoten aus
  4. Hinzufügen des JDK-Pfads
    • Klicken Sie auf den Button "Add..." (Hinzufügen...), um ein neues installiertes JRE hinzuzufügen
    • Wählen Sie "Standard VM" und klicken Sie auf "Next" (Weiter)
    • Klicken Sie auf "Directory..." (Verzeichnis...)
    • Navigieren Sie zu Ihrem Spielverzeichnis "...\RisingWorld\_New Version\Data\Java\JDK"
    • Wählen Sie den Ordner "JDK" aus und klicken Sie auf "OK" (oder "Ordner auswählen")
    • Klicken Sie auf "Finish" (Fertigstellen)
  5. Festlegen des neuen JRE als Standard
    • Stellen Sie sicher, dass das Kontrollkästchen neben dem neu hinzugefügten JDK-Pfad aktiviert ist
    • Klicken Sie auf "Apply and Close" (Übernehmen und Schließen)

Nachdem diese Schritte abgeschlossen sind, ist der Pfad zum JDK in Eclipse konfiguriert. Jetzt können Sie Eclipse verwenden, um Plugins für die Rising World Plugin-API zu entwickeln und dabei das JDK aus dem Spielverzeichnis zu verwenden.

  • "Add" - Auswählen des Installierten JREs

  • Festlegen des neuen JRE als Standard und übernehmen

Neues Projekt anlegen

  1. Eclipse öffnen und auf "File" > "New" > "Java Project" klicken.
  2. Im Dialogfeld "New Java Project" den Projektnamen eingeben, z.B. "RisingWorldPlugin".
  3. Bei der JRE auf "Use an execution environment JRE:" gehen und die passende Java-Version auswählen, die mit der Rising World API kompatibel ist.
  4. Klicken Sie auf "Next" und dann auf "Finish".


Einbindung der Rising World Plugin-API

Einbindung der Plugin-API

Das Spiel wird bereits mit der API-Bibliothek (PluginAPI.jar) und dem entsprechenden JavaDoc (javadoc.zip) ausgeliefert, beides ist im
Spielverzeichnis unter Folder-icon.png RisingWorld\_New Version\Data\SDK\ zu finden. Wenn Sie die API aus dem Spielverzeichnis verwenden, verwendet Ihre IDE immer automatisch die neueste API. Unter diesem Link gibt es eine Online-Version des neuesten JavaDoc: API Packages.

Einbindung:

  1. Im Eclipse-Projektbaum mit der rechten Maustaste auf das Projekt klicken und "Properties" auswählen.
  2. Zum Bereich "Java Build Path" navigieren und zum Reiter "Libraries" wechseln
  3. Auf "classpath" klicken
  4. Auf "Add External JARs..." klicken und die PluginAPI.jar Datei auswählen
  5. auf "classpath" verschieben wenn nötig
  6. Auf "Apply and Close" klicken

Im Eclipse-Projektbaum ist "Referenced Libraries" erschienen

Plugin erstellen

Im folgenden Beispiel nennen wir dein Paketnamen mainerstesplugin und deine Klasse MyPluginClass.

  1. Rechtsklick auf das Projekt > "New" > "Package" und einen Paketnamen wie net.mypackage.mainerstesplugin angeben
  2. Auf "Finish" klicken
  3. Rechtsklick auf das neu erstellte Paket > "New" > "Class" und einen Klassennamen MyPluginClass eingeben
  4. Auf "Finish" klicken und die Klasse wird erstellt
  5. Folgenden Code als Beispiel eingeben, um mit der Entwicklung zu beginnen:
package net.mypackage.mainerstesplugin;

import net.risingworld.api.Plugin;
import net.risingworld.api.events.EventMethod;
import net.risingworld.api.events.Listener;
import net.risingworld.api.objects.Player;
import net.risingworld.api.events.player.PlayerConnectEvent;
import net.risingworld.api.events.player.PlayerSpawnEvent;
import net.risingworld.api.events.player.PlayerCommandEvent;

public class MyPluginClass extends Plugin implements Listener
{
    @Override
    public void onEnable()
    {
       registerEventListener(this);
       System.out.println(this.getName() + ":  ist geladen");
    }

    @Override
    public void onDisable()
    {
        System.out.println("Mein Plugin wurde entladen !");
    }
    
    @EventMethod
	public void onPlayerConnectEvent(PlayerConnectEvent event) 
	{
		Player player = event.getPlayer(); 
		System.out.println(this.getName() + ":  Player Connect");
		player.sendTextMessage("Player "+player.getName()+" Connect");
	}

    @EventMethod
    public void onPlayerSpawn(PlayerSpawnEvent event)
    {
        Player player = event.getPlayer();
        player.sendTextMessage("Player "+player.getName()+" Spawn");
    }

    @EventMethod
    public void onPlayerCommand(PlayerCommandEvent event) 
    {
        //diese Methode wird aufgerufen, wenn das "PlayerCommandEvent" ausgelöst wird
        //d.h. wenn ein Spieler einen Befehl in den Chat eingibt

		//Befehl durch Leerzeichen Teilen
		String[] cmd = event.getCommand().split(" ");

		//Spieler, der den Befehl ausgeführt hat
		Player player = event.getPlayer();

		//Wenn der Spieler "/kill" eingibt, töte ihn
		if (cmd[0].equalsIgnoreCase("/kill")) 
		{
	        player.kill();
	    }
    }
}
Rising World Plugin API Links.  

Projektname

Der Projektnamen ist der Name, der einem Projekt in Eclipse zugewiesen wird. Er wird bei der Erstellung eines neuen Projekts festgelegt und dient dazu, das Projekt innerhalb der Eclipse-Arbeitsumgebung zu identifizieren. Der Projektnamen kann aus Buchstaben, Zahlen und einigen Sonderzeichen bestehen, aber es wird empfohlen, keine Leerzeichen zu verwenden, da Eclipse dies nicht unterstützt.

Paketname

Der Paketname ist der Name, der einem Paket innerhalb eines Projekts zugeordnet wird. Ein Paket ist eine logische Gruppierung von Klassen und anderen Ressourcen in einem Projekt. Der Paketname wird in Kleinbuchstaben geschrieben und sollte eine Domain-Namenskonvention verwenden, z. B. "net.example.myproject" oder "net.mypackage.mainplugin". Dies hilft, Konflikte zwischen Paketnamen zu vermeiden und die Organisation von Klassen und Ressourcen zu erleichtern. Klassen befinden sich immer in Paketen. Methoden und Klassen können vollqualifiziert (d.h. mit dem Paketnamen) benannt werden. 

Es ist wichtig, den Paketnamen in Kleinbuchstaben zu schreiben, 
da Java und Eclipse die Groß- und Kleinschreibung von Paketnamen nicht unterscheiden.

Fehler

Eine rote Schlangenlinie über import net. ...
Falls ein Fehler auftritt und eine rote Schlangenlinie über import net.risingworld.api zu sehen ist,
setze alles unter Properties -> Java Build Path -> Libraries auf classpath und lösche die Datei module-info.java. Dann speichern wenn nötig und Eclipse neu starten.

Nach dem Neustart wird das Projekt dort keinen Fehler mehr aufweisen.

 

plugin.yml Datei

Die Definitionsdatei "plugin.yml" ist notwendig. Jedes Plugin benötigt eine Definitionsdatei. Sie muss "plugin.yml" heißen und gehört in einen "resources"-Ordner in dem Quellverzeichnis. Nach dem kompilieren wird der Ressourcenordner automatisch zum resultierenden JAR hinzugefügt.
Siehe auch: Rising World Forum: Create a Plugin

Erstellen

plugin.yml Datei erstellen
  • Erstelle einen "resources" Ordner in dem Quellverzeichnis unter /src
  • Erstelle eine "plugin.yml" Textdatei in src/resources/
  • Kopiere "plugin.yml" Beispiel in die Datei und passe es an

Siehe: help.eclipse: Working with Folders and Resources und help.eclipse: Creating a folder (Erstellen eines Ordners)

Beispiel

Hier ist ein Beispiel für die "plugin.yml" Definitionsdatei: 

name: MyPluginName
main: net.mypackage.mainerstesplugin.MyPluginClass
version: 0.0.1
author: <AuthorName>
team: <your team, optional>
description: "RW Plugin description ..."
loadorder: 0
license: MIT
website: http://www.optional_homepage_url.com

Eigenschaften

plugin.yml Datei Beispiel
  • name - Name des Plugins.
  • main - Pfad zur Hauptklasse des Plugins einschließlich des Pakets.
  • version - Versionsnummer des Plugins.
  • author - Name des Plugin-Erstellers.
  • team - Optional; Teammitglieder des Plugins.
  • description - Beschreibung des Plugins.
  • loadorder - Optional; gibt an, ob das Plugin früher oder später als andere Plugins geladen werden soll.
  • license - Lizenz des Plugins.
  • website - Website des Plugins oder des Erstellers.

Diese Eigenschaften sind wichtig für die ordnungsgemäße Funktion und Identifizierung eines Plugins. Einige davon sind jedoch optional und können je nach Bedarf ergänzt werden.

90%


Plugin kompilieren und testen

Um das Plugin zu kompilieren, einfach das Projekt in Eclipse bauen.

  1. Rechtsklick auf das Projekt > "Export" > "Java" > "JAR file"
  2. klicken Sie auf "Next" (Weiter)
  3. "JAR file" > "Browse"

Die generierte .jar-Datei soll dann im
Plugins-Verzeichnis Folder-icon.png RisingWorld\_New Version\Plugins\MainErstesPlugin\ platziert werden, um das Plugin zu testen.

Dynamisch kompilieren

Optional können fortgeschrittene Plugin-Entwickler mit der "projectinfo.txt" arbeiten.
Diese Datei bietet eine praktische Möglichkeit, Plugins dynamisch mit dem Rising World Spiel zu kompilieren.
Hier sind einige wichtige Punkte zur Verwendung der "projectinfo.txt":

  • Die "projectinfo.txt" ermöglicht das dynamische Kompilieren von Plugins während des Spielbetriebs.
  • Sie ist besonders nützlich, wenn Änderungen am Java-Plugin-Code vorgenommen werden, während das Spiel läuft.
  • Um sie zu nutzen, müssen alle JAR-Dateien aus dem Plugin-Ordner im Spiel entfernt werden, und stattdessen wird eine "projectinfo.txt" erstellt.
  • In der "projectinfo.txt" werden der Name des Plugins, der Pfad zum "src" Ordner des Plugin-Projekts
  • Optional der Pfad zum "libs" Ordner mit den erforderlichen Bibliotheken angegeben. Die Dateien bzw. der Ordner, der unter libs angegeben wurde, wird beim Kompilieren rüberkopiert.
  • Zusätzlich kann auch eine loadorder definiert werden, um anzugeben, ob das Plugin früher oder später als andere Plugins geladen werden soll.
  • Wenn das Plugin Assets verwendet, können auch Asset-Pfade in der "projectinfo.txt" angegeben werden.

Ein Beispiel für den Inhalt einer "projectinfo.txt" Datei: 

name: TestPlugin
path: C:\Users\Name\Projects\Rising World\TestPlugin\src
libs: C:\Users\Name\Projects\Rising World\ToolsAPI
loadorder: -100

Siehe: RW Forum: Antwort von red51


Weiterentwicklung und Debugging

Weiterhin ist es empfehlenswert, regelmäßig neue Features zu implementieren, das Plugin zu testen und Fehler zu beheben. Eclipse bietet umfassende Debugging-Tools, die dabei helfen können, Probleme effizient zu identifizieren und zu lösen. ...

Remote debuggen

Es ist möglich Eclipse mit einer Remote Debugging Session mit der Virtual Machine zu verbinden.
Siehe:

Siehe auch

Abgerufen von „https://www.rising-world-wiki.de/index.php?title=Plugin-Erstellung/Java/Eclipse_Entwicklungsumgebung&oldid=2440“