PacketEvents

https://docs.packetevents.com
Admin
PacketEvents is a Minecraft Java Edition protocol library built on Netty, designed for efficient...
Tokens:8,527
Snippets:82
Trust Score:4.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Integrating PacketEvents into a Bukkit Plugin

Source: https://docs.packetevents.com/setup-when-bundling/tweaking-packetevents

Full implementation example showing the lifecycle of PacketEvents within a Bukkit plugin, including configuration, loading, initialization, and termination.

```java
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.util.TimeStampMode;
import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
import org.bukkit.plugin.java.JavaPlugin;


public class YourBukkitPlugin extends JavaPlugin {


    @Override
    public void onLoad() {
        // Create our PacketEvents instance
        PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));


        // Configure PacketEvents settings
        PacketEvents.getAPI().getSettings().checkForUpdates(true).debug(false)
                .timeStampMode(TimeStampMode.MILLIS);


        // Load PacketEvents
        PacketEvents.getAPI().load();


        /*
         * MORE CODE MAY APPEAR HERE (such as registering listeners)
         */
    }


    @Override
    public void onEnable() {
        // Initialize the library!
        PacketEvents.getAPI().init();
    }


    @Override
    public void onDisable() {
        // Clean-up process
        PacketEvents.getAPI().terminate();
    }
}
```

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

### Example Listener with Fake Armor Stand

Source: https://docs.packetevents.com/processing-and-sending/advanced-packetevents-example-combining-our-knowledge

This Java class implements PacketListener to handle user logins and packet receives. It spawns a fake Armor Stand for each user and tracks their clicks on it.

```java
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketReceiveEvent;
import com.github.retrooper.packetevents.event.UserLoginEvent;
import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.protocol.player.User;
import com.github.retrooper.packetevents.protocol.world.Location;
import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientAttack;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerSpawnEntity;
import io.github.retrooper.packetevents.util.SpigotConversionUtil;
import io.github.retrooper.packetevents.util.SpigotReflectionUtil;
import org.bukkit.entity.Player;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;


import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;


@NullMarked
public class ExampleListener implements PacketListener {


    private @Nullable FakeArmorStand fakeArmorStand = null;


    @Override
    public void onUserLogin(UserLoginEvent event) {
        User user = event.getUser();
        Player player = event.getPlayer();


        // Create the Armor Stand (if we haven't already)
        if (this.fakeArmorStand == null) {
            // Generate a random UUID
            UUID uuid = UUID.randomUUID();
            // Generate an Entity ID
            int entityId = SpigotReflectionUtil.generateEntityId();


            this.fakeArmorStand = new FakeArmorStand(uuid, entityId);
        }


        // Spawn the Armor Stand at the user's current location
        Location spawnLocation = SpigotConversionUtil.fromBukkitLocation(player.getLocation());
        this.fakeArmorStand.spawn(user, spawnLocation);
    }


    @Override
    public void onPacketReceive(PacketReceiveEvent event) {
        User user = event.getUser();
        int entityId = -1; // Not an attack or interaction packet if entityId remains -1
        if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
            // They interacted with an entity.
            WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
            // Retrieve that entity's ID
            entityId = packet.getEntityId();
        }
        else if (event.getPacketType() == PacketType.Play.Client.ATTACK) {
            // They attacked the Armor Stand
            WrapperPlayClientAttack attack = new WrapperPlayClientAttack(event);
            entityId = attack.getEntityId();
        }




        // Check if the client interacted with (or attacked) the Armor Stand
        if (entityId != -1 && this.fakeArmorStand != null && entityId == this.fakeArmorStand.entityId) {
            // Increment their clicks
            int clicks = this.fakeArmorStand.clicks.getOrDefault(user.getUUID(), 0) + 1;
            this.fakeArmorStand.clicks.put(user.getUUID(), clicks);
            user.sendMessage("You now have " + clicks + " clicks on the Armor Stand!");
        }
    }


    private static class FakeArmorStand {


        private final int entityId;
        private final UUID uuid;


        // track their clicks
        private final Map<UUID, Integer> clicks = new ConcurrentHashMap<>();


        public FakeArmorStand(UUID uuid, int entityId) {
            this.uuid = uuid;
            this.entityId = entityId;
        }


        public void spawn(User user, Location location) {
            WrapperPlayServerSpawnEntity packet = new WrapperPlayServerSpawnEntity(
                    this.entityId,
                    this.uuid,
                    EntityTypes.ARMOR_STAND,
                    location,
                    location.getYaw(), // Head yaw
                    0, // No additional data
                    null // We won't specify any initial velocity
            );
            user.sendPacket(packet);
        }
    }
}

```

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

