papermc-skill 1.0.0

package/docs/01-modern-paper-architecture.md

@@ -0,0 +1,172 @@
+# Arsitektur Modern Plugin Paper Minecraft Java
+
+Dokumen ini membahas arsitektur modern pembuatan plugin untuk server Paper Minecraft Java (khususnya versi 1.20+ dan 1.21+), mencakup build tools, konfigurasi manifest, lifecycle bootstrapping, dan sistem pemetaan (Mojang mappings).
+
+---
+
+## 1. Evolusi Arsitektur: Spigot vs Modern Paper
+
+Secara historis, plugin Minecraft dibuat di atas Bukkit/Spigot API dengan `plugin.yml` dan Maven/Gradle sederhana. Namun, ekosistem Paper modern telah merevolusi cara kerja plugin:
+
+| Fitur | Spigot Legacy | Modern Paper (1.20.6+ / 1.21+) |
+| :--- | :--- | :--- |
+| **Manifest File** | `plugin.yml` | `paper-plugin.yml` (atau hybrid) |
+| **Text Handling** | `ChatColor` & legacy string formatting (`§a`) | Kyori Adventure & MiniMessage (`Component`) |
+| **Lifecycle Hook** | Hanya `JavaPlugin.onLoad` & `onEnable` | `PluginBootstrap` + `JavaPlugin` + `LifecycleEvents` |
+| **Command System** | `getCommand("...").setExecutor(...)` | Paper Brigadier Native (`LifecycleEvents.COMMANDS`) atau Cloud |
+| **Mapping NMS** | Obfuscated Spigot mapping (`reobf`) | Mojang Mappings langsung di runtime (1.20.5+) via Paperweight |
+| **Multi-threading** | Single main thread (`BukkitScheduler`) | Multi-thread regionized ready (Folia & Schedulers terpisah) |
+
+---
+
+## 2. Build Tooling: Gradle & Paperweight Userdev
+
+Standard industri modern untuk proyek Paper adalah **Gradle (Kotlin DSL - `.gradle.kts`)** menggunakan plugin **`paperweight-userdev`** dari PaperMC.
+
+### Keunggulan Paperweight Userdev:
+- Menyediakan akses ke **Mojang Mappings (NMS)** langsung tanpa alat deobfuscation eksternal yang rumit.
+- Sejak Paper 1.20.5+, server Paper menjalankan Mojang Mappings secara native di runtime.
+- Terintegrasi dengan plugin `xyz.jpenilla.run-paper` untuk menjalankan test server Paper/Folia langsung dengan satu perintah gradle (`./gradlew runServer`).
+
+### Contoh `build.gradle.kts`:
+
+```kotlin
+plugins {
+    `java-library`
+    id("io.papermc.paperweight.userdev") version "2.0.0-beta.21"
+    id("xyz.jpenilla.run-paper") version "3.0.2" // Task ./gradlew runServer
+    id("com.gradleup.shadow") version "8.3.6"    // Shadow jar bila menggunakan dependensi eksternal
+}
+
+group = "com.example"
+version = "1.0.0-SNAPSHOT"
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21)) // Minecraft 1.20.5+ membutuhkan minimal Java 21
+}
+
+dependencies {
+    paperweight.paperDevBundle("1.21.4-R0.1-SNAPSHOT")
+    
+    // Contoh library umum
+    // implementation("org.incendo:cloud-paper:2.0.0-beta.10")
+}
+
+tasks {
+    compileJava {
+        options.release.set(21)
+        options.encoding = Charsets.UTF_8.name()
+    }
+    
+    shadowJar {
+        archiveClassifier.set("") // Menjadikan output shadow jar sebagai artifact utama
+        // relocate package eksternal agar tidak bentrok dengan plugin lain
+        // relocate("org.incendo.cloud", "com.example.plugin.libs.cloud")
+    }
+}
+```
+
+---
+
+## 3. Konfigurasi `paper-plugin.yml`
+
+Modern Paper menggunakan manifest `paper-plugin.yml` yang terletak di `src/main/resources/paper-plugin.yml`.
+
+### Keuntungan `paper-plugin.yml`:
+- Dukungan dependency loading yang jauh lebih fleksibel (bootstrapper dependencies, server dependencies).
+- Mendukung deklarasi bootstrapper class (`bootstrapper`).
+- Kompatibilitas multi-threaded Folia (`folia-supported: true`).
+
+### Contoh Struktur `paper-plugin.yml`:
+
+```yaml
+name: ExamplePlugin
+version: '${version}'
+main: com.example.plugin.ExamplePlugin
+bootstrapper: com.example.plugin.ExampleBootstrap
+description: Modern Paper Minecraft Plugin
+api-version: '1.21'
+folia-supported: true
+authors:
+  - DeveloperName
+
+dependencies:
+  bootstrap:
+    # Dependensi yang dibutuhkan pada fase bootstrap
+  server:
+    Vault:
+      load: BEFORE
+      required: false
+      join-classpath: true
+    LuckPerms:
+      load: BEFORE
+      required: false
+```
+
+---
+
+## 4. Lifecycle Baru: `PluginBootstrap` vs `JavaPlugin`
+
+Paper memperkenalkan antarmuka `io.papermc.paper.plugin.bootstrap.PluginBootstrap`.
+
+### Urutan Lifecycle Server Paper:
+1. **Plugin Loader Creation**: Resolusi classpath dan dependensi.
+2. **Bootstrap Phase (`PluginBootstrap#bootstrap`)**:
+   - Berjalan sangat awal sebelum world di-load.
+   - Digunakan untuk meregistrasi **Brigadier Commands**, modifikasi konfigurasi registry, dan setup resource global.
+3. **Plugin Instantiation**: Instance `JavaPlugin` dibuat.
+4. **`onLoad()`**: Mirip fase Spigot tradisional.
+5. **`onEnable()`**: Registrasi listener event, scheduler, inisialisasi database, dan setup UI/Game logic.
+6. **`onDisable()`**: Graceful shutdown, flush queue database, dan pembatalan task.
+
+### Contoh Implementasi Bootstrapper:
+
+```java
+package com.example.plugin;
+
+import io.papermc.paper.plugin.bootstrap.BootstrapContext;
+import io.papermc.paper.plugin.bootstrap.PluginBootstrap;
+import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
+import org.jspecify.annotations.NullMarked;
+
+@NullMarked
+public final class ExampleBootstrap implements PluginBootstrap {
+
+    @Override
+    public void bootstrap(final BootstrapContext context) {
+        // Registrasi Lifecycle Events seperti command handler modern
+        context.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> {
+            final var registrar = event.registrar();
+            // Registrasi syntax Brigadier di sini
+        });
+    }
+}
+```
+
+### Contoh Implementasi Main Plugin (`JavaPlugin`):
+
+```java
+package com.example.plugin;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class ExamplePlugin extends JavaPlugin {
+
+    @Override
+    public void onEnable() {
+        // Menggunakan ComponentLogger modern Paper
+        getComponentLogger().info(
+            Component.text("ExamplePlugin berhasil diaktifkan!", NamedTextColor.GREEN)
+        );
+    }
+
+    @Override
+    public void onDisable() {
+        getComponentLogger().info(
+            Component.text("ExamplePlugin dimatikan secara aman.", NamedTextColor.RED)
+        );
+    }
+}
+```

