Java ProtocolSupportAPI类代码示例

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
public void start() {
	Bukkit.getPluginManager().registerEvents(this, ProtocolSupportLegacySupport.getInstance());
	ProtocolSupportAPI.getConnections().forEach(this::initConnection);
	Bukkit.getScheduler().runTaskTimer(ProtocolSupportLegacySupport.getInstance(), () -> {
		ProtocolSupportAPI.getConnections().forEach(connection -> {
			Player player = connection.getPlayer();
			if (player == null) {
				return;
			}
			LegacyBossBar bossbar = getBossBar(connection);
			if (bossbar == null) {
				return;
			}
			bossbar.handlePlayerTick(connection, player);
		});
	}, 0, 1);
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
public void execute(CommandSender sender, String[] args) {
	if ((args.length == 1) || (args.length == 2)) {
		if (args[0].equalsIgnoreCase("list")) {
			sender.sendMessage(new TextComponent(ChatColor.GREEN + "ProtocolSupport Players:"));
			for (ProtocolVersion version : ProtocolVersion.getAllSupported()) {
				List<String> players = ProxyServer.getInstance().getPlayers().stream()
				.filter(player -> ProtocolSupportAPI.getProtocolVersion(player) == version)
				.map(player -> player.getName())
				.collect(Collectors.toList());
				if (!players.isEmpty() || ((args.length == 2) && (args[1].equalsIgnoreCase("v") || args[1].equalsIgnoreCase("verbose")))) {
					sender.sendMessage(new TextComponent(ChatColor.GOLD + "[" + version.getName() + "]: " + ChatColor.GREEN + String.join(", ", players)));
				}
			}
			if ((args.length == 1) || !(args[1].equalsIgnoreCase("v") || args[1].equalsIgnoreCase("verbose"))) {
				sender.sendMessage(new TextComponent(ChatColor.GOLD + "List all compatible versions using " + ChatColor.GREEN + "/psb list verbose"));
			}
		} else if (args[0].equalsIgnoreCase("connections")) {
			for (Connection connection : ProtocolSupportAPI.getConnections()) {
				sender.sendMessage(new TextComponent(ChatColor.GREEN + connection.toString()));
			}
		}
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
public boolean handle(CommandSender sender, String[] args) {
	boolean verbose = (args.length == 1) && (args[0].equalsIgnoreCase("v") || args[0].equalsIgnoreCase("verbose"));
	sender.sendMessage(ChatColor.YELLOW + "ProtocolSupport Players:");
	for (ProtocolVersion version : ProtocolVersion.getAllSupported()) {
		List<String> players = Bukkit.getOnlinePlayers().stream()
		.filter(player -> ProtocolSupportAPI.getProtocolVersion(player) == version)
		.map(player -> player.getName())
		.collect(Collectors.toList());
		if (!players.isEmpty() || verbose) {
			sender.sendMessage(ChatColor.YELLOW + "[" + version.getName() + "]: " + ChatColor.GREEN + String.join(", ", players));
		}
	}
	if (!verbose) {
		sender.sendMessage(ChatColor.YELLOW + "List all compatible versions using by adding verbose or v argument to this command");
	}
	return true;
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
protected static ConnectionImpl prepare(Channel channel, ProtocolVersion version) {
	channel.pipeline().remove(ChannelHandlers.INITIAL_DECODER);
	ConnectionImpl connection = ConnectionImpl.getFromChannel(channel);
	if (ServerPlatform.get().getMiscUtils().isDebugging()) {
		ProtocolSupport.logInfo(MessageFormat.format("{0} connected with protocol version {1}", connection.getAddress(), version));
	}
	connection.getNetworkManagerWrapper().setPacketListener(ServerPlatform.get().getWrapperFactory().createHandshakeListener(connection.getNetworkManagerWrapper()));
	if (!ProtocolSupportAPI.isProtocolVersionEnabled(version)) {
		if (version.getProtocolType() == ProtocolType.PC) {
			version = version.isBeforeOrEq(ProtocolVersion.MINECRAFT_1_6_4) ? ProtocolVersion.MINECRAFT_LEGACY : ProtocolVersion.MINECRAFT_FUTURE;
		} else {
			throw new IllegalArgumentException(MessageFormat.format("Unable to get legacy or future version for disabled protocol version {0}", version));
		}
	}
	connection.setVersion(version);
	return connection;
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
/**
 * Sends title, subtitle, and it's params <br>
 * Title and subtitle can't be both null
 * @param player Player to which title is sent
 * @param titleJson title chat json or null
 * @param subtitleJson subtitle chat json or null
 * @param fadeIn ticks to spend fading in
 * @param stay ticks to display
 * @param fadeOut ticks to spend fading out
 */
public static void sendSimpleTitle(Player player, String titleJson, String subtitleJson, int fadeIn, int stay, int fadeOut) {
	Validate.notNull(player, "Player can't be null");
	if ((titleJson == null) && (subtitleJson == null)) {
		throw new IllegalArgumentException("Title and subtitle can't be both null");
	}
	Connection connection = ProtocolSupportAPI.getConnection(player);
	connection.sendPacket(ServerPlatform.get().getPacketFactory().createTitleParamsPacket(fadeIn, stay, fadeOut));
	if (subtitleJson != null) {
		connection.sendPacket(ServerPlatform.get().getPacketFactory().createTitleSubPacket(subtitleJson));
	}
	if (titleJson == null) {
		titleJson = "";
	}
	connection.sendPacket(ServerPlatform.get().getPacketFactory().createTitleMainPacket(titleJson));
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
public FeatureEmulation() {
	Bukkit.getScheduler().runTaskTimer(ProtocolSupport.getInstance(), () -> {
		Bukkit.getOnlinePlayers().stream()
		.filter(player -> {
			ProtocolVersion version = ProtocolSupportAPI.getProtocolVersion(player);
			return (version.getProtocolType() == ProtocolType.PC) && version.isBefore(ProtocolVersion.MINECRAFT_1_9);
		})
		.filter(player -> player.hasPotionEffect(PotionEffectType.LEVITATION))
		.filter(player -> !player.isFlying())
		.forEach(player -> {
			Vector vel = player.getVelocity();
			vel.setY(vel.getY() + (((0.05D * (player.getPotionEffect(PotionEffectType.LEVITATION).getAmplifier() + 1)) - vel.getY()) * 0.2D));
			player.setVelocity(vel);
		});
	}, 1, 1);
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onEntityDamage(EntityDamageEvent event) {
	if (((event.getCause() == DamageCause.FIRE_TICK) || (event.getCause() == DamageCause.FIRE) || (event.getCause() == DamageCause.DROWNING))) {
		for (Player player : ServerPlatform.get().getMiscUtils().getNearbyPlayers(event.getEntity().getLocation(), 48, 128, 48)) {
			if (player != null) {
				Connection connection = ProtocolSupportAPI.getConnection(player);
				if (
					(connection != null) &&
					(connection.getVersion().getProtocolType() == ProtocolType.PC) &&
					connection.getVersion().isBefore(ProtocolVersion.MINECRAFT_1_12)
				) {
					connection.sendPacket(ServerPlatform.get().getPacketFactory().createEntityStatusPacket(event.getEntity(), 2));
				}
			}
		}
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
protected ProtocolVersion getProtocol(Player player) {
    if (protocolSupported) {
        return ProtocolVersion.getVersion(ProtocolSupportAPI.getProtocolVersion(player).getId());
    }

    return null;
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
public void setup(@Nonnull TerminableConsumer consumer) {
    Events.subscribe(PlayerLoginEvent.class, EventPriority.MONITOR)
            .filter(e -> e.getResult() == PlayerLoginEvent.Result.ALLOWED)
            .handler(e -> {
                plugin.getDataManager().logPlayer(e.getPlayer().getUniqueId(), e.getPlayer().getName());
                Metadata.provideForPlayer(e.getPlayer()).put(NetworkAnalytics.CONNECTION_TIME_SECONDS, (System.currentTimeMillis() / 1000L));
            })
            .bindWith(consumer);

    Events.subscribe(PlayerJoinEvent.class, EventPriority.MONITOR)
            .handler(e -> {
                ProtocolVersion protocolVersion = ProtocolSupportAPI.getProtocolVersion(e.getPlayer());
                if (protocolVersion != null) {
                    Metadata.provideForPlayer(e.getPlayer()).put(NetworkAnalytics.PROTOCOL_VERSION, protocolVersion);
                }
            })
            .bindWith(consumer);

    Events.subscribe(PlayerQuitEvent.class)
            .handler(e -> {
                Long loginTime = Metadata.provideForPlayer(e.getPlayer()).getOrNull(NetworkAnalytics.CONNECTION_TIME_SECONDS);
                long now = System.currentTimeMillis() / 1000L;
                if (loginTime != null) {
                    long diff = now - loginTime;
                    int mins = (int) TimeUnit.SECONDS.toMinutes(diff);
                    if (mins > 0) {
                        plugin.getDataManager().incrementPlayerMinutesPlayed(e.getPlayer().getUniqueId(), mins);
                    }
                }
            })
            .bindWith(consumer);
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@EventHandler
public void onLogin(PlayerJoinEvent e) {
	ProtocolVersion ver = ProtocolSupportAPI.getProtocolVersion(e.getPlayer());
	if (ver.isBefore(ProtocolVersion.MINECRAFT_1_7_5)) {
		e.getPlayer().kickPlayer(Util.parseColors("&c" + ver.getName() + " &fis not supported by iZenith.\n" + "Supported versions are &a1.7.x&f, &a1.8.x &fand &a1.9.x"));
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
public static void kickBoats() {
	for (Player player : Bukkit.getOnlinePlayers()) {
		if(player.isInsideVehicle() && player.getVehicle() instanceof Boat && ProtocolSupportAPI.getProtocolVersion(player).isBefore(ProtocolVersion.MINECRAFT_1_9)){
			player.getVehicle().eject();
			player.sendMessage(ChatColor.RED + "Boats are currently disabled for versions lower than " + ChatColor.DARK_RED + "1.9");
		}
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@EventHandler(priority = EventPriority.LOW)
public void onFinishLogin(PlayerLoginFinishEvent event) throws InterruptedException, ExecutionException, InvocationTargetException {
	Connection connection = ProtocolSupportAPI.getConnection(event.getAddress());

	if (event.isLoginDenied() || !Settings.captchaEnabled || Bukkit.getOfflinePlayer(event.getUUID()).hasPlayedBefore()) {
		cleanupConnection(connection);
		return;
	}

	ValidatorInfo validator = (ValidatorInfo) connection.getMetadata(validator_info_key);

	if (validator == null) {
		return;
	}

	byte[] mapdata = MapCaptchaPainter.create(validator.generateCaptcha());

	connection.sendPacket(Packets.createSetSlotPacket(36, new ItemStack(Material.MAP, 1, (short) 1)));
	connection.sendPacket(Packets.createMapDataPacket(1, mapdata));

	connection.sendPacket(Packets.createChatPacket(Settings.captchaStartMessage));

	try {
		if (!validator.waitConfirm(Settings.captchaMaxWait, TimeUnit.SECONDS)) {
			BanDataSource.getInstance().ban(event.getAddress().getAddress());
			event.denyLogin(Settings.captchaFailMessage);
		} else {
			if (validator.isSuccess()) {
				connection.sendPacket(Packets.createChatPacket(Settings.captchaSuccessMessage));
			} else {
				BanDataSource.getInstance().ban(event.getAddress().getAddress());
				event.denyLogin(Settings.captchaFailTryBanMessage.replace("{MAXTRIES}", String.valueOf(Settings.captchaMaxTries)));
			}
		}
		cleanupConnection(connection);
	} catch (AbortedException e) {
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
@Nullable
protected ItemType[] get(Event e) {
	Material m = item.getSingle(e).getRandom().getType();
	ItemRemapperControl mapper = ProtocolSupportAPI.getItemRemapper(version.getSingle(e));
	@SuppressWarnings("deprecation")
	ItemType itemType = new ItemType(mapper.getRemap(mapper.getRemap(m).getId()));
	return new ItemType[]{itemType};
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
public void change(Event e, Object[] delta, Changer.ChangeMode mode){
	Material mbefore = item.getSingle(e).getRandom().getType();
	Material m = ((ItemType)delta[0]).getRandom().getType();
	ItemRemapperControl mapper = ProtocolSupportAPI.getItemRemapper(version.getSingle(e));
	if (mode == ChangeMode.SET) {
		mapper.setRemap(mbefore, m);
	} else if (mode == ChangeMode.RESET) {
		mapper.setRemap(mbefore, mbefore);
	}
}
 

import protocolsupport.api.ProtocolSupportAPI; //导入依赖的package包/类
@Override
@Nullable
protected Number[] get(Event e) {
	Number itemMaterial = item.getSingle(e);
	ItemRemapperControl mapper = ProtocolSupportAPI.getItemRemapper(version.getSingle(e));
	return new Number[]{mapper.getRemap(itemMaterial.intValue())};
}