Event Types - LiquidBounce

Overview

LiquidBounce provides a comprehensive set of event types organized into categories. All events extend the base Event class. Package: net.ccbluex.liquidbounce.event.events

Event Categories

Events are organized in the following files:

GameEvents.kt - Core game events
PlayerEvents.kt - Player-specific events
NetworkEvents.kt - Network/packet events
WorldEvents.kt - World and chunk events
EntityEvents.kt - Entity-related events
UserInterfaceEvents.kt - UI and screen events
WindowEvents.kt - Window and input events
DrawEvents.kt - Rendering events
ClientEvents.kt - Client-specific events

Game Events

GameTickEvent

data object GameTickEvent : Event()

Called every game tick (20 times per second). Usage:

private val tickHandler = handler<GameTickEvent> {
    // Runs 20 times per second
}

GameRenderEvent

data object GameRenderEvent : Event()

Called during game rendering.

RotationUpdateEvent

data object RotationUpdateEvent : Event()

Called when rotations should be updated.

Player Events

PlayerTickEvent

data object PlayerTickEvent : Event()

Called every player tick.

PlayerMoveEvent

class PlayerMoveEvent(
    var movement: Vec3d
) : Event()

Called when player moves. Modifiable. Usage:

private val moveHandler = handler<PlayerMoveEvent> { event ->
    event.movement = Vec3d(0.0, 0.0, 0.0) // Stop movement
}

PlayerJumpEvent

class PlayerJumpEvent(
    var motion: Float
) : Event()

Called when player jumps. Can modify jump height.

PlayerSafeWalkEvent

class PlayerSafeWalkEvent : Event() {
    var isSafeWalk = false
}

Called to check if player should safe walk (prevent falling off edges).

AttackEntityEvent

class AttackEntityEvent(
    val entity: Entity
) : Event()

Called when attacking an entity.

Network Events

PacketEvent

class PacketEvent(
    val packet: Packet<*>,
    val origin: TransferOrigin
) : CancellableEvent()

Called for sent and received packets. Can be cancelled. Usage:

private val packetHandler = handler<PacketEvent> { event ->
    when (event.packet) {
        is ClientboundPlayerPositionPacket -> {
            // Handle position packet
        }
    }
}

ServerConnectEvent

class ServerConnectEvent(
    val serverInfo: ServerInfo
) : Event()

Called when connecting to a server.

DisconnectEvent

data object DisconnectEvent : Event()

Called when disconnecting from server.

World Events

WorldChangeEvent

class WorldChangeEvent(
    val world: ClientLevel?
) : Event()

Called when world changes (join/leave).

ChunkLoadEvent

class ChunkLoadEvent(
    val chunk: LevelChunk
) : Event()

Called when a chunk is loaded.

ChunkUnloadEvent

class ChunkUnloadEvent(
    val chunkX: Int,
    val chunkZ: Int
) : Event()

Called when a chunk is unloaded.

BlockChangeEvent

class BlockChangeEvent(
    val blockPos: BlockPos,
    val blockState: BlockState
) : Event()

Called when a block changes.

Input Events

KeyboardKeyEvent

class KeyboardKeyEvent(
    val window: Long,
    val keyCode: Int,
    val scanCode: Int,
    val action: Int,
    val mods: Int
) : Event()

Called on keyboard input. Usage:

private val keyHandler = handler<KeyboardKeyEvent> { event ->
    if (event.action == GLFW.GLFW_PRESS) {
        when (event.keyCode) {
            GLFW.GLFW_KEY_F -> {
                // F key pressed
            }
        }
    }
}

MouseButtonEvent

class MouseButtonEvent(
    val window: Long,
    val button: Int,
    val action: Int,
    val mods: Int
) : Event()

Called on mouse button input.

MouseScrollEvent

class MouseScrollEvent(
    val window: Long,
    val horizontal: Double,
    val vertical: Double
) : Event()

Called on mouse scroll.

Module Events

ModuleToggleEvent

class ModuleToggleEvent(
    val moduleName: String,
    val hidden: Boolean,
    val enabled: Boolean
) : Event()

Called when a module is toggled.

ModuleActivationEvent

