Plugin-Erstellung/Java/Plugin Debugging

Aus Rising World Wiki


Plugin Debugging ist ein Rising-World Wiki-Tutorial, das beschreibt, wie Rising-World-Plugins kompiliert, getestet und gedebuggt werden. Behandelt werden verschiedene Methoden zum Kompilieren (Eclipse, Kommandozeile, Build-Tools) sowie Remote Debugging mit Eclipse und anderen IDEs.

Kompilieren

Mit Eclipse

Eclipse ist eine kostenlose, quelloffene und Java-basierte integrierte Entwicklungsumgebung (IDE) zur Softwareentwicklung.
Um ein Plugin in Eclipse zu kompilieren, wird das Projekt als JAR-Datei exportiert. Die generierte JAR-Datei muss anschließend im Plugins-Verzeichnis abgelegt werden, um das Plugin zu testen.[1]

  1. Rechtsklick auf das Projekt > "Export" > "Java" > "JAR file"
  2. Auf "Next" (Weiter) klicken
  3. "JAR file" > "Browse" und den Speicherort wählen

Die generierte .jar-Datei muss im Plugins-Verzeichnis platziert werden, um das Plugin zu testen: 

 Folder-icon.png RisingWorld\Plugins\<PluginName>\MeinPlugin.jar

Die plugin.yml Datei gehört in einen "resources"-Ordner im Quellverzeichnis (üblicherweise unter src/resources/) und wird beim Kompilieren automatisch in das resultierende JAR übernommen.[2]
Weitere Informationen zu plugin.yml enthält der Abschnitt Eclipse Entwicklungsumgebung - plugin.yml Datei

Mit Kommandozeile (javac)

Java-Programme müssen zur Ausführung kompiliert werden. Der Quelltext (.java-Dateien) wird durch den Compiler javac in Bytecode (.class-Dateien) überführt, der dann durch die Java Virtual Machine (JVM) ausgeführt wird. 

javac (ausgesprochen "java-see") ist der primäre Java-Compiler, der im Java Development Kit (JDK) enthalten ist.

Für Rising-World-Plugins wird empfohlen, das mitgelieferte JDK aus dem Spielverzeichnis unter /Data/Java/JDK zu verwenden [3].
Es kann alternativ von jdk.java.net/20 heruntergeladen werden.

Voraussetzungen:

  • JDK muss installiert sein (Java Development Kit), idealerweise aus dem Spielverzeichnis
  • Der Pfad zum JDK muss in den Umgebungsvariablen (PATH) enthalten sein

Einfache Kompilierung

Der Befehl javac HalloWelt.java kompiliert eine einzelne Java-Quelldatei in den ausführbaren Bytecode. Damit der Compiler die Datei verarbeiten kann, muss die Datei eine public class enthalten, deren Name exakt dem Dateinamen entspricht (zum Beispiel HalloWelt.java enthält public class HalloWelt). 

javac HalloWelt.java

Dies erzeugt eine Datei HalloWelt.class im selben Verzeichnis.
Hinweis: Für Rising-World-Plugin-Projekte ist diese Form nicht ausreichend, weil:

  • Rising-World-Plugins in der Regel aus mehreren Klassen und Packages bestehen
  • Die PluginAPI als externe Bibliothek (JAR) eingebunden werden muss
  • Am Ende eine lauffähige .jar-Datei mit plugin.yml benötigt wird

Kompilierung mit Classpath

Wenn das Plugin externe Bibliotheken benötigt (zum Beispiel die PluginAPI.jar), muss der Classpath angegeben werden. Der Classpath teilt dem Compiler mit, wo er benötigte Klassen finden kann.[4] 

javac -classpath "Pfad\zu\SDK\PluginAPI.jar" MeinPlugin.java

Die PluginAPI.jar liegt im Spielverzeichnis unter Folder-icon.png RisingWorld\data\SDK\.

Setzen eines Klassenpfades

Wird der Java-Compiler genutzt, lässt sich der Klassenpfad mit dem Kommandozeilenparameter classpath setzen:[5] [6] 

