dismhook Lua API

-- hello.lua
-- The smallest script that puts something on screen.
-- Drop it in Documents\dh-<username>\scripts, press Refresh in the Scripts tab, tick it on.

dismhook.log("hello.lua loaded (API " .. dismhook.api.major .. "." .. dismhook.api.minor .. ")")

-- everything that is drawn is drawn from the "frame" event, about 60 times a second
dismhook.events.on("frame", function(frame)
    local map = frame.map ~= "" and frame.map or "no map"
    dismhook.draw.panel(20, 200, 260, 64, "Hello from Lua", 90, 160, 255, 255)
    dismhook.draw.text(30, 226, string.format("%s  |  %d players", map, #frame.players), 235, 235, 240, 255)
end)

-- esp_boxes.lua
-- Boxes, health bars, names and distance for every enemy, using world_to_screen.
--
-- Two things worth knowing:
--   * player.bones is 1-based: bone id 7 (the head) is bones[8].
--   * colour channels must be whole numbers, so use math.floor() when a colour is calculated.

local ENEMIES_ONLY = true

local function health_colour(fraction)
    return math.floor(255 * (1 - fraction)), math.floor(255 * fraction), 60
end

dismhook.events.on("frame", function(frame)
    local me = frame.local_player
    local eye = frame.camera.origin

    for _, player in ipairs(frame.players) do
        if not ENEMIES_ONLY or player.team ~= me.team then
            local head = player.bones[8] or { x = player.origin.x, y = player.origin.y, z = player.origin.z + 64 }
            local top = dismhook.game.world_to_screen({ x = head.x, y = head.y, z = head.z + 9 })
            local bottom = dismhook.game.world_to_screen(player.origin)

            if top and bottom then
                local height = bottom.y - top.y
                if height > 4 then
                    local width = height * 0.45
                    local left = top.x - width / 2

                    -- the box: green while you can see them, red while they are behind something
                    local r, g, b = 255, 90, 90
                    if player.visible then r, g, b = 90, 255, 120 end
                    dismhook.draw.rect(left, top.y, width, height, r, g, b, 255, 1.5)

                    -- health bar on the left
                    local fraction = math.max(0, math.min(100, player.health)) / 100
                    dismhook.draw.filled_rect(left - 6, top.y, 3, height, 0, 0, 0, 170)
                    local hr, hg, hb = health_colour(fraction)
                    dismhook.draw.filled_rect(left - 6, top.y + height * (1 - fraction), 3, height * fraction, hr, hg, hb, 255)

                    -- name above, distance and weapon below
                    local dx, dy, dz = player.origin.x - eye.x, player.origin.y - eye.y, player.origin.z - eye.z
                    local distance = math.sqrt(dx * dx + dy * dy + dz * dz)
                    dismhook.draw.text(left, top.y - 14, player.name, 255, 255, 255, 255)
                    dismhook.draw.text(left, bottom.y + 2, string.format("%d u  %s", math.floor(distance), player.weapon.name), 200, 200, 210, 255)
                end
            end
        end
    end
end)

-- event_feed.lua
-- A fading feed of what happens in the round, built from events instead of polling.
--
-- Note: a player who dies is simply gone from frame.players, so a death shows up as
-- "player_left" (after a "player_hurt"), not as "player_killed".

local MAX_LINES = 8
local LIFETIME = 6.0            -- seconds a line stays
local FADE = 1.0                -- seconds it takes to fade out

local lines = {}
local now = 0                   -- seconds, kept up to date by the frame handler
local names = {}                -- pawn handle -> name, learned from the frames

local function push(text, r, g, b)
    table.insert(lines, 1, { text = text, born = now, r = r, g = g, b = b })
    while #lines > MAX_LINES do table.remove(lines) end
end

local function who(handle)
    return names[handle] or "someone"
end

dismhook.events.on("map_changed", function(map)
    lines = {}
    push("Map: " .. map, 255, 255, 255)
end)

dismhook.events.on("player_hurt", function(e)
    push(string.format("%s lost %d hp (%d left)", who(e.handle), e.damage, e.health), 255, 200, 90)
end)

dismhook.events.on("player_left", function(handle)
    push(who(handle) .. " is gone", 255, 120, 120)
end)

dismhook.events.on("weapon_changed", function(e)
    push(who(e.handle) .. " switched to " .. e.weapon.name, 150, 190, 255)
end)

dismhook.events.on("bomb_planted", function() push("Bomb planted", 255, 190, 60) end)
dismhook.events.on("bomb_defuse_started", function() push("Defuse started", 120, 255, 160) end)
dismhook.events.on("bomb_defused", function() push("Bomb defused", 120, 255, 160) end)

dismhook.events.on("frame", function(frame)
    now = frame.timestamp_us / 1000000
    for _, player in ipairs(frame.players) do names[player.handle] = player.name end

    local y = 400
    for _, line in ipairs(lines) do
        local age = now - line.born
        if age < LIFETIME then
            local alpha = math.floor(255 * math.min(1, (LIFETIME - age) / FADE))
            dismhook.draw.text(20, y, line.text, line.r, line.g, line.b, alpha)
            y = y + 15
        end
    end
end)

-- grenade_paths.lua
-- Draws where every grenade in the air is going to land, with a countdown to the bang.
--
-- projectile.kind: 1 HE, 2 flash, 3 smoke, 4 molotov, 5 molotov fire (no flight), 6 decoy

local NAMES = { [1] = "he", [2] = "flash", [3] = "smoke", [4] = "molotov", [6] = "decoy" }

dismhook.events.on("frame", function(frame)
    for _, projectile in ipairs(frame.projectiles) do
        local name = NAMES[projectile.kind]
        if name and not projectile.detonated then
            -- predict from where the grenade is now, at the speed it has now
            local path = dismhook.game.predict_grenade(projectile.origin, projectile.velocity, name)
            if path and path.valid then
                local previous
                for _, point in ipairs(path.points) do
                    if previous then
                        dismhook.draw.world_line(previous, point, 255, 200, 80, 200, 1.5)
                    end
                    previous = point
                end

                for _, bounce in ipairs(path.bounces) do
                    local spot = dismhook.game.world_to_screen(bounce)
                    if spot then dismhook.draw.filled_circle(spot.x, spot.y, 2.5, 255, 255, 255, 220) end
                end

                local landing = dismhook.game.world_to_screen(path.end_position)
                if landing then
                    dismhook.draw.circle(landing.x, landing.y, 7, 255, 200, 80, 255, 2)
                    dismhook.draw.text(landing.x + 11, landing.y - 6, string.format("%s  %.1f s", name, path.duration), 255, 255, 255, 255)
                end
            end
        end
    end
end)

-- hotkey_toggle.lua
-- Flip settings of the program with a key: F6 for player ESP, F7 for the radar.
-- Uses dismhook.config to read and write any setting by its path, and shows a small toast.
--
-- Virtual-key codes: F6 is 0x75, F7 is 0x76 (see the key table in the reference).

local HOTKEYS = {
    { vk = 0x75, path = "esp.m_player.enabled", label = "Player ESP" },
    { vk = 0x76, path = "esp.m_radar.enabled",  label = "Radar" },
}

local was_down = {}
local toast, toast_until = "", 0

-- "tick" runs every 16 ms, whatever the game is doing
dismhook.events.on("tick", function()
    for _, hotkey in ipairs(HOTKEYS) do
        local down = dismhook.input.is_down(hotkey.vk)
        if down and not was_down[hotkey.vk] then          -- only on the press, not while held
            local current = dismhook.config.get(hotkey.path)
            if type(current) == "boolean" then
                dismhook.config.set(hotkey.path, not current)   -- queued, applied on the next frame
                toast = hotkey.label .. (current and " off" or " on")
                toast_until = os.time() + 2
            else
                dismhook.log("no such setting: " .. hotkey.path)
            end
        end
        was_down[hotkey.vk] = down
    end
end)

-- raised after a script's config change has been applied (not for changes made in the menu)
dismhook.events.on("config_changed", function()
    dismhook.log("config changed by a script")
end)

-- registering a frame handler is what makes the toast possible
dismhook.events.on("frame", function()
    if os.time() < toast_until then
        dismhook.draw.panel(20, 120, 200, 40, toast, 90, 160, 255, 255)
    end
end)

-- radar.lua
-- A radar in the corner of the screen, on top of the game's own overview image for the map.
-- Save it directly in the scripts folder (not in a sub-folder): the exported picture is
-- loaded from .data\<script name>\, which is only reachable from there.

local SIZE = 240                     -- radar size in pixels
local LEFT, TOP = 20, 20             -- where it sits on screen

local id = dismhook.api.data_dir:match("[^\\/]+$")     -- this script's name, as the runtime knows it
local overview, texture, loaded_for = nil, nil, nil

local function load_overview(map)
    loaded_for, overview, texture = map, nil, nil
    if map == "" then return end
    -- this reads and decodes the game's own map image: do it once per map, never per frame
    local info, err = dismhook.game.radar_overview(map, "overview")
    if not info then
        dismhook.log("no radar image for " .. map .. ": " .. tostring(err))
        return
    end
    overview = info
    texture = dismhook.draw.load_texture(".data/" .. id .. "/overview-primary.png")
end

-- world position -> pixel on the radar
local function to_radar(pos)
    local u = (pos.x - overview.pos_x) / overview.scale         -- pixel on the overview image
    local v = (overview.pos_y - pos.y) / overview.scale
    return LEFT + u / overview.width * SIZE, TOP + v / overview.height * SIZE
end

dismhook.events.on("frame", function(frame)
    if frame.map ~= loaded_for then load_overview(frame.map) end
    if not overview then return end

    dismhook.draw.filled_rect(LEFT, TOP, SIZE, SIZE, 12, 13, 18, 200)
    if texture then dismhook.draw.image(texture, LEFT, TOP, SIZE, SIZE, 255, 255, 255, 235) end

    for _, player in ipairs(frame.players) do
        local x, y = to_radar(player.origin)
        if x >= LEFT and x <= LEFT + SIZE and y >= TOP and y <= TOP + SIZE then
            local mine = player.team == frame.local_player.team
            if mine then
                dismhook.draw.filled_circle(x, y, 3.5, 90, 170, 255, 255)
            else
                dismhook.draw.filled_circle(x, y, 3.5, 255, 90, 90, 255)
            end
        end
    end

    local x, y = to_radar(frame.camera.origin)                    -- you
    dismhook.draw.circle(x, y, 4.5, 255, 255, 255, 255, 1.5)
    dismhook.draw.rect(LEFT, TOP, SIZE, SIZE, 54, 57, 69, 255, 1)
end)

-- spectator_alert.lua
-- A red panel with the names of everyone who is watching you.
-- (The list is refreshed about five times a second.)

local X, Y, W = 20, 560, 230

dismhook.events.on("frame", function(frame)
    local count = #frame.spectators
    if count == 0 then return end

    dismhook.draw.panel(X, Y, W, 34 + count * 16, "Watched by " .. count, 255, 90, 90, 255)
    for index, spectator in ipairs(frame.spectators) do
        dismhook.draw.text(X + 10, Y + 28 + (index - 1) * 16, spectator.name, 235, 235, 240, 255)
    end
end)

-- the same information as a one-off message: when somebody starts or stops watching
local known = {}
dismhook.events.on("tick", function()
    local frame = dismhook.game.snapshot()
    if not frame then return end
    local seen = {}
    for _, spectator in ipairs(frame.spectators) do
        seen[spectator.steam_id64] = true
        if not known[spectator.steam_id64] then dismhook.log(spectator.name .. " started watching you") end
    end
    for steam_id in pairs(known) do
        if not seen[steam_id] then dismhook.log("a spectator stopped watching you") end
    end
    known = seen
end)

-- crouch_toggle.lua
-- Press X once to crouch and stay crouched, press it again to stand up.
-- It presses whatever key you have bound to crouch in the game, found with dismhook.input.binding.
--
-- Input is only sent while the menu is closed and the game window is ready; the runtime lets go
-- of every key the script holds when that stops being true, and when the script stops.

local HOTKEY = 0x58                 -- X
local crouch_key                    -- the virtual key the game's crouch is bound to
local was_down, crouching = false, false

local function find_crouch_key()
    local binding = dismhook.input.binding("duck")
    if binding and binding.device == 1 then     -- 1 = a keyboard key (mouse buttons are 2 and up)
        crouch_key = binding.virtual_key
    end
end

-- "load" can arrive more than once on the very first start, so keep it harmless to repeat
dismhook.events.on("load", find_crouch_key)

dismhook.events.on("tick", function()
    local down = dismhook.input.is_down(HOTKEY)
    if down and not was_down and crouch_key then
        crouching = not crouching
        if not dismhook.input.key(crouch_key, crouching) then
            crouching = false                       -- refused: the menu is open or the game is not ready
        end
    end
    was_down = down
end)

-- the runtime releases held keys when the menu opens; keep our own idea of it in step
dismhook.events.on("frame", function(frame)
    if frame.menu_open or not frame.input_ready then crouching = false end
end)

-- template.lua
-- A starting point: every part of a script in the place it belongs.
-- Copy it, rename it, delete what you do not need.

------------------------------------------------------------------------------------------
-- 1. Top of the file. This runs once, when the script starts (and again after every reload).
--    Keep it quick: the whole chunk has to finish within 8 ms.
------------------------------------------------------------------------------------------
local SETTINGS = {
    panel_x = 20,
    panel_y = 200,
}

-- whatever you saved last time (nil the first time)
local saved = dismhook.storage.get("state") or { runs = 0 }

------------------------------------------------------------------------------------------
-- 2. Lifecycle events
------------------------------------------------------------------------------------------
-- "load": the script is up. On the very first start it can arrive more than once, so make
-- what you do here safe to repeat.
dismhook.events.on("load", function()
    dismhook.log("loaded")
end)

-- "unload": the script is stopping or being replaced by a new version of the file.
-- Keys and mouse buttons the script holds are released by the runtime; save what you need.
dismhook.events.on("unload", function()
    saved.runs = saved.runs + 1
    dismhook.storage.set("state", saved)
end)

------------------------------------------------------------------------------------------
-- 3. "tick": every 16 ms, always. For logic that does not need the game's data:
--    polling keys, timers, talking to dismhook.config.
------------------------------------------------------------------------------------------
local elapsed = 0
dismhook.events.on("tick", function(dt)
    elapsed = elapsed + dt
end)

------------------------------------------------------------------------------------------
-- 4. Game events: they only fire once you register for them, and only while a game is running.
------------------------------------------------------------------------------------------
dismhook.events.on("map_changed", function(map)
    dismhook.log("now on " .. map)
end)

------------------------------------------------------------------------------------------
-- 5. "frame": the game's data plus the one place you may draw. About 60 times a second.
--    A handler that errors stops the whole script (it shows "Error" in the list) until you
--    save the file again, so guard anything that can go wrong with pcall.
------------------------------------------------------------------------------------------
local function draw_panel(frame)
    dismhook.draw.panel(SETTINGS.panel_x, SETTINGS.panel_y, 240, 60, "Template", 90, 160, 255, 255)
    dismhook.draw.text(SETTINGS.panel_x + 10, SETTINGS.panel_y + 26,
        string.format("%d players, up %.0f s", #frame.players, elapsed), 235, 235, 240, 255)
end

dismhook.events.on("frame", function(frame)
    local ok, err = pcall(draw_panel, frame)
    if not ok then dismhook.log("draw failed: " .. tostring(err)) end
end)

{
    "id": "kill_tracker",
    "name": "Kill tracker",
    "version": "1.2.0",
    "author": "you",
    "description": "Counts the kills you confirm, and how long the map has been running",
    "api_version": 2,
    "entry": "main.lua"
}

-- kill_tracker\main.lua
-- The entry point named in manifest.json. It can require() anything inside this folder:
-- "lib.util" is the file lib\util.lua next to this one.

local util = require("lib.util")

local kills = 0
local started = nil

dismhook.events.on("map_changed", function()
    kills = 0
    started = nil
end)

dismhook.events.on("confirmed_hit", function(hit)
    if hit.killed then kills = kills + 1 end
end)

dismhook.events.on("frame", function(frame)
    started = started or frame.local_player.game_time
    local up = frame.local_player.game_time - started
    dismhook.draw.text(20, 640, string.format("Kills: %d   Map time: %s", kills, util.clock(up)), 255, 255, 255, 255)
end)

-- kill_tracker\lib\util.lua
-- A module: whatever it returns is what require("lib.util") gives back.

local util = {}

-- 75.4 -> "1:15"
function util.clock(seconds)
    seconds = math.max(0, math.floor(seconds))
    return string.format("%d:%02d", seconds // 60, seconds % 60)
end

function util.clamp(value, low, high)
    return math.max(low, math.min(high, value))
end

return util