# Mod Loader programmieren



## JavaGamer (15. Jun 2014)

Hallo.

Ich habe mir mal ein kleines 2D-Game programmiert und möchte jetzt dafür eine Modding-API wie bei Minecraft es Forge ist programmieren. Jedoch habe ich keine Ahnung wie ich anfangen soll, also wie ich mein Spiel dazu bringe dass es mein ModLoader lädt ohne dass ich dafür mein Spiel abändern muss. Also halt so wie bei FML und Forge, dass alles geladen wird aber halt Mojang dafür nichts an deren Code ändern müssen damit das geladen werden kann.
Und ja, ich habe bereits in den Source-Code von FML und Forge hineingeschaut, aber dieser macht mich nur noch ratloser.

Ich hoffe ihr könnt mir dabei helfen.
JavaGamer


----------



## Gucky (15. Jun 2014)

Was ist jetzt deine Frage? Wie du deine schon fertigen Mods in dein Spiel bekommst oder wie du es hinbekommst, dass dein Spiel "Modable" wird?


----------



## JavaGamer (15. Jun 2014)

Gucky hat gesagt.:


> Was ist jetzt deine Frage? Wie du deine schon fertigen Mods in dein Spiel bekommst oder wie du es hinbekommst, dass dein Spiel "Modable" wird?



Wie ich es hinbekomme das mein Spiel "Modable" bekomme, der Rest dürfte nicht so schwer werden, bzw. habe ich schon einige Ideen.

Also eigentlich, die Frage:

Wie kann ich das Spiel dazu bringen eine Modding-API zu laden (also sowas wie FML (ForgeModLoader, der halt Forge und alles andere lädt und ins Game einbindet, damit man dann Mods erstellen und verwenden kann))


----------



## Ruzmanz (15. Jun 2014)

Google mal nach "Java Plugin System", da findest du einige Beispiele. Du musst im Vorfeld ein Interface definieren. Die Plugins / Mods müssen das Interface implementieren. Anschließend lädst du dann die einzelnen Class/Jar-Dateien.


----------



## Gucky (15. Jun 2014)

Die Zusammenfassung ist:
Definiere eine/mehrer Schnittstelle/n, mit allen Werten und Variablen, die dein Plugin (ein Mod ist nichts Anderes) bekommen soll. Dann halte ich es für das Einfachste, wenn du einen Ordner Mods machst und dort alle Mods als .jar o.Ä. speicherst. Dein Programm guckt nach, ob dort passende Mods drin liegen und arbeitet mit ihnen.


----------



## JavaGamer (16. Jun 2014)

Ruzmanz hat gesagt.:


> Google mal nach "Java Plugin System", da findest du einige Beispiele. Du musst im Vorfeld ein Interface definieren. Die Plugins / Mods müssen das Interface implementieren. Anschließend lädst du dann die einzelnen Class/Jar-Dateien.





Gucky hat gesagt.:


> Die Zusammenfassung ist:
> Definiere eine/mehrer Schnittstelle/n, mit allen Werten und Variablen, die dein Plugin (ein Mod ist nichts Anderes) bekommen soll. Dann halte ich es für das Einfachste, wenn du einen Ordner Mods machst und dort alle Mods als .jar o.Ä. speicherst. Dein Programm guckt nach, ob dort passende Mods drin liegen und arbeitet mit ihnen.



Also muss ich in meinem Game selber ein Interface erstellen zum laden der Plugins? Falls dem so ist, gibt es auch einen Weg, dass das Interface dass den Mod/das Plugin definiert auserhalb des Games liegt, also dass es einmal eine ungemoddete Version vom Game gibt und man auch eine Version hat die gemoddet werden kann? (also halt so wie bei Minecraft) Wie...?


----------



## Gucky (16. Jun 2014)

Wie meinst du das? Natürlich kannst du das Interface als .jar neben dein Programm legen. Das wäre sogar recht gut, da du somit den Plugins leicht das Interface zur Verfügung stellen kannst.

Das Interface ist die Schnittstelle zum Laden des Plugins. Es läd nicht das Plugin, sondern es ist sozusagen die Erklärung, wie das Plugin zu laden ist.


----------



## JavaGamer (16. Jun 2014)

Gucky hat gesagt.:


> Wie meinst du das? Natürlich kannst du das Interface als .jar neben dein Programm legen. Das wäre sogar recht gut, da du somit den Plugins leicht das Interface zur Verfügung stellen kannst.
> 
> Das Interface ist die Schnittstelle zum Laden des Plugins. Es läd nicht das Plugin, sondern es ist sozusagen die Erklärung, wie das Plugin zu laden ist.



Ja, also ich meine das so, dass ich halt in eine Jar habe, in dieser ist das Game selbst untergebracht und in einer 2. jar ist dann alles Untergebracht um Mods in das Spiel (jar 1 einzubinden) und diese Mods sind dann in weiteren externen jars untergebracht die sich im "mods" Ordner befinden.

Nur wie stelle ich dies jetzt an, dass die 2. jar aufgerufen wird und das Game lädt und die entsprechenenden Mods ins Game einbindet.

Und wie kann die 2. Jar zum laden der Mods (die auch einen Mod defenieren soll) die Main-Klasse eines Mods finden bzw. erkennen und laden, da es ist ja kein 

```
public static void main(String[] args) { }
```
vorhanden

Kurzfassung: Wie erkennt die Loader.jar die Mods und wie kann diese sie in die Game.jar einbinden? ???:L