### Initialize and Terminate PacketEvents on Spigot

Source: https://docs.packetevents.com/setup-when-bundling/master

This example demonstrates the proper initialization and termination of PacketEvents within a Bukkit-based plugin. It shows the usage of `onLoad`, `onEnable`, and `onDisable` methods for loading, initializing, and terminating the PacketEvents API.

```java
import com.github.retrooper.packetevents.PacketEvents;
import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
import org.bukkit.plugin.java.JavaPlugin;


public class YourBukkitPlugin extends JavaPlugin {


    @Override
    public void onLoad() {
        // Building, loading, and initializing the library is necessary when bundling.
        PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));
        PacketEvents.getAPI().load();


        /*
         * MORE CODE MAY APPEAR HERE (such as registering listeners)
         */
    }


    @Override
    public void onEnable() {
        // Initialize the library!
        PacketEvents.getAPI().init();
    }


    @Override
    public void onDisable() {
        // Clean-up process
        PacketEvents.getAPI().terminate();
    }
}
```

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

### Initialize and Terminate PacketEvents on Velocity

Source: https://docs.packetevents.com/setup-when-bundling/master

This example shows how to initialize and terminate PacketEvents for a Velocity-based proxy. It utilizes Velocity's event system for proxy initialization and shutdown to manage the PacketEvents API lifecycle.

```java
import com.github.retrooper.packetevents.PacketEvents;
import com.google.common.eventbus.Subscribe;
import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
import com.velocitypowered.api.plugin.Plugin;
import com.velocitypowered.api.plugin.PluginContainer;
import com.velocitypowered.api.plugin.annotation.DataDirectory;
import com.velocitypowered.api.proxy.ProxyServer;
import io.github.retrooper.packetevents.velocity.factory.VelocityPacketEventsBuilder;
import jakarta.inject.Inject;
import org.slf4j.Logger;


import java.nio.file.Path;


@Plugin(...)
public class YourVelocityPlugin {


    private final ProxyServer server;
    private final Logger logger;
    private final PluginContainer pluginContainer;
    private final Path dataDirectory;


    @Inject
    public YourVelocityPlugin(
            final ProxyServer server,
            final Logger logger,
            final PluginContainer pluginContainer,
            final @DataDirectory Path dataDirectory
    ) {
        this.server = server;
        this.logger = logger;
        this.pluginContainer = pluginContainer;
        this.dataDirectory = dataDirectory;
    }


    @Subscribe
    public void onProxyInitialize(final ProxyInitializeEvent event) {
        PacketEvents.setAPI(VelocityPacketEventsBuilder.build(this.server, this.pluginContainer, this.logger, this.dataDirectory));
        PacketEvents.getAPI().load();


        /*
         * MORE CODE MAY APPEAR HERE (such as registering listeners)
         */
        PacketEvents.getAPI().init();
    }


    @Subscribe
    public void onProxyShutdown(ProxyShutdownEvent event) {
        PacketEvents.getAPI().terminate();
    }
}
```

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

### Configure Gradle Buildscript

Source: https://docs.packetevents.com/introduction/development-setup

Add the CodeMC repositories and the PacketEvents dependency to your build.gradle file.

```groovy
repositories {
    maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
    maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
    // your other repositories...
}


dependencies {
    compileOnly("com.github.retrooper:packetevents-~~INSERT_MODULE_HERE~~:2.13.0")
    // your other dependencies...
}
```

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

### Configure Maven Buildscript

Source: https://docs.packetevents.com/introduction/development-setup

Add the CodeMC repositories and the PacketEvents dependency to your pom.xml file.

