跳到主内容
paste
bin
.ca
type · paste · share
⌘
K
登录
?
账户
更多
▾
文档
系列
bin 系列
pastebin.ca
中心
Share text and code with expiry and privacy controls.
imagebin.ca
Upload and share images with direct links.
filebin.ca
Drop a file and get a shareable link.
notebin.ca
Write Markdown notes with durable links.
turl.ca
Short, reputation-checked links.
attn.ca
Notifications and alerts for your services.
voicebin.ca
Record and share short voice clips.
dnsbin.ca
Inspect DNS and debug records.
← 返回文本
›
编辑 / 分支
无标题文本
#76mqCJkjqA
public / public
新版本
匿名
已创建 6 days ago
过期于 18 hours
14.0 KB
语法:
text
你的更改会创建一个链接到此文本的新文本 — 原始文本不变。
新版本
你的更改会创建一个链接到此文本的新文本 — 原始文本不变。
标题(可选)
文件名
语法
text
text
bash
c
cpp
css
diff
dockerfile
go
html
ini
java
javascript
json
kotlin
lua
makefile
markdown
nginx
php
python
ruby
rust
shellscript
sql
swift
toml
typescript
xml
yaml
可见性
公开动态
访问
public
过期
7 天
10 分钟
1 小时
1 天
7 天
30 天
90 天
自定义…
自定义过期
变更备注
(可选)
任何人都能在公开动态中找到此文本。选择“未列出”即可仅通过链接分享。
创建新版本
取消
粘贴或输入…
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; } }