LiteDevelopers

https://docs.rollczi.dev
Admin
LiteDevelopers is a team that creates open-source plugins, APIs, and extensions for the Minecraft...
Tokens:31,965
Snippets:404
Trust Score:5.8
Update:11 months ago
Show doc for...
Tokens:
Raw
### Add EternalCode Repository to Build Configuration

Source: https://docs.rollczi.dev/documentation/liteskullapi/getting-started

Configure your build tool to include the EternalCode repository, which hosts the LiteSkullAPI library. This ensures your project can download the necessary artifacts. Supported build tools include Maven, Gradle Kotlin, and Gradle Groovy.

```kotlin
maven {
    url = uri("https://repo.eternalcode.pl/releases")
}
```

```groovy
maven {
    url "https://repo.eternalcode.pl/releases"
}
```

```xml
<repository>
    <id>eternalcode-reposilite-releases</id>
    <name>EternalCode Repository</name>
    <url>https://repo.eternalcode.pl/releases</url>
</repository>
```

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

### Add LiteSkullAPI Dependency to Project

Source: https://docs.rollczi.dev/documentation/liteskullapi/getting-started

Include the LiteSkullAPI library as a dependency in your project's build file. This allows you to use the library's functionalities. Versions and artifact IDs are specified for Maven, Gradle Kotlin, and Gradle Groovy.

```kotlin
implementation("dev.rollczi:liteskullapi:2.0.0")
```

```groovy
implementation "dev.rollczi:liteskullapi:2.0.0"
```

```xml
<dependency>
    <groupId>dev.rollczi</groupId>
    <artifactId>liteskullapi</artifactId>
    <version>2.0.0</version>
</dependency>
```

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

### Add Panda Repository to Gradle/Maven

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/dependencies

Specifies how to add the Panda Repository to your project's build configuration using Gradle (Kotlin and Groovy) and Maven.

```kotlin
maven { url = uri("https://repo.panda-lang.org/releases") }
```

```groovy
maven { url "https://repo.panda-lang.org/releases" }
```

```xml
<repository>
    <id>reposilite-repository-releases</id>
    <name>Reposilite Repository</name>
    <url>https://repo.panda-lang.org/releases</url>
</repository>
```

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

### Add LiteCommands Dependency to Gradle/Maven

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/dependencies

Shows how to include the LiteCommands library in your project's dependencies using Gradle (Kotlin and Groovy) and Maven. Remember to replace `{platform}` with the desired platform.

```kotlin
implementation("dev.rollczi:{platform}:3.10.2")
```

```groovy
implementation "dev.rollczi:{platform}:3.10.2"
```

```xml
<dependency>
    <groupId>dev.rollczi</groupId>
    <artifactId>{platform}</artifactId>
    <version>3.10.2</version>
</dependency>
```

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

### Register LiteAdventurePlatformExtension in LiteCommands Builder

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-platform-kyori

Example of registering the LiteAdventurePlatformExtension within the LiteCommands builder in Java. This allows configuration of MiniMessage, legacy color support, and argument colorization.

```java
.extension(new LiteAdventurePlatformExtension<>(this.audienceProvider), config -> config
    .miniMessage(true)
    .legacyColor(true)
    .colorizeArgument(true)
    .serializer(this.miniMessage)
)
```

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

### Configure -parameters Compiler Flag for Gradle/Maven

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/dependencies

Explains how to add the `-parameters` compiler argument to your build configuration in Gradle (Kotlin and Groovy) and Maven. This flag is necessary for certain LiteCommands features, such as automatic parameter name detection.

```kotlin
tasks.compileJava {
    options.compilerArgs.add("-parameters")
}
```

```groovy
tasks.withType(JavaCompile) {
    options.compilerArgs.add("-parameters")
}
```

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.11.0</version>
    <configuration>
        <compilerArgs>
            <arg>-parameters</arg>
        </compilerArgs>
    </configuration>
</plugin>
```

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

### Define a Command with Named Subcommands using @Execute

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/command-and-executor

Illustrates creating a command with multiple subcommands, each with its own @Execute annotation. This example shows how to define subcommands with and without arguments, and how to handle specific subcommand names.

```java
import com.google.inject.Inject;
import dev.rollczi.litecommands.annotations.Command;
import dev.rollczi.litecommands.annotations.Execute;
import dev.rollczi.litecommands.annotations.Arg;

@Command(name = "time set")
public class TimeSetCommand {
    @Execute
    void execute(@Arg int time) {
        // /time set <time>
    }

    @Execute(name = "day")
    void day() {
        // /time set day
    }

    @Execute(name = "night")
    void night() {
        // /time set night
    }
}
```

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

### Example Output for Global Violation Message

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Shows the output when the global violation message is configured, displaying the parameter name and message for each violation.

```java
[!] Custom constraint violations:
 - nick: size must be between 3 and 16
 - nick: must match "[a-zA-Z]*"
