### Complete Client Setup

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of a complete client setup with encryption and login packet.

```java
InetSocketAddress serverAddress = new InetSocketAddress("example.com", 19132);

Channel channel = new Bootstrap()
    .channelFactory(RakChannelFactory.client(NioDatagramChannel.class))
    .group(new NioEventLoopGroup())
    .handler(new BedrockClientInitializer() {
        @Override
        protected void initSession(BedrockClientSession session) {
            // Configure session
            session.setCodec(Bedrock_v429.CODEC);
            session.setPacketHandler(new ClientPacketHandler());
            session.setCompression(PacketCompressionAlgorithm.SNAPPY);
            
            // Generate and enable encryption
            try {
                KeyGenerator keyGen = KeyGenerator.getInstance("AES");
                keyGen.init(256);
                session.enableEncryption(keyGen.generateKey());
            } catch (NoSuchAlgorithmException e) {
                // Handle error
            }
            
            // Enable logging for debugging
            session.setLogging(true);
            
            // Send login packet
            LoginPacket login = new LoginPacket();
            login.setProtocolVersion(429);
            login.setUsername("Player");
            session.sendPacket(login);
        }
    })
    .connect(serverAddress)
    .syncUninterruptibly()
    .channel();
```

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

### Complete Server Setup

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of a complete server setup with dynamic codec selection, compression, and encryption.

```java
InetSocketAddress bindAddress = new InetSocketAddress("0.0.0.0", 19132);

BedrockPong pong = new BedrockPong()
    .edition("MCPE")
    .motd("Survival Server")
    .protocolVersion(429)
    .gameType("Survival")
    .playerCount(0)
    .maximumPlayerCount(100)
    .ipv4Port(19132);

ServerBootstrap serverBootstrap = new ServerBootstrap()
    .channelFactory(RakChannelFactory.server(NioDatagramChannel.class))
    .option(RakChannelOption.RAK_ADVERTISEMENT, pong.toByteBuf())
    .group(new NioEventLoopGroup())
    .childHandler(new BedrockServerInitializer() {
        @Override
        protected void initSession(BedrockServerSession session) {
            session.setPacketHandler(new ServerPacketHandler() {
                @Override
                public PacketSignal handle(LoginPacket packet) {
                    // Set codec based on client's protocol version
                    int clientProtocol = packet.getProtocolVersion();
                    if (clientProtocol == 429) {
                        session.setCodec(Bedrock_v429.CODEC);
                    } else {
                        // Disconnect unsupported version
                        session.disconnect("disconnect.invalidVersion");
                        return PacketSignal.HANDLED;
                    }
                    
                    // Enable compression and encryption
                    session.setCompression(PacketCompressionAlgorithm.SNAPPY);
                    try {
                        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
                        keyGen.init(256);
                        session.enableEncryption(keyGen.generateKey());
                    } catch (NoSuchAlgorithmException e) {
                        session.disconnect("disconnect.encryptionError");
                        return PacketSignal.HANDLED;
                    }
                    
                    return PacketSignal.HANDLED;
                }
            });
        }
    });

Channel serverChannel = serverBootstrap.bind(bindAddress).syncUninterruptibly().channel();
```

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

### Environment Variable Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of setting the disconnect timeout Java system property.

```bash
java -Dorg.cloudburstmc.protocol.bedrock.disconnectTimeout=15 -jar server.jar
```

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

### BedrockSession Setup

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of initializing a BedrockSession, setting the codec, packet handler, and optionally enabling compression, encryption, and logging.

```java
protected void initSession(BedrockSession session) {
    // 1. Set codec first (before sending packets)
    session.setCodec(Bedrock_v429.CODEC);

    // 2. Set packet handler
    session.setPacketHandler(new MyPacketHandler());

    // 3. Optional: enable compression
    session.setCompression(PacketCompressionAlgorithm.SNAPPY);

    // 4. Optional: enable encryption
    SecretKey encryptionKey = generateEncryptionKey();
    session.enableEncryption(encryptionKey);

    // 5. Optional: enable logging
    session.setLogging(true); // TRACE level

    // Now ready to send packets
    LoginPacket loginPacket = new LoginPacket();
    // ... populate packet
    session.sendPacket(loginPacket);
}
```

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

### Compression Algorithms

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Examples of setting different compression algorithms for the session.

```java
// Zlib compression (standard)
session.setCompression(PacketCompressionAlgorithm.ZLIB);

// Snappy compression (faster, lower ratio)
session.setCompression(PacketCompressionAlgorithm.SNAPPY);

// No compression
session.setCompression(PacketCompressionAlgorithm.NONE);
```

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

### Custom Compression Strategy

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of setting a custom compression strategy and querying the current one.

```java
CompressionStrategy strategy = new ZlibCompression();
peer.setCompression(strategy);

// Query current compression
CompressionStrategy current = peer.getCompressionStrategy();
if (current != null) {
    // Compression is enabled
}
```

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

### Enable Encryption

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of enabling encryption for the session with a generated key.

```java
// Protocol >= 428: uses AES-CTR mode
// Protocol < 428: uses AES-ECB mode (automatic)
session.enableEncryption(encryptionKey);
```

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

### AES Key Generation

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of generating an AES-256 encryption key.

```java
// Generate AES-256 key
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey encryptionKey = keyGen.generateKey();
```

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

### Testing Configuration

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of mocking BedrockCodecHelper and BedrockSession for testing packet serialization without a real server.

```java
// Mock codec helper
BedrockCodecHelper mockHelper = mock(BedrockCodecHelper.class);

// Mock session
BedrockSession mockSession = mock(BedrockSession.class);
when(mockSession.getCodec()).thenReturn(Bedrock_v429.CODEC);

// Test packet serialization
BedrockCodec codec = Bedrock_v429.CODEC;
ByteBuf buffer = Unpooled.buffer();
codec.tryEncode(codec.createHelper(), buffer, testPacket);
```

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

