637 lines
23 KiB
Java
637 lines
23 KiB
Java
/*
|
|
* ProtocolLib - Bukkit server library that allows access to the Minecraft protocol.
|
|
* Copyright (C) 2012 Kristian S. Stangeland
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it under the terms of the
|
|
* GNU General Public License as published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with this program;
|
|
* if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
* 02111-1307 USA
|
|
*/
|
|
|
|
package com.comphenix.protocol.events;
|
|
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import javax.annotation.Nonnull;
|
|
|
|
import org.bukkit.plugin.Plugin;
|
|
|
|
import com.comphenix.protocol.PacketType;
|
|
import com.comphenix.protocol.injector.GamePhase;
|
|
import com.comphenix.protocol.injector.packet.PacketRegistry;
|
|
import com.google.common.base.Preconditions;
|
|
import com.google.common.collect.Iterables;
|
|
import com.google.common.collect.Lists;
|
|
import com.google.common.collect.Sets;
|
|
|
|
/**
|
|
* Represents a packet listener with useful constructors.
|
|
* <p>
|
|
* Remember to override onPacketReceiving() and onPacketSending(), depending on the ConnectionSide.
|
|
* @author Kristian
|
|
*/
|
|
public abstract class PacketAdapter implements PacketListener {
|
|
protected Plugin plugin;
|
|
protected ConnectionSide connectionSide;
|
|
protected ListeningWhitelist receivingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
|
|
protected ListeningWhitelist sendingWhitelist = ListeningWhitelist.EMPTY_WHITELIST;
|
|
|
|
/**
|
|
* Initialize a packet adapter using a collection of parameters. Use {@link #params()} to get an instance to this builder.
|
|
* @param params - the parameters.
|
|
*/
|
|
public PacketAdapter(@Nonnull AdapterParameteters params) {
|
|
this(
|
|
checkValidity(params).plugin, params.connectionSide, params.listenerPriority,
|
|
params.gamePhase, params.options, params.packets
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with the given parameters.
|
|
* @param plugin - the plugin.
|
|
* @param types - the packet types.
|
|
*/
|
|
public PacketAdapter(Plugin plugin, PacketType... types) {
|
|
this(plugin, ListenerPriority.NORMAL, types);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with the given parameters.
|
|
* @param plugin - the plugin.
|
|
* @param types - the packet types.
|
|
*/
|
|
public PacketAdapter(Plugin plugin, Iterable<? extends PacketType> types) {
|
|
this(params(plugin, Iterables.toArray(types, PacketType.class)));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with the given parameters.
|
|
* @param plugin - the plugin.
|
|
* @param listenerPriority - the priority.
|
|
* @param types - the packet types.
|
|
*/
|
|
public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types) {
|
|
this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with the given parameters.
|
|
* @param plugin - the plugin.
|
|
* @param listenerPriority - the priority.
|
|
* @param types - the packet types.
|
|
* @param options - the options.
|
|
*/
|
|
public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, Iterable<? extends PacketType> types, ListenerOptions... options) {
|
|
this(params(plugin, Iterables.toArray(types, PacketType.class)).listenerPriority(listenerPriority).options(options));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with the given parameters.
|
|
* @param plugin - the plugin.
|
|
* @param listenerPriority - the priority.
|
|
* @param types - the packet types.
|
|
*/
|
|
public PacketAdapter(Plugin plugin, ListenerPriority listenerPriority, PacketType... types) {
|
|
this(params(plugin, types).listenerPriority(listenerPriority));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener with default priority.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, Integer... packets) {
|
|
this(plugin, connectionSide, ListenerPriority.NORMAL, packets);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param listenerPriority - the event priority.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Set<Integer> packets) {
|
|
this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets.toArray(new Integer[0]));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param gamePhase - which game phase this listener is active under.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Set<Integer> packets) {
|
|
this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets.toArray(new Integer[0]));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param listenerPriority - the event priority.
|
|
* @param gamePhase - which game phase this listener is active under.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Set<Integer> packets) {
|
|
this(plugin, connectionSide, listenerPriority, gamePhase, packets.toArray(new Integer[0]));
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param listenerPriority - the event priority.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, Integer... packets) {
|
|
this(plugin, connectionSide, listenerPriority, GamePhase.PLAYING, packets);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param options - which listener options to use.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerOptions[] options, Integer... packets) {
|
|
this(plugin, connectionSide, ListenerPriority.NORMAL, GamePhase.PLAYING, options, packets);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param gamePhase - which game phase this listener is active under.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, GamePhase gamePhase, Integer... packets) {
|
|
this(plugin, connectionSide, ListenerPriority.NORMAL, gamePhase, packets);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param listenerPriority - the event priority.
|
|
* @param gamePhase - which game phase this listener is active under.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority, GamePhase gamePhase, Integer... packets) {
|
|
this(plugin, connectionSide, listenerPriority, gamePhase, new ListenerOptions[0], packets);
|
|
}
|
|
|
|
/**
|
|
* Initialize a packet listener for a single connection side.
|
|
* <p>
|
|
* The game phase is used to optimize performance. A listener should only choose BOTH or LOGIN if it's absolutely necessary.
|
|
* <p>
|
|
* Listener options must be specified in order for {@link NetworkMarker#getInputBuffer()} to function correctly.
|
|
* <p>
|
|
* Deprecated: Use {@link #params()} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param connectionSide - the packet type the listener is looking for.
|
|
* @param listenerPriority - the event priority.
|
|
* @param gamePhase - which game phase this listener is active under.
|
|
* @param options - which listener options to use.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
*/
|
|
@Deprecated
|
|
public PacketAdapter(
|
|
Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
|
|
GamePhase gamePhase, ListenerOptions[] options, Integer... packets) {
|
|
|
|
this(plugin, connectionSide, listenerPriority, gamePhase, options,
|
|
PacketRegistry.toPacketTypes(Sets.newHashSet(packets), connectionSide.getSender()).toArray(new PacketType[0])
|
|
);
|
|
}
|
|
|
|
// For internal use only
|
|
private PacketAdapter(
|
|
Plugin plugin, ConnectionSide connectionSide, ListenerPriority listenerPriority,
|
|
GamePhase gamePhase, ListenerOptions[] options, PacketType... packets) {
|
|
|
|
if (plugin == null)
|
|
throw new IllegalArgumentException("plugin cannot be null");
|
|
if (connectionSide == null)
|
|
throw new IllegalArgumentException("connectionSide cannot be null");
|
|
if (listenerPriority == null)
|
|
throw new IllegalArgumentException("listenerPriority cannot be null");
|
|
if (gamePhase == null)
|
|
throw new IllegalArgumentException("gamePhase cannot be NULL");
|
|
if (packets == null)
|
|
throw new IllegalArgumentException("packets cannot be null");
|
|
if (options == null)
|
|
throw new IllegalArgumentException("options cannot be null");
|
|
|
|
ListenerOptions[] serverOptions = options;
|
|
ListenerOptions[] clientOptions = options;
|
|
|
|
// Special case that allows us to specify optionIntercept().
|
|
if (connectionSide == ConnectionSide.BOTH) {
|
|
serverOptions = except(serverOptions, new ListenerOptions[0],
|
|
ListenerOptions.INTERCEPT_INPUT_BUFFER);
|
|
}
|
|
|
|
// Add whitelists
|
|
if (connectionSide.isForServer())
|
|
sendingWhitelist = ListeningWhitelist.newBuilder().
|
|
priority(listenerPriority).
|
|
types(packets).
|
|
gamePhase(gamePhase).
|
|
options(serverOptions).
|
|
build();
|
|
|
|
if (connectionSide.isForClient())
|
|
receivingWhitelist = ListeningWhitelist.newBuilder().
|
|
priority(listenerPriority).
|
|
types(packets).
|
|
gamePhase(gamePhase).
|
|
options(clientOptions).
|
|
build();
|
|
|
|
this.plugin = plugin;
|
|
this.connectionSide = connectionSide;
|
|
}
|
|
|
|
// Remove a given element from an array
|
|
private static <T> T[] except(T[] values, T[] buffer, T except) {
|
|
List<T> result = Lists.newArrayList(values);
|
|
|
|
result.remove(except);
|
|
return result.toArray(buffer);
|
|
}
|
|
|
|
@Override
|
|
public void onPacketReceiving(PacketEvent event) {
|
|
// Lets prevent some bugs
|
|
throw new IllegalStateException("Override onPacketReceiving to get notifcations of received packets!");
|
|
}
|
|
|
|
@Override
|
|
public void onPacketSending(PacketEvent event) {
|
|
// Lets prevent some bugs
|
|
throw new IllegalStateException("Override onPacketSending to get notifcations of sent packets!");
|
|
}
|
|
|
|
@Override
|
|
public ListeningWhitelist getReceivingWhitelist() {
|
|
return receivingWhitelist;
|
|
}
|
|
|
|
@Override
|
|
public ListeningWhitelist getSendingWhitelist() {
|
|
return sendingWhitelist;
|
|
}
|
|
|
|
@Override
|
|
public Plugin getPlugin() {
|
|
return plugin;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the name of the plugin that has been associated with the listener.
|
|
* @param listener - the listener.
|
|
* @return Name of the associated plugin.
|
|
*/
|
|
public static String getPluginName(PacketListener listener) {
|
|
return getPluginName(listener.getPlugin());
|
|
}
|
|
|
|
/**
|
|
* Retrieves the name of the given plugin.
|
|
* @param plugin - the plugin.
|
|
* @return Name of the given plugin.
|
|
*/
|
|
public static String getPluginName(Plugin plugin) {
|
|
if (plugin == null)
|
|
return "UNKNOWN";
|
|
|
|
try {
|
|
return plugin.getName();
|
|
} catch (NoSuchMethodError e) {
|
|
return plugin.toString();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
// This is used by the error reporter
|
|
return String.format("PacketAdapter[plugin=%s, sending=%s, receiving=%s]",
|
|
getPluginName(this),
|
|
sendingWhitelist,
|
|
receivingWhitelist);
|
|
}
|
|
|
|
/**
|
|
* Construct a helper object for passing parameters to the packet adapter.
|
|
* <p>
|
|
* This is often simpler and better than passing them directly to each constructor.
|
|
* @return Helper object.
|
|
*/
|
|
public static AdapterParameteters params() {
|
|
return new AdapterParameteters();
|
|
}
|
|
|
|
/**
|
|
* Construct a helper object for passing parameters to the packet adapter.
|
|
* <p>
|
|
* This is often simpler and better than passing them directly to each constructor.
|
|
* Deprecated: Use {@link #params(Plugin, PacketType...)} instead.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param packets - the packet IDs the listener is looking for.
|
|
* @return Helper object.
|
|
*/
|
|
@Deprecated
|
|
public static AdapterParameteters params(Plugin plugin, Integer... packets) {
|
|
return new AdapterParameteters().plugin(plugin).packets(packets);
|
|
}
|
|
|
|
/**
|
|
* Construct a helper object for passing parameters to the packet adapter.
|
|
* <p>
|
|
* This is often simpler and better than passing them directly to each constructor.
|
|
* @param plugin - the plugin that spawned this listener.
|
|
* @param packets - the packet types the listener is looking for.
|
|
* @return Helper object.
|
|
*/
|
|
public static AdapterParameteters params(Plugin plugin, PacketType... packets) {
|
|
return new AdapterParameteters().plugin(plugin).types(packets);
|
|
}
|
|
|
|
/**
|
|
* Represents a builder for passing parameters to the packet adapter constructor.
|
|
* <p>
|
|
* Note: Never make spelling mistakes in a public API!
|
|
* @author Kristian
|
|
*/
|
|
public static class AdapterParameteters {
|
|
private Plugin plugin;
|
|
private ConnectionSide connectionSide;
|
|
private PacketType[] packets;
|
|
|
|
// Parameters with default values
|
|
private GamePhase gamePhase = GamePhase.PLAYING;
|
|
private ListenerOptions[] options = new ListenerOptions[0];
|
|
private ListenerPriority listenerPriority = ListenerPriority.NORMAL;
|
|
|
|
/**
|
|
* Set the plugin that spawned this listener. This parameter is required.
|
|
* @param plugin - the plugin.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters plugin(@Nonnull Plugin plugin) {
|
|
this.plugin = Preconditions.checkNotNull(plugin, "plugin cannot be NULL.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the packet types this listener is looking for. This parameter is required.
|
|
* @param connectionSide - the new packet type.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters connectionSide(@Nonnull ConnectionSide connectionSide) {
|
|
this.connectionSide = Preconditions.checkNotNull(connectionSide, "connectionside cannot be NULL.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set this adapter to also look for client-side packets.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters clientSide() {
|
|
return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.CLIENT_SIDE));
|
|
}
|
|
|
|
/**
|
|
* Set this adapter to also look for server-side packets.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters serverSide() {
|
|
return connectionSide(ConnectionSide.add(connectionSide, ConnectionSide.SERVER_SIDE));
|
|
}
|
|
|
|
/**
|
|
* Set the the event priority, where the execution is in ascending order from lowest to highest.
|
|
* <p>
|
|
* Default is {@link ListenerPriority#NORMAL}.
|
|
* @param listenerPriority - the new event priority.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters listenerPriority(@Nonnull ListenerPriority listenerPriority) {
|
|
this.listenerPriority = Preconditions.checkNotNull(listenerPriority, "listener priority cannot be NULL.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set which game phase this listener is active under. This is a hint for ProtocolLib to start intercepting login packets.
|
|
* <p>
|
|
* Default is {@link GamePhase#PLAYING}, which will not intercept login packets.
|
|
* @param gamePhase - the new game phase.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters gamePhase(@Nonnull GamePhase gamePhase) {
|
|
this.gamePhase = Preconditions.checkNotNull(gamePhase, "gamePhase cannot be NULL.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the game phase to {@link GamePhase#LOGIN}, allowing ProtocolLib to intercept login packets.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters loginPhase() {
|
|
return gamePhase(GamePhase.LOGIN);
|
|
}
|
|
|
|
/**
|
|
* Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
|
|
* <p>
|
|
* The default is to disable this raw packet interception.
|
|
* @param options - every option to use.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters options(@Nonnull ListenerOptions... options) {
|
|
this.options = Preconditions.checkNotNull(options, "options cannot be NULL.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set listener options that decide whether or not to intercept the raw packet data as read from the network stream.
|
|
* <p>
|
|
* The default is to disable this raw packet interception.
|
|
* @param options - every option to use.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters options(@Nonnull Set<? extends ListenerOptions> options) {
|
|
Preconditions.checkNotNull(options, "options cannot be NULL.");
|
|
this.options = options.toArray(new ListenerOptions[0]);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Add a given option to the current builder.
|
|
* @param option - the option to add.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
private AdapterParameteters addOption(ListenerOptions option) {
|
|
if (options == null) {
|
|
return options(option);
|
|
} else {
|
|
Set<ListenerOptions> current = Sets.newHashSet(options);
|
|
current.add(option);
|
|
return options(current);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set the listener option to {@link ListenerOptions#INTERCEPT_INPUT_BUFFER}, causing ProtocolLib to read the raw packet data from the network stream.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters optionIntercept() {
|
|
return addOption(ListenerOptions.INTERCEPT_INPUT_BUFFER);
|
|
}
|
|
|
|
/**
|
|
* Set the listener option to {@link ListenerOptions#DISABLE_GAMEPHASE_DETECTION}, causing ProtocolLib to ignore automatic game phase detection.
|
|
* <p>
|
|
* This is no longer relevant in 1.7.2.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters optionManualGamePhase() {
|
|
return addOption(ListenerOptions.DISABLE_GAMEPHASE_DETECTION);
|
|
}
|
|
|
|
/**
|
|
* Set the listener option to {@link ListenerOptions#ASYNC}, indicating that our listener is thread safe.
|
|
* <p>
|
|
* This allows ProtocolLib to perform certain optimizations.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters optionAsync() {
|
|
return addOption(ListenerOptions.ASYNC);
|
|
}
|
|
|
|
/**
|
|
* Set the packet IDs of the packets the listener is looking for.
|
|
* <p>
|
|
* This parameter is required.
|
|
* <p>
|
|
* Deprecated: Use {@link #types(PacketType...)} instead.
|
|
* @param packets - the packet IDs to look for.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
@Deprecated
|
|
public AdapterParameteters packets(@Nonnull Integer... packets) {
|
|
Preconditions.checkNotNull(packets, "packets cannot be NULL");
|
|
PacketType[] types = new PacketType[packets.length];
|
|
|
|
for (int i = 0; i < types.length; i++) {
|
|
types[i] = PacketType.findLegacy(packets[i]);
|
|
}
|
|
this.packets = types;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the packet IDs of the packets the listener is looking for.
|
|
* <p>
|
|
* This parameter is required.
|
|
* @param packets - a set of the packet IDs to look for.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
@Deprecated
|
|
public AdapterParameteters packets(@Nonnull Set<Integer> packets) {
|
|
return packets(packets.toArray(new Integer[0]));
|
|
}
|
|
|
|
/**
|
|
* Set the packet types the listener is looking for.
|
|
* <p>
|
|
* This parameter is required.
|
|
* @param packets - the packet types to look for.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters types(@Nonnull PacketType... packets) {
|
|
// Set the connection side as well
|
|
if (connectionSide == null) {
|
|
for (PacketType type : packets) {
|
|
this.connectionSide = ConnectionSide.add(this.connectionSide, type.getSender().toSide());
|
|
}
|
|
}
|
|
this.packets = Preconditions.checkNotNull(packets, "packets cannot be NULL");
|
|
|
|
if (packets.length == 0)
|
|
throw new IllegalArgumentException("Passed an empty packet type array.");
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Set the packet types the listener is looking for.
|
|
* <p>
|
|
* This parameter is required.
|
|
* @param packets - a set of packet types to look for.
|
|
* @return This builder, for chaining.
|
|
*/
|
|
public AdapterParameteters types(@Nonnull Set<PacketType> packets) {
|
|
return types(packets.toArray(new PacketType[0]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if the required parameters are set.
|
|
*/
|
|
private static AdapterParameteters checkValidity(AdapterParameteters params) {
|
|
if (params == null)
|
|
throw new IllegalArgumentException("params cannot be NULL.");
|
|
if (params.plugin == null)
|
|
throw new IllegalStateException("Plugin was never set in the parameters.");
|
|
if (params.connectionSide == null)
|
|
throw new IllegalStateException("Connection side was never set in the parameters.");
|
|
if (params.packets == null)
|
|
throw new IllegalStateException("Packet IDs was never set in the parameters.");
|
|
return params;
|
|
}
|
|
}
|