```

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

### Adventure Component Argument Type (With Color) in Java

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/arg/platform-types

This example shows how to use the `Component` argument type with color formatting using the `@Key` annotation in Adventure. It requires the `@Execute` and `@Arg` annotations.

```java
@Execute
void execute(@Arg @Key("color") Component colored) {
    // ...
}
```

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

### Example Ban Command with ChatGPT Integration

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/chatgpt-extension

Demonstrates how to use the ChatGPT extension within a command execution. The 'reason' argument is augmented with the @ChatGpt annotation, allowing ChatGPT to generate a ban reason based on the specified topic. This showcases dynamic input generation for commands.

```java
@Command(name = "ban")
public class BanCommand {

    @Execute
    void ban(
        @Arg Player player,
        @Join @ChatGpt(topic = "Reason for ban") String reason
    ) {
        player.kickPlayer(reason);
    }

}
```

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

### Bukkit World Argument Type in Java

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/arg/platform-types

This example illustrates how to use the `World` argument type to reference game worlds in Bukkit. The `@Execute` and `@Arg` annotations are necessary for this functionality.

```java
@Execute
void execute(@Arg World world) {
    // ...
}
```

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

### Restrict Command Access with Multiple Permissions (Java)

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/permission

This example shows how to assign multiple permissions to a command, allowing different levels of access. The first execution method requires 'gamemode.use' and 'gamemode.admin', while the second, more specific method, requires 'gamemode.other'. This allows for granular control over command usage.

```java
import org.example.litecommands.annotations.Command;
import org.example.litecommands.annotations.Execute;
import org.example.litecommands.annotations.Permission;
import org.example.litecommands.context.CommandSender;
import org.example.litecommands.context.Context;
import org.example.litecommands.context.Player;
import org.example.litecommands.enums.GameMode;

@Command(name = "gamemode")
@Permission({"gamemode.use", "gamemode.admin"})
public class GamemodeCommand {
    @Execute
    void gamemode(@Context Player player, @Arg GameMode mode) {
        player.setGameMode(mode);
    }
    
    @Execute
    @Permission("gamemode.other")
    void list(@Context CommandSender sender, @Arg GameMode mode, @Arg Player target) {
        target.setGameMode(mode);
    }
}
```

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

### Example Output for Custom Constraint Violations Message

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Illustrates the resulting output when the custom constraint violations message is applied, showing joined violation messages for the 'nick' argument.

```java
[!] Custom constraint violations:
<nick> - size must be between 3 and 16
<nick> - must match "[a-zA-Z]*"
```

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

### Example Command with Jakarta Annotations

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Demonstrates a Java command argument 'nick' annotated with Jakarta Bean Validation's `@Size` annotation to enforce length constraints (minimum 3, maximum 16 characters).

```java
@Execute
void ban(@Arg @Size(min = 3, max = 16) String nick) {
    // Command implementation
}
```

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

### Register LiteCommands Adventure Extension (Java)

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-kyori

Registers the LiteAdventureExtension within the LiteCommands builder in Java. This setup enables MiniMessage, legacy color codes, and argument colorization, with an option to provide a custom serializer.

```java
.extension(new LiteAdventureExtension<>(), config -> config
    .miniMessage(true)
    .legacyColor(true)
    .colorizeArgument(true)
    .serializer(this.miniMessage)
)
```

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

### Minestom Player and Target Player Teleportation in Java

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/arg/platform-types

This example shows how to use the `Player` argument type for both the initiator and the target in a teleportation command for Minestom. It requires the `@Execute` and `@Arg` annotations.

```java
@Execute(name = "teleport")
void teleport(@Arg Player player, @Arg Player target) {
    // ...
}
```

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

### Advanced Command Definitions with Nested Commands using @RootCommand

Source: https://docs.rollczi.dev/documentation/litecommands/features/root-command

This example illustrates advanced usage of the @RootCommand annotation, including defining nested commands. It showcases how to create a main command with sub-commands, each with its own execution methods and aliases.

```java
import org.example.annotations.RootCommand;
import org.example.annotations.Execute;
import org.example.annotations.Command;

@RootCommand
public class MessageCommands {

    @Execute(name = "msg")
    void executedMethod() {
        // -> /msg
    }

    @Execute(name = "reply", aliases = {"r"})
    void executedMethod() {
        // -> /reply or /r
    }

    @Execute(name = "chat info")
    void chatInfo() {
        // -> /chat info
    }

    @Command(name = "spy")
    static class SpyCommands {

        @Execute
        void spySwitch() {
            // -> /spy
        }

        @Execute(name = "off")
        void spyOff() {
            // -> /spy off
        }