### Creating a Server

Source: https://github.com/cloudburstmc/protocol/blob/3.0/EXAMPLES.md

Example of how to create a Bedrock server.

```java
InetSocketAddress bindAddress = new InetSocketAddress("0.0.0.0", 19132);

BedrockPong pong = new BedrockPong()
        .edition("MCPE")
        .motd("My Server")
        .playerCount(0)
        .maximumPlayerCount(20)
        .gameType("Survival")
        .protocolVersion(Bedrock_v389.CODEC.getProtocolVersion());

new ServerBootstrap()
        .channelFactory(RakChannelFactory.server(NioDatagramChannel.class))
        .option(RakChannelOption.RAK_ADVERTISEMENT, pong.toByteBuf())
        .group(new NioEventLoopGroup())
        .childHandler(new BedrockServerInitializer() {
            @Override
            protected void initSession(BedrockServerSession session) {
                // Connection established
                // Make sure to set the packet codec version you wish to use before sending out packets
                session.setCodec(Bedrock_v389.CODEC);
                // Remember to set a packet handler so you receive incoming packets
                session.setPacketHandler(new FooBarPacketHandler());
                // By default, the server will use a compatible codec that will read any LoginPacket.
                // After receiving the LoginPacket, you need to set the correct packet codec for the client and continue.
            }
        })
        .bind(bindAddress)
        .syncUninterruptibly();
```

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

### Full Server Setup with Utilities

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

An example demonstrating how to set up a full Bedrock server using CloudburstMC protocol utilities, including packet handling for login and player movement.

```java
import org.cloudburstmc.protocol.bedrock.*;
import org.cloudburstmc.protocol.bedrock.codec.*;
import org.cloudburstmc.protocol.bedrock.packet.*;

public class ServerExample {
    public static void main(String[] args) throws Exception {
        // Create server advertisement
        BedrockPong pong = new BedrockPong()
            .edition("MCPE")
            .motd("Cloudburst Survival Server")
            .protocolVersion(Bedrock_v429.CODEC.getProtocolVersion())
            .gameType("Survival")
            .playerCount(0)
            .maximumPlayerCount(100)
            .ipv4Port(19132);

        // Start server
        new ServerBootstrap()
            .channelFactory(RakChannelFactory.server(NioDatagramChannel.class))
            .option(RakChannelOption.RAK_ADVERTISEMENT, pong.toByteBuf())
            .group(new NioEventLoopGroup())
            .childHandler(new BedrockServerInitializer() {
                @Override
                protected void initSession(BedrockServerSession session) {
                    session.setPacketHandler(new MyServerHandler(session));
                }
            })
            .bind(new InetSocketAddress("0.0.0.0", 19132))
            .syncUninterruptibly();

        System.out.println("Server started!");
    }
}

class MyServerHandler extends BedrockPacketHandler {
    private final BedrockServerSession session;

    public MyServerHandler(BedrockServerSession session) {
        this.session = session;
    }

    @Override
    public PacketSignal handle(LoginPacket packet) {
        int clientVersion = packet.getProtocolVersion();
        
        if (clientVersion != Bedrock_v429.CODEC.getProtocolVersion()) {
            session.disconnect("Unsupported game version", false);
            return PacketSignal.HANDLED;
        }

        session.setCodec(Bedrock_v429.CODEC);
        session.setCompression(PacketCompressionAlgorithm.SNAPPY);

        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        session.enableEncryption(keyGen.generateKey());

        return PacketSignal.HANDLED;
    }

    @Override
    public PacketSignal handle(MovePlayerPacket packet) {
        // Handle player movement
        Vector3f position = packet.getPosition();
        return PacketSignal.HANDLED;
    }

    @Override
    public void onDisconnect(CharSequence reason) {
        System.out.println("Player disconnected: " + reason);
    }
}
```

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

### Encryption Setup Error Handling

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of handling exceptions during encryption setup, including cases where encryption is already enabled.

```java
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey key = keyGen.generateKey();

try {
    session.enableEncryption(key);
} catch (IllegalStateException e) {
    if (e.getMessage().contains("Encryption is already enabled")) {
        logger.debug("Encryption already active");
    }
} catch (IllegalArgumentException e) {
    logger.error("Invalid AES key: {}", e.getMessage());
}
```

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

### RakChannelOption Configuration

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of configuring Netty's RakChannelOption before connecting a client.

```java
new Bootstrap()
    .channelFactory(RakChannelFactory.client(NioDatagramChannel.class))
    .option(RakChannelOption.RAK_PROTOCOL_VERSION, 10)
    .option(RakChannelOption.RAK_SUPPORTED_VERSIONS, new int[]{10})
    // ... other Netty options
    .connect(address)
    .sync();
```

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

### BedrockCodec Builder

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Example of building a BedrockCodec with protocol version, Minecraft version, RakNet protocol version, a helper, and registering packets.

```java
BedrockCodec codec = BedrockCodec.builder()
    .protocolVersion(429)
    .minecraftVersion("1.16.0.0")
    .raknetProtocolVersion(10)
    .helper(MyCodecHelper::new)
    .registerPacket(LoginPacket::new, new LoginPacketSerializer(), 0x01, PacketRecipient.SERVER)
    .registerPacket(PlayStatusPacket::new, new PlayStatusPacketSerializer(), 0x02, PacketRecipient.CLIENT)
    // ... register all packets
    .build();
```

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

### SimpleDefinitionRegistry Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Concrete implementation of DefinitionRegistry with examples.

```java
DefinitionRegistry<ItemDefinition> itemRegistry = 
    new SimpleDefinitionRegistry<>(itemDefinitions);

ItemDefinition diamond = itemRegistry.getDefinition("minecraft:diamond");
ItemDefinition item = itemRegistry.getDefinition(264); // Runtime ID
```

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

