Гайд Фикс на фт *вы не отправляли запросов на телепортацию*

Начинающий
Статус
Онлайн
Регистрация
8 Авг 2024
Сообщения
296
Реакции[?]
0
Поинты[?]
0
так заткни меня, чо ждешь

тебе нужно ходить с каменным еблом всю жизнь?
ты считаешь, то что мне надо смеяться с числа?
докажи, что я спастил все, что я просматриваю)). И скажи, тебе вообще какое дело что я смотрю? Может мне интересно комментарии посмотреть, не, не думал?
то есть ты мне про функции говоришь, а потом просишь худ показать? В этом есть какая-та связь вообще? Между функциями и интерфейсом? Я думаю нету
 
Начинающий
Статус
Оффлайн
Регистрация
31 Янв 2024
Сообщения
200
Реакции[?]
3
Поинты[?]
3K
ты считаешь, то что мне надо смеяться с числа?

то есть ты мне про функции говоришь, а потом просишь худ показать? В этом есть какая-та связь вообще? Между функциями и интерфейсом? Я думаю нету
прямая связь. никогда не было такого что функции имба а худ каллище полное, либо худ имба и обходы соотвественно либо же худ хуйня и функции также))
профиль открой свой
заставь меня
 
Начинающий
Статус
Оффлайн
Регистрация
16 Апр 2024
Сообщения
186
Реакции[?]
1
Поинты[?]
0
прямая связь. никогда не было такого что функции имба а худ каллище полное, либо худ имба и обходы соотвественно либо же худ хуйня и функции также))

заставь меня
а че ты ссыкуешь але
прямая связь. никогда не было такого что функции имба а худ каллище полное, либо худ имба и обходы соотвественно либо же худ хуйня и функции также))

заставь меня
в чем проблема открыть профиль?
 
Начинающий
Статус
Онлайн
Регистрация
8 Авг 2024
Сообщения
296
Реакции[?]
0
Поинты[?]
0
прямая связь. никогда не было такого что функции имба а худ каллище полное, либо худ имба и обходы соотвественно либо же худ хуйня и функции также))

заставь меня
Ну не знаю, я лично сейчас функциями а не интерфейсом занимаюсь, мне на худ пофиг как-то сейчас, может потом сделаю
 
Начинающий
Статус
Оффлайн
Регистрация
26 Дек 2023
Сообщения
571
Реакции[?]
11
Поинты[?]
4K
NetworkManager::
package net.minecraft.network;
//Я отсосал за этот код
ДАААААААААААААААААААААААААААААААААААААААААА

import com.google.common.collect.Queues;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import com.viaversion.viaversion.connection.UserConnectionImpl;
import com.viaversion.viaversion.protocol.ProtocolPipelineImpl;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelException;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.DefaultEventLoopGroup;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.epoll.Epoll;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollSocketChannel;
import io.netty.channel.local.LocalChannel;
import io.netty.channel.local.LocalServerChannel;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.timeout.ReadTimeoutHandler;
import io.netty.handler.timeout.TimeoutException;
import io.netty.util.AttributeKey;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import java.net.InetAddress;
import java.net.SocketAddress;
import java.util.Queue;
import javax.annotation.Nullable;
import javax.crypto.Cipher;
import net.minecraft.network.login.ServerLoginNetHandler;
import net.minecraft.network.play.ServerPlayNetHandler;
import net.minecraft.network.play.server.SDisconnectPacket;
import net.minecraft.util.LazyValue;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TranslationTextComponent;
import org.apache.commons.lang3.Validate;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;

import nullform.Nullform;
import nullform.events.EventPacket;
import via.ViaLoadingBase;
import via.netty.handler.ViaDecoder;
import via.netty.handler.ViaEncoder;