package/docs/02-adventure-and-minimessage.md

@@ -0,0 +1,160 @@
+# Adventure API & MiniMessage di Paper Minecraft
+
+Paper mengintegrasikan **Kyori Adventure** secara native sebagai antarmuka pemrosesan teks. Pendekatan lama yang menggunakan tanda warna section (`§a`, `§l`) atau `org.bukkit.ChatColor` telah **ditinggalkan (deprecated)** karena rentan merusak format teks, tidak mendukung RGB hex secara fleksibel, dan tidak modular.
+
+---
+
+## 1. Mengapa Adventure & MiniMessage?
+
+- **Type-Safe Components**: Teks bukan sekadar string biasa melainkan hierarki objek `Component` yang immutable.
+- **Dukungan Warna Penuh**: Mendukung warna 24-bit TrueColor / Hex (`#FF5555`), Gradients, dan Rainbows.
+- **Interaktivitas Kaya**: Event klik (`run_command`, `suggest_command`, `open_url`), hover tooltip (`show_text`, `show_item`, `show_entity`), dan font kustom.
+- **MiniMessage Format**: String format yang sangat mudah dibaca manusia berbasis tag XML-like, aman dari injeksi formatting.
+
+---
+
+## 2. Format Dasar MiniMessage
+
+Gunakan `net.kyori.adventure.text.minimessage.MiniMessage`:
+
+```java
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+final MiniMessage mm = MiniMessage.miniMessage();
+
+// Contoh teks berwarna dan bergradasi
+Component c1 = mm.deserialize("<gradient:#ff007f:#7f00ff><bold>Server RPG Terhebat</bold></gradient>");
+Component c2 = mm.deserialize("<gray>Klik <green><click:run_command:'/spawn'>DI SINI</click></green> untuk kembali ke spawn.</gray>");
+Component c3 = mm.deserialize("<hover:show_text:'<yellow>Status: Aktif</yellow>'>Arahkan kursor ke sini</hover>");
+```
+
+### Tag MiniMessage Populer:
+- Warna bawaan: `<red>`, `<green>`, `<gold>`, `<aqua>`, `<dark_purple>`, `<white>`, dll.
+- Warna Hex: `<#rrggbb>` atau `<color:#rrggbb>`.
+- Format style: `<bold>` (`<b>`), `<italic>` (`<i>`), `<underlined>` (`<u>`), `<strikethrough>` (`<s>`), `<obfuscated>` (`<obf>`).
+- Gradasi warna: `<gradient:#55cdfc:#f7a8b8:#ffffff>Trans Rights</gradient>`.
+- Pelangi: `<rainbow>Teks pelangi dinamis</rainbow>`.
+- Reset gaya: `<reset>` atau penutupan tag `</red>`.
+
+---
+
+## 3. Dynamic Tag Resolvers (Placeholder Kustom)
+
+MiniMessage menyediakan `TagResolver` untuk memasukkan variabel secara dinamis tanpa merusak parsing atau membuka celah string injection:
+
+```java
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.entity.Player;
+
+public Component createWelcomeMessage(Player player, int coins) {
+    return MiniMessage.miniMessage().deserialize(
+        "<gold>Selamat datang, <yellow><player_name></yellow>! Koin Anda: <green><coins></green></gold>",
+        TagResolver.resolver(
+            Placeholder.component("player_name", player.displayName()),
+            Placeholder.unparsed("coins", String.valueOf(coins))
+        )
+    );
+}
+```
+
+> **Perbedaan `component` vs `unparsed`**:
+> - `Placeholder.component(...)`: Menyisipkan child component yang sudah di-parse, mempertahankan format.
+> - `Placeholder.unparsed(...)`: Menyisipkan teks murni. Tag apapun di dalamnya **tidak** akan di-evaluasi sebagai tag MiniMessage (aman untuk input dari user/chat chatbox).
+
+---
+
+## 4. Mengirim Pesan ke Audience
+
+Di Paper, setiap entitas yang bisa menerima pesan mengimplementasikan antarmuka `net.kyori.adventure.audience.Audience` (termasuk `Player`, `ConsoleCommandSender`, dan `Server`).
+
+### Chat Biasa & Console Logging
+```java
+// Mengirim ke pemain
+player.sendMessage(MiniMessage.miniMessage().deserialize("<aqua>Pesan masuk!</aqua>"));
+
+// Mengirim via ComponentLogger pada plugin
+getComponentLogger().info(MiniMessage.miniMessage().deserialize("<green>Plugin siap melayani pemain!</green>"));
+```
+
+### Action Bar
+```java
+player.sendActionBar(MiniMessage.miniMessage().deserialize("<red>Zona Bahaya!</red>"));
+```
+
+### Titles & Subtitles
+```java
+import net.kyori.adventure.title.Title;
+import java.time.Duration;
+
+final Title title = Title.title(
+    MiniMessage.miniMessage().deserialize("<gold><bold>KEMENANGAN!</bold></gold>"),
+    MiniMessage.miniMessage().deserialize("<gray>Anda memenangkan ronde ini</gray>"),
+    Title.Times.times(Duration.ofMillis(500), Duration.ofSeconds(3), Duration.ofMillis(1000))
+);
+
+player.showTitle(title);
+```
+
+### BossBar
+```java
+import net.kyori.adventure.bossbar.BossBar;
+
+BossBar bossBar = BossBar.bossBar(
+    MiniMessage.miniMessage().deserialize("<dark_red>Ender Dragon HP</dark_red>"),
+    0.75f, // 75%
+    BossBar.Color.RED,
+    BossBar.Overlay.PROGRESS
+);
+
+// Tampilkan bossbar
+player.showBossBar(bossBar);
+
+// Hapus bila sudah selesai
+player.hideBossBar(bossBar);
+```
+
+### Sound Effects
+```java
+import net.kyori.adventure.sound.Sound;
+import org.bukkit.SoundCategory;
+
+Sound sound = Sound.sound(
+    org.bukkit.Sound.ENTITY_PLAYER_LEVELUP.key(),
+    Sound.Source.PLAYER,
+    1.0f, // volume
+    1.2f  // pitch
+);
+
+player.playSound(sound);
+```
+
+---
+
+## 5. Serialisasi Item & Lore dengan Adventure
+
+Saat membuat `ItemStack`, gunakan metode komponen `Component` alih-alih String lama:
+
+```java
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import java.util.List;
+
+ItemStack sword = new ItemStack(Material.DIAMOND_SWORD);
+ItemMeta meta = sword.getItemMeta();
+
+if (meta != null) {
+    // Custom name menggunakan Component
+    meta.displayName(MiniMessage.miniMessage().deserialize("<gradient:#00c6ff:#0072ff><bold>Pedang Es Legendaris</bold></gradient>"));
+    
+    // Lore menggunakan List<Component>
+    meta.lore(List.of(
+        MiniMessage.miniMessage().deserialize("<gray>Memberikan efek <aqua>Freeze</aqua> saat menyerang.</gray>"),
+        MiniMessage.miniMessage().deserialize("<dark_gray>Level: <gold>★★★★★</gold></dark_gray>")
+    ));
+    
+    sword.setItemMeta(meta);
+}
+```

