公开动态 #76mqCJkjqA

text paste

公开 text v1 · 不可变
原始 编辑
·已发布 2026-11-16 07:08 UTC
渲染后的文本正文
package dev.nexo.module.combat.velocity;import dev.nexo.client.Chat;import dev.nexo.module.combat.VelocityModule;import java.util.ArrayList;import java.util.List;import net.minecraft.client.entity.EntityPlayerSP;import net.minecraft.client.multiplayer.WorldClient;import net.minecraft.network.Packet;import net.minecraft.network.play.server.S02PacketChat;import net.minecraft.network.play.server.S03PacketTimeUpdate;import net.minecraft.network.play.server.S06PacketUpdateHealth;import net.minecraft.network.play.server.S07PacketRespawn;import net.minecraft.network.play.server.S08PacketPlayerPosLook;import net.minecraft.network.play.server.S12PacketEntityVelocity;import net.minecraft.network.play.server.S13PacketDestroyEntities;import net.minecraft.network.play.server.S18PacketEntityTeleport;import net.minecraft.network.play.server.S25PacketBlockBreakAnim;import net.minecraft.network.play.server.S27PacketExplosion;import net.minecraft.network.play.server.S29PacketSoundEffect;import net.minecraft.network.play.server.S2BPacketChangeGameState;import net.minecraft.network.play.server.S2CPacketSpawnGlobalEntity;import net.minecraft.network.play.server.S2FPacketSetSlot;/** * 1:1 port of Boop's {@code BufferVelocity}. * * <p>Nothing happens until a knockback actually arrives. At that moment the mode starts * <em>blinking</em>: every packet that reaches the client from then on is held instead of processed. * The client briefly stops seeing the world, so the server's movement prediction for us keeps * running against a state it already accepted - and when the batch is replayed, the knockback lands * into a prediction that no longer matches, which cancels most of its effect. * * <p>There is no timer: once it starts blinking, the batch is only released when the module is * switched off (or the world changes). That is deliberate - the whole point is that the server's * prediction runs against a stale state for as long as the hold lasts. * * <p>An exact allow-list runs first and is never held, even mid-blinking. Those packets either * carry state the client cannot reconstruct out of order (health, time, chat, inventory, position * corrections, teleports) or would look wrong if delayed (thunder, game-state change). */public class BufferVelocity extends VelocityMode {    protected final List<Packet<?>> heldPackets = new ArrayList<Packet<?>>();    protected WorldClient packetWorld;    protected boolean blinking;    /** Wall-clock time the current hold began, for the timeout. */    protected long holdStartMs;    /** Highest countdown number already announced, so each number prints once. */    private int announcedCountdown;    /**     * Hard limit on how long packets may stay held.     *     * <p>Holding without a timer means the client stops acknowledging inbound state entirely. The     * server eventually gives up on it - keepalive or transaction timeouts - and drops the     * connection. Releasing before that happens keeps the hold usable for as long as it is useful     * and no longer.     */    /** Configured warning length, clamped to a sane range. */    protected static int releaseWarningSeconds() {        int seconds = dev.nexo.config.NexoConfig.velocityreleaseSeconds;        if (seconds < 1) {            seconds = 1;        }        if (seconds > 10) {            seconds = 10;        }        return seconds;    }    /**     * Configured hold limit in milliseconds.     *     * @return the limit, or {@code 0} when the timeout is disabled     */    protected static long holdTimeoutMs() {        int tenths = dev.nexo.config.NexoConfig.velocityholdTimeout;        if (tenths <= 0) {            return 0L;        }        if (tenths > 300) {            tenths = 300;        }        // tenths of a second -> milliseconds        return tenths * 100L;    }    protected boolean pendingJump;    public BufferVelocity(VelocityModule parent) {        super(parent);    }    @Override    public void onPacketReceive(Packet<?> packet, boolean[] cancelled) {        EntityPlayerSP player = VelocityModule.mc().thePlayer;        if (player == null || VelocityModule.mc().theWorld == null) {            return;        }        // A respawn invalidates the world the batch belongs to.        if (packet instanceof S07PacketRespawn) {            clearHold();            return;        }        // Allow-list first: these are never delayed, blinking or not.        if (isAlwaysAllowed(packet)) {            return;        }        // Only packets the play handler can actually accept may be held. A status or login packet        // mixed into the stream (some proxies emit S00PacketServerInfo on the play connection) is        // not playable at all, and replaying it later casts the play handler to the status handler        // and crashes the client. Letting them straight through is both safer and closer to vanilla.        if (!isPlayPacket(packet)) {            return;        }        if (!blinking && isKnockbackPacket(packet)) {            if (!parent.canActOnSwing()) {                VelocityTrace.log("hold", "knockback ignored (canActOnSwing=false) "                        + packet.getClass().getSimpleName());                return;            }            // Decide whether this particular knockback should be suppressed at all. The source has            // to be inferred from what is in the world, because the packet does not carry it.            KnockbackSource.Type source = KnockbackSource.classify();            if (!suppresses(source)) {                VelocityTrace.log("hold", "knockback allowed through, source=" + source);                return;            }            VelocityTrace.log("hold", "knockback suppressed, source=" + source);            if (packet instanceof S12PacketEntityVelocity                    && ((S12PacketEntityVelocity) packet).getMotionY() > 0) {                pendingJump = true;            }            blinking = true;            packetWorld = VelocityModule.mc().theWorld;            holdStartMs = System.currentTimeMillis();            announcedCountdown = 0;            VelocityTrace.log("hold", "START by " + packet.getClass().getSimpleName()                    + String.format(" timeout=%.1fs", holdTimeoutMs() / 1000.0));        }        if (blinking) {            cancelled[0] = true;            heldPackets.add(packet);            VelocityTrace.log("hold", "held " + packet.getClass().getSimpleName()                    + " n=" + heldPackets.size());        }    }    /**     * Whether a knockback from this source should be suppressed.     *     * <p>Each source has its own switch so a rod pull can be allowed through (being reeled in     * repeatedly is far more disruptive than the push itself) while melee stays suppressed.     */    private static boolean suppresses(KnockbackSource.Type source) {        switch (source) {            case ROD:                return dev.nexo.config.NexoConfig.velocitykbRod;            case BOW:                return dev.nexo.config.NexoConfig.velocitykbBow;            case MELEE:            default:                return dev.nexo.config.NexoConfig.velocitykbMelee;        }    }    /**     * Whether this packet belongs to the play phase and can be replayed through the play handler.     *     * <p>Deliberately a name check rather than an exhaustive allow-list: the goal is only to keep     * packets from the other connection phases out of the hold, not to police which play packets are     * held. Anything whose handler lives outside {@code network.play} or {@code network.status} /     * {@code network.login} is passed through untouched.     */    private static boolean isPlayPacket(Packet<?> packet) {        String name = packet.getClass().getName();        // Status and login packets have handlers of a different type; replaying them is a cast        // error by construction.        if (name.startsWith("net.minecraft.network.status.")                || name.startsWith("net.minecraft.network.login.")) {            return false;        }        // Handshake is connection setup and never has a play handler.        if (name.startsWith("net.minecraft.network.handshake.")) {            return false;        }        return true;    }    /**     * Packets that are never held.     *     * <p>Transcribed from the reference build; each entry is there because delaying it desyncs     * something the client cannot repair later.     */    protected boolean isAlwaysAllowed(Packet<?> packet) {        if (packet instanceof S03PacketTimeUpdate                || packet instanceof S06PacketUpdateHealth                || packet instanceof S13PacketDestroyEntities                || packet instanceof S02PacketChat                || packet instanceof S25PacketBlockBreakAnim                || packet instanceof S2FPacketSetSlot                || packet instanceof S08PacketPlayerPosLook                || packet instanceof S18PacketEntityTeleport) {            return true;        }        if (packet instanceof S2BPacketChangeGameState) {            int state = ((S2BPacketChangeGameState) packet).getGameState();            // 1 = begin raining, 2 = end raining, 7 = rain fade value, 8 = rain fade time.            if (state == 1 || state == 2 || state == 7 || state == 8) {                return true;            }        }        if (packet instanceof S2CPacketSpawnGlobalEntity) {            // 1.8.9 exposes no accessor for the type field, so every global entity spawn is let            // through instead of only lightning. The difference is a few cosmetic entities.            return true;        }        if (packet instanceof S29PacketSoundEffect                && "ambient.weather.thunder".equalsIgnoreCase(                        ((S29PacketSoundEffect) packet).getSoundName())) {            return true;        }        return false;    }    @Override    public void onPostPlayerUpdate() {        if (!blinking) {            return;        }        if (holdStartMs <= 0L) {            // Defensive: a hold without a start time would compute an enormous elapsed and release            // on the very next tick, then repeat - the countdown would spam chat every second.            // Re-stamp it instead so the timeout measures from now.            holdStartMs = System.currentTimeMillis();            return;        }        long timeout = holdTimeoutMs();        if (timeout <= 0L) {            // Timeout disabled: the hold only ends when the module is switched off or the world            // changes. Useful when a longer silence is wanted, at the risk of the server timing the            // connection out.            return;        }        long elapsed = System.currentTimeMillis() - holdStartMs;        long remaining = timeout - elapsed;        // Count down the last few seconds in chat so the release is never a surprise: the client        // freezes for a moment when the backlog goes out, and without warning that looks like a        // hang.        if (dev.nexo.config.NexoConfig.velocityreleaseCountdown                && remaining > 0 && remaining <= releaseWarningSeconds() * 1000L) {            int seconds = (int) ((remaining + 999L) / 1000L);            if (seconds > 0 && seconds <= releaseWarningSeconds() && seconds != announcedCountdown) {                announcedCountdown = seconds;                if (dev.nexo.config.NexoConfig.velocitydebug) {                    dev.nexo.client.Chat.print("&ereleasing in &f" + seconds + "&e...");                }            }        }        if (remaining > 0) {            return;        }        // Timed out. Hand everything over before the server decides we are gone.        if (dev.nexo.config.NexoConfig.velocitydebug) {            dev.nexo.client.Chat.print("&ereleased (timeout)");        }        announcedCountdown = 0;        flushAll();    }    @Override    public void onPostPlayerInput() {        // The jump is issued from flushAll() instead: with no timer the release only happens when        // the module is turned off, so there is no tick to wait for here.    }    @Override    public void reset(boolean release) {        if (release) {            // flushAll() reads and clears pendingJump itself, so it must run first.            flushAll();        } else {            pendingJump = false;            clearHold();        }    }    private boolean isKnockbackPacket(Packet<?> packet) {        EntityPlayerSP player = VelocityModule.mc().thePlayer;        if (player == null) {            return false;        }        if (packet instanceof S12PacketEntityVelocity) {            return ((S12PacketEntityVelocity) packet).getEntityID() == player.getEntityId();        }        if (packet instanceof S27PacketExplosion) {            S27PacketExplosion explosion = (S27PacketExplosion) packet;            return explosion.func_149149_c() != 0.0f                    || explosion.func_149144_d() != 0.0f                    || explosion.func_149147_e() != 0.0f;        }        return false;    }    protected void flushAll() {        List<Packet<?>> batch = new ArrayList<Packet<?>>(heldPackets);        WorldClient world = packetWorld;        int count = batch.size();        boolean jump = pendingJump;        VelocityTrace.log("release", "FLUSH " + count + " packets"                + String.format(" held=%.1fs", (System.currentTimeMillis() - holdStartMs) / 1000.0));        clearHold();        parent.replayPackets(batch, world);        // The knockback packet is inside the batch, so jumping has to happen after the replay.        if (jump) {            EntityPlayerSP player = VelocityModule.mc().thePlayer;            if (player != null && player.movementInput != null) {                player.movementInput.jump = true;            }        }    }    protected void clearHold() {        heldPackets.clear();        packetWorld = null;        blinking = false;        holdStartMs = 0L;        announcedCountdown = 0;    }    /** Packets currently held, for the HUD. */    public int heldCount() {        return heldPackets.size();    }    public boolean isBlinking() {        return blinking;    }}