Minecraft/mc-server
Archived
0
Fork 0
Code Releases Activity

proto125_netty as module

Browse Source
This commit is contained in:
DmitriyMX
2018-04-22 22:11:24 +03:00
parent fc5e860068
commit a4ee3a9ac3
10 changed files with 15 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
proto125/build.gradle
View File

@@ -1,18 +1,10 @@
group 'mc'
version '1.0-SNAPSHOT'
ext {
netty_version = '4.1.22.Final'
}
dependencies {
/* Core */
compile_excludeCopy project(':core')
/* Netty */
compile (group: 'io.netty', name: 'netty-all', version: netty_version)
/* Components */
compile (group: 'com.google.guava', name: 'guava', version: '24.1-jre')
compile (group: 'com.google.code.gson', name: 'gson', version: '2.8.2')
}

23
proto125/src/main/java/mc/core/network/proto_125/netty/NettyPlayer.java
View File

@@ -1,23 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-15
*/
package mc.core.network.proto_125.netty;
import lombok.Getter;
import lombok.Setter;
import mc.core.Location;
import mc.core.Look;
import mc.core.Player;
import mc.core.network.NetChannel;
@Getter
@Setter
public class NettyPlayer implements Player {
private int id;
private String name;
private boolean online;
private NetChannel channel;
private Location location;
private Look look;
}

75
proto125/src/main/java/mc/core/network/proto_125/netty/NettyServer.java
View File

@@ -1,75 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-10
*/
package mc.core.network.proto_125.netty;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LoggingHandler;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import mc.core.network.Server;
import mc.core.network.StartServerException;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
public class NettyServer implements Server {
@Autowired
private ApplicationContext applicationContext;
@Setter
private String host;
@Setter
private int port;
@Setter
private int workerGroupCount = 0;
private EventLoopGroup bossGroup, workerGroup;
private ChannelInitializer buildChannelInitializer() {
return new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel socketChannel) {
Map<String, ChannelHandler> beans = applicationContext.getBeansOfType(ChannelHandler.class);
beans.forEach(socketChannel.pipeline()::addLast);
}
};
}
private ServerBootstrap buildServerBootstrap() {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(buildChannelInitializer());
return bootstrap;
}
@Override
public void start() throws StartServerException {
log.info("Use protocol 1.2.5");
bossGroup = new NioEventLoopGroup(1);
workerGroup = new NioEventLoopGroup(workerGroupCount);
ServerBootstrap serverBootstrap = buildServerBootstrap();
log.info("Start server: {}:{}", host, port);
try {
serverBootstrap.bind(host, port).sync().channel().closeFuture().sync();
} catch (InterruptedException e) {
throw new StartServerException(e);
}
}
}

41
proto125/src/main/java/mc/core/network/proto_125/netty/PacketDecoder.java
View File

@@ -1,41 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-03-25
*/
package mc.core.network.proto_125.netty;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import lombok.extern.slf4j.Slf4j;
import mc.core.network.CSPacket;
import mc.core.network.NetStream;
import mc.core.network.proto_125.netty.wrappers.WrapperNetStream;
import mc.core.network.proto_125.packets.PacketManager;
import java.util.List;
@Slf4j
public class PacketDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
log.debug("ByteBuf readableBytes: {}", in.readableBytes());
int id = in.readUnsignedByte();
log.debug("Pkt-Id: {} / 0x{}", id, Integer.toHexString(id).toUpperCase());
Class<? extends CSPacket> packetClass = PacketManager.getClientSidePacket(id);
if (packetClass != null) {
NetStream netStream = new WrapperNetStream(in);
CSPacket packet = packetClass.newInstance();
packet.readSelf(netStream);
out.add(packet);
log.debug("{}: {}", packet.getClass().getSimpleName(), packet.toString());
} else {
log.debug("Unknown packet");
}
if (in.readableBytes() > 0)
in.skipBytes(in.readableBytes());
}
}

29
proto125/src/main/java/mc/core/network/proto_125/netty/PacketEncoder.java
View File

@@ -1,29 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-10
*/
package mc.core.network.proto_125.netty;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import lombok.extern.slf4j.Slf4j;
import mc.core.network.SCPacket;
import mc.core.network.proto_125.packets.PacketManager;
@Slf4j
public class PacketEncoder extends MessageToByteEncoder<SCPacket> {
@Override
protected void encode(ChannelHandlerContext ctx, SCPacket pkt, ByteBuf out) throws Exception {
log.debug("{}: {}", pkt.getClass().getSimpleName(), pkt.toString());
Integer id = PacketManager.getServirSidePacket(pkt.getClass());
if (id == null) {
log.warn("Not defined ID packet \"{}\"", pkt.getClass().getSimpleName());
return;
}
byte[] bytes = pkt.toByteArray();
out.writeByte(id);
out.writeBytes(bytes);
}
}

