Schlosser Let’s Craft Code!

Wie du deine Minecraft-Welt mit Plugins erweiterst
1. Auflage 2025
ISBN: 978-3-367-11295-1
Verlag: Rheinwerk
Format: EPUB
Kopierschutz: 0 - No protection

E-Book, Deutsch, 438 Seiten

Reihe: Rheinwerk Computing

Mit Minecraft-Plugins ganz einfach Programmieren lernen!

Baue dein eigenes Minecraft! Der Enderdrache ist besiegt, die Base steht auf festen Beinen, aber irgendwie willst du mehr aus deinem Server machen? Plugins sind der Schlüssel zu einer ganz neuen Minecraft-Welt . In diesem Buch lernst du, wie du deine eigenen Plugins mit Java entwickelst – von neuen Crafting-Rezepten über das Design epischer Schlachten bis hin zu modifizierten Monstern und Ausrüstungsgegenständen. Mit deinen Plugins kannst du ein ganz neues Minecraft erfinden – und lernst nebenbei Schritt für Schritt die Programmierbasics in Java .

• Minecraft-Plugins entwickeln ohne Vorkenntnisse
• Dynamische Charaktere, Steuerung per Chat, magische Explosionen, stylische Inventarmenüs und vieles mehr
• Eigene Features erstellen, zum Mitspielen ohne Installation oder Mods
• Ohne Vorkenntnisse einsteigen und mit Java programmieren lernen

Aus dem Inhalt:

• Tools installieren und das erste Plugin-Projekt erstellen
• Basics zum Aufbau von Quellcode
• Datentypen und Variablen
• Arrays und Kontrollstrukturen
• Items und Inventare modifizieren
• Monster und Rüstungsgegenstände selbst erstellen und spawnen
• Eigene Crafting-Rezepte entwickeln
• Item-Shops und Arenakämpfe auf dem eigenen Server

Autoren/Hrsg.

Schlosser, Max

Inhaltsverzeichnis

  Vorwort ... 13

  1.  Einleitung: Willkommen in der Welt der Minecraft-Plugin-Programmierung ... 15

       1.1 ... Was sind Minecraft-Plugins, und warum macht es Spaß, sie zu entwickeln? ... 16

       1.2 ... Die wichtigsten Fragen vor dem Lesen ... 17

       1.3 ... Struktur des Buches ... 20

       1.4 ... Übersicht über die Kapitel ... 23

  2.  Aller Anfang ist leicht: Die ersten Schritte zur Plugin-Entwicklung ... 27

       2.1 ... Was ist Java, und warum nutzen wir diese Programmiersprache? ... 27

       2.2 ... Das Plugin-Projekt erstellen ... 39

       2.3 ... Testnachrichten in der Konsole ausgeben ... 64

  3.  Los geht's: Programmier-Basics mit Plugins kennenlernen ... 77

       3.1 ... Einen einfachen Befehl erstellen und registrieren ... 78

       3.2 ... Fehler finden und behandeln ... 95

       3.3 ... Methoden machen das Leben einfacher ... 99

       3.4 ... Datentypen und Variablen ... 105

       3.5 ... Methoden mit Parametern und Rückgabewerten ... 115

       3.6 ... Ein wenig Mathematik ... 124

       3.7 ... Musterlösungen für die Übungen ... 134

  4.  Mehr Kontrolle im Quellcode: Kontrollstrukturen und Arrays ... 137

       4.1 ... Wahrheitswerte und »if«-Abfragen ... 137

       4.2 ... Arrays ... 149

       4.3 ... Schleifen ... 156

       4.4 ... Musterlösungen für die Übungen ... 170

  5.  Hör mal, wer da hämmert: Events mit einem Listener abhören ... 175

       5.1 ... Einen Listener schreiben und registrieren ... 176

       5.2 ... Weitere Beispiele für Listener ... 180

       5.3 ... Musterlösungen für die Übungen ... 190

  6.  Hol mehr aus deinen Ideen: Weitere Plugin-Basics ... 193

       6.1 ... Bestimmte Aktionen an Spielern vornehmen ... 193

       6.2 ... Mit Blöcken arbeiten ... 198

       6.3 ... Die Welt manipulieren ... 204

  7.  Die Mischung macht's: Collections und funktionales Programmieren ... 213

       7.1 ... Listen ... 213

       7.2 ... Maps ... 224

       7.3 ... Grundlagen der funktionalen Programmierung ... 231

       7.4 ... Musterlösungen für die Übungen ... 242

  8.  Befehlshaber: Fortgeschrittene Befehle erstellen ... 247

       8.1 ... Tab-Vervollständigung hinzufügen ... 248

       8.2 ... Berechtigungen für Befehle festlegen ... 253

       8.3 ... Chatnachrichten aufhübschen ... 258

  9.  Ausrüstung leicht gemacht: Items und Inventare ... 265

       9.1 ... Items erstellen und nutzen ... 266

       9.2 ... Virtuelle Inventare erstellen ... 278

       9.3 ... Musterlösungen für die Übungen ... 290

