net.minecraft.network.ClientConnection Java Examples

@Redirect(method =  "onCollision", at = @At(
        value = "INVOKE",
        target = "Lnet/minecraft/network/ClientConnection;isOpen()Z"
))
private boolean isConnectionGood(ClientConnection clientConnection)
{
    return clientConnection.isOpen() || getOwner() instanceof EntityPlayerMPFake;
}
 

@Redirect(method = "onPlayerConnect", at = @At(value = "NEW", target = "net/minecraft/server/network/ServerPlayNetworkHandler"))
private ServerPlayNetworkHandler replaceNetworkHandler(MinecraftServer server, ClientConnection clientConnection, ServerPlayerEntity playerIn)
{
    boolean isServerPlayerEntity = playerIn instanceof EntityPlayerMPFake;
    if (isServerPlayerEntity)
    {
        return new NetHandlerPlayServerFake(this.server, clientConnection, playerIn);
    }
    else
    {
        return new ServerPlayNetworkHandler(this.server, clientConnection, playerIn);
    }
}
 

public static void onSendHandshake(ClientConnection connect, Packet<?> handshakePacket) {
    if (ConnectionMode.isSupportedProtocol(ConnectionInfo.protocolVersion)) {
        ((HandshakePacketAccessor) handshakePacket).setProtocolVersion(ConnectionInfo.protocolVersion);
        ConnectionInfo.protocol = ProtocolRegistry.get(ConnectionInfo.protocolVersion);
        ConnectionInfo.protocol.setup(false);
    }
}
 

@Inject(method = "tick", at = @At("HEAD"))
private void onTick(CallbackInfo ci) {
    ClientConnection versionRequestConnection = this.versionRequestConnection.get();
    if (versionRequestConnection != null) {
        if (versionRequestConnection.isOpen())
            versionRequestConnection.tick();
        else
            versionRequestConnection.handleDisconnection();
    }
}
 

public <M> void sendTo(M message, ClientConnection connection, NetworkDirection direction) {
	connection.send(toVanillaPacket(message, direction));
}
 

@Inject(method = "onPlayerConnect", at = @At("RETURN"))
private void onPlayerConnected(ClientConnection connection, ServerPlayerEntity player, CallbackInfo ci)
{
    CarpetServer.onPlayerLoggedIn(player);
    PLAYER_CONNECTS.onPlayerEvent(player);
}
 

public NetHandlerPlayServerFake(MinecraftServer server, ClientConnection cc, ServerPlayerEntity playerIn)
{
    super(server, cc, playerIn);
}
 

