Blink

Queue and flush network packets for advanced movement mechanics and lag simulation

Blink is a powerful feature that allows you to queue network packets and release them later, creating the appearance of lag or enabling advanced movement techniques.

Overview

The BlinkManager (features/blink/BlinkManager.kt:75) intercepts network packets and stores them in a queue instead of sending them immediately. When flushed, all queued packets are sent at once.

How It Works

Packet Queueing

1. Intercept Packets

   The PacketEvent handler intercepts all packets (BlinkManager.kt:125)

2. Check Action

   Fires BlinkPacketEvent to determine if the packet should be queued

3. Queue or Pass

   Based on the action, the packet is either queued or allowed through

4. Store Snapshot

   Queued packets are stored with origin and timestamp

Packet Queue

val packetQueue: ConcurrentLinkedQueue<PacketSnapshot> = Queues.newConcurrentLinkedQueue()

Each snapshot contains:

data class PacketSnapshot(
    val packet: Packet<*>,
    val origin: TransferOrigin,  // INCOMING or OUTGOING
    val timestamp: Long
)

Blink Actions

The BlinkPacketEvent returns one of three actions:

enum class Action(val priority: Int) {
    FLUSH(0),    // Send all queued packets
    PASS(1),     // Let this packet through
    QUEUE(2),    // Queue this packet
}

Actions are prioritized by their value, with FLUSH taking precedence (BlinkManager.kt:289-293).

Packet Filtering

Certain packets are never queued:

Always Passed

• Connection packets (ClientIntentionPacket, ServerboundStatusRequestPacket, ServerboundPingRequestPacket)
• Chat messages (ServerboundChatPacket, ClientboundSystemChatPacket, ServerboundChatCommandPacket)

Implementation (BlinkManager.kt:145-154):

when (packet) {
    is ClientIntentionPacket, is ServerboundStatusRequestPacket, 
    is ServerboundPingRequestPacket -> {
        return@handler
    }
    
    is ServerboundChatPacket, is ClientboundSystemChatPacket, 
    is ServerboundChatCommandPacket -> {
        return@handler
    }
}

Auto-Flush Triggers

Some packets trigger automatic flush:

• Teleport: ClientboundPlayerPositionPacket
• Disconnect: ClientboundDisconnectPacket
• Death: ClientboundSetHealthPacket with health ≤ 0

This prevents desyncs and ensures game-critical packets are processed (BlinkManager.kt:157-171).

Ignored Packets

Player hurt sounds are ignored to reduce queue spam:

is ClientboundSoundPacket if packet.sound.value() == SoundEvents.PLAYER_HURT -> {
    return@handler
}

Flushing Packets

By Origin

Flush all packets from a specific origin:

BlinkManager.flush(TransferOrigin.OUTGOING)  // Send queued outgoing packets
BlinkManager.flush(TransferOrigin.INCOMING)  // Process queued incoming packets

By Condition

Flush packets matching a condition:

BlinkManager.flush { snapshot ->
    snapshot.timestamp < someTimestamp
}

By Count

Flush a specific number of movement packets:

BlinkManager.flush(count = 10)  // Flush first 10 movement packets

Implementation (BlinkManager.kt:233-254):

fun flush(count: Int) {
    var counter = 0
    
    with(packetQueue.iterator()) {
        while (hasNext()) {
            val snapshot = next()
            val packet = snapshot.packet
            
            if (packet is ServerboundMovePlayerPacket && packet.hasPos) {
                counter += 1
            }
            
            flushSnapshot(snapshot)
            remove()
            
            if (counter >= count) {
                break
            }
        }
    }
}

Canceling Blink

Cancel blink and teleport to the first queued position:

BlinkManager.cancel()

This:

1. Teleports player to first queued position
2. Flushes all non-movement packets
3. Discards movement packets
4. Clears the queue

Implementation (BlinkManager.kt:256-268):

fun cancel() {
    positions.firstOrNull()?.let { pos ->
        player.setPos(pos)
    }
    
    for (snapshot in packetQueue) {
        when (snapshot.packet) {
            is ServerboundMovePlayerPacket -> continue
            else -> flushSnapshot(snapshot)
        }
    }
    packetQueue.clear()
}

Position Tracking

Get queued player positions:

val positions = BlinkManager.positions

