Paper

https://docs.papermc.io/paper/dev/
Admin
Paper is a high-performance Minecraft server implementation that provides developers with APIs and...
Tokens:64,157
Snippets:755
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### YAML Configuration Example

Source: https://docs.papermc.io/paper/dev/plugin-configurations

Illustrates the basic key-value pair structure of a YAML configuration file.

```yaml
root:
  one-key: 10
  another-key: David
```

--------------------------------

### Example Command Structure

Source: https://docs.papermc.io/paper/dev/command-api/basics/command-tree

Illustrates a basic command structure with a root and several subcommands.

```plaintext
/customplugin reload
/customplugin tphere
/customplugin killall
```

--------------------------------

### Key Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure

Shows how to use the key argument to accept and validate namespaced keys.

```java
public static LiteralCommandNode<CommandSourceStack> keyArgument() {
    return Commands.literal("key")
        .then(Commands.argument("key_input", ArgumentTypes.key())
            .executes(ctx -> {
                final Key key = ctx.getArgument("key_input", Key.class);


                ctx.getSource().getSender().sendRichMessage("You put in <aqua><key></aqua>!",
                    Placeholder.unparsed("key", key.asString())
                );


                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### RegistryKey Interface Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry

Illustrates the definition of a RegistryKey for items within the RegistryKey interface.

```java
public sealed interface RegistryKey<T> extends Keyed permits RegistryKeyImpl {
    // ...
    RegistryKey<ItemType> ITEM = RegistryKeyImpl.create("item");
    // ...
}
```

--------------------------------

### Examples of dependency configurations

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins

Various scenarios for dependency management, including load order requirements and classpath sharing.

```yaml
# Suppose we require ProtocolLib to be loaded for our plugin
ProtocolLib:
  load: BEFORE
  required: true


# Now, we are going to register some details for a shop plugin
# So the shop plugin should load after our plugin
SuperShopsXUnlimited:
  load: AFTER
  required: false


# Now, we are going to need to access a plugins classpath
# So that we can properly interact with it.
SuperDuperTacoParty:
  required: true
  join-classpath: true
