use of com.velocitypowered.proxy.connection.client.ConnectedPlayer in project InteractiveChat by LOOHP.
the class InteractiveChatVelocity method onProxyInitialization.
@Subscribe
public void onProxyInitialization(ProxyInitializeEvent event) {
plugin = this;
try {
JSONObject json = (JSONObject) new JSONParser().parse(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("velocity-plugin.json"), StandardCharsets.UTF_8));
description = new VelocityPluginDescription(json);
} catch (IOException | ParseException e1) {
e1.printStackTrace();
}
if (!getDataFolder().exists()) {
getDataFolder().mkdir();
}
try {
Config.loadConfig(CONFIG_ID, new File(getDataFolder(), "bungeeconfig.yml"), getClass().getClassLoader().getResourceAsStream("config_proxy.yml"), getClass().getClassLoader().getResourceAsStream("config_proxy.yml"), true);
} catch (IOException e) {
e.printStackTrace();
return;
}
loadConfig();
CommandsVelocity.createBrigadierCommand();
proxyServer.getChannelRegistrar().register(ICChannelIdentifier.INSTANCE);
getLogger().info(TextColor.GREEN + "[InteractiveChat] Registered Plugin Messaging Channels!");
Metrics metrics = metricsFactory.make(this, BSTATS_PLUGIN_ID);
Charts.setup(metrics);
playerCooldownManager = new ProxyPlayerCooldownManager(placeholderList.values().stream().flatMap(each -> each.stream()).distinct().collect(Collectors.toList()));
messageForwardingHandler = new ProxyMessageForwardingHandler((info, component) -> {
Player player = proxyServer.getPlayer(info.getPlayer()).get();
ServerConnection server = player.getCurrentServer().get();
proxyServer.getScheduler().buildTask(plugin, () -> {
try {
if (player != null && server != null) {
PluginMessageSendingVelocity.requestMessageProcess(player, server.getServer(), component, info.getId());
}
} catch (IOException e) {
e.printStackTrace();
}
}).delay(delay + 50, TimeUnit.MILLISECONDS).schedule();
}, (info, component) -> {
Chat chatPacket = new Chat(component + "<QUxSRUFEWVBST0NFU1NFRA==>", info.getPosition(), null);
Optional<Player> optplayer = getServer().getPlayer(info.getPlayer());
if (optplayer.isPresent()) {
ConnectedPlayer userConnection = (ConnectedPlayer) optplayer.get();
userConnection.getConnection().getChannel().write(chatPacket);
}
}, uuid -> {
return proxyServer.getPlayer(uuid).isPresent();
}, uuid -> {
Optional<ServerConnection> optCurrentServer = proxyServer.getPlayer(uuid).get().getCurrentServer();
return optCurrentServer.isPresent() && hasInteractiveChat(optCurrentServer.get().getServer());
}, () -> (long) delay + 2000);
ThreadFactory factory = new ThreadFactoryBuilder().setNameFormat("InteractiveChatProxy Async PluginMessage Processing Thread #%d").build();
pluginMessageHandlingExecutor = new ThreadPoolExecutor(8, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<>(true), factory);
getLogger().info(TextColor.GREEN + "[InteractiveChat] InteractiveChat (Velocity) has been enabled!");
run();
}
use of com.velocitypowered.proxy.connection.client.ConnectedPlayer in project InteractiveChat by LOOHP.
the class InteractiveChatVelocity method onPlayerConnected.
@Subscribe
public void onPlayerConnected(PostLoginEvent event) {
if (!filtersAdded) {
addFilters();
}
Player player = event.getPlayer();
forwardedMessages.put(player.getUniqueId(), new ConcurrentHashMap<>());
if (player.hasPermission("interactivechat.backendinfo")) {
String proxyVersion = getDescription().getVersion();
for (BackendInteractiveChatData data : serverInteractiveChatInfo.values()) {
if (data.isOnline() && data.getProtocolVersion() != Registry.PLUGIN_MESSAGING_PROTOCOL_VERSION) {
String msg = TextColor.RED + "[InteractiveChat] Warning: Backend Server " + data.getServer() + " is not running a version of InteractiveChat which has the same plugin messaging protocol version as the proxy!";
HoverEvent<Component> hoverComponent = Component.text(TextColor.YELLOW + "Proxy Version: " + proxyVersion + " (" + Registry.PLUGIN_MESSAGING_PROTOCOL_VERSION + ")\n" + TextColor.RED + data.getServer() + " Version: " + data.getVersion() + " (" + data.getProtocolVersion() + ")").asHoverEvent();
TextComponent text = Component.text(msg).hoverEvent(hoverComponent);
sendMessage(player, text);
sendMessage(getServer().getConsoleCommandSource(), text);
}
}
}
ConnectedPlayer userConnection = (ConnectedPlayer) player;
ChannelPipeline pipeline = userConnection.getConnection().getChannel().pipeline();
pipeline.addBefore(Connections.HANDLER, "interactivechat_interceptor", new ChannelDuplexHandler() {
@Override
public void write(ChannelHandlerContext channelHandlerContext, Object obj, ChannelPromise channelPromise) throws Exception {
try {
if (obj instanceof Chat) {
Chat packet = (Chat) obj;
String message = packet.getMessage();
byte position = packet.getType();
if ((position == 0 || position == 1) && message != null) {
if (message.contains("<QUxSRUFEWVBST0NFU1NFRA==>")) {
message = message.replace("<QUxSRUFEWVBST0NFU1NFRA==>", "");
if (Registry.ID_PATTERN.matcher(message).find()) {
message = Registry.ID_PATTERN.matcher(message).replaceAll("").trim();
}
packet.setMessage(message);
} else if (player.getCurrentServer().isPresent() && hasInteractiveChat(player.getCurrentServer().get().getServer())) {
messageForwardingHandler.processMessage(player.getUniqueId(), message, position);
return;
}
}
}
} catch (Throwable e) {
e.printStackTrace();
}
super.write(channelHandlerContext, obj, channelPromise);
}
});
}
use of com.velocitypowered.proxy.connection.client.ConnectedPlayer in project LimboAPI by Elytrium.
the class LimboImpl method spawnPlayer.
@Override
public void spawnPlayer(Player apiPlayer, LimboSessionHandler handler) {
ConnectedPlayer player = (ConnectedPlayer) apiPlayer;
MinecraftConnection connection = player.getConnection();
Class<? extends LimboSessionHandler> handlerClass = handler.getClass();
if (this.limboName == null) {
this.limboName = handlerClass.getSimpleName();
}
connection.eventLoop().execute(() -> {
ChannelPipeline pipeline = connection.getChannel().pipeline();
if (Settings.IMP.MAIN.LOGGING_ENABLED) {
this.plugin.getLogger().info(player.getUsername() + " (" + player.getRemoteAddress() + ") has connected to the " + this.limboName + " Limbo");
}
if (!pipeline.names().contains("prepared-encoder")) {
// and an error occurs that "minecraft-encoder" doesn't exist.
if (!pipeline.names().contains(Connections.MINECRAFT_ENCODER)) {
connection.close();
return;
}
pipeline.addAfter(Connections.MINECRAFT_ENCODER, "prepared-encoder", new PreparedPacketEncoder(connection.getProtocolVersion()));
}
RegisteredServer previousServer = null;
if (connection.getState() != LimboProtocol.getLimboRegistry()) {
connection.setState(LimboProtocol.getLimboRegistry());
VelocityServerConnection server = player.getConnectedServer();
if (server != null) {
server.disconnect();
player.setConnectedServer(null);
previousServer = server.getServer();
this.plugin.setLimboJoined(player);
}
}
if (this.plugin.isLimboJoined(player)) {
if (connection.getType() == ConnectionTypes.LEGACY_FORGE) {
connection.delayedWrite(this.safeRejoinPackets);
} else {
connection.delayedWrite(this.fastRejoinPackets);
}
} else {
connection.delayedWrite(this.joinPackets);
}
connection.delayedWrite(this.postJoinPackets);
connection.delayedWrite(this.getBrandMessage(handlerClass));
this.plugin.setLimboJoined(player);
LimboSessionHandlerImpl sessionHandler = new LimboSessionHandlerImpl(this.plugin, player, handler, connection.getSessionHandler(), previousServer, () -> this.limboName);
connection.setSessionHandler(sessionHandler);
connection.flush();
if (connection.getProtocolVersion().compareTo(ProtocolVersion.MINECRAFT_1_18_2) >= 0) {
this.plugin.getServer().getScheduler().buildTask(this.plugin, () -> connection.eventLoop().execute(() -> this.proceed(player, sessionHandler))).delay(Settings.IMP.MAIN.RECEIVER_LEVEL_1_18_2_FIXER_DELAY, TimeUnit.MILLISECONDS).schedule();
} else {
this.proceed(player, sessionHandler);
}
});
}
use of com.velocitypowered.proxy.connection.client.ConnectedPlayer in project LimboFilter by Elytrium.
the class LimboFilterCommand method execute.
@Override
public void execute(SimpleCommand.Invocation invocation) {
CommandSource source = invocation.source();
String[] args = invocation.arguments();
if (args.length == 1) {
switch(args[0].toLowerCase(Locale.ROOT)) {
case "reload":
{
if (source.hasPermission("limbofilter.reload")) {
try {
this.plugin.reload();
source.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.RELOAD));
} catch (Exception e) {
source.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.RELOAD_FAILED));
e.printStackTrace();
}
} else {
this.showHelp(source);
}
return;
}
case "stats":
{
if (source instanceof Player) {
if (source.hasPermission("limbofilter.stats")) {
ConnectedPlayer player = (ConnectedPlayer) source;
if (!this.playersWithStats.contains(player.getUniqueId())) {
source.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.STATS_ENABLED));
this.playersWithStats.add(player.getUniqueId());
} else {
source.sendMessage(LegacyComponentSerializer.legacyAmpersand().deserialize(Settings.IMP.MAIN.STRINGS.STATS_DISABLED));
this.playersWithStats.remove(player.getUniqueId());
}
} else {
this.showHelp(source);
}
} else {
source.sendMessage(this.createStatsComponent(0));
}
return;
}
default:
{
this.showHelp(source);
}
}
}
this.showHelp(source);
}
Aggregations