package/docs/03-persistent-data-container.md

@@ -0,0 +1,179 @@
+# PersistentDataContainer (PDC) di Paper Minecraft
+
+`PersistentDataContainer` (PDC) adalah API resmi Bukkit/Paper untuk menyimpan data kustom secara permanen pada objek dalam game seperti:
+- **Item (`ItemMeta`)**
+- **Entity (`Entity`, `LivingEntity`, `Player`)**
+- **Block State / Tile Entity (`TileState`)**
+- **Chunk (`Chunk`)**
+- **World (`World`)**
+
+PDC menggantikan ketergantungan pada library NBT pihak ketiga (seperti NBTAPI) atau pembacaan lore tersembunyi yang rapuh. Data yang disimpan di PDC disimpan langsung dalam NBT vanilla Minecraft dan otomatis disimpan/di-load bersama world data.
+
+---
+
+## 1. Konsep Kunci: NamespacedKey
+
+Setiap nilai yang disimpan di PDC diidentifikasi oleh `NamespacedKey` unik yang terdiri dari `namespace` (biasanya nama plugin berhuruf kecil) dan `key`:
+
+```java
+import org.bukkit.NamespacedKey;
+import org.bukkit.plugin.Plugin;
+
+public final class DataKeys {
+    public static NamespacedKey CUSTOM_ID;
+    public static NamespacedKey COOLDOWN_TIMESTAMP;
+    public static NamespacedKey ITEM_STATS;
+
+    public static void init(Plugin plugin) {
+        CUSTOM_ID = new NamespacedKey(plugin, "custom_id");
+        COOLDOWN_TIMESTAMP = new NamespacedKey(plugin, "cooldown_timestamp");
+        ITEM_STATS = new NamespacedKey(plugin, "item_stats");
+    }
+}
+```
+
+---
+
+## 2. Menyimpan & Membaca Tipe Data Primitif
+
+PDC mendukung berbagai tipe bawaan melalui enum `PersistentDataType`:
+- `PersistentDataType.STRING`
+- `PersistentDataType.INTEGER`
+- `PersistentDataType.LONG`
+- `PersistentDataType.DOUBLE`
+- `PersistentDataType.FLOAT`
+- `PersistentDataType.BYTE` (boolean sering disimpan sebagai byte `1` / `0`)
+- `PersistentDataType.BYTE_ARRAY`
+- `PersistentDataType.TAG_CONTAINER` (PDC bersarang / nested)
+
+### Contoh Menyimpan Data pada ItemStack:
+```java
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+public ItemStack createTeleportWand(String wandId) {
+    ItemStack wand = new ItemStack(Material.BLAZE_ROD);
+    ItemMeta meta = wand.getItemMeta();
+    if (meta != null) {
+        PersistentDataContainer pdc = meta.getPersistentDataContainer();
+        pdc.set(DataKeys.CUSTOM_ID, PersistentDataType.STRING, wandId);
+        pdc.set(DataKeys.COOLDOWN_TIMESTAMP, PersistentDataType.LONG, System.currentTimeMillis());
+        wand.setItemMeta(meta);
+    }
+    return wand;
+}
+```
+
+### Contoh Membaca & Memvalidasi Data pada ItemStack:
+```java
+public boolean isCustomWand(ItemStack item) {
+    if (item == null || !item.hasItemMeta()) return false;
+    
+    PersistentDataContainer pdc = item.getItemMeta().getPersistentDataContainer();
+    return pdc.has(DataKeys.CUSTOM_ID, PersistentDataType.STRING);
+}
+
+public String getWandId(ItemStack item) {
+    if (!isCustomWand(item)) return null;
+    return item.getItemMeta().getPersistentDataContainer().get(DataKeys.CUSTOM_ID, PersistentDataType.STRING);
+}
+```
+
+---
+
+## 3. Menyimpan Data pada Entitas dan Chunk
+
+PDC juga dapat diakses langsung pada entitas dan chunk tanpa meta terpisah:
+
+```java
+import org.bukkit.entity.Entity;
+import org.bukkit.Chunk;
+
+// Menandai entitas khusus (misal Custom Boss)
+public void markAsCustomBoss(Entity entity, String bossType) {
+    entity.getPersistentDataContainer().set(DataKeys.CUSTOM_ID, PersistentDataType.STRING, bossType);
+}
+
+// Menandai chunk yang telah diproses oleh plugin
+public void markChunkProcessed(Chunk chunk) {
+    chunk.getPersistentDataContainer().set(new NamespacedKey("myplugin", "processed"), PersistentDataType.BYTE, (byte) 1);
+}
+```
+
+---
+
+## 4. Tipe Data Kustom (Complex Object Serialization)
+
+Kita dapat mengimplementasikan antarmuka `PersistentDataType<T, Z>` kustom untuk menyimpan objek kompleks (seperti record/POJO) ke dalam PDC tanpa perlu serialisasi JSON manual di setiap panggilan.
+
+### Contoh Record Objek:
+```java
+public record ItemStats(int damageBonus, double critChance, int durability) {}
+```
+
+### Implementasi `PersistentDataType` Kustom:
+```java
+import org.bukkit.persistence.PersistentDataAdapterContext;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+import org.bukkit.NamespacedKey;
+
+public final class ItemStatsDataType implements PersistentDataType<PersistentDataContainer, ItemStats> {
+
+    private final NamespacedKey damageKey;
+    private final NamespacedKey critKey;
+    private final NamespacedKey durabilityKey;
+
+    public ItemStatsDataType(org.bukkit.plugin.Plugin plugin) {
+        this.damageKey = new NamespacedKey(plugin, "damage");
+        this.critKey = new NamespacedKey(plugin, "crit");
+        this.durabilityKey = new NamespacedKey(plugin, "durability");
+    }
+
+    @Override
+    public Class<PersistentDataContainer> getPrimitiveType() {
+        return PersistentDataContainer.class;
+    }
+
+    @Override
+    public Class<ItemStats> getComplexType() {
+        return ItemStats.class;
+    }
+
+    @Override
+    public PersistentDataContainer toPrimitive(ItemStats complex, PersistentDataAdapterContext context) {
+        PersistentDataContainer container = context.newPersistentDataContainer();
+        container.set(damageKey, PersistentDataType.INTEGER, complex.damageBonus());
+        container.set(critKey, PersistentDataType.DOUBLE, complex.critChance());
+        container.set(durabilityKey, PersistentDataType.INTEGER, complex.durability());
+        return container;
+    }
+
+    @Override
+    public ItemStats fromPrimitive(PersistentDataContainer primitive, PersistentDataAdapterContext context) {
+        int damage = primitive.getOrDefault(damageKey, PersistentDataType.INTEGER, 0);
+        double crit = primitive.getOrDefault(critKey, PersistentDataType.DOUBLE, 0.0);
+        int durability = primitive.getOrDefault(durabilityKey, PersistentDataType.INTEGER, 100);
+        return new ItemStats(damage, crit, durability);
+    }
+}
+```
+
+### Penggunaan Langsung:
+```java
+ItemStats stats = new ItemStats(25, 0.15, 500);
+pdc.set(DataKeys.ITEM_STATS, new ItemStatsDataType(plugin), stats);
+
+// Membaca kembali:
+ItemStats loadedStats = pdc.get(DataKeys.ITEM_STATS, new ItemStatsDataType(plugin));
+```
+
+---
+
+## 5. Best Practices PDC
+1. **Gunakan Singleton Keys**: Jangan instansiasi `new NamespacedKey(...)` berulang kali di hot-loop (seperti `EntityDamageByEntityEvent`); simpan sebagai static final constants.
+2. **Namespace Konsisten**: Selalu gunakan plugin instance untuk key namespace agar tidak terjadi tabrakan dengan plugin lain.
+3. **Pembersihan Data**: Hapus data yang tidak lagi valid menggunakan `pdc.remove(key)` untuk menghemat ukuran file world/NBT.

