Metadata-Version: 2.4
Name: easy-mc-launcher
Version: 0.10.0
Summary: A simple package to make creating Minecraft launchers easier.
Author: Jamie
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.7
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: minecraft-launcher-lib
Requires-Dist: requests
Dynamic: license-file

# Easy MC Launcher

Ein simples Python-Package, um ohne Kopfschmerzen eigene Minecraft-Launcher zu programmieren.

Wenn du schon mal versucht hast, einen Minecraft-Launcher von Grund auf zu schreiben, kennst du die Probleme: Man muss sich mit Java-Versionen herumschlagen, komplexe JSON-Dateien von Mojang parsen, gigantische Start-Parameter generieren, und die Installation von Forge oder Fabric ist ein Albtraum. Dieses Package versteckt die ganze komplizierte Logik und gibt dir einfach verständliche Befehle.

## Installation

```bash
pip install easy-mc-launcher
```

---

## Alle Klassen auf einen Blick

| Klasse | Was sie macht |
|---|---|
| `EasyLauncher` | Versionen installieren, Fabric/Forge installieren, Java laden, Spiel starten |
| `SettingsManager` | RAM, Username, Auflösung usw. speichern und laden |
| `ProfileManager` | Verschiedene Profile anlegen (z.B. "Vanilla", "Modded", "Skyblock") |
| `ModManager` | Mods downloaden, aktivieren, deaktivieren, löschen |
| `ResourcePackManager` | Resource Packs downloaden und verwalten |
| `ShaderPackManager` | Shader Packs downloaden und verwalten |
| `WorldManager` | Welten sichern (Backup), wiederherstellen, löschen |
| `ServerPinger` | Prüfen ob ein Server online ist, Spielerzahl und Version abfragen |
| `CrashReporter` | Crash-Reports lesen, zusammenfassen und Logs durchsuchen |

---

## Code-Beispiele

### 1. Vanilla Minecraft starten

```python
from easy_mc_launcher import EasyLauncher, SettingsManager

settings = SettingsManager()
settings.set("username", "Notch")
settings.set("ram_max", "4G")

launcher = EasyLauncher()

# Startet Minecraft 1.20.1 (lädt alles Nötige automatisch herunter)
launcher.launch("1.20.1", settings)
```

### 2. Direkt auf einen Server verbinden

Wenn du einen Launcher für deinen eigenen Server baust, willst du wahrscheinlich, dass das Spiel sich beim Start direkt verbindet.

```python
launcher.launch("1.20.1", settings, server_ip="mc.hypixel.net", server_port=25565)
```

### 3. Server vorher prüfen, ob er online ist

Bevor du den Spieler auf den Server wirfst, kannst du prüfen ob er überhaupt erreichbar ist. Der `ServerPinger` benutzt das echte Minecraft Server List Ping Protokoll und braucht keine extra Bibliothek dafür.

```python
from easy_mc_launcher import ServerPinger

# Gibt ein Dict zurück mit allen Infos
info = ServerPinger.ping("mc.hypixel.net")

if info["online"]:
    print(f"Server ist online!")
    print(f"Spieler: {info['players_online']}/{info['players_max']}")
    print(f"Version: {info['version']}")
    print(f"Ping: {info['ping_ms']}ms")
    print(f"MOTD: {info['motd']}")
else:
    print("Server ist offline oder nicht erreichbar.")

# Oder einfach nur schnell True/False checken:
if ServerPinger.is_online("mc.hypixel.net"):
    launcher.launch("1.20.1", settings, server_ip="mc.hypixel.net")
```

### 4. Fabric oder Forge installieren

Einen Modloader über Code zu installieren ist normalerweise extrem aufwendig. Hier reicht ein Befehl.

```python
from easy_mc_launcher import EasyLauncher, SettingsManager

launcher = EasyLauncher()
settings = SettingsManager()

# Installiert Fabric und gibt den Namen des neuen Profils zurück
fabric_version = launcher.install_fabric("1.20.1")

# Für Forge:
# forge_version = launcher.install_forge("1.20.1-47.1.0")

launcher.launch(fabric_version, settings)
```

### 5. Das richtige Java automatisch laden

Alte MC-Versionen brauchen Java 8, neue brauchen Java 17 oder 21. Dieser Befehl lädt die exakt richtige Version von Mojang.

```python
launcher.install_java("1.20.1")
```

### 6. Profile verwalten

Wenn dein Launcher mehrere Konfigurationen braucht (z.B. Vanilla zum Bauen, ein Modpack zum PvP, eine Skyblock-Config), kannst du Profile anlegen. Ein Profil speichert Version, RAM, Username und alles was du willst. Man kann dann mit einem Befehl zwischen Profilen wechseln.

```python
from easy_mc_launcher import ProfileManager, SettingsManager

profiles = ProfileManager()
settings = SettingsManager()

# Profile erstellen
profiles.create_profile("Vanilla", version="1.20.1", ram_max="4G", username="Steve")
profiles.create_profile("Modded", version="1.20.1", ram_max="8G", username="Steve",
                         extra={"server_ip": "mein-server.de"})

# Alle Profile auflisten
print(profiles.list_profiles())  # ['Vanilla', 'Modded']

# Ein Profil direkt auf die Settings anwenden (setzt alle Werte auf einmal)
profiles.apply_to_settings("Modded", settings)

# Profil nachträglich ändern
profiles.update_profile("Modded", ram_max="6G")

# Profil kopieren
profiles.duplicate_profile("Vanilla", "Vanilla Backup")
```