10.  Daten und Einstellungen speichern: Configs ... 293

       10.1 ... Daten in einer Config speichern und laden ... 294

       10.2 ... Musterlösungen für die Übung ... 303

11.  Gut Ding will Weile haben: Asynchrone Prozesse ... 305

       11.1 ... Nutzung von BukkitTasks ... 305

       11.2 ... Musterlösungen für die Übungen ... 314

12.  Grausame Monster und schwebende Hologramme: Entities manipulieren ... 319

       12.1 ... Entities erstellen und verändern ... 320

       12.2 ... Musterlösungen für die Übungen ... 339

13.  Komplexbeispiele 1 ... 343

       13.1 ... Aufgaben ... 343

       13.2 ... Musterlösungen ... 346

14.  Werkbänke mit Kniff: Eigene Crafting-Rezepte erstellen ... 357

       14.1 ... Neue Rezepte anlegen ... 357

       14.2 ... Bestimmte Items für dein Rezept voraussetzen ... 364

       14.3 ... Musterlösungen für die Übungen ... 370

15.  Informationen übersichtlich darstellen: Scoreboards ... 375

       15.1 ... Die Tabliste verändern ... 375

       15.2 ... Sidebar-Scoreboards anlegen und nutzen ... 379

       15.3 ... Musterlösung für die Übungen ... 387

16.  Eine Klasse für sich: Grundlagen der objektorientierten Programmierung ... 389

       16.1 ... Einführung Klassen ... 390

       16.2 ... Vererbung ... 406

       16.3 ... Exkurs: Exceptions mit »try ... catch« behandeln ... 415

       16.4 ... Exkurs: Interfaces am Beispiel von »ConfigurationSerializable« ... 417

       16.5 ... Static ... 422

       16.6 ... Musterlösungen für die Übungen ... 424

17.  Komplexbeispiele 2 ... 427

       17.1 ... Komplexbeispiel 17.01: Ein passabler Parkour ... 427

       17.2 ... Komplexbeispiel 17.02: Die Schlimmstein-Bombe ... 428

       17.3 ... Komplexbeispiel 17.03: Hokuspokus ... 428

       17.4 ... Komplexbeispiel 17.04: Schönheit liegt im Auge ... ... 429

       17.5 ... Komplexbeispiel 17.05: Waffenspiel der Wahrheit ... 429

       17.6 ... Weitere Ideen zum Selbst-Umsetzen ... 430

18.  Wie geht es weiter? ... 431

  Index ... 433

Leseproben

2    Aller Anfang ist leicht: Die ersten Schritte zur Plugin-Entwicklung

Dreimal auf Holz geklopft

Nun kann es also losgehen: Du weißt, was dich in diesem Buch erwartet, und bist sicher schon gespannt, deine ersten Plugins zu programmieren. Dieses Kapitel legt dafür die wichtigsten Grundlagen, was leider auch ein wenig Theorie mit sich bringt. Ich kann dir dafür versprechen: So theoretisch wie in diesem Kapitel wird es danach nicht mehr.

Gleichzeitig warten auch coole praktische Dinge auf dich: Schon in diesem Kapitel wirst du dein erstes Plugin erstellen, das von deinem Server erkannt wird. Davor müssen wir allerdings noch ein paar Dinge erledigen. Zunächst müssen wir einiges auf deinem Computer einrichten: Wir benötigen eine Umgebung für die Programmiersprache, mit der wir im Buch arbeiten, und installieren ein Programm, das uns beim Programmieren unterstützt. Außerdem erstellen wir das erste Plugin und setzen einen Test-Server auf, der direkt auf deinem Rechner läuft und dem du dann im Mehrspielermodus beitreten kannst. Zu dem neu angelegten Plugin erkläre ich dir im Detail, welche Bedeutung verschiedene Dinge im Code haben und welche wichtigen Dateien wir für ein Plugin erstellen müssen. So verstehst du von Anfang an, wie du dich im Code zurechtfindest, und kannst im Laufe des Buches viel einfacher deine eigenen Ideen entwickeln oder neue Plugins erstellen.