### Get Protocol Version Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of retrieving the Bedrock protocol version from a BedrockCodec instance.

```java
int version = codec.getProtocolVersion();
```

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

### Get Minecraft Version Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of retrieving the Minecraft version string from a BedrockCodec instance.

```java
String version = codec.getMinecraftVersion();
```

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

### Codec Set During Handler Setup - Error Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Illustrates an error scenario where a packet is sent before the codec is set, highlighting the correct order of operations.

```java
@Override
protected void initSession(BedrockClientSession session) {
    // ERROR: Sending packet without codec
    LoginPacket login = new LoginPacket();
    session.sendPacket(login); // Packet headers are encoded using codec!
    
    // Correct:
    session.setCodec(Bedrock_v429.CODEC); // Set codec FIRST
    session.sendPacket(login);
}
```

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

### BedrockServerInitializer Usage Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of using BedrockServerInitializer with ServerBootstrap to set up a server.

```java
Channel serverChannel = new ServerBootstrap()
    .channelFactory(RakChannelFactory.server(NioDatagramChannel.class))
    .group(new NioEventLoopGroup())
    .option(RakChannelOption.RAK_ADVERTISEMENT, serverAdvert.toByteBuf())
    .childHandler(new BedrockServerInitializer() {
        @Override
        protected void initSession(BedrockServerSession session) {
            session.setPacketHandler(new ServerHandler() {
                @Override
                public PacketSignal handle(LoginPacket packet) {
                    // Determine codec based on client protocol
                    if (packet.getProtocolVersion() == 429) {
                        session.setCodec(Bedrock_v429.CODEC);
                    } else {
                        session.disconnect("disconnect.unsupportedProtocol");
                        return PacketSignal.HANDLED;
                    }
                    
                    // Set compression and encryption
                    session.setCompression(PacketCompressionAlgorithm.SNAPPY);
                    
                    KeyGenerator keyGen = KeyGenerator.getInstance("AES");
                    keyGen.init(256);
                    session.enableEncryption(keyGen.generateKey());
                    
                    return PacketSignal.HANDLED;
                }
            });
        }
    })
    .bind(new InetSocketAddress("0.0.0.0", 19132))
    .syncUninterruptibly()
    .channel();
```

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

### Get RakNet Protocol Version Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of retrieving the RakNet protocol version from a BedrockCodec instance.

```java
int rakVersion = codec.getRaknetProtocolVersion();
```

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

### Example BedrockClientInitializer

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of how to extend BedrockClientInitializer and override initSession to configure a client session.

```java
public class MyInitializer extends BedrockClientInitializer {
    @Override
    protected void initSession(BedrockClientSession session) {
        session.setCodec(Bedrock_v429.CODEC);
        session.setPacketHandler(new MyPacketHandler());
        session.setCompression(PacketCompressionAlgorithm.SNAPPY);
    }
}
```

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

### Connecting to a Remote Server

Source: https://github.com/cloudburstmc/protocol/blob/3.0/EXAMPLES.md

Example of how to connect to a remote Bedrock server.

```java
new Bootstrap()
        .channelFactory(RakChannelFactory.client(NioDatagramChannel.class))
        .group(new NioEventLoopGroup())
        .handler(new BedrockClientInitializer() {
            @Override
            protected void initSession(BedrockClientSession session) {
                // Connection established
                // Make sure to set the packet codec version you wish to use before sending out packets
                session.setCodec(Bedrock_v389.CODEC);
                // Remember to set a packet handler so you receive incoming packets
                session.setPacketHandler(new FooBarPacketHandler());
                // Now send packets...
            }
        })
        .connect(new InetSocketAddress("example.com", 19132))
        .syncUninterruptibly();
```

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

### BedrockClientInitializer Usage Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of using BedrockClientInitializer with Bootstrap to establish a client connection.

```java
Channel channel = new Bootstrap()
    .channelFactory(RakChannelFactory.client(NioDatagramChannel.class))
    .group(new NioEventLoopGroup())
    .handler(new BedrockClientInitializer() {
        @Override
        protected void initSession(BedrockClientSession session) {
            session.setCodec(Bedrock_v429.CODEC);
            session.setPacketHandler(new ClientHandler());
            
            // Send login packet
            LoginPacket loginPacket = new LoginPacket();
            loginPacket.setProtocolVersion(429);
            session.sendPacket(loginPacket);
        }
    })
    .connect(new InetSocketAddress("example.com", 19132))
    .syncUninterruptibly()
    .channel();
```

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

### BedrockPong protocolVersion method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the protocol version for BedrockPong.

```java
pong.protocolVersion(Bedrock_v429.CODEC.getProtocolVersion())
```

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

### Client Initializer

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Custom client initializer for Bedrock Edition.

```java
public class MyClientInitializer extends BedrockClientInitializer {
    @Override
    protected void initSession(BedrockClientSession session) {
        session.setCodec(Bedrock_v429.CODEC);
        session.setPacketHandler(new ClientPacketHandler());
        session.setCompression(PacketCompressionAlgorithm.SNAPPY);
    }
}
```

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

### BedrockPong edition method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the edition string for BedrockPong.

```java
pong.edition("MCPE")
```

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

### BedrockPong ipv6Port method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the IPv6 port for BedrockPong.

```java
pong.ipv6Port(19133)
```

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

### Server Initializer

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Custom server initializer for Bedrock Edition.

```java
public class MyServerInitializer extends BedrockServerInitializer {
    @Override
    protected void initSession(BedrockServerSession session) {
        // Server can handle multiple protocol versions initially
        // Set appropriate codec based on LoginPacket
        session.setPacketHandler(new ServerPacketHandler());
    }
}
```

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

