2020-04-24 03:25:58 +02:00
|
|
|
package net.minestom.server.utils;
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2021-08-24 14:59:17 +02:00
|
|
|
import it.unimi.dsi.fastutil.ints.IntIntPair;
|
2021-03-30 16:54:56 +02:00
|
|
|
import net.kyori.adventure.audience.Audience;
|
|
|
|
import net.kyori.adventure.audience.ForwardingAudience;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.MinecraftServer;
|
2021-08-24 14:59:17 +02:00
|
|
|
import net.minestom.server.Viewable;
|
2021-06-11 17:19:11 +02:00
|
|
|
import net.minestom.server.adventure.MinestomAdventure;
|
2021-03-30 16:54:56 +02:00
|
|
|
import net.minestom.server.adventure.audience.PacketGroupingAudience;
|
2020-11-13 07:43:35 +01:00
|
|
|
import net.minestom.server.entity.Player;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.listener.manager.PacketListenerManager;
|
2021-08-04 04:00:42 +02:00
|
|
|
import net.minestom.server.network.packet.FramedPacket;
|
2021-03-12 16:33:19 +01:00
|
|
|
import net.minestom.server.network.packet.server.ComponentHoldingServerPacket;
|
2020-04-24 03:25:58 +02:00
|
|
|
import net.minestom.server.network.packet.server.ServerPacket;
|
2020-11-20 03:57:05 +01:00
|
|
|
import net.minestom.server.network.player.PlayerConnection;
|
2021-08-11 14:18:04 +02:00
|
|
|
import net.minestom.server.network.player.PlayerSocketConnection;
|
2021-08-04 12:41:15 +02:00
|
|
|
import net.minestom.server.network.socket.Server;
|
2021-08-24 14:59:17 +02:00
|
|
|
import net.minestom.server.utils.binary.BinaryBuffer;
|
2020-08-19 20:34:21 +02:00
|
|
|
import net.minestom.server.utils.binary.BinaryWriter;
|
2021-09-13 23:01:37 +02:00
|
|
|
import net.minestom.server.utils.binary.PooledBuffers;
|
2020-12-14 06:06:28 +01:00
|
|
|
import net.minestom.server.utils.callback.validator.PlayerValidator;
|
2021-08-11 14:47:20 +02:00
|
|
|
import org.jetbrains.annotations.ApiStatus;
|
2020-11-05 22:20:51 +01:00
|
|
|
import org.jetbrains.annotations.NotNull;
|
2021-08-24 14:59:17 +02:00
|
|
|
import org.jetbrains.annotations.Nullable;
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2021-06-20 20:59:53 +02:00
|
|
|
import java.nio.ByteBuffer;
|
2021-08-25 09:01:13 +02:00
|
|
|
import java.util.*;
|
2021-08-13 01:08:19 +02:00
|
|
|
import java.util.concurrent.ConcurrentHashMap;
|
2021-08-24 14:59:17 +02:00
|
|
|
import java.util.function.Consumer;
|
2021-06-20 20:59:53 +02:00
|
|
|
import java.util.zip.Deflater;
|
2020-11-13 07:43:35 +01:00
|
|
|
|
2020-08-15 04:05:15 +02:00
|
|
|
/**
|
2021-08-03 12:57:13 +02:00
|
|
|
* Utils class for packets. Including writing a {@link ServerPacket} into a {@link ByteBuffer}
|
2020-11-13 09:17:53 +01:00
|
|
|
* for network processing.
|
2021-09-06 13:40:11 +02:00
|
|
|
* <p>
|
|
|
|
* Note that all methods are mostly internal and can change at any moment.
|
|
|
|
* This is due to their very unsafe nature (use of local buffers as cache) and their potential performance impact.
|
|
|
|
* Be sure to check the implementation code.
|
2020-08-15 04:05:15 +02:00
|
|
|
*/
|
2020-08-07 08:10:10 +02:00
|
|
|
public final class PacketUtils {
|
2020-11-20 03:57:05 +01:00
|
|
|
private static final PacketListenerManager PACKET_LISTENER_MANAGER = MinecraftServer.getPacketListenerManager();
|
2021-09-08 20:31:13 +02:00
|
|
|
private static final ThreadLocal<Deflater> LOCAL_DEFLATER = ThreadLocal.withInitial(Deflater::new);
|
2021-09-13 22:12:07 +02:00
|
|
|
|
|
|
|
/// Local buffers
|
2021-09-04 16:43:45 +02:00
|
|
|
private static final LocalCache PACKET_BUFFER = LocalCache.get("packet-buffer", Server.MAX_PACKET_SIZE);
|
2021-09-10 06:35:34 +02:00
|
|
|
private static final LocalCache LOCAL_BUFFER = LocalCache.get("local-buffer", Server.MAX_PACKET_SIZE);
|
2020-11-20 05:37:13 +01:00
|
|
|
|
2021-09-13 22:12:07 +02:00
|
|
|
// Viewable packets
|
2021-08-26 10:36:31 +02:00
|
|
|
private static final Object VIEWABLE_PACKET_LOCK = new Object();
|
|
|
|
private static final Map<Viewable, ViewableStorage> VIEWABLE_STORAGE_MAP = new WeakHashMap<>();
|
|
|
|
|
2020-08-07 08:10:10 +02:00
|
|
|
private PacketUtils() {
|
|
|
|
}
|
2019-08-22 14:52:32 +02:00
|
|
|
|
2021-08-26 10:55:56 +02:00
|
|
|
@ApiStatus.Internal
|
|
|
|
@ApiStatus.Experimental
|
|
|
|
public static ByteBuffer localBuffer() {
|
2021-09-10 06:35:34 +02:00
|
|
|
return LOCAL_BUFFER.get();
|
2021-08-26 10:55:56 +02:00
|
|
|
}
|
|
|
|
|
2021-03-30 16:54:56 +02:00
|
|
|
/**
|
|
|
|
* Sends a packet to an audience. This method performs the following steps in the
|
|
|
|
* following order:
|
|
|
|
* <ol>
|
|
|
|
* <li>If {@code audience} is a {@link Player}, send the packet to them.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link PacketGroupingAudience}, call
|
|
|
|
* {@link #sendGroupedPacket(Collection, ServerPacket)} on the players that the
|
|
|
|
* grouping audience contains.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link ForwardingAudience.Single},
|
|
|
|
* call this method on the single audience inside the forwarding audience.</li>
|
|
|
|
* <li>Otherwise, if {@code audience} is a {@link ForwardingAudience}, call this
|
|
|
|
* method for each audience member of the forwarding audience.</li>
|
|
|
|
* <li>Otherwise, do nothing.</li>
|
|
|
|
* </ol>
|
|
|
|
*
|
|
|
|
* @param audience the audience
|
2021-05-08 22:45:57 +02:00
|
|
|
* @param packet the packet
|
2021-03-30 16:54:56 +02:00
|
|
|
*/
|
|
|
|
@SuppressWarnings("OverrideOnly") // we need to access the audiences inside ForwardingAudience
|
|
|
|
public static void sendPacket(@NotNull Audience audience, @NotNull ServerPacket packet) {
|
|
|
|
if (audience instanceof Player) {
|
|
|
|
((Player) audience).getPlayerConnection().sendPacket(packet);
|
|
|
|
} else if (audience instanceof PacketGroupingAudience) {
|
|
|
|
PacketUtils.sendGroupedPacket(((PacketGroupingAudience) audience).getPlayers(), packet);
|
|
|
|
} else if (audience instanceof ForwardingAudience.Single) {
|
|
|
|
PacketUtils.sendPacket(((ForwardingAudience.Single) audience).audience(), packet);
|
|
|
|
} else if (audience instanceof ForwardingAudience) {
|
|
|
|
for (Audience member : ((ForwardingAudience) audience).audiences()) {
|
|
|
|
PacketUtils.sendPacket(member, packet);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-11-13 09:17:53 +01:00
|
|
|
/**
|
2020-11-20 03:57:05 +01:00
|
|
|
* Sends a {@link ServerPacket} to multiple players.
|
2020-11-13 09:17:53 +01:00
|
|
|
* <p>
|
2020-11-20 03:57:05 +01:00
|
|
|
* Can drastically improve performance since the packet will not have to be processed as much.
|
2020-11-13 09:17:53 +01:00
|
|
|
*
|
2020-12-14 06:06:28 +01:00
|
|
|
* @param players the players to send the packet to
|
|
|
|
* @param packet the packet to send to the players
|
|
|
|
* @param playerValidator optional callback to check if a specify player of {@code players} should receive the packet
|
2020-11-13 09:17:53 +01:00
|
|
|
*/
|
2020-12-14 06:06:28 +01:00
|
|
|
public static void sendGroupedPacket(@NotNull Collection<Player> players, @NotNull ServerPacket packet,
|
2021-08-04 16:49:01 +02:00
|
|
|
@NotNull PlayerValidator playerValidator) {
|
2020-11-20 14:14:55 +01:00
|
|
|
if (players.isEmpty())
|
|
|
|
return;
|
2021-03-12 16:33:19 +01:00
|
|
|
// work out if the packet needs to be sent individually due to server-side translating
|
|
|
|
boolean needsTranslating = false;
|
2021-06-11 17:19:11 +02:00
|
|
|
if (MinestomAdventure.AUTOMATIC_COMPONENT_TRANSLATION && packet instanceof ComponentHoldingServerPacket) {
|
|
|
|
needsTranslating = ComponentUtils.areAnyTranslatable(((ComponentHoldingServerPacket) packet).components());
|
2021-03-12 16:33:19 +01:00
|
|
|
}
|
|
|
|
if (MinecraftServer.hasGroupedPacket() && !needsTranslating) {
|
2021-01-02 15:44:50 +01:00
|
|
|
// Send grouped packet...
|
2021-08-04 16:49:01 +02:00
|
|
|
if (!PACKET_LISTENER_MANAGER.processServerPacket(packet, players))
|
|
|
|
return;
|
2021-09-07 01:24:51 +02:00
|
|
|
final ByteBuffer finalBuffer = createFramedPacket(packet).flip();
|
2021-08-13 19:58:14 +02:00
|
|
|
final FramedPacket framedPacket = new FramedPacket(packet.getId(), finalBuffer, packet);
|
2021-08-04 16:49:01 +02:00
|
|
|
// Send packet to all players
|
|
|
|
for (Player player : players) {
|
|
|
|
if (!player.isOnline() || !playerValidator.isValid(player))
|
|
|
|
continue;
|
|
|
|
final PlayerConnection connection = player.getPlayerConnection();
|
2021-08-08 19:11:47 +02:00
|
|
|
if (connection instanceof PlayerSocketConnection) {
|
|
|
|
((PlayerSocketConnection) connection).write(framedPacket);
|
2021-08-04 16:49:01 +02:00
|
|
|
} else {
|
|
|
|
connection.sendPacket(packet);
|
2021-01-02 15:44:50 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Write the same packet for each individual players
|
2020-11-20 03:57:05 +01:00
|
|
|
for (Player player : players) {
|
2021-08-04 16:49:01 +02:00
|
|
|
if (!player.isOnline() || !playerValidator.isValid(player))
|
2020-12-14 06:06:28 +01:00
|
|
|
continue;
|
2021-08-04 00:37:17 +02:00
|
|
|
player.getPlayerConnection().sendPacket(packet, false);
|
2020-11-20 03:57:05 +01:00
|
|
|
}
|
2020-11-13 07:43:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-14 06:06:28 +01:00
|
|
|
/**
|
|
|
|
* Same as {@link #sendGroupedPacket(Collection, ServerPacket, PlayerValidator)}
|
|
|
|
* but with the player validator sets to null.
|
|
|
|
*
|
|
|
|
* @see #sendGroupedPacket(Collection, ServerPacket, PlayerValidator)
|
|
|
|
*/
|
|
|
|
public static void sendGroupedPacket(@NotNull Collection<Player> players, @NotNull ServerPacket packet) {
|
2021-08-04 16:49:01 +02:00
|
|
|
sendGroupedPacket(players, packet, player -> true);
|
2020-12-14 06:06:28 +01:00
|
|
|
}
|
|
|
|
|
2021-08-11 14:18:04 +02:00
|
|
|
public static void broadcastPacket(@NotNull ServerPacket packet) {
|
|
|
|
sendGroupedPacket(MinecraftServer.getConnectionManager().getOnlinePlayers(), packet);
|
|
|
|
}
|
|
|
|
|
2021-08-26 10:36:31 +02:00
|
|
|
@ApiStatus.Experimental
|
|
|
|
public static void prepareViewablePacket(@NotNull Viewable viewable, @NotNull ServerPacket serverPacket,
|
|
|
|
@Nullable Player player) {
|
|
|
|
if (player != null && !player.isAutoViewable()) {
|
|
|
|
// Operation cannot be optimized
|
|
|
|
player.sendPacketToViewers(serverPacket);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ViewableStorage viewableStorage;
|
|
|
|
synchronized (VIEWABLE_PACKET_LOCK) {
|
|
|
|
viewableStorage = VIEWABLE_STORAGE_MAP.computeIfAbsent(viewable, ViewableStorage::new);
|
|
|
|
}
|
|
|
|
viewableStorage.append(serverPacket, player != null ? player.getPlayerConnection() : null);
|
|
|
|
}
|
|
|
|
|
|
|
|
@ApiStatus.Experimental
|
|
|
|
public static void prepareViewablePacket(@NotNull Viewable viewable, @NotNull ServerPacket serverPacket) {
|
|
|
|
prepareViewablePacket(viewable, serverPacket, null);
|
|
|
|
}
|
|
|
|
|
|
|
|
@ApiStatus.Internal
|
|
|
|
public static void flush() {
|
|
|
|
synchronized (VIEWABLE_PACKET_LOCK) {
|
|
|
|
for (ViewableStorage viewableStorage : VIEWABLE_STORAGE_MAP.values()) {
|
|
|
|
viewableStorage.process();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-03 12:57:13 +02:00
|
|
|
public static void writeFramedPacket(@NotNull ByteBuffer buffer,
|
2021-08-03 21:16:24 +02:00
|
|
|
@NotNull ServerPacket packet,
|
|
|
|
boolean compression) {
|
|
|
|
if (!compression) {
|
2021-09-08 20:31:13 +02:00
|
|
|
// Uncompressed format https://wiki.vg/Protocol#Without_compression
|
2021-08-03 21:16:24 +02:00
|
|
|
final int lengthIndex = Utils.writeEmptyVarIntHeader(buffer);
|
|
|
|
Utils.writeVarInt(buffer, packet.getId());
|
|
|
|
packet.write(new BinaryWriter(buffer));
|
|
|
|
final int finalSize = buffer.position() - (lengthIndex + 3);
|
|
|
|
Utils.writeVarIntHeader(buffer, lengthIndex, finalSize);
|
|
|
|
return;
|
|
|
|
}
|
2021-09-08 20:31:13 +02:00
|
|
|
// Compressed format https://wiki.vg/Protocol#With_compression
|
2021-08-03 21:16:24 +02:00
|
|
|
final int compressedIndex = Utils.writeEmptyVarIntHeader(buffer);
|
|
|
|
final int uncompressedIndex = Utils.writeEmptyVarIntHeader(buffer);
|
|
|
|
|
2021-09-09 00:26:10 +02:00
|
|
|
final int contentStart = buffer.position();
|
2021-08-03 21:16:24 +02:00
|
|
|
Utils.writeVarInt(buffer, packet.getId());
|
2021-09-08 22:26:18 +02:00
|
|
|
packet.write(BinaryWriter.view(buffer)); // ensure that the buffer is not resized/changed
|
2021-08-03 21:16:24 +02:00
|
|
|
final int packetSize = buffer.position() - contentStart;
|
|
|
|
if (packetSize >= MinecraftServer.getCompressionThreshold()) {
|
|
|
|
// Packet large enough, compress
|
2021-09-05 02:50:59 +02:00
|
|
|
buffer.position(contentStart);
|
2021-09-07 01:31:34 +02:00
|
|
|
final ByteBuffer uncompressedContent = buffer.slice().limit(packetSize);
|
2021-09-05 02:50:59 +02:00
|
|
|
final ByteBuffer uncompressedCopy = localBuffer().put(uncompressedContent).flip();
|
2021-08-03 21:16:24 +02:00
|
|
|
|
2021-09-08 20:31:13 +02:00
|
|
|
Deflater deflater = LOCAL_DEFLATER.get();
|
2021-08-04 00:37:17 +02:00
|
|
|
deflater.setInput(uncompressedCopy);
|
2021-08-03 21:16:24 +02:00
|
|
|
deflater.finish();
|
|
|
|
deflater.deflate(buffer);
|
|
|
|
deflater.reset();
|
|
|
|
|
2021-09-08 22:26:18 +02:00
|
|
|
Utils.writeVarIntHeader(buffer, compressedIndex, buffer.position() - uncompressedIndex);
|
|
|
|
Utils.writeVarIntHeader(buffer, uncompressedIndex, packetSize); // Data Length
|
2021-03-26 15:58:46 +01:00
|
|
|
} else {
|
2021-09-09 00:26:10 +02:00
|
|
|
// Packet too small
|
|
|
|
Utils.writeVarIntHeader(buffer, compressedIndex, buffer.position() - uncompressedIndex);
|
2021-09-08 22:26:18 +02:00
|
|
|
Utils.writeVarIntHeader(buffer, uncompressedIndex, 0); // Data Length (0 since uncompressed)
|
2021-03-26 13:08:05 +01:00
|
|
|
}
|
|
|
|
}
|
2021-08-04 12:41:15 +02:00
|
|
|
|
2021-09-05 02:50:59 +02:00
|
|
|
public static ByteBuffer createFramedPacket(@NotNull ServerPacket packet, boolean compression) {
|
|
|
|
ByteBuffer buffer = PACKET_BUFFER.get();
|
|
|
|
writeFramedPacket(buffer, packet, compression);
|
2021-08-04 12:41:15 +02:00
|
|
|
return buffer;
|
|
|
|
}
|
2021-08-04 16:49:01 +02:00
|
|
|
|
|
|
|
public static ByteBuffer createFramedPacket(@NotNull ServerPacket packet) {
|
2021-09-05 02:50:59 +02:00
|
|
|
return createFramedPacket(packet, MinecraftServer.getCompressionThreshold() > 0);
|
2021-08-05 03:09:45 +02:00
|
|
|
}
|
|
|
|
|
2021-08-14 14:39:11 +02:00
|
|
|
@ApiStatus.Internal
|
|
|
|
public static FramedPacket allocateTrimmedPacket(@NotNull ServerPacket packet) {
|
2021-09-05 02:50:59 +02:00
|
|
|
final ByteBuffer temp = PacketUtils.createFramedPacket(packet).flip();
|
2021-09-07 01:24:51 +02:00
|
|
|
final ByteBuffer buffer = ByteBuffer.allocateDirect(temp.remaining())
|
|
|
|
.put(temp).flip().asReadOnlyBuffer();
|
2021-08-14 14:39:11 +02:00
|
|
|
return new FramedPacket(packet.getId(), buffer, packet);
|
2021-08-05 00:08:53 +02:00
|
|
|
}
|
2021-08-13 01:08:19 +02:00
|
|
|
|
|
|
|
@ApiStatus.Internal
|
2021-08-13 01:13:58 +02:00
|
|
|
public static final class LocalCache {
|
|
|
|
private static final Map<String, LocalCache> CACHES = new ConcurrentHashMap<>();
|
2021-08-13 01:08:19 +02:00
|
|
|
|
|
|
|
private final String name;
|
|
|
|
private final ThreadLocal<ByteBuffer> cache;
|
|
|
|
|
2021-08-13 01:13:58 +02:00
|
|
|
private LocalCache(String name, int size) {
|
2021-08-13 01:08:19 +02:00
|
|
|
this.name = name;
|
|
|
|
this.cache = ThreadLocal.withInitial(() -> ByteBuffer.allocateDirect(size));
|
|
|
|
}
|
|
|
|
|
2021-08-13 01:13:58 +02:00
|
|
|
public static LocalCache get(String name, int size) {
|
2021-09-08 22:26:18 +02:00
|
|
|
return CACHES.computeIfAbsent(name, s -> new LocalCache(s, size));
|
2021-08-13 01:08:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public String name() {
|
|
|
|
return name;
|
|
|
|
}
|
|
|
|
|
2021-08-13 01:13:58 +02:00
|
|
|
public ByteBuffer get() {
|
2021-08-13 01:08:19 +02:00
|
|
|
return cache.get().clear();
|
|
|
|
}
|
|
|
|
}
|
2021-08-24 14:59:17 +02:00
|
|
|
|
2021-08-25 13:54:09 +02:00
|
|
|
private static final class ViewableStorage {
|
2021-08-24 14:59:17 +02:00
|
|
|
private final Viewable viewable;
|
2021-08-25 13:54:09 +02:00
|
|
|
private final Map<PlayerConnection, List<IntIntPair>> entityIdMap = new HashMap<>();
|
2021-09-14 02:22:58 +02:00
|
|
|
private final BinaryBuffer buffer = PooledBuffers.get();
|
2021-08-24 14:59:17 +02:00
|
|
|
|
|
|
|
private ViewableStorage(Viewable viewable) {
|
|
|
|
this.viewable = viewable;
|
2021-09-14 02:22:58 +02:00
|
|
|
PooledBuffers.registerBuffer(this, buffer);
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
|
|
|
|
2021-08-26 10:36:31 +02:00
|
|
|
private synchronized void append(ServerPacket serverPacket, PlayerConnection connection) {
|
2021-08-25 10:45:35 +02:00
|
|
|
final ByteBuffer framedPacket = createFramedPacket(serverPacket).flip();
|
2021-09-13 23:01:37 +02:00
|
|
|
final int packetSize = framedPacket.limit();
|
|
|
|
if (packetSize >= buffer.capacity()) {
|
|
|
|
processSingle(framedPacket, connection);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!buffer.canWrite(packetSize)) process();
|
2021-08-24 14:59:17 +02:00
|
|
|
final int start = buffer.writerOffset();
|
2021-09-13 23:01:37 +02:00
|
|
|
buffer.write(framedPacket);
|
2021-08-24 14:59:17 +02:00
|
|
|
final int end = buffer.writerOffset();
|
2021-08-26 10:36:31 +02:00
|
|
|
if (connection != null) {
|
|
|
|
List<IntIntPair> list = entityIdMap.computeIfAbsent(connection, con -> new ArrayList<>());
|
2021-08-25 09:01:13 +02:00
|
|
|
list.add(IntIntPair.of(start, end));
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-25 09:01:13 +02:00
|
|
|
private synchronized void process() {
|
2021-09-14 02:22:58 +02:00
|
|
|
if (buffer.writerOffset() == 0)
|
|
|
|
return; // TODO: there is nothing in the buffer, remove from VIEWABLE_STORAGE_MAP
|
2021-08-25 17:25:08 +02:00
|
|
|
for (Player player : viewable.getViewers()) {
|
2021-08-25 09:01:13 +02:00
|
|
|
PlayerConnection connection = player.getPlayerConnection();
|
|
|
|
Consumer<ByteBuffer> writer = connection instanceof PlayerSocketConnection
|
|
|
|
? ((PlayerSocketConnection) connection)::write :
|
|
|
|
byteBuffer -> {
|
|
|
|
// TODO for non-socket connection
|
|
|
|
};
|
|
|
|
|
2021-08-25 13:54:09 +02:00
|
|
|
int lastWrite = 0;
|
|
|
|
final List<IntIntPair> pairs = entityIdMap.get(connection);
|
2021-09-07 04:47:33 +02:00
|
|
|
if (pairs != null) {
|
2021-08-25 10:45:35 +02:00
|
|
|
for (IntIntPair pair : pairs) {
|
2021-08-24 14:59:17 +02:00
|
|
|
final int start = pair.leftInt();
|
2021-08-25 13:54:09 +02:00
|
|
|
if (start != lastWrite) {
|
2021-09-07 04:47:33 +02:00
|
|
|
ByteBuffer slice = buffer.asByteBuffer(lastWrite, start - lastWrite);
|
2021-08-25 09:01:13 +02:00
|
|
|
writer.accept(slice);
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
2021-08-25 10:45:35 +02:00
|
|
|
lastWrite = pair.rightInt();
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
2021-08-25 13:54:09 +02:00
|
|
|
}
|
|
|
|
// Write remaining
|
|
|
|
final int remaining = buffer.writerOffset() - lastWrite;
|
|
|
|
if (remaining > 0) {
|
|
|
|
ByteBuffer remainSlice = buffer.asByteBuffer(lastWrite, remaining);
|
|
|
|
writer.accept(remainSlice);
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
2021-08-25 09:01:13 +02:00
|
|
|
}
|
2021-08-25 13:54:09 +02:00
|
|
|
// Clear state
|
|
|
|
this.entityIdMap.clear();
|
2021-09-14 02:22:58 +02:00
|
|
|
this.buffer.clear();
|
2021-09-13 23:01:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private synchronized void processSingle(ByteBuffer buffer, PlayerConnection exception) {
|
|
|
|
process();
|
|
|
|
for (Player player : viewable.getViewers()) {
|
|
|
|
PlayerConnection connection = player.getPlayerConnection();
|
|
|
|
if (Objects.equals(connection, exception)) continue;
|
2021-09-14 02:22:58 +02:00
|
|
|
if (connection instanceof PlayerSocketConnection) {
|
|
|
|
((PlayerSocketConnection) connection).write(buffer.position(0));
|
2021-09-13 23:01:37 +02:00
|
|
|
}
|
|
|
|
// TODO for non-socket connection
|
|
|
|
}
|
2021-08-24 14:59:17 +02:00
|
|
|
}
|
|
|
|
}
|
2019-08-22 14:52:32 +02:00
|
|
|
}
|