From 213afe5ae4e632751254116baee1a24757146c10 Mon Sep 17 00:00:00 2001 From: M_Viper Date: Sat, 7 Nov 2026 23:16:32 +0000 Subject: [PATCH] Upload via GUI (14 Dateien) --- README.md | 748 ++++++------ pom.xml | 2 +- .../de/landschunkinfo/ChunkExpansion.java | 172 +-- .../java/de/landschunkinfo/InfoCommand.java | 998 ++++++++-------- .../de/landschunkinfo/LandsChunkInfo.java | 1032 ++++++++--------- .../java/de/landschunkinfo/LockStore.java | 370 +++--- .../java/de/landschunkinfo/PvpRegions.java | 6 +- src/main/resources/config.yml | 105 +- src/main/resources/plugin.yml | 7 +- 9 files changed, 1686 insertions(+), 1754 deletions(-) diff --git a/README.md b/README.md index d1d537e..e1d6dc8 100644 --- a/README.md +++ b/README.md @@ -1,371 +1,377 @@ -# LandsChunkInfo – Anleitung (Version 1.0.4) - -Dieses Plugin ist eine Erweiterung für das **Lands**-Plugin. Es bietet: - -- **Chunk-Übersicht:** wie viele Chunks ein Land belegt, wie viele frei und wie viele gesperrt sind. -- **Wartezeit nach `/unclaim`:** Der Slot bleibt für eine einstellbare Zeit gesperrt. Die Spieler sehen, **wann wieder ein Chunk frei wird**. -- **Upkeep-Anzeige:** wann das Land das nächste Mal zahlen muss. -- **Slot freikaufen** (`skip`, `gift`), **Auto-Claim-Warteschlange**, **Watchlist** und **zeitlich begrenzte Claims**. -- **PvP-Regionen:** Bereiche (z. B. eine Arena), in denen Spieler kämpfen dürfen, auch wenn sie im selben Land Mitglied sind. -- **Platzhalter** für PlaceholderAPI. - -Du brauchst keine Programmierkenntnisse. Diese Anleitung erklärt alles Schritt für Schritt. - ---- - -## 1. Was brauche ich? - -| Was | Pflicht? | Wofür | -|---|---|---| -| Ein Minecraft-Server mit **Paper** (Version 1.21 bis 26) | Ja | Das Plugin läuft darauf | -| **Java 25** auf dem Server | Ja | Lands 8.8.0 braucht das ebenfalls | -| Das Plugin **Lands** (Version 8.8.0) | Ja | Ohne Lands startet dieses Plugin nicht | -| **Vault** + ein Economy-Plugin (z. B. EssentialsX) | Nein | Nur zum Bezahlen mit Spielergeld (`skip`, `gift`) | -| **PlaceholderAPI** | Nein | Nur für Platzhalter in Scoreboard, Tab-Liste usw. | - -Folia wird **nicht** unterstützt. - ---- - -## 2. Installation und Update - -1. Stoppe den Server. -2. Kopiere `LandsChunkInfo-1.0.4.jar` in den Ordner `plugins` deines Servers (dort liegt auch die Lands-Jar). - **Bei einem Update:** Lösche zuerst die alte `LandsChunkInfo-*.jar`. Es darf nur **eine** Version im Ordner liegen. -3. Starte den Server. -4. Schau in die Konsole. Du solltest `[LandsChunkInfo] Enabling LandsChunkInfo` sehen. Steht dort ein roter Fehler, lies Abschnitt 11. -5. Beim ersten Start wird `plugins/LandsChunkInfo/config.yml` erstellt. Dort stellst du alles ein (Abschnitt 7). - -**Wichtig:** Nach dem Austausch der Jar-Datei ist immer ein **Neustart** nötig. `/reload` reicht nicht und kann Fehler verursachen. - -Deine Dateien in `plugins/LandsChunkInfo/` (`config.yml`, `data.yml`, `pvp-regions.yml`) bleiben bei einem Update erhalten. - ---- - -## 3. Der Befehl - -Der Hauptbefehl heißt **`/chunks`**. Es gibt die Kurzform `/chunkslots`. - -> **Hinweis:** Der Name `/chunks` wird bewusst nicht benutzt, weil WorldEdit/FastAsyncWorldEdit einen eigenen Befehl `/chunks` hat. Der würde sonst mit diesem Plugin kollidieren (Fehler „Too many arguments“). - ---- - -## 4. Was können die Spieler? - -### Übersicht anzeigen - -| Befehl | Was passiert | -|---|---| -| `/chunks` | Zeigt alle deine Lands: Chunks belegt, frei, gesperrt, wann der nächste Chunk frei wird, Upkeep | -| `/chunks MeinLand` | Zeigt nur dieses eine Land | -| `/chunks top` | Zeigt die Lands mit den meisten Chunks | - -**Beispiel einer Anzeige:** - -``` -Deine Chunks -Von dir geclaimt: 12 / 20 - MeinLand -Chunks: 12 / 20 | Frei: 6 | Gesperrt: 2 -Nächster Chunk wieder frei in: 3Std 12Min (23.10. 14:30) -Danach: 20Std 5Min -Sofort freischalten: /chunks skip (Preis: 80,00) -Upkeep: 36,00 pro Zyklus, nächster Einzug in 2T 4Std -``` - -Was bedeuten die Wörter? - -- **Frei** = So viele Chunks kann das Land jetzt sofort claimen. -- **Gesperrt** = Jemand hat einen Chunk abgegeben (`/unclaim`). Dieser Platz ist für eine Weile blockiert. Nach der Wartezeit ist er wieder frei. -- **Upkeep** = Die regelmäßige Gebühr, die das Land zahlen muss, damit es seine Chunks behält. -- Wenn das Land-Guthaben für den Upkeep nicht reicht, steht eine rote Warnung dabei (und, wenn Lands beim Upkeep Chunks abzieht, wie viele verloren gehen würden). -- Wenn Lands Inaktivität einstellt, steht dort auch, ob der Besitzer online ist oder wann das Land als inaktiv gilt. - -### Gesperrten Slot sofort freikaufen - -| Befehl | Was passiert | -|---|---| -| `/chunks skip` | Zeigt den Preis für den nächsten gesperrten Slot deines Lands | -| `/chunks skip confirm` | Kauft den Slot wirklich. Ohne `confirm` wird **nichts** bezahlt | -| `/chunks skip MeinLand confirm` | Dasselbe für ein bestimmtes eigenes Land | -| `/chunks gift FremdesLand` | Zeigt den Preis, um einen Slot in einem **fremden** Land freizukaufen | -| `/chunks gift FremdesLand confirm` | Kauft den Slot. Die online Mitglieder des Lands werden benachrichtigt | - -Der Preis wird günstiger, je kürzer die Wartezeit noch ist. Es wird immer der Slot freigekauft, der am frühesten frei würde. - -### Chunk vormerken (Warteschlange) - -Der Chunk, auf dem du **gerade stehst**, ist frei, aber dein Land hat keinen freien Slot? Dann merk ihn vor. Sobald ein Slot frei wird, claimt das Plugin ihn **automatisch** für dich. - -| Befehl | Was passiert | -|---|---| -| `/chunks queue` | Merkt den Chunk vor, auf dem du stehst (für dein Hauptland) | -| `/chunks queue MeinLand` | Dasselbe, aber für ein bestimmtes Land | -| `/chunks queue list` | Zeigt deine vorgemerkten Chunks | -| `/chunks queue clear` | Löscht alle deine Vormerkungen | - -Wichtig: **Du musst online sein**, damit der Chunk geclaimt wird. Ist der Chunk inzwischen von jemand anderem geclaimt, wird die Vormerkung gelöscht. - -### Fremden Chunk beobachten (Watchlist) - -Ein Chunk gehört jemand anderem, und du willst ihn haben, falls er frei wird? Stell dich drauf: - -| Befehl | Was passiert | -|---|---| -| `/chunks watch` | Du bekommst eine Nachricht, sobald dieser Chunk frei wird | -| `/chunks watch list` | Zeigt, was du beobachtest | -| `/chunks watch clear` | Hört mit allem auf | - -Tipp: Wenn die Nachricht kommt, nutze danach `/chunks queue`, um ihn dir zu sichern. - -### Chunk nur für kurze Zeit (Temp-Claim) - -Du brauchst einen Chunk nur für ein paar Tage (z. B. für ein Event)? Stell dich in den Chunk. Er muss zu **deinem eigenen** Land gehören (du musst der Besitzer sein): - -| Befehl | Was passiert | -|---|---| -| `/chunks temp 7` | Der Chunk wird nach 7 Tagen automatisch freigegeben | -| `/chunks temp list` | Zeigt die Temp-Chunks deiner Lands | -| `/chunks temp cancel` | Nimmt dem Chunk, auf dem du stehst, das Ablaufdatum wieder weg | - -Wenn ein Temp-Chunk abläuft, wird dadurch **kein** Slot gesperrt. - -### Hinweis beim Einloggen - -Beim Einloggen (kurz nach dem Join) sagt das Plugin dem Spieler, wie viele Slots in seinen Lands frei sind und wann der nächste gesperrte Slot frei wird. Der Besitzer bekommt zusätzlich eine Warnung, wenn das Land-Guthaben nicht für den Upkeep reicht und der Einzug bald ansteht. - ---- - -## 5. PvP-Regionen (für Admins) - -### Wozu? - -Lands verbietet PvP in der **Wildnis** zwischen Spielern, die im selben Land Mitglied sind (Meldung: „Du kannst diesen Spieler nicht in der Wildnis angreifen, weil er Mitglied in einem deiner Länder ist“). Mit einer PvP-Region kannst du einen Bereich festlegen, in dem trotzdem gekämpft werden darf, z. B. eine Arena. - -### Region anlegen - -Du brauchst das Recht `landschunkinfo.admin` (Standard: OPs). - -1. Stell dich an die erste Ecke der Arena: `/chunks pvp pos1` -2. Stell dich an die gegenüberliegende Ecke: `/chunks pvp pos2` -3. Lege die Region an: `/chunks pvp create arena` - -| Befehl | Was passiert | -|---|---| -| `/chunks pvp pos1` | Setzt die erste Ecke an deiner Position | -| `/chunks pvp pos2` | Setzt die zweite Ecke an deiner Position | -| `/chunks pvp create ` | Legt die Region aus den beiden Ecken an | -| `/chunks pvp delete ` | Löscht die Region | -| `/chunks pvp list` | Zeigt alle Regionen | - -### Wie funktioniert das? - -- Die Regionen sind **Rechtecke über die ganze Höhe**. Beide Ecken müssen in derselben Welt liegen. -- Solange ein Spieler in einer PvP-Region steht, bekommt er automatisch das Lands-Recht `lands.bypass.attack_player`. Lands prüft den Angriff dann nicht, und die rote Meldung bleibt aus. Verlässt er die Region, wird das Recht wieder entzogen. -- Falls Lands einen Schlag trotzdem abbricht, wird er freigegeben, wenn **Angreifer und Opfer beide** in der Region stehen. Das gilt auch für Pfeile und andere Projektile. -- Der Rückstoß wird in der Region ebenfalls freigegeben. -- **Außerhalb** der Region ändert sich nichts. Dort gelten weiter die Regeln von Lands. -- Die Regionen werden in `plugins/LandsChunkInfo/pvp-regions.yml` gespeichert. - -### Wichtig für die Server-Einrichtung - -Die PvP-Region von diesem Plugin ist eine **zusätzliche** Region. Sie ersetzt keine WorldGuard-Region. Wenn du PvP sonst überall verbieten willst, regelst du das weiterhin in WorldGuard (z. B. `pvp deny` für die ganze Welt und `pvp allow` für die Arena). Lege die Region von diesem Plugin am besten genauso groß wie die WorldGuard-Arena an. - -Alternative ohne dieses Plugin: In der Lands-Config (`plugins/Lands/config.yml`) gibt es unter `combat:` die Option `ally-wilderness`. Steht sie auf `true`, dürfen Spieler mit gemeinsamem Land überall in der Wildnis kämpfen. Nach einer Änderung ist ein Neustart nötig. - ---- - -## 6. Die Platzhalter (optional) - -Nur nötig, wenn du **PlaceholderAPI** hast und die Werte z. B. im Scoreboard oder in der Tab-Liste anzeigen willst. Die Werte beziehen sich auf das Hauptland des Spielers (sein eigenes Land, sonst das erste Land, in dem er vertraut ist). - -| Platzhalter | Zeigt | -|---|---| -| `%chunkinfo_land%` | Name des Lands (`-` ohne Land) | -| `%chunkinfo_used%` | Belegte Chunks | -| `%chunkinfo_max%` | Maximale Chunks (oder `unbegrenzt`) | -| `%chunkinfo_free%` | Freie Chunks (oder `unbegrenzt`) | -| `%chunkinfo_locked%` | Gesperrte Slots | -| `%chunkinfo_next_free%` | Zeit, bis der nächste Slot frei wird (`-` wenn keiner gesperrt ist) | -| `%chunkinfo_upkeep%` | Upkeep-Kosten pro Zyklus | -| `%chunkinfo_upkeep_in%` | Zeit bis zum nächsten Upkeep | -| `%chunkinfo_top_1_name%` | Name des Lands auf Platz 1 (statt 1 geht jede Zahl) | -| `%chunkinfo_top_1_chunks%` | Chunks des Lands auf Platz 1 | - ---- - -## 7. Einstellungen (config.yml) - -Die Datei findest du unter `plugins/LandsChunkInfo/config.yml`. Öffne sie mit einem Texteditor (Notepad++ oder VS Code). Nach einer Änderung gibst du im Spiel oder in der Konsole `/chunks reload` ein (braucht das Recht `landschunkinfo.admin`). - -**Wichtig:** Lass die Einrückungen (die Leerzeichen am Zeilenanfang) unverändert. Ändere nur die Werte hinter dem Doppelpunkt. - -### Wartezeit nach dem Unclaimen - -```yaml -unclaim-cooldown: - enabled: true - duration: 24h - enforce: true -``` - -- `enabled` – `true` = Funktion an, `false` = aus. -- `duration` – Wie lange ein Slot nach `/unclaim` gesperrt bleibt. Schreibweise: - - `30m` = 30 Minuten - - `12h` = 12 Stunden - - `2d` = 2 Tage - - `1d12h` = 1 Tag und 12 Stunden -- `enforce` – `true` = Das Land kann in dieser Zeit wirklich **nicht** neu claimen, wenn alle Plätze belegt oder gesperrt sind. `false` = es wird nur angezeigt, aber nichts blockiert. - -### Upkeep-Zeitpunkt - -```yaml -upkeep: - anchor-date: "" -``` - -Das Plugin liest den Rhythmus aus der Lands-Config und merkt sich automatisch, wann Lands das erste Mal Upkeep eingezogen hat. **Bis dahin ist die Anzeige nur geschätzt.** Wenn du genau weißt, an welchem Tag zuletzt eingezogen wurde, trage das Datum ein, zum Beispiel `"2026-10-15"`. - -### Slot freikaufen - -```yaml -skip: - enabled: true - payment: PLAYER - price-per-hour: 25.0 - min-price: 50.0 -``` - -- `payment` – `PLAYER` = das Geld kommt vom Spieler (Vault nötig). `LAND` = das Geld kommt aus der Landkasse (nur der Besitzer darf das). `gift` bezahlt immer der Spieler selbst. -- `price-per-hour` – Preis pro verbleibender Stunde Wartezeit. -- `min-price` – Mindestpreis, auch wenn nur noch wenige Minuten fehlen. - -Beispiel: Noch 10 Stunden Wartezeit, 25 pro Stunde ergibt 250. - -### Warteschlange, Watchlist, Temp-Claims, Top-Liste - -```yaml -queue: - max: 3 -watch: - max: 5 -temp-claims: - enabled: true - max-days: 30 - max-per-land: 3 -top: - size: 10 -``` - -- `max` – Wie viele Einträge ein Spieler gleichzeitig haben darf. -- `max-days` – Längste erlaubte Dauer für einen Temp-Chunk. -- `max-per-land` – Wie viele Temp-Chunks ein Land gleichzeitig haben darf. -- `top.size` – Wie viele Lands in `/chunks top` stehen. - -### Hinweis beim Einloggen - -```yaml -join-reminder: - enabled: true - upkeep-warning-hours: 48 -``` - -Mit `enabled: false` schaltest du den Hinweis ab. `upkeep-warning-hours` legt fest, ab wie vielen Stunden vor dem Einzug die Upkeep-Warnung kommt. - -### Texte ändern - -Unter `messages:` stehen die Meldungen. Farben schreibst du mit `&`: - -- `&a` = grün, `&c` = rot, `&e` = gelb, `&7` = grau - -`%time%` wird im Spiel durch die Restzeit ersetzt. Lass es stehen. - ---- - -## 8. Rechte (Permissions) - -Rechte vergibst du mit einem Rechte-Plugin, z. B. LuckPerms. - -| Recht | Wer bekommt es standardmäßig? | Was erlaubt es? | -|---|---|---| -| `landschunkinfo.use` | Alle | `/chunks`, `top` und den Hinweis beim Einloggen | -| `landschunkinfo.skip` | Alle | Eigenen Slot freikaufen | -| `landschunkinfo.gift` | Alle | Slot in fremdem Land freikaufen | -| `landschunkinfo.queue` | Alle | Warteschlange benutzen | -| `landschunkinfo.watch` | Alle | Watchlist benutzen | -| `landschunkinfo.temp` | Alle | Temp-Claims benutzen | -| `landschunkinfo.bypass` | Nur OPs | Wartezeit nach dem Unclaimen gilt **nicht** | -| `landschunkinfo.admin` | Nur OPs | `/chunks reload` und `/chunks pvp ...` | - -**Beispiel:** Du willst, dass niemand außer Teammitgliedern Slots verschenken darf. Entziehe allen das Recht `landschunkinfo.gift` und gib es nur der Team-Gruppe. - ---- - -## 9. Häufige Fragen - -**Warum sieht ein Spieler „Gesperrt“, obwohl er nichts gemacht hat?** -Jemand aus seinem Land hat einen Chunk abgegeben. Die Sperre gilt für das **ganze Land**, nicht für einzelne Spieler. - -**Warum wird bei manchen Unclaims nichts gesperrt?** -Gesperrt wird nur, wenn ein Spieler selbst `/unclaim` benutzt. Nicht gesperrt wird, wenn das Land gelöscht wird, Chunks durch den Upkeep verloren gehen oder ein Temp-Chunk abläuft. Spieler mit dem Recht `landschunkinfo.bypass` lösen ebenfalls keine Sperre aus. - -**Wie sehen Spieler, wie lange sie auf einen Chunk warten müssen?** -Mit `/chunks`. Dort steht „Nächster Chunk wieder frei in: …“. - -**Die Upkeep-Zeit stimmt nicht.** -Lands verrät dem Plugin nicht, wann genau der Zyklus gestartet ist. Nach dem ersten echten Einzug passt die Anzeige. Alternativ trägst du in `upkeep.anchor-date` ein bekanntes Einzugsdatum ein. - -**Muss ich den Server neu starten?** -Für Änderungen an der `config.yml` reicht `/chunks reload`. Beim Austausch der Jar-Datei brauchst du einen Neustart (kein `/reload`). - -**Verlieren Spieler ihre Chunks, wenn ich das Plugin entferne?** -Nein. Das Plugin ändert keine Lands-Daten außer bei zwei Dingen: Wenn die Warteschlange einen Chunk claimt oder wenn ein Temp-Chunk abläuft. Entfernst du das Plugin, bleiben alle bestehenden Chunks gleich. Die gespeicherten Sperren und Listen liegen nur in `plugins/LandsChunkInfo/data.yml`. - -**Kann ich einem Spieler mehr Chunk-Slots geben?** -Nein, das geht nur in Lands selbst (`player-limits.yml`). Dieses Plugin ändert keine Limits. - ---- - -## 10. Datensicherung - -Alles, was sich das Plugin merkt, steht in diesen Dateien in `plugins/LandsChunkInfo/`: - -| Datei | Inhalt | -|---|---| -| `config.yml` | Deine Einstellungen | -| `data.yml` | Sperren, Warteschlange, Watchlist, Temp-Chunks, letzter Upkeep | -| `pvp-regions.yml` | Die PvP-Regionen | - -Wenn du den Server umziehst oder ein Backup machst, kopiere diese Dateien mit. **Bearbeite `data.yml` und `pvp-regions.yml` nicht von Hand, solange der Server läuft.** Das Plugin überschreibt die Dateien sonst. - ---- - -## 11. Wenn etwas nicht klappt - -| Problem | Lösung | -|---|---| -| Plugin startet nicht, in der Konsole steht etwas mit „Lands“ | Lands fehlt oder ist nicht aktiv. Prüfe, ob die Lands-Jar im Ordner `plugins` liegt und startet | -| Fehler mit „Unsupported class file version“ oder „Java“ | Der Server läuft mit einem zu alten Java. Du brauchst **Java 25** | -| `/chunkinfo` zeigt „Too many arguments“ oder die Ausgabe von WorldEdit | Das ist der Befehl von WorldEdit/FAWE, nicht von diesem Plugin. Benutze `/chunks` oder `/chunkslots` | -| `/chunks` sagt „Du bist in keinem Land Mitglied“ | Der Spieler hat kein Land und ist in keinem als vertrauenswürdig eingetragen. Das ist normal | -| `skip` oder `gift` meldet, Vault fehle | Installiere Vault und ein Economy-Plugin, oder stelle `skip.payment` auf `LAND` (dann geht nur `skip`, `gift` bleibt gesperrt) | -| Die Platzhalter zeigen sich als Text, z. B. `%chunkinfo_used%` | PlaceholderAPI fehlt oder wurde nach diesem Plugin geladen. Starte den Server neu | -| Änderungen an der `config.yml` wirken nicht | `/chunks reload` ausführen. Falls es trotzdem nicht klappt: Auf Einrückungen und fehlende Anführungszeichen prüfen | -| Spieler können nach dem Unclaimen trotzdem sofort claimen | Prüfe `unclaim-cooldown.enforce`, das muss `true` sein. Und prüfe, ob der Spieler das Recht `landschunkinfo.bypass` hat (OPs haben es automatisch) | -| In der PvP-Region kommt trotzdem die Lands-Meldung oder kein Schaden | Prüfe mit `/chunks pvp list`, ob die Region existiert und ob **beide** Spieler darin stehen. Die Region ist ein Rechteck: am Rand zählt der Block, auf dem man steht | -| Mitglieder desselben Lands bekommen in der Arena keinen Rückstoß | Das Plugin gibt den Rückstoß frei, wenn Lands ihn blockiert. Hilft das nicht, kommt es von einem anderen Plugin (z. B. Team- oder Friendly-Fire-Plugin) | -| Nach dem Update ist die alte Version aktiv | Es liegen zwei Jar-Dateien in `plugins`. Lösche die alte und starte neu | - -Wenn du nicht weiterkommst: Kopiere die **roten Zeilen aus der Server-Konsole** (oder aus `logs/latest.log`) und gib sie weiter. Daraus lässt sich fast immer die Ursache erkennen. - ---- - -## 12. Bekannte Grenzen - -- Die PvP-Regionen funktionieren auf einem echten Server. Die übrigen Funktionen (Sperren, Skip, Queue, Watch, Temp) wurden dort noch nicht ausführlich getestet. Probiere neue Versionen erst auf einem Testserver aus. -- Die Upkeep-Zeit ist bis zum ersten echten Einzug eine Schätzung. -- Die Warteschlange und die Watchlist arbeiten nur für Spieler, die **online** sind. -- Temp-Chunks laufen erst ab, wenn der Ersteller oder der Besitzer des Lands online ist. -- Lands-Limits (z. B. maximale Chunks) kann das Plugin nicht verändern. -- PvP-Regionen sind einfache Rechtecke ohne Höhenbegrenzung und keine WorldGuard-Regionen. -- Die rote Lands-Meldung zum PvP in der Wildnis kann das Plugin nicht umschreiben. Sie wird in der Arena nur vermieden, weil Lands den Angriff dort nicht mehr prüft. +# LandsChunkInfo – Anleitung (Version 1.0.7) + +Dieses Plugin ist eine Erweiterung für das **Lands**-Plugin. Es bietet: + +- **Chunk-Übersicht:** wie viele Chunks ein Land belegt, wie viele frei und wie viele gesperrt sind. +- **Wartezeit nach `/unclaim`:** Der Slot bleibt für eine einstellbare Zeit gesperrt. Die Spieler sehen, **wann wieder ein Chunk frei wird**. +- **Spielzeit-Anzeige:** wie viel Online-Zeit noch fehlt, bis das Limit durch Lands' Spielzeit-Belohnung um einen Chunk steigt. +- **Upkeep-Anzeige:** wann das Land das nächste Mal zahlen muss. +- **Slot freikaufen** (`skip`, `gift`), **Auto-Claim-Warteschlange** und **Watchlist**. +- **PvP-Regionen:** Bereiche (z. B. eine Arena), in denen Spieler kämpfen dürfen, auch wenn sie im selben Land Mitglied sind. +- **Platzhalter** für PlaceholderAPI. + +Du brauchst keine Programmierkenntnisse. Diese Anleitung erklärt alles Schritt für Schritt. + +--- + +## 1. Was brauche ich? + +| Was | Pflicht? | Wofür | +|---|---|---| +| Ein Minecraft-Server mit **Paper** (Version 1.21 bis 26) | Ja | Das Plugin läuft darauf | +| **Java 25** auf dem Server | Ja | Lands 8.8.0 braucht das ebenfalls | +| Das Plugin **Lands** (Version 8.8.0) | Ja | Ohne Lands startet dieses Plugin nicht | +| **Vault** + ein Economy-Plugin (z. B. EssentialsX) | Nein | Nur zum Bezahlen mit Spielergeld (`skip`, `gift`) | +| **PlaceholderAPI** | Nein | Nur für Platzhalter in Scoreboard, Tab-Liste usw. | + +Folia wird **nicht** unterstützt. + +--- + +## 2. Installation und Update + +1. Stoppe den Server. +2. Kopiere `LandsChunkInfo-1.0.7.jar` in den Ordner `plugins` deines Servers (dort liegt auch die Lands-Jar). + **Bei einem Update:** Lösche zuerst die alte `LandsChunkInfo-*.jar`. Es darf nur **eine** Version im Ordner liegen. +3. Starte den Server. +4. Schau in die Konsole. Du solltest `[LandsChunkInfo] Enabling LandsChunkInfo` sehen. Steht dort ein roter Fehler, lies Abschnitt 11. +5. Beim ersten Start wird `plugins/LandsChunkInfo/config.yml` erstellt. Dort stellst du alles ein (Abschnitt 7). + +**Wichtig:** Nach dem Austausch der Jar-Datei ist immer ein **Neustart** nötig. `/reload` reicht nicht und kann Fehler verursachen. + +Deine Dateien in `plugins/LandsChunkInfo/` (`config.yml`, `data.yml`, `pvp-regions.yml`) bleiben bei einem Update erhalten. + +--- + +## 3. Der Befehl + +Der Hauptbefehl heißt **`/chunks`**. Es gibt die Kurzform `/chunkslots`. + +> **Hinweis:** Der Name `/chunks` wird bewusst nicht benutzt, weil WorldEdit/FastAsyncWorldEdit einen eigenen Befehl `/chunks` hat. Der würde sonst mit diesem Plugin kollidieren (Fehler „Too many arguments“). + +--- + +## 4. Was können die Spieler? + +### Übersicht anzeigen + +| Befehl | Was passiert | +|---|---| +| `/chunks` | Zeigt alle deine Lands: Chunks belegt, frei, gesperrt, wann der nächste Chunk frei wird, Upkeep | +| `/chunks MeinLand` | Zeigt nur dieses eine Land | +| `/chunks top` | Zeigt die Lands mit den meisten Chunks | + +**Beispiel einer Anzeige:** + +``` +Deine Chunks +Von dir geclaimt: 12 / 20 + MeinLand +Chunks: 12 / 20 | Frei: 6 | Gesperrt: 2 +Nächster Chunk wieder frei in: 3Std 12Min (23.10. 14:30) +Danach: 20Std 5Min +Sofort freischalten: /chunks skip (Preis: 80,00) +Upkeep: 36,00 pro Zyklus, nächster Einzug in 2T 4Std +``` + +Wenn du in Lands Spielzeit-Belohnungen eingerichtet hast (siehe unten), steht über den Lands zusätzlich: + +``` +Nächster Chunk durch Spielzeit: 2Std 10Min Online-Zeit (Bonus bisher: 4/20) +``` + +Was bedeuten die Wörter? + +- **Frei** = So viele Chunks kann das Land jetzt sofort claimen. +- **Gesperrt** = Jemand hat einen Chunk abgegeben (`/unclaim`). Dieser Platz ist für eine Weile blockiert. Nach der Wartezeit ist er wieder frei. +- **Upkeep** = Die regelmäßige Gebühr, die das Land zahlen muss, damit es seine Chunks behält. +- Wenn das Land-Guthaben für den Upkeep nicht reicht, steht eine rote Warnung dabei (und, wenn Lands beim Upkeep Chunks abzieht, wie viele verloren gehen würden). +- Wenn Lands Inaktivität einstellt, steht dort auch, ob der Besitzer online ist oder wann das Land als inaktiv gilt. + +### Spielzeit bis zum nächsten Chunk + +Lands kann das Chunk-Limit mit der Spielzeit wachsen lassen. Das stellst du in `plugins/Lands/player-limits.yml` im Abschnitt `time-rewards` ein, zum Beispiel: + +```yaml +time-rewards: + player_chunks: + time: 2h + max: 20 +``` + +Dann bekommt jeder Spieler alle 2 Stunden Spielzeit einen Chunk mehr, höchstens 20. Dieses Plugin zeigt in `/chunks` an, wie lange der Spieler noch online sein muss: + +- `player_chunks` = **Nächster Chunk durch Spielzeit** (Chunks, die ein Spieler insgesamt claimen darf). +- `land_size` = **Nächster Land-Chunk durch Spielzeit** (maximale Größe seiner Lands). + +Die Zeile erscheint nur, wenn `time` größer als `0s` ist und das `max` noch nicht erreicht wurde. Gerechnet wird mit der Spielzeit-Statistik des Servers, genau wie bei Lands. Hat Lands eine andere Einstellung, zeigt die Anzeige dasselbe wie Lands. Das Plugin ändert an den Limits nichts. + +### Gesperrten Slot sofort freikaufen + +| Befehl | Was passiert | +|---|---| +| `/chunks skip` | Zeigt den Preis für den nächsten gesperrten Slot deines Lands | +| `/chunks skip confirm` | Kauft den Slot wirklich. Ohne `confirm` wird **nichts** bezahlt | +| `/chunks skip MeinLand confirm` | Dasselbe für ein bestimmtes eigenes Land | +| `/chunks gift FremdesLand` | Zeigt den Preis, um einen Slot in einem **fremden** Land freizukaufen | +| `/chunks gift FremdesLand confirm` | Kauft den Slot. Die online Mitglieder des Lands werden benachrichtigt | + +Der Preis wird günstiger, je kürzer die Wartezeit noch ist. Es wird immer der Slot freigekauft, der am frühesten frei würde. + +### Chunk vormerken (Warteschlange) + +Der Chunk, auf dem du **gerade stehst**, ist frei, aber dein Land hat keinen freien Slot? Dann merk ihn vor. Sobald ein Slot frei wird, claimt das Plugin ihn **automatisch** für dich. + +| Befehl | Was passiert | +|---|---| +| `/chunks queue` | Merkt den Chunk vor, auf dem du stehst (für dein Hauptland) | +| `/chunks queue MeinLand` | Dasselbe, aber für ein bestimmtes Land | +| `/chunks queue list` | Zeigt deine vorgemerkten Chunks | +| `/chunks queue clear` | Löscht alle deine Vormerkungen | + +Wichtig: **Du musst online sein**, damit der Chunk geclaimt wird. Ist der Chunk inzwischen von jemand anderem geclaimt, wird die Vormerkung gelöscht. + +### Fremden Chunk beobachten (Watchlist) + +Ein Chunk gehört jemand anderem, und du willst ihn haben, falls er frei wird? Stell dich drauf: + +| Befehl | Was passiert | +|---|---| +| `/chunks watch` | Du bekommst eine Nachricht, sobald dieser Chunk frei wird | +| `/chunks watch list` | Zeigt, was du beobachtest | +| `/chunks watch clear` | Hört mit allem auf | + +Tipp: Wenn die Nachricht kommt, nutze danach `/chunks queue`, um ihn dir zu sichern. + +### Hinweis beim Einloggen + +Beim Einloggen (kurz nach dem Join) sagt das Plugin dem Spieler, wie viele Slots in seinen Lands frei sind und wann der nächste gesperrte Slot frei wird. Der Besitzer bekommt zusätzlich eine Warnung, wenn das Land-Guthaben nicht für den Upkeep reicht und der Einzug bald ansteht. + +--- + +## 5. PvP-Regionen (für Admins) + +### Wozu? + +Lands verbietet PvP in der **Wildnis** zwischen Spielern, die im selben Land Mitglied sind (Meldung: „Du kannst diesen Spieler nicht in der Wildnis angreifen, weil er Mitglied in einem deiner Länder ist“). Mit einer PvP-Region kannst du einen Bereich festlegen, in dem trotzdem gekämpft werden darf, z. B. eine Arena. + +### Region anlegen + +Du brauchst das Recht `landschunkinfo.admin` (Standard: OPs). + +1. Stell dich an die erste Ecke der Arena: `/chunks pvp pos1` +2. Stell dich an die gegenüberliegende Ecke: `/chunks pvp pos2` +3. Lege die Region an: `/chunks pvp create arena` + +| Befehl | Was passiert | +|---|---| +| `/chunks pvp pos1` | Setzt die erste Ecke an deiner Position | +| `/chunks pvp pos2` | Setzt die zweite Ecke an deiner Position | +| `/chunks pvp create ` | Legt die Region aus den beiden Ecken an | +| `/chunks pvp delete ` | Löscht die Region | +| `/chunks pvp list` | Zeigt alle Regionen | + +### Wie funktioniert das? + +- Die Regionen sind **Rechtecke über die ganze Höhe**. Beide Ecken müssen in derselben Welt liegen. +- Solange ein Spieler in einer PvP-Region steht, bekommt er automatisch das Lands-Recht `lands.bypass.attack_player`. Lands prüft den Angriff dann nicht, und die rote Meldung bleibt aus. Verlässt er die Region, wird das Recht wieder entzogen. +- Falls Lands einen Schlag trotzdem abbricht, wird er freigegeben, wenn **Angreifer und Opfer beide** in der Region stehen. Das gilt auch für Pfeile und andere Projektile. +- Der Rückstoß wird in der Region ebenfalls freigegeben. +- **Außerhalb** der Region ändert sich nichts. Dort gelten weiter die Regeln von Lands. +- Die Regionen werden in `plugins/LandsChunkInfo/pvp-regions.yml` gespeichert. + +### Wichtig für die Server-Einrichtung + +Die PvP-Region von diesem Plugin ist eine **zusätzliche** Region. Sie ersetzt keine WorldGuard-Region. Wenn du PvP sonst überall verbieten willst, regelst du das weiterhin in WorldGuard (z. B. `pvp deny` für die ganze Welt und `pvp allow` für die Arena). Lege die Region von diesem Plugin am besten genauso groß wie die WorldGuard-Arena an. + +Alternative ohne dieses Plugin: In der Lands-Config (`plugins/Lands/config.yml`) gibt es unter `combat:` die Option `ally-wilderness`. Steht sie auf `true`, dürfen Spieler mit gemeinsamem Land überall in der Wildnis kämpfen. Nach einer Änderung ist ein Neustart nötig. + +--- + +## 6. Die Platzhalter (optional) + +Nur nötig, wenn du **PlaceholderAPI** hast und die Werte z. B. im Scoreboard oder in der Tab-Liste anzeigen willst. Die Werte beziehen sich auf das Hauptland des Spielers (sein eigenes Land, sonst das erste Land, in dem er vertraut ist). + +| Platzhalter | Zeigt | +|---|---| +| `%chunkinfo_land%` | Name des Lands (`-` ohne Land) | +| `%chunkinfo_used%` | Belegte Chunks | +| `%chunkinfo_max%` | Maximale Chunks (oder `unbegrenzt`) | +| `%chunkinfo_free%` | Freie Chunks (oder `unbegrenzt`) | +| `%chunkinfo_locked%` | Gesperrte Slots | +| `%chunkinfo_next_free%` | Zeit, bis der nächste Slot frei wird (`-` wenn keiner gesperrt ist) | +| `%chunkinfo_next_playtime%` | Online-Zeit bis zum nächsten Chunk durch Spielzeit (`-` wenn nicht eingerichtet oder Maximum erreicht) | +| `%chunkinfo_upkeep%` | Upkeep-Kosten pro Zyklus | +| `%chunkinfo_upkeep_in%` | Zeit bis zum nächsten Upkeep | +| `%chunkinfo_top_1_name%` | Name des Lands auf Platz 1 (statt 1 geht jede Zahl) | +| `%chunkinfo_top_1_chunks%` | Chunks des Lands auf Platz 1 | + +--- + +## 7. Einstellungen (config.yml) + +Die Datei findest du unter `plugins/LandsChunkInfo/config.yml`. Öffne sie mit einem Texteditor (Notepad++ oder VS Code). Nach einer Änderung gibst du im Spiel oder in der Konsole `/chunks reload` ein (braucht das Recht `landschunkinfo.admin`). + +**Wichtig:** Lass die Einrückungen (die Leerzeichen am Zeilenanfang) unverändert. Ändere nur die Werte hinter dem Doppelpunkt. + +### Wartezeit nach dem Unclaimen + +```yaml +unclaim-cooldown: + enabled: true + duration: 24h + enforce: true +``` + +- `enabled` – `true` = Funktion an, `false` = aus. +- `duration` – Wie lange ein Slot nach `/unclaim` gesperrt bleibt. Schreibweise: + - `30m` = 30 Minuten + - `12h` = 12 Stunden + - `2d` = 2 Tage + - `1d12h` = 1 Tag und 12 Stunden +- `enforce` – `true` = Das Land kann in dieser Zeit wirklich **nicht** neu claimen, wenn alle Plätze belegt oder gesperrt sind. `false` = es wird nur angezeigt, aber nichts blockiert. + +### Upkeep-Zeitpunkt + +```yaml +upkeep: + anchor-date: "" +``` + +Das Plugin liest den Rhythmus aus der Lands-Config und merkt sich automatisch, wann Lands das erste Mal Upkeep eingezogen hat. **Bis dahin ist die Anzeige nur geschätzt.** Wenn du genau weißt, an welchem Tag zuletzt eingezogen wurde, trage das Datum ein, zum Beispiel `"2026-10-15"`. + +### Slot freikaufen + +```yaml +skip: + enabled: true + payment: PLAYER + price-per-hour: 25.0 + min-price: 50.0 +``` + +- `payment` – `PLAYER` = das Geld kommt vom Spieler (Vault nötig). `LAND` = das Geld kommt aus der Landkasse (nur der Besitzer darf das). `gift` bezahlt immer der Spieler selbst. +- `price-per-hour` – Preis pro verbleibender Stunde Wartezeit. +- `min-price` – Mindestpreis, auch wenn nur noch wenige Minuten fehlen. + +Beispiel: Noch 10 Stunden Wartezeit, 25 pro Stunde ergibt 250. + +### Warteschlange, Watchlist, Top-Liste + +```yaml +queue: + max: 3 +watch: + max: 5 +top: + size: 10 +``` + +- `max` – Wie viele Einträge ein Spieler gleichzeitig haben darf. +- `top.size` – Wie viele Lands in `/chunks top` stehen. + +### Hinweis beim Einloggen + +```yaml +join-reminder: + enabled: true + upkeep-warning-hours: 48 +``` + +Mit `enabled: false` schaltest du den Hinweis ab. `upkeep-warning-hours` legt fest, ab wie vielen Stunden vor dem Einzug die Upkeep-Warnung kommt. + +### Texte ändern + +Unter `messages:` stehen die Meldungen. Farben schreibst du mit `&`: + +- `&a` = grün, `&c` = rot, `&e` = gelb, `&7` = grau + +`%time%` wird im Spiel durch die Restzeit ersetzt. Lass es stehen. + +--- + +## 8. Rechte (Permissions) + +Rechte vergibst du mit einem Rechte-Plugin, z. B. LuckPerms. + +| Recht | Wer bekommt es standardmäßig? | Was erlaubt es? | +|---|---|---| +| `landschunkinfo.use` | Alle | `/chunks`, `top` und den Hinweis beim Einloggen | +| `landschunkinfo.skip` | Alle | Eigenen Slot freikaufen | +| `landschunkinfo.gift` | Alle | Slot in fremdem Land freikaufen | +| `landschunkinfo.queue` | Alle | Warteschlange benutzen | +| `landschunkinfo.watch` | Alle | Watchlist benutzen | +| `landschunkinfo.bypass` | Nur OPs | Wartezeit nach dem Unclaimen gilt **nicht** | +| `landschunkinfo.admin` | Nur OPs | `/chunks reload` und `/chunks pvp ...` | + +**Beispiel:** Du willst, dass niemand außer Teammitgliedern Slots verschenken darf. Entziehe allen das Recht `landschunkinfo.gift` und gib es nur der Team-Gruppe. + +--- + +## 9. Häufige Fragen + +**Warum sieht ein Spieler „Gesperrt“, obwohl er nichts gemacht hat?** +Jemand aus seinem Land hat einen Chunk abgegeben. Die Sperre gilt für das **ganze Land**, nicht für einzelne Spieler. + +**Warum wird bei manchen Unclaims nichts gesperrt?** +Gesperrt wird nur, wenn ein Spieler selbst `/unclaim` benutzt. Nicht gesperrt wird, wenn das Land gelöscht wird oder Chunks durch den Upkeep verloren gehen. Spieler mit dem Recht `landschunkinfo.bypass` lösen ebenfalls keine Sperre aus. + +**Wie sehen Spieler, wie lange sie auf einen Chunk warten müssen?** +Mit `/chunks`. Dort steht „Nächster Chunk wieder frei in: …“. + +**Die Upkeep-Zeit stimmt nicht.** +Lands verrät dem Plugin nicht, wann genau der Zyklus gestartet ist. Nach dem ersten echten Einzug passt die Anzeige. Alternativ trägst du in `upkeep.anchor-date` ein bekanntes Einzugsdatum ein. + +**Muss ich den Server neu starten?** +Für Änderungen an der `config.yml` reicht `/chunks reload`. Beim Austausch der Jar-Datei brauchst du einen Neustart (kein `/reload`). + +**Verlieren Spieler ihre Chunks, wenn ich das Plugin entferne?** +Nein. Das Plugin ändert keine Lands-Daten außer bei einer Sache: Wenn die Warteschlange einen Chunk claimt. Entfernst du das Plugin, bleiben alle bestehenden Chunks gleich. Die gespeicherten Sperren und Listen liegen nur in `plugins/LandsChunkInfo/data.yml`. + +**Kann ich einem Spieler mehr Chunk-Slots geben?** +Nein, das geht nur in Lands selbst (`player-limits.yml`). Dieses Plugin ändert keine Limits. + +--- + +## 10. Datensicherung + +Alles, was sich das Plugin merkt, steht in diesen Dateien in `plugins/LandsChunkInfo/`: + +| Datei | Inhalt | +|---|---| +| `config.yml` | Deine Einstellungen | +| `data.yml` | Sperren, Warteschlange, Watchlist, letzter Upkeep | +| `pvp-regions.yml` | Die PvP-Regionen | + +Wenn du den Server umziehst oder ein Backup machst, kopiere diese Dateien mit. **Bearbeite `data.yml` und `pvp-regions.yml` nicht von Hand, solange der Server läuft.** Das Plugin überschreibt die Dateien sonst. + +--- + +## 11. Wenn etwas nicht klappt + +| Problem | Lösung | +|---|---| +| Plugin startet nicht, in der Konsole steht etwas mit „Lands“ | Lands fehlt oder ist nicht aktiv. Prüfe, ob die Lands-Jar im Ordner `plugins` liegt und startet | +| Fehler mit „Unsupported class file version“ oder „Java“ | Der Server läuft mit einem zu alten Java. Du brauchst **Java 25** | +| `/chunkinfo` zeigt „Too many arguments“ oder die Ausgabe von WorldEdit | Das ist der Befehl von WorldEdit/FAWE, nicht von diesem Plugin. Benutze `/chunks` oder `/chunkslots` | +| `/chunks` sagt „Du bist in keinem Land Mitglied“ | Der Spieler hat kein Land und ist in keinem als vertrauenswürdig eingetragen. Das ist normal | +| `skip` oder `gift` meldet, Vault fehle | Installiere Vault und ein Economy-Plugin, oder stelle `skip.payment` auf `LAND` (dann geht nur `skip`, `gift` bleibt gesperrt) | +| Die Platzhalter zeigen sich als Text, z. B. `%chunkinfo_used%` | PlaceholderAPI fehlt oder wurde nach diesem Plugin geladen. Starte den Server neu | +| Änderungen an der `config.yml` wirken nicht | `/chunks reload` ausführen. Falls es trotzdem nicht klappt: Auf Einrückungen und fehlende Anführungszeichen prüfen | +| Spieler können nach dem Unclaimen trotzdem sofort claimen | Prüfe `unclaim-cooldown.enforce`, das muss `true` sein. Und prüfe, ob der Spieler das Recht `landschunkinfo.bypass` hat (OPs haben es automatisch) | +| In der PvP-Region kommt trotzdem die Lands-Meldung oder kein Schaden | Prüfe mit `/chunks pvp list`, ob die Region existiert und ob **beide** Spieler darin stehen. Die Region ist ein Rechteck: am Rand zählt der Block, auf dem man steht | +| Mitglieder desselben Lands bekommen in der Arena keinen Rückstoß | Das Plugin gibt den Rückstoß frei, wenn Lands ihn blockiert. Hilft das nicht, kommt es von einem anderen Plugin (z. B. Team- oder Friendly-Fire-Plugin) | +| Nach dem Update ist die alte Version aktiv | Es liegen zwei Jar-Dateien in `plugins`. Lösche die alte und starte neu | + +Wenn du nicht weiterkommst: Kopiere die **roten Zeilen aus der Server-Konsole** (oder aus `logs/latest.log`) und gib sie weiter. Daraus lässt sich fast immer die Ursache erkennen. + +--- + +## 12. Bekannte Grenzen + +- Die PvP-Regionen funktionieren auf einem echten Server. Die übrigen Funktionen (Sperren, Skip, Queue, Watch) wurden dort noch nicht ausführlich getestet. Probiere neue Versionen erst auf einem Testserver aus. +- Die Upkeep-Zeit ist bis zum ersten echten Einzug eine Schätzung. +- Die Warteschlange und die Watchlist arbeiten nur für Spieler, die **online** sind. +- Lands-Limits (z. B. maximale Chunks) kann das Plugin nicht verändern. +- PvP-Regionen sind einfache Rechtecke ohne Höhenbegrenzung und keine WorldGuard-Regionen. +- Die rote Lands-Meldung zum PvP in der Wildnis kann das Plugin nicht umschreiben. Sie wird in der Arena nur vermieden, weil Lands den Angriff dort nicht mehr prüft. diff --git a/pom.xml b/pom.xml index 89dad2d..cea1480 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 de.landschunkinfo LandsChunkInfo - 1.0.4 + 1.0.7 jar diff --git a/src/main/java/de/landschunkinfo/ChunkExpansion.java b/src/main/java/de/landschunkinfo/ChunkExpansion.java index 7c4c946..46c65c1 100644 --- a/src/main/java/de/landschunkinfo/ChunkExpansion.java +++ b/src/main/java/de/landschunkinfo/ChunkExpansion.java @@ -1,84 +1,88 @@ -package de.landschunkinfo; - -import me.angeschossen.lands.api.land.Land; -import me.clip.placeholderapi.expansion.PlaceholderExpansion; -import org.bukkit.OfflinePlayer; - -import java.util.List; -import java.util.Locale; - -/** - * Platzhalter (Bezug: Hauptland des Spielers, also eigenes Land oder erstes Land mit Vertrauen): - * %chunkinfo_land%, _used, _max, _free, _locked, _next_free, _upkeep, _upkeep_in, - * %chunkinfo_top__name%, %chunkinfo_top__chunks% - */ -final class ChunkExpansion extends PlaceholderExpansion { - - private final LandsChunkInfo plugin; - - ChunkExpansion(LandsChunkInfo plugin) { - this.plugin = plugin; - } - - @Override - public String getIdentifier() { - return "chunkinfo"; - } - - @Override - public String getAuthor() { - return "LandsChunkInfo"; - } - - @Override - public String getVersion() { - return plugin.getPluginMeta().getVersion(); - } - - @Override - public boolean persist() { - return true; - } - - @Override - public String onRequest(OfflinePlayer player, String params) { - String key = params.toLowerCase(Locale.ROOT); - if (key.startsWith("top_")) { - String[] p = key.split("_"); - if (p.length != 3) { - return null; - } - try { - int rank = Integer.parseInt(p[1]); - List top = plugin.top(rank); - if (top.size() < rank) { - return "-"; - } - Land l = top.get(rank - 1); - return p[2].equals("name") ? l.getName() : p[2].equals("chunks") ? String.valueOf(l.getChunksAmount()) : null; - } catch (NumberFormatException e) { - return null; - } - } - if (player == null) { - return ""; - } - Land land = plugin.primaryLand(player.getUniqueId()); - if (land == null) { - return key.equals("land") ? "-" : "0"; - } - List locked = plugin.cooldownActive() ? plugin.store.active(LandsChunkInfo.landId(land)) : List.of(); - long now = System.currentTimeMillis(); - return switch (key) { - case "land" -> land.getName(); - case "used" -> String.valueOf(land.getChunksAmount()); - case "max" -> land.getMaxChunks() <= 0 ? "unbegrenzt" : String.valueOf(land.getMaxChunks()); - case "free" -> plugin.freeSlots(land) < 0 ? "unbegrenzt" : String.valueOf(plugin.freeSlots(land)); - case "locked" -> String.valueOf(locked.size()); - case "next_free" -> locked.isEmpty() ? "-" : TimeUtil.format(locked.get(0) - now); - case "upkeep" -> String.format(Locale.GERMANY, "%.2f", land.getUpkeepCosts()); - case "upkeep_in" -> TimeUtil.format(plugin.nextUpkeep() - now); - default -> null; - }; - } -} +package de.landschunkinfo; + +import me.angeschossen.lands.api.land.Land; +import me.clip.placeholderapi.expansion.PlaceholderExpansion; +import org.bukkit.OfflinePlayer; + +import java.util.List; +import java.util.Locale; + +/** + * Platzhalter (Bezug: Hauptland des Spielers, also eigenes Land oder erstes Land mit Vertrauen): + * %chunkinfo_land%, _used, _max, _free, _locked, _next_free, _upkeep, _upkeep_in, + * %chunkinfo_top__name%, %chunkinfo_top__chunks% + */ +final class ChunkExpansion extends PlaceholderExpansion { + + private final LandsChunkInfo plugin; + + ChunkExpansion(LandsChunkInfo plugin) { + this.plugin = plugin; + } + + @Override + public String getIdentifier() { + return "chunkinfo"; + } + + @Override + public String getAuthor() { + return "LandsChunkInfo"; + } + + @Override + public String getVersion() { + return plugin.getPluginMeta().getVersion(); + } + + @Override + public boolean persist() { + return true; + } + + @Override + public String onRequest(OfflinePlayer player, String params) { + String key = params.toLowerCase(Locale.ROOT); + if (key.startsWith("top_")) { + String[] p = key.split("_"); + if (p.length != 3) { + return null; + } + try { + int rank = Integer.parseInt(p[1]); + List top = plugin.top(rank); + if (top.size() < rank) { + return "-"; + } + Land l = top.get(rank - 1); + return p[2].equals("name") ? l.getName() : p[2].equals("chunks") ? String.valueOf(l.getChunksAmount()) : null; + } catch (NumberFormatException e) { + return null; + } + } + if (player == null) { + return ""; + } + if (key.equals("next_playtime")) { + LandsChunkInfo.Reward r = plugin.playtimeReward(player.getUniqueId(), "player_chunks"); + return r == null ? "-" : TimeUtil.format(r.remainingMs()); + } + Land land = plugin.primaryLand(player.getUniqueId()); + if (land == null) { + return key.equals("land") ? "-" : "0"; + } + List locked = plugin.cooldownActive() ? plugin.store.active(LandsChunkInfo.landId(land)) : List.of(); + long now = System.currentTimeMillis(); + return switch (key) { + case "land" -> land.getName(); + case "used" -> String.valueOf(land.getChunksAmount()); + case "max" -> land.getMaxChunks() <= 0 ? "unbegrenzt" : String.valueOf(land.getMaxChunks()); + case "free" -> plugin.freeSlots(land) < 0 ? "unbegrenzt" : String.valueOf(plugin.freeSlots(land)); + case "locked" -> String.valueOf(locked.size()); + case "next_free" -> locked.isEmpty() ? "-" : TimeUtil.format(locked.get(0) - now); + case "upkeep" -> String.format(Locale.GERMANY, "%.2f", land.getUpkeepCosts()); + case "upkeep_in" -> TimeUtil.format(plugin.nextUpkeep() - now); + default -> null; + }; + } +} diff --git a/src/main/java/de/landschunkinfo/InfoCommand.java b/src/main/java/de/landschunkinfo/InfoCommand.java index afca7a8..cae0f28 100644 --- a/src/main/java/de/landschunkinfo/InfoCommand.java +++ b/src/main/java/de/landschunkinfo/InfoCommand.java @@ -1,530 +1,468 @@ -package de.landschunkinfo; - -import de.landschunkinfo.LockStore.Entry; -import de.landschunkinfo.LockStore.Kind; -import me.angeschossen.lands.api.framework.limit.Limit; -import me.angeschossen.lands.api.land.Land; -import me.angeschossen.lands.api.player.LandPlayer; -import org.bukkit.Bukkit; -import org.bukkit.World; -import org.bukkit.command.Command; -import org.bukkit.command.CommandExecutor; -import org.bukkit.command.CommandSender; -import org.bukkit.command.TabCompleter; -import org.bukkit.configuration.file.YamlConfiguration; -import org.bukkit.entity.Player; - -import java.util.ArrayList; -import java.util.List; -import java.util.Locale; -import java.util.UUID; - -final class InfoCommand implements CommandExecutor, TabCompleter { - - private static final List SUBS = List.of("top", "skip", "gift", "queue", "watch", "temp", "pvp", "reload"); - - private final LandsChunkInfo plugin; - - InfoCommand(LandsChunkInfo plugin) { - this.plugin = plugin; - } - - // ------------------------------------------------------------ Dispatcher - - @Override - public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { - if (args.length >= 1 && args[0].equalsIgnoreCase("reload")) { - if (!sender.hasPermission("landschunkinfo.admin")) { - plugin.send(sender, plugin.cfgMsg("no-permission")); - return true; - } - plugin.reload(); - plugin.send(sender, plugin.cfgMsg("reloaded")); - return true; - } - if (!(sender instanceof Player p)) { - plugin.send(sender, plugin.cfgMsg("players-only")); - return true; - } - if (!p.hasPermission("landschunkinfo.use")) { - plugin.send(p, plugin.cfgMsg("no-permission")); - return true; - } - String sub = args.length == 0 ? "" : args[0].toLowerCase(Locale.ROOT); - switch (sub) { - case "top" -> top(p); - case "skip" -> skip(p, args, false); - case "gift" -> skip(p, args, true); - case "queue" -> queue(p, args); - case "watch" -> watch(p, args); - case "temp" -> temp(p, args); - case "pvp" -> pvp(p, args); - default -> info(p, args); - } - return true; - } - - private void pvp(Player p, String[] args) { - if (!allowed(p, "admin")) { - return; - } - String action = args.length < 2 ? "" : args[1].toLowerCase(Locale.ROOT); - switch (action) { - case "pos1" -> { - plugin.pvp.setPos1(p); - plugin.send(p, "&aPunkt 1 gesetzt."); - } - case "pos2" -> { - plugin.pvp.setPos2(p); - plugin.send(p, "&aPunkt 2 gesetzt."); - } - case "create" -> { - if (args.length < 3) { - plugin.send(p, "&cNutzung: /chunks pvp create "); - return; - } - String err = plugin.pvp.create(p, args[2]); - plugin.send(p, err == null ? "&aPvP-Region &e" + args[2] + " &aerstellt." : "&c" + err); - } - case "delete" -> { - if (args.length < 3) { - plugin.send(p, "&cNutzung: /chunks pvp delete "); - return; - } - plugin.send(p, plugin.pvp.delete(args[2]) ? "&aRegion geloescht." : "&cRegion nicht gefunden."); - } - case "list" -> { - if (plugin.pvp.all().isEmpty()) { - plugin.send(p, "&7Keine PvP-Regionen vorhanden."); - } - plugin.pvp.all().values().forEach(r -> p.sendMessage(plugin.line("&8- &e" + r.name() + " &7(" + r.world() - + ": " + r.minX() + "," + r.minZ() + " bis " + r.maxX() + "," + r.maxZ() + ")"))); - } - default -> plugin.send(p, "&7/chunks pvp pos1 | pos2 | create | delete | list"); - } - } - - private boolean allowed(Player p, String perm) { - if (p.hasPermission("landschunkinfo." + perm)) { - return true; - } - plugin.send(p, plugin.cfgMsg("no-permission")); - return false; - } - - private Land findLand(String name) { - for (Object o : plugin.lands.getLands()) { - Land l = (Land) o; - if (l.getName().equalsIgnoreCase(name)) { - return l; - } - } - return null; - } - - private static boolean isMember(Land land, UUID uuid) { - return uuid.equals(land.getOwnerUID()) || land.isTrusted(uuid); - } - - // ------------------------------------------------------------------ Info - - private void info(Player p, String[] args) { - List shown = plugin.landsOf(p.getUniqueId()); - if (args.length >= 1) { - String wanted = String.join(" ", args); - shown = shown.stream().filter(l -> l.getName().equalsIgnoreCase(wanted)).toList(); - if (shown.isEmpty()) { - plugin.send(p, plugin.cfgMsg("land-not-found")); - return; - } - } else if (shown.isEmpty()) { - plugin.send(p, plugin.cfgMsg("no-land")); - return; - } - - LandPlayer lp = plugin.lands.getLandPlayer(p.getUniqueId()); - if (lp != null) { - Limit limit = Limit.getById("player_chunks"); - if (limit != null) { - int lim = lp.getLimit(limit); - p.sendMessage(plugin.line("&8&m &r &aDeine Chunks &8&m ")); - p.sendMessage(plugin.line("&7Von dir geclaimt: &e" + lp.getChunksClaimed().size() - + " &7/ &e" + (lim < 0 ? "unbegrenzt" : lim))); - } - } - for (Land land : shown) { - describe(p, land); - } - p.sendMessage(plugin.line("&8Mehr: &7/chunks top | skip | gift | queue | watch | temp")); - } - - private void describe(Player p, Land land) { - int max = land.getMaxChunks(); - int size = land.getChunksAmount(); - String id = LandsChunkInfo.landId(land); - List locked = plugin.cooldownActive() ? plugin.store.active(id) : List.of(); - long now = System.currentTimeMillis(); - - p.sendMessage(plugin.line("&8&m &r &a" + land.getName() + " &8&m ")); - if (max <= 0) { - p.sendMessage(plugin.line("&7Chunks: &e" + size + " &7(kein Limit)")); - } else { - p.sendMessage(plugin.line("&7Chunks: &e" + size + " &7/ &e" + max + " &8| &7Frei: &a" - + plugin.freeSlots(land) + (locked.isEmpty() ? "" : " &8| &7Gesperrt: &c" + locked.size()))); - } - if (plugin.cooldownActive()) { - if (locked.isEmpty()) { - p.sendMessage(plugin.line("&7Gesperrte Slots: &akeine")); - } else { - long first = locked.get(0); - p.sendMessage(plugin.line("&7Naechster Chunk wieder frei in: &e" + TimeUtil.format(first - now) - + " &8(" + LandsChunkInfo.fmt(first) + ")")); - if (locked.size() > 1) { - StringBuilder sb = new StringBuilder("&7Danach: "); - locked.stream().skip(1).limit(4).forEach(t -> sb.append("&e") - .append(TimeUtil.format(t - now)).append("&7, ")); - sb.setLength(sb.length() - 2); - p.sendMessage(plugin.line(sb + (locked.size() > 5 ? " ..." : ""))); - } - if (plugin.getConfig().getBoolean("skip.enabled", true)) { - p.sendMessage(plugin.line("&7Sofort freischalten: &e/chunks skip &7(Preis: &e" - + price(first - now) + "&7)")); - } - } - } - - for (Entry t : plugin.store.entries(Kind.TEMP)) { - if (t.landId().equals(id)) { - p.sendMessage(plugin.line("&7Temp-Chunk &e" + t.x() + ", " + t.z() + " &7laeuft ab in &e" - + TimeUtil.format(t.until() - now))); - } - } - - double upkeep = land.getUpkeepCosts(); - if (upkeep > 0) { - long next = plugin.nextUpkeep(); - double balance = land.getBalance(); - p.sendMessage(plugin.line("&7Upkeep: &e" + money(upkeep) + " &7pro Zyklus, naechster Einzug in &e" - + TimeUtil.format(next - now) + " &8(" + LandsChunkInfo.fmt(next) + ")")); - if (balance < upkeep) { - String risk = ""; - YamlConfiguration lc = plugin.landsConfig(); - if (lc != null && lc.getBoolean("upkeep.unclaim", false) && lc.getDouble("upkeep.per-chunk", 0) > 0) { - int lost = (int) Math.min(size, Math.ceil((upkeep - balance) / lc.getDouble("upkeep.per-chunk"))); - risk = " - " + lost + " Chunk(s) wuerden verloren gehen!"; - } - p.sendMessage(plugin.line("&cGuthaben (" + money(balance) + ") reicht nicht fuer den Upkeep." + risk)); - } - } - - Long inactive = plugin.inactivityRemaining(land); - if (inactive != null && inactive >= 0) { - boolean ownerOnline = land.getOwnerUID() != null && Bukkit.getPlayer(land.getOwnerUID()) != null; - p.sendMessage(plugin.line("&7Inaktivitaet des Besitzers: " + (ownerOnline - ? "&aBesitzer online" - : "&eLand gilt in &c" + TimeUtil.format(inactive) + " &eals inaktiv"))); - } - } - - private static String money(double v) { - return String.format(Locale.GERMANY, "%.2f", v); - } - - // ------------------------------------------------------------------- Top - - private void top(Player p) { - int n = plugin.getConfig().getInt("top.size", 10); - p.sendMessage(plugin.line("&8&m &r &aTop-Lands nach Chunks &8&m ")); - int i = 1; - for (Land l : plugin.top(n)) { - p.sendMessage(plugin.line("&e#" + i++ + " &7" + l.getName() + " &8- &a" + l.getChunksAmount() + " Chunks")); - } - } - - // ------------------------------------------------------------ Skip / Gift - - private String price(long remainingMs) { - return money(priceValue(remainingMs)); - } - - private double priceValue(long remainingMs) { - double perHour = plugin.getConfig().getDouble("skip.price-per-hour", 25.0); - double min = plugin.getConfig().getDouble("skip.min-price", 50.0); - return Math.max(min, remainingMs / 3_600_000.0 * perHour); - } - - /** /chunks skip [Land] [confirm] bzw. /chunks gift [confirm] */ - private void skip(Player p, String[] args, boolean gift) { - if (!allowed(p, gift ? "gift" : "skip")) { - return; - } - if (!plugin.getConfig().getBoolean("skip.enabled", true) || !plugin.cooldownActive()) { - plugin.send(p, "&cDiese Funktion ist deaktiviert."); - return; - } - boolean confirm = args.length > 1 && args[args.length - 1].equalsIgnoreCase("confirm"); - int end = confirm ? args.length - 1 : args.length; - String name = end > 1 ? String.join(" ", List.of(args).subList(1, end)) : null; - - Land land; - if (name != null) { - land = findLand(name); - } else if (gift) { - plugin.send(p, "&cNutzung: /chunks gift [confirm]"); - return; - } else { - land = plugin.landsOf(p.getUniqueId()).stream() - .filter(l -> !plugin.store.active(LandsChunkInfo.landId(l)).isEmpty()).findFirst().orElse(null); - if (land == null) { - plugin.send(p, "&aDu hast keine gesperrten Slots."); - return; - } - } - if (land == null || (!gift && !isMember(land, p.getUniqueId()))) { - plugin.send(p, plugin.cfgMsg("land-not-found")); - return; - } - List locked = plugin.store.active(LandsChunkInfo.landId(land)); - if (locked.isEmpty()) { - plugin.send(p, "&e" + land.getName() + " &ahat keine gesperrten Slots."); - return; - } - long remaining = locked.get(0) - System.currentTimeMillis(); - double price = priceValue(remaining); - boolean fromLand = !gift && "LAND".equalsIgnoreCase(plugin.getConfig().getString("skip.payment", "PLAYER")); - - if (fromLand && !p.getUniqueId().equals(land.getOwnerUID())) { - plugin.send(p, "&cNur der Besitzer darf aus der Landkasse zahlen."); - return; - } - if (!fromLand && plugin.vault == null) { - plugin.send(p, "&cDafuer wird Vault mit einem Economy-Plugin benoetigt."); - return; - } - if (!confirm) { - plugin.send(p, "&7Slot in &e" + land.getName() + " &7(noch &e" + TimeUtil.format(remaining) - + "&7) freischalten fuer &e" + money(price) + (fromLand ? " &7aus der Landkasse" : "") - + "&7. Bestaetigen: &e/chunks " + (gift ? "gift " : "skip ") + land.getName() + " confirm"); - return; - } - - if (fromLand) { - if (land.getBalance() < price) { - plugin.send(p, "&cDie Landkasse hat nicht genug Guthaben."); - return; - } - land.setBalance(land.getBalance() - price); - } else { - if (plugin.vault.balance(p) < price || !plugin.vault.withdraw(p, price)) { - plugin.send(p, "&cDu hast nicht genug Geld."); - return; - } - } - if (!plugin.store.removeEarliest(LandsChunkInfo.landId(land))) { - plugin.send(p, "&cDer Slot ist inzwischen von selbst frei geworden."); - return; - } - plugin.send(p, "&aSlot in &e" + land.getName() + " &afreigeschaltet (&e" + money(price) + " &abezahlt)."); - if (gift) { - for (Player m : plugin.onlineMembers(land)) { - plugin.send(m, "&a" + p.getName() + " hat einen Chunk-Slot fuer &e" + land.getName() + " &afreigeschaltet!"); - } - } - } - - // ----------------------------------------------------------------- Queue - - private void queue(Player p, String[] args) { - if (!allowed(p, "queue")) { - return; - } - String arg = args.length > 1 ? args[1].toLowerCase(Locale.ROOT) : ""; - if (arg.equals("list")) { - listEntries(p, Kind.QUEUE, "Warteschlange"); - return; - } - if (arg.equals("clear")) { - plugin.send(p, "&7" + plugin.store.removeAll(Kind.QUEUE, p.getUniqueId()) + " Eintraege entfernt."); - return; - } - Land land; - if (args.length > 1) { - land = findLand(String.join(" ", List.of(args).subList(1, args.length))); - } else { - land = plugin.primaryLand(p.getUniqueId()); - } - if (land == null || !isMember(land, p.getUniqueId())) { - plugin.send(p, plugin.cfgMsg("land-not-found")); - return; - } - World w = p.getWorld(); - int cx = p.getLocation().getBlockX() >> 4; - int cz = p.getLocation().getBlockZ() >> 4; - if (plugin.lands.getLandByUnloadedChunk(w, cx, cz) != null) { - plugin.send(p, "&cDieser Chunk ist schon geclaimt. Mit &e/chunks watch &ckannst du ihn beobachten."); - return; - } - List mine = plugin.store.entries(Kind.QUEUE).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); - if (mine.size() >= plugin.getConfig().getInt("queue.max", 3)) { - plugin.send(p, "&cDeine Warteschlange ist voll (&e/chunks queue clear&c)."); - return; - } - if (mine.stream().anyMatch(e -> e.at(w.getName(), cx, cz))) { - plugin.send(p, "&cDieser Chunk ist schon in deiner Warteschlange."); - return; - } - plugin.store.add(Kind.QUEUE, new Entry(p.getUniqueId(), LandsChunkInfo.landId(land), w.getName(), cx, cz, 0)); - int free = plugin.freeSlots(land); - plugin.send(p, "&aChunk &e" + cx + ", " + cz + " &avorgemerkt fuer &e" + land.getName() + "&a. " - + (free == 0 ? "Er wird geclaimt, sobald ein Slot frei wird (du musst dafuer online sein)." - : "Er wird in Kuerze geclaimt.")); - } - - // ----------------------------------------------------------------- Watch - - private void watch(Player p, String[] args) { - if (!allowed(p, "watch")) { - return; - } - String arg = args.length > 1 ? args[1].toLowerCase(Locale.ROOT) : ""; - if (arg.equals("list")) { - listEntries(p, Kind.WATCH, "Watchlist"); - return; - } - if (arg.equals("clear")) { - plugin.send(p, "&7" + plugin.store.removeAll(Kind.WATCH, p.getUniqueId()) + " Eintraege entfernt."); - return; - } - World w = p.getWorld(); - int cx = p.getLocation().getBlockX() >> 4; - int cz = p.getLocation().getBlockZ() >> 4; - Land holder = plugin.lands.getLandByUnloadedChunk(w, cx, cz); - if (holder == null) { - plugin.send(p, "&cDieser Chunk ist frei - du kannst ihn direkt claimen oder mit &e/chunks queue &avormerken."); - return; - } - List mine = plugin.store.entries(Kind.WATCH).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); - if (mine.size() >= plugin.getConfig().getInt("watch.max", 5)) { - plugin.send(p, "&cDeine Watchlist ist voll (&e/chunks watch clear&c)."); - return; - } - if (mine.stream().anyMatch(e -> e.at(w.getName(), cx, cz))) { - plugin.send(p, "&cDen beobachtest du schon."); - return; - } - plugin.store.add(Kind.WATCH, new Entry(p.getUniqueId(), LandsChunkInfo.landId(holder), w.getName(), cx, cz, 0)); - plugin.send(p, "&aDu wirst benachrichtigt, sobald Chunk &e" + cx + ", " + cz + " &a(Land &e" + holder.getName() + "&a) frei wird."); - } - - private void listEntries(Player p, Kind kind, String title) { - List mine = plugin.store.entries(kind).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); - p.sendMessage(plugin.line("&8&m &r &a" + title + " &8&m ")); - if (mine.isEmpty()) { - p.sendMessage(plugin.line("&7(leer)")); - } - for (Entry e : mine) { - Land land = plugin.landById(e.landId()); - p.sendMessage(plugin.line("&e" + e.world() + " " + e.x() + ", " + e.z() - + " &8- &7Land: &e" + (land == null ? "?" : land.getName()))); - } - } - - // ------------------------------------------------------------------ Temp - - private void temp(Player p, String[] args) { - if (!allowed(p, "temp")) { - return; - } - if (!plugin.getConfig().getBoolean("temp-claims.enabled", true)) { - plugin.send(p, "&cDiese Funktion ist deaktiviert."); - return; - } - World w = p.getWorld(); - int cx = p.getLocation().getBlockX() >> 4; - int cz = p.getLocation().getBlockZ() >> 4; - String arg = args.length > 1 ? args[1].toLowerCase(Locale.ROOT) : ""; - - if (arg.equals("list")) { - p.sendMessage(plugin.line("&8&m &r &aTemp-Chunks &8&m ")); - long now = System.currentTimeMillis(); - plugin.store.entries(Kind.TEMP).stream().filter(e -> plugin.landsOf(p.getUniqueId()).stream() - .anyMatch(l -> LandsChunkInfo.landId(l).equals(e.landId()))).forEach(e -> p.sendMessage(plugin.line( - "&e" + e.world() + " " + e.x() + ", " + e.z() + " &8- &7noch &e" + TimeUtil.format(e.until() - now)))); - return; - } - Land land = plugin.lands.getLandByUnloadedChunk(w, cx, cz); - if (land == null || !p.getUniqueId().equals(land.getOwnerUID())) { - plugin.send(p, "&cDu musst in einem Chunk deines eigenen Lands stehen."); - return; - } - String id = LandsChunkInfo.landId(land); - if (arg.equals("cancel")) { - boolean removed = plugin.store.entries(Kind.TEMP).stream() - .filter(e -> e.landId().equals(id) && e.at(w.getName(), cx, cz)) - .anyMatch(e -> plugin.store.remove(Kind.TEMP, e)); - plugin.send(p, removed ? "&aDie Zeitbegrenzung fuer diesen Chunk wurde entfernt." : "&cDieser Chunk hat keine Zeitbegrenzung."); - return; - } - int days; - try { - days = Integer.parseInt(arg); - } catch (NumberFormatException ex) { - plugin.send(p, "&cNutzung: /chunks temp | cancel | list"); - return; - } - int maxDays = plugin.getConfig().getInt("temp-claims.max-days", 30); - if (days < 1 || days > maxDays) { - plugin.send(p, "&cErlaubt sind 1 bis " + maxDays + " Tage."); - return; - } - List forLand = plugin.store.entries(Kind.TEMP).stream().filter(e -> e.landId().equals(id)).toList(); - Entry existing = forLand.stream().filter(e -> e.at(w.getName(), cx, cz)).findFirst().orElse(null); - if (existing == null && forLand.size() >= plugin.getConfig().getInt("temp-claims.max-per-land", 3)) { - plugin.send(p, "&cEs sind schon zu viele Temp-Chunks in diesem Land."); - return; - } - if (existing != null) { - plugin.store.remove(Kind.TEMP, existing); - } - long until = System.currentTimeMillis() + days * 86_400_000L; - plugin.store.add(Kind.TEMP, new Entry(p.getUniqueId(), id, w.getName(), cx, cz, until)); - plugin.send(p, "&aChunk &e" + cx + ", " + cz + " &awird in &e" + days + " Tag(en) &aautomatisch freigegeben (" - + LandsChunkInfo.fmt(until) + ")."); - } - - // ----------------------------------------------------------------- Tab - - @Override - public List onTabComplete(CommandSender s, Command c, String alias, String[] args) { - if (!(s instanceof Player p)) { - return List.of(); - } - String last = args[args.length - 1].toLowerCase(Locale.ROOT); - List out = new ArrayList<>(); - if (args.length == 1) { - out.addAll(SUBS); - plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); - } else { - switch (args[0].toLowerCase(Locale.ROOT)) { - case "queue", "watch" -> out.addAll(args.length == 2 ? List.of("list", "clear") : List.of()); - case "temp" -> out.addAll(List.of("list", "cancel", "1", "7", "14", "30")); - case "pvp" -> { - if (args.length == 2) { - out.addAll(List.of("pos1", "pos2", "create", "delete", "list")); - } else if (args[1].equalsIgnoreCase("delete")) { - out.addAll(plugin.pvp.names()); - } - } - case "skip", "gift" -> { - out.add("confirm"); - plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); - } - default -> { } - } - if (args[0].equalsIgnoreCase("queue")) { - plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); - } - } - return out.stream().filter(o -> o.toLowerCase(Locale.ROOT).startsWith(last)).toList(); - } -} +package de.landschunkinfo; + +import de.landschunkinfo.LockStore.Entry; +import de.landschunkinfo.LockStore.Kind; +import me.angeschossen.lands.api.framework.limit.Limit; +import me.angeschossen.lands.api.land.Land; +import me.angeschossen.lands.api.player.LandPlayer; +import org.bukkit.Bukkit; +import org.bukkit.World; +import org.bukkit.command.Command; +import org.bukkit.command.CommandExecutor; +import org.bukkit.command.CommandSender; +import org.bukkit.command.TabCompleter; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; + +import java.util.ArrayList; +import java.util.List; +import java.util.Locale; +import java.util.UUID; + +final class InfoCommand implements CommandExecutor, TabCompleter { + + private static final List SUBS = List.of("top", "skip", "gift", "queue", "watch", "pvp", "reload"); + + private final LandsChunkInfo plugin; + + InfoCommand(LandsChunkInfo plugin) { + this.plugin = plugin; + } + + // ------------------------------------------------------------ Dispatcher + + @Override + public boolean onCommand(CommandSender sender, Command command, String label, String[] args) { + if (args.length >= 1 && args[0].equalsIgnoreCase("reload")) { + if (!sender.hasPermission("landschunkinfo.admin")) { + plugin.send(sender, plugin.cfgMsg("no-permission")); + return true; + } + plugin.reload(); + plugin.send(sender, plugin.cfgMsg("reloaded")); + return true; + } + if (!(sender instanceof Player p)) { + plugin.send(sender, plugin.cfgMsg("players-only")); + return true; + } + if (!p.hasPermission("landschunkinfo.use")) { + plugin.send(p, plugin.cfgMsg("no-permission")); + return true; + } + String sub = args.length == 0 ? "" : args[0].toLowerCase(Locale.ROOT); + switch (sub) { + case "top" -> top(p); + case "skip" -> skip(p, args, false); + case "gift" -> skip(p, args, true); + case "queue" -> queue(p, args); + case "watch" -> watch(p, args); + case "pvp" -> pvp(p, args); + default -> info(p, args); + } + return true; + } + + private void pvp(Player p, String[] args) { + if (!allowed(p, "admin")) { + return; + } + String action = args.length < 2 ? "" : args[1].toLowerCase(Locale.ROOT); + switch (action) { + case "pos1" -> { + plugin.pvp.setPos1(p); + plugin.send(p, "&aPunkt 1 gesetzt."); + } + case "pos2" -> { + plugin.pvp.setPos2(p); + plugin.send(p, "&aPunkt 2 gesetzt."); + } + case "create" -> { + if (args.length < 3) { + plugin.send(p, "&cNutzung: /chunks pvp create "); + return; + } + String err = plugin.pvp.create(p, args[2]); + plugin.send(p, err == null ? "&aPvP-Region &e" + args[2] + " &aerstellt." : "&c" + err); + } + case "delete" -> { + if (args.length < 3) { + plugin.send(p, "&cNutzung: /chunks pvp delete "); + return; + } + plugin.send(p, plugin.pvp.delete(args[2]) ? "&aRegion geloescht." : "&cRegion nicht gefunden."); + } + case "list" -> { + if (plugin.pvp.all().isEmpty()) { + plugin.send(p, "&7Keine PvP-Regionen vorhanden."); + } + plugin.pvp.all().values().forEach(r -> p.sendMessage(plugin.line("&8- &e" + r.name() + " &7(" + r.world() + + ": " + r.minX() + "," + r.minZ() + " bis " + r.maxX() + "," + r.maxZ() + ")"))); + } + default -> plugin.send(p, "&7/chunks pvp pos1 | pos2 | create | delete | list"); + } + } + + private boolean allowed(Player p, String perm) { + if (p.hasPermission("landschunkinfo." + perm)) { + return true; + } + plugin.send(p, plugin.cfgMsg("no-permission")); + return false; + } + + private Land findLand(String name) { + for (Object o : plugin.lands.getLands()) { + Land l = (Land) o; + if (l.getName().equalsIgnoreCase(name)) { + return l; + } + } + return null; + } + + private static boolean isMember(Land land, UUID uuid) { + return uuid.equals(land.getOwnerUID()) || land.isTrusted(uuid); + } + + // ------------------------------------------------------------------ Info + + private void info(Player p, String[] args) { + List shown = plugin.landsOf(p.getUniqueId()); + if (args.length >= 1) { + String wanted = String.join(" ", args); + shown = shown.stream().filter(l -> l.getName().equalsIgnoreCase(wanted)).toList(); + if (shown.isEmpty()) { + plugin.send(p, plugin.cfgMsg("land-not-found")); + return; + } + } else if (shown.isEmpty()) { + plugin.send(p, plugin.cfgMsg("no-land")); + return; + } + + LandPlayer lp = plugin.lands.getLandPlayer(p.getUniqueId()); + if (lp != null) { + Limit limit = Limit.getById("player_chunks"); + if (limit != null) { + int lim = lp.getLimit(limit); + p.sendMessage(plugin.line("&8&m &r &aDeine Chunks &8&m ")); + p.sendMessage(plugin.line("&7Von dir geclaimt: &e" + lp.getChunksClaimed().size() + + " &7/ &e" + (lim < 0 ? "unbegrenzt" : lim))); + } + } + playtimeLine(p, "player_chunks", "Naechster Chunk durch Spielzeit"); + playtimeLine(p, "land_size", "Naechster Land-Chunk durch Spielzeit"); + for (Land land : shown) { + describe(p, land); + } + p.sendMessage(plugin.line("&8Mehr: &7/chunks top | skip | gift | queue | watch")); + } + + private void playtimeLine(Player p, String limit, String title) { + LandsChunkInfo.Reward r = plugin.playtimeReward(p.getUniqueId(), limit); + if (r != null) { + p.sendMessage(plugin.line("&7" + title + ": &e" + TimeUtil.format(r.remainingMs()) + + " &7Online-Zeit &8(Bonus bisher: " + r.earned() + (r.max() >= 0 ? "/" + r.max() : "") + ")")); + } + } + + private void describe(Player p, Land land) { + int max = land.getMaxChunks(); + int size = land.getChunksAmount(); + String id = LandsChunkInfo.landId(land); + List locked = plugin.cooldownActive() ? plugin.store.active(id) : List.of(); + long now = System.currentTimeMillis(); + + p.sendMessage(plugin.line("&8&m &r &a" + land.getName() + " &8&m ")); + if (max <= 0) { + p.sendMessage(plugin.line("&7Chunks: &e" + size + " &7(kein Limit)")); + } else { + p.sendMessage(plugin.line("&7Chunks: &e" + size + " &7/ &e" + max + " &8| &7Frei: &a" + + plugin.freeSlots(land) + (locked.isEmpty() ? "" : " &8| &7Gesperrt: &c" + locked.size()))); + } + if (plugin.cooldownActive()) { + if (locked.isEmpty()) { + p.sendMessage(plugin.line("&7Gesperrte Slots: &akeine")); + } else { + long first = locked.get(0); + p.sendMessage(plugin.line("&7Naechster Chunk wieder frei in: &e" + TimeUtil.format(first - now) + + " &8(" + LandsChunkInfo.fmt(first) + ")")); + if (locked.size() > 1) { + StringBuilder sb = new StringBuilder("&7Danach: "); + locked.stream().skip(1).limit(4).forEach(t -> sb.append("&e") + .append(TimeUtil.format(t - now)).append("&7, ")); + sb.setLength(sb.length() - 2); + p.sendMessage(plugin.line(sb + (locked.size() > 5 ? " ..." : ""))); + } + if (plugin.getConfig().getBoolean("skip.enabled", true)) { + p.sendMessage(plugin.line("&7Sofort freischalten: &e/chunks skip &7(Preis: &e" + + price(first - now) + "&7)")); + } + } + } + + double upkeep = land.getUpkeepCosts(); + if (upkeep > 0) { + long next = plugin.nextUpkeep(); + double balance = land.getBalance(); + p.sendMessage(plugin.line("&7Upkeep: &e" + money(upkeep) + " &7pro Zyklus, naechster Einzug in &e" + + TimeUtil.format(next - now) + " &8(" + LandsChunkInfo.fmt(next) + ")")); + if (balance < upkeep) { + String risk = ""; + YamlConfiguration lc = plugin.landsConfig(); + if (lc != null && lc.getBoolean("upkeep.unclaim", false) && lc.getDouble("upkeep.per-chunk", 0) > 0) { + int lost = (int) Math.min(size, Math.ceil((upkeep - balance) / lc.getDouble("upkeep.per-chunk"))); + risk = " - " + lost + " Chunk(s) wuerden verloren gehen!"; + } + p.sendMessage(plugin.line("&cGuthaben (" + money(balance) + ") reicht nicht fuer den Upkeep." + risk)); + } + } + + Long inactive = plugin.inactivityRemaining(land); + if (inactive != null && inactive >= 0) { + boolean ownerOnline = land.getOwnerUID() != null && Bukkit.getPlayer(land.getOwnerUID()) != null; + p.sendMessage(plugin.line("&7Inaktivitaet des Besitzers: " + (ownerOnline + ? "&aBesitzer online" + : "&eLand gilt in &c" + TimeUtil.format(inactive) + " &eals inaktiv"))); + } + } + + private static String money(double v) { + return String.format(Locale.GERMANY, "%.2f", v); + } + + // ------------------------------------------------------------------- Top + + private void top(Player p) { + int n = plugin.getConfig().getInt("top.size", 10); + p.sendMessage(plugin.line("&8&m &r &aTop-Lands nach Chunks &8&m ")); + int i = 1; + for (Land l : plugin.top(n)) { + p.sendMessage(plugin.line("&e#" + i++ + " &7" + l.getName() + " &8- &a" + l.getChunksAmount() + " Chunks")); + } + } + + // ------------------------------------------------------------ Skip / Gift + + private String price(long remainingMs) { + return money(priceValue(remainingMs)); + } + + private double priceValue(long remainingMs) { + double perHour = plugin.getConfig().getDouble("skip.price-per-hour", 25.0); + double min = plugin.getConfig().getDouble("skip.min-price", 50.0); + return Math.max(min, remainingMs / 3_600_000.0 * perHour); + } + + /** /chunks skip [Land] [confirm] bzw. /chunks gift [confirm] */ + private void skip(Player p, String[] args, boolean gift) { + if (!allowed(p, gift ? "gift" : "skip")) { + return; + } + if (!plugin.getConfig().getBoolean("skip.enabled", true) || !plugin.cooldownActive()) { + plugin.send(p, "&cDiese Funktion ist deaktiviert."); + return; + } + boolean confirm = args.length > 1 && args[args.length - 1].equalsIgnoreCase("confirm"); + int end = confirm ? args.length - 1 : args.length; + String name = end > 1 ? String.join(" ", List.of(args).subList(1, end)) : null; + + Land land; + if (name != null) { + land = findLand(name); + } else if (gift) { + plugin.send(p, "&cNutzung: /chunks gift [confirm]"); + return; + } else { + land = plugin.landsOf(p.getUniqueId()).stream() + .filter(l -> !plugin.store.active(LandsChunkInfo.landId(l)).isEmpty()).findFirst().orElse(null); + if (land == null) { + plugin.send(p, "&aDu hast keine gesperrten Slots."); + return; + } + } + if (land == null || (!gift && !isMember(land, p.getUniqueId()))) { + plugin.send(p, plugin.cfgMsg("land-not-found")); + return; + } + List locked = plugin.store.active(LandsChunkInfo.landId(land)); + if (locked.isEmpty()) { + plugin.send(p, "&e" + land.getName() + " &ahat keine gesperrten Slots."); + return; + } + long remaining = locked.get(0) - System.currentTimeMillis(); + double price = priceValue(remaining); + boolean fromLand = !gift && "LAND".equalsIgnoreCase(plugin.getConfig().getString("skip.payment", "PLAYER")); + + if (fromLand && !p.getUniqueId().equals(land.getOwnerUID())) { + plugin.send(p, "&cNur der Besitzer darf aus der Landkasse zahlen."); + return; + } + if (!fromLand && plugin.vault == null) { + plugin.send(p, "&cDafuer wird Vault mit einem Economy-Plugin benoetigt."); + return; + } + if (!confirm) { + plugin.send(p, "&7Slot in &e" + land.getName() + " &7(noch &e" + TimeUtil.format(remaining) + + "&7) freischalten fuer &e" + money(price) + (fromLand ? " &7aus der Landkasse" : "") + + "&7. Bestaetigen: &e/chunks " + (gift ? "gift " : "skip ") + land.getName() + " confirm"); + return; + } + + if (fromLand) { + if (land.getBalance() < price) { + plugin.send(p, "&cDie Landkasse hat nicht genug Guthaben."); + return; + } + land.setBalance(land.getBalance() - price); + } else { + if (plugin.vault.balance(p) < price || !plugin.vault.withdraw(p, price)) { + plugin.send(p, "&cDu hast nicht genug Geld."); + return; + } + } + if (!plugin.store.removeEarliest(LandsChunkInfo.landId(land))) { + plugin.send(p, "&cDer Slot ist inzwischen von selbst frei geworden."); + return; + } + plugin.send(p, "&aSlot in &e" + land.getName() + " &afreigeschaltet (&e" + money(price) + " &abezahlt)."); + if (gift) { + for (Player m : plugin.onlineMembers(land)) { + plugin.send(m, "&a" + p.getName() + " hat einen Chunk-Slot fuer &e" + land.getName() + " &afreigeschaltet!"); + } + } + } + + // ----------------------------------------------------------------- Queue + + private void queue(Player p, String[] args) { + if (!allowed(p, "queue")) { + return; + } + String arg = args.length > 1 ? args[1].toLowerCase(Locale.ROOT) : ""; + if (arg.equals("list")) { + listEntries(p, Kind.QUEUE, "Warteschlange"); + return; + } + if (arg.equals("clear")) { + plugin.send(p, "&7" + plugin.store.removeAll(Kind.QUEUE, p.getUniqueId()) + " Eintraege entfernt."); + return; + } + Land land; + if (args.length > 1) { + land = findLand(String.join(" ", List.of(args).subList(1, args.length))); + } else { + land = plugin.primaryLand(p.getUniqueId()); + } + if (land == null || !isMember(land, p.getUniqueId())) { + plugin.send(p, plugin.cfgMsg("land-not-found")); + return; + } + World w = p.getWorld(); + int cx = p.getLocation().getBlockX() >> 4; + int cz = p.getLocation().getBlockZ() >> 4; + if (plugin.lands.getLandByUnloadedChunk(w, cx, cz) != null) { + plugin.send(p, "&cDieser Chunk ist schon geclaimt. Mit &e/chunks watch &ckannst du ihn beobachten."); + return; + } + List mine = plugin.store.entries(Kind.QUEUE).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); + if (mine.size() >= plugin.getConfig().getInt("queue.max", 3)) { + plugin.send(p, "&cDeine Warteschlange ist voll (&e/chunks queue clear&c)."); + return; + } + if (mine.stream().anyMatch(e -> e.at(w.getName(), cx, cz))) { + plugin.send(p, "&cDieser Chunk ist schon in deiner Warteschlange."); + return; + } + plugin.store.add(Kind.QUEUE, new Entry(p.getUniqueId(), LandsChunkInfo.landId(land), w.getName(), cx, cz, 0)); + int free = plugin.freeSlots(land); + plugin.send(p, "&aChunk &e" + cx + ", " + cz + " &avorgemerkt fuer &e" + land.getName() + "&a. " + + (free == 0 ? "Er wird geclaimt, sobald ein Slot frei wird (du musst dafuer online sein)." + : "Er wird in Kuerze geclaimt.")); + } + + // ----------------------------------------------------------------- Watch + + private void watch(Player p, String[] args) { + if (!allowed(p, "watch")) { + return; + } + String arg = args.length > 1 ? args[1].toLowerCase(Locale.ROOT) : ""; + if (arg.equals("list")) { + listEntries(p, Kind.WATCH, "Watchlist"); + return; + } + if (arg.equals("clear")) { + plugin.send(p, "&7" + plugin.store.removeAll(Kind.WATCH, p.getUniqueId()) + " Eintraege entfernt."); + return; + } + World w = p.getWorld(); + int cx = p.getLocation().getBlockX() >> 4; + int cz = p.getLocation().getBlockZ() >> 4; + Land holder = plugin.lands.getLandByUnloadedChunk(w, cx, cz); + if (holder == null) { + plugin.send(p, "&cDieser Chunk ist frei - du kannst ihn direkt claimen oder mit &e/chunks queue &avormerken."); + return; + } + List mine = plugin.store.entries(Kind.WATCH).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); + if (mine.size() >= plugin.getConfig().getInt("watch.max", 5)) { + plugin.send(p, "&cDeine Watchlist ist voll (&e/chunks watch clear&c)."); + return; + } + if (mine.stream().anyMatch(e -> e.at(w.getName(), cx, cz))) { + plugin.send(p, "&cDen beobachtest du schon."); + return; + } + plugin.store.add(Kind.WATCH, new Entry(p.getUniqueId(), LandsChunkInfo.landId(holder), w.getName(), cx, cz, 0)); + plugin.send(p, "&aDu wirst benachrichtigt, sobald Chunk &e" + cx + ", " + cz + " &a(Land &e" + holder.getName() + "&a) frei wird."); + } + + private void listEntries(Player p, Kind kind, String title) { + List mine = plugin.store.entries(kind).stream().filter(e -> e.player().equals(p.getUniqueId())).toList(); + p.sendMessage(plugin.line("&8&m &r &a" + title + " &8&m ")); + if (mine.isEmpty()) { + p.sendMessage(plugin.line("&7(leer)")); + } + for (Entry e : mine) { + Land land = plugin.landById(e.landId()); + p.sendMessage(plugin.line("&e" + e.world() + " " + e.x() + ", " + e.z() + + " &8- &7Land: &e" + (land == null ? "?" : land.getName()))); + } + } + + // ----------------------------------------------------------------- Tab + + @Override + public List onTabComplete(CommandSender s, Command c, String alias, String[] args) { + if (!(s instanceof Player p)) { + return List.of(); + } + String last = args[args.length - 1].toLowerCase(Locale.ROOT); + List out = new ArrayList<>(); + if (args.length == 1) { + out.addAll(SUBS); + plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); + } else { + switch (args[0].toLowerCase(Locale.ROOT)) { + case "queue", "watch" -> out.addAll(args.length == 2 ? List.of("list", "clear") : List.of()); + case "pvp" -> { + if (args.length == 2) { + out.addAll(List.of("pos1", "pos2", "create", "delete", "list")); + } else if (args[1].equalsIgnoreCase("delete")) { + out.addAll(plugin.pvp.names()); + } + } + case "skip", "gift" -> { + out.add("confirm"); + plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); + } + default -> { } + } + if (args[0].equalsIgnoreCase("queue")) { + plugin.landsOf(p.getUniqueId()).forEach(l -> out.add(l.getName())); + } + } + return out.stream().filter(o -> o.toLowerCase(Locale.ROOT).startsWith(last)).toList(); + } +} diff --git a/src/main/java/de/landschunkinfo/LandsChunkInfo.java b/src/main/java/de/landschunkinfo/LandsChunkInfo.java index 4d861ae..27aa83b 100644 --- a/src/main/java/de/landschunkinfo/LandsChunkInfo.java +++ b/src/main/java/de/landschunkinfo/LandsChunkInfo.java @@ -1,519 +1,513 @@ -package de.landschunkinfo; - -import de.landschunkinfo.LockStore.Entry; -import de.landschunkinfo.LockStore.Kind; -import me.angeschossen.lands.api.LandsIntegration; -import me.angeschossen.lands.api.applicationframework.util.ULID; -import me.angeschossen.lands.api.events.ChunkDeleteEvent; -import me.angeschossen.lands.api.events.ChunkPreClaimEvent; -import me.angeschossen.lands.api.events.land.DeleteReason; -import me.angeschossen.lands.api.events.memberholder.MemberHolderUpkeepEvent; -import me.angeschossen.lands.api.land.Land; -import me.angeschossen.lands.api.player.LandPlayer; -import net.kyori.adventure.text.Component; -import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; -import org.bukkit.Bukkit; -import org.bukkit.OfflinePlayer; -import org.bukkit.Statistic; -import org.bukkit.World; -import org.bukkit.configuration.file.YamlConfiguration; -import org.bukkit.entity.Player; -import org.bukkit.event.EventHandler; -import org.bukkit.event.EventPriority; -import org.bukkit.event.Listener; -import org.bukkit.event.player.PlayerJoinEvent; -import org.bukkit.plugin.Plugin; -import org.bukkit.plugin.java.JavaPlugin; - -import java.io.File; -import java.time.Instant; -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.time.LocalTime; -import java.time.ZoneId; -import java.time.format.DateTimeFormatter; -import java.util.ArrayList; -import java.util.Comparator; -import java.util.HashSet; -import java.util.List; -import java.util.Locale; -import java.util.Set; -import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; - -public final class LandsChunkInfo extends JavaPlugin implements Listener { - - private static final DateTimeFormatter DATE = DateTimeFormatter.ofPattern("dd.MM. HH:mm"); - private static final long TICK_SECONDS = 30; - - LandsIntegration lands; - LockStore store; - VaultHook vault; - PvpRegions pvp; - - private long cooldownMillis; - private long lastTick = System.currentTimeMillis(); - /** Unclaims, die vom Plugin selbst ausgeloest wurden (Temp-Claims) und keinen Slot sperren sollen. */ - private final Set silent = ConcurrentHashMap.newKeySet(); - - @Override - public void onEnable() { - saveDefaultConfig(); - lands = LandsIntegration.of(this); - store = new LockStore(getDataFolder(), getLogger()); - reload(); - - if (Bukkit.getPluginManager().getPlugin("Vault") != null) { - vault = VaultHook.create(); - } - if (vault == null) { - getLogger().info("Vault/Economy nicht gefunden: Bezahlung nur aus der Landkasse moeglich, /chunks gift ist deaktiviert."); - } - if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) { - new ChunkExpansion(this).register(); - } - - pvp = new PvpRegions(this, getDataFolder(), getLogger()); - Bukkit.getPluginManager().registerEvents(pvp, this); - Bukkit.getPluginManager().registerEvents(this, this); - InfoCommand command = new InfoCommand(this); - var cmd = getCommand("chunks"); - if (cmd != null) { - cmd.setExecutor(command); - cmd.setTabCompleter(command); - } - Bukkit.getScheduler().runTaskTimer(this, this::tick, 100L, TICK_SECONDS * 20L); - } - - @Override - public void onDisable() { - if (pvp != null) { - pvp.shutdown(); - } - if (store != null) { - store.save(); - } - } - - void reload() { - reloadConfig(); - cooldownMillis = TimeUtil.parse(getConfig().getString("unclaim-cooldown.duration", "24h")); - if (cooldownMillis < 0) { - getLogger().warning("unclaim-cooldown.duration ist ungueltig, Cooldown wird deaktiviert."); - } - } - - // --------------------------------------------------------------- Helfer - - boolean cooldownActive() { - return getConfig().getBoolean("unclaim-cooldown.enabled", true) && cooldownMillis > 0; - } - - long cooldownMillis() { - return cooldownMillis; - } - - Component line(String text) { - return LegacyComponentSerializer.legacyAmpersand().deserialize(text); - } - - void send(org.bukkit.command.CommandSender to, String text) { - to.sendMessage(line(getConfig().getString("messages.prefix", "") + text)); - } - - String cfgMsg(String key, String... repl) { - String text = getConfig().getString("messages." + key, key); - for (int i = 0; i + 1 < repl.length; i += 2) { - text = text.replace(repl[i], repl[i + 1]); - } - return text; - } - - static String landId(Land land) { - return land.getULID().toString(); - } - - Land landById(String id) { - try { - return lands.getLandByULID(ULID.fromString(id)); - } catch (RuntimeException e) { - return null; - } - } - - /** Lands, in denen die Person Besitzer oder vertraut ist. */ - List landsOf(UUID uuid) { - List out = new ArrayList<>(); - for (Object o : lands.getLands()) { - Land l = (Land) o; - if (uuid.equals(l.getOwnerUID()) || l.isTrusted(uuid)) { - out.add(l); - } - } - out.sort(Comparator.comparing((Land l) -> !uuid.equals(l.getOwnerUID())).thenComparing(Land::getName)); - return out; - } - - /** Hauptland: eigenes Land, sonst das erste Land, in dem man vertraut ist. */ - Land primaryLand(UUID uuid) { - List l = landsOf(uuid); - return l.isEmpty() ? null : l.get(0); - } - - /** Freie Slots; -1 = kein Limit. */ - int freeSlots(Land land) { - int max = land.getMaxChunks(); - if (max <= 0) { - return -1; - } - int locked = cooldownActive() ? store.active(landId(land)).size() : 0; - return Math.max(0, max - land.getChunksAmount() - locked); - } - - List onlineMembers(Land land) { - List out = new ArrayList<>(); - for (Object o : land.getOnlinePlayers()) { - if (o instanceof Player p) { - out.add(p); - } else if (o instanceof LandPlayer lp && lp.getPlayer() != null) { - out.add(lp.getPlayer()); - } - } - return out; - } - - /** Land-Rangliste nach Chunks, absteigend. */ - List top(int n) { - List all = new ArrayList<>(); - for (Object o : lands.getLands()) { - all.add((Land) o); - } - all.sort(Comparator.comparingInt(Land::getChunksAmount).reversed()); - return all.subList(0, Math.min(n, all.size())); - } - - static String fmt(long millis) { - return DATE.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault())); - } - - private static String chunkKey(String landId, String world, int x, int z) { - return landId + "|" + world + "|" + x + "|" + z; - } - - // --------------------------------------------------------------- Events - - /** Manuelles Unclaim sperrt den Slot fuer die konfigurierte Zeit. */ - @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) - public void onUnclaim(ChunkDeleteEvent e) { - String id = landId(e.getLand()); - if (silent.remove(chunkKey(id, e.getWorld().getName(), e.getX(), e.getZ()))) { - return; - } - if (!cooldownActive() || e.getReason() != DeleteReason.DEFAULT - || "LAND_DELETION".equals(String.valueOf(e.getUnclaimType()))) { - return; - } - LandPlayer lp = e.getLandPlayer(); - Player p = lp == null ? null : lp.getPlayer(); - if (p != null && p.hasPermission("landschunkinfo.bypass")) { - return; - } - store.add(id, System.currentTimeMillis() + cooldownMillis); - } - - @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) - public void onClaim(ChunkPreClaimEvent e) { - if (!cooldownActive() || !getConfig().getBoolean("unclaim-cooldown.enforce", true)) { - return; - } - LandPlayer lp = e.getLandPlayer(); - Player p = lp == null ? null : lp.getPlayer(); - if (p != null && p.hasPermission("landschunkinfo.bypass")) { - return; - } - Land land = e.getLand(); - int max = land.getMaxChunks(); - if (max <= 0) { - return; - } - int size = land.getChunksAmount(); - List locked = store.active(landId(land)); - // Nur eingreifen, wenn der Platz allein wegen der Sperren fehlt; sonst uebernimmt Lands. - if (size < max && size + locked.size() >= max) { - e.setCancelled(true); - if (p != null) { - long next = locked.get(Math.max(0, size + locked.size() - max)) - System.currentTimeMillis(); - send(p, cfgMsg("claim-blocked", "%time%", TimeUtil.format(next))); - } - } - } - - @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) - public void onUpkeep(MemberHolderUpkeepEvent e) { - long now = System.currentTimeMillis(); - if (now - store.lastUpkeep() > 600_000L) { - store.lastUpkeep(now); - } - } - - @EventHandler - public void onJoin(PlayerJoinEvent e) { - if (!getConfig().getBoolean("join-reminder.enabled", true)) { - return; - } - Player p = e.getPlayer(); - Bukkit.getScheduler().runTaskLater(this, () -> joinSummary(p), 60L); - } - - private void joinSummary(Player p) { - if (!p.isOnline() || !p.hasPermission("landschunkinfo.use")) { - return; - } - long now = System.currentTimeMillis(); - long warnMs = (long) (getConfig().getDouble("join-reminder.upkeep-warning-hours", 48) * 3_600_000L); - for (Land land : landsOf(p.getUniqueId())) { - int free = freeSlots(land); - if (free > 0 && land.getMaxChunks() > 0) { - send(p, "&aIn &e" + land.getName() + " &asind &e" + free + " &afreie Chunk-Slots verfuegbar."); - } - List locked = cooldownActive() ? store.active(landId(land)) : List.of(); - if (!locked.isEmpty()) { - send(p, "&7" + land.getName() + ": naechster Slot frei in &e" + TimeUtil.format(locked.get(0) - now)); - } - double upkeep = land.getUpkeepCosts(); - if (upkeep > 0 && land.getBalance() < upkeep && nextUpkeep() - now <= warnMs - && p.getUniqueId().equals(land.getOwnerUID())) { - send(p, "&cAchtung: &e" + land.getName() + " &chat zu wenig Guthaben fuer den Upkeep (Einzug in &e" - + TimeUtil.format(nextUpkeep() - now) + "&c)."); - } - } - } - - // --------------------------------------------------------------- Ticker - - private void tick() { - long now = System.currentTimeMillis(); - try { - notifyExpiredLocks(now); - processTemp(now); - processQueue(); - processWatch(); - } catch (RuntimeException ex) { - getLogger().warning("Fehler im Hintergrund-Task: " + ex); - } - lastTick = now; - } - - private void notifyExpiredLocks(long now) { - for (String id : store.lockedLands()) { - Land land = landById(id); - if (land == null) { - store.clearLocks(id); - continue; - } - long expired = store.all(id).stream().filter(t -> t > lastTick && t <= now).count(); - if (expired > 0) { - for (Player p : onlineMembers(land)) { - send(p, "&aIn &e" + land.getName() + " &aist wieder &e" + expired + " &aChunk-Slot frei!"); - } - } - } - } - - private void processQueue() { - Set usedThisTick = new HashSet<>(); - for (Entry e : store.entries(Kind.QUEUE)) { - Player p = Bukkit.getPlayer(e.player()); - Land land = landById(e.landId()); - World w = Bukkit.getWorld(e.world()); - if (land == null || w == null) { - store.remove(Kind.QUEUE, e); - continue; - } - if (p == null) { - continue; - } - Land holder = lands.getLandByUnloadedChunk(w, e.x(), e.z()); - if (holder != null) { - if (holder.equals(land)) { - store.remove(Kind.QUEUE, e); - } - continue; - } - if (freeSlots(land) == 0 || !usedThisTick.add(e.landId())) { - continue; - } - LandPlayer lp = lands.getLandPlayer(e.player()); - if (lp == null) { - continue; - } - store.remove(Kind.QUEUE, e); - java.util.concurrent.CompletableFuture f = land.claimChunk(lp, w, e.x(), e.z()); - f.whenComplete((r, ex) -> Bukkit.getScheduler().runTask(this, () -> { - if (!p.isOnline()) { - return; - } - String where = e.x() + ", " + e.z(); - if (ex == null && land.hasChunk(w, e.x(), e.z())) { - send(p, "&aWarteschlange: Chunk &e" + where + " &awurde fuer &e" + land.getName() + " &ageclaimt."); - } else { - send(p, "&cWarteschlange: Chunk &e" + where + " &ckonnte nicht geclaimt werden (Eintrag entfernt)."); - } - })); - } - } - - private void processWatch() { - for (Entry e : store.entries(Kind.WATCH)) { - World w = Bukkit.getWorld(e.world()); - if (w == null) { - store.remove(Kind.WATCH, e); - continue; - } - Player p = Bukkit.getPlayer(e.player()); - if (p == null) { - continue; - } - if (lands.getLandByUnloadedChunk(w, e.x(), e.z()) == null) { - store.remove(Kind.WATCH, e); - send(p, "&aDer beobachtete Chunk &e" + e.x() + ", " + e.z() + " &a(" + e.world() - + ") ist jetzt frei! Mit &e/chunks queue &akannst du ihn dir sichern."); - } - } - } - - private void processTemp(long now) { - for (Entry e : store.entries(Kind.TEMP)) { - if (e.until() > now) { - continue; - } - Land land = landById(e.landId()); - World w = Bukkit.getWorld(e.world()); - if (land == null || w == null || !land.hasChunk(w, e.x(), e.z())) { - store.remove(Kind.TEMP, e); - continue; - } - LandPlayer lp = lands.getLandPlayer(e.player()); - if (lp == null && land.getOwnerUID() != null) { - lp = lands.getLandPlayer(land.getOwnerUID()); - } - if (lp == null) { - continue; // wartet, bis ein Verantwortlicher online ist - } - store.remove(Kind.TEMP, e); - String key = chunkKey(e.landId(), e.world(), e.x(), e.z()); - silent.add(key); - Bukkit.getScheduler().runTaskLater(this, () -> silent.remove(key), 200L); - land.unclaimChunk(w, e.x(), e.z(), lp); - for (Player p : onlineMembers(land)) { - send(p, "&7Der zeitlich begrenzte Chunk &e" + e.x() + ", " + e.z() + " &7von &e" + land.getName() - + " &7ist abgelaufen und wurde freigegeben."); - } - } - } - - // --------------------------------------------------------------- Upkeep - - YamlConfiguration landsConfig() { - Plugin pl = Bukkit.getPluginManager().getPlugin("Lands"); - File f = pl == null ? null : new File(pl.getDataFolder(), "config.yml"); - return f != null && f.exists() ? YamlConfiguration.loadConfiguration(f) : null; - } - - /** Naechster Upkeep-Einzug in epoch-millis, abgeleitet aus Lands economic.interval. */ - long nextUpkeep() { - ZoneId zone = ZoneId.systemDefault(); - int days = 1; - LocalTime time = LocalTime.MIDNIGHT; - YamlConfiguration lc = landsConfig(); - if (lc != null) { - days = Math.max(1, lc.getInt("economic.interval.days_2", lc.getInt("economic.interval.days", 1))); - try { - time = LocalTime.parse(lc.getString("economic.interval.time", "00:00:00")); - } catch (Exception ignored) { - // Standardwert behalten - } - } - LocalDate anchor = null; - if (store.lastUpkeep() > 0) { - anchor = Instant.ofEpochMilli(store.lastUpkeep()).atZone(zone).toLocalDate(); - } else { - try { - String cfg = getConfig().getString("upkeep.anchor-date", ""); - if (!cfg.isBlank()) { - anchor = LocalDate.parse(cfg); - } - } catch (Exception ignored) { - // ungueltiges Datum -> Schaetzung - } - } - LocalDateTime now = LocalDateTime.now(zone); - if (anchor == null) { - LocalDateTime next = now.toLocalDate().atTime(time); - return (next.isAfter(now) ? next : next.plusDays(1)).atZone(zone).toInstant().toEpochMilli(); - } - LocalDateTime next = anchor.atTime(time); - while (!next.isAfter(now)) { - next = next.plusDays(days); - } - return next.atZone(zone).toInstant().toEpochMilli(); - } - - // --------------------------------------------------------- Inaktivitaet - - /** - * Restzeit bis der Besitzer laut Lands-Einstellung (expiration.owner_list) als inaktiv gilt. - * Gibt null zurueck, wenn die Funktion in Lands nicht aktiv ist, -1 bei "never". - */ - Long inactivityRemaining(Land land) { - YamlConfiguration lc = landsConfig(); - UUID owner = land.getOwnerUID(); - if (lc == null || owner == null) { - return null; - } - List list = null; - for (String key : lc.getKeys(true)) { - if (key.endsWith("expiration.owner_list")) { - list = lc.getStringList(key); - break; - } - } - if (list == null || list.isEmpty()) { - return null; - } - OfflinePlayer op = Bukkit.getOfflinePlayer(owner); - long playMs = op.getStatistic(Statistic.PLAY_ONE_MINUTE) * 50L; - String chosen = null; - long chosenPlay = Long.MAX_VALUE; - String highest = null; - long highestPlay = -1; - for (String entry : list) { - String[] parts = entry.split(":"); - long pt = parts.length == 2 ? TimeUtil.parse(parts[0].trim()) : -1; - if (pt < 0) { - continue; - } - if (pt >= playMs && pt < chosenPlay) { - chosen = parts[1].trim(); - chosenPlay = pt; - } - if (pt > highestPlay) { - highest = parts[1].trim(); - highestPlay = pt; - } - } - String offline = chosen != null ? chosen : highest; - if (offline == null) { - return null; - } - if (offline.equalsIgnoreCase("never")) { - return -1L; - } - long threshold = TimeUtil.parse(offline); - if (threshold < 0) { - return null; - } - long lastSeen = op.isOnline() ? System.currentTimeMillis() : op.getLastSeen(); - return Math.max(0, threshold - (System.currentTimeMillis() - lastSeen)); - } -} +package de.landschunkinfo; + +import de.landschunkinfo.LockStore.Entry; +import de.landschunkinfo.LockStore.Kind; +import me.angeschossen.lands.api.LandsIntegration; +import me.angeschossen.lands.api.applicationframework.util.ULID; +import me.angeschossen.lands.api.events.ChunkDeleteEvent; +import me.angeschossen.lands.api.events.ChunkPreClaimEvent; +import me.angeschossen.lands.api.events.land.DeleteReason; +import me.angeschossen.lands.api.events.memberholder.MemberHolderUpkeepEvent; +import me.angeschossen.lands.api.land.Land; +import me.angeschossen.lands.api.player.LandPlayer; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import org.bukkit.Bukkit; +import org.bukkit.OfflinePlayer; +import org.bukkit.Statistic; +import org.bukkit.World; +import org.bukkit.configuration.file.YamlConfiguration; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.java.JavaPlugin; + +import java.io.File; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +public final class LandsChunkInfo extends JavaPlugin implements Listener { + + private static final DateTimeFormatter DATE = DateTimeFormatter.ofPattern("dd.MM. HH:mm"); + private static final long TICK_SECONDS = 30; + + LandsIntegration lands; + LockStore store; + VaultHook vault; + PvpRegions pvp; + + private long cooldownMillis; + private long lastTick = System.currentTimeMillis(); + + @Override + public void onEnable() { + saveDefaultConfig(); + lands = LandsIntegration.of(this); + store = new LockStore(getDataFolder(), getLogger()); + reload(); + + if (Bukkit.getPluginManager().getPlugin("Vault") != null) { + vault = VaultHook.create(); + } + if (vault == null) { + getLogger().info("Vault/Economy nicht gefunden: Bezahlung nur aus der Landkasse moeglich, /chunks gift ist deaktiviert."); + } + if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) { + new ChunkExpansion(this).register(); + } + + pvp = new PvpRegions(this, getDataFolder(), getLogger()); + // Spaet registrieren, damit die PvP-Freigabe nach den Listenern von Lands laeuft. + Bukkit.getScheduler().runTaskLater(this, () -> { + Bukkit.getPluginManager().registerEvents(pvp, this); + pvp.refreshAll(); + }, 100L); + Bukkit.getPluginManager().registerEvents(this, this); + InfoCommand command = new InfoCommand(this); + var cmd = getCommand("chunks"); + if (cmd != null) { + cmd.setExecutor(command); + cmd.setTabCompleter(command); + } + Bukkit.getScheduler().runTaskTimer(this, this::tick, 100L, TICK_SECONDS * 20L); + } + + @Override + public void onDisable() { + if (pvp != null) { + pvp.shutdown(); + } + if (store != null) { + store.save(); + } + } + + void reload() { + reloadConfig(); + cooldownMillis = TimeUtil.parse(getConfig().getString("unclaim-cooldown.duration", "24h")); + if (cooldownMillis < 0) { + getLogger().warning("unclaim-cooldown.duration ist ungueltig, Cooldown wird deaktiviert."); + } + } + + // --------------------------------------------------------------- Helfer + + boolean cooldownActive() { + return getConfig().getBoolean("unclaim-cooldown.enabled", true) && cooldownMillis > 0; + } + + long cooldownMillis() { + return cooldownMillis; + } + + Component line(String text) { + return LegacyComponentSerializer.legacyAmpersand().deserialize(text); + } + + void send(org.bukkit.command.CommandSender to, String text) { + to.sendMessage(line(getConfig().getString("messages.prefix", "") + text)); + } + + String cfgMsg(String key, String... repl) { + String text = getConfig().getString("messages." + key, key); + for (int i = 0; i + 1 < repl.length; i += 2) { + text = text.replace(repl[i], repl[i + 1]); + } + return text; + } + + static String landId(Land land) { + return land.getULID().toString(); + } + + Land landById(String id) { + try { + return lands.getLandByULID(ULID.fromString(id)); + } catch (RuntimeException e) { + return null; + } + } + + /** Lands, in denen die Person Besitzer oder vertraut ist. */ + List landsOf(UUID uuid) { + List out = new ArrayList<>(); + for (Object o : lands.getLands()) { + Land l = (Land) o; + if (uuid.equals(l.getOwnerUID()) || l.isTrusted(uuid)) { + out.add(l); + } + } + out.sort(Comparator.comparing((Land l) -> !uuid.equals(l.getOwnerUID())).thenComparing(Land::getName)); + return out; + } + + /** Hauptland: eigenes Land, sonst das erste Land, in dem man vertraut ist. */ + Land primaryLand(UUID uuid) { + List l = landsOf(uuid); + return l.isEmpty() ? null : l.get(0); + } + + /** Freie Slots; -1 = kein Limit. */ + int freeSlots(Land land) { + int max = land.getMaxChunks(); + if (max <= 0) { + return -1; + } + int locked = cooldownActive() ? store.active(landId(land)).size() : 0; + return Math.max(0, max - land.getChunksAmount() - locked); + } + + List onlineMembers(Land land) { + List out = new ArrayList<>(); + for (Object o : land.getOnlinePlayers()) { + if (o instanceof Player p) { + out.add(p); + } else if (o instanceof LandPlayer lp && lp.getPlayer() != null) { + out.add(lp.getPlayer()); + } + } + return out; + } + + /** Land-Rangliste nach Chunks, absteigend. */ + List top(int n) { + List all = new ArrayList<>(); + for (Object o : lands.getLands()) { + all.add((Land) o); + } + all.sort(Comparator.comparingInt(Land::getChunksAmount).reversed()); + return all.subList(0, Math.min(n, all.size())); + } + + static String fmt(long millis) { + return DATE.format(LocalDateTime.ofInstant(Instant.ofEpochMilli(millis), ZoneId.systemDefault())); + } + + // --------------------------------------------------------------- Events + + /** Manuelles Unclaim sperrt den Slot fuer die konfigurierte Zeit. */ + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onUnclaim(ChunkDeleteEvent e) { + String id = landId(e.getLand()); + if (!cooldownActive() || e.getReason() != DeleteReason.DEFAULT + || "LAND_DELETION".equals(String.valueOf(e.getUnclaimType()))) { + return; + } + LandPlayer lp = e.getLandPlayer(); + Player p = lp == null ? null : lp.getPlayer(); + if (p != null && p.hasPermission("landschunkinfo.bypass")) { + return; + } + store.add(id, System.currentTimeMillis() + cooldownMillis); + } + + @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true) + public void onClaim(ChunkPreClaimEvent e) { + if (!cooldownActive() || !getConfig().getBoolean("unclaim-cooldown.enforce", true)) { + return; + } + LandPlayer lp = e.getLandPlayer(); + Player p = lp == null ? null : lp.getPlayer(); + if (p != null && p.hasPermission("landschunkinfo.bypass")) { + return; + } + Land land = e.getLand(); + int max = land.getMaxChunks(); + if (max <= 0) { + return; + } + int size = land.getChunksAmount(); + List locked = store.active(landId(land)); + // Nur eingreifen, wenn der Platz allein wegen der Sperren fehlt; sonst uebernimmt Lands. + if (size < max && size + locked.size() >= max) { + e.setCancelled(true); + if (p != null) { + long next = locked.get(Math.max(0, size + locked.size() - max)) - System.currentTimeMillis(); + send(p, cfgMsg("claim-blocked", "%time%", TimeUtil.format(next))); + } + } + } + + @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true) + public void onUpkeep(MemberHolderUpkeepEvent e) { + long now = System.currentTimeMillis(); + if (now - store.lastUpkeep() > 600_000L) { + store.lastUpkeep(now); + } + } + + @EventHandler + public void onJoin(PlayerJoinEvent e) { + if (!getConfig().getBoolean("join-reminder.enabled", true)) { + return; + } + Player p = e.getPlayer(); + Bukkit.getScheduler().runTaskLater(this, () -> joinSummary(p), 60L); + } + + private void joinSummary(Player p) { + if (!p.isOnline() || !p.hasPermission("landschunkinfo.use")) { + return; + } + long now = System.currentTimeMillis(); + long warnMs = (long) (getConfig().getDouble("join-reminder.upkeep-warning-hours", 48) * 3_600_000L); + for (Land land : landsOf(p.getUniqueId())) { + int free = freeSlots(land); + if (free > 0 && land.getMaxChunks() > 0) { + send(p, "&aIn &e" + land.getName() + " &asind &e" + free + " &afreie Chunk-Slots verfuegbar."); + } + List locked = cooldownActive() ? store.active(landId(land)) : List.of(); + if (!locked.isEmpty()) { + send(p, "&7" + land.getName() + ": naechster Slot frei in &e" + TimeUtil.format(locked.get(0) - now)); + } + double upkeep = land.getUpkeepCosts(); + if (upkeep > 0 && land.getBalance() < upkeep && nextUpkeep() - now <= warnMs + && p.getUniqueId().equals(land.getOwnerUID())) { + send(p, "&cAchtung: &e" + land.getName() + " &chat zu wenig Guthaben fuer den Upkeep (Einzug in &e" + + TimeUtil.format(nextUpkeep() - now) + "&c)."); + } + } + } + + // --------------------------------------------------------------- Ticker + + private void tick() { + long now = System.currentTimeMillis(); + try { + notifyExpiredLocks(now); + processQueue(); + processWatch(); + } catch (RuntimeException ex) { + getLogger().warning("Fehler im Hintergrund-Task: " + ex); + } + lastTick = now; + } + + private void notifyExpiredLocks(long now) { + for (String id : store.lockedLands()) { + Land land = landById(id); + if (land == null) { + store.clearLocks(id); + continue; + } + long expired = store.all(id).stream().filter(t -> t > lastTick && t <= now).count(); + if (expired > 0) { + for (Player p : onlineMembers(land)) { + send(p, "&aIn &e" + land.getName() + " &aist wieder &e" + expired + " &aChunk-Slot frei!"); + } + } + } + } + + private void processQueue() { + Set usedThisTick = new HashSet<>(); + for (Entry e : store.entries(Kind.QUEUE)) { + Player p = Bukkit.getPlayer(e.player()); + Land land = landById(e.landId()); + World w = Bukkit.getWorld(e.world()); + if (land == null || w == null) { + store.remove(Kind.QUEUE, e); + continue; + } + if (p == null) { + continue; + } + Land holder = lands.getLandByUnloadedChunk(w, e.x(), e.z()); + if (holder != null) { + if (holder.equals(land)) { + store.remove(Kind.QUEUE, e); + } + continue; + } + if (freeSlots(land) == 0 || !usedThisTick.add(e.landId())) { + continue; + } + LandPlayer lp = lands.getLandPlayer(e.player()); + if (lp == null) { + continue; + } + store.remove(Kind.QUEUE, e); + java.util.concurrent.CompletableFuture f = land.claimChunk(lp, w, e.x(), e.z()); + f.whenComplete((r, ex) -> Bukkit.getScheduler().runTask(this, () -> { + if (!p.isOnline()) { + return; + } + String where = e.x() + ", " + e.z(); + if (ex == null && land.hasChunk(w, e.x(), e.z())) { + send(p, "&aWarteschlange: Chunk &e" + where + " &awurde fuer &e" + land.getName() + " &ageclaimt."); + } else { + send(p, "&cWarteschlange: Chunk &e" + where + " &ckonnte nicht geclaimt werden (Eintrag entfernt)."); + } + })); + } + } + + private void processWatch() { + for (Entry e : store.entries(Kind.WATCH)) { + World w = Bukkit.getWorld(e.world()); + if (w == null) { + store.remove(Kind.WATCH, e); + continue; + } + Player p = Bukkit.getPlayer(e.player()); + if (p == null) { + continue; + } + if (lands.getLandByUnloadedChunk(w, e.x(), e.z()) == null) { + store.remove(Kind.WATCH, e); + send(p, "&aDer beobachtete Chunk &e" + e.x() + ", " + e.z() + " &a(" + e.world() + + ") ist jetzt frei! Mit &e/chunks queue &akannst du ihn dir sichern."); + } + } + } + + // --------------------------------------------------------------- Upkeep + + YamlConfiguration landsConfig() { + Plugin pl = Bukkit.getPluginManager().getPlugin("Lands"); + File f = pl == null ? null : new File(pl.getDataFolder(), "config.yml"); + return f != null && f.exists() ? YamlConfiguration.loadConfiguration(f) : null; + } + + /** Naechster Upkeep-Einzug in epoch-millis, abgeleitet aus Lands economic.interval. */ + long nextUpkeep() { + ZoneId zone = ZoneId.systemDefault(); + int days = 1; + LocalTime time = LocalTime.MIDNIGHT; + YamlConfiguration lc = landsConfig(); + if (lc != null) { + days = Math.max(1, lc.getInt("economic.interval.days_2", lc.getInt("economic.interval.days", 1))); + try { + time = LocalTime.parse(lc.getString("economic.interval.time", "00:00:00")); + } catch (Exception ignored) { + // Standardwert behalten + } + } + LocalDate anchor = null; + if (store.lastUpkeep() > 0) { + anchor = Instant.ofEpochMilli(store.lastUpkeep()).atZone(zone).toLocalDate(); + } else { + try { + String cfg = getConfig().getString("upkeep.anchor-date", ""); + if (!cfg.isBlank()) { + anchor = LocalDate.parse(cfg); + } + } catch (Exception ignored) { + // ungueltiges Datum -> Schaetzung + } + } + LocalDateTime now = LocalDateTime.now(zone); + if (anchor == null) { + LocalDateTime next = now.toLocalDate().atTime(time); + return (next.isAfter(now) ? next : next.plusDays(1)).atZone(zone).toInstant().toEpochMilli(); + } + LocalDateTime next = anchor.atTime(time); + while (!next.isAfter(now)) { + next = next.plusDays(days); + } + return next.atZone(zone).toInstant().toEpochMilli(); + } + + // ------------------------------------------------------- Spielzeit-Belohnung + + /** Ergebnis der Spielzeit-Belohnung: Restzeit bis zum naechsten Bonus, bisher erhaltene Boni, Maximum (-1 = unbegrenzt). */ + record Reward(long remainingMs, long earned, int max) { + } + + /** + * Liest time-rewards.<limit> aus der player-limits.yml von Lands und berechnet, wie viel Online-Zeit + * dem Spieler noch bis zum naechsten Bonus fehlt. null = nicht eingerichtet oder Maximum erreicht. + */ + Reward playtimeReward(UUID uuid, String limit) { + Plugin pl = Bukkit.getPluginManager().getPlugin("Lands"); + File f = pl == null ? null : new File(pl.getDataFolder(), "player-limits.yml"); + if (f == null || !f.exists()) { + return null; + } + YamlConfiguration y = YamlConfiguration.loadConfiguration(f); + long period = TimeUtil.parse(y.getString("time-rewards." + limit + ".time", "0s")); + int max = y.getInt("time-rewards." + limit + ".max", -1); + if (period <= 0) { + return null; + } + long playMs = Bukkit.getOfflinePlayer(uuid).getStatistic(Statistic.PLAY_ONE_MINUTE) * 50L; + long earned = playMs / period; + if (max >= 0 && earned >= max) { + return null; + } + return new Reward(period - playMs % period, earned, max); + } + + // --------------------------------------------------------- Inaktivitaet + + /** + * Restzeit bis der Besitzer laut Lands-Einstellung (expiration.owner_list) als inaktiv gilt. + * Gibt null zurueck, wenn die Funktion in Lands nicht aktiv ist, -1 bei "never". + */ + Long inactivityRemaining(Land land) { + YamlConfiguration lc = landsConfig(); + UUID owner = land.getOwnerUID(); + if (lc == null || owner == null) { + return null; + } + List list = null; + for (String key : lc.getKeys(true)) { + if (key.endsWith("expiration.owner_list")) { + list = lc.getStringList(key); + break; + } + } + if (list == null || list.isEmpty()) { + return null; + } + OfflinePlayer op = Bukkit.getOfflinePlayer(owner); + long playMs = op.getStatistic(Statistic.PLAY_ONE_MINUTE) * 50L; + String chosen = null; + long chosenPlay = Long.MAX_VALUE; + String highest = null; + long highestPlay = -1; + for (String entry : list) { + String[] parts = entry.split(":"); + long pt = parts.length == 2 ? TimeUtil.parse(parts[0].trim()) : -1; + if (pt < 0) { + continue; + } + if (pt >= playMs && pt < chosenPlay) { + chosen = parts[1].trim(); + chosenPlay = pt; + } + if (pt > highestPlay) { + highest = parts[1].trim(); + highestPlay = pt; + } + } + String offline = chosen != null ? chosen : highest; + if (offline == null) { + return null; + } + if (offline.equalsIgnoreCase("never")) { + return -1L; + } + long threshold = TimeUtil.parse(offline); + if (threshold < 0) { + return null; + } + long lastSeen = op.isOnline() ? System.currentTimeMillis() : op.getLastSeen(); + return Math.max(0, threshold - (System.currentTimeMillis() - lastSeen)); + } +} diff --git a/src/main/java/de/landschunkinfo/LockStore.java b/src/main/java/de/landschunkinfo/LockStore.java index 419f95a..b11989d 100644 --- a/src/main/java/de/landschunkinfo/LockStore.java +++ b/src/main/java/de/landschunkinfo/LockStore.java @@ -1,185 +1,185 @@ -package de.landschunkinfo; - -import org.bukkit.configuration.file.YamlConfiguration; - -import java.io.File; -import java.io.IOException; -import java.util.ArrayList; -import java.util.EnumMap; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.UUID; -import java.util.logging.Logger; - -/** Persistiert Slot-Sperren, Queue, Watchlist, Temp-Claims und den letzten Upkeep-Einzug. */ -final class LockStore { - - enum Kind { QUEUE, WATCH, TEMP } - - /** Eintrag fuer Queue/Watch/Temp. {@code until} wird nur bei TEMP genutzt. */ - record Entry(UUID player, String landId, String world, int x, int z, long until) { - - String serialize() { - return player + ";" + landId + ";" + world + ";" + x + ";" + z + ";" + until; - } - - static Entry parse(String s) { - String[] p = s.split(";"); - return new Entry(UUID.fromString(p[0]), p[1], p[2], Integer.parseInt(p[3]), Integer.parseInt(p[4]), - Long.parseLong(p[5])); - } - - boolean at(String world, int x, int z) { - return this.world.equals(world) && this.x == x && this.z == z; - } - } - - private final File file; - private final Logger log; - private final Map> locks = new HashMap<>(); - private final Map> entries = new EnumMap<>(Kind.class); - private long lastUpkeep; - - LockStore(File dataFolder, Logger log) { - this.file = new File(dataFolder, "data.yml"); - this.log = log; - for (Kind k : Kind.values()) { - entries.put(k, new ArrayList<>()); - } - load(); - } - - private void load() { - if (!file.exists()) { - return; - } - YamlConfiguration yml = YamlConfiguration.loadConfiguration(file); - lastUpkeep = yml.getLong("last-upkeep", 0); - var section = yml.getConfigurationSection("locks"); - if (section != null) { - for (String land : section.getKeys(false)) { - locks.put(land, new ArrayList<>(section.getLongList(land))); - } - } - for (Kind k : Kind.values()) { - for (String s : yml.getStringList(k.name().toLowerCase())) { - try { - entries.get(k).add(Entry.parse(s)); - } catch (RuntimeException e) { - log.warning("Ungueltiger Eintrag in data.yml uebersprungen: " + s); - } - } - } - } - - synchronized void save() { - YamlConfiguration yml = new YamlConfiguration(); - yml.set("last-upkeep", lastUpkeep); - purge(); - locks.forEach((land, list) -> yml.set("locks." + land, list)); - for (Kind k : Kind.values()) { - yml.set(k.name().toLowerCase(), entries.get(k).stream().map(Entry::serialize).toList()); - } - try { - yml.save(file); - } catch (IOException e) { - log.warning("data.yml konnte nicht gespeichert werden: " + e.getMessage()); - } - } - - private void purge() { - long now = System.currentTimeMillis(); - locks.values().forEach(l -> l.removeIf(t -> t <= now)); - locks.values().removeIf(List::isEmpty); - } - - // ------------------------------------------------------------------ Sperren - - synchronized void add(String landId, long until) { - locks.computeIfAbsent(landId, k -> new ArrayList<>()).add(until); - save(); - } - - /** Aktive Sperren eines Lands, aufsteigend nach Ablaufzeit. */ - synchronized List active(String landId) { - long now = System.currentTimeMillis(); - List list = locks.get(landId); - if (list == null) { - return List.of(); - } - return list.stream().filter(t -> t > now).sorted().toList(); - } - - /** Alle Land-IDs, die (evtl. abgelaufene) Sperren halten. */ - synchronized List lockedLands() { - return new ArrayList<>(locks.keySet()); - } - - /** Alle Sperren eines Lands inkl. abgelaufener, fuer Ablauf-Benachrichtigungen. */ - synchronized List all(String landId) { - return new ArrayList<>(locks.getOrDefault(landId, List.of())); - } - - /** Entfernt die fruehste aktive Sperre. */ - synchronized boolean removeEarliest(String landId) { - List list = locks.get(landId); - if (list == null) { - return false; - } - long now = System.currentTimeMillis(); - Long min = list.stream().filter(t -> t > now).min(Long::compare).orElse(null); - if (min == null) { - return false; - } - list.remove(min); - save(); - return true; - } - - synchronized void clearLocks(String landId) { - if (locks.remove(landId) != null) { - save(); - } - } - - // ------------------------------------------------------------------ Eintraege - - synchronized List entries(Kind kind) { - return new ArrayList<>(entries.get(kind)); - } - - synchronized void add(Kind kind, Entry entry) { - entries.get(kind).add(entry); - save(); - } - - synchronized boolean remove(Kind kind, Entry entry) { - boolean removed = entries.get(kind).remove(entry); - if (removed) { - save(); - } - return removed; - } - - synchronized int removeAll(Kind kind, UUID player) { - int before = entries.get(kind).size(); - entries.get(kind).removeIf(e -> e.player().equals(player)); - int removed = before - entries.get(kind).size(); - if (removed > 0) { - save(); - } - return removed; - } - - // ------------------------------------------------------------------ Upkeep - - synchronized long lastUpkeep() { - return lastUpkeep; - } - - synchronized void lastUpkeep(long time) { - this.lastUpkeep = time; - save(); - } -} +package de.landschunkinfo; + +import org.bukkit.configuration.file.YamlConfiguration; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.logging.Logger; + +/** Persistiert Slot-Sperren, Queue, Watchlist und den letzten Upkeep-Einzug. */ +final class LockStore { + + enum Kind { QUEUE, WATCH } + + /** Eintrag fuer Queue/Watch. {@code until} ist ungenutzt (0). */ + record Entry(UUID player, String landId, String world, int x, int z, long until) { + + String serialize() { + return player + ";" + landId + ";" + world + ";" + x + ";" + z + ";" + until; + } + + static Entry parse(String s) { + String[] p = s.split(";"); + return new Entry(UUID.fromString(p[0]), p[1], p[2], Integer.parseInt(p[3]), Integer.parseInt(p[4]), + Long.parseLong(p[5])); + } + + boolean at(String world, int x, int z) { + return this.world.equals(world) && this.x == x && this.z == z; + } + } + + private final File file; + private final Logger log; + private final Map> locks = new HashMap<>(); + private final Map> entries = new EnumMap<>(Kind.class); + private long lastUpkeep; + + LockStore(File dataFolder, Logger log) { + this.file = new File(dataFolder, "data.yml"); + this.log = log; + for (Kind k : Kind.values()) { + entries.put(k, new ArrayList<>()); + } + load(); + } + + private void load() { + if (!file.exists()) { + return; + } + YamlConfiguration yml = YamlConfiguration.loadConfiguration(file); + lastUpkeep = yml.getLong("last-upkeep", 0); + var section = yml.getConfigurationSection("locks"); + if (section != null) { + for (String land : section.getKeys(false)) { + locks.put(land, new ArrayList<>(section.getLongList(land))); + } + } + for (Kind k : Kind.values()) { + for (String s : yml.getStringList(k.name().toLowerCase())) { + try { + entries.get(k).add(Entry.parse(s)); + } catch (RuntimeException e) { + log.warning("Ungueltiger Eintrag in data.yml uebersprungen: " + s); + } + } + } + } + + synchronized void save() { + YamlConfiguration yml = new YamlConfiguration(); + yml.set("last-upkeep", lastUpkeep); + purge(); + locks.forEach((land, list) -> yml.set("locks." + land, list)); + for (Kind k : Kind.values()) { + yml.set(k.name().toLowerCase(), entries.get(k).stream().map(Entry::serialize).toList()); + } + try { + yml.save(file); + } catch (IOException e) { + log.warning("data.yml konnte nicht gespeichert werden: " + e.getMessage()); + } + } + + private void purge() { + long now = System.currentTimeMillis(); + locks.values().forEach(l -> l.removeIf(t -> t <= now)); + locks.values().removeIf(List::isEmpty); + } + + // ------------------------------------------------------------------ Sperren + + synchronized void add(String landId, long until) { + locks.computeIfAbsent(landId, k -> new ArrayList<>()).add(until); + save(); + } + + /** Aktive Sperren eines Lands, aufsteigend nach Ablaufzeit. */ + synchronized List active(String landId) { + long now = System.currentTimeMillis(); + List list = locks.get(landId); + if (list == null) { + return List.of(); + } + return list.stream().filter(t -> t > now).sorted().toList(); + } + + /** Alle Land-IDs, die (evtl. abgelaufene) Sperren halten. */ + synchronized List lockedLands() { + return new ArrayList<>(locks.keySet()); + } + + /** Alle Sperren eines Lands inkl. abgelaufener, fuer Ablauf-Benachrichtigungen. */ + synchronized List all(String landId) { + return new ArrayList<>(locks.getOrDefault(landId, List.of())); + } + + /** Entfernt die fruehste aktive Sperre. */ + synchronized boolean removeEarliest(String landId) { + List list = locks.get(landId); + if (list == null) { + return false; + } + long now = System.currentTimeMillis(); + Long min = list.stream().filter(t -> t > now).min(Long::compare).orElse(null); + if (min == null) { + return false; + } + list.remove(min); + save(); + return true; + } + + synchronized void clearLocks(String landId) { + if (locks.remove(landId) != null) { + save(); + } + } + + // ------------------------------------------------------------------ Eintraege + + synchronized List entries(Kind kind) { + return new ArrayList<>(entries.get(kind)); + } + + synchronized void add(Kind kind, Entry entry) { + entries.get(kind).add(entry); + save(); + } + + synchronized boolean remove(Kind kind, Entry entry) { + boolean removed = entries.get(kind).remove(entry); + if (removed) { + save(); + } + return removed; + } + + synchronized int removeAll(Kind kind, UUID player) { + int before = entries.get(kind).size(); + entries.get(kind).removeIf(e -> e.player().equals(player)); + int removed = before - entries.get(kind).size(); + if (removed > 0) { + save(); + } + return removed; + } + + // ------------------------------------------------------------------ Upkeep + + synchronized long lastUpkeep() { + return lastUpkeep; + } + + synchronized void lastUpkeep(long time) { + this.lastUpkeep = time; + save(); + } +} diff --git a/src/main/java/de/landschunkinfo/PvpRegions.java b/src/main/java/de/landschunkinfo/PvpRegions.java index b60be31..8a922dc 100644 --- a/src/main/java/de/landschunkinfo/PvpRegions.java +++ b/src/main/java/de/landschunkinfo/PvpRegions.java @@ -232,7 +232,7 @@ final class PvpRegions implements Listener { * Laeuft nach Lands (HIGHEST): Wenn Angreifer und Opfer beide in einer PvP-Region stehen, * wird ein von Lands abgebrochener Schaden wieder freigegeben. */ - @EventHandler(priority = EventPriority.HIGHEST) + @EventHandler(priority = EventPriority.MONITOR) public void onDamage(EntityDamageByEntityEvent e) { if (regions.isEmpty() || !(e.getEntity() instanceof Player victim)) { return; @@ -253,14 +253,14 @@ final class PvpRegions implements Listener { } /** Rueckstoss in der PvP-Region freigeben, falls Lands ihn fuer Land-Mitglieder unterdrueckt. */ - @EventHandler(priority = EventPriority.HIGHEST) + @EventHandler(priority = EventPriority.MONITOR) public void onKnockback(EntityKnockbackByEntityEvent e) { if (e.isCancelled() && e.getEntity() instanceof Player victim && isRecent(victim)) { e.setCancelled(false); } } - @EventHandler(priority = EventPriority.HIGHEST) + @EventHandler(priority = EventPriority.MONITOR) public void onVelocity(PlayerVelocityEvent e) { if (e.isCancelled() && isRecent(e.getPlayer())) { e.setCancelled(false); diff --git a/src/main/resources/config.yml b/src/main/resources/config.yml index 9b70809..6b5f721 100644 --- a/src/main/resources/config.yml +++ b/src/main/resources/config.yml @@ -1,56 +1,49 @@ -# Unclaim-Cooldown: Nach einem manuellen /unclaim bleibt der Chunk-Slot des Lands -# für diese Zeit gesperrt. Format: 30s, 15m, 12h, 2d oder kombiniert (1d12h). -unclaim-cooldown: - enabled: true - duration: 24h - # true = Claimen wird blockiert, solange alle Slots belegt oder gesperrt sind. - # false = nur Anzeige, kein Eingriff ins Claimen. - enforce: true - -# Upkeep-Anzeige. Zeitpunkt wird aus der Lands-config.yml (economic.interval) gelesen. -# Der letzte echte Einzug wird automatisch gespeichert. Bis dahin kann ein Startdatum -# (Tag eines bekannten Einzugs, yyyy-MM-dd) angegeben werden, sonst wird geschätzt. -upkeep: - anchor-date: "" - -messages: - prefix: "&8[&aChunks&8] &7" - no-permission: "&cDazu hast du keine Berechtigung." - players-only: "&cNur Spieler können diesen Befehl nutzen." - no-land: "&cDu bist in keinem Land Mitglied." - land-not-found: "&cLand nicht gefunden oder du bist dort kein Mitglied." - reloaded: "&aKonfiguration neu geladen." - claim-blocked: "&cAlle freien Chunk-Slots sind nach einem Unclaim noch gesperrt. Nächster Slot frei in &e%time%&c." - -# Gesperrten Slot sofort freischalten (/chunks skip, /chunks gift ). -skip: - enabled: true - # PLAYER = Geld des Spielers (Vault), LAND = Landkasse (nur Besitzer). gift nutzt immer PLAYER. - payment: PLAYER - # Preis = Restzeit in Stunden * price-per-hour, mindestens min-price. - price-per-hour: 25.0 - min-price: 50.0 - -# Auto-Claim-Warteschlange (/chunks queue): claimt vorgemerkte freie Chunks, sobald ein Slot frei ist. -# Der Spieler muss dafuer online sein. -queue: - max: 3 - -# Watchlist (/chunks watch): Nachricht, sobald ein fremder Chunk frei wird. -watch: - max: 5 - -# Zeitlich begrenzte Claims (/chunks temp ): Chunk wird nach Ablauf automatisch freigegeben, -# ohne dass dadurch ein Slot gesperrt wird. -temp-claims: - enabled: true - max-days: 30 - max-per-land: 3 - -# Hinweis beim Login: freie Slots, naechster Slot, Upkeep-Warnung. -join-reminder: - enabled: true - upkeep-warning-hours: 48 - -top: - size: 10 +# Unclaim-Cooldown: Nach einem manuellen /unclaim bleibt der Chunk-Slot des Lands +# für diese Zeit gesperrt. Format: 30s, 15m, 12h, 2d oder kombiniert (1d12h). +unclaim-cooldown: + enabled: true + duration: 24h + # true = Claimen wird blockiert, solange alle Slots belegt oder gesperrt sind. + # false = nur Anzeige, kein Eingriff ins Claimen. + enforce: true + +# Upkeep-Anzeige. Zeitpunkt wird aus der Lands-config.yml (economic.interval) gelesen. +# Der letzte echte Einzug wird automatisch gespeichert. Bis dahin kann ein Startdatum +# (Tag eines bekannten Einzugs, yyyy-MM-dd) angegeben werden, sonst wird geschätzt. +upkeep: + anchor-date: "" + +messages: + prefix: "&8[&aChunks&8] &7" + no-permission: "&cDazu hast du keine Berechtigung." + players-only: "&cNur Spieler können diesen Befehl nutzen." + no-land: "&cDu bist in keinem Land Mitglied." + land-not-found: "&cLand nicht gefunden oder du bist dort kein Mitglied." + reloaded: "&aKonfiguration neu geladen." + claim-blocked: "&cAlle freien Chunk-Slots sind nach einem Unclaim noch gesperrt. Nächster Slot frei in &e%time%&c." + +# Gesperrten Slot sofort freischalten (/chunks skip, /chunks gift ). +skip: + enabled: true + # PLAYER = Geld des Spielers (Vault), LAND = Landkasse (nur Besitzer). gift nutzt immer PLAYER. + payment: PLAYER + # Preis = Restzeit in Stunden * price-per-hour, mindestens min-price. + price-per-hour: 25.0 + min-price: 50.0 + +# Auto-Claim-Warteschlange (/chunks queue): claimt vorgemerkte freie Chunks, sobald ein Slot frei ist. +# Der Spieler muss dafuer online sein. +queue: + max: 3 + +# Watchlist (/chunks watch): Nachricht, sobald ein fremder Chunk frei wird. +watch: + max: 5 + +# Hinweis beim Login: freie Slots, naechster Slot, Upkeep-Warnung. +join-reminder: + enabled: true + upkeep-warning-hours: 48 + +top: + size: 10 diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml index a83235a..c7adbcd 100644 --- a/src/main/resources/plugin.yml +++ b/src/main/resources/plugin.yml @@ -5,11 +5,11 @@ api-version: '1.21' depend: [Lands] softdepend: [Vault, PlaceholderAPI] folia-supported: false -description: Zeigt Spielern ihre Chunks und wann wieder ein Chunk frei wird (Unclaim-Cooldown und Upkeep), mit Skip, Queue, Watchlist, Temp-Claims und Platzhaltern. +description: Zeigt Spielern ihre Chunks und wann wieder ein Chunk frei wird (Unclaim-Cooldown und Upkeep), mit Skip, Queue, Watchlist und Platzhaltern. commands: chunks: description: Chunk-Belegung, freie Slots, Upkeep, Queue, Watchlist und mehr - usage: / [land|top|skip|gift|queue|watch|temp] + usage: / [land|top|skip|gift|queue|watch] aliases: [chunkslots] permissions: landschunkinfo.use: @@ -27,9 +27,6 @@ permissions: landschunkinfo.watch: description: Chunk-Watchlist default: true - landschunkinfo.temp: - description: Zeitlich begrenzte Claims - default: true landschunkinfo.bypass: description: Unclaim-Cooldown ignorieren default: op