Menu

Functions

root

Returns the submenu instance for your scripts dedicated submenu inside of the Scripts submenu.

function menu.root(): submenu

player_root

Returns the submenu instance for your scripts dedicated submenu for each player.

function menu.player_root(): submenu

find

Finds an option in the menu via a hierarchy path.

---@param path string
function menu.find(path): option

iter

Returns a tree of all menu options, preserving hierarchy and order.

function menu.iter(): menu_node[]

type_of

Returns the name of an option object, else “unknown”

---@param object option
function menu.type_of(object): string

Types

menu_node

submenu

---@param name string
---@param insert_at? integer
function submenu:submenu(name, insert_at?): submenu

---@param name string
---@param insert_at? integer
function submenu:toggle(name, insert_at?): toggle

---@param name string
---@param key? integer
---@param insert_at? integer
function submenu:hotkey(name, key?, insert_at?): hotkey

---@param name string
---@param insert_at? integer
function submenu:textbox(name, insert_at?): textbox

---@param name string
---@param insert_at? integer
function submenu:button(name, insert_at?): button

---@param name string
---@param insert_at? integer
function submenu:breaker(name, insert_at?): breaker

---@param name string
---@param type? menu.type|integer
---@param insert_at? integer
function submenu:number_int(name, type?, insert_at?): number_int

---@param name string
---@param type? menu.type|integer
---@param insert_at? integer
function submenu:number_float(name, type?, insert_at?): number_float

---@param name string
---@param values table
---@param type menu.type|integer
---@param multi? bool
---@param insert_at? integer
function submenu:combo_int(name, values, type, multi?, insert_at?): combo_int

---@param name string
---@param values table
---@param type menu.type|integer
---@param multi? bool
---@param insert_at? integer
function submenu:combo_float(name, values, type, multi?, insert_at?): combo_float

---@param name string
---@param values table
---@param type menu.type|integer
---@param multi? bool
---@param insert_at? integer
function submenu:combo_str(name, values, type, multi?, insert_at?): combo_str

---@param new_size integer
function submenu:resize(new_size): nil

textbox

---@param text string
function textbox:tooltip(text): textbox

---@param flag menu.flags
function textbox:flags(flags): textbox

---@param event menu.event
---@param fn function(textbox)
function textbox:event(event, fn): textbox

---@param chars integer
function textbox:max_chars(chars): textbox

function textbox:invoke(): textbox

toggle

---@param text string
function toggle:tooltip(text): toggle

---@param flag menu.flags
function toggle:flags(flags): toggle

---@param event menu.event
---@param fn function(toggle)
function toggle:event(event, fn): toggle

function toggle:invoke(): toggle

hotkey

---@param text string
function hotkey:tooltip(text): hotkey

---@param flag menu.flags
function hotkey:flags(flags): hotkey

---@param event menu.event
---@param fn function
function hotkey:event(event, fn): hotkey

function hotkey:invoke(): hotkey

breaker

---@param text string
function breaker:tooltip(text): breaker

---@param flag menu.flags
function breaker:flags(flags): breaker

---@param event menu.event
---@param fn function(breaker)
function breaker:event(event, fn): breaker

function breaker:invoke(): breaker

button

---@param text string
function button:tooltip(text): button

---@param flag menu.flags
function button:flags(flags): button

---@param event menu.event
---@param fn function(button)
function button:event(event, fn): button

function button:invoke(): button

number_int

---@param text string
function number_int:tooltip(text): number_int

---@param flag menu.flags
function number_int:flags(flags): number_int

---@param event menu.event
---@param fn function(number_int)
function number_int:event(event, fn): number_int

---@param fmt string
---@param min integer
---@param max integer
---@param step? integer
function number_int:fmt(fmt, min, max, step?): number_int

---@param step integer
function number_int:step(step): number_int

function number_int:invoke(): number_int

number_float

---@param text string
function number_float:tooltip(text): number_float

---@param flag menu.flags
function number_float:flags(flags): number_float

---@param event menu.event
---@param fn function(number_float)
function number_float:event(event, fn): number_float

---@param fmt string
---@param min number
---@param max number
---@param step? number
function number_float:fmt(fmt, min, max, step?): number_float

---@param step number
function number_float:step(step): number_float

function number_float:invoke(): number_float

combo_int

---@param text string
function combo_int:tooltip(text): combo_int

---@param flag menu.flags
function combo_int:flags(flags): combo_int

---@param event menu.event
---@param fn function(combo_int)
function combo_int:event(event, fn): combo_int

function combo_int:invoke(): combo_int

combo_float

---@param text string
function combo_float:tooltip(text): combo_float