### BedrockPong ipv4Port method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the IPv4 port for BedrockPong.

```java
pong.ipv4Port(19132)
```

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

### Server Advertisement

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Configures server advertisement for Bedrock Edition.

```java
BedrockPong pong = new BedrockPong()
    .edition("MCPE")
    .motd("Server Name")
    .protocolVersion(429)
    .gameType("Survival")
    .playerCount(5)
    .maximumPlayerCount(20)
    .ipv4Port(19132)
    .ipv6Port(19133);

new ServerBootstrap()
    .option(RakChannelOption.RAK_ADVERTISEMENT, pong.toByteBuf())
    .childHandler(...)
    .bind(bindAddress)
    .sync();
```

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

### EncryptionUtils createCipher method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of creating AES ciphers for encryption and decryption.

```java
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey key = keyGen.generateKey();

Cipher encryptCipher = EncryptionUtils.createCipher(true, true, key);
Cipher decryptCipher = EncryptionUtils.createCipher(true, false, key);
```

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

### Connection Established Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of initializing a Bedrock client session, setting the codec, packet handler, and sending initial packets.

```java
protected void initSession(BedrockClientSession session) {
    // At this point: channel is active, pipeline is set up
    
    session.setCodec(Bedrock_v429.CODEC);
    session.setPacketHandler(handler);
    
    // Now safe to send packets
    LoginPacket login = new LoginPacket();
    session.sendPacket(login); // Queued for next tick
    session.sendPacketImmediately(login); // Sent immediately
}
```

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

### Writing Items Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec-helper.md

Example of writing item data using BedrockCodecHelper.

```java
ItemData item = new ItemData();
item.setDefinitionId("minecraft:diamond_sword");
item.setCount(1);

ByteBuf buffer = Unpooled.buffer();
helper.writeItem(buffer, item);
```

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

### BedrockPacketType Enumeration Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of accessing BedrockPacketType constants.

```java
BedrockPacketType.LOGIN
BedrockPacketType.PLAY_STATUS
BedrockPacketType.ADD_PLAYER
BedrockPacketType.ADD_ENTITY
// ... etc
```

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

### Best Practice: Install Packet Handler Early

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Highlights the best practice of installing the packet handler early in the session initialization process.

```java
@Override
protected void initSession(BedrockServerSession session) {
    // Install handler before codec switch
    session.setPacketHandler(new MyHandler());
}
```

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

### BedrockPong playerCount method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the current player count for BedrockPong.

```java
pong.playerCount(5)
```

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

### BedrockPong motd method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the message of the day for BedrockPong.

```java
pong.motd("Survival Server - Join us!")
```

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

### BedrockPong gameType method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the game type for BedrockPong.

```java
pong.gameType("Survival")
```

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

### BedrockPong maximumPlayerCount method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of setting the maximum player count for BedrockPong.

```java
pong.maximumPlayerCount(100)
```

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

### Reading Entities Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec-helper.md

Example of reading entity data using BedrockCodecHelper.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockCodecHelper helper = codec.createHelper();
ByteBuf buffer = ...;

// Read entity data
EntityDataMap entityData = new EntityDataMap();
helper.readEntityData(buffer, entityData);

// Access entity properties
Vector3f position = entityData.get(EntityDataTypes.POSITION);
String name = entityData.get(EntityDataTypes.NAMETAG);
```

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

### Setting compression

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/types.md

Example of setting compression.

```java
BedrockPeer peer = ...;
peer.setCompression(PacketCompressionAlgorithm.SNAPPY);
```

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

### PacketSerializeException Catching Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of catching and logging a PacketSerializeException.

```java
try {
    BedrockPacket packet = codec.tryDecode(helper, buffer, packetId);
} catch (PacketSerializeException e) {
    log.error("Failed to decode packet {}: {}", packetId, e.getMessage());
    // Log detailed cause
    log.debug(e.getCause());
}
```

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

### Codec Helper Configuration

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/configuration.md

Configuring item, block, text converter, and encoding settings for the BedrockCodecHelper.

```java
BedrockCodecHelper helper = codec.createHelper();

// Set item definitions
DefinitionRegistry<ItemDefinition> items = ...;
helper.setItemDefinitions(items);

// Set block definitions
DefinitionRegistry<BlockDefinition> blocks = ...;
helper.setBlockDefinitions(blocks);

// Set text converter
TextConverter textConverter = new AdventureTextConverter();
helper.setTextConverter(textConverter);

// Set encoding settings
EncodingSettings settings = ...;
helper.setEncodingSettings(settings);
```

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

### BedrockDisconnectReasons getReason method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of converting RakNet disconnect reasons to Bedrock reasons.

```java
RakDisconnectReason rakReason = RakDisconnectReason.TIMED_OUT;
String bedrockReason = BedrockDisconnectReasons.getReason(rakReason);
// Returns: "disconnect.timeout"
```

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

### Try Decode Example (Overload 1)

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of decoding a Bedrock packet from a ByteBuf using its ID, with a BedrockCodecHelper.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockCodecHelper helper = codec.createHelper();
ByteBuf buffer = ...;
BedrockPacket packet = codec.tryDecode(helper, buffer, 0x01);
```

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

### Compression Configuration

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of configuring packet compression algorithm for a Bedrock server session.

```java
@Override
protected void initSession(BedrockServerSession session) {
    // Available algorithms: ZLIB, SNAPPY, NONE
    session.setCompression(PacketCompressionAlgorithm.SNAPPY);
}
```

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

### Builder Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of constructing a BedrockCodec instance using the builder pattern, specifying protocol version, Minecraft version, a custom helper, and registering a packet.

```java
BedrockCodec codec = BedrockCodec.builder()
    .protocolVersion(429)
    .minecraftVersion("1.16.0")
    .helper(MyCodecHelper::new)
    .registerPacket(LoginPacket::new, new LoginPacketSerializer(), 0x01, PacketRecipient.SERVER)
    .build();
```

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