```xml
<repositories>
    <repository>
        <id>codemc-releases</id>
        <url>https://repo.codemc.io/repository/maven-releases/</url>
    </repository>
    <repository>
        <id>codemc-snapshots</id>
        <url>https://repo.codemc.io/repository/maven-snapshots/</url>
    </repository>
    <!-- your other repositories... -->
</repositories>
    <!-- ... -->
<dependencies>
<dependency>
    <groupId>com.github.retrooper</groupId>
    <artifactId>packetevents-~~INSERT_MODULE_HERE~~</artifactId>
    <version>2.13.0</version>
    <scope>provided</scope>
</dependency>
<!-- your other dependencies... -->
</dependencies>
```

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

### Configure Maven and Gradle for PacketEvents

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Add the necessary repositories and dependencies to your build configuration to include PacketEvents.

```xml
<repositories>
    <repository>
        <id>codemc-releases</id>
        <url>https://repo.codemc.io/repository/maven-releases/</url>
    </repository>
    <repository>
        <id>codemc-snapshots</id>
        <url>https://repo.codemc.io/repository/maven-snapshots/</url>
    </repository>
    <!-- your other repositories... -->
</repositories>
    <!-- ... -->
<dependencies>
<dependency>
    <groupId>com.github.retrooper</groupId>
    <artifactId>packetevents-~~INSERT_MODULE_HERE~~</artifactId>
    <version>2.13.0</version>
    <scope>compile</scope>
</dependency>
<!-- your other dependencies... -->
</dependencies>
```

```gradle
repositories {
    maven { url = uri("https://repo.codemc.io/repository/maven-releases/") }
    maven { url = uri("https://repo.codemc.io/repository/maven-snapshots/") }
    // your other repositories...
}


dependencies {
    implementation("com.github.retrooper:packetevents-~~INSERT_MODULE_HERE~~:2.13.0")
    // your other dependencies...
}
```

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

### Registering a Packet Listener (Bundled)

Source: https://docs.packetevents.com/processing-and-sending/master

This snippet is for registering a packet listener when PacketEvents is bundled or shaded within your plugin. It includes the necessary steps for building, loading, initializing, and terminating the library.

```java
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.PacketListenerPriority;
import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
import org.bukkit.plugin.java.JavaPlugin;


public class YourBukkitPlugin extends JavaPlugin {


    @Override
    public void onLoad() {
        // Building, loading, and initializing the library is necessary when bundling (or shading).
        PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));
        PacketEvents.getAPI().load();


        // Register our listener
        PacketEvents.getAPI().getEventManager().registerListener(new ExampleListener(),
                PacketListenerPriority.NORMAL);
    }


    @Override
    public void onEnable() {
        // Initialize the library!
        PacketEvents.getAPI().init();
    }


    @Override
    public void onDisable() {
        // Clean-up process
        PacketEvents.getAPI().terminate();
    }
}
```

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

### Simulate Animation Packet using BungeeCord ProxiedPlayer

Source: https://docs.packetevents.com/sending-and-simulating-packets

Simulates an Animation (Swing Arm) packet using a BungeeCord ProxiedPlayer object. This method is suitable for proxy environments.

```java
ProxiedPlayer player = ...;
WrapperPlayClientAnimation packet = new WrapperPlayClientAnimation(
    InteractionHand.MAIN_HAND);
// Finally, fake the incoming packet.
PacketEvents.getAPI().getPlayerManager().receivePacket(player, packet);
```

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

### Registering a Packet Listener (Normal)

Source: https://docs.packetevents.com/processing-and-sending/master

Use this snippet to register a packet listener when PacketEvents is not bundled with your plugin. Ensure the ExampleListener class is defined elsewhere.

```java
import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.EventManager;
import com.github.retrooper.packetevents.event.PacketListenerPriority;
import org.bukkit.plugin.java.JavaPlugin;


public class YourBukkitPlugin extends JavaPlugin {


    @Override
    public void onLoad() {
        EventManager events = PacketEvents.getAPI().getEventManager();
        events.registerListener(new ExampleListener(), PacketListenerPriority.NORMAL);
    }
}
```

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

### Relocate PacketEvents with Gradle Shadow

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Use the Shadow plugin in Gradle to relocate dependencies within the shadowJar task.