public class NetworkManager extends SimpleChannelInboundHandler < IPacket<? >>
{
    private static final Logger LOGGER = LogManager.getLogger();
    public static final Marker NETWORK_MARKER = MarkerManager.getMarker("NETWORK");
    public static final Marker NETWORK_PACKETS_MARKER = MarkerManager.getMarker("NETWORK_PACKETS", NETWORK_MARKER);
    public static final AttributeKey<ProtocolType> PROTOCOL_ATTRIBUTE_KEY = AttributeKey.valueOf("protocol");
    public static final LazyValue<NioEventLoopGroup> CLIENT_NIO_EVENTLOOP = new LazyValue<>(() ->
    {
        return new NioEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Client IO #%d").setDaemon(true).build());
    });
    public static final LazyValue<EpollEventLoopGroup> CLIENT_EPOLL_EVENTLOOP = new LazyValue<>(() ->
    {
        return new EpollEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Epoll Client IO #%d").setDaemon(true).build());
    });
    public static final LazyValue<DefaultEventLoopGroup> CLIENT_LOCAL_EVENTLOOP = new LazyValue<>(() ->
    {
        return new DefaultEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Local Client IO #%d").setDaemon(true).build());
    });
    private final PacketDirection direction;
    private final Queue<NetworkManager.QueuedPacket> outboundPacketsQueue = Queues.newConcurrentLinkedQueue();

    /** The active channel */
    private Channel channel;

    /** The address of the remote party */
    private SocketAddress socketAddress;

    /** The INetHandler instance responsible for processing received packets */
    private INetHandler packetListener;

    /** A String indicating why the network has shutdown. */
    private ITextComponent terminationReason;
    private boolean isEncrypted;
    private boolean disconnected;
    private int field_211394_q;
    private int field_211395_r;
    private float field_211396_s;
    private float field_211397_t;
    private int ticks;
    private boolean field_211399_v;

    public NetworkManager(PacketDirection packetDirection)
    {
        this.direction = packetDirection;
    }

    public void channelActive(ChannelHandlerContext p_channelActive_1_) throws Exception
    {
        super.channelActive(p_channelActive_1_);
        this.channel = p_channelActive_1_.channel();
        this.socketAddress = this.channel.remoteAddress();

        try
        {
            this.setConnectionState(ProtocolType.HANDSHAKING);
        }
        catch (Throwable throwable)
        {
            LOGGER.fatal(throwable);
        }
    }

    /**
     * Sets the new connection state and registers which packets this channel may send and receive
     */
    public void setConnectionState(ProtocolType newState)
    {
        this.channel.attr(PROTOCOL_ATTRIBUTE_KEY).set(newState);
        this.channel.config().setAutoRead(true);
        LOGGER.debug("Enabled auto read");
    }

    public void channelInactive(ChannelHandlerContext p_channelInactive_1_) throws Exception
    {
        this.closeChannel(new TranslationTextComponent("disconnect.endOfStream"));
    }

    public void exceptionCaught(ChannelHandlerContext p_exceptionCaught_1_, Throwable p_exceptionCaught_2_)
    {
        if (p_exceptionCaught_2_ instanceof SkipableEncoderException)
        {
            LOGGER.debug("Skipping packet due to errors", p_exceptionCaught_2_.getCause());
        }
        else
        {
            boolean flag = !this.field_211399_v;
            this.field_211399_v = true;

            if (this.channel.isOpen())
            {
                if (p_exceptionCaught_2_ instanceof TimeoutException)
                {
                    LOGGER.debug("Timeout", p_exceptionCaught_2_);
                    this.closeChannel(new TranslationTextComponent("disconnect.timeout"));
                }
                else
                {
                    ITextComponent itextcomponent = new TranslationTextComponent("disconnect.genericReason", "Internal Exception: " + p_exceptionCaught_2_);

                    if (flag)
                    {
                        LOGGER.debug("Failed to sent packet", p_exceptionCaught_2_);
                        this.sendPacket(new SDisconnectPacket(itextcomponent), (p_211391_2_) ->
                        {
                            this.closeChannel(itextcomponent);
                        });
                        this.disableAutoRead();
                    }
                    else
                    {
                        LOGGER.debug("Double fault", p_exceptionCaught_2_);
                        this.closeChannel(itextcomponent);
                    }
                }
            }
        }
    }

    protected void channelRead0(ChannelHandlerContext p_channelRead0_1_, IPacket<?> p_channelRead0_2_) throws Exception
    {
        if (this.channel.isOpen())
        {
            try
            {
                processPacket(p_channelRead0_2_, this.packetListener);
            }
            catch (ThreadQuickExitException threadquickexitexception)
            {
            }

            ++this.field_211394_q;
        }
    }