190
proto125/src/main/java/mc/core/network/proto_125/netty/PacketHandler.java
View File

@@ -1,190 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-10
*/
package mc.core.network.proto_125.netty;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.AttributeKey;
import lombok.extern.slf4j.Slf4j;
import mc.core.*;
import mc.core.network.CSPacket;
import mc.core.network.proto_125.netty.wrappers.WrapperNetChannel;
import mc.core.network.proto_125.packets.*;
import org.springframework.beans.factory.annotation.Autowired;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Optional;
import java.util.Random;
@Slf4j
public class PacketHandler extends SimpleChannelInboundHandler<CSPacket> {
private static final Random random = new Random();
private static final AttributeKey<Player> ATTR_PLAYER = AttributeKey.newInstance("ATTR_PLAYER");
@Autowired
private Config config;
@Autowired
private PlayerManager playerManager;
@Override
public void channelInactive(ChannelHandlerContext context) throws Exception {
super.channelInactive(context);
Player player = context.channel().attr(ATTR_PLAYER).get();
if (player != null) {
playerManager.removePlayer(player);
}
context.channel().attr(ATTR_PLAYER).set(null);
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, CSPacket packet) throws Exception {
Optional<Method> optionalMethod = Arrays.stream(this.getClass().getDeclaredMethods())
.filter(method -> method.getName().equals("on" + packet.getClass().getSimpleName())
&& method.getParameterCount() == 2
&& method.getParameterTypes()[0].isAssignableFrom(Channel.class)
&& method.getParameterTypes()[1].isAssignableFrom(packet.getClass()))
.findFirst();
if (optionalMethod.isPresent()) {
Method method = optionalMethod.get();
method.invoke(this, ctx.channel(), packet);
}
}
public void onPingPacket(Channel channel, PingPacket packet) {
KickPacket pkt = new KickPacket();
pkt.setPongMessage(config.getDescriptionServer(), 0, config.getMaxPlayers());
channel.writeAndFlush(pkt);
}
public void onHandshakePacket(Channel channel, HandshakePacket packet) {
channel.writeAndFlush(packet);
}
public void onLoginPacket(Channel channel, LoginPacket packet) {
final Location spawnLoc = new Location(0, 65, 0);
Player player;
Optional<Player> optPlayer = playerManager.getPlayer(packet.getPlayerName());
if (optPlayer.isPresent()) {
player = optPlayer.get();
} else {
int pId = random.nextInt(9999);
player = new NettyPlayer();
player.setId(pId);
player.setName(packet.getPlayerName());
player.setLocation(spawnLoc);
player.setLook(new Look(0f, 0f));
player.setOnline(true);
playerManager.addPlayer(player);
}
// Response login
packet.setPlayerId(player.getId());
packet.setLevelType("flat");
packet.setServerMode(1/*creative*/);
packet.setDimension(0/*Overworld*/);
packet.setDifficulty(0/*Peaceful*/);
packet.setMaxPlayers(config.getMaxPlayers());
channel.write(packet);
// send Spawn position
SpawnPositionPacket spawnPkt = new SpawnPositionPacket();
spawnPkt.setLocation(spawnLoc);
channel.write(spawnPkt);
// send Player abilities
PlayerAbilitiesPacket abilitiesPkt = new PlayerAbilitiesPacket();
abilitiesPkt.setCanFly(true);
abilitiesPkt.setFlying(true);
abilitiesPkt.setGodMode(true);
abilitiesPkt.setInstantDestroyBlocks(true);
channel.write(abilitiesPkt);
// send Player info
PlayerInfoPacket infoPkt = new PlayerInfoPacket();
infoPkt.setPlayerName(player.getName());
infoPkt.setOnline(true);
infoPkt.setPing(4);
channel.write(infoPkt);
// send Chunk allocation
ChunkAllocationPacket chInitPkt = new ChunkAllocationPacket();
chInitPkt.setX(0);
chInitPkt.setZ(0);
chInitPkt.setInitChunk(true);
channel.write(chInitPkt);
for (int x = -17; x <= 17; x++) {
for (int z = -17; z <= 17; z++) {
if (x == 0 && z == 0) continue;
chInitPkt = new ChunkAllocationPacket();
chInitPkt.setX(x);
chInitPkt.setZ(z);
chInitPkt.setInitChunk(true);
channel.write(chInitPkt);
}
}
// send Chunk data
ChunkDataPacket chDataPkt = new ChunkDataPacket();
chDataPkt.setX(0);
chDataPkt.setZ(0);
chDataPkt.setNeedInitChunk(false);
chDataPkt.setYMin(0);
chDataPkt.setYMax(0);
channel.write(chDataPkt);
for (int x = -17; x <= 17; x++) {
for (int z = -17; z <= 17; z++) {
if (x == 0 && z == 0) continue;
chDataPkt = new ChunkDataPacket();
chDataPkt.setX(x);
chDataPkt.setZ(z);
chDataPkt.setNeedInitChunk(false);
chDataPkt.setYMin(0);
chDataPkt.setYMax(0);
channel.write(chDataPkt);
}
}
// send Position and look
PositionAndLookPacket posLookPkt = new PositionAndLookPacket();
posLookPkt.setLocation(player.getLocation());
posLookPkt.setStance(player.getLocation().getY() + 1.64d);
posLookPkt.setLook(player.getLook());
posLookPkt.setOnGround(false);
channel.write(posLookPkt);
channel.attr(ATTR_PLAYER).set(player);
player.setChannel(new WrapperNetChannel(channel));
player.setOnline(true);
channel.flush();
}
public void onKickPacket(Channel channel, KickPacket packet) {
if (packet.getReason().equals("Quitting")) {
channel.disconnect();
}
}
public void onPlayerPositionPacket(Channel channel, PlayerPositionPacket packet) {
Player player = channel.attr(ATTR_PLAYER).get();
player.getLocation().setX(packet.getX());
player.getLocation().setY(packet.getY());
player.getLocation().setZ(packet.getZ());
}
public void onPlayerLookPacket(Channel channel, PlayerLookPacket packet) {
Player player = channel.attr(ATTR_PLAYER).get();
player.getLook().setYaw(packet.getYaw());
player.getLook().setPitch(packet.getPitch());
}
}

