AdlC/PicoLimbo
AdlC/PicoLimbo
1
0
Fork 0
mirror of https://github.com/Nan1t/NanoLimbo.git synced 2025-07-16 14:10:13 +02:00
Code Issues Packages Projects Releases Wiki Activity

Renamed PreEncodedPacket. Removed unused classes

Browse Source
This commit is contained in:
Nanit 2022-01-23 12:08:57 +02:00
parent f1f5d68dd6
commit 2e69580271
5 changed files with 40 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/main/java/ru/nanit/limbo/connection/ClientConnection.java
View File

@ -13,7 +13,7 @@ import ru.nanit.limbo.LimboConstants;
import ru.nanit.limbo.connection.pipeline.PacketDecoder; import ru.nanit.limbo.connection.pipeline.PacketDecoder;
import ru.nanit.limbo.connection.pipeline.PacketEncoder; import ru.nanit.limbo.connection.pipeline.PacketEncoder;
import ru.nanit.limbo.protocol.ByteMessage; import ru.nanit.limbo.protocol.ByteMessage;
import ru.nanit.limbo.protocol.PreEncodedPacket; import ru.nanit.limbo.protocol.PacketSnapshot;
import ru.nanit.limbo.protocol.packets.PacketHandshake; import ru.nanit.limbo.protocol.packets.PacketHandshake;
import ru.nanit.limbo.protocol.packets.login.*; import ru.nanit.limbo.protocol.packets.login.*;
import ru.nanit.limbo.protocol.packets.play.*; import ru.nanit.limbo.protocol.packets.play.*;
@ -39,23 +39,23 @@ import java.util.concurrent.ThreadLocalRandom;
public class ClientConnection extends ChannelInboundHandlerAdapter { public class ClientConnection extends ChannelInboundHandlerAdapter {
private static PreEncodedPacket PACKET_LOGIN_SUCCESS; private static PacketSnapshot PACKET_LOGIN_SUCCESS;
private static PreEncodedPacket PACKET_JOIN_GAME; private static PacketSnapshot PACKET_JOIN_GAME;
private static PreEncodedPacket PACKET_PLUGIN_MESSAGE; private static PacketSnapshot PACKET_PLUGIN_MESSAGE;
private static PreEncodedPacket PACKET_PLAYER_ABILITIES; private static PacketSnapshot PACKET_PLAYER_ABILITIES;
private static PreEncodedPacket PACKET_PLAYER_INFO; private static PacketSnapshot PACKET_PLAYER_INFO;
private static PreEncodedPacket PACKET_DECLARE_COMMANDS; private static PacketSnapshot PACKET_DECLARE_COMMANDS;
private static PreEncodedPacket PACKET_PLAYER_POS; private static PacketSnapshot PACKET_PLAYER_POS;
private static PreEncodedPacket PACKET_JOIN_MESSAGE; private static PacketSnapshot PACKET_JOIN_MESSAGE;
private static PreEncodedPacket PACKET_BOSS_BAR; private static PacketSnapshot PACKET_BOSS_BAR;
private static PreEncodedPacket PACKET_TITLE_TITLE; private static PacketSnapshot PACKET_TITLE_TITLE;
private static PreEncodedPacket PACKET_TITLE_SUBTITLE; private static PacketSnapshot PACKET_TITLE_SUBTITLE;
private static PreEncodedPacket PACKET_TITLE_TIMES; private static PacketSnapshot PACKET_TITLE_TIMES;
private static PreEncodedPacket PACKET_TITLE_LEGACY_TITLE; private static PacketSnapshot PACKET_TITLE_LEGACY_TITLE;
private static PreEncodedPacket PACKET_TITLE_LEGACY_SUBTITLE; private static PacketSnapshot PACKET_TITLE_LEGACY_SUBTITLE;
private static PreEncodedPacket PACKET_TITLE_LEGACY_TIMES; private static PacketSnapshot PACKET_TITLE_LEGACY_TIMES;
private final LimboServer server; private final LimboServer server;
private final Channel channel; private final Channel channel;
@ -408,18 +408,18 @@ public class ClientConnection extends ChannelInboundHandlerAdapter {
PacketDeclareCommands declareCommands = new PacketDeclareCommands(); PacketDeclareCommands declareCommands = new PacketDeclareCommands();
declareCommands.setCommands(Collections.emptyList()); declareCommands.setCommands(Collections.emptyList());
PACKET_LOGIN_SUCCESS = PreEncodedPacket.of(loginSuccess); PACKET_LOGIN_SUCCESS = PacketSnapshot.of(loginSuccess);
PACKET_JOIN_GAME = PreEncodedPacket.of(joinGame); PACKET_JOIN_GAME = PacketSnapshot.of(joinGame);
PACKET_PLAYER_ABILITIES = PreEncodedPacket.of(playerAbilities); PACKET_PLAYER_ABILITIES = PacketSnapshot.of(playerAbilities);
PACKET_PLAYER_POS = PreEncodedPacket.of(positionAndLook); PACKET_PLAYER_POS = PacketSnapshot.of(positionAndLook);
PACKET_PLAYER_INFO = PreEncodedPacket.of(info); PACKET_PLAYER_INFO = PacketSnapshot.of(info);
PACKET_DECLARE_COMMANDS = PreEncodedPacket.of(declareCommands); PACKET_DECLARE_COMMANDS = PacketSnapshot.of(declareCommands);
if (server.getConfig().isUseBrandName()){ if (server.getConfig().isUseBrandName()){
PacketPluginMessage pluginMessage = new PacketPluginMessage(); PacketPluginMessage pluginMessage = new PacketPluginMessage();
pluginMessage.setChannel("minecraft:brand"); pluginMessage.setChannel("minecraft:brand");
pluginMessage.setMessage(server.getConfig().getBrandName()); pluginMessage.setMessage(server.getConfig().getBrandName());
PACKET_PLUGIN_MESSAGE = PreEncodedPacket.of(pluginMessage); PACKET_PLUGIN_MESSAGE = PacketSnapshot.of(pluginMessage);
} }
if (server.getConfig().isUseJoinMessage()) { if (server.getConfig().isUseJoinMessage()) {
@ -427,14 +427,14 @@ public class ClientConnection extends ChannelInboundHandlerAdapter {
joinMessage.setJsonData(server.getConfig().getJoinMessage()); joinMessage.setJsonData(server.getConfig().getJoinMessage());
joinMessage.setPosition(PacketChatMessage.Position.CHAT); joinMessage.setPosition(PacketChatMessage.Position.CHAT);
joinMessage.setSender(UUID.randomUUID()); joinMessage.setSender(UUID.randomUUID());
PACKET_JOIN_MESSAGE = PreEncodedPacket.of(joinMessage); PACKET_JOIN_MESSAGE = PacketSnapshot.of(joinMessage);
} }
if (server.getConfig().isUseBossBar()) { if (server.getConfig().isUseBossBar()) {
PacketBossBar bossBar = new PacketBossBar(); PacketBossBar bossBar = new PacketBossBar();
bossBar.setBossBar(server.getConfig().getBossBar()); bossBar.setBossBar(server.getConfig().getBossBar());
bossBar.setUuid(UUID.randomUUID()); bossBar.setUuid(UUID.randomUUID());
PACKET_BOSS_BAR = PreEncodedPacket.of(bossBar); PACKET_BOSS_BAR = PacketSnapshot.of(bossBar);
} }
if (server.getConfig().isUseTitle()) { if (server.getConfig().isUseTitle()) {
@ -463,13 +463,13 @@ public class ClientConnection extends ChannelInboundHandlerAdapter {
legacyTimes.setTitle(title); legacyTimes.setTitle(title);
legacyTimes.setAction(PacketTitleLegacy.Action.SET_TIMES_AND_DISPLAY); legacyTimes.setAction(PacketTitleLegacy.Action.SET_TIMES_AND_DISPLAY);
PACKET_TITLE_TITLE = PreEncodedPacket.of(packetTitle); PACKET_TITLE_TITLE = PacketSnapshot.of(packetTitle);
PACKET_TITLE_SUBTITLE = PreEncodedPacket.of(packetSubtitle); PACKET_TITLE_SUBTITLE = PacketSnapshot.of(packetSubtitle);
PACKET_TITLE_TIMES = PreEncodedPacket.of(packetTimes); PACKET_TITLE_TIMES = PacketSnapshot.of(packetTimes);
PACKET_TITLE_LEGACY_TITLE = PreEncodedPacket.of(legacyTitle); PACKET_TITLE_LEGACY_TITLE = PacketSnapshot.of(legacyTitle);
PACKET_TITLE_LEGACY_SUBTITLE = PreEncodedPacket.of(legacySubtitle); PACKET_TITLE_LEGACY_SUBTITLE = PacketSnapshot.of(legacySubtitle);
PACKET_TITLE_LEGACY_TIMES = PreEncodedPacket.of(legacyTimes); PACKET_TITLE_LEGACY_TIMES = PacketSnapshot.of(legacyTimes);
} }
} }
} }

6
src/main/java/ru/nanit/limbo/connection/pipeline/PacketEncoder.java
View File

@ -5,7 +5,7 @@ import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder; import io.netty.handler.codec.MessageToByteEncoder;
import ru.nanit.limbo.protocol.ByteMessage; import ru.nanit.limbo.protocol.ByteMessage;
import ru.nanit.limbo.protocol.Packet; import ru.nanit.limbo.protocol.Packet;
import ru.nanit.limbo.protocol.PreEncodedPacket; import ru.nanit.limbo.protocol.PacketSnapshot;
import ru.nanit.limbo.protocol.registry.State; import ru.nanit.limbo.protocol.registry.State;
import ru.nanit.limbo.protocol.registry.Version; import ru.nanit.limbo.protocol.registry.Version;
import ru.nanit.limbo.util.Logger; import ru.nanit.limbo.util.Logger;
@ -27,8 +27,8 @@ public class PacketEncoder extends MessageToByteEncoder<Packet> {
ByteMessage msg = new ByteMessage(out); ByteMessage msg = new ByteMessage(out);
int packetId; int packetId;
if (packet instanceof PreEncodedPacket) { if (packet instanceof PacketSnapshot) {
packetId = registry.getPacketId(((PreEncodedPacket)packet).getWrappedPacket().getClass()); packetId = registry.getPacketId(((PacketSnapshot)packet).getWrappedPacket().getClass());
} else { } else {
packetId = registry.getPacketId(packet.getClass()); packetId = registry.getPacketId(packet.getClass());
} }

8
src/main/java/ru/nanit/limbo/protocol/Direction.java
View File

@ -1,8 +0,0 @@
package ru.nanit.limbo.protocol;
public enum Direction {
CLIENT,
SERVER
}

10
src/main/java/ru/nanit/limbo/protocol/PreEncodedPacket.java → src/main/java/ru/nanit/limbo/protocol/PacketSnapshot.java
View File

@ -5,12 +5,12 @@ import ru.nanit.limbo.protocol.registry.Version;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
public class PreEncodedPacket implements PacketOut { public class PacketSnapshot implements PacketOut {
private final PacketOut packet; private final PacketOut packet;
private final Map<Version, byte[]> versionMessages; private final Map<Version, byte[]> versionMessages;
public PreEncodedPacket(PacketOut packet) { public PacketSnapshot(PacketOut packet) {
this.packet = packet; this.packet = packet;
this.versionMessages = new HashMap<>(); this.versionMessages = new HashMap<>();
} }
@ -19,7 +19,7 @@ public class PreEncodedPacket implements PacketOut {
return packet; return packet;
} }
public PreEncodedPacket encodePacket() { public PacketSnapshot encodePacket() {
for (Version version : Version.values()) { for (Version version : Version.values()) {
ByteMessage encodedMessage = ByteMessage.create(); ByteMessage encodedMessage = ByteMessage.create();
packet.encode(encodedMessage, version); packet.encode(encodedMessage, version);
@ -45,7 +45,7 @@ public class PreEncodedPacket implements PacketOut {
return packet.getClass().getSimpleName(); return packet.getClass().getSimpleName();
} }
public static PreEncodedPacket of(PacketOut packet) { public static PacketSnapshot of(PacketOut packet) {
return new PreEncodedPacket(packet).encodePacket(); return new PacketSnapshot(packet).encodePacket();
} }
} }

1
src/main/java/ru/nanit/limbo/protocol/packets/play/PacketPluginMessage.java
View File

@ -5,6 +5,7 @@ import ru.nanit.limbo.protocol.PacketOut;
import ru.nanit.limbo.protocol.registry.Version; import ru.nanit.limbo.protocol.registry.Version;
public class PacketPluginMessage implements PacketOut { public class PacketPluginMessage implements PacketOut {
private String channel; private String channel;
private String message; private String message;