This extracts positions from queued ServerboundMovePlayerPackets (BlinkManager.kt:78-82):

val positions
    get() = packetQueue
        .map { snapshot -> snapshot.packet }
        .filterIsInstance<ServerboundMovePlayerPacket> { it.hasPos }
        .map { Vec3(it.x, it.y, it.z) }

Lag Detection

val isLagging = BlinkManager.isLagging

Returns true if there are queued packets (BlinkManager.kt:84-85).

Packet Rewriting

Modify queued packets before flushing:

BlinkManager.rewrite<ServerboundMovePlayerPacket> { packet ->
    // Modify packet
    packet.x += 1.0
}

This uses inline reified generics to filter and modify packets (BlinkManager.kt:275-277).

Time-Based Flushing

Check if packets have been queued longer than a delay:

if (BlinkManager.isAboveTime(1000L)) {
    // Packets have been queued for >1 second
    BlinkManager.flush(TransferOrigin.OUTGOING)
}

Implementation (BlinkManager.kt:270-273):

fun isAboveTime(delay: Long): Boolean {
    val entryPacketTime = (packetQueue.firstOrNull()?.timestamp ?: return false)
    return System.currentTimeMillis() - entryPacketTime >= delay
}

Visual Feedback

ESP Modes

Blink includes multiple ESP modes for visualization:

• Box - Draws a box at the blink position
• Model - Renders a player model
• Wireframe - Shows wireframe rendering
• None - No visualization

Modes are configured via:

private val espMode = modes(this, "Esp", 2) {
    arrayOf(
        BlinkEspBox(it, ::getEspData),
        BlinkEspModel(it, getEspData = ::getEspData),
        BlinkEspWireframe(it, ::getEspData),
        BlinkEspNone(it),
    )
}

Line Trail

Draws a line showing the blink path:

private val lineColor by color("Line", Color4b.LIQUID_BOUNCE)

private val renderHandler = handler<WorldRenderEvent> { event ->
    val matrixStack = event.matrixStack
    if (lineColor.a > 0) {
        renderEnvironmentForWorld(matrixStack) {
            drawLineStrip(
                argb = lineColor.argb,
                positions = positions.mapToArray { Vec3f(relativeToCamera(it)) },
            )
        }
    }
}

Event Handlers

Auto-Flush Handlers

Blink automatically attempts to flush based on game events:

// Flush outgoing packets each render frame
private val flushHandler = handler<GameRenderTaskQueueEvent> {
    if (fireEvent(null, TransferOrigin.OUTGOING) == Action.FLUSH) {
        flush(TransferOrigin.OUTGOING)
    }
}

// Flush incoming packets each tick
private val flushReceiveHandler = handler<TickPacketProcessEvent> {
    if (fireEvent(null, TransferOrigin.INCOMING) == Action.FLUSH) {
        flush(TransferOrigin.INCOMING)
    }
}

World Change Handler

Clears packets on disconnect:

private val worldChangeHandler = handler<WorldChangeEvent> { event ->
    if (event.world == null) {
        packetQueue.clear()
    }
}

Use Cases

Lag Switch

Simulate lag to confuse opponents:

// Queue packets for 2 seconds
if (BlinkManager.isAboveTime(2000)) {
    BlinkManager.flush(TransferOrigin.OUTGOING)
}

Advanced Movement

Queue movement packets and release them to teleport:

// Move while blinking
// Then flush to appear to teleport
BlinkManager.flush(TransferOrigin.OUTGOING)

Desync

Create client-server position desync:

// Cancel to snap back to first position
BlinkManager.cancel()

Gradual Flush

Flush packets gradually:

// Flush 5 movement packets per tick
BlinkManager.flush(count = 5)

Best Practices

Handle Disconnects

Blink automatically clears on world change. Don’t manually clear unless needed.

Respect Auto-Flush

Don’t prevent auto-flush for teleport/death packets - this can cause severe desyncs.

Monitor Queue Size

Large queues can cause lag spikes when flushed. Consider periodic partial flushes.

Use Cancel for Safety

When in doubt, use cancel() instead of flush() to prevent invalid game states.

Configuration

Blink is configured as a ValueGroup:

object BlinkManager : EventListener, ValueGroup("BlinkManager")

This allows it to be toggled and configured through the client’s module system.