33
proto125/src/main/java/mc/core/network/proto_125/netty/wrappers/WrapperNetChannel.java
View File

@@ -1,33 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-13
*/
package mc.core.network.proto_125.netty.wrappers;
import io.netty.channel.Channel;
import lombok.RequiredArgsConstructor;
import mc.core.network.NetChannel;
import mc.core.network.SCPacket;
import mc.core.network.proto_125.packets.KeepAlivePacket;
import mc.core.network.proto_125.packets.PingPacket;
import mc.core.network.proto_125.packets.TimeUpdatePacket;
@RequiredArgsConstructor
public class WrapperNetChannel implements NetChannel {
private final Channel channel;
@Override
public void sendKeepAlive() {
channel.writeAndFlush(new KeepAlivePacket());
}
@Override
public void sendTimeUpdate(long value) {
channel.writeAndFlush(new TimeUpdatePacket(value));
}
@Override
public void writeAndFlush(SCPacket pkt) {
channel.writeAndFlush(pkt);
}
}

108
proto125/src/main/java/mc/core/network/proto_125/netty/wrappers/WrapperNetStream.java
View File

@@ -1,108 +0,0 @@
/*
* DmitriyMX <dimon550@gmail.com>
* 2018-04-08
*/
package mc.core.network.proto_125.netty.wrappers;
import io.netty.buffer.ByteBuf;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import mc.core.network.NetStream;
import mc.core.network.proto_125.NetStream_p125;
import java.nio.charset.StandardCharsets;
@RequiredArgsConstructor
public class WrapperNetStream extends NetStream_p125 {
private final ByteBuf byteBuf;
@Override
public boolean readBoolean() {
return byteBuf.readBoolean();
}
@Override
public byte readByte() {
return byteBuf.readByte();
}
@Override
public void readBytes(byte[] buffer) {
byteBuf.readBytes(buffer);
}
@Override
public int readUnsignedByte() {
return byteBuf.readUnsignedByte();
}
@Override
public int readUnsignedShort() {
return byteBuf.readUnsignedShort();
}
@Override
public short readShort() {
return byteBuf.readShort();
}
@Override
public int readInt() {
return byteBuf.readInt();
}
@Override
public float readFloat() {
return byteBuf.readFloat();
}
@Override
public double readDouble() {
return byteBuf.readDouble();
}
@Override
public void writeBoolean(boolean value) {
byteBuf.writeBoolean(value);
}
@Override
public void writeByte(int value) {
byteBuf.writeByte(value);
}
@Override
public void writeBytes(byte[] buffer) {
byteBuf.writeBytes(buffer);
}
@Override
public void writeShort(int value) {
byteBuf.writeShort(value);
}
@Override
public void writeInt(int value) {
byteBuf.writeInt(value);
}
@Override
public void writeLong(long value) {
byteBuf.writeLong(value);
}
@Override
public void writeFloat(float value) {
byteBuf.writeFloat(value);
}
@Override
public void writeDouble(double value) {
byteBuf.writeDouble(value);
}
@Override
public void skipBytes(int count) {
byteBuf.skipBytes(count);
}
}