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}. * *
Nothing happens until a knockback actually arrives. At that moment the mode starts * blinking: 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. * *
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. * *
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 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.
*
* 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.
*
* 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.
*
* 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