javac -classpath "pfad1;pfad2" com.package.MainClass
Erklärung
  • javac ist der Befehl zum Aufrufen des Java-Compilers.
  • classpath ist die Option zum Setzen eines oder mehrerer Klassenpfade.
  • pfad1 und pfad2 sind die einzubindenden Klassenbibliotheken.
  • com.package.MainClass ist die zu kompilierende Klasse.

Mehrere Dateien oder Packages

Für größere Projekte mit mehreren Dateien und Packages wird der Parameter -d verwendet, um das Ausgabeverzeichnis explizit anzugeben. Mit Wildcards (zum Beispiel *.java) können alle Quelldateien eines Verzeichnisses auf einmal kompiliert werden. 

javac -d "<Ausgabeverzeichnis>" -classpath "<Pfad>\zu\PluginAPI.jar" src\net\meinpackage\*.java

Der Parameter -d gibt das Ausgabeverzeichnis für die .class-Dateien an.
Plugins-Verzeichnis Folder-icon.png RisingWorld\Plugins\MainErstesPlugin\ .

Erstellen einer JAR-Datei

Nach der Kompilierung müssen die .class-Dateien in eine JAR-Datei (Java Archive) gepackt werden. Java Archive ist notwendig damit ein Rising World Java Plugin geladen wird. Dabei ist darauf zu achten, dass die plugin.yml-Datei aus dem resources-Ordner mit in das JAR übernommen wird: 

jar cvf MeinPlugin.jar net\meinpackage\*.class resources\plugin.yml

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.
Die resultierende JAR-Datei wird anschließend im Plugins-Verzeichnis Folder-icon.png RisingWorld\Plugins\MainErstesPlugin\ platziert.

Siehe auch:


ToDo Informationen: Manifest Datei, Pfad zur Manifest-Datei, jar Parameter, Sollte die JAR-Datei bereits existieren oder nur den Inhalt hinzufügen dann die Option u (update) statt c
...

Mit Build-Tools

Für komplexe Projekte wird die Verwendung von Build-Tools wie Maven, Gradle oder Entwicklungsumgebung (IDE) empfohlen. Diese Tools verwalten Abhängigkeiten und das Kompilieren automatisch.

Maven

Maven verwendet eine pom.xml-Datei (Project Object Model) als zentrale Konfigurationsdatei: 

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>net.meinpackage</groupId>
    <artifactId>MeinPlugin</artifactId>
    <version>0.2.0</version>

    <dependencies>
       ... 
    </dependencies>

    <build>
       ... 
    </build>
</project>

Kompilieren und Packen: 

mvn clean package

Gradle

Gradle verwendet eine build.gradle-Datei zur Konfiguration: 

plugins {
    id 'java'
}

repositories {
    flatDir {
        dirs '<Pfad>/zu'
    }
}

dependencies {
    implementation name: 'PluginAPI'
}

jar {
    from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}

Kompilieren und Packen: 

gradle build

Dynamisches Kompilieren mit projectinfo.txt

Fortgeschrittene Plugin-Entwickler können mit der projectinfo.txt arbeiten. Diese Datei ermöglicht das dynamische Kompilieren von Plugins während des Spielbetriebs.

Vorteile
  • Änderungen am Java-Plugin-Code können vorgenommen werden, während das Spiel läuft
  • Es ist kein manueller Export und kein Kopieren von JAR-Dateien erforderlich
Voraussetzungen
  • Alle JAR-Dateien werden aus dem Plugin-Ordner entfernt
  • Stattdessen wird eine projectinfo.txt im Plugin-Ordner erstellt

Beispiel projectinfo.txt: 

name: TestPlugin
path: Pfad\zum\Plugin-Projekt\src
libs: Pfad\zum\ToolsAPI
loadorder: -100
Felder
  • name – Name des Plugins
  • path – Pfad zum "src" Ordner des Plugin-Projekts
  • libs – Optional: Pfad zum "libs" Ordner mit den erforderlichen Bibliotheken (wird beim Kompilieren rüberkopiert)
  • loadorder – Optional: Lade-Reihenfolge (niedrigere Werte = früheres Laden)
  • assets – Optional: Asset-Pfade, wenn das Plugin Assets verwendet