    private static <T extends INetHandler> void processPacket(IPacket<T> p_197664_0_, INetHandler p_197664_1_)
    {
        p_197664_0_.processPacket((T)p_197664_1_);
    }

    /**
     * Sets the NetHandler for this NetworkManager, no checks are made if this handler is suitable for the particular
     * connection state (protocol)
     */
    public void setNetHandler(INetHandler handler)
    {
        Validate.notNull(handler, "packetListener");
        this.packetListener = handler;
    }

    public void sendPacket(IPacket<?> packetIn)
    {
        this.sendPacket(packetIn, (GenericFutureListener <? extends Future <? super Void >>)null);
    }

    public void sendPacket(IPacket<?> packetIn, [USER=1265501]@nullable[/USER] GenericFutureListener <? extends Future <? super Void >> p_201058_2_)
    {
        if (this.isChannelOpen())
        {
            this.flushOutboundQueue();
            this.dispatchPacket(packetIn, p_201058_2_);
        }
        else
        {
            this.outboundPacketsQueue.add(new NetworkManager.QueuedPacket(packetIn, p_201058_2_));
        }
    }

    /**
     * Will commit the packet to the channel. If the current thread 'owns' the channel it will write and flush the
     * packet, otherwise it will add a task for the channel eventloop thread to do that.
     */
    private void dispatchPacket(IPacket<?> inPacket, [USER=1265501]@nullable[/USER] GenericFutureListener <? extends Future <? super Void >> futureListeners)
    {
        ProtocolType protocoltype = ProtocolType.getFromPacket(inPacket);
        ProtocolType protocoltype1 = this.channel.attr(PROTOCOL_ATTRIBUTE_KEY).get();
        ++this.field_211395_r;

        if (protocoltype1 != protocoltype)
        {
            LOGGER.debug("Disabled auto read");
            this.channel.config().setAutoRead(false);
        }

        if (this.channel.eventLoop().inEventLoop())
        {
            if (protocoltype != protocoltype1)
            {
                this.setConnectionState(protocoltype);
            }

            ChannelFuture channelfuture = this.channel.writeAndFlush(inPacket);

            if (futureListeners != null)
            {
                channelfuture.addListener(futureListeners);
            }

            channelfuture.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
        }
        else
        {
            this.channel.eventLoop().execute(() ->
            {
                if (protocoltype != protocoltype1)
                {
                    this.setConnectionState(protocoltype);
                }

                ChannelFuture channelfuture1 = this.channel.writeAndFlush(inPacket);

                if (futureListeners != null)
                {
                    channelfuture1.addListener(futureListeners);
                }

                channelfuture1.addListener(ChannelFutureListener.FIRE_EXCEPTION_ON_FAILURE);
            });
        }
    }

    /**
     * Will iterate through the outboundPacketQueue and dispatch all Packets
     */
    private void flushOutboundQueue()
    {
        if (this.channel != null && this.channel.isOpen())
        {
            synchronized (this.outboundPacketsQueue)
            {
                NetworkManager.QueuedPacket networkmanager$queuedpacket;

                while ((networkmanager$queuedpacket = this.outboundPacketsQueue.poll()) != null)
                {
                    this.dispatchPacket(networkmanager$queuedpacket.packet, networkmanager$queuedpacket.field_201049_b);
                }
            }
        }
    }

    /**
     * Checks timeouts and processes all packets received
     */
    public void tick()
    {
        this.flushOutboundQueue();

        if (this.packetListener instanceof ServerLoginNetHandler)
        {
            ((ServerLoginNetHandler)this.packetListener).tick();
        }

        if (this.packetListener instanceof ServerPlayNetHandler)
        {
            ((ServerPlayNetHandler)this.packetListener).tick();
        }

        if (this.channel != null)
        {
            this.channel.flush();
        }

        if (this.ticks++ % 20 == 0)
        {
            this.func_241877_b();
        }
    }

    protected void func_241877_b()
    {
        this.field_211397_t = MathHelper.lerp(0.75F, (float)this.field_211395_r, this.field_211397_t);
        this.field_211396_s = MathHelper.lerp(0.75F, (float)this.field_211394_q, this.field_211396_s);
        this.field_211395_r = 0;
        this.field_211394_q = 0;
    }

    /**
     * Returns the socket address of the remote side. Server-only.
     */
    public SocketAddress getRemoteAddress()
    {
        return this.socketAddress;
    }