### Server Packet Handler Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

An example of how to implement a BedrockPacketHandler to process incoming packets for a Bedrock server session.

```java
class MyServerHandler extends BedrockPacketHandler {
    private BedrockServerSession session;
    
    public MyServerHandler(BedrockServerSession session) {
        this.session = session;
    }
    
    @Override
    public PacketSignal handle(LoginPacket packet) {
        String username = packet.getUsername();
        int protocolVersion = packet.getProtocolVersion();
        
        // Validate version
        BedrockCodec codec = SUPPORTED_CODECS.get(protocolVersion);
        if (codec == null) {
            session.disconnect("Your game version is not supported", false);
            return PacketSignal.HANDLED;
        }
        
        session.setCodec(codec);
        
        // Validate username
        if (username.length() > 16 || username.isEmpty()) {
            session.disconnect("Invalid username", false);
            return PacketSignal.HANDLED;
        }
        
        // Check bans
        if (isBanned(username)) {
            session.disconnect("You are banned", false);
            return PacketSignal.HANDLED;
        }
        
        // Accept login
        return PacketSignal.HANDLED;
    }
    
    @Override
    public PacketSignal handle(MovePlayerPacket packet) {
        // Player moved
        return PacketSignal.HANDLED;
    }
    
    @Override
    public void onDisconnect(CharSequence reason) {
        System.out.println("Player disconnected: " + reason);
        // Clean up player resources
    }
}
```

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

### Example Usage of close Method

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-peer.md

Demonstrates how to close the peer connection.

```java
peer.close("Server shutting down");
```

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

### Example Usage

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/adventure-text-converter.md

Demonstrates parsing legacy text, JSON, and translatable components, as well as serializing back to legacy and JSON formats.

```java
AdventureTextConverter converter = new AdventureTextConverter();

// Parse legacy text with colors
BedrockComponent hello = converter.deserialize("§cRed §bBlue §rNormal", false);

// Parse JSON
BedrockComponent json = converter.deserializeJson(
    "{\"text\":\"Server\",\"color\":\"gold\"}",
    false
);

// Translatable with parameters
List<String> params = Arrays.asList("Alice", "Hello");
BedrockComponent msg = converter.deserializeWithArguments(
    "chat.type.text",
    params,
    true
);

// Serialize back
String legacy = converter.serialize("Hello World");
String json = converter.serializeJson("Hello World");
```

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

### Try Decode Example (Overload 2)

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Example of decoding a Bedrock packet from a ByteBuf, including recipient validation to ensure the packet direction matches the expected recipient.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockCodecHelper helper = codec.createHelper();
ByteBuf buffer = ...;
BedrockPacket packet = codec.tryDecode(helper, buffer, 0x01, PacketRecipient.SERVER);
```

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

### Encryption Configuration

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of enabling encryption for a Bedrock server session using AES.

```java
@Override
protected void initSession(BedrockServerSession session) {
    try {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        session.enableEncryption(keyGen.generateKey());
    } catch (NoSuchAlgorithmException e) {
        session.disconnect("Server error");
    }
}
```

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

### BedrockPong toByteBuf method example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of converting a BedrockPong object to a Netty ByteBuf.

```java
BedrockPong pong = new BedrockPong()
    .edition("MCPE")
    .motd("Server")
    .protocolVersion(429)
    .playerCount(0)
    .maximumPlayerCount(20);

new ServerBootstrap()
    .option(RakChannelOption.RAK_ADVERTISEMENT, pong.toByteBuf())
    // ...
```

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

### Create a Server

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Example of creating a Bedrock Edition server using the CloudburstMC Protocol library.

```java
new ServerBootstrap()
    .channelFactory(RakChannelFactory.server(NioDatagramChannel.class))
    .option(RakChannelOption.RAK_ADVERTISEMENT, serverAdvert.toByteBuf())
    .group(new NioEventLoopGroup())
    .childHandler(new BedrockServerInitializer() {
        @Override
        protected void initSession(BedrockServerSession session) {
            session.setPacketHandler(new ServerHandler());
        }
    })
    .bind(new InetSocketAddress("0.0.0.0", 19132))
    .syncUninterruptibly();
```

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

### PacketSerializeException Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of catching a PacketSerializeException during packet deserialization.

```java
try {
    BedrockCodec codec = Bedrock_v429.CODEC;
    BedrockCodecHelper helper = codec.createHelper();
    ByteBuf buffer = Unpooled.wrappedBuffer(new byte[]{1, 2, 3});
    codec.tryDecode(helper, buffer, 0x01);
} catch (PacketSerializeException e) {
    e.printStackTrace();
    // Handle deserialization error
}
```

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

### Kick with Custom Reason Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

Player violation.

```java
// Player violation
session.disconnect("You were kicked: Spam detected", false);

// Client displays: "You were kicked: Spam detected"
```

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

### Create a Client

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Example of creating a Bedrock Edition client using the CloudburstMC Protocol library.

```java
new Bootstrap()
    .channelFactory(RakChannelFactory.client(NioDatagramChannel.class))
    .group(new NioEventLoopGroup())
    .handler(new BedrockClientInitializer() {
        @Override
        protected void initSession(BedrockClientSession session) {
            session.setCodec(Bedrock_v429.CODEC);
            session.setPacketHandler(new MyPacketHandler());
            session.setCompression(PacketCompressionAlgorithm.SNAPPY);
            
            LoginPacket login = new LoginPacket();
            session.sendPacket(login);
        }
    })
    .connect(new InetSocketAddress("example.com", 19132))
    .syncUninterruptibly();