package/docs/04-commands-and-brigadier.md

@@ -0,0 +1,157 @@
+# Command System Modern: Brigadier & Cloud di Paper
+
+Sistem command di Minecraft Java berevolusi signifikan. Metode lama Bukkit seperti `CommandExecutor`, `TabCompleter`, dan deklarasi perintah di `plugin.yml` kini digantikan oleh:
+1. **Paper Native Brigadier API** (diperkenalkan di Paper 1.20.6+ melalui `LifecycleEvents.COMMANDS`).
+2. **Incendo Cloud Framework** (`cloud-paper`): Standar industri untuk framework command berbasis anotasi / builder yang sangat fleksibel dan multi-platform.
+
+---
+
+## 1. Native Paper Brigadier Commands (Paper 1.20.6+)
+
+Mojang Brigadier adalah command dispatcher engine resmi Minecraft. Paper mengekspos API Brigadier secara langsung tanpa perlu hack NMS atau dependensi tambahan.
+
+### Registrasi Melalui Lifecycle Events
+Command didaftarkan saat fase Bootstrap atau saat event `LifecycleEvents.COMMANDS` dipicu:
+
+```java
+package com.example.plugin;
+
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.arguments.StringArgumentType;
+import io.papermc.paper.command.brigadier.Commands;
+import io.papermc.paper.command.brigadier.CommandSourceStack;
+import io.papermc.paper.plugin.bootstrap.BootstrapContext;
+import io.papermc.paper.plugin.bootstrap.PluginBootstrap;
+import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEvents;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import org.bukkit.entity.Player;
+
+public final class CommandBootstrapper implements PluginBootstrap {
+
+    @Override
+    public void bootstrap(BootstrapContext context) {
+        context.getLifecycleManager().registerEventHandler(LifecycleEvents.COMMANDS, event -> {
+            final Commands commands = event.registrar();
+
+            // Membangun pohon syntax command /teleportzone <nama> [radius]
+            commands.register(
+                Commands.literal("teleportzone")
+                    .requires(source -> source.getSender().hasPermission("plugin.command.teleportzone"))
+                    .then(Commands.argument("nama", StringArgumentType.word())
+                        .suggests((ctx, builder) -> {
+                            builder.suggest("lobby");
+                            builder.suggest("arena");
+                            builder.suggest("market");
+                            return builder.buildFuture();
+                        })
+                        .then(Commands.argument("radius", IntegerArgumentType.integer(1, 100))
+                            .executes(ctx -> {
+                                final CommandSourceStack source = ctx.getSource();
+                                final String zone = StringArgumentType.getString(ctx, "nama");
+                                final int radius = IntegerArgumentType.getInteger(ctx, "radius");
+
+                                source.getSender().sendMessage(
+                                    MiniMessage.miniMessage().deserialize(
+                                        "<green>Mempersiapkan teleportasi ke zona <gold>" + zone + "</gold> dengan radius <yellow>" + radius + "</yellow>!</green>"
+                                    )
+                                );
+                                return com.mojang.brigadier.Command.SINGLE_SUCCESS;
+                            })
+                        )
+                        .executes(ctx -> {
+                            final CommandSourceStack source = ctx.getSource();
+                            final String zone = StringArgumentType.getString(ctx, "nama");
+                            source.getSender().sendMessage(
+                                MiniMessage.miniMessage().deserialize("<green>Teleportasi default ke zona <gold>" + zone + "</gold>!</green>")
+                            );
+                            return com.mojang.brigadier.Command.SINGLE_SUCCESS;
+                        })
+                    )
+                    .build(),
+                "Perintah teleportasi zona modern",
+                java.util.List.of("tpzone") // alias
+            );
+        });
+    }
+}
+```
+
+### Keuntungan Paper Brigadier:
+- **Client-Side Syntax Highlighting**: Minecraft client dapat menandai teks merah saat syntax salah sebelum perintah ditekan.
+- **Auto Tab-Completion**: Tidak perlu menulis logika `TabCompleter` manual yang rumit.
+- **Validasi Tipe Otomatis**: Argument validasi otomatis ditangani (angka out-of-range otomatis ditolak).
+
+---
+
+## 2. Incendo Cloud Command Framework (`cloud-paper`)
+
+Untuk plugin yang membutuhkan dependensi injeksi, parsing objek otomatis (seperti `Player`, `OfflinePlayer`, `World`, `Duration`), dan command yang sangat banyak, **Cloud** adalah pilihan terpopuler.
+
+### Dependensi Gradle:
+```kotlin
+dependencies {
+    implementation("org.incendo:cloud-paper:2.0.0-beta.10")
+    // atau cloud-annotations jika menyukai gaya @Command
+    implementation("org.incendo:cloud-annotations:2.0.0-beta.10")
+}
+```
+
+### Inisialisasi Cloud PaperCommandManager:
+```java
+import org.incendo.cloud.paper.PaperCommandManager;
+import org.incendo.cloud.execution.ExecutionCoordinator;
+import org.bukkit.command.CommandSender;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class PluginCommands {
+
+    public static PaperCommandManager<CommandSender> createManager(JavaPlugin plugin) {
+        PaperCommandManager<CommandSender> manager = PaperCommandManager.createNative(
+            plugin,
+            ExecutionCoordinator.simpleCoordinator()
+        );
+
+        // Daftarkan brigadier mapper jika didukung
+        if (manager.hasCapability(org.incendo.cloud.paper.PaperCommandManager.Capability.BRIGADIER)) {
+            manager.registerBrigadier();
+        }
+
+        return manager;
+    }
+}
+```
+
+### Contoh Perintah dengan Cloud Builder:
+```java
+import org.incendo.cloud.paper.PaperCommandManager;
+import org.incendo.cloud.bukkit.parser.PlayerParser;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+
+public void registerGiveRewardCommand(PaperCommandManager<CommandSender> manager) {
+    manager.command(
+        manager.commandBuilder("reward")
+            .permission("plugin.reward")
+            .required("target", PlayerParser.playerParser())
+            .handler(commandContext -> {
+                CommandSender sender = commandContext.sender();
+                Player target = commandContext.get("target");
+
+                target.sendMessage(MiniMessage.miniMessage().deserialize("<gold>Kamu menerima hadiah spesial!</gold>"));
+                sender.sendMessage(MiniMessage.miniMessage().deserialize("<green>Hadiah terkirim ke " + target.getName() + ".</green>"));
+            })
+    );
+}
+```
+
+---
+
+## 3. Komparasi: Kapan Memilih Apa?
+
+| Aspek | Paper Native Brigadier | Incendo Cloud |
+| :--- | :--- | :--- |
+| **Ukuran Jar** | Zero-dependency (bawaan Paper) | Menambahkan lib ~300KB-800KB (butuh shadow/relocate) |
+| **Kemudahan** | Cocok untuk command sederhana-menengah | Sangat baik untuk ratusan sub-command |
+| **Argument Parser** | Perlu mapping manual untuk tipe Bukkit | Built-in parser untuk Player, Location, Selector, dll |
+| **Portabilitas** | Hanya berjalan di Paper 1.20.6+ | Mendukung Velocity, Bungee, Fabric, Paper |