    /**
     * Closes the channel, the parameter can be used for an exit message (not certain how it gets sent)
     */
    public void closeChannel(ITextComponent message)
    {
        if (this.channel.isOpen())
        {
            this.channel.close().awaitUninterruptibly();
            this.terminationReason = message;
        }
    }

    /**
     * True if this NetworkManager uses a memory connection (single player game). False may imply both an active TCP
     * connection or simply no active connection at all
     */
    public boolean isLocalChannel()
    {
        return this.channel instanceof LocalChannel || this.channel instanceof LocalServerChannel;
    }

    /**
     * Create a new NetworkManager from the server host and connect it to the server
     */
    public static NetworkManager createNetworkManagerAndConnect(InetAddress address, int serverPort, boolean useNativeTransport)
    {
        final NetworkManager networkmanager = new NetworkManager(PacketDirection.CLIENTBOUND);
        Class <? extends SocketChannel > oclass;
        LazyValue <? extends EventLoopGroup > lazyvalue;

        if (Epoll.isAvailable() && useNativeTransport)
        {
            oclass = EpollSocketChannel.class;
            lazyvalue = CLIENT_EPOLL_EVENTLOOP;
        }
        else
        {
            oclass = NioSocketChannel.class;
            lazyvalue = CLIENT_NIO_EVENTLOOP;
        }

        new Bootstrap().group(lazyvalue.getValue()).handler(new ChannelInitializer<Channel>() {

            [USER=1367676]@override[/USER]
            protected void initChannel(Channel channel) {
                try {
                    channel.config().setOption(ChannelOption.TCP_NODELAY, true);
                } catch (ChannelException channelException) {
                    // empty catch block
                }
                //channel.pipeline().addLast(new Socks4ProxyHandler(new InetSocketAddress("93.178.82.123", 3629)));
                channel.pipeline().addLast("timeout", new ReadTimeoutHandler(30)).addLast("splitter", new NettyVarint21FrameDecoder()).addLast("decoder", new NettyPacketDecoder(PacketDirection.CLIENTBOUND)).addLast("prepender", new NettyVarint21FrameEncoder()).addLast("encoder", new NettyPacketEncoder(PacketDirection.SERVERBOUND)).addLast("packet_handler", networkmanager);

                if (channel instanceof SocketChannel) {
                    UserConnectionImpl user = new UserConnectionImpl(channel, true);
                    new ProtocolPipelineImpl(user);
                    if (ViaLoadingBase.getInstance().getTargetVersion().getVersion() != Nullform.getInstance().getViaMCP().getNATIVE_VERSION()) {
                        channel.pipeline().addBefore("encoder", "via-encoder", new ViaEncoder(user));
                        channel.pipeline().addBefore("decoder", "via-decoder", new ViaDecoder(user));
                    }
                }
            }
        }).channel(oclass).connect(address, serverPort).syncUninterruptibly();
        return networkmanager;
    }

    /**
     * Prepares a clientside NetworkManager: establishes a connection to the socket supplied and configures the channel
     * pipeline. Returns the newly created instance.
     */
    public static NetworkManager provideLocalClient(SocketAddress address)
    {
        final NetworkManager networkmanager = new NetworkManager(PacketDirection.CLIENTBOUND);
        (new Bootstrap()).group(CLIENT_LOCAL_EVENTLOOP.getValue()).handler(new ChannelInitializer<Channel>()
        {
            protected void initChannel(Channel p_initChannel_1_) throws Exception
            {
                p_initChannel_1_.pipeline().addLast("packet_handler", networkmanager);
            }
        }).channel(LocalChannel.class).connect(address).syncUninterruptibly();
        return networkmanager;
    }

    public void func_244777_a(Cipher p_244777_1_, Cipher p_244777_2_)
    {
        this.isEncrypted = true;
        this.channel.pipeline().addBefore("splitter", "decrypt", new NettyEncryptingDecoder(p_244777_1_));
        this.channel.pipeline().addBefore("prepender", "encrypt", new NettyEncryptingEncoder(p_244777_2_));
    }

    public boolean isEncrypted()
    {
        return this.isEncrypted;
    }

    /**
     * Returns true if this NetworkManager has an active channel, false otherwise
     */
    public boolean isChannelOpen()
    {
        return this.channel != null && this.channel.isOpen();
    }

