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

Encoding != Rendering. Renamed confusing class name

Browse Source
This commit is contained in:
Nanit 2021-10-28 21:05:56 +03:00
parent 5c94dcffea
commit 1c6da4ee0a
4 changed files with 52 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,7 +7,7 @@ import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.channel.ChannelInboundHandlerAdapter;
import ru.nanit.limbo.LimboConstants; import ru.nanit.limbo.LimboConstants;
import ru.nanit.limbo.protocol.ByteMessage; import ru.nanit.limbo.protocol.ByteMessage;
import ru.nanit.limbo.protocol.PreRenderedPacket; import ru.nanit.limbo.protocol.PreEncodedPacket;
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.*;
import ru.nanit.limbo.connection.pipeline.PacketDecoder; import ru.nanit.limbo.connection.pipeline.PacketDecoder;
@ -34,14 +34,14 @@ import java.util.concurrent.ThreadLocalRandom;
public class ClientConnection extends ChannelInboundHandlerAdapter { public class ClientConnection extends ChannelInboundHandlerAdapter {
private static PreRenderedPacket PACKET_LOGIN_SUCCESS; private static PreEncodedPacket PACKET_LOGIN_SUCCESS;
private static PreRenderedPacket PACKET_JOIN_GAME; private static PreEncodedPacket PACKET_JOIN_GAME;
private static PreRenderedPacket PACKET_PLAYER_ABILITIES; private static PreEncodedPacket PACKET_PLAYER_ABILITIES;
private static PreRenderedPacket PACKET_PLAYER_INFO; private static PreEncodedPacket PACKET_PLAYER_INFO;
private static PreRenderedPacket PACKET_DECLARE_COMMANDS; private static PreEncodedPacket PACKET_DECLARE_COMMANDS;
private static PreRenderedPacket PACKET_PLAYER_POS; private static PreEncodedPacket PACKET_PLAYER_POS;
private static PreRenderedPacket PACKET_JOIN_MESSAGE; private static PreEncodedPacket PACKET_JOIN_MESSAGE;
private static PreRenderedPacket PACKET_BOSS_BAR; private static PreEncodedPacket PACKET_BOSS_BAR;
private final LimboServer server; private final LimboServer server;
private final Channel channel; private final Channel channel;
@ -318,26 +318,26 @@ public class ClientConnection extends ChannelInboundHandlerAdapter {
PacketDeclareCommands declareCommands = new PacketDeclareCommands(); PacketDeclareCommands declareCommands = new PacketDeclareCommands();
declareCommands.setCommands(Collections.singletonList("limbo")); declareCommands.setCommands(Collections.singletonList("limbo"));
PACKET_LOGIN_SUCCESS = PreRenderedPacket.of(loginSuccess); PACKET_LOGIN_SUCCESS = PreEncodedPacket.of(loginSuccess);
PACKET_JOIN_GAME = PreRenderedPacket.of(joinGame); PACKET_JOIN_GAME = PreEncodedPacket.of(joinGame);
PACKET_PLAYER_ABILITIES = PreRenderedPacket.of(playerAbilities); PACKET_PLAYER_ABILITIES = PreEncodedPacket.of(playerAbilities);
PACKET_PLAYER_POS = PreRenderedPacket.of(positionAndLook); PACKET_PLAYER_POS = PreEncodedPacket.of(positionAndLook);
PACKET_PLAYER_INFO = PreRenderedPacket.of(info); PACKET_PLAYER_INFO = PreEncodedPacket.of(info);
PACKET_DECLARE_COMMANDS = PreRenderedPacket.of(declareCommands); PACKET_DECLARE_COMMANDS = PreEncodedPacket.of(declareCommands);
if (server.getConfig().isUseJoinMessage()){ if (server.getConfig().isUseJoinMessage()){
PacketChatMessage joinMessage = new PacketChatMessage(); PacketChatMessage joinMessage = new PacketChatMessage();
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 = PreRenderedPacket.of(joinMessage); PACKET_JOIN_MESSAGE = PreEncodedPacket.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 = PreRenderedPacket.of(bossBar); PACKET_BOSS_BAR = PreEncodedPacket.of(bossBar);
} }
} }
} }

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.PreRenderedPacket; import ru.nanit.limbo.protocol.PreEncodedPacket;
import ru.nanit.limbo.protocol.registry.State; import ru.nanit.limbo.protocol.registry.State;
import ru.nanit.limbo.util.Logger; import ru.nanit.limbo.util.Logger;
@ -24,8 +24,8 @@ public class PacketEncoder extends MessageToByteEncoder<Packet> {
ByteMessage msg = new ByteMessage(out); ByteMessage msg = new ByteMessage(out);
int packetId; int packetId;
if (packet instanceof PreRenderedPacket){ if (packet instanceof PreEncodedPacket){
packetId = registry.getPacketId(((PreRenderedPacket)packet).getWrappedPacket().getClass()); packetId = registry.getPacketId(((PreEncodedPacket)packet).getWrappedPacket().getClass());
} else { } else {
packetId = registry.getPacketId(packet.getClass()); packetId = registry.getPacketId(packet.getClass());
} }

32
src/main/java/ru/nanit/limbo/protocol/PreEncodedPacket.java Normal file
View File

@ -0,0 +1,32 @@
package ru.nanit.limbo.protocol;
public class PreEncodedPacket implements PacketOut {
private final PacketOut packet;
private byte[] message;
public PreEncodedPacket(PacketOut packet) {
this.packet = packet;
}
public PacketOut getWrappedPacket() {
return packet;
}
public PreEncodedPacket encodePacket() {
ByteMessage encodedMessage = ByteMessage.create();
packet.encode(encodedMessage);
this.message = encodedMessage.toByteArray();
encodedMessage.release();
return this;
}
@Override
public void encode(ByteMessage msg) {
msg.writeBytes(message);
}
public static PreEncodedPacket of(PacketOut packet) {
return new PreEncodedPacket(packet).encodePacket();
}
}

32
src/main/java/ru/nanit/limbo/protocol/PreRenderedPacket.java
View File

@ -1,32 +0,0 @@
package ru.nanit.limbo.protocol;
public class PreRenderedPacket implements PacketOut {
private final PacketOut packet;
private byte[] message;
public PreRenderedPacket(PacketOut packet){
this.packet = packet;
}
public PacketOut getWrappedPacket(){
return packet;
}
public PreRenderedPacket render(){
ByteMessage renderedMessage = ByteMessage.create();
packet.encode(renderedMessage);
this.message = renderedMessage.toByteArray();
renderedMessage.release();
return this;
}
@Override
public void encode(ByteMessage msg) {
msg.writeBytes(message);
}
public static PreRenderedPacket of(PacketOut packet){
return new PreRenderedPacket(packet).render();
}
}