        @Execute(name = "on")
        void spyOn() {
            // -> /spy on
        }
    }
}
```

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

### Example Output for Specific @Size Violation Message

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Demonstrates the output when a specific violation message for the `@Size` annotation is applied, showing a tailored message including the min and max values from the annotation.

```java
[!] Custom constraint violations:
 - nick: between 3 and 16
 - nick: must match "[a-zA-Z]*"
```

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

### Configure Global StrictMode in Bukkit Plugin

Source: https://docs.rollczi.dev/documentation/litecommands/features/strict-mode

Demonstrates how to set the global StrictMode for LiteCommands within a Bukkit plugin using Java. This example shows initializing LiteCommands and disabling StrictMode by default.

```java
public class ExamplePlugin extends JavaPlugin {

    private LiteCommands<CommandSender> liteCommands;

    @Override
    public void onEnable() {
        this.liteCommands = LiteBukkitFactory.builder("fallback-prefix", this)
                .commands(
                        // your commands
                )
                .strictMode(StrictMode.DISABLED)
                .build();
    }

    @Override
    public void onDisable() {
        if (this.liteCommands != null) {
            this.liteCommands.unregister();
        }
    }
}
```

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

### Java Example: Implementing @Shortcut for Game Mode Commands

Source: https://docs.rollczi.dev/documentation/litecommands/features/shortcut

This Java code demonstrates how to use the @Shortcut annotation to create aliases for game mode commands. It defines '/gmc' as a shortcut for '/gamemode creative' and '/gms' for '/gamemode survival'. This snippet requires the LiteCommands library and standard Minecraft/Bukkit API components.

```java
@Command(name = "gamemode")
public class GamemodeCommand {

    @Execute(name = "creative")
    @Shortcut("gmc")
    public void setCreative(@Context Player player) {
        player.setGameMode(GameMode.CREATIVE);
        player.sendMessage(ChatUtil.color("&aGame mode set to Creative."));
    }

    @Execute(name = "survival")
    @Shortcut("gms")
    public void setSurvival(@Context Player player) {
        player.setGameMode(GameMode.SURVIVAL);
        player.sendMessage(ChatUtil.color("&aGame mode set to Survival."));
    }
}
```

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

### Basic @Arg Annotation Usage in Java

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/arg

Demonstrates basic usage of the @Arg annotation to capture string arguments in a command handler. The annotation marks a parameter as a command argument that will be parsed from user input. This example shows a simple 'say' command that accepts text and outputs it.

```java
@Command(name = "say")
public class SayCommand {
    @Execute
    void execute(@Context SENDER sender, @Arg String text) {
        System.out.println(text);
    }
}
```

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

### Traditional Bukkit Chat Command Implementation (Java)

Source: https://docs.rollczi.dev/documentation/litecommands/what-is-litecommands

This Java code shows a traditional implementation of a chat command for Bukkit using the CommandExecutor interface. It manually handles argument parsing, permission checks, and message sending, which is more verbose than the LiteCommands approach. This example highlights the complexities LiteCommands aims to simplify.

```java
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;

public class BukkitWayCommand implements CommandExecutor {

    private final ChatManager chatManager = new ChatManager();

    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        if (!sender.hasPermission("command.chat")) {
            sender.sendMessage(ChatColor.RED + "You do not have permission to use this command.");
            return true;
        }

        if (args.length == 0) {
            this.usage(sender);
            return true;
        }

        if (args[0].equalsIgnoreCase("on")) {
            this.chatManager.enableChat();
            return true;
        }

        if (args[0].equalsIgnoreCase("off")) {
            this.chatManager.disableChat();
            return true;
        }

        if (args.length == 2 && args[0].equalsIgnoreCase("clear")) {
            if (!sender.hasPermission("command.chat.clear")) {
                sender.sendMessage(ChatColor.RED + "You do not have permission to use this command.");
                return true;
            }

            try {
                int lines = Integer.parseInt(args[1]);
                this.chatManager.clearChat(lines);
            } catch (NumberFormatException exeption) {
                sender.sendMessage(ChatColor.RED + "Invalid argument: " + args[1] + " is not a number.");
            }

            return true;
        }

        this.usage(sender);
        return true;
    }

    private void usage(CommandSender sender) {
        sender.sendMessage(ChatColor.RED + "Usage:");
        sender.sendMessage(ChatColor.RED + " - /chat on");
        sender.sendMessage(ChatColor.RED + " - /chat off");
        sender.sendMessage(ChatColor.RED + " - /chat clear <lines>");
    }

}
```

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

### Custom Validation Factory with Hibernate Validator in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Demonstrates how to configure a custom validation factory using Hibernate Validator. This allows for advanced validation configurations by integrating with the Hibernate Validator provider. The example shows the basic setup for configuring the factory.

```Java
.validationFactory(Validation.byProvider(HibernateValidator.class)
     .configure()
     // hibernate validator config ...
     .buildValidatorFactory()
)
```

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

### Java Example: @ExecuteDefault Annotation for Gamemode Command

Source: https://docs.rollczi.dev/documentation/litecommands/features/execute-default

Demonstrates the implementation of the @ExecuteDefault annotation in Java using LiteCommands. This annotation acts as a fallback for commands that do not match specific arguments, providing default behavior. The example shows a 'gamemode' command with default, 'creative', and 'survival' subcommands.

```java
import com.litecommands.annotations.Command;
import com.litecommands.annotations.Execute;
import com.litecommands.annotations.ExecuteDefault;
import com.litecommands.context.Context;
import org.bukkit.GameMode;
import org.bukkit.entity.Player;