```

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

### IllegalArgumentException (BedrockCodec) Trigger Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example demonstrating an IllegalArgumentException due to invalid codec configuration (negative protocol version).

```java
public <T extends BedrockPacket> Builder registerPacket(...) {
    checkArgument(id >= 0, "id cannot be negative");
    checkArgument(!packets.containsKey(packetClass), "Packet class already registered");
}
```

```java
try {
    BedrockCodec.builder()
        .protocolVersion(-1) // Negative version
        .build();
} catch (IllegalArgumentException e) {
    // Invalid protocol version
}
```

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

### DecoderException (Netty) Trigger Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example demonstrating a DecoderException when an unexpected message type is encountered in the Netty pipeline.

```java
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    if (msg instanceof BedrockPacketWrapper) {
        this.onBedrockPacket((BedrockPacketWrapper) msg);
    } else {
        throw new DecoderException("Unexpected message type: " + msg.getClass().getName());
    }
}
```

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

### Exception in initSession

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example of handling exceptions during session initialization, including logging the error and explicitly closing the session.

```java
@Override
protected void initSession(BedrockClientSession session) {
    try {
        session.setCodec(codec);
        session.setPacketHandler(handler);
    } catch (Exception e) {
        log.error("Failed to initialize session", e);
        session.close("Initialization failed");
    }
}
```

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

### Skin Handling

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec-helper.md

Example of reading and writing player skins using the Bedrock Codec Helper.

```java
SerializedSkin skin = helper.readSkin(buffer);
String geometry = skin.getGeometryName();
byte[] imageData = skin.getSkinData();
helper.writeSkin(buffer, skin);
```

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

### sendPacket Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Queues a packet for transmission to the remote peer. Packets are batched and sent on the next tick (50ms intervals).

```java
BedrockSession session = ...;
LoginPacket loginPacket = new LoginPacket();
loginPacket.setProtocolVersion(429);
session.sendPacket(loginPacket);
```

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

### setCompression Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Sets the compression algorithm for outgoing packets. Only the primary session can set compression. Peer uses the RAK protocol version to configure compression strategy.

```java
BedrockSession session = ...;
session.setCompression(PacketCompressionAlgorithm.SNAPPY);
```

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

### Codec Building Error Handling

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of handling exceptions during codec construction.

```java
try {
    BedrockCodec codec = BedrockCodec.builder()
        .protocolVersion(429)
        .minecraftVersion("1.16.0.0")
        .helper(MyCodecHelper::new)
        .registerPacket(LoginPacket::new, new LoginPacketSerializer(), 0x01, PacketRecipient.SERVER)
        .build();
} catch (IllegalArgumentException e) {
    logger.error("Codec configuration error: {}", e.getMessage());
} catch (NullPointerException e) {
    logger.error("Missing required codec configuration: {}", e.getMessage());
}
```

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

### Graceful Disconnect Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

Player quit normally.

```java
// Player quit normally
session.disconnect("disconnect.disconnected", false);

// Flow:
// 1. DisconnectPacket sent with "disconnect.disconnected"
// 2. Client displays disconnect screen
// 3. After 10 seconds, connection forcibly closed
// 4. onDisconnect(disconnectReason) called on handler
```

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

### NullPointerException Trigger Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example demonstrating a NullPointerException when a null argument is passed to a non-nullable method.

```java
public void setCodec(BedrockCodec codec) {
    Objects.requireNonNull(codec, "codec");
}
```

```java
try {
    session.setPacketHandler(null); // @NonNull parameter
} catch (NullPointerException e) {
    // packetHandler cannot be null
}
```

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

### Client Login Flow

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Example handler for the client login flow.

```java
class ClientHandler extends BedrockPacketHandler {
    private BedrockSession session;
    
    public ClientHandler(BedrockSession session) {
        this.session = session;
    }
    
    @Override
    public PacketSignal handle(PlayStatusPacket packet) {
        if (packet.getStatus() == PlayStatusPacket.Status.LOGIN_SUCCESS) {
            // Now in game
            MovePlayerPacket move = new MovePlayerPacket();
            move.setPosition(new Vector3f(0, 64, 0));
            session.sendPacket(move);
        }
        return PacketSignal.HANDLED;
    }
}
```

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

### Server Version Negotiation

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Example handler for server version negotiation.

```java
class ServerHandler extends BedrockPacketHandler {
    @Override
    public PacketSignal handle(LoginPacket packet) {
        int clientVersion = packet.getProtocolVersion();
        
        BedrockCodec codec = SUPPORTED_VERSIONS.get(clientVersion);
        if (codec == null) {
            session.disconnect("Unsupported version: " + clientVersion);
            return PacketSignal.HANDLED;
        }
        
        session.setCodec(codec);
        session.setCompression(PacketCompressionAlgorithm.SNAPPY);
        
        // Send PlayStatus
        PlayStatusPacket status = new PlayStatusPacket();
        status.setStatus(PlayStatusPacket.Status.LOGIN_SUCCESS);
        session.sendPacket(status);
        
        return PacketSignal.HANDLED;
    }
}
```

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

### enableEncryption Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Enables AES encryption on the session. Only the primary session can enable encryption. Automatically selects CTR mode for protocol versions >= 428.

```java
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(256);
SecretKey key = keyGen.generateKey();
session.enableEncryption(key);
```

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

### getPeer Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Returns the underlying peer that manages this session's network connection.

```java
BedrockPeer peer = session.getPeer();
SocketAddress address = peer.getSocketAddress();
```

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

### Client Default Codec Selection

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example for a client to explicitly set the codec to match the server's requirements.

```java
@Override
protected void initSession(BedrockClientSession session) {
    // Must match server's expected protocol
    session.setCodec(Bedrock_v429.CODEC);
}
```

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

### sendPacketImmediately Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Sends a packet immediately without waiting for the next tick. Flushes the channel immediately after writing.

```java
BedrockSession session = ...;
DisconnectPacket disconnectPacket = new DisconnectPacket();
disconnectPacket.setKickMessage("Server shutting down");
session.sendPacketImmediately(disconnectPacket);
```

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

### getPacketHandler Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Returns the current packet handler that processes incoming packets. Returns null if no handler is set.

```java
BedrockSession session = ...;
BedrockPacketHandler handler = session.getPacketHandler();
```

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

### setPacketHandler Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Sets the packet handler that will receive all incoming packets for this session.

```java
BedrockSession session = ...;
session.setPacketHandler(new MyPacketHandler());
```

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

### disconnect (overload) Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Disconnects with a specific reason. Uses the default hideReason=false.

```java
BedrockSession session = ...;
session.disconnect("disconnect.server_full");
```

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

### disconnect Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Disconnects with the default reason "disconnect.disconnected".

```java
BedrockSession session = ...;
session.disconnect();
```

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

### Disconnect Without Reason Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

Server shutting down.

```java
// Server shutting down
session.disconnect(null, true);