```kotlin
plugins {
    id("com.gradleup.shadow") version "9.3.1"
    // your other plugins...
}


tasks.shadowJar {
    relocate("com.github.retrooper", "~~my.domain.myplugin~~.libs.packetevents")
    relocate("io.github.retrooper", "~~my.domain.myplugin~~.libs.packetevents")
    relocate("net.kyori", "~~my.domain.myplugin~~.libs.kyori")
    relocate("com.google.gson", "~~my.domain.myplugin~~.libs.gson")
}
```

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

### Define Soft Dependencies in plugin.yml

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Configure soft dependencies for Bukkit-based platforms to ensure PacketEvents loads after required network-related plugins.

```yaml
softdepend:
- ProtocolLib
- ProtocolSupport
- ViaVersion
- ViaBackwards
- ViaRewind
- Geyser-Spigot
```

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

### Minimize PacketEvents with Gradle Shadow

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Enable minimization in the shadowJar task to reduce distribution size.

```kotlin
tasks.shadowJar {
    minimize()
}
```

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

### Minimize PacketEvents with Maven Shade

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Set minimizeJar to true in the Maven Shade configuration to discard unused classes.

```xml
    <goal>shade</goal>
</goals>
<configuration>
    <minimizeJar>false</minimizeJar>
    <minimizeJar>true</minimizeJar>
    <createDependencyReducedPom>false</createDependencyReducedPom>
    <relocations>
        <relocation>
```

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

### Simulate Animation Packet using Bukkit/Velocity Player

Source: https://docs.packetevents.com/sending-and-simulating-packets

Simulates an Animation (Swing Arm) packet using a Bukkit or Velocity Player object. This is the recommended approach for servers running on Bukkit or Velocity.

```java
Player player = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayClientAnimation packet = new WrapperPlayClientAnimation(
    InteractionHand.MAIN_HAND);
// Finally, fake the incoming packet.
PacketEvents.getAPI().getPlayerManager().receivePacket(player, packet);
```

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

### Relocate PacketEvents with Maven Shade

Source: https://docs.packetevents.com/setup-when-bundling/a-beginners-guide-to-bundling

Configure the Maven Shade plugin to relocate specific packages to avoid version conflicts.

```xml
<plugins>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <version>3.6.1</version>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>shade</goal>
                </goals>
                <configuration>
                    <minimizeJar>false</minimizeJar>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <relocations>
                        <relocation>
                            <pattern>com.github.retrooper</pattern>
                            <shadedPattern>~~my.domain.myplugin~~.libs.packetevents</shadedPattern>
                        </relocation>
                        <relocation>
                            <pattern>io.github.retrooper</pattern>
                            <shadedPattern>~~my.domain.myplugin~~.libs.packetevents</shadedPattern>
                        </relocation>
                        <relocation>
                            <pattern>net.kyori</pattern>
                            <shadedPattern>~~my.domain.myplugin~~.libs.kyori</shadedPattern>
                        </relocation>
                        <relocation>
                            <pattern>com.google.gson</pattern>
                            <shadedPattern>~~my.domain.myplugin~~.libs.gson</shadedPattern>
                        </relocation>
                    </relocations>
                </configuration>
            </execution>
        </executions>
    </plugin>
    <!-- your other plugins... -->
</plugins>
```

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

### Accessing and Modifying PacketEvents Settings

Source: https://docs.packetevents.com/setup-when-bundling/tweaking-packetevents

Settings should be configured prior to loading the PacketEvents instance. Multiple settings can be modified using a fluent API approach.

```java
PacketEventsSettings settings = instance.getSettings();
// e.g. disable checking for updates
settings.checkForUpdates(false);
// you can also modify multiple settings at once:
settings.checkForUpdates(true).debug(false).timeStampMode(TimeStampMode.MILLIS);
```

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

### Convert PacketEvents ItemStack to Bukkit ItemStack

Source: https://docs.packetevents.com/introduction/a-developers-introduction

Use SpigotConversionUtil.toBukkitItemStack to convert a PacketEvents ItemStack to a Bukkit ItemStack. Ensure necessary imports are present.

```java
import com.github.retrooper.packetevents.protocol.item.ItemStack;
import io.github.retrooper.packetevents.util.SpigotConversionUtil;


// Here's your PacketEvents ItemStack
ItemStack packetEventsItemStack = ...;


// Here's your converted Bukkit ItemStack
org.bukkit.inventory.ItemStack bukkitItemStack = SpigotConversionUtil.toBukkitItemStack(packetEventsItemStack);
```

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