### 7. Mods verwalten

Mods herunterladen, ein- und ausschalten oder komplett löschen. Das Deaktivieren benennt die Datei in `.jar.disabled` um, sodass Minecraft sie beim Start ignoriert, man sie aber nicht neu herunterladen muss.

```python
from easy_mc_launcher import EasyLauncher, ModManager

launcher = EasyLauncher()
mods = ModManager(launcher.minecraft_directory)

# Mod über einen direkten Download-Link in den /mods Ordner laden
mods.download_mod("https://link-zur-mod.jar", "sodium.jar")

# Mod deaktivieren (bleibt auf der Festplatte, wird aber nicht geladen)
mods.disable_mod("sodium.jar")

# Mod wieder aktivieren
mods.enable_mod("sodium.jar")

# Alle aktiven Mods auflisten
print(mods.get_installed_mods())

# Alle Mods auf einmal löschen (z.B. für einen sauberen Neustart)
mods.clear_all_mods()
```

### 8. Shader Packs verwalten

Funktioniert genauso wie Mods, aber für Shader (Optifine/Iris).

```python
from easy_mc_launcher import EasyLauncher, ShaderPackManager

launcher = EasyLauncher()
shaders = ShaderPackManager(launcher.minecraft_directory)

shaders.download_shader("https://link-zum-shader.zip", "BSL.zip")
print(shaders.get_installed_shaders())
shaders.delete_shader("BSL.zip")
```

### 9. Resource Packs verwalten

```python
from easy_mc_launcher import EasyLauncher, ResourcePackManager

launcher = EasyLauncher()
packs = ResourcePackManager(launcher.minecraft_directory)

packs.download_pack("https://link.zip", "Faithful.zip")
print(packs.get_installed_packs())
packs.delete_pack("Faithful.zip")
```

### 10. Welten sichern und wiederherstellen

Damit deine User nicht ihre Welten verlieren, wenn etwas schiefgeht. Du kannst Backups erstellen (mit automatischem Zeitstempel im Namen), sie auflisten, wiederherstellen oder löschen. Zeigt dir auch die Größe einer Welt in MB an.

```python
from easy_mc_launcher import EasyLauncher, WorldManager

launcher = EasyLauncher()
worlds = WorldManager(launcher.minecraft_directory)

# Alle Welten anzeigen
for world in worlds.get_worlds():
    size = worlds.get_world_size(world["name"])
    print(f"{world['name']} - {size} MB")

# Backup erstellen (automatischer Name mit Zeitstempel)
worlds.backup_world("MeineWelt")

# Oder mit eigenem Namen
worlds.backup_world("MeineWelt", backup_name="Vor-dem-Update")

# Alle Backups auflisten
print(worlds.get_backups())

# Backup wiederherstellen
worlds.restore_backup("Vor-dem-Update", restore_as="MeineWelt")

# Welt löschen
worlds.delete_world("AlteTestwelt")
```

### 11. Crash-Reports lesen und Logs durchsuchen

Wenn das Spiel crasht und ein User dir nur "es geht nicht" sagt, kannst du mit dem `CrashReporter` automatisch den neusten Crash-Report auslesen und die wichtigsten Infos extrahieren. Du kannst auch die `latest.log` nach bestimmten Fehlern durchsuchen.

```python
from easy_mc_launcher import EasyLauncher, CrashReporter

launcher = EasyLauncher()
crashes = CrashReporter(launcher.minecraft_directory)

# Den neusten Crash-Report zusammenfassen
summary = crashes.get_crash_summary()
if "error" not in summary:
    print(f"Crash-Beschreibung: {summary['description']}")
    print(f"Fehler: {summary['exception']}")
    print(f"MC-Version: {summary['minecraft_version']}")

# Alle Crash-Reports auflisten
print(crashes.get_crash_reports())

# Die latest.log nach Fehlern durchsuchen
errors = crashes.search_log("ERROR")
for line in errors:
    print(line)

# Oder nach einem bestimmten Mod-Namen suchen
crashes.search_log("sodium")
```

### 12. Versionen aufräumen

```python
from easy_mc_launcher import EasyLauncher

launcher = EasyLauncher()

# Neuste Version finden
print(launcher.get_latest_release())
print(launcher.get_latest_snapshot())

# Alte Version löschen
launcher.delete_version("1.19.2")
```

---

## Einstellungen im Detail (SettingsManager)

Der `SettingsManager` speichert alles automatisch in einer `launcher_settings.json`. Du musst dich nicht selbst um das Lesen und Schreiben kümmern.

| Key | Beschreibung | Beispiel |
|---|---|---|
| `"username"` | Ingame-Name | `"Steve"` |
| `"uuid"` | Spieler-UUID (wird automatisch generiert wenn leer) | `""` |
| `"ram_min"` | Minimaler RAM | `"1G"` |
| `"ram_max"` | Maximaler RAM | `"4G"` |
| `"resolution"` | Fenstergröße beim Start | `{"width": 854, "height": 480}` |
| `"show_logs"` | Live-Logs im Terminal anzeigen | `True` / `False` |
| `"java_path"` | Pfad zu einer eigenen `javaw.exe` (optional) | `"C:/Program Files/Java/bin/javaw.exe"` |
