Protocolize

Protocolize's support for Minecraft versions depends on which data modules are installed:

You can extend support for new packets and versions by installing additional modules.

To use the Protocolize API in a Maven project, add the exceptionflug repository and the protocolize-api dependency. Note that the scope should be set to provided because the plugin is installed on the proxy server at runtime.

<repository>
    <id>exceptionflug</id>
    <url>https://mvn.exceptionflug.de/repository/exceptionflug-public/</url>
</repository>

<dependency>
    <groupId>dev.simplix</groupId>
    <artifactId>protocolize-api</artifactId>
    <version>2.4.2</version>
    <scope>provided</scope>
</dependency>

To use the Protocolize API in a Gradle project, add the exceptionflug Maven repository and use compileOnly for the protocolize-api dependency.

repositories {
    maven {
        url = uri('https://mvn.exceptionflug.de/repository/exceptionflug-public/')
    }
}

dependencies {
    compileOnly("dev.simplix:protocolize-api:2.4.1")
}

To use Protocolize, you must install it directly onto your proxy server. It supports both BungeeCord and Velocity proxy servers.

Download the latest version compatible with your specific proxy software from the official download page: https://exceptionflug.de/protocolize.

Protocolize may exhibit instability if used in proxy installations alongside the following plugins:

• Geyser
• Floodgate
• ViaVersion

The default data module includes implementations for the following packet classes in the dev.simplix.protocolize.data.packets package:

Use the static create method on the WritableBookContentComponent interface to instantiate a new component. This method uses the internal Protocolize service to resolve the appropriate factory. You must provide a list of WriteablePage objects.

List<WriteablePage> pages = List.of(new WriteablePage("Hello World", "Hello World"));
WritableBookContentComponent component = WritableBookContentComponent.create(pages);

You can apply transformations to a ChatElement to modify its styling. The disableItalic() method returns the same ChatElement instance with italics removed, allowing for a fluent API style.

ChatElement<T> element = ChatElement.ofJson("{\"text\": \"Italic Text\", \"italic\": true}")
    .disableItalic();

Once you have a ChatElement<T>, you can extract the underlying component or convert it back into a specific data format using the following methods:

• asComponent(): Returns the underlying component of type T.
• asJson(): Returns the component as a JSON string.
• asLegacyText(): Returns the component as a legacy color-coded string.
• asNbt(): Returns the component as an NBT Tag<?>.
• toString(): Returns the component as legacy text.

ChatElement<T> element = ChatElement.ofLegacyText("§bBlue Text");

String json = element.asJson();
String legacy = element.asLegacyText();
Tag<?> nbt = element.asNbt();
T component = element.asComponent();

Use the static factory methods on the ChatElement interface to create chat components from different input formats. These methods automatically resolve the appropriate ComponentConverter via the Protocolize service provider.

Available factory methods:

• ofLegacyText(String text): Creates a ChatElement from a legacy Minecraft-style color-coded string.
• ofJson(String text): Creates a ChatElement from a JSON-formatted component string.
• ofNbt(Tag<?> tag): Creates a ChatElement from an NBT tag.

// Create from legacy text
ChatElement<T> legacy = ChatElement.ofLegacyText("§aHello World");

// Create from JSON
ChatElement<T> json = ChatElement.ofJson("{\"text\": \"Hello\"}");

// Create from NBT
ChatElement<T> nbt = ChatElement.ofNbt(someNbtTag);

The WritableBookContentComponent interface allows you to manage a collection of WriteablePage objects. It extends StructuredComponent and provides methods to manipulate the page list.

// Get all pages
List<WriteablePage> pages = component.getPages();

// Add a new page
component.addPage(new WriteablePage("New Page Content", "New Page Content"));

// Remove a specific page
component.removePage(somePage);

// Clear all pages
component.removeAllPages();

// Set the entire list of pages
component.setPages(newPagesList);

The /protocolize command is the primary CLI entrypoint for managing the Protocolize plugin on a BungeeCord proxy. It can be executed by the console or players (depending on the sub-command).

Sub-commands

No arguments

Running /protocolize without any arguments displays the current version and author of the plugin.

debug

Running /protocolize debug generates a debug report and saves it to a file named protocolize-debug.txt in the server's root directory.

Note: This sub-command can only be executed by the console. If a player attempts to use it, the command will fail with an error message.

### Usage Examples

# Display version information (Console or Player)
/protocolize

# Generate a debug report (Console ONLY)
/protocolize debug