Also vergleichbar mit dem System von Minecraft Forge, falls du dieses kennst.


----------



## Gucky (16. Jun 2014)

Ich verstehe nicht sooo viel von Plugins aber das, was ich verstanden habe, ist, dass dein Hauptjar die Mods einlesen muss oder sie zumindest in dem Hauptjar ankommen müssen, sodass es damit arbeiten kann. Dann müsste das Hauptjar im zweiten .jar die Methode 
	
	
	
	





```
Mods ladeMods()
```
 aufrufen und somit die Mods einlesen und dem Hauptjar übergeben. Das macht dann irgendwas damit.
Zusätzlich hast du in dem Jar ModLoader noch sämtliche Interfaces, die du brauchst um die Schnittstellen mit dem Hauptjar zu vereinbaren (gibt es Mods, die von selbst laufen, müssen sie mit in die GameLoop des Spiels etc.)

Wenn du mit der Java API arbeitest, dann machst du nichts Anderes, als Methoden einer schon compilierten .jar aufzurufen und deren Klassen zu verwenden.


----------



## JavaGamer (16. Jun 2014)

Gucky hat gesagt.:


> Ich verstehe nicht sooo viel von Plugins aber das, was ich verstanden habe, ist, dass dein Hauptjar die Mods einlesen muss oder sie zumindest in dem Hauptjar ankommen müssen, sodass es damit arbeiten kann. Dann müsste das Hauptjar im zweiten .jar die Methode
> 
> 
> 
> ...



A: Ich arbeite mit der Java API (also ganz normalem Java und Java2D).
B: Und wie stelle ich es an, dass die ModLoader.jar die Mods einliest und so an die Game.jar weitergibt, dass diese damit arbeiten kann? (Man könnte es ja so machen, dass die ModLoader.jar die Game.jar startet und alles übergibt aber bloß wie?)
C: Wie findet die ModLoader.jar die Main-Klasse des Mods um diese zu laden und dann alles an die Game.jar weiter zu geben, also dass diese z.B. die Main-Klasse lädt und dann alles andere gleich mit übergeben wird und jenachdem in welcher Methode es drin ist, an der entsprechenden Stelle zu laden (macht ja kein Sinn, wenn man z.B. mehrere neue Levels mit nem Mod hat und alle geladen werden obwohl du vielleicht net mal alle schaffst und somit schon vorher aufhörst...)


----------



## Gucky (16. Jun 2014)

ModLoader holt sich von der Hauptjar das Verzeichnis, in dem die Mods stehen und guckt dort nach, ob dort Mods vorhanden sind. Dann guckt ModLoader nach, ob dort eine Klasse zu finden ist, die eines der Mod-Interfaces implementiert. Wenn ja, ruft es die passenden Methoden, um Informationen über das Hauptjar auszutauschen und die Mod lauffähig machen.


----------



## JavaGamer (17. Jun 2014)

Gucky hat gesagt.:


> ModLoader holt sich von der Hauptjar das Verzeichnis, in dem die Mods stehen und guckt dort nach, ob dort Mods vorhanden sind. Dann guckt ModLoader nach, ob dort eine Klasse zu finden ist, die eines der Mod-Interfaces implementiert. Wenn ja, ruft es die passenden Methoden, um Informationen über das Hauptjar auszutauschen und die Mod lauffähig machen.



Ok, also ich habe jetzt soweit den ModLoader fertig, dass er weiss wie die Main-Klasse eines Mods aussieht, nur wie bringe ich ihn jetzt dazu diese zu suchen in der Mod.jar und alles in die Game.jar reinzupacken, also das zu kombinieren, den ModCode und den GameCode und dann das Game zu starten?

Hier mal meine bisherige Klasse:



Spoiler: Code





```
package minecraftplaye.mods.pml;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * This class defines how a mod looks like!
 * 
 * @author MinecraftPlaye
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Mod
{
	
	/**
	 * The name of the owner/creator/Founder or Lead Developer of this mod/plugin
	 * @author MinecraftPlaye
	 */
	String owner() default "";
	
	/**
	 * The complete team!
	 * @author MinecraftPlaye
	 */
	String credits() default "";
	
	/**
	 * The unique mod identifier for this mod
	 * @author MinecraftPlaye
	 */
	String modId() default "";
	
	/**
	 * A user friendly name for the mod
	 * @author MinecraftPlaye
	 */
	String name() default "";
	
	/**
	 * A version string for this mod
	 * @author MinecraftPlaye
	 */
	String version() default "";
	
	/**
	 * The acceptable platformer versions that this mod will load and run in 
	 * @author MinecraftPlaye
	 */
	String acceptedPlatformerVersions() default "";
}
```

Und hier ist die Modklasse:

```
package minecraftplaye.mods.pml;

@Mod(modId="test", acceptedPlatformerVersions="0.0.1", owner="MinecraftPlaye", name="TestMod")
public class Main
{
	
}
```




Und ich hätte jetzt die Idee, dass die Klasse Mod noch ein EventHandler bekommt über den man dann Methoden verwenden kann vom Game selbst, also dass wenn du dann 


```
@Mod.EventHandler
public void tick(TickEvent event) {}
```
oder so ähnlich etwas hinschreibst in deine Main-Methode, dass dann der darin vorhandene Code einfach ans Ende der 

```
public void tick(){...}
```
 Methode in der Game.jar Klasse hinzugefügt wird, also dass diese dann so aussieht:

```
public void tick() {GameCode...ModCode...}
```


----------