Debugging

Konsolen-Debugging

Der einfachste Weg zum Debuggen ist die Verwendung von Konsolenausgaben mit System.out.println(): 

@Override
public void onEnable() {
    System.out.println("Plugin wird geladen...");
    registerEventListener(this);
    System.out.println("Event-Listener registriert");
}

Die Ausgaben erscheinen in der Server-Konsole und in der Log-Datei (Player.log).

Remote Debugging mit Eclipse

Eine Remote-Debugging-Session mit Eclipse kann mit der Java Virtual Machine (JVM) verbunden werden, in der Rising World Plugin läuft.[7] Dies ermöglicht das Setzen von Breakpoints und das schrittweise Durchlaufen des Codes. Die Vorgehensweise wird im Abschnitt Remote debuggen des Eclipse-Tutorials beschrieben.

Schritt 1: JVM im Debug-Modus starten Die JVM wird mit zusätzlichen Debug-Optionen gestartet. Dies wird über die Einstellung Plugins_VMOptions in der config.properties-Datei (Singleplayer) oder server.properties-Datei (Dedicated Server) konfiguriert. Mehrere Optionen werden durch Semikolon getrennt: 

 
# Max amount of heap memory (MB) for the Java VM. Default: 1024
Plugins_Memory=1024

# Optional Java VM options, separated by semicolon 
Plugins_VMOptions=-Xdebug;-Xnoagent;-Djava.compiler=NONE;-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000

Siehe auch: Forum: Plugin Remote debuggen?.

Erklärung der Optionen
  • -Xdebug – Aktiviert den Debug-Modus
  • -Xnoagent – Deaktiviert den alten sun.tools.debug Agent
  • -Djava.compiler=NONE – Deaktiviert den JIT-Compiler
  • -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000 – Konfiguriert JDWP (Java Debug Wire Protocol)
    • transport=dt_socket – Verwendet Socket-Transport
    • server=y – Die JVM fungiert als Server
    • suspend=n – Startet nicht im angehaltenen Modus (für suspend=y wird der Start angehalten, bis der Debugger verbunden ist)
    • address=8000 – Port für die Debug-Verbindung (kann geändert werden, zum Beispiel auf 8008 bei Konflikten)

Remote Debugging mit Visual Studio Code (VS Code)

Um Java-Code in Visual Studio Code (VS Code) remote zu debuggen, muss die Remote-JVM mit JDWP-Argumenten gestartet und VS Code anschließend per launch.json angebunden werden.
...

Wichtig
  • der lokale Projektcode muss identisch mit dem Remote-Code sein
  • dass die Firewall den Debug-Port (z. B. 8000) freigibt
  • JDK-Versionen zwischen Debugger und Ziel-JVM muss gleich sein. Bei abweichenden JDK-Versionen kann es zu Fehlschlägen beim Source-Mapping kommen.

Remote Debugging mit NetBeans

...

IntelliJ IDEA

...

Debugging mit KI-Code-Agenten

Künstliche Intelligenz (KI)-basierte Code-Agenten (wie z. B. Cursor, Claude, MiniMax Code oder ähnliche Tools) können Plugin-Entwickler beim Debugging von Rising World Plugins unterstützen. Sie eignen sich besonders für die Analyse von der Konsole, Log-Dateien und die Fehlersuche.

Mögliche Einsatzbereiche

  • Konsolenausgaben lesen und analysieren: Die Server-Konsole und die Log-Datei (Player.log) werden nach Fehlermeldungen und Stack-Traces durchsucht. Relevante Zeilen werden dem Entwickler zur weiteren Analyse vorgelegt.
  • Analyse von Log-Ausgaben: KI-Agenten können die Server-Konsole sowie Log-Dateien (z. B. Player.log oder Server-Logs) systematisch nach Fehlermeldungen, Exceptions und Stack-Traces durchsuchen und relevante Stellen hervorheben.
  • Log-Dateien prüfen: Systematische Durchsicht der Log-Dateien (insbesondere der Server-Log-Datei auf einem Dedicated Server) auf wiederkehrende Muster und Fehlertypen.
  • Debug-Statements einbauen: System.out.println()-Anweisungen werden an strategischen Stellen im Code ergänzt, um Werte zur Laufzeit sichtbar zu machen.
  • Code-Abschnitte erklären: Logik, die Stack-Traces auslöst, wird analysiert, dem Entwickler erläutert und mögliche Ursachen aufgezeigt.