@Command(name = "gamemode")
public class GamemodeCommand {
    
    @ExecuteDefault
    public void executeDefault(@Context Player player) {
        player.sendMessage(ChatUtil.color("&cPlease use one of the following gamemodes:"));
        player.sendMessage(ChatUtil.color("&c- /gamemode creative"));
        player.sendMessage(ChatUtil.color("&c- /gamemode survival"));
    }

    @Execute(name = "creative")
    public void setCreative(@Context Player player) {
        player.setGameMode(GameMode.CREATIVE);
        player.sendMessage(ChatUtil.color("&aGame mode set to Creative."));
    }

    @Execute(name = "survival")
    public void setSurvival(@Context Player player) {
        player.setGameMode(GameMode.SURVIVAL);
        player.sendMessage(ChatUtil.color("&aGame mode set to Survival."));
    }
}
```

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

### Register Command in LiteCommands Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/first-command

Registers the HelloCommand class instance in the LiteCommands builder using the .commands() method. This makes the command available for execution in the server.

```java
.commands(
    new HelloCommand()
)
```

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

### Register Commands with LiteCommands Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/command-and-executor

This snippet demonstrates how to register previously defined commands (like HelloCommand and TimeSetCommand) with the LiteCommands builder. This is a crucial step to make the commands active in the application.

```java
// LiteCommands builder
.commands(
    new HelloCommand(),
    new TimeSetCommand()
)
.build();
```

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

### Configure Global Violation Message

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Defines a global message format for all violations using the `.violationMessage()` method. This example includes the parameter name and the specific violation message.

```java
.violationMessage((invocation, violation) ->
    " - " + violation.getParameterName() + ": " + violation.getMessage()
)
```

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

### Configure LiteSkullAPI Builder Options

Source: https://docs.rollczi.dev/documentation/liteskullapi/initialize

Demonstrates various configuration options for the LiteSkullAPI builder, including setting a custom logger, default skull data, and custom executors for synchronized tasks. These options help tailor the API's behavior.

```java
/* Set custom logger */
.logger(Logger)

/* Set default skull */
.defaultSkull(SkullData)
.defaultSkull(SkullDataDefault)

/* Set scheduler to execute synchronized tasks */
.scheduler(SynchronizedExecutor)

/* Set standard bukkit scheduler to execute synchronized tasks */
.bukkitScheduler(Plugin)

/* Set count of thread for asynchronous executor service */
.threadPool(int)
```

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

### Add Dependency for LiteCommands Adventure Platform

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-platform-kyori

Instructions for adding the LiteCommands Adventure Platform extension as a dependency to your project. Supports Gradle (Kotlin and Groovy) and Maven build tools. Ensure you use version '3.10.2' or later.

```kotlin
implementation("dev.rollczi:litecommands-adventure-platform:3.10.2")
```

```groovy
implementation "dev.rollczi:litecommands-adventure-platform:3.10.2"
```

```xml
<dependency>
    <groupId>dev.rollczi</groupId>
    <artifactId>litecommands-adventure-platform</artifactId>
    <version>3.10.2</version>
</dependency>
```

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

### Get Locale for Command Invocation in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Defines how to retrieve the locale for a command invocation. It checks if the sender has a locale set, otherwise defaults to Locale.ENGLISH. This is a common pattern for internationalization.

```Java
.locale(invocation -> {
    Locale locale = invocation.sender().getLocale();

    return locale != null ? locale : Locale.ENGLISH;
})
```

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

### Configure LiteSkullAPI Custom Extractors and Creator

Source: https://docs.rollczi.dev/documentation/liteskullapi/initialize

Details advanced configuration options for LiteSkullAPI, including setting custom extractors for API-based skull data and online player data, as well as a custom item creator.

```java
/* Set custom api skull extractor */
.apiExtractor(SkullDataAPIExtractor)

/* Set custom skull online player extractor */
.playerExtractor(SkullDataPlayerExtractor)