### Simulate Animation Packet using PacketEvents User

Source: https://docs.packetevents.com/sending-and-simulating-packets

Simulates an Animation (Swing Arm) packet using the PacketEvents cross-platform user. This method is useful when you have direct access to a PacketEvents User object.

```java
User user = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayClientAnimation packet = new WrapperPlayClientAnimation(
    InteractionHand.MAIN_HAND);
// Finally, fake the incoming packet.
user.receivePacket(packet);
```

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

### Convert Bukkit ItemStack to PacketEvents ItemStack

Source: https://docs.packetevents.com/introduction/a-developers-introduction

Use SpigotConversionUtil.fromBukkitItemStack to convert a Bukkit ItemStack to a PacketEvents ItemStack. Ensure necessary imports are present.

```java
import com.github.retrooper.packetevents.protocol.item.ItemStack;
import io.github.retrooper.packetevents.util.SpigotConversionUtil;


// Here's your Bukkit ItemStack
org.bukkit.inventory.ItemStack bukkitItemStack = ...;


// Here's your converted PacketEvents ItemStack
ItemStack packetEventsItemStack = SpigotConversionUtil.fromBukkitItemStack(bukkitItemStack);
```

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

### Convert Entity ID to Bukkit Entity

Source: https://docs.packetevents.com/introduction/a-developers-introduction

Leverage SpigotConversionUtil.getEntityById to convert a received Entity ID into a Bukkit Entity. Providing a World object can improve search performance.

```java
int entityId = ...; // Received an Entity ID from PacketEvents


World world = null; // Can be null! (Providing a world can allow for faster search time)
// Retrieve Bukkit Entity
Entity bukkitEntity = SpigotConversionUtil.getEntityById(world, entityId);


// Now, we can access some data using Bukkit.
String entityName = bukkitEntity.getName();
```

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

### Simulate Packet Silently

Source: https://docs.packetevents.com/sending-and-simulating-packets

Use this method to simulate receiving a packet from a user without triggering their packet listeners. This is useful for testing or faking incoming data.

```java
User user = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayClientAnimation packet = new WrapperPlayClientAnimation(
    InteractionHand.MAIN_HAND);
// Finally, fake the incoming packet without triggering their listeners.
user.receivePacketSilently(packet);
```

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

### Marking Packet for Re-encoding

Source: https://docs.packetevents.com/processing-and-sending/master

When modifying a packet, it is crucial to call `event.markForReEncode(true)` to ensure that PacketEvents properly re-encodes the modified packet before sending it.

```java
event.markForReEncode(true);
```

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

### Send Update Health Packet via BungeeCord ProxiedPlayer

Source: https://docs.packetevents.com/sending-and-simulating-packets

Use this snippet to send an Update Health packet to a BungeeCord ProxiedPlayer. It leverages the PacketEvents API for cross-server packet management.

```java
ProxiedPlayer player = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(
    20f, // Health (0-20)
    20, // Food (0-20)
    5f); // Food saturation (0-5)
// Finally, send it to the player.
PacketEvents.getAPI().getPlayerManager().sendPacket(player, packet);
```

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

### Send Packet Silently

Source: https://docs.packetevents.com/sending-and-simulating-packets

Use this method to send a packet to a user without triggering their packet listeners. Ensure the packet object is correctly instantiated with all necessary data.

```java
User user = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(
    20d, // Health (0-20)
    20, // Food (0-20)
    5d); // Food saturation (0-5)
// Finally, send it to the user without triggering their listeners.
user.sendPacketSilently(packet);
```

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

### Intercepting Player Attack and Interact Entity Packets

Source: https://docs.packetevents.com/processing-and-sending/master

This Java code snippet intercepts 'Attack' and 'Interact Entity' packets. It supports both modern and legacy Minecraft versions. The code sends a message to the player when an entity is attacked, including entity details via hover text.