Einschränkungen

KI-Code-Agenten können keine direkte interaktive Remote-Debugging-Session mit der Java Virtual Machine (JVM) aufbauen. Dies erfordert weiterhin eine IDE wie Eclipse,
...

Überwachung von CMD / PowerShell

KI-Agenten können Windows-Befehlszeilen (CMD oder PowerShell) ausführen und deren Ausgaben verarbeiten. Für kontinuierliches Monitoring eignen sich dedizierte Lösungen wie Icinga für Windows in Kombination mit PowerShell-Cmdlets.
...

Spielstart über CMD

KI-Agent kann Windows CMD (bzw. PowerShell) überwachen und auslesen – aber mit Einschränkungen. Rising World (Steam AppID 324080) kann über die Kommandozeile gestartet werden.
...

Minimaler Start

Windows-Eingabeaufforderung (CMD) Standard-Befehl 

steam.exe -applaunch 324080

Mit diesem Aufruf startet Steam das Spiel, ohne dass in der CMD-Konsole sichtbare Debug-Ausgaben erscheinen. Nach dem Start des Spiels kehrt die Konsole sofort in den Eingabezustand zurück (also kein blockierender Aufruf).[8]
Mit dem reinen -applaunch 324080-Aufruf sind weder Steam- noch Spiel-Ausgaben in der Konsole zu sehen. Die Konsole ist sofort nach Spielstart wieder für weitere Kommandos bereit.

Start mit Debug-Parametern

Zusätzliche Steam-Parameter können die Debug-Ausgabe aktivieren [9] Siehe dazu Steam (valve software) - Command line options, Command-Line Parameters und Developer console. 

"C:\Program Files (x86)\Steam\steam.exe" -applaunch 324080 -dev -console

Spielstart über PowerShell

PowerShell[10] (ideal für KI)
Grundlegender Aufruf: 

Start-Process -FilePath "C:\Pfad\Zur\Anwendung.exe"


Über Steam Rising World starten: 

Start-Process -FilePath "steam.exe" -ArgumentList "-applaunch 324080"

Weitere Informationen unter Microsoft learn: PowerShell Start-Process

Siehe auch

Forum

Externe Quellen

Wiki Seiten: Plugin-Erstellung


Kategorien

Java
Java‎ (2 K, 8 S)
Java-Codeschnipsel‎ (10 S)
Plugin-API‎ (1 K, 11 S)
 Tutorial Kategorie
Tutorial‎ (5 S)
Keine Unterkategorien


Einzelnachweise

  1. ↑ https://forum.rising-world.net/thread/4757-create-a-plugin/
  2. ↑ https://forum.rising-world.net/thread/4757-create-a-plugin/
  3. ↑ https://forum.rising-world.net/thread/13419-stimmt-jdk-20-f%C3%BCr-plugins-noch/?postID=99444#post99444
  4. ↑ https://de.wikipedia.org/wiki/Klassenpfad
  5. ↑ https://de.wikipedia.org/wiki/Klassenpfad
  6. ↑ https://web.mit.edu/java_v1.1.6/www/tools/javac.html
  7. ↑ https://forum.rising-world.net/thread/13433-plugin-remote-debuggen/
  8. ↑ https://developer.valvesoftware.com/wiki/Command_line_options_(Steam)
  9. ↑ https://developer.valvesoftware.com/wiki/Command_line_options_(Steam)
  10. ↑ https://learn.microsoft.com/de-de/powershell/module/microsoft.powershell.management/start-process
Abgerufen von „https://wiki.rising-world.net/w/index.php?title=Plugin-Erstellung/Java/Plugin_Debugging&oldid=4325“