Examples with PacketType com.bergerkiller.bukkit.common.protocol.PacketType used on opensource projects

Example 1 with PacketType

use of com.bergerkiller.bukkit.common.protocol.PacketType in project BKCommonLib by bergerhealer.

the class VehicleMountHandler_BaseImpl method handlePacketSend.

/**
 * Call this to handle a relevant packet that was sent from the server to the client
 *
 * @param packet The packet sent
 */
public final void handlePacketSend(CommonPacket packet) {
    synchronizeAndQueuePackets(() -> {
        // Refresh player dimension if none could be set (temporary player, pre-join)
        if (this._playerDimension == null) {
            this._playerDimension = PlayerUtil.getPlayerDimension(this._player);
        }
        // Event handler for further implementations
        onPacketSend(packet);
        // Handle packets
        PacketType type = packet.getType();
        if (type == PacketType.OUT_ENTITY_DESTROY) {
            PacketPlayOutEntityDestroyHandle dp = PacketPlayOutEntityDestroyHandle.createHandle(packet.getHandle());
            if (dp.hasMultipleEntityIds()) {
                for (int entityId : dp.getEntityIds()) {
                    handleDespawn(entityId);
                }
            } else {
                handleDespawn(dp.getSingleEntityId());
            }
        } else if (type == PacketType.OUT_RESPAWN) {
            DimensionType dimension;
            try {
                dimension = packet.read(PacketType.OUT_RESPAWN.dimensionType);
            } catch (IllegalArgumentException ex) {
                // Logging.LOGGER_NETWORK.log(Level.WARNING, "Failed to decide dimension from respawn packet", ex);
                dimension = null;
            }
            if (dimension != null && !dimension.equals(this._playerDimension)) {
                this._playerDimension = dimension;
                handleReset();
            }
        } else if (type == PacketType.OUT_CAMERA) {
            // Called when vanilla/server/Bukkit starts or stops spectating an Entity
            // We remember this choice for later
            this._vanillaSpectatedEntity = packet.read(PacketType.OUT_CAMERA.entityId);
            // If currently spectating something already, override
            int len = this._spectatorStack.length;
            if (len > 0) {
                packet.write(PacketType.OUT_CAMERA.entityId, this._spectatorStack[len - 1]);
            }
        } else {
            if (this.isPositionTracked()) {
                // Also decode position
                if (type == PacketType.OUT_ENTITY_SPAWN) {
                    PacketPlayOutSpawnEntityHandle handle = PacketPlayOutSpawnEntityHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), handle.getCommonEntityType(), new Vector(handle.getPosX(), handle.getPosY(), handle.getPosZ()));
                } else if (type == PacketType.OUT_ENTITY_SPAWN_LIVING) {
                    PacketPlayOutSpawnEntityLivingHandle handle = PacketPlayOutSpawnEntityLivingHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), handle.getCommonEntityType(), new Vector(handle.getPosX(), handle.getPosY(), handle.getPosZ()));
                } else if (type == PacketType.OUT_ENTITY_SPAWN_NAMED) {
                    PacketPlayOutNamedEntitySpawnHandle handle = PacketPlayOutNamedEntitySpawnHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), CommonEntityType.PLAYER, new Vector(handle.getPosX(), handle.getPosY(), handle.getPosZ()));
                } else if (type == PacketType.OUT_ENTITY_TELEPORT) {
                    PacketPlayOutEntityTeleportHandle handle = PacketPlayOutEntityTeleportHandle.createHandle(packet.getHandle());
                    handleMove(handle.getEntityId(), (position) -> {
                        position.setX(handle.getPosX());
                        position.setY(handle.getPosY());
                        position.setZ(handle.getPosZ());
                    });
                } else if (type == PacketType.OUT_ENTITY_MOVE || type == PacketType.OUT_ENTITY_MOVE_LOOK) {
                    PacketPlayOutEntityHandle handle = PacketPlayOutEntityHandle.createHandle(packet.getHandle());
                    handleMove(handle.getEntityId(), (position) -> {
                        position.setX(position.getX() + handle.getDeltaX());
                        position.setY(position.getY() + handle.getDeltaY());
                        position.setZ(position.getZ() + handle.getDeltaZ());
                    });
                }
            } else {
                // No decoding/tracking of position
                if (type == PacketType.OUT_ENTITY_SPAWN) {
                    PacketPlayOutSpawnEntityHandle handle = PacketPlayOutSpawnEntityHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), handle.getCommonEntityType(), null);
                } else if (type == PacketType.OUT_ENTITY_SPAWN_LIVING) {
                    PacketPlayOutSpawnEntityLivingHandle handle = PacketPlayOutSpawnEntityLivingHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), handle.getCommonEntityType(), null);
                } else if (type == PacketType.OUT_ENTITY_SPAWN_NAMED) {
                    PacketPlayOutNamedEntitySpawnHandle handle = PacketPlayOutNamedEntitySpawnHandle.createHandle(packet.getHandle());
                    handleSpawn(handle.getEntityId(), CommonEntityType.PLAYER, null);
                }
            }
        }
    });
}

Example 2 with PacketType

use of com.bergerkiller.bukkit.common.protocol.PacketType in project BKCommonLib by bergerhealer.