// Flow:
// 1. DisconnectPacket sent with messageSkipped=true
// 2. Client displays "Disconnected"
// 3. After 10 seconds, connection closed
```

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

### BedrockPong Constructor and Builder Pattern

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-utilities.md

Example of creating a BedrockPong object using the builder pattern.

```java
BedrockPong pong = new BedrockPong()
    .edition("MCPE")
    .motd("My Server")
    .protocolVersion(429)
    .gameType("Survival")
    .playerCount(5)
    .maximumPlayerCount(20)
    .ipv4Port(19132);
```

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

### Server Default Codec Selection

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Example for a server to use a compatibility codec initially and switch based on the client's LoginPacket protocol version.

```java
@Override
protected void initSession(BedrockServerSession session) {
    session.setPacketHandler(new PacketHandler() {
        public PacketSignal handle(LoginPacket packet) {
            // Switch codec based on client version
            switch (packet.getProtocolVersion()) {
                case 429: session.setCodec(Bedrock_v429.CODEC); break;
                case 445: session.setCodec(Bedrock_v445.CODEC); break;
                default:
                    session.disconnect("Unsupported protocol");
            }
            return PacketSignal.HANDLED;
        }
    });
}
```

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

### getCodec Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Returns the current codec used for packet serialization/deserialization. Can only be called on the primary session (subClientId == 0).

```java
BedrockSession session = ...;
BedrockCodec codec = session.getCodec();
int protocolVersion = codec.getProtocolVersion();
```

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

### Get Legacy Serializer

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/adventure-text-converter.md

Returns the legacy text serializer used for parsing/formatting legacy-formatted text.

```java
BedrockLegacyTextSerializer serializer = converter.getLegacySerializer();
```

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

### setCodec Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Sets the codec for packet serialization. Only the primary session (subClientId == 0) can set the codec. Typically called during handshake negotiation.

```java
BedrockSession session = ...;
session.setCodec(Bedrock_v429.CODEC);
```

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

### Validation During Login

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

Example of validating login packets and throwing custom exceptions for specific validation failures.

```java
public PacketSignal handle(LoginPacket packet) {
    try {
        validateLoginPacket(packet);
    } catch (InvalidPlayerException e) {
        session.disconnect(e.getDisconnectReason(), false);
        return PacketSignal.HANDLED;
    }
    return PacketSignal.HANDLED;
}

private void validateLoginPacket(LoginPacket packet) throws InvalidPlayerException {
    if (packet.getProtocolVersion() < 291) {
        throw new InvalidPlayerException("Version too old");
    }
    if (players.size() >= MAX_PLAYERS) {
        throw new InvalidPlayerException("Server full");
    }
}
```

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

### Handle Packets

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Example of handling incoming packets and disconnect events in a Bedrock Edition client.

```java
class MyPacketHandler extends BedrockPacketHandler {
    @Override
    public PacketSignal handle(LoginPacket packet) {
        System.out.println("Login: " + packet.getUsername());
        return PacketSignal.HANDLED;
    }
    
    @Override
    public void onDisconnect(CharSequence reason) {
        System.out.println("Disconnected: " + reason);
    }
}
```

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

### Packet Deserialization with Validation

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of handling exceptions during packet decoding, including validation errors.

```java
try {
    BedrockPacket packet = codec.tryDecode(
        helper,
        buffer,
        packetId,
        PacketRecipient.SERVER  // Validate direction
    );
} catch (PacketSerializeException e) {
    logger.error("Malformed packet from {}: {}", address, e.getMessage());
} catch (IllegalArgumentException e) {
    logger.warn("Packet direction violation: {}", e.getMessage());
}
```

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

### initSession Method (abstract)

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Override to configure the session (set codec, packet handler, compression, encryption).

```java
protected abstract void initSession(BedrockSession session);
```

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

### Constructor

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/adventure-text-converter.md

Creates a new instance with default serializers.

```java
public AdventureTextConverter()
```

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

### IllegalArgumentException (Encryption) Trigger Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example demonstrating an IllegalArgumentException when an invalid AES key algorithm is used.

```java
public void enableEncryption(SecretKey secretKey) {
    if (!secretKey.getAlgorithm().equals("AES")) {
        throw new IllegalArgumentException("Invalid key algorithm");
    }
}
```

```java
KeyGenerator keyGen = KeyGenerator.getInstance("RSA"); // Wrong algorithm
SecretKey key = keyGen.generateKey();
try {
    session.enableEncryption(key);
} catch (IllegalArgumentException e) {
    // Key must be AES
}
```

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

### IllegalStateException (BedrockSession) Trigger Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example demonstrating an IllegalStateException being thrown when sending a packet on a closed session.

```java
public void sendPacket(BedrockPacket packet) {
    this.checkForClosed(); // Throws if closed
}
```

```java
session.close("Server shutdown");
try {
    session.sendPacket(packet); // Throws IllegalStateException
} catch (IllegalStateException e) {
    // Session is closed
}
```

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

### isConnected Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Returns true if the session is still connected (not closed).

```java
if (session.isConnected()) {
    session.sendPacket(myPacket);
}
```

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

### Checking packet recipient

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/types.md

Example of checking packet recipient.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockPacketDefinition<?> def = codec.getPacketDefinition(0x01);
if (def.getRecipient() == PacketRecipient.SERVER) {
    // Server-bound packet
}
```

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