class ModuleActivationEvent(
    val moduleName: String
) : Event()

Called when a module is activated.

ValueChangedEvent

class ValueChangedEvent(
    val value: Value<*>
) : Event()

Called when a config value changes.

Render Events

WorldRenderEvent

class WorldRenderEvent(
    val matrixStack: PoseStack,
    val partialTicks: Float,
    val camera: Camera
) : Event()

Called during world rendering. Usage:

private val renderHandler = handler<WorldRenderEvent> { event ->
    // Render ESP boxes, tracers, etc.
    renderBox(event.matrixStack, pos, color)
}

OverlayRenderEvent

class OverlayRenderEvent(
    val context: GuiGraphics,
    val tickDelta: Float
) : Event()

Called during HUD overlay rendering.

ScreenRenderEvent

class ScreenRenderEvent(
    val screen: Screen,
    val context: GuiGraphics,
    val mouseX: Int,
    val mouseY: Int,
    val tickDelta: Float
) : Event()

Called during screen rendering.

Combat Events

TargetChangeEvent

class TargetChangeEvent(
    val target: PlayerData
) : Event()

Called when combat target changes.

Notification Events

NotificationEvent

class NotificationEvent(
    val title: String,
    val message: String,
    val severity: Severity
) : Event()

Called to display notifications. Severity:

INFO
SUCCESS
WARNING
ERROR
ENABLED
DISABLED

Chat Events

ChatReceiveEvent

class ChatReceiveEvent(
    val message: Component,
    var chatType: ChatType
) : CancellableEvent()

Called when receiving chat message. Can be cancelled.

ChatSendEvent

class ChatSendEvent(
    var message: String
) : CancellableEvent()

Called when sending chat message. Can modify or cancel.

Session Events

SessionEvent

class SessionEvent(
    val session: GameProfile
) : Event()

Called on session change (login).

Window Events

WindowResizeEvent

class WindowResizeEvent(
    val window: Window
) : Event()

Called when game window is resized.

Base Event Class

All events inherit from:

abstract class Event {
    var isCompleted = false
        internal set
}

Cancellable Events

Some events can be cancelled:

abstract class CancellableEvent : Event() {
    var isCancelled = false
        private set
    
    fun cancelEvent() {
        isCancelled = true
    }
}

Cancellable Events:

PacketEvent
ChatReceiveEvent
ChatSendEvent
PlayerMoveEvent
Many more…

Event Ordering

Events are processed by priority:

FIRST_PRIORITY (1000) - Runs first
SAFETY_FEATURE (900)
Default (0)
MODEL_STATE (500)
READ_FINAL_STATE (-500)
LAST_PRIORITY (-1000) - Runs last

Best Practices

Use specific events - More efficient than generic
Cancel early if possible - Prevent unnecessary processing
Keep handlers lightweight - Events fire frequently
Check running state - Handler respects EventListener.running
Handle null safety - Some event properties can be null
Use correct priority - Default works for most cases

Module System

Command System

Configuration

Events

Utilities

​Overview

​Event Categories

​Game Events

​GameTickEvent

​GameRenderEvent

​RotationUpdateEvent

​Player Events

​PlayerTickEvent

​PlayerMoveEvent

​PlayerJumpEvent

​PlayerSafeWalkEvent

​AttackEntityEvent

​Network Events

​PacketEvent

​ServerConnectEvent

​DisconnectEvent

​World Events

​WorldChangeEvent

​ChunkLoadEvent

​ChunkUnloadEvent

​BlockChangeEvent

​Input Events

​KeyboardKeyEvent

​MouseButtonEvent

​MouseScrollEvent

​Module Events

​ModuleToggleEvent

​ModuleActivationEvent

​ValueChangedEvent

​Render Events

​WorldRenderEvent

​OverlayRenderEvent

​ScreenRenderEvent

​Combat Events

​TargetChangeEvent

​Notification Events

​NotificationEvent

​Chat Events

​ChatReceiveEvent

​ChatSendEvent

​Session Events

​SessionEvent

​Window Events

​WindowResizeEvent

​Base Event Class

​Cancellable Events

​Event Ordering

​Best Practices

​See Also

Build docs developers (and LLMs) love