    public boolean hasNoChannel()
    {
        return this.channel == null;
    }

    /**
     * Gets the current handler for processing packets
     */
    public INetHandler getNetHandler()
    {
        return this.packetListener;
    }

    [USER=1265501]@nullable[/USER]

    /**
     * If this channel is closed, returns the exit message, null otherwise.
     */
    public ITextComponent getExitMessage()
    {
        return this.terminationReason;
    }

    /**
     * Switches the channel to manual reading modus
     */
    public void disableAutoRead()
    {
        this.channel.config().setAutoRead(false);
    }

    public void setCompressionThreshold(int threshold)
    {
        if (threshold >= 0)
        {
            if (this.channel.pipeline().get("decompress") instanceof NettyCompressionDecoder)
            {
                ((NettyCompressionDecoder)this.channel.pipeline().get("decompress")).setCompressionThreshold(threshold);
            }
            else
            {
                this.channel.pipeline().addBefore("decoder", "decompress", new NettyCompressionDecoder(threshold));
            }

            if (this.channel.pipeline().get("compress") instanceof NettyCompressionEncoder)
            {
                ((NettyCompressionEncoder)this.channel.pipeline().get("compress")).setCompressionThreshold(threshold);
            }
            else
            {
                this.channel.pipeline().addBefore("encoder", "compress", new NettyCompressionEncoder(threshold));
            }
        }
        else
        {
            if (this.channel.pipeline().get("decompress") instanceof NettyCompressionDecoder)
            {
                this.channel.pipeline().remove("decompress");
            }

            if (this.channel.pipeline().get("compress") instanceof NettyCompressionEncoder)
            {
                this.channel.pipeline().remove("compress");
            }
        }
    }

    public void handleDisconnection()
    {
        if (this.channel != null && !this.channel.isOpen())
        {
            if (this.disconnected)
            {
                LOGGER.warn("handleDisconnection() called twice");
            }
            else
            {
                this.disconnected = true;

                if (this.getExitMessage() != null)
                {
                    this.getNetHandler().onDisconnect(this.getExitMessage());
                }
                else if (this.getNetHandler() != null)
                {
                    this.getNetHandler().onDisconnect(new TranslationTextComponent("multiplayer.disconnect.generic"));
                }
            }
        }
    }

    public float getPacketsReceived()
    {
        return this.field_211396_s;
    }

    public float getPacketsSent()
    {
        return this.field_211397_t;
    }

    static class QueuedPacket
    {
        private final IPacket<?> packet;
        [USER=1265501]@nullable[/USER]
        private final GenericFutureListener <? extends Future <? super Void >> field_201049_b;

        public QueuedPacket(IPacket<?> p_i48604_1_, [USER=1265501]@nullable[/USER] GenericFutureListener <? extends Future <? super Void >> p_i48604_2_)
        {
            this.packet = p_i48604_1_;
            this.field_201049_b = p_i48604_2_;
        }
    }
}
кому фикс ? в дс iacidka напишите дам
 
Начинающий
Статус
Оффлайн
Регистрация
31 Янв 2024
Сообщения
200
Реакции[?]
3
Поинты[?]
3K
кому фикс ? в дс iacidka напишите дам
был бы признателен очень, мне в падлу самому этот нетворк менежер фиксить
Ну не знаю, я лично сейчас функциями а не интерфейсом занимаюсь, мне на худ пофиг как-то сейчас, может потом сделаю
ну значит ты просто тупой :/ насколько чит красивый это буквально показатель сколько ты сил в него вложил. если тебе конечно комфортно играть с корявыми визуалами еле живыми и спащенным худом то ну соболезную
 
Начинающий
Статус
Онлайн
Регистрация
8 Авг 2024
Сообщения
296
Реакции[?]
0
Поинты[?]
0
был бы признателен очень, мне в падлу самому этот нетворк менежер фиксить

ну значит ты просто тупой :/ насколько чит красивый это буквально показатель сколько ты сил в него вложил. если тебе конечно комфортно играть с корявыми визуалами еле живыми и спащенным худом то ну соболезную
пока что худа нету, и клиент я свой даже не выкладывал, вот поэтому и пофиг на интерфейс пока что
 
Сверху Снизу