Packet Events Pledge Test

PacketEventsTest.java

package org.example;

import com.github.retrooper.packetevents.PacketEvents;
import com.github.retrooper.packetevents.event.SimplePacketListenerAbstract;
import com.github.retrooper.packetevents.event.simple.PacketPlayReceiveEvent;
import com.github.retrooper.packetevents.event.simple.PacketPlaySendEvent;
import com.github.retrooper.packetevents.protocol.packettype.PacketType;
import com.github.retrooper.packetevents.settings.PacketEventsSettings;
import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientPlayerPositionAndRotation;
import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerPlayerPositionAndLook;
import dev.thomazz.pledge.api.PacketFrame;
import dev.thomazz.pledge.api.Pledge;
import dev.thomazz.pledge.api.event.ActivateHandlerEvent;
import dev.thomazz.pledge.api.event.PacketFrameCreateEvent;
import dev.thomazz.pledge.api.event.PacketFrameErrorEvent;
import dev.thomazz.pledge.api.event.PacketFrameReceiveEvent;
import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.util.Vector;

import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;

public class PacketEventsTest extends JavaPlugin implements Listener {
    private final Map<PacketFrame, Queue<Vector>> teleportLocations = new HashMap<>();
    private final Queue<Vector> receiving = new ArrayDeque<>();
    private Pledge pledge;

    @Override
    public void onEnable() {
        this.pledge = Pledge.build().start(this);
        this.getServer().getPluginManager().registerEvents(this, this);

        PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this, new PacketEventsSettings().checkForUpdates(false)));
        PacketEvents.getAPI().load();
        PacketEvents.getAPI().init();

        PacketEvents.getAPI().getEventManager().registerListener(new SimplePacketListenerAbstract() {
            @Override
            public void onPacketPlaySend(PacketPlaySendEvent event) {
                if (event.getPacketType() == PacketType.Play.Server.PLAYER_POSITION_AND_LOOK) {
                    WrapperPlayServerPlayerPositionAndLook wrapper = new WrapperPlayServerPlayerPositionAndLook(event);
                    Vector vector = new Vector(wrapper.getX(), wrapper.getY(), wrapper.getZ());

                    Player player = Bukkit.getPlayer(event.getUser().getUUID());
                    if (wrapper.getRelativeFlags().getMask() == 0) {
                        Queue<Vector> receiving = PacketEventsTest.this.teleportLocations.computeIfAbsent(
                            PacketEventsTest.this.pledge.getOrCreateFrame(player), key -> new ArrayDeque<>()
                        );

                        receiving.add(vector);
                        Bukkit.broadcastMessage("server teleport");
                    }
                }
            }

            @Override
            public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
                if (event.getPacketType() == PacketType.Play.Client.PLAYER_POSITION_AND_ROTATION) {
                    WrapperPlayClientPlayerPositionAndRotation wrapper = new WrapperPlayClientPlayerPositionAndRotation(event);
                    Vector result = new Vector(wrapper.getPosition().x, wrapper.getPosition().y, wrapper.getPosition().z);

                    Vector receive = PacketEventsTest.this.receiving.peek();
                    if (receive != null) {
                        if (receive.equals(result) && !wrapper.isOnGround()) {
                            String receiveText = String.format("x: %.3f y:%.3f z:%.3f", receive.getX(), receive.getY(), receive.getZ());
                            Bukkit.broadcastMessage(ChatColor.GREEN + "match: " + receiveText);
                            PacketEventsTest.this.receiving.poll();
                        }
                    }
                }
            }
        });
    }

    @Override
    public void onDisable() {
        this.pledge.destroy();
    }

    @EventHandler
    public void onHandler(ActivateHandlerEvent event) {
        Bukkit.broadcastMessage("activate handler");
    }

    @EventHandler
    public void onError(PacketFrameErrorEvent event) {
        Bukkit.broadcastMessage(ChatColor.RED + "ERROR:" + event.getType());
    }

    @EventHandler
    public void onFrameReceive(PacketFrameReceiveEvent event) {
        switch (event.getType()) {
            case RECEIVE_START:
                Queue<Vector> receiving = this.teleportLocations.remove(event.getFrame());
                if (receiving != null) {
                    this.receiving.addAll(receiving);
                    Bukkit.broadcastMessage("receive frame start");
                }
                break;
            case RECEIVE_END:
                if (!this.receiving.isEmpty()) {
                    Bukkit.broadcastMessage(ChatColor.RED + "unconsumed teleports!");
                }

                this.receiving.clear();
                Bukkit.broadcastMessage("receive frame end");
                break;
        }
    }

    @EventHandler
    public void onFrameCreate(PacketFrameCreateEvent event) {
        Bukkit.broadcastMessage("create frame");
    }
}