the class PacketHandlerHooked method addPacketMonitor.

@Override
public void addPacketMonitor(Plugin plugin, PacketMonitor monitor, PacketType[] types) {
    if (monitor == null) {
        throw new IllegalArgumentException("Monitor is not allowed to be null");
    } else if (plugin == null) {
        throw new IllegalArgumentException("Plugin is not allowed to be null");
    }
    // Register the listener
    for (PacketType type : types) {
        // Map to listener array
        List<PacketMonitor> monitorList = monitors.get(type);
        if (monitorList == null) {
            monitorList = new ArrayList<PacketMonitor>();
            monitors.put(type, monitorList);
        }
        monitorList.add(monitor);
        // Map to plugin list
        List<PacketMonitor> list = monitorPlugins.get(plugin);
        if (list == null) {
            list = new ArrayList<PacketMonitor>(2);
            monitorPlugins.put(plugin, list);
        }
        list.add(monitor);
    }
}

Example 3 with PacketType

use of com.bergerkiller.bukkit.common.protocol.PacketType in project BKCommonLib by bergerhealer.

the class PacketHandlerHooked method addPacketListener.

@Override
public void addPacketListener(Plugin plugin, PacketListener listener, PacketType[] types) {
    if (listener == null) {
        throw new IllegalArgumentException("Listener is not allowed to be null");
    } else if (plugin == null) {
        throw new IllegalArgumentException("Plugin is not allowed to be null");
    }
    // Register the listener
    for (PacketType type : types) {
        // Map to listener array
        List<PacketListener> listenerList = listeners.get(type);
        if (listenerList == null) {
            listenerList = new ArrayList<PacketListener>();
            listeners.put(type, listenerList);
        }
        listenerList.add(listener);
        // Map to plugin list
        List<PacketListener> list = listenerPlugins.get(plugin);
        if (list == null) {
            list = new ArrayList<PacketListener>(2);
            listenerPlugins.put(plugin, list);
        }
        list.add(listener);
    }
}

Example 4 with PacketType

use of com.bergerkiller.bukkit.common.protocol.PacketType in project BKCommonLib by bergerhealer.

the class PacketHandlerHooked method handlePacketReceive.

/**
 * Handles a packet before it is being handled by the server
 *
 * @param player from which the packet came
 * @param packet that is handled
 * @param wasCancelled - True if the packet is allowed to be received, False
 * if not
 * @return True if the packet is allowed to be received, False if not
 */
public boolean handlePacketReceive(Player player, Object packet, boolean wasCancelled) {
    if (player == null || packet == null) {
        return true;
    }
    // Handle listeners
    PacketType type = PacketType.getType(packet);
    List<PacketListener> listenerList = listeners.get(type);
    if (listenerList != null) {
        CommonPacket cp = new CommonPacket(packet, type);
        PacketReceiveEvent ev = new PacketReceiveEvent(player, cp);
        ev.setCancelled(wasCancelled);
        for (PacketListener listener : listenerList) {
            try {
                listener.onPacketReceive(ev);
            } catch (Throwable t) {
                Logging.LOGGER_NETWORK.log(Level.SEVERE, "Error occurred in onPacketReceive handling " + type + ":", t);
            }
        }
        if (ev.isCancelled()) {
            return false;
        }
    }
    // Handle monitors
    List<PacketMonitor> monitorList = monitors.get(type);
    if (monitorList != null) {
        CommonPacket cp = new CommonPacket(packet, type);
        for (PacketMonitor monitor : monitorList) {
            try {
                monitor.onMonitorPacketReceive(cp, player);
            } catch (Throwable t) {
                Logging.LOGGER_NETWORK.log(Level.SEVERE, "Error occurred in onMonitorPacketReceive handling " + type + ":", t);
            }
        }
    }
    return true;
}

Example 5 with PacketType

use of com.bergerkiller.bukkit.common.protocol.PacketType in project BKCommonLib by bergerhealer.

the class PacketHandlerHooked method handlePacketSend.

/**
 * Handles a packet before it is being sent to a player
 *
 * @param player for which the packet was meant
 * @param packet that is handled
 * @param wasCancelled - True if it was originally cancelled, False if not
 * @return True if the packet is allowed to be sent, False if not
 */
public boolean handlePacketSend(Player player, Object packet, boolean wasCancelled) {
    if (player == null || packet == null) {
        return true;
    }
    // Check if silent
    boolean is_silent = this.silentQueue.take(player, packet);
    // Handle listeners
    PacketType type = PacketType.getType(packet);
    if (!is_silent) {
        List<PacketListener> listenerList = listeners.get(type);
        if (listenerList != null) {
            CommonPacket cp = new CommonPacket(packet, type);
            PacketSendEvent ev = new PacketSendEvent(player, cp);
            ev.setCancelled(wasCancelled);
            for (PacketListener listener : listenerList) {
                try {
                    listener.onPacketSend(ev);
                } catch (Throwable t) {
                    Logging.LOGGER_NETWORK.log(Level.SEVERE, "Error occurred in onPacketSend handling " + type + ":", t);
                }
            }
            if (ev.isCancelled()) {
                return false;
            }
        }
    }
    // Handle monitors
    handlePacketSendMonitor(player, type, packet);
    return true;
}