2.1    Was ist Java, und warum nutzen wir diese Programmiersprache?

Wenn du noch nie zuvor programmiert hast, kennst du sicher viele Mythen und Legenden rund um Programmiersprachen und Quellcode: Kryptisch aussehender Text, den nur absolute Genies schreiben und verstehen können und der von der einen auf die andere Sekunde über den Bildschirm flackert.

Glücklicherweise ist es viel leichter als das, und wie du schon in diesem Kapitel sehen wirst, kannst auch du Quellcode leichter verstehen und sogar selbst schreiben, als du es dir im Moment noch zutraust. All das ermöglicht uns eine Programmiersprache. In den letzten Jahrzehnten und sogar noch im letzten Jahrhundert sind zahlreiche Programmiersprachen entstanden, die alle ein gemeinsames Ziel eint: Uns das Leben beim Entwickeln von Programmen oder auch Minecraft-Plugins leichter zu machen. Dafür schreiben wir den schon oft erwähnten Quellcode (kurz Code genannt): Das ist Text, der fest vorgeschriebenen Regeln folgt und den wir mit ein wenig Hintergrundwissen und Erfahrung gut lesen und schreiben können. Dabei werden viele Sonderzeichen verwendet, die du in normalen Texten nur selten findest. Im Quellcode haben diese Zeichen aber meist eine besondere Bedeutung, sodass schon das Hinzufügen oder Entfernen nur eines Zeichens ungeahnte Folgen haben kann.

Ein Beispiel für die schnelle Wirkung von Änderungen im Quellcode

Um ein Beispiel für solche Folgen zu nennen: Stell dir vor, dass du mit deinem Plugin die Geschwindigkeit eines Monsters verändern willst. Fügst du aus Versehen (oder auch absichtlich) ein Minuszeichen (–) vor die Zahl der Geschwindigkeit, bekäme die Zahl plötzlich eine völlig andere Bedeutung. Statt einer hohen Zahl wäre der Wert nun auf einmal kleiner als 0, was kein gültiger Geschwindigkeitswert mehr wäre. Solche Fehler schleichen sich schnell ein, hier musst du also aufmerksam sein.

Wenn du Code geschrieben hast, folgt ein wichtiger Prozess: Nun muss der Text, den wir als Menschen verstehen könnten, für den Computer lesbar gemacht werden. Die technischen Details sind an dieser Stelle gar nicht so wichtig, doch stell es dir so vor, dass dein PC am Ende nur mit den Zahlen 0 und 1 arbeitet. Denken wir am besten gar nicht daran, Abfolgen aus 0 und 1 von Hand zu schreiben, sondern verwenden wir den magischen Vorgang des Kompilierens. Im Englischen wird dieser Prozess auch Compiling genannt, das passende Programm dazu nennt man einen Compiler. Wenn der Compiler seine Arbeit getan hat, haben wir ein fertiges Programm, das von unserem PC gelesen werden kann, zusammengebaut.

Nicht jede Sprache hat einen Compiler

Es gibt Programmiersprachen, die andere Technologien als einen Compiler verwenden. Besonders bekannt sind hier sogenannte Interpreter-Sprachen, die einen passenden Interpreter verwenden. Dieser wandelt den Quellcode nicht in maschinenlesbaren Code um, sondern stellt eine eigene Software bereit, die den Programmcode »live« verstehen kann, während das Programm läuft.

In diesem Buch arbeiten wir mit der Programmiersprache Java. Vielleicht hast du schon einmal von Java gehört, denn es ist auch heute, mehr als 30 Jahre nach der Erfindung der Sprache, eine der bekanntesten und meistgenutzten Programmiersprachen der Welt. Viele bekannte Programme wurden in Java entwickelt, so zum Beispiel unser Lieblingsspiel Minecraft (das sagt ja auch der Name Java Edition).

Java ist eine besondere Programmiersprache, da sie aus mehreren Teilen besteht, die du beim Entwickeln von Programmen grundlegend verstehen musst.

• Java Development Kit (JDK): Das JDK ist das Herzstück, um eigene Java-Programme zu entwickeln. Mithilfe des JDK startest du nämlich das Kompilieren des Quellcodes in eine maschinenlesbare Form. Java-Programme werden dabei in eine besondere Maschinenform übersetzt, den sogenannten Bytecode. Der Bytecode ist speziell für Java entwickelt worden.

