📓Events

List of game events:

local hitgroup_str = {
    [0] = 'generic',
    'head', 'chest', 'stomach',
    'left arm', 'right arm',
    'left leg', 'right leg',
    'neck', 'generic', 'gear'
}

events.player_hurt:set(function(e)
    local me = entity.get_local_player()
    local attacker = entity.get(e.attacker, true)

    if me == attacker then
        local user = entity.get(e.userid, true)
        local hitgroup = hitgroup_str[e.hitgroup]

        print(('Hit %s in the %s for %d damage (%d health remaining)'):format(
            user:get_name(), hitgroup,
            e.dmg_health, e.health
        ))
    end
end)

List of events:

render

Fired every frame. Most functions from the render namespace can only be used here.

events.render:set(function(ctx)
    render.rect(vector(0, 0), vector(1920, 1080), color(230, 150))
end)

render_glow

Fired every time the game prepares glow object manager. This event gives you the ability to render glow lines. Access the function by adding an argument to the callback.

ctx:render(from: vector, to: vector, thickness: number, flags: string, color: color)

local real_yaw, abs_yaw = 0, 0

events.createmove:set(function(cmd)
    local me = entity.get_local_player()
    local anim_state = me:get_anim_state()

    if not anim_state or cmd.choked_commands > 0 then
        return
    end

    real_yaw = anim_state.eye_yaw
    abs_yaw = anim_state.abs_yaw
end)

events.render_glow:set(function(ctx)
    local me = entity.get_local_player()

    if not me or not me:is_alive() then
        return
    end

    local origin = me:get_origin()
    local real_yaw_dir = origin + (vector():angles(0, real_yaw) * 20)
    local abs_yaw_dir = origin + (vector():angles(0, abs_yaw) * 25)

    ctx:render(origin, real_yaw_dir, 0.15, 'lg', color(255, 0, 0)) -- Real yaw
    ctx:render(origin, abs_yaw_dir, 0.15, 'g', color(35, 215, 235)) -- Body yaw
end)

override_view

Fired every time the game prepares camera view.

createmove

Fired every time the game prepares a move command. Use this to modify something before the aimbot or movement features. Use the parameter passed by the callback to access the UserCmd.

-- Sets the Roll angle when Shift (+speed) is being held
events.createmove:set(function(cmd)
    if cmd.in_speed then
        cmd.view_angles.z = 50 -- you are now unhittable
    end
end)

🔗 struct UserCmd

local on_createmove = function(cmd)
    cmd.in_attack -- +attack
    cmd.in_attack2 -- +attack2
    
    cmd.in_use -- +use
    cmd.in_jump -- +jump
    cmd.in_duck -- +duck
    cmd.in_walk -- +walk
    cmd.in_speed -- +speed
    cmd.in_reload -- +reload
    
    cmd.in_moveleft
    cmd.in_moveright
    cmd.in_forward
    cmd.in_back
    cmd.in_left
    cmd.in_right
    
    cmd.in_bullrush
end

events.createmove:set(on_createmove)

createmove_run

Fired every time the game runs a move command. Use the parameter passed by the callback to access the RunCommand.

🔗 struct RunCommand

aim_fire

Fired every time the aimbot shoots at a player.

aim_ack

bullet_fire

Fired every time someone fires a bullet.

console_input

Fired every time the user runs a console command. Use the parameter passed by the callback to access the input string.

local last_random_int

events.console_input:set(function(text)
    if text == '/roll' then
        local random_int = utils.random_int(1, 6)

        local str = common.get_username() .. ' rolled a ' .. random_int
        if random_int == 1 and random_int == last_random_int then
            str = str .. '... snake eyes!'
        end

        print(str)

        last_random_int = random_int
        return false
    end
end)

This can be used to implement custom console commands. Return false to prevent the game from processing the command.

draw_model

Fired before a model is rendered. Use the parameter passed by the callback to access the model context. Return false to prevent the game from rendering the original model.

local ct_fbi_glass = materials.get('models/player/ct_fbi/ct_fbi_glass', true)

events.draw_model:set(function(ctx)
    local me = entity.get_local_player()

    if ctx.entity == me then
        -- Override local player model with the new material
        ctx:draw(ct_fbi_glass)

        -- Prevent the game from drawing the original model
        return false
    end
end)

level_init

Fired after fully connected to the server (first non-delta packet received). (SIGNONSTATE:FULL)

pre_render

Fired before a frame is rendered. (FrameStageNotify:FRAME_RENDER_START)

post_render

Fired after a frame is rendered. (FrameStageNotify:FRAME_RENDER_END)

net_update_start

Fired before the game processes entity updates from the server. (FrameStageNotify:FRAME_NET_UPDATE_START)

net_update_end

Fired after an entity update packet is received from the server. (FrameStageNotify:FRAME_NET_UPDATE_END)

config_state

Fired every time config state is updated. The current state is accessible from the callback arguments as one of these strings: pre_save, post_save, pre_load, post_load.

events.config_state(function(state)
    print(state == "pre_save")
end)

mouse_input

Fired every time the mouse input occurs. Return false to lock the mouse input.

shutdown

Fired when the script is about to unload.

pre_update_clientside_animation

Fired before C_CSPlayer::UpdateClientSideAnimation is called.

post_update_clientside_animation

Fired after C_CSPlayer::UpdateClientSideAnimation is called.

grenade_override_view

Invoked to override the input values for the grenade prediction. Contains detailed view parameters associated with the grenade trajectory prediction.

grenade_warning

Fired when the "Grenade Proximity Warning" is being rendered. Return false to it from being rendered.

grenade_prediction

Fired when the cheat is drawing the predicted grenade trajectory. Contains detailed information about the grenade's trajectory and impact.

localplayer_transparency

Invoked to override the opacity of the local player's model. You can override it by returning a custom alpha value.

List of complicated events:

voice_message

Fired every time the game receives a voice packet.

🔗 struct bf_read

🔗 struct bf_write

📌 Firing this event from the Lua will send a voice packet

events.voice_message(function: buffer)

events.voice_message(function(ctx)
    local buffer = ctx.buffer
    local code = buffer:read_bits(16)

    if code ~= 0x1337 then
        return
    end

    local tickcount = buffer:read_bits(32)

    print(string.format(
        'received voice packet from %s | pct_tickcount: %d',
        ctx.entity:get_name(), tickcount
    ))
end)

-- Note that you wont be able to receive your own voice packet
-- unless voice_loopback convar is set to 1
events.voice_message:call(function(buffer)
    buffer:write_bits(0x1337, 16)
    buffer:write_bits(globals.tickcount, 32)
end)

[neverlose] received voice packet from Salvatore | pct_tickcount: 1200