```java
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketReceiveEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.protocol.player.User;
import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientAttack;
import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity;
import io.github.retrooper.packetevents.util.SpigotConversionUtil;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.HoverEvent;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextDecoration;
import org.bukkit.entity.Entity;
import org.jspecify.annotations.NullMarked;


@NullMarked
public class ExampleListener implements PacketListener {


    @Override
    public void onPacketReceive(PacketReceiveEvent event) {
        User user = event.getUser();
        // This code supports Minecraft 26.1 and newer.
        if (event.getPacketType() == PacketType.Play.Client.ATTACK) {
            WrapperPlayClientAttack attackPacket = new WrapperPlayClientAttack(event);
            // Execute our code here
            doSomething(user, attackPacket.getEntityId());
        }
        // This code works on Minecraft 1.8-1.21.11.
        else if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) {
            WrapperPlayClientInteractEntity packet = new WrapperPlayClientInteractEntity(event);
            WrapperPlayClientInteractEntity.InteractAction action = packet.getAction();
            // Check if the action is an ATTACK and not a right click
            if (action == WrapperPlayClientInteractEntity.InteractAction.ATTACK) {
                // Execute our code here
                doSomething(user, packet.getEntityId());
            }
        }
    }


    public void doSomething(User user, int entityID) {
        // Find the Bukkit entity that was attacked (WARNING: unsafe method!)
        Entity entity = SpigotConversionUtil.getEntityById(null, entityID);


        // Create a chat component with the Adventure API
        Component message = Component.text("You attacked an entity.")
            .hoverEvent(HoverEvent.hoverEvent(
                HoverEvent.Action.SHOW_TEXT,
                Component.text("Entity Name: " + entity.getName())
                .color(NamedTextColor.GREEN)
                .decorate(TextDecoration.BOLD)
                .decorate(TextDecoration.ITALIC)));


        // Send a message to the user using PacketEvents
        user.sendMessage(message);


    }
}
```

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

### Send Update Health Packet via Bukkit/Velocity Player

Source: https://docs.packetevents.com/sending-and-simulating-packets

This code sends an Update Health packet to a Bukkit or Velocity player. It utilizes the PacketEvents API to manage packet delivery to the player.

```java
Player player = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(
    20f, // Health (0-20)
    20, // Food (0-20)
    5f); // Food saturation (0-5)
// Finally, send it to the player.
PacketEvents.getAPI().getPlayerManager().sendPacket(player, packet);
```

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

### Modifying Minecraft Update Health Packet

Source: https://docs.packetevents.com/processing-and-sending/master

This snippet demonstrates how to modify the 'Update Health' packet to send a custom health value to the client. Remember to mark the event for re-encoding after modification.

```java
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerUpdateHealth;
import org.jspecify.annotations.NullMarked;


@NullMarked
public class ExampleListener implements PacketListener {


    @Override
    public void onPacketSend(PacketSendEvent event) {
        if (event.getPacketType() == PacketType.Play.Server.UPDATE_HEALTH) {
            // health of the connected player was updated!
            WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(event);
            packet.setHealth(15.0F); // range depends on maximum health of entity
            event.markForReEncode(true); // tells packetevents to modify the packet
        }
    }
}
```

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

### Send Update Health Packet via PacketEvents User

Source: https://docs.packetevents.com/sending-and-simulating-packets

Use this snippet to send an Update Health packet to a user when using the PacketEvents cross-platform user API. Ensure you have the correct user object and packet wrapper.

```java
User user = ...;
// Create the packet (feed it all the data it needs).
WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(
    20f, // Health (0-20)
    20, // Food (0-20)
    5f); // Food saturation (0-5)
// Finally, send it to the user.
user.sendPacket(packet);
```

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

### Intercepting Minecraft Update Health Packet

Source: https://docs.packetevents.com/processing-and-sending/master

This snippet shows how to intercept the 'Update Health' packet sent from the server to the client. It checks the packet type and extracts the current health value.

```java
import com.github.retrooper.packetevents.event.PacketListener;
import com.github.retrooper.packetevents.event.PacketSendEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerUpdateHealth;
import org.jspecify.annotations.NullMarked;


@NullMarked
public class ExampleListener implements PacketListener {


    @Override
    public void onPacketSend(PacketSendEvent event) {
        if (event.getPacketType() == PacketType.Play.Server.UPDATE_HEALTH) {
            // health of the connected player was updated!
            WrapperPlayServerUpdateHealth packet = new WrapperPlayServerUpdateHealth(event);
            float health = packet.getHealth();
        }
    }
}
```
Tokens:
Raw