• Java Runtime Environment (JRE): Das JRE ist laut der deutschen Übersetzung die »Laufzeitumgebung« für Java-Programme. Es enthält verschiedene Java-Dateien, mit denen in Java entwickelte Programme verstanden und ausgeführt werden können. Doch damit das gut funktioniert, ist ein weiterer wichtiger Bestandteil der Java-Familie notwendig.

• Java Virtual Machine (JVM): Die JVM ist die eigentliche Umgebung, die ein Java-Programm ausführt. Sie versteht den Bytecode, den das JDK erzeugt hat, und wandelt die Bytecode-Befehle so um, dass genau das passiert, was wir programmiert haben. Die JVM auf dem Server würde also dafür sorgen, dass dein entwickeltes Plugin genau so funktioniert, wie du es ursprünglich im Code erdacht hast.

Wie du es dir vielleicht schon denken kannst, benötigen wir für die Entwicklung von Plugins alle drei genannten Bestandteile: Mithilfe des JDK schreiben wir zunächst Plugin-Quellcode, den wir im Anschluss in Bytecode umwandeln. Das JRE hilft uns im Anschluss direkt auf den Server, den Bytecode zu verstehen und so das Plugin testen zu können, indem der Bytecode innerhalb der JVM ausgewertet wird. Glücklicherweise müssen wir nicht alle drei Programme einzeln installieren. Setzen wir für die Ausführung von Java-Programmen das JRE auf, so enthält dieses automatisch die JVM, um Bytecode verstehen zu können. Wenn wir also nur Java-Programme ausführen wollen, dann würde es ausreichen, lediglich das JRE zu installieren. Wir wollen allerdings entwickeln, doch auch hier hilft uns Java: Das JDK enthält nicht nur die notwendigen Entwicklungswerkzeuge wie den Bytecode-Compiler, sondern zugleich das JRE (und dieses enthält wiederum das JDK). Vereinfacht gesagt: Wenn wir das JDK installieren, dann installieren wir das JRE und die JVM automatisch mit. Abbildung 2.1 zeigt grafisch, wie die drei vorgestellten Werkzeuge zusammenhängen.

Warum der Bytecode und die JVM so praktisch für uns sind

Java-Bytecode ist eine wirkliche Besonderheit, da er für unterschiedliche Betriebssysteme gleich ist. Während andere Programme also mehrmals für verschiedenste Plattformen kompiliert werden müssen, werden Java-Programme nur einmalig in Bytecode umgewandelt.

Der wahre Trick liegt hier in der JVM: Sie weiß auf dem jeweiligen Betriebssystem, wie der Bytecode gelesen werden muss, damit das Programm funktioniert. Während der Bytecode also immer gleich bleibt, hat jede Plattform eine eigene JVM, die »weiß«, wie der Bytecode auf dem jeweiligen Betriebssystem gelesen werden muss. Das macht Java zu einer plattformunabhängigen Sprache. Das heißt, dass der gleiche Quellcode für verschiedene Plattformen verwendet werden kann. Das siehst du auch gut an Minecraft: Die ursprüngliche Version wurde in Java entwickelt und konnte deshalb direkt an allen PCs gespielt werden, egal, ob Windows, Mac oder Linux als Betriebssystem verwendet wurde.

Abbildung 2.1     JDK, JRE und JVM hängen eng zusammen und sind bei der Installation »ineinander verschachtelt«.

Nun, da du weißt, wie JDK, JRE und JVM zusammenhängen, können wir erst einmal das JDK installieren, mit dem wir später Plugins kompilieren und auf unserem Server ausführen können.

2.1.1    Das JDK installieren

Ohne weiter in die technischen Details der Sprache Java zu gehen, starten wir nun mit der ersten Installation: Wir installieren das soeben erklärte JDK auf unserem PC, damit wir im Anschluss Plugins mit Java programmieren und ausführen können.

Wenn du Java schon...

Über Autor(innen)

Schlosser, Max
Max Schlosser ist wissenschaftlicher Mitarbeiter und Promovend im Fachbereich Medieninformatik in Mittweida – und durch und durch Games-Fan. Mit Java entwickelt er schon seit seiner Jugendzeit eigene Plugins für seine zahlreichen Minecraft-Welten und mit der Unity-Engine baut er seine ganz eigenen Spielewelten auf. Beinah noch mehr Spaß als das Entwickeln macht ihm die Vermittlung seines Wissens – ob auf seinem YouTube-Kanal »Schloool«, »BiVieh«, an der Hochschule oder im Buch: Er ist begeistert, wenn aus seinen Erklärungen praktische Skills und spielbare Games werden.