/* Set custom skull item creator */
.creator(SkullCreator)
```

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

### Customize Constraint Violations Message

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

Configures a custom message format for all constraint violations using the `.constraintViolationsMessage()` method. The example joins all violation messages into a single string with a custom header.

```java
.constraintViolationsMessage((invocation, result) ->
    "[!] Custom constraint violations: \n" + result.asJoinedString("\n")
)
```

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

### Configure LiteBukkitFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for Bukkit platforms. It requires a fallback prefix and the JavaPlugin instance. Commands are registered using the .commands() method. Ensure commands are not declared in plugin.yml. Unregisters commands on disable.

```java
public class ExamplePlugin extends JavaPlugin {

    private LiteCommands<CommandSender> liteCommands;

    @Override
    public void onEnable() {
        this.liteCommands = LiteBukkitFactory.builder("fallback-prefix", this)
            .commands(
                new FlyCommand(),
                new GameModeCommand()
                // your other commands
            )
            .build();
    }

    @Override
    public void onDisable() {
        if (this.liteCommands != null) {
            this.liteCommands.unregister();
        }
    }
}
```

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

### Configure LiteSpongeFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for Sponge platforms. It requires the PluginContainer and Game instances. Commands are registered using the .commands() method. Ensure commands are not declared in plugin.yml.

```java
@Plugin("sponge-plugin")
public class SpongePlugin {

    @Inject
    public SpongePlugin(PluginContainer pluginContainer, Game game) {
        LiteSpongeFactory.builder(pluginContainer, game)
            .commands(
                new TeleportCommand(),
                new KickCommand(),
                // your other commands

            )
            .build();

        // your code ...
    }
}
```

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

### Create Command Class with @Command and @Execute Annotations

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/first-command

Defines a command class using the @Command annotation with a name and an @Execute method that processes command execution. The method receives a CommandSender context and a String argument (username), then sends a response message to the sender.

```java
@Command(name = "hello")
public class HelloCommand {

    @Execute
    void hello(@Context CommandSender sender, @Arg String username) {
        sender.sendMessage("Hello, " + username + "!");
    }

}
```

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

### Configure LiteMinestomFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for Minestom platforms. Commands are registered using the .commands() method. This factory does not require a plugin instance.

```java
public class ExampleMinestom {

    public static void main(String[] args) {
        LiteMinestomFactory.builder()
            .commands(
                new FlyCommand(),
                new GameModeCommand()
            )
            .build();

        // your code ...
    }
}
```

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

### Configure LiteSkullAPI Database and Data Expiration

Source: https://docs.rollczi.dev/documentation/liteskullapi/initialize

Shows how to integrate a custom database implementation for storing skulls and set an expiration duration for this data. This requires implementing the SkullDatabase interface.

```java
/* Set implementation of database for skull */
.database(SkullDatabase)

/* Set expiration of skull data after saving to database. */
.dataBaseSaveExpire(Duration)
```

```java
public class SkullDatabaseImpl implements SkullDatabase {
    // ...
}
```

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

### Credit Card Command with @CreditCardNumber Annotation in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

An example of a 'credit-card' command that takes a 'cardNumber' argument. The @CreditCardNumber annotation is used to validate that the provided string is a valid credit card number format.

```Java
@Command(name = "credit-card")

public class CreditCommand {

    @Execute
    void credit(@Arg @CreditCardNumber String cardNumber) {
        // Command implementation
    }

}
```

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

### Using Component as Response in LiteCommands

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-usage-examples

Shows how to return an Adventure Component object as the response from a LiteCommands command. This allows commands to send formatted text back to the user.

```java
import net.kyori.adventure.text.Component;
import com.github.litecommands.annotations.*;

@Execute(name = "info")
Component info() {
    return Component.text("This is an example of the Component response.");
}
```

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

### Email Command with @Email Annotation in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

An example of an 'email' command that accepts an 'email' argument. The @Email annotation ensures that the provided string is a valid email address format, useful for validating user input.

```Java
@Command(name = "email")
public class EmailCommand {

    @Execute
    void email(@Arg @Email String email) {
        // Command implementation
    }

}
```

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

### Enabling Argument Colorizer in LiteCommands

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-usage-examples

Explains how to enable the Adventure colorizer for arguments within LiteCommands. This can be done globally via the LiteCommands builder using either LiteAdventureExtension or LiteAdventurePlatformExtension.

```java
// Using LiteAdventureExtension
.extension(new LiteAdventureExtension<SENDER>()
    .colorizeArgument(true)
)
```

```java
// Using LiteAdventurePlatformExtension
.extension(new LiteAdventurePlatformExtension<SENDER>(this.audienceProvider)
    .colorizeArgument(true)
)
```

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

### Define a Simple Command with @Command and @Execute

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/command-and-executor

Demonstrates how to declare a basic command using the @Command annotation for the command name and @Execute for the command's execution logic. This is suitable for commands without arguments or subcommands.

```java
import com.google.inject.Inject;
import dev.rollczi.litecommands.annotations.Command;
import dev.rollczi.litecommands.annotations.Execute;
import dev.rollczi.litecommands.annotations.Arg;