```

--------------------------------

### Paper NamespacedKey Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper

Provides an example of a namespaced key argument, which is useful for handling custom keys in Bukkit API. It returns a NamespacedKey object.

```java
public static LiteralCommandNode<CommandSourceStack> namespacedKeyArgument() {
    return Commands.literal("namespacedkey")
        .then(Commands.argument("key", ArgumentTypes.namespacedKey())
            .executes(ctx -> {
                final NamespacedKey key = ctx.getArgument("key", NamespacedKey.class);


                ctx.getSource().getSender().sendRichMessage("You put in <aqua><key></aqua>!",
                    Placeholder.unparsed("key", key.toString())
                );
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Shapeless Recipe Crafting Grid Examples

Source: https://docs.papermc.io/paper/dev/recipes

Examples of valid item arrangements for a shapeless recipe. Any combination of the specified ingredients will yield the result.

```plaintext
  DSS   |   SDS   |   S D
  D     |   D     |   D
  D     |   D     |   D S
```

--------------------------------

### Use Translatable Component

Source: https://docs.papermc.io/paper/dev/component-api/i18n

This example shows how to create a translatable component using a defined translation key and providing arguments.

```java
Component.translatable("some.translation.key", Component.text("The Argument"))
```

--------------------------------

### Component Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure

Demonstrates how to use the component argument to accept and display a JSON-formatted text component.

```java
public static LiteralCommandNode<CommandSourceStack> componentArgument() {
    return Commands.literal("componentargument")
        .then(Commands.argument("arg", ArgumentTypes.component())
            .executes(ctx -> {
                final Component component = ctx.getArgument("arg", Component.class);


                ctx.getSource().getSender().sendRichMessage(
                    "Your message: <input>",
                    Placeholder.component("input", component)
                );
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Datapack Load Success Console Output

Source: https://docs.papermc.io/paper/dev/lifecycle/datapacks

Example console output indicating a datapack has loaded successfully.

```log
[01:10:12 INFO]: [PaperDocsTestProject] Loading server plugin PaperDocsTestProject v1.0-DEV
[01:10:12 INFO]: [PaperDocsTestProject] The datapack loaded successfully!
```

--------------------------------

### Chaining 'then' for 'eat' Subcommand

Source: https://docs.papermc.io/paper/dev/command-api/basics/command-tree

Demonstrates chaining literal arguments for the 'eat' subcommand, similar to the 'killall' example.

```java
eat
    .then(Commands.literal("ice-cream"))
    .then(Commands.literal("main-dish"));
```

--------------------------------

### Register Basic Command

Source: https://docs.papermc.io/paper/dev/command-api/misc/basic-command

Example of how to register a custom BasicCommand implementation within the onEnable method of a plugin. This makes the command available in-game.

```java
@Override
public void onEnable() {
    registerCommand("broadcast", new BroadcastCommand());
}
```

--------------------------------

### Adventure Style Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure

Illustrates using the style argument to apply Adventure styles to text components.

```java
public static LiteralCommandNode<CommandSourceStack> styleArgument() {
    return Commands.literal("style")
        .then(Commands.argument("style", ArgumentTypes.style())
            .then(Commands.argument("message", StringArgumentType.greedyString())
                .executes(ctx -> {
                    final Style style = ctx.getArgument("style", Style.class);
                    final String msg = StringArgumentType.getString(ctx, "message");


                    ctx.getSource().getSender().sendRichMessage("Your input: <input>",
                        Placeholder.component("input", Component.text(message).style(style))
                    );
                    return Command.SINGLE_SUCCESS;
                })))
        .build();
}
```

--------------------------------

### Creating Subcommands with Chained Branches

Source: https://docs.papermc.io/paper/dev/command-api/basics/command-tree

This example shows how to create subcommand builders ('eat' and 'killall') with their branches already chained, and then register these subcommands to a root command.

```java
LiteralArgumentBuilder<CommandSourceStack> eat = Commands.literal("eat")
    .then(Commands.literal("ice-cream"))
    .then(Commands.literal("main-dish"));


LiteralArgumentBuilder<CommandSourceStack> killall = Commands.literal("killall")
    .then(Commands.literal("entities"))
    .then(Commands.literal("players"))
    .then(Commands.literal("zombies"));



LiteralArgumentBuilder<CommandSourceStack> advancedCommandRoot = Commands.literal("advanced");
advancedCommandRoot.then(eat);
advancedCommandRoot.then(killall);
```

--------------------------------

### Player Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player

Demonstrates retrieving a specific player using the player argument and applying a velocity to them. Requires the 'minecraft.command.selector' permission.

```Java
public static LiteralCommandNode<CommandSourceStack> playerArgument() {
    return Commands.literal("player")
        .then(Commands.argument("target", ArgumentTypes.player())
            .executes(ctx -> {
                final PlayerSelectorArgumentResolver targetResolver = ctx.getArgument("target", PlayerSelectorArgumentResolver.class);
                final Player target = targetResolver.resolve(ctx.getSource()).getFirst();


                target.setVelocity(new Vector(0, 100, 0));
                target.sendRichMessage("<rainbow>Yeeeeeeeeeet");


                ctx.getSource().getSender().sendRichMessage("Yeeted <target>!",
                    Placeholder.component("target", target.name())
                );
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Example event handler for debugging

Source: https://docs.papermc.io/paper/dev/debugging

A sample event handler used to demonstrate setting breakpoints and inspecting variables during execution.

```java
@EventHandler
public void onPlayerMove(PlayerMoveEvent event) {
  Player player = event.getPlayer();
  Location location = player.getLocation();


  if (location.getWorld() == null)
    return;


  if (location.getWorld().getEnvironment() == World.Environment.NETHER) {
    player.sendMessage("You are in the nether!");
  }
}
```

--------------------------------

### Spawn particles using ParticleBuilder

Source: https://docs.papermc.io/paper/dev/particles

Example of spawning 14 note particles in a 4x0.4x4 cuboid using the ParticleBuilder class.

```java
Particle.NOTE.builder()
  .location(someLocation)
  .offset(2, 0.2, 2)
  .count(14)
  .receivers(32, true)
  .spawn();
```

--------------------------------

### Implement the main JavaPlugin class

Source: https://docs.papermc.io/paper/dev/project-setup

An example of a main plugin class extending JavaPlugin and implementing Listener to handle player join events.

```java
package io.papermc.testplugin;


import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.java.JavaPlugin;


public class ExamplePlugin extends JavaPlugin implements Listener {
  @Override
  public void onEnable() {
    Bukkit.getPluginManager().registerEvents(this, this);
  }


  @EventHandler
  public void onPlayerJoin(PlayerJoinEvent event) {
    event.getPlayer().sendMessage(Component.text("Hello, " + event.getPlayer().getName() + "!"));
  }
}
```

--------------------------------

### Multiple Entities Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player

Shows how to use the entities argument to retrieve one or more entities and display their names. Requires the 'minecraft.command.selector' permission.

```Java
public static LiteralCommandNode<CommandSourceStack> entitiesArgument() {
    return Commands.literal("entitiesarg")
        .then(Commands.argument("arg", ArgumentTypes.entities())
            .executes(ctx -> {
                final EntitySelectorArgumentResolver entitySelectorArgumentResolver = ctx.getArgument("arg", EntitySelectorArgumentResolver.class);
                final List<Entity> entities = entitySelectorArgumentResolver.resolve(ctx.getSource());


                final Component foundEntities = Component.join(JoinConfiguration.commas(true), entities.stream().map(Entity::name).toList());


                ctx.getSource().getSender().sendRichMessage("Found <green><entitynames>",
                    Placeholder.component("entitynames", foundEntities)
                );


                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Paper ItemStack Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper

Shows how to implement an item stack argument for commands, allowing players to specify items with components. This mirrors the functionality of the vanilla /give command.

```java
public static LiteralCommandNode<CommandSourceStack> itemStackArgument() {
    return Commands.literal("itemstack")
        .then(Commands.argument("stack", ArgumentTypes.itemStack())
            .executes(ctx -> {
                final ItemStack itemStack = ctx.getArgument("stack", ItemStack.class);


                if (ctx.getSource().getExecutor() instanceof Player player) {
                    player.getInventory().addItem(itemStack);
                    ctx.getSource().getSender().sendRichMessage("<green>Successfully gave <player> a <item>",
                        Placeholder.component("player", player.name()),
                        Placeholder.component("item", Component.translatable(itemStack))
                    );
                    return Command.SINGLE_SUCCESS;
                }


                ctx.getSource().getSender().sendRichMessage("<red>This argument requires a player!");
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Define a Translation Key and Message

Source: https://docs.papermc.io/paper/dev/component-api/i18n

This is an example of a translation key and its corresponding message format, used in a properties file.

```properties
some.translation.key=Translated Message: {0}
```

--------------------------------

### Time Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper

Demonstrates how to register and use a time argument. It retrieves the time in ticks and applies it to the player's world, sending a message to the player.

```java
public static LiteralCommandNode<CommandSourceStack> timeArgument() {
    return Commands.literal("timearg")
        .then(Commands.argument("time", ArgumentTypes.time())
            .executes(ctx -> {
                final int timeInTicks = IntegerArgumentType.getInteger(ctx, "time");


                if (ctx.getSource().getExecutor() instanceof Player player) {
                    player.getWorld().setFullTime(player.getWorld().getFullTime() + timeInTicks);
                    player.sendRichMessage("Moved time forward by " + timeInTicks + " ticks!");
                    return Command.SINGLE_SUCCESS;
                }


                ctx.getSource().getSender().sendPlainMessage("This argument requires a player!");
                return Command.SINGLE_SUCCESS;
            })
        ).build();
}
```

--------------------------------

### Example: Cool Sword Data Components

Source: https://docs.papermc.io/paper/dev/data-component-api

Shows setting multiple data components on a sword, including lore, enchantments, rarity, and overriding the enchantment glint.

```java
ItemStack sword = ItemStack.of(Material.DIAMOND_SWORD);
sword.setData(DataComponentTypes.LORE, ItemLore.lore().addLine(Component.text("Cool sword!")).build());
sword.setData(DataComponentTypes.ENCHANTMENTS, ItemEnchantments.itemEnchantments().add(Enchantment.SHARPNESS, 10).build());
sword.setData(DataComponentTypes.RARITY, ItemRarity.RARE);


sword.unsetData(DataComponentTypes.TOOL);


sword.setData(DataComponentTypes.MAX_DAMAGE, 10);
sword.setData(DataComponentTypes.ENCHANTMENT_GLINT_OVERRIDE, true);
```

--------------------------------

### Basic Command Restriction

Source: https://docs.papermc.io/paper/dev/command-api/basics/requirements

A simple example demonstrating how to restrict a command using a basic predicate. This command will always pass the restriction.

```java
Commands.literal("test-req")
    .requires(Commands.restricted(source -> true))
    .executes(ctx -> {
        ctx.getSource().getSender().sendRichMessage("You passed!");
        return Command.SINGLE_SUCCESS;
    });
```

--------------------------------

### Players Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player

Extends a command to target multiple players using the 'players' argument. Resolves to a List<Player> which can be iterated.

```java
public static LiteralCommandNode<CommandSourceStack> playersArgument() {
    return Commands.literal("players")
        .then(Commands.argument("targets", ArgumentTypes.players())
            .executes(ctx -> {
                final PlayerSelectorArgumentResolver targetResolver = ctx.getArgument("targets", PlayerSelectorArgumentResolver.class);
                final List<Player> targets = targetResolver.resolve(ctx.getSource());
                final CommandSender sender = ctx.getSource().getSender();


                for (final Player target : targets) {
                    target.setVelocity(new Vector(0, 100, 0));
                    target.sendRichMessage("<rainbow>Yeeeeeeeeeet");


                    sender.sendRichMessage("Yeeted <target>!",
                        Placeholder.component("target", target.name())
                    );
                }
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### UUID Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper

Shows how to implement a UUID argument for looking up offline player data. It retrieves a UUID and checks if the corresponding player has played before.

```java
public static LiteralCommandNode<CommandSourceStack> uuidArgument() {
    return Commands.literal("uuid-lookup")
        .then(Commands.argument("uuid", ArgumentTypes.uuid())
            .executes(ctx -> {
                final UUID uuid = ctx.getArgument("uuid", UUID.class);
                final OfflinePlayer result = Bukkit.getOfflinePlayer(uuid);


                ctx.getSource().getSender().sendRichMessage("Has <aqua><uuid></aqua> played before: <result>",
                    Placeholder.unparsed("uuid", uuid.toString()),
                    Placeholder.parsed("result", result.hasPlayedBefore() ? "<green>true</green>" : "<red>false</red>")
                );


                return Command.SINGLE_SUCCESS;
            })
        ).build();
}
```

--------------------------------

### Single Entity Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player

Demonstrates how to use the entity argument to retrieve a single entity and display its name. Requires the 'minecraft.command.selector' permission.

```Java
public static LiteralCommandNode<CommandSourceStack> entityArgument() {
    return Commands.literal("entityarg")
        .then(Commands.argument("arg", ArgumentTypes.entity())
            .executes(ctx -> {
                final EntitySelectorArgumentResolver entitySelectorArgumentResolver = ctx.getArgument("arg", EntitySelectorArgumentResolver.class);
                final List<Entity> entities = entitySelectorArgumentResolver.resolve(ctx.getSource());


                ctx.getSource().getSender().sendRichMessage("Found <green><entityname>",
                    Placeholder.component("entityname", entities.getFirst().name())
                );


                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Invalid Structure Registry Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry

Demonstrates a command using the STRUCTURE registry key with a resource argument, which can cause client connection errors.

```java
// Registering this command will cause clients to not be able to connect to the server.
final LiteralCommandNode<CommandSourceStack> invalidRegistryArgument = Commands.literal("registry-structure")
    .then(Commands.argument("value", ArgumentTypes.resource(RegistryKey.STRUCTURE)))
    .build();
```

--------------------------------

### BasicCommand Implementation

Source: https://docs.papermc.io/paper/dev/command-api/misc/basic-command

This is a basic implementation of the BasicCommand interface, overriding the execute method. It serves as a starting point for creating custom commands.

```java
package your.package.name;


import io.papermc.paper.command.brigadier.BasicCommand;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import org.jspecify.annotations.NullMarked;


@NullMarked
public class YourCommand implements BasicCommand {


    @Override
    public void execute(CommandSourceStack source, String[] args) {


    }
}
```

--------------------------------

### Register Template Mirror Argument

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums

Example of registering a command with a template mirror argument. The argument is retrieved as a Mirror enum.

```java
public static LiteralCommandNode<CommandSourceStack> templateMirrorArgument() {
    return Commands.literal("templatemirror")
        .then(Commands.argument("mirror", ArgumentTypes.templateMirror())
            .executes(ctx -> {
                final Mirror mirror = ctx.getArgument("mirror", Mirror.class);


                ctx.getSource().getSender().sendPlainMessage("You selected: " + mirror.name());


                return Command.SINGLE_SUCCESS;
            })
        ).build();
}
```

--------------------------------

### Paper Block State Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/paper

Demonstrates how to create a command literal that accepts a block state argument. This allows players to specify a block type with its associated data.

```java
public static LiteralCommandNode<CommandSourceStack> blockStateArgument() {
    return Commands.literal("blockstateargument")
        .then(Commands.argument("arg", ArgumentTypes.blockState())
            .executes(ctx -> {
                final BlockState blockState = ctx.getArgument("arg", BlockState.class);


                ctx.getSource().getSender().sendPlainMessage("You specified a " + blockState.getType() + "!");
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Named Color Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/adventure

Demonstrates using the named color argument to select from 16 built-in text colors and apply them to a message.

```java
public static LiteralCommandNode<CommandSourceStack> namedColorArgument() {
    return Commands.literal("namedcolor")
        .then(Commands.argument("color", ArgumentTypes.namedColor())
            .then(Commands.argument("message", StringArgumentType.greedyString())
                .executes(ctx -> {
                    final NamedTextColor color = ctx.getArgument("color", NamedTextColor.class);
                    final String msg = StringArgumentType.getString(ctx, "message");


                    ctx.getSource().getSender().sendMessage(
                        Component.text(msg).color(color)
                    );
                    return Command.SINGLE_SUCCESS;
                })))
        .build();
}
```

--------------------------------

### Example of a command with custom player argument logic

Source: https://docs.papermc.io/paper/dev/command-api/basics/custom-arguments

This snippet demonstrates how to implement custom suggestions and validation for a player argument directly within a command definition. It filters for online operators and throws an exception if the selected player is not an operator.

```java
Commands.argument("player", ArgumentTypes.player())
    .suggests((ctx, builder) -> {
        Bukkit.getOnlinePlayers().stream()
            .filter(ServerOperator::isOp)
            .map(Player::getName)
            .filter(name -> name.toLowerCase(Locale.ROOT).startsWith(builder.getRemainingLowerCase()))
            .forEach(builder::suggest);
        return builder.buildFuture();
    })
    .executes(ctx -> {
        final Player player = ctx.getArgument("player", PlayerSelectorArgumentResolver.class).resolve(ctx.getSource()).getFirst();
        if (!player.isOp()) {
            final Message message = MessageComponentSerializer.message().serialize(text(player.getName() + " is not a server operator!"));
            throw new SimpleCommandExceptionType(message).create();
        }


        ctx.getSource().getSender().sendRichMessage("Player <player> is an operator!",
            Placeholder.component("player", player.displayName())
        );
        return Command.SINGLE_SUCCESS;
    })
```

--------------------------------

### Custom ConfigurationSerializable Class

Source: https://docs.papermc.io/paper/dev/plugin-configurations

Provides an example of implementing `ConfigurationSerializable` for custom data types. Includes `serialize` for saving and `deserialize` for loading data from the configuration.

```java
public class TeleportOptions implements ConfigurationSerializable {


    private int chunkX;
    private int chunkZ;
    private String name;


    public TeleportOptions(int chunkX, int chunkZ, String name) {
        // Set the values
    }


    public Map<String, Object> serialize() {
        Map<String, Object> data = new HashMap<>();


        data.put("chunk-x", this.chunkX);
        data.put("chunk-z", this.chunkZ);
        data.put("name", this.name);


        return data;
    }


    public static TeleportOptions deserialize(Map<String, Object> args) {
        return new TeleportOptions(
                (int) args.get("chunk-x"),
                (int) args.get("chunk-z"),
                (String) args.get("name")
        );
    }
}
```

--------------------------------

### Example: Written Book Data Component

Source: https://docs.papermc.io/paper/dev/data-component-api

Demonstrates setting `WRITTEN_BOOK_CONTENT` using a builder to define title, author, pages (including filtered pages), and generation.

```java
ItemStack book = ItemStack.of(Material.WRITTEN_BOOK);
WrittenBookContent.Builder builder = WrittenBookContent.writtenBookContent("My Book", "AuthorName");


builder.addPage(Component.text("This is a new page!"));


builder.addFilteredPage(
    Filtered.of(Component.text("I hate Paper!"), Component.text("I love Paper!"))
);


builder.generation(1);


book.setData(DataComponentTypes.WRITTEN_BOOK_CONTENT, builder.build());
```

--------------------------------

### Basic Suggestion Provider Lambda

Source: https://docs.papermc.io/paper/dev/command-api/basics/argument-suggestions

A simple lambda for the `suggests` method that builds an empty future. This is a starting point before adding actual suggestions.

```java
Commands.argument("name", StringArgumentType.word())
    .suggests((ctx, builder) -> builder.buildFuture());
```

--------------------------------

### Enchantment Registry Argument Implementation

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry

An example of implementing a command that uses the enchantment registry resource argument to enchant a player's held item.

```java
public static LiteralCommandNode<CommandSourceStack> enchantmentRegistry() {
    return Commands.literal("enchants-registry")
        .then(Commands.argument("enchantment", ArgumentTypes.resource(RegistryKey.ENCHANTMENT))
            .executes(ctx -> {
                final Enchantment enchantment = ctx.getArgument("enchantment", Enchantment.class);


                if (ctx.getSource().getExecutor() instanceof Player player) {
                    final ItemStack stack = player.getInventory().getItemInMainHand();
                    stack.addUnsafeEnchantment(enchantment, 10);
                    ctx.getSource().getSender().sendRichMessage("Enchanted <player>'s <item> with <enchantment>!",
                        Placeholder.component("player", player.name()),
                        Placeholder.component("item", Component.translatable(stack)),
                        Placeholder.component("enchantment", enchantment.displayName(10))
                    );
                    return Command.SINGLE_SUCCESS;
                }


                ctx.getSource().getSender().sendRichMessage("<red>This command requires a player!");
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Player Profiles Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/entity-player

Command to look up player profiles using the 'playerProfiles' argument. Resolves to a Collection<PlayerProfile> and should be run asynchronously due to potential Mojang API calls.

```java
public static LiteralCommandNode<CommandSourceStack> playerProfilesArgument() {
    return Commands.literal("lookup")
        .then(Commands.argument("profile", ArgumentTypes.playerProfiles())
            .executes(ctx -> {
                final PlayerProfileListResolver profilesResolver = ctx.getArgument("profile", PlayerProfileListResolver.class);
                final Collection<PlayerProfile> foundProfiles = profilesResolver.resolve(ctx.getSource());


                for (final PlayerProfile profile : foundProfiles) {
                    ctx.getSource().getSender().sendPlainMessage("Found " + profile.getName());
                }


                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Integer Range Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/predicate

Shows how to implement an integer range argument for validating integer inputs against a defined range. It checks if a given integer is within the specified bounds.

```java
public static LiteralCommandNode<CommandSourceStack> integerRangeArgument() {
    return Commands.literal("integerrange")
        .then(Commands.argument("range", ArgumentTypes.integerRange())
            .then(Commands.argument("tested_integer", IntegerArgumentType.integer())
                .executes(MinecraftArguments::runIntegerRangeCommand)))
        .build();
}


private static int runIntegerRangeCommand(final CommandContext<CommandSourceStack> ctx) {
    final IntegerRangeProvider integerRangeProvider = ctx.getArgument("range", IntegerRangeProvider.class);
    final int integerToTest = IntegerArgumentType.getInteger(ctx, "tested_integer");


    if (integerRangeProvider.range().contains(integerToTest)) {
        ctx.getSource().getSender().sendRichMessage("<aqua><input></aqua> <green>is</green> inside the specified range!",
            Placeholder.unparsed("input", Integer.toString(integerToTest))
        );
        return Command.SINGLE_SUCCESS;
    }


    ctx.getSource().getSender().sendRichMessage("<aqua><input></aqua> <red>is not</red> inside the specified range!",
        Placeholder.unparsed("input", Integer.toString(integerToTest))
    );


    return Command.SINGLE_SUCCESS;
}
```

--------------------------------

### Example Stacktrace of a NullPointerException

Source: https://docs.papermc.io/paper/dev/reading-stacktraces

This stacktrace demonstrates a NullPointerException that occurred during plugin enablement. It shows the exception type, the specific error message, and the sequence of method calls leading to the error, including the exact line of code in the plugin.

```java
[15:20:42 ERROR]: Could not pass event PluginEnableEvent to TestPlugin v1.0
java.lang.NullPointerException: Cannot invoke "Object.toString()" because "player" is null
        at io.papermc.testplugin.TestPlugin.onPluginEnable(TestPlugin.java:23) ~[TestPlugin-1.0-SNAPSHOT.jar:?]
        at com.destroystokyo.paper.event.executor.asm.generated.GeneratedEventExecutor1.execute(Unknown Source) ~[?:?]
        at org.bukkit.plugin.EventExecutor$2.execute(EventExecutor.java:77) ~[paper-api-1.20.2-R0.1-SNAPSHOT.jar:?]
        at co.aikar.timings.TimedEventExecutor.execute(TimedEventExecutor.java:81) ~[paper-api-1.20.2-R0.1-SNAPSHOT.jar:git-Paper-49]
        at org.bukkit.plugin.RegisteredListener.callEvent(RegisteredListener.java:70) ~[paper-api-1.20.2-R0.1-SNAPSHOT.jar:?]
        at io.papermc.paper.plugin.manager.PaperEventManager.callEvent(PaperEventManager.java:54) ~[paper-1.20.2.jar:git-Paper-49]
        at io.papermc.paper.plugin.manager.PaperPluginManagerImpl.callEvent(PaperPluginManagerImpl.java:126) ~[paper-1.20.2.jar:git-Paper-49]
        at org.bukkit.plugin.SimplePluginManager.callEvent(SimplePluginManager.java:615) ~[paper-api-1.20.2-R0.1-SNAPSHOT.jar:?]
        at io.papermc.paper.plugin.manager.PaperPluginInstanceManager.enablePlugin(PaperPluginInstanceManager.java:200) ~[paper-1.20.2.jar:git-Paper-49]
        at io.papermc.paper.plugin.manager.PaperPluginManagerImpl.enablePlugin(PaperPluginManagerImpl.java:104) ~[paper-1.20.2.jar:git-Paper-49]
        at org.bukkit.plugin.SimplePluginManager.enablePlugin(SimplePluginManager.java:507) ~[paper-api-1.20.2-R0.1-SNAPSHOT.jar:?]
        at org.bukkit.craftbukkit.v1_20_R2.CraftServer.enablePlugin(CraftServer.java:636) ~[paper-1.20.2.jar:git-Paper-49]
        at org.bukkit.craftbukkit.v1_20_R2.CraftServer.enablePlugins(CraftServer.java:547) ~[paper-1.20.2.jar:git-Paper-49]
        at net.minecraft.server.MinecraftServer.loadWorld0(MinecraftServer.java:636) ~[paper-1.20.2.jar:git-Paper-49]
        at net.minecraft.server.MinecraftServer.loadLevel(MinecraftServer.java:435) ~[paper-1.20.2.jar:git-Paper-49]
        at net.minecraft.server.dedicated.DedicatedServer.initServer(DedicatedServer.java:308) ~[paper-1.20.2.jar:git-Paper-49]
        at net.minecraft.server.MinecraftServer.runServer(MinecraftServer.java:1101) ~[paper-1.20.2.jar:git-Paper-49]
        at net.minecraft.server.MinecraftServer.lambda$spin$0(MinecraftServer.java:318) ~[paper-1.20.2.jar:git-Paper-49]
        at java.lang.Thread.run(Thread.java:833) ~[?:?]

```

--------------------------------

### Send PlayerCount Plugin Message

Source: https://docs.papermc.io/paper/dev/plugin-messaging

Example of sending a 'PlayerCount' plugin message to a BungeeCord proxy to get the number of players on a specific server. The response is handled in `onPluginMessageReceived`.

```java
public class MyPlugin extends JavaPlugin implements PluginMessageListener {


    @Override
    public void onEnable() {
        this.getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
        this.getServer().getMessenger().registerIncomingPluginChannel(this, "BungeeCord", this);


        Player player = ...;
        ByteArrayDataOutput out = ByteStreams.newDataOutput();
        out.writeUTF("PlayerCount");
        out.writeUTF("lobby");
        player.sendPluginMessage(this, "BungeeCord", out.toByteArray());
        // The response will be handled in onPluginMessageReceived
    }


    @Override
    public void onPluginMessageReceived(String channel, Player player, byte[] message) {
        if (!channel.equals("BungeeCord")) {
            return;
        }
        ByteArrayDataInput in = ByteStreams.newDataInput(message);
        String subchannel = in.readUTF();
        if (subchannel.equals("PlayerCount")) {
            // This is our response to the PlayerCount request
            String server = in.readUTF();
            int playerCount = in.readInt();
        }
    }
}
```

--------------------------------

### SQL Injection Example Input

Source: https://docs.papermc.io/paper/dev/using-databases

Example of malicious input that can be used to exploit SQL injection vulnerabilities.

```text
' OR 1=1; --
```

--------------------------------

### Configure server startup for remote debugging

Source: https://docs.papermc.io/paper/dev/debugging

Include the JDWP agent library in the server startup command to enable remote connection from an IDE.

```bash
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar paper-26.2.jar nogui
```

--------------------------------

### Item Predicate Argument Example

Source: https://docs.papermc.io/paper/dev/command-api/arguments/predicate

Illustrates the use of the item predicate argument to filter items based on specific criteria. This example checks if a default wooden sword satisfies the given predicate.

```java
public static LiteralCommandNode<CommandSourceStack> itemPredicateArgument() {
    return Commands.literal("itempredicate")
        .then(Commands.argument("predicate", ArgumentTypes.itemPredicate())
            .executes(ctx -> {
                final ItemStackPredicate predicate = ctx.getArgument("predicate", ItemStackPredicate.class);
                final ItemStack defaultWoodenSword = ItemType.WOODEN_SWORD.createItemStack();


                ctx.getSource().getSender().sendRichMessage("Does predicate include a default wooden sword? <result>",
                    Placeholder.parsed("result", predicate.test(defaultWoodenSword) ? "<green>true</green>" : "<red>false</red>")
                );
                return Command.SINGLE_SUCCESS;
            }))
        .build();
}
```

--------------------------------

### Spawn geyser plume particle

Source: https://docs.papermc.io/paper/dev/particles

Examples of spawning a GEYSER_PLUME particle using ParticleBuilder or spawnParticle.

```java
Particle.GEYSER_PLUME.builder()
  .location(someLocation)
  .count(0)
  .receivers(32, true)
  .data(new Particle.Geyser(1))
  .spawn();
```

```java
someWorld.spawnParticle(Particle.GEYSER_PLUME, someLocation, 0, 0, 0, 0, new Particle.Geyser(1));
```

--------------------------------

### Creating Components (Sub-optimal)

Source: https://docs.papermc.io/paper/dev/component-api/introduction

Demonstrates a less efficient way to build components where each modification creates a new instance. Use builders for optimal construction.

```java
final Component component = Component.text("Hello")
    .color(TextColor.color(0x13f832))
    .append(Component.text(" world!", NamedTextColor.GREEN));
```

--------------------------------

### Creating Components (Optimal with Builder)

Source: https://docs.papermc.io/paper/dev/component-api/introduction

Shows the recommended, efficient method for constructing components using builders, which avoids creating new instances for each change. Static imports are suggested for brevity.

```java
final Component component = text()
    .content("Hello").color(color(0x13f832))
    .append(text(" world!", GREEN))
    .build();
```

--------------------------------

### Spawn geyser base particle

Source: https://docs.papermc.io/paper/dev/particles

Examples of spawning a GEYSER_BASE particle using ParticleBuilder or spawnParticle.

```java
Particle.GEYSER_BASE.builder()
  .location(someLocation)
  .count(0)
  .receivers(32, true)
  .data(new Particle.GeyserBase(1, 1))
  .spawn();
```

```java
someWorld.spawnParticle(Particle.GEYSER_BASE, someLocation, 0, 0, 0, 0, new Particle.GeyserBase(1, 1));
```

--------------------------------

### Command Requiring Operator Status

Source: https://docs.papermc.io/paper/dev/command-api/basics/requirements

This example shows how to define a command that can only be executed by a server operator.

```java
Commands.literal("testcmd")
    .requires(sender -> sender.getSender().isOp())
    .executes(ctx -> {
        ctx.getSource().getSender().sendRichMessage("<gold>You are a server operator!");
        return Command.SINGLE_SUCCESS;
    });
```

--------------------------------

### Registering a BasicCommand with Lambda

Source: https://docs.papermc.io/paper/dev/command-api/misc/basic-command

Demonstrates registering a command using a lambda expression for conciseness. This is functional but may reduce readability for complex commands.

```java
@Override
public void onEnable() {
    registerCommand(
        "quickcmd",
        (source, args) -> source.getSender().sendRichMessage("<yellow>Hello!")
    );
}
```

--------------------------------

### Using ArgumentTypes.resource with RegistryKey.ITEM

Source: https://docs.papermc.io/paper/dev/command-api/arguments/registry

Demonstrates how to use the `ArgumentTypes.resource` with `RegistryKey.ITEM` to directly retrieve an item and add it to the player's inventory. This method includes client-side error checking.

```java
Commands.argument("item", ArgumentTypes.resource(RegistryKey.ITEM))
    .executes(ctx -> {
        final ItemType item = ctx.getArgument("item", ItemType.class);


        if (ctx.getSource().getExecutor() instanceof Player player) {
            player.getInventory().addItem(item.createItemStack());
        }


        return Command.SINGLE_SUCCESS;
    });
```

--------------------------------

### Get Lifecycle Manager in BootstrapContext

Source: https://docs.papermc.io/paper/dev/lifecycle

Obtain the LifecycleEventManager instance within a BootstrapContext during server startup.

```java
@Override
public void bootstrap(BootstrapContext context) {
    final LifecycleEventManager<BootstrapContext> lifecycleManager = context.getLifecycleManager();
}
```

--------------------------------

### Spawn geyser emitter particle

Source: https://docs.papermc.io/paper/dev/particles

Examples of spawning a GEYSER emitter particle using ParticleBuilder or spawnParticle.

```java
Particle.GEYSER.builder()
  .location(someLocation)
  .count(0)
  .receivers(32, true)
  .data(new Particle.Geyser(1))
  .spawn();
```

```java
someWorld.spawnParticle(Particle.GEYSER, someLocation, 0, 0, 0, 0, new Particle.Geyser(1));
```

--------------------------------

### Get Lifecycle Manager in Plugin

Source: https://docs.papermc.io/paper/dev/lifecycle

Obtain the LifecycleEventManager instance within a plugin's onEnable method.

```java
@Override
public void onEnable() {
    final LifecycleEventManager<Plugin> lifecycleManager = this.getLifecycleManager();
}
```

--------------------------------

### Configure plugin loading and prefix

Source: https://docs.papermc.io/paper/dev/plugin-yml

Set the server load phase and the custom log prefix for the plugin.

```yaml
load: STARTUP
```

```yaml
prefix: EpicPaperMCHypePlugin
```

--------------------------------

### Obtain BukkitScheduler Instance

Source: https://docs.papermc.io/paper/dev/scheduler

Get the BukkitScheduler instance from the Server object. This is typically done in the onEnable method of your plugin.

```java
public void onEnable() {
    BukkitScheduler scheduler = this.getServer().getScheduler();
}
```

--------------------------------

### Configure individual dependency settings

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins

Detailed configuration for a single dependency, defining load order, requirement status, and classpath access.

```yaml
RegistryPlugin:
  load: BEFORE # Defaults to OMIT
  required: true # Defaults to true
  join-classpath: true # Defaults to true
```

--------------------------------

### Full BroadcastCommand Implementation

Source: https://docs.papermc.io/paper/dev/command-api/misc/basic-command

The complete BroadcastCommand class, demonstrating command execution and integrated player name suggestions.

```java
package your.package.name;


import io.papermc.paper.command.brigadier.BasicCommand;
import io.papermc.paper.command.brigadier.CommandSourceStack;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;


import java.util.Collection;


@NullMarked
public class BroadcastCommand implements BasicCommand {


    @Override
    public void execute(CommandSourceStack source, String[] args) {
        final Component name = source.getExecutor() != null
            ? source.getExecutor().name()
            : source.getSender().name();


        if (args.length == 0) {
            source.getSender().sendRichMessage("<red>You cannot send an empty broadcast!");
            return;
        }


        final String message = String.join(" ", args);
        final Component broadcastMessage = MiniMessage.miniMessage().deserialize(
            "<red><bold>BROADCAST</red> <name> <dark_gray>»</dark_gray> <message>",
            Placeholder.component("name", name),
            Placeholder.unparsed("message", message)
        );


        Bukkit.broadcast(broadcastMessage);
    }


    @Override
    public @Nullable String permission() {
        return "example.broadcast.use";
    }


    @Override
    public Collection<String> suggest(CommandSourceStack source, String[] args) {
        if (args.length == 0) {
            return Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
        }


        return Bukkit.getOnlinePlayers().stream()
            .map(Player::getName)
            .filter(name -> name.toLowerCase().startsWith(args[args.length - 1].toLowerCase()))
            .toList();
    }
}

```

--------------------------------

### Register Template Rotation Argument

Source: https://docs.papermc.io/paper/dev/command-api/arguments/enums

Example of registering a command with a template rotation argument. The argument is retrieved as a StructureRotation enum.

```java
public static LiteralCommandNode<CommandSourceStack> templateRotationArgument() {
    return Commands.literal("templaterotation")
        .then(Commands.argument("rotation", ArgumentTypes.templateRotation())
            .executes(ctx -> {
                final StructureRotation rotation = ctx.getArgument("rotation", StructureRotation.class);


                ctx.getSource().getSender().sendPlainMessage("You selected: " + rotation.name());


                return Command.SINGLE_SUCCESS;
            })
        ).build();
}
```

--------------------------------

### Define a Runnable Task

Source: https://docs.papermc.io/paper/dev/scheduler

Implement the Runnable interface for tasks that do not require a BukkitTask instance. This example shows a separate class implementation.

```java
public class MyRunnableTask implements Runnable {


    private final MyPlugin plugin;


    public MyRunnableTask(MyPlugin plugin) {
        this.plugin = plugin;
    }


    @Override
    public void run() {
        this.plugin.getServer().broadcast(Component.text("Hello, World!"));
    }
}
```

--------------------------------

### Using MiniMessage Helper Method

Source: https://docs.papermc.io/paper/dev/component-api/introduction

Demonstrates how to use a custom 'mm' helper method to deserialize MiniMessage strings, making component creation more concise. Remember to import the helper.

```java
import static io.papermc.docs.util.Components.mm; // replace with your own package


final Component component = mm("<blue>Hello <red>World!");
```

--------------------------------

### Initialize SQLite Driver and Connect

Source: https://docs.papermc.io/paper/dev/using-databases

Use this to initialize the SQLite JDBC driver and establish a connection to your database file. Ensure the driver is loaded before creating the connection.

```java
public class DatabaseManager {


  public void connect() {
    Class.forName("org.sqlite.JDBC");
    Connection connection = DriverManager.getConnection("jdbc:sqlite:plugins/TestPlugin/database.db");
  }
}
```

--------------------------------

### Secure SQL Login with Prepared Statements

Source: https://docs.papermc.io/paper/dev/using-databases

Illustrates how to securely handle user login by using prepared statements to prevent SQL injection. This method separates SQL logic from user input.

```java
public void login(DataSource dataSource, String username, String password) {
    try (Connection connection = dataSource.getConnection()) {
        PreparedStatement statement = connection.prepareStatement("SELECT * FROM users WHERE username = ? AND password = ?");
        statement.setString(1, username);
        statement.setString(2, password);
        ResultSet result = statement.executeQuery();
        // Do work
    } catch (Exception e) {
        // Handle any exceptions that arise from getting / handing the exception
    }
}
```

--------------------------------

### Set Non-Valued Data Components (Flags)

Source: https://docs.papermc.io/paper/dev/data-component-api

Use `setData()` to apply non-valued components, which act as flags. This example sets the `GLIDER` component.

```java
stack.setData(DataComponentTypes.GLIDER);


stack.unsetData(DataComponentTypes.GLIDER);
```

--------------------------------

### Basic Listener Class Structure

Source: https://docs.papermc.io/paper/dev/event-listeners

Create a class that implements the Listener interface to begin listening for events.

```java
public class ExampleListener implements Listener {
    // ...
}
```

--------------------------------

### Get Handler List for an Event

Source: https://docs.papermc.io/paper/dev/handler-lists

Retrieve the HandlerList associated with a specific event. This can be done either from an event instance or directly from the event class.

```java
public class ExampleListener implements Listener {


    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        HandlerList handlerList = event.getHandlerList();
        // ...
    }


    // Or:


    public ExampleListener() {
        // Access the handler list through the static getter
        HandlerList handlerList = PlayerJoinEvent.getHandlerList();
        // ...
    }
}
```

--------------------------------

### Retrieving Audience UUID

Source: https://docs.papermc.io/paper/dev/component-api/audiences

Demonstrates how to get the unique identifier (UUID) of an audience member using the pointer system. Returns an Optional<UUID>.

```java
// Get the uuid from an audience member, returning an Optional<UUID>
Optional<UUID> uuid = audience.get(Identity.UUID);
```

--------------------------------

### Flyspeed Command Implementation

Source: https://docs.papermc.io/paper/dev/command-api/basics/executors

This snippet demonstrates how to implement a `/flyspeed` command using `ArgumentBuilder`. It includes argument parsing, sender and executor retrieval, and setting the player's flight speed.

```java
Commands.literal("flyspeed")
    .then(Commands.argument("speed", FloatArgumentType.floatArg(0, 1.0f))
        .executes(ctx -> {
            float speed = FloatArgumentType.getFloat(ctx, "speed"); // Retrieve the speed argument
            CommandSender sender = ctx.getSource().getSender(); // Retrieve the command sender
            Entity executor = ctx.getSource().getExecutor(); // Retrieve the command executor, which may or may not be the same as the sender


            // Check whether the executor is a player, as you can only set a player's flight speed
            if (!(executor instanceof Player player)) {
                // If a non-player tried to set their own flight speed
                sender.sendPlainMessage("Only players can fly!");
                return Command.SINGLE_SUCCESS;
            }


            // Set the player's speed
            player.setFlySpeed(speed);


            if (sender == executor) {
                // If the player executed the command themselves
                player.sendPlainMessage("Successfully set your flight speed to " + speed);
                return Command.SINGLE_SUCCESS;
            }


            // If the speed was set by a different sender (Like using /execute)
            sender.sendRichMessage("Successfully set <playername>'s flight speed to " + speed, Placeholder.component("playername", player.name()));
            player.sendPlainMessage("Your flight speed has been set to " + speed);
            return Command.SINGLE_SUCCESS;
        })
    );
```

--------------------------------

### Circular Plugin Loading Error Log

Source: https://docs.papermc.io/paper/dev/getting-started/paper-plugins

Example of the error output generated when Paper detects an unresolvable circular dependency loop during plugin loading.

```text

[ERROR]: [LoadOrderTree] =================================
[ERROR]: [LoadOrderTree] Circular plugin loading detected:
[ERROR]: [LoadOrderTree] 1) Paper-Test-Plugin1 -> Paper-Test-Plugin -> Paper-Test-Plugin1
[ERROR]: [LoadOrderTree]    Paper-Test-Plugin1 loadbefore: [Paper-Test-Plugin]
[ERROR]: [LoadOrderTree]    Paper-Test-Plugin loadbefore: [Paper-Test-Plugin1]
[ERROR]: [LoadOrderTree] Please report this to the plugin authors of the first plugin of each loop or join the PaperMC Discord server for further help.
[ERROR]: [LoadOrderTree] =================================

```

--------------------------------

### Configure plugin website and API version

Source: https://docs.papermc.io/paper/dev/plugin-yml

Set the plugin website URL and the minimum required Paper API version.

```yaml
website: https://papermc.io
```

```yaml
api-version: '26.2'
```

--------------------------------

### Suggesting Fixed Amounts for Give Item Command

Source: https://docs.papermc.io/paper/dev/command-api/basics/argument-suggestions

This snippet demonstrates how to provide a predefined list of suggestions (1, 16, 32, 64) for an integer argument in a custom command. It's useful when specific numerical values are commonly used.

```java
@NullMarked
public class SuggestionsTest {


    public static LiteralCommandNode<CommandSourceStack> constructGiveItemCommand() {
        // Create new command: /giveitem
        return Commands.literal("giveitem")


            // Require a player to execute the command
            .requires(ctx -> ctx.getExecutor() instanceof Player)


            // Declare a new ItemStack argument
            .then(Commands.argument("item", ArgumentTypes.itemStack())


                // Declare a new integer argument with the bounds of 1 to 99
                .then(Commands.argument("amount", IntegerArgumentType.integer(1, 99))


                    // Here, we use method references, since otherwise, our command definition would grow too big
                    .suggests(SuggestionsTest::getAmountSuggestions)
                    .executes(SuggestionsTest::executeCommandLogic)


                )
            )
            .build();
    }


    private static CompletableFuture<Suggestions> getAmountSuggestions(final CommandContext<CommandSourceStack> ctx, final SuggestionsBuilder builder) {
        // Suggest 1, 16, 32, and 64 to the user when they reach the 'amount' argument
        builder.suggest(1);
        builder.suggest(16);
        builder.suggest(32);
        builder.suggest(64);
        return builder.buildFuture();
    }


    private static int executeCommandLogic(final CommandContext<CommandSourceStack> ctx) {
        // We know that the executor will be a player, so we can just silently return
        if (!(ctx.getSource().getExecutor() instanceof Player player)) {
            return Command.SINGLE_SUCCESS;
        }


        // If the player has no empty slot, we tell the player that they have no free inventory space
        final int firstEmptySlot = player.getInventory().firstEmpty();
        if (firstEmptySlot == -1) {
            player.sendRichMessage("<light_purple>You do not have enough space in your inventory!");
            return Command.SINGLE_SUCCESS;
        }


        // Retrieve our argument values
        final ItemStack item = ctx.getArgument("item", ItemStack.class);
        final int amount = IntegerArgumentType.getInteger(ctx, "amount");


        // Set the item's amount and give it to the player
        item.setAmount(amount);
        player.getInventory().setItem(firstEmptySlot, item);


        // Send a confirmation message
        player.sendRichMessage("<light_purple>You have been given <white><amount>x</white> <aqua><item></aqua>!",
            Placeholder.component("amount", Component.text(amount)),
            Placeholder.component("item", Component.translatable(item).hoverEvent(item))
        );
        return Command.SINGLE_SUCCESS;
    }
}
```
Tokens:
Raw