@Inject(method = "onPlayerConnect", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/PlayerManager;sendWorldInfo(Lnet/minecraft/server/network/ServerPlayerEntity;Lnet/minecraft/server/world/ServerWorld;)V"), cancellable = true)
public void tick(ClientConnection clientConnection_1, ServerPlayerEntity serverPlayerEntity_1, CallbackInfo info) {
    NetworkManager.sendTo(SandboxServer.INSTANCE.createAddonSyncPacket(), serverPlayerEntity_1);
}
 

private void connect(final String string_1, final int int_1) {
    Log.info("Connecting to {}, {}", string_1, int_1);
    Thread thread_1 = new Thread("Server Connector #" + CONNECTOR_THREADS_COUNT.incrementAndGet()) {
        public void run() {
            InetAddress inetAddress_1 = null;

            try {
                if (ConnectionScreen.this.connectingCancelled) {
                    return;
                }

                inetAddress_1 = InetAddress.getByName(string_1);
                ConnectionScreen.this.connection = ClientConnection.connect(inetAddress_1, int_1, ConnectionScreen.this.minecraft.options.shouldUseNativeTransport());
                ConnectionScreen.this.connection.setPacketListener(new ClientLoginNetworkHandler(ConnectionScreen.this.connection, ConnectionScreen.this.minecraft, ConnectionScreen.this.parent, ConnectionScreen.this::setStatus));
                ConnectionScreen.this.connection.send(new HandshakeC2SPacket(string_1, int_1, NetworkState.LOGIN));
                ConnectionScreen.this.connection.send(new LoginHelloC2SPacket(ConnectionScreen.this.minecraft.getSession().getProfile()));
            } catch (UnknownHostException var4) {
                if (ConnectionScreen.this.connectingCancelled) {
                    return;
                }

                Log.error("Couldn't connect to server", var4);
                ConnectionScreen.this.minecraft.execute(() -> {
                    ConnectionScreen.this.minecraft.openScreen(new DisconnectedScreen(ConnectionScreen.this.parent, "connect.failed", new TranslatableText("disconnect.genericReason", new Object[]{"Unknown host"})));
                });
            } catch (Exception var5) {
                if (ConnectionScreen.this.connectingCancelled) {
                    return;
                }

                Log.error("Couldn't connect to server", var5);
                String string_1x = inetAddress_1 == null ? var5.toString() : var5.toString().replaceAll(inetAddress_1 + ":" + int_1, "");
                ConnectionScreen.this.minecraft.execute(() -> {
                    ConnectionScreen.this.minecraft.openScreen(new DisconnectedScreen(ConnectionScreen.this.parent, "connect.failed", new TranslatableText("disconnect.genericReason", new Object[]{string_1x})));
                });
            }

        }
    };
    thread_1.setUncaughtExceptionHandler(new UncaughtExceptionLogger(Log.LOG));
    thread_1.start();
}
 

@Inject(method = "onPlayerConnect", at = @At("RETURN"))
private void hookPlayerLogin(ClientConnection connection, ServerPlayerEntity player, CallbackInfo callback) {
	EntityEvents.onPlayerLoggedIn(player);
}
 

@Shadow
public abstract ClientConnection getConnection();
 

@Shadow
public abstract ClientConnection getConnection();
 

@Shadow
public abstract ClientConnection getConnection();
 

@Shadow
public abstract ClientConnection getConnection();
 

private Consumer<Packet<?>> connectionList(final Supplier<List<ClientConnection>> connections) {
	return packet -> connections.get().forEach(connection -> connection.send(packet));
}
 

@Shadow
@Override
public ClientConnection getConnection()
{
	return null;
}
 

public ClientConnection getNetworkManager() {
	return clientConnection;
}
 

Context(ClientConnection clientConnection, NetworkDirection networkDirection, PacketDispatcher dispatcher) {
	this.clientConnection = clientConnection;
	this.networkDirection = networkDirection;
	this.packetDispatcher = dispatcher;
}
 

Context(ClientConnection connection, NetworkDirection networkDirection, int index) {
	this(connection, networkDirection, new PacketDispatcher.ClientConnectionDispatcher(connection, index, networkDirection.reply()));
}
 

ClientConnectionDispatcher(ClientConnection connection, int packetIndex, NetworkDirection direction) {
	super();
	this.connection = connection;
	this.packetIndex = packetIndex;
	this.direction = direction;
}
 

@Override
public void multiconnect_setVersionRequestConnection(ClientConnection connection) {
    versionRequestConnection.set(connection);
}
 

@Redirect(method = "run()V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/ClientConnection;send(Lnet/minecraft/network/Packet;)V", ordinal = 0))
public void sendHandshake(ClientConnection connect, Packet<?> packet) {
    ConnectionHandler.onSendHandshake(connect, packet);
    connect.send(packet);
}
 

@Override
public ClientConnection getConnection() {
    return connection;
}
 

public GetProtocolPacketListener(ClientConnection connection) {
    this.connection = connection;
}
 

public static boolean onCustomPayload(final ICustomPacket<?> packet, final ClientConnection connection) {
	ListenableChannel target = NetworkRegistry.findListener(packet.getName());

	if (target == null) {
		return false;
	}

	final NetworkEvent.Context context = new NetworkEvent.Context(connection, packet.getDirection(), packet.getIndex());

	target.onPacket(packet, context);

	return context.getPacketHandled();
}
 

void multiconnect_setVersionRequestConnection(ClientConnection connection);