### Constructor

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec-helper.md

Creates a new BedrockCodecHelper instance.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockCodecHelper helper = codec.createHelper();
```

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

### getSocketAddress Example

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-session.md

Returns the remote socket address for this session's connection.

```java
SocketAddress address = session.getSocketAddress();
System.out.println("Connected to: " + address);
```

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

### BedrockComponent Constructor

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/adventure-text-converter.md

Wraps an Adventure Component.

```java
public BedrockComponent(Component component)
```

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

### Enable Packet Logging

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

How to enable packet logging on a session.

```java
session.setLogging(true); // Logs at TRACE level
```

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

### BedrockChannelInitializer Class

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Abstract base class for both client and server initializers. Sets up the Netty pipeline with codec, compression, and encryption handlers.

```java
public abstract class BedrockChannelInitializer extends ChannelInitializer<Channel>
```

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

### Reading Complex Arrays

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec-helper.md

Example of reading a list of item stacks using the Bedrock Codec Helper.

```java
// Read list of item stacks
List<ItemData> itemStacks = new ArrayList<>();
helper.readArray(buffer, itemStacks, 100, (buf, h) -> h.readItem(buf));
```

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

### Full Server Connection Flow

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-server-session.md

Illustrates the typical lifecycle of a Bedrock server connection, from initialization to disconnection.

```java
new ServerBootstrap()
    .childHandler(new BedrockServerInitializer() {
        @Override
        protected void initSession(BedrockServerSession session) {
            session.setPacketHandler(new ServerHandler(session));
            // Codec not set yet — wait for LoginPacket
        }
    })
    .bind(address)
    .sync();

// When client connects:
// 1. Channel activates
// 2. initSession() called
// 3. LoginPacket arrives
// 4. Handler validates and sets codec
// 5. PlayStatusPacket sent
// 6. Game packets exchanged
// 7. Client or server calls disconnect()
// 8. DisconnectPacket sent
// 9. After timeout: connection closed
// 10. onDisconnect() called
```

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

### Best Practice: Set Codec Before Sending Packets

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Reinforces the best practice of setting the codec before sending any packets to ensure proper encoding.

```java
@Override
protected void initSession(BedrockClientSession session) {
    session.setCodec(Bedrock_v429.CODEC); // First
    session.setPacketHandler(handler);
    LoginPacket packet = new LoginPacket();
    session.sendPacket(packet); // Now safe
}
```

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

### Gradle

Source: https://github.com/cloudburstmc/protocol/blob/3.0/README.md

Add the CloudburstMC Protocol library to your Gradle project.

```kotlin
repositories {
    maven("https://repo.opencollab.dev/maven-snapshots/")
}

dependencies {
    implementation("org.cloudburstmc.protocol:bedrock-connection:3.0.0.Beta6-SNAPSHOT")
}
```

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

### Packet Serialization Error Handling

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/errors.md

Example of handling PacketSerializeException during packet encoding.

```java
BedrockCodec codec = Bedrock_v429.CODEC;
BedrockCodecHelper helper = codec.createHelper();

try {
    LoginPacket packet = new LoginPacket();
    // Populate packet fields
    ByteBuf buffer = Unpooled.buffer();
    codec.tryEncode(helper, buffer, packet);
} catch (PacketSerializeException e) {
    logger.error("Failed to serialize login packet", e);
}
```

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

### Helper Method

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/bedrock-codec.md

Sets the helper factory for creating BedrockCodecHelper instances. This is required before building the codec.

```java
public Builder helper(@NonNull Supplier<BedrockCodecHelper> helperFactory)
```

```java
codec.toBuilder()
    .helper(MyCodecHelper::new)
    .build()
```

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

### initChannel Method

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Called automatically by Netty. Sets up pipeline handlers and invokes initSession() when ready.

```java
protected final void initChannel(Channel channel) throws Exception
```

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

### BedrockClientInitializer Class

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Initializer for client-side connections. Creates BedrockClientSession on channel activation.

```java
public abstract class BedrockClientInitializer extends BedrockChannelInitializer
```

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

### Handle Encryption Errors

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/api-reference/netty-initializers.md

Initializes AES encryption for a Bedrock server session and handles potential exceptions.

```java
    @Override
    protected void initSession(BedrockServerSession session) {
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("AES");
            keyGen.init(256);
            session.enableEncryption(keyGen.generateKey());
        } catch (NoSuchAlgorithmException e) {
            log.error("AES not available", e);
            session.disconnect("Server error");
        } catch (IllegalStateException e) {
            log.warn("Encryption already enabled: {}", e.getMessage());
        }
    }
```

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

### Text Handling

Source: https://github.com/cloudburstmc/protocol/blob/3.0/_autodocs/README.md

Examples of handling text formatting, including legacy and JSON formats, and translatable messages with arguments.

```java
AdventureTextConverter textConverter = new AdventureTextConverter();

// Parse legacy format
BedrockComponent hello = textConverter.deserialize("§cHello §bWorld", false);

// Parse JSON
BedrockComponent json = textConverter.deserializeJson(
    "{\"text\":\"Server\",\"color\":\"gold\"}",
    false
);

// Translatable with arguments
List<String> args = Arrays.asList("Alice", "Hello");
BedrockComponent msg = textConverter.deserializeWithArguments(
    "chat.type.text",
    args,
    true
);
```