/** * Notifies the player with the specified message but does nothing else. * * @param message the server to send the player to * @return the redirect result */ public static Notify create(Component message) { return new Notify(message); } }
/** * Creates a new {@link DisconnectPlayer} with the specified reason. * * @param reason the reason to use when disconnecting the player * @return the disconnect result */ public static DisconnectPlayer create(Component reason) { return new DisconnectPlayer(reason); } }
/** * Creates a new redirect result to forward the player to the specified {@code server}. * * @param server the server to send the player to * @return the redirect result */ public static RedirectPlayer create(RegisteredServer server) { return new RedirectPlayer(server); } }
KickedFromServerEvent originalEvent = new KickedFromServerEvent(this, rs, kickReason, !connectedServer.getServer().equals(rs), friendlyReason); server.getEventManager().fire(originalEvent) .thenAcceptAsync(event -> { if (event.getResult() instanceof DisconnectPlayer) { DisconnectPlayer res = (DisconnectPlayer) event.getResult(); disconnect(res.getReason()); } else if (event.getResult() instanceof RedirectPlayer) { RedirectPlayer res = (RedirectPlayer) event.getResult(); createConnectionRequest(res.getServer()).fireAndForget(); } else if (event.getResult() instanceof Notify) { Notify res = (Notify) event.getResult(); if (event.kickedDuringServerConnect()) { sendMessage(res.getMessage()); } else { disconnect(res.getMessage());
@Subscribe public void onServerConnected(final ServerConnectedEvent e) { //Attempt to resend any votes that were previously cached. BackendServer server = new VelocityBackendServer(plugin.getServer(), e.getServer()); onServerConnect(server); handlePlayerSwitch(server, e.getPlayer().getUsername()); }
@Subscribe(order = PostOrder.LATE) public void connectedEvent(ServerConnectedEvent e) { UserConnection user = Via.getManager().getConnection(e.getPlayer().getUniqueId()); try { checkServerChange(e, Via.getManager().getConnection(e.getPlayer().getUniqueId())); } catch (Exception e1) { e1.printStackTrace(); } }
ServerPreConnectEvent event = new ServerPreConnectEvent(ConnectedPlayer.this, toConnect); return server.getEventManager().fire(event) .thenCompose(newEvent -> { Optional<RegisteredServer> connectTo = newEvent.getResult().getServer(); if (!connectTo.isPresent()) { return CompletableFuture.completedFuture(
@Subscribe public void onServerConnected(final ServerConnectedEvent e) { //Attempt to resend any votes that were previously cached. onServerConnect(new VelocityBackendServer(plugin.getServer(), e.getServer())); }
/** * Allows the player to connect to the specified server. * @param server the new server to connect to * @return a result to allow the player to connect to the specified server */ public static ServerResult allowed(RegisteredServer server) { Preconditions.checkNotNull(server, "server"); return new ServerResult(server); } }
/** * Constructs a PlayerChatEvent. * @param player the player sending the message * @param message the message being sent */ public PlayerChatEvent(Player player, String message) { this.player = Preconditions.checkNotNull(player, "player"); this.message = Preconditions.checkNotNull(message, "message"); this.result = ChatResult.allowed(); }
/** * Creates the ServerPreConnectEvent. * @param player the player who is connecting to a server * @param originalServer the server the player was trying to connect to */ public ServerPreConnectEvent(Player player, RegisteredServer originalServer) { this.player = Preconditions.checkNotNull(player, "player"); this.originalServer = Preconditions.checkNotNull(originalServer, "originalServer"); this.result = ServerResult.allowed(originalServer); }
/** * Allows the message to be sent, but silently replaced with another. * @param message the message to use instead * @return a result with a new message */ public static ChatResult message(@NonNull String message) { Preconditions.checkNotNull(message, "message"); return new ChatResult(true, message); } }
public void setModInfo(ModInfo modInfo) { this.modInfo = modInfo; server.getEventManager().fireAndForget(new PlayerModInfoEvent(this, modInfo)); }
@Override public void encode(ByteBuf buf, Direction direction, ProtocolVersion protocolVersion) { if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_9_4) <= 0) { ProtocolUtils.writeString(buf, hash); } ProtocolUtils.writeVarInt(buf, status.ordinal()); }
@Override public void decode(ByteBuf buf, Direction direction, ProtocolVersion protocolVersion) { if (protocolVersion.compareTo(ProtocolVersion.MINECRAFT_1_9_4) <= 0) { this.hash = ProtocolUtils.readString(buf); } this.status = Status.values()[ProtocolUtils.readVarInt(buf)]; }
void setPlayerSettings(ClientSettings settings) { ClientSettingsWrapper cs = new ClientSettingsWrapper(settings); this.settings = cs; server.getEventManager().fireAndForget(new PlayerSettingsChangedEvent(this, cs)); }
@Override public boolean handle(ResourcePackResponse packet) { server.getEventManager().fireAndForget(new PlayerResourcePackStatusEvent(player, packet.getStatus())); return false; }
@Subscribe public void onPlayerJoin(ServerConnectedEvent joinEvent) { Player player = joinEvent.getPlayer(); runnableFactory.create("Add Player to Ping list", new AbsRunnable() { @Override public void run() { if (player.isActive()) { addPlayer(player); } } }).runTaskLater(TimeAmount.toTicks(config.get(TimeSettings.PING_PLAYER_LOGIN_DELAY), TimeUnit.MILLISECONDS)); }
/** * Creates a {@code KickedFromServerEvent} instance. * @param player the player affected * @param server the server the player disconnected from * @param originalReason the reason for being kicked, optional * @param duringServerConnect whether or not the player was kicked during the connection process * @param fancyReason a fancy reason for being disconnected, used for the initial result */ public KickedFromServerEvent(Player player, RegisteredServer server, @Nullable Component originalReason, boolean duringServerConnect, Component fancyReason) { this.player = Preconditions.checkNotNull(player, "player"); this.server = Preconditions.checkNotNull(server, "server"); this.originalReason = originalReason; this.duringServerConnect = duringServerConnect; this.result = new Notify(fancyReason); }
@Subscribe public void onServerSwitch(ServerConnectedEvent event) { try { Player player = event.getPlayer(); UUID uuid = player.getUniqueId(); long now = System.currentTimeMillis(); // Replaces the current session in the cache. sessionCache.cacheSession(uuid, new Session(uuid, serverInfo.getServerUUID(), now, null, null)); processing.submit(processors.info().playerPageUpdateProcessor(uuid)); } catch (Exception e) { errorHandler.log(L.WARN, this.getClass(), e); } } }