@Command(name = "hello")
public class HelloCommand {
    @Execute
    void execute() {
        // /hello
    }
}
```

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

### Configure LiteJDAFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for JDA (Java Discord API) platforms. It requires the JDA instance. Commands can be configured with guild IDs for instant updates. Commands are registered using the .commands() method.

```java
public class ExampleJDA {

    public static void main(String[] args) {
        JDA jda = JDABuilder.createDefault("token")
            .build();

        LiteJDAFactory.builder(jda)
            .settings(settings -> settings
                // If you want to update commands instantly, you can specify the id of your guild
                .guilds("GUILD_ID")
            )
            .commands(
                new EmbedCommand(),
                new MessageCommand()
                // your other commands
            )
            .build();

        // your code ...
    }
}
```

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

### Define a flag with a custom identifier using @Flag

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/flag

This example shows how to define a flag with a custom identifier, such as '--silent', instead of the typical short form like '-s'. This provides more descriptive command-line options.

```java
@Flag("--silent")
```

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

### Defaulting Optional Argument to Sender's World in Java

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/arg-optional

Illustrates the logic for providing a default value to an optional argument when it's not supplied by the user. This example uses `Optional.orElse()` for the `@Arg Optional<T>` approach.

```java
World selectedWorld = world.orElse(sender.getWorld());
```

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

### Add LiteCommands Adventure Dependency (Gradle Groovy)

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-kyori

Integrates the LiteCommands Adventure extension into your project using Gradle with Groovy. This requires version 3.10.2 or a later release. It's a necessary step for Adventure support.

```groovy
implementation "dev.rollczi:litecommands-adventure:3.10.2"
```

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

### Login Command with @Size Annotation in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

An example of a 'login' command that requires a 'password' argument. The @Size annotation enforces that the password must be at least 8 characters long, demonstrating basic input length validation.

```Java
@Command(name = "login")
public class LoginCommand {

    @Execute
    void login(@Arg @Size(min = 8) String password) {
        // Command implementation
    }

}
```

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

### Plugin Enable/Disable with LiteCommands (Java)

Source: https://docs.rollczi.dev/documentation/litecommands/advanced/argument-with-key

This Java code snippet demonstrates how to enable and disable a Bukkit plugin using the LiteCommands library. It initializes the command system on plugin enable and unregisters it on disable. Dependencies include the LiteBukkitFactory and CommandSender.

```java
public class YourPlugin extends Plugin {

    private LiteCommands<CommandSender> liteCommands;

    @Override
    public void onEnable() {
        this.liteCommands = LiteBukkitFactory.builder(this)
                .commands(
                        new CalculateCommand()
                )
                .argument(Integer.class, ArgumentKey.of(FirstArgument.KEY), new FirstArgument())
                .argument(Integer.class, ArgumentKey.of(SecondArgument.KEY), new SecondArgument())
                .build();
    }

    @Override
    public void onDisable() {
        if (this.liteCommands != null) {
            this.liteCommands.unregister();
        }
    }
}
```

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

### Configure LiteVelocityFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for Velocity platforms. It requires the ProxyServer instance. Commands are registered using the .commands() method. Ensure commands are not declared in plugin.yml. Unregisters commands on disable.

```java
@Plugin(id = "example-plugin", name = "ExamplePlugin", version = "1.0.0")
public class ExamplePlugin {

    private final ProxyServer proxyServer;
    private LiteCommands<CommandSource> liteCommands;

    @Inject
    public ExamplePlugin(ProxyServer proxyServer) {
        this.proxyServer = proxyServer;
    }

    @Subscribe
    public void onProxyInitialization(ProxyInitializeEvent event) {
        this.liteCommands = LiteVelocityFactory.builder(this.proxyServer)
            .commands(
                new SendCommand(),
                new MoveCommand(),
                // your other commands
            )
            .build();

        // your code ...
    }

    @Subscribe
    public void onProxyShutdown(ProxyShutdownEvent event) {
        if (this.liteCommands != null) {
            this.liteCommands.unregister();
        }
    }
}
```

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

### Configure LiteBungeeFactory Builder

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/configure-builder

Initializes and builds LiteCommands for BungeeCord platforms. It requires the Plugin instance. Commands are registered using the .commands() method. Ensure commands are not declared in plugin.yml. Unregisters commands on disable.

```java
public class ExamplePlugin extends Plugin {

    private LiteCommands<CommandSender> liteCommands;

    @Override
    public void onEnable() {
        this.liteCommands = LiteBungeeFactory.builder(this)
            .commands(
                new SendCommand(),
                new MoveCommand(),
                // your other commands
            )
            .build();

        // your code ...
    }