---@param flag menu.flags
function combo_float:flags(flags): combo_float

---@param event menu.event
---@param fn function(combo_float)
function combo_float:event(event, fn): combo_float

function combo_float:invoke(): combo_float

combo_str

---@param text string
function combo_str:tooltip(text): combo_str

---@param flag menu.flags
function combo_str:flags(flags): combo_str

---@param event menu.event
---@param fn function(combo_str)
function combo_str:event(event, fn): combo_str

function combo_str:invoke(): combo_str

combo_list_int

---@param index integer
function combo_list_int:at(index): combo_list_int

combo_list_float

---@param index integer
function combo_list_float:at(index): combo_list_float

combo_list_str

---@param index integer
function combo_list_str:at(index): combo_list_str

combo_multi_list

---@param index integer
function combo_multi_list:is_set(index): bool

---@param index integer
---@param value bool
function combo_multi_list:set(index, value): nil

---@param index integer
function combo_multi_list:is_disabled(index): bool

---@param index integer
---@param value bool
function combo_multi_list:disable(index, value): nil

Constants

flags

menu.flags.in_game
menu.flags.hotkey
menu.flags.host_only
menu.flags.scr_host_only
menu.flags.risky
menu.flags.disabled
menu.flags.fake_radio
menu.flags.fake_submenu
menu.flags.command

event

menu.event.click
menu.event.completed
menu.event.enter
menu.event.leave

slider

menu.slider.scroll
menu.slider.press
menu.slider.toggle

type

menu.type.submenu
menu.type.button
menu.type.toggle
menu.type.color
menu.type.number
menu.type.combo
menu.type.text
menu.type.breaker
menu.type.radio
menu.type.label
menu.type.hotkey
menu.type.multi_combo

sub_type

menu.sub_type.integer
menu.sub_type.floating
menu.sub_type.str
menu.sub_type.boolean
menu.sub_type.vec2
menu.sub_type.vec3
menu.sub_type.scr_vec3
menu.sub_type.color

Example

local root = menu.root()
local player_root = menu.player_root()

-- modify an existing option
local noclip_opt = menu.find('Player > Movement > Noclip')
if noclip_opt then
  noclip_opt.toggle = true
end

-- add options to existing submenus
local player_submenu = menu.find('Player')
local player_opt_index = player_submenu.first_option_index;

player_submenu:button('First Extra Option', player_opt_index)
player_submenu:button('Second Extra Option', player_opt_index + 1)

-- add options to network players
player_root:button('notify')
  :event(menu.event.click, function(opt)
    if players.is_target_session() then
      notify.push('cool script', 'session is selected', { icon = notify.icon.hazard })
    else
      notify.push('cool script', players.target().name, { icon = notify.icon.hazard })
    end
  end)

-- add options to your own dedicated submenu in Scripts
local self_menu = root:submenu('Self')

self_menu:button('resize')
  :event(menu.event.click, function(opt)
    self_menu:resize(2)
  end)

self_menu:button('test loop')
  :event(menu.event.click, function(opt)
    local start_time = os.clock()
    while true do
      print('test')

      if os.clock() - start_time >= 3 then
        return
      end

      util:yield()
    end
  end)

self_menu:number_int('int number opt', menu.slider.scroll)
  :fmt('%i', 0, 100)
  :event(menu.event.click, function(opt)
    print('value was changed to ' .. opt.value)
  end)

self_menu:number_float('float number opt', menu.slider.scroll)
  :fmt('%.2f', 0.0, 100.0)
  :event(menu.event.click, function(opt)
    print('value was changed to ' .. opt.value)
  end)

local combo_int_list = { { 'name1', 123 }, { 'name2', 43 } }
self_menu:combo_int('int combo opt', combo_int_list, menu.slider.press)
  :event(menu.event.click, function(opt)
    print('index: ' .. opt.value)
    print('pressed: ' .. opt.list:at(opt.value).name)
  end)

local combo_float_list = { { 'n1', 12.34 }, { 'n2', 99.19 }, { 'n3', 12.44 } }
self_menu:combo_float('float combo multi opt', combo_float_list, menu.slider.press, true) -- true signals that this combo is a "multi" type, where each index can be toggled
  :event(menu.event.click, function(opt)
    print('index: ' .. opt.value)
    print('count: ' .. #combo_float_list)
    for i = 1, #combo_float_list do
      print(type(i))
      print('i:' .. i)
      print('index: ', i, 'set: ', opt.multi:is_set(i))

      if opt.multi:is_set(i) then
        print('	name: ', combo_float_list[i][1])
      end
    end
  end)