Starts refactoring the documentation for NBT arguments. The aim is to…

… create a separate page for NBT compound arguments with tutorials using both the NBTAPI and Rtag. We want to include Rtag because hopefully that gives us some insight into a possible implementation of the NBT path argument for #386

commandapi-documentation-code/src/main/java/dev/jorel/commandapi/examples/java/Examples.java

@@ -746,6 +746,18 @@ void argument_nbt2() {
 }
 }
 
+class argument_nbt_rtag1 extends JavaPlugin {
+/* ANCHOR: argumentNBTRtag1 */
+@Override
+public void onLoad() {
+    CommandAPI.onLoad(new CommandAPIBukkitConfig(this)
+        .initializeNBTAPI(Object.class, o -> o)
+    );
+}
+/* ANCHOR_END: argumentNBTRtag1 */
+
+}
+
 void argument_objectives() {
 /* ANCHOR: argumentObjectives1 */
 new CommandAPICommand("sidebar")

docssrc/book.toml

@@ -31,6 +31,7 @@ level = 2
 # Should we check links on the internet? Enabling this option adds a
 # non-negligible performance impact
 follow-web-links = true
+optional = true
 
 # Are we allowed to link to files outside of the book's root directory? This
 # may help prevent linking to sensitive files (e.g. "../../../../etc/shadow")
@@ -57,4 +58,4 @@ warning-policy = "error"
 #
 # Hint: you can use TOML's raw strings (single quote) to avoid needing to
 # escape things twice.
-exclude = [ 'spigotmc\.org', 'bukkit\.org' ]
+exclude = [ 'spigotmc\.org', 'bukkit\.org' ]

docssrc/src/SUMMARY.md

@@ -80,6 +80,7 @@
       - [Block predicate arguments](./argument_blockpredicate.md)
       - [ItemStack predicate arguments](./argument_itemstackpredicate.md)
     - [NBT arguments](./argument_nbt.md)
+      - [NBT Compound argument](./argument_nbt_compound.md)
     - [Literal arguments](./category_literal_arguments.md)
       - [Literal arguments](./argument_literal.md)
       - [Multi literal arguments](./argument_multiliteral.md)

docssrc/src/argument_nbt.md

@@ -1,5 +1,9 @@
 # NBT arguments
 
+The CommandAPI has support for arguments that interact with Minecraft's [NBT format](https://minecraft.wiki/w/NBT_format). Since Minecraft's NBT format is not directly accessible via Spigot (it is instead implemented via Spigot's APIs when necessary), using NBT-based arguments requires an implementation of an NBT API that is capable of interpreting NMS NBT objects.
+
+
+
 The CommandAPI includes support for NBT compound arguments using an NBT API. The usage for the `NBTCompoundArgument` depends on whether you are using the CommandAPI plugin (using a `CommandAPI.jar` file in your `plugins/` folder), or are shading the CommandAPI (including the compiled CommandAPI code in your own plugin).
 
 -----

docssrc/src/argument_nbt_compound.md

@@ -0,0 +1,118 @@
+# NBT Compound argument
+
+### Using Minecraft's NBT objects
+
+|Spigot-mapped name|Mojang-mapped name|
+|------------------|------------------|
+|`NBTTagCompound`|`CompoundTag`|
+|`NBTBase`|`Tag`|
+
+NBTTagCompound
+
+The CommandAPI allows you to access the NMS `NBTTagCompound` class via `net.minecraft.nbt.NBTTagCompound` directly without requiring any additional APIs to access NBT. This is especially useful for Mojang-mapped servers.
+
+```java
+@Override
+public void onLoad() {
+    CommandAPI.onLoad(new CommandAPIBukkitConfig(this)
+        .initializeNBTAPI(NBTTagCompound.class, o -> o)
+    );
+}
+```
+
+------
+
+## Using the NBT API
+
+-----
+
+## Using Rtag
+
+[Rtag](https://www.spigotmc.org/resources/100694/) is an easily shadeable API that allows you to easily interact with NBT and is highly compatible with the CommandAPI! There are multiple ways to deconstruct NBT arguments using Rtag:
+
+### Accessing individual paths using `Rtag.INSTANCE.get()`
+
+The [`Rtag#get`](https://javadoc.saicone.com/rtag/com/saicone/rtag/Rtag.html#get(java.lang.Object,java.lang.Object...)) method allows you to retrieve objects directly from an NMS `NBTTagCompound` object without requiring you to import `net.minecraft.net.NBTTagCompound`
+
+```java
+@Override
+public void onLoad() {
+    CommandAPI.onLoad(new CommandAPIBukkitConfig(this)
+        .initializeNBTAPI(Object.class, o -> o)
+    );
+}
+```
+
+<div class="example">
+
+For example, if you have an NBT compound tag with this data:
+
+```json
+{
+    "some": {
+        "path": {
+            "here": "hello"
+        }
+    }
+}
+```
+
+You can access the string value `hello` using `Rtag.INSTANCE.get()`:
+
+```java
+new CommandAPICommand("test")
+    .withArguments(new NBTCompoundArgument<Object>("nbt"))
+    .executes((sender, args) -> {
+        String result = Rtag.INSTANCE.get(args.get("nbt"), "some", "path", "here");
+    })
+    .register();
+```
+
+</div>
+
+### Converting the whole compound tag into standard Java objects
+
+The easiest way to interact with Rtag is to deconstruct a compound tag into a `Map` of Java objects. Rtag is able to do this easily using `TagCompound#getValue`, with the `Rtag.INSTANCE` field:
+
+```java
+@Override
+public void onLoad() {
+    CommandAPI.onLoad(new CommandAPIBukkitConfig(this)
+        .initializeNBTAPI(Map.class, o -> TagCompound.getValue(Rtag.INSTANCE, o))
+    );
+}
+```
+
+<div class="example">
+
+Say you have an NBT compound tag that looks like this:
+
+```json
+{
+    name: "Notch",
+    exp: 20s,
+    armor: ["diamond_helmet", "elytra", "diamond_leggings", "leather_boots"],
+    hand_item: {
+        type: "diamond_pickaxe",
+        durability: 123
+    }
+}
+```
+
+Using Rtag's representation of an NBT compound tag using standard Java objects would convert the above NBT compound tag into the following object:
+
+```java
+Map<String, Object> {
+    "name": String "Notch",
+    "exp": Short 20,
+    "armor": List<String> ["diamond_helmet", "elytra", "diamond_leggings", "leather_boots"],
+    "hand_item": Map<String, Object> {
+        "type": String "diamond_pickaxe",
+        "durability": Integer 123
+    }
+}
+```
+
+This 
+
+</div>