    @Override
    public void onDisable() {
        if (this.liteCommands != null) {
            this.liteCommands.unregister();
        }
    }
}
```

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

### Configuring Serializer (MiniMessage and Legacy) in LiteCommands

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-usage-examples

Details how to configure the Adventure serializer in LiteCommands to support MiniMessage and legacy color codes. This is done via the LiteCommands builder using LiteAdventureExtension or LiteAdventurePlatformExtension.

```java
// Using LiteAdventureExtension
.extension(new LiteAdventureExtension<SENDER>()
    .miniMessage(true)
    .legacyColor(true)
)
```

```java
// Using LiteAdventurePlatformExtension
.extension(new LiteAdventurePlatformExtension<SENDER>(this.audienceProvider)
    .miniMessage(true)
    .legacyColor(true)
)
```

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

### Get Skull Data CompletableFuture (Java)

Source: https://docs.rollczi.dev/documentation/liteskullapi/completable-future-api

Retrieves skull data for a given player asynchronously using CompletableFuture. This is beneficial for network-bound operations or data processing that can occur in the background. The method returns a CompletableFuture that resolves to a SkullData object.

```java
CompletableFuture<SkullData> future = skullAPI.getSkullData("Rollczi");
```

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

### Teleport Player to Target with @Context and @Arg

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/context

This Java code snippet demonstrates teleporting a player to a target player using @Context for the sender and @Arg for the target. It requires both the Server and Player contexts to be resolved.

```java
import org.spongepowered.api.entity.living.player.Player;
import org.spongepowered.plugin.plugin.PluginContainer;
import org.spongepowered.plugin.scheduler.Scheduler;
import org.spongepowered.plugin.scheduler.Task;
import org.spongepowered.api.Platform;
import org.spongepowered.api.Server;
import org.spongepowered.api.block.BlockState;
import org.spongepowered.api.command.Command;
import org.spongepowered.api.command.CommandResult;
import org.spongepowered.api.command.args.GenericArguments;
import org.spongepowered.api.command.spec.CommandExecutor;
import org.spongepowered.api.command.spec.CommandSpec;
import org.spongepowered.api.data.key.Keys;
import org.spongepowered.api.data.type.HandTypes;
import org.spongepowered.api.entity.Entity;
import org.spongepowered.api.entity.living.LivingEntity;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.cause.EventContextKey;
import org.spongepowered.api.event.cause.EventContextKeys;
import org.spongepowered.api.item.inventory.ItemStack;
import org.spongepowered.api.text.Text;
import org.spongepowered.api.world.Location;
import org.spongepowered.api.world.World;

import java.util.Optional;

import static org.spongepowered.api.text.Text.of;

@Command(name = "teleport")
public class TeleportCommand {
    
    @Execute
    void teleport(
        @Bind Server server, 
        @Context Player sender,
        @Arg Player target
    ) { 
        sender.teleport(target.getLocation());
    }
}
```

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

### Get Player Health with @Context

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/context

This Java code snippet demonstrates how to use the @Context annotation to retrieve the Player object and display their current health. It requires the Player context to be resolved, otherwise, it shows a PLAYER_ONLY message.

```java
import org.spongepowered.api.entity.living.player.Player;
import org.spongepowered.plugin.plugin.PluginContainer;
import org.spongepowered.plugin.scheduler.Scheduler;
import org.spongepowered.plugin.scheduler.Task;
import org.spongepowered.api.Platform;
import org.spongepowered.api.Server;
import org.spongepowered.api.block.BlockState;
import org.spongepowered.api.command.Command;
import org.spongepowered.api.command.CommandResult;
import org.spongepowered.api.command.args.GenericArguments;
import org.spongepowered.api.command.spec.CommandExecutor;
import org.spongepowered.api.command.spec.CommandSpec;
import org.spongepowered.api.data.key.Keys;
import org.spongepowered.api.data.type.HandTypes;
import org.spongepowered.api.entity.Entity;
import org.spongepowered.api.entity.living.LivingEntity;
import org.spongepowered.api.event.cause.Cause;
import org.spongepowered.api.event.cause.EventContextKey;
import org.spongepowered.api.event.cause.EventContextKeys;
import org.spongepowered.api.item.inventory.ItemStack;
import org.spongepowered.api.text.Text;
import org.spongepowered.api.world.Location;
import org.spongepowered.api.world.World;

import java.util.Optional;

import static org.spongepowered.api.text.Text.of;

@Command(name = "health")
public class HealthCommand {
    
    @Execute // console can't execute it!
    void health(@Context Player sender) {
        // /health
        double health = sender.getHealth();
        sender.sendMessage("Your current health is: " + health);
    }
}
```

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

### Get Skull Signature and Texture with Java

Source: https://docs.rollczi.dev/documentation/liteskullapi/basic-api

Fetches the signature and texture (value) of a player's skull using the LiteSkullAPI. This method accepts a callback that receives a SkullData object containing the signature and texture. Ensure LiteSkullAPI is properly initialized before use.

```java
skullAPI.acceptSkullData("Rollczi", skullData -> {
    String signature = skullData.getSignature();
    String texture = skullData.getValue();
});
```

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

### Implement Account Context Provider in Java

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/context/custom-context

This Java code implements the ContextProvider interface for the Account class. It retrieves the Account object for a given player using an AccountManager. The provide method takes an Invocation object and returns a ContextResult, either an error message or the Account object.

```java
public class AccountContextProvider implements ContextProvider<CommandSender, Account> {

    private final AccountManager accountManager;

    public AccountContext(AccountManager accountManager) {
        this.accountManager = accountManager;
    }

    @Override
    public ContextResult<Account> provide(Invocation<CommandSender> invocation) {
        if (!(invocation.sender() instanceof Player player)) {
            return ContextResult.error("&cOnly players can use this command!");
        }
        
        return ContextResult.ok(() -> {
            Account account = this.accountManager.getAccount(player.getName());
            if (account == null) {
                throw new IllegalStateException("&cAccount " + player.getName() + " not found");
            }

            return account;
        });
    }
}
```

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

### Define a Command with Multiple Subcommands using @Execute

Source: https://docs.rollczi.dev/documentation/litecommands/getting-started/command-and-executor

Shows an alternative way to structure commands with subcommands. This method uses a single @Command annotation for the base command and multiple @Execute annotations for different subcommands, including those with arguments and specific names.

```java
import com.google.inject.Inject;
import dev.rollczi.litecommands.annotations.Command;
import dev.rollczi.litecommands.annotations.Execute;
import dev.rollczi.litecommands.annotations.Arg;

@Command(name = "time")
public class TimeCommand {
    @Execute(name = "add")
    void addTime(@Arg int time) {
        // /time add
    }

    @Execute(name = "set")
    void setTime(@Arg int time) {
        // /time set
    }

    @Execute(name = "set day")
    void setDay() {
        // /time set day
    }
}
```

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

### Get Skull Item Stack with Java

Source: https://docs.rollczi.dev/documentation/liteskullapi/basic-api

Retrieves a skull item stack for a given player name using the LiteSkullAPI. This function is asynchronous and takes a callback to process the item stack once available. No external dependencies are explicitly mentioned beyond the LiteSkullAPI itself.

```java
skullAPI.acceptSkull("Rollczi", itemStack -> {

});
```

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

### Ban Command with @Pattern and @Future Annotations in Java

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/jakarata

An example of a command named 'ban' that accepts a 'name' argument validated by @Pattern (alphanumeric characters) and a 'date' argument validated by @Future (must be in the future). This showcases argument validation for command-line interfaces.

```Java
@Command(name = "ban")
public class BanCommand {

    @Execute
    void ban(
        @Arg @Pattern(regexp = "[a-zA-Z_]+") String name,
        @Arg @Future Instant date
    ) {
        // Command implementation
    }

}
```

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

### Get Skull Item CompletableFuture (Java)

Source: https://docs.rollczi.dev/documentation/liteskullapi/completable-future-api

Fetches a player's skull item asynchronously using the CompletableFuture API. This method is useful for operations that may take time and should not block the main thread. It returns a CompletableFuture that will eventually resolve to an ItemStack representing the skull.

```java
CompletableFuture<ItemStack> future = skullAPI.getSkull("Rollczi");
```

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

### Define Literal Aliases with @Literal Array

Source: https://docs.rollczi.dev/documentation/litecommands/arguments/literal

Shows how to define multiple literal arguments for the same command path using an array in the @Literal annotation. This allows a single command execution to accept various keywords for the same argument, providing flexibility for users. For example, 'temp' and 't' can both be used.

```java
import com.github.rollinginthedark.litecommands.annotations.Command;
import com.github.rollinginthedark.litecommands.annotations.Execute;
import com.github.rollinginthedark.litecommands.annotations.Arg;
import com.github.rollinginthedark.litecommands.annotations.Literal;
import org.bukkit.entity.Player;
import java.time.Duration;

@Command(name = "ban")
public class BanCommand {
    @Execute
    void groupClear(@Arg Player target, @Literal({"temp", "t"}) String literal, @Arg Duration time) {
        // Command /ban <target> temp <reason...>
        // or command /ban <target> t <reason...>
    }
}
```

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

### Add LiteCommands Adventure Dependency (Gradle Kotlin)

Source: https://docs.rollczi.dev/documentation/litecommands/extensions/kyori-adventure/adventure-kyori

Adds the LiteCommands Adventure extension to your project using Gradle with Kotlin. Ensure you are using version 3.10.2 or later. This dependency is essential for enabling Adventure features.

```kotlin
implementation("dev.rollczi:litecommands-adventure:3.10.2")
```
Tokens:
Raw