Tinkr

https://docs.tinkr.site
Admin
Tinkr is a scripting platform that provides Lua and Routine APIs for creating custom scripts,...
Tokens:48,561
Snippets:268
Trust Score:5.5
Update:10 months ago
Show doc for...
Tokens:
Raw
### Create and Build a GUI Window with GUIBuilder (Lua)

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder

Demonstrates the minimal usage of GUIBuilder to create a new instance, define a window with specific properties, and then build/display that window. It requires the Tinkr library and specifically the GUIBuilder utility.

```Lua
local Tinkr = ...
local GUIBuilder = Tinkr.Util.GUIBuilder
 
-- Create a new instance of GUIBuilder.
local Builder = GUIBuilder:New {
    -- This is the name of your configs .json file, all settings will be stored in
    -- this file. GUIBuilder will manage this file, just make sure the name is
    -- unique enough that no other GUIs will share the same name.
    config = "example_empty" -- would be `configs/example_empty.json`
}
 
-- Create a Window element, with no content.
local Window = Builder:Window {
    key = "example_window",
    title = "Empty Window",
    width = 250,
    height = 350,
    content = { }
}
 
-- Build the GUI element, this shows the window.
Builder:Build(Window)
```

--------------------------------

### Get Power Level - Lua Examples

Source: https://docs.tinkr.site/Routine/Conditions/power

Demonstrates how to use the 'power' function in Lua to retrieve various power types for the player or a target unit. It shows examples for fetching Lunar Power, default Mana, and target Mana.

```lua
local playerAstral = power(PowerType.LunarPower)
local playerMana = power()
local targetMana = power(PowerType.Mana, 'target')
```

--------------------------------

### Lua: Dropdown Menu Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Showcases the creation of dropdown menus using Tinkr's GUI builder. Dropdowns allow users to select an option from a list. This example demonstrates standard dropdowns and multi-select dropdowns, defining key-value pairs for the options.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local DropdownGroup = Builder:Group {
    title = "Standard Dropdowns",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:Dropdown {
                    key = 'dropdown_a',
                    label = "Example Dropdown A",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D",
                        option_e = "Option E",
                    }
                },
                Builder:Dropdown {
                    key = 'dropdown_b',
                    label = "Example Dropdown B",
                    multi = true,

```

--------------------------------

### Create Dropdowns

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Configures standard dropdown menus, supporting both single selection and multi-selection. Each dropdown is defined with a key, label, and a map of values.

```lua
local DropdownGroup = Builder:Group {
    title = "Standard Dropdowns",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:Dropdown {
                    key = 'dropdown_a',
                    label = "Example Dropdown A",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D",
                        option_e = "Option E",
                    }
                },
                Builder:Dropdown {
                    key = 'dropdown_b',
                    label = "Example Dropdown B",
                    multi = true,
                    description = "This dropdown allows selecting multiple values.",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D",
                        option_e = "Option E",
                    }
                }
            }
        }
    }
}
```

--------------------------------

### Lua: Basic Checkbox Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Demonstrates the creation of simple checkboxes using Tinkr's GUIBuilder. Checkboxes allow for binary (yes/no) state selection, useful for enabling or disabling features. This example includes checkboxes with and without descriptions.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local SimpleCheckboxes = Builder:Group {
    title = "Simple Checkboxes",
    content = {
        Builder:Text "Checkboxes allow you to have 2 states (yes and no) which can be used for enabling or disabling functionality.",
        Builder:Spacer { },
        Builder:Checkbox {
            key = "checkbox_a",
            label = "Checkbox A",
            description = "Description for Checkbox A."
        },
        Builder:Checkbox {
            key = "checkbox_b",
            label = "Checkbox B",
            description = "Description for Checkbox B."
        },
        Builder:Checkbox {
            key = "checkbox_c",
            label = "Checkbox C"
        }
    }
}
```

--------------------------------

### Build GUI Window with Tabs and Elements

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Constructs a GUI window titled 'GUI Example' containing a tab group. The tab group includes various input elements like EditBox, Dropdown, Slider, and ColorPicker. This code utilizes a 'Builder' pattern for UI construction.

```lua
local TabGroup = Builder:TabGroup {
    key = "tab_group_a",
    tabs = {
        Builder:Tab {
            key = "tab_a",
            title = "Tab A",
            content = {
                Builder:EditBox {
                    key = "editbox_a",
                    label = "Example Edit Box A",
                    placeholder = "Enter text here"
                },
                Builder:Spacer { },
                Builder:EditBox {
                    key = "editbox_b",
                    label = "Example Edit Box B",
                    placeholder = "Enter password here",
                    password = true
                },
                Builder:Spacer { },
                Builder:Dropdown {
                    key = 'dropdown_b',
                    label = "Example Dropdown B",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D"
                    }
                },
                Builder:Spacer { },
                Builder:EditBox {
                    key = "editbox_c",
                    label = "Edit Box C",
                    placeholder = "Placeholder Value",
                    description = "This input requires you to click " .. OKAY,
                    button = true
                },
                Builder:Spacer { },
                Builder:Dropdown {
                    key = 'dropdown_a',
                    label = "Example Dropdown A",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D",
                        option_e = "Option E",
                    }
                },
                Builder:Spacer { },
                Builder:Slider {
                    key = 'slider_a',
                    label = "Example Slider A",
                    description = "This slider ranges from 0% (0) to 100% (1).",
                },
                Builder:Spacer { },
                Builder:ColorPicker {
                    key = 'color_a',
                    label = "Example Color Picker A",
                    description = "This does not include an alpha value."
                },
            }
        }
    }
}

local Window = Builder:Window {
    key = "gui_example",
    title = "GUI Example",
    width = 350,
    height = 500,
    content = {
        TabGroup
    }
}

Builder:Build(Window)

```

--------------------------------

### Movement Utility Usage Example (Lua)

Source: https://docs.tinkr.site/Modules/Util/Movement

Demonstrates the basic usage of the Tinkr.Util.Movement functions by hooking into movements and toggling their state. This example assumes Tinkr and its Movement utility are properly initialized.

```lua
local Tinkr = ...
local Movement = Tinkr.Util.Movement

Movement:Hook()
Movement:Toggle()
```

--------------------------------

### Tinkr HTTP Module: Deprecated methods for GET and POST

Source: https://docs.tinkr.site/Modules/Util/HTTP

Provides examples of deprecated HTTP methods like HTTP:GET and HTTP:POST, intended for legacy code. It also shows the usage of the HTTP:Params helper for constructing POST request parameters. These methods are not recommended for new development.

```lua
-- An example of a HTTP GET
HTTP:GET('https://example.com', function (status, res) 
    if status == 200 then
        print(res)
    end
end)

-- An example of the HTTP Params helper
local params = HTTP:Params({ foo = 'bar', baz = 'bang'})

-- An example of a HTTP POST
HTTP:POST('https://example.com', params, function (status, res) 
    if status == 200 then
        print(res)
    end
end)
```

--------------------------------

### TTT Function Usage Example

Source: https://docs.tinkr.site/Routine/Conditions/ttt

Demonstrates how to use the ttt function in a conditional statement. The example checks if the time to target for 'pet' to reach 'target' is greater than 3 seconds, implying a need to wait for the pet to get closer.

```lua
if ttt('pet', 'target') > 3  then
    -- Let's take a second, let our pet get closer.
end
if ttt('pet', 'target') > 3  then
    -- Let's take a second, let our pet get closer.
end
```

--------------------------------

### Slider Component Examples

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Demonstrates the creation of slider components with different configurations. It includes a basic slider ranging from 0% to 100% and a more customized slider with specific min, max, step, and default values, and without percentage display. These sliders are part of a larger UI builder system.

```lua
local SliderGroup = Builder:Group {
    title = "Sliders",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:Slider {
                    key = 'slider_a',
                    label = "Example Slider A",
                    description = "This slider ranges from 0% (0) to 100% (1).",
                },
                Builder:Slider {
                    key = 'slider_b',
                    label = "Example Slider B",
                    description = "This slider ranges from 25 to 75.",
                    min = 25,
                    max = 75,
                    step = 1,
                    default = 50,
                    percent = false
                }
            }
        }
    }
}
```

--------------------------------

### Lua: Multi-Line Edit Box Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Demonstrates the implementation of multi-line text input fields using Tinkr's GUI builder. These are suitable for longer text entries such as comments or descriptions. The example shows how to configure the number of lines, placeholder text, and include an optional button.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local MultiLineEditBoxGroup = Builder:Group {
    title = "Multi-Line EditBoxes",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:EditBox {
                    key = "multi_editbox_a",
                    label = "Edit Box A",
                    multiline = true,
                    lines = 6,
                    placeholder = "Placeholder value",
                    description = "This is a multi-line edit box.",
                    button = true,
                },
                Builder:EditBox {
                    key = "multi_editbox_b",
                    label = "Edit Box B",
                    multiline = true,
                    lines = 6,
                    placeholder = "Placeholder value",
                    description = "This is a multi-line edit box."
                }
            }
        }
    }
}
```

--------------------------------

### Create Simple Checkboxes

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Implements basic checkboxes with labels and optional descriptions. These are used for binary state selections (e.g., enabling/disabling features).

```lua
local SimpleCheckboxes = Builder:Group {
    title = "Simple Checkboxes",
    content = {
        Builder:Text "Checkboxes allow you to have 2 states (yes and no) which can be used for enabling or disabling functionality.",
        Builder:Spacer { },
        Builder:Checkbox {
            key = "checkbox_a",
            label = "Checkbox A",
            description = "Description for Checkbox A."
        },
        Builder:Checkbox {
            key = "checkbox_b",
            label = "Checkbox B",
            description = "Description for Checkbox B."
        },
        Builder:Checkbox {
            key = "checkbox_c",
            label = "Checkbox C"
        }
    }
}
```

--------------------------------

### Deprecated HTTP Helper Methods (GET, POST)

Source: https://docs.tinkr.site/Modules/Util/HTTP

These methods are older convenience functions for making GET and POST requests. They are deprecated and should not be used in new code.

```APIDOC
## Deprecated HTTP Helper Methods

### Description
These are older, deprecated helper methods for making basic HTTP GET and POST requests. It is recommended to use the more flexible `HTTP:Request` method instead.

### Method
`HTTP:GET(url, callback)`

### Parameters
- **url** (string) - The URL to fetch.
- **callback** (function) - A function to handle the response (`status`, `res`).

### Request Example (GET)
```lua
HTTP:GET('https://example.com', function (status, res)
    if status == 200 then
        print(res)
    end
end)
```

### Method
`HTTP:POST(url, params, callback)`

### Parameters
- **url** (string) - The URL to send the POST request to.
- **params** (table) - A table of parameters to send as form data. Use `HTTP:Params` to format.
- **callback** (function) - A function to handle the response (`status`, `res`).

### Request Example (POST)
```lua
local params = HTTP:Params({ foo = 'bar', baz = 'bang'})
HTTP:POST('https://example.com', params, function (status, res)
    if status == 200 then
        print(res)
    end
end)
```

### Helper
`HTTP:Params(params_table)`

### Description
Helper function to format a table of parameters for use with `HTTP:POST`.

### Request Example
```lua
local params = HTTP:Params({ foo = 'bar', baz = 'bang'})
```
```

--------------------------------

### Aura Function Example (Lua)

Source: https://docs.tinkr.site/Routine/Conditions/aura

This example demonstrates how to use the 'aura' function in Lua to check if a 'BlazingBarrier' buff is active ('HELPFUL') on the 'player'. If the aura is present, it attempts to cast the 'BlazingBarrier' spell. The example is repeated, highlighting potential redundancy in usage.

```lua
if aura('player', BlazingBarrier, 'HELPFUL') then
  return cast(BlazingBarrier, 'player') 
end
if aura('player', BlazingBarrier, 'HELPFUL') then
  return cast(BlazingBarrier, 'player') 
end
```

--------------------------------

### Lua: Single-Line Edit Box Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Showcases the creation of single-line text input fields (edit boxes) using Tinkr's GUI builder. This example includes edit boxes with labels, descriptions, placeholder text, and an optional button. These are suitable for short text inputs like names or search queries.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local SingleLineEditBoxGroup = Builder:Group {
    title = "Single Line EditBoxes",
    content = {
        Builder:EditBox {
            key = "editbox_a",
            label = "Edit Box A",
            description = "This editbox has a description with it."
        },
        Builder:EditBox {
            key = "editbox_b",
            label = "Edit Box B",
            placeholder = "This editbox has a placeholder value"
        },
        Builder:EditBox {
            key = "editbox_c",
            label = "Edit Box C",
            placeholder = "Placeholder Value",
            description = "This input requires you to click " .. OKAY,
            button = true
        }
    }
}
```

--------------------------------

### Lua: Radio Button Group Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Demonstrates the implementation of radio button groups using Tinkr's GUI builder. Radio buttons allow users to select one option from a predefined set. This example shows both inline and stacked radio button layouts with custom option labels.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local RadioCheckboxes = Builder:Group {
    title = "Radio Checkboxes",
    content = {
        Builder:Text "Radios allow you to select between a set of options, much like a dropdown but presented in a different way.",
        Builder:Spacer { },
        Builder:Radio {
            key = "radio_a",
            values = {
                option_a = "Option A",
                option_b = "Option B",
                option_c = "Option C",
                option_d = "Option D"
            }
        },
        Builder:Spacer { },
        Builder:Text "You can also force radios to be stacked instead of displayed inline.",
        Builder:Spacer { height = 14 },
        Builder:Radio {
            key = "radio_b",
            stacked = true,
            values = {
                option_a = "Option A",
                option_b = "Option B",
                option_c = "Option C",
                option_d = "Option D"
            }
        }
    }
}
```

--------------------------------

### Lua: Tri-State Checkbox Implementation with Tinkr

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Illustrates the use of tri-state checkboxes in Tinkr's GUI builder. These checkboxes support three states: 'yes', 'no', and 'half', which are useful for indicating partial states. The example shows how to set the default state for each tri-state checkbox.

```lua
local Tinkr = ...

local Builder = Tinkr.Util.GUIBuilder:New {
    config = "example_builder"
}

local TriStateCheckboxes = Builder:Group {
    title = "Tri State Checkboxes",
    content = {
        Builder:Text "Tri State checkboxes allow you to have 3 states (yes, no and half) which can be useful for showing that something is partially enabled.",
        Builder:Spacer { },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_a",
            label = "Tri State A",
            default = "yes"
        },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_b",
            label = "Tri State B",
            default = "half"
        },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_c",
            label = "Tri State C",
            default = "no"
        }
    }
}
```

--------------------------------

### Interrupt Channeling Spell Example (Lua)

Source: https://docs.tinkr.site/Routine/Conditions/channeling

Example demonstrating how to cast 'Rebuke' on a target if the target is channeling. This snippet checks the channeling status and conditionally casts a spell.

```Lua
if channeling('target') then 
  return cast(Rebuke, 'target')
end
```

--------------------------------

### Create Multi-Line Edit Boxes

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Defines a group of multi-line edit boxes with customizable labels, placeholders, and line counts. These are used for capturing larger text inputs from users.

```lua
local MultiLineEditBoxGroup = Builder:Group {
    title = "Multi-Line EditBoxes",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:EditBox {
                    key = "multi_editbox_a",
                    label = "Edit Box A",
                    multiline = true,
                    lines = 6,
                    placeholder = "Placeholder value",
                    description = "This is a multi-line edit box.",
                    button = true,
                },
                Builder:EditBox {
                    key = "multi_editbox_b",
                    label = "Edit Box B",
                    multiline = true,
                    lines = 6,
                    placeholder = "Placeholder value",
                    description = "This is a multi-line edit box.",
                }
            }
        }
    }
}
```

--------------------------------

### Configure Radio Button Groups

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Sets up radio button groups for selecting one option from a predefined set. Supports both inline and stacked layouts, with options defined by key-value pairs.

```lua
local RadioCheckboxes = Builder:Group {
    title = "Radio Checkboxes",
    content = {
        Builder:Text "Radios allow you to select between a set of options, much like a dropdown but presented in a different way.",
        Builder:Spacer { },
        Builder:Radio {
            key = "radio_a",
            values = {
                option_a = "Option A",
                option_b = "Option B",
                option_c = "Option C",
                option_d = "Option D"
            }
        },
        Builder:Spacer { },
        Builder:Text "You can also force radios to be stacked instead of displayed inline.",
        Builder:Spacer { height = 14 },
        Builder:Radio {
            key = "radio_b",
            stacked = true,
            values = {
                option_a = "Option A",
                option_b = "Option B",
                option_c = "Option C",
                option_d = "Option D"
            }
        }
    }
}
```

--------------------------------

### Specific Channeling Spell Check Example (Lua)

Source: https://docs.tinkr.site/Routine/Conditions/channeling

Example showing how to check if a target is specifically channeling the 'Hearth' spell. This allows for targeted interruptions based on the spell name.

```Lua
if channeling('target') == "Hearth" then 
  return cast(Rebuke, 'target')
end
```

--------------------------------

### ScreenToWorld Function Signature and Example Usage

Source: https://docs.tinkr.site/Lua/Utility/ScreenToWorld

This snippet shows the function signature for ScreenToWorld, which takes screen coordinates (x, y) and hit flags to return world coordinates (x, y, z). It also includes an example demonstrating how to call the function with sample values and bitwise OR operations for hit flags.

```lua
ScreenToWorld(x, y, hitFlags) : x, y, z
ScreenToWorld(x, y, hitFlags) : x, y, z
```

```lua
local sx, sy = 0, 0
local hitFlags = bit.bor(0x1, 0x10, 0x100, 0x100000)
local x, y, z = ScreenToWorld(sx, sy, hitFlags)
local sx, sy = 0, 0
local hitFlags = bit.bor(0x1, 0x10, 0x100, 0x100000)
local x, y, z = ScreenToWorld(sx, sy, hitFlags)
```

--------------------------------

### Create Single Line Edit Boxes

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Defines single-line input fields with labels, descriptions, and placeholder text. An optional button can be appended to the edit box.

```lua
local SingleLineEditBoxGroup = Builder:Group {
    title = "Single Line EditBoxes",
    content = {
        Builder:EditBox {
            key = "editbox_a",
            label = "Edit Box A",
            description = "This editbox has a description with it."
        },
        Builder:EditBox {
            key = "editbox_b",
            label = "Edit Box B",
            placeholder = "This editbox has a placeholder value"
        },
        Builder:EditBox {
            key = "editbox_c",
            label = "Edit Box C",
            placeholder = "Placeholder Value",
            description = "This input requires you to click " .. OKAY,
            button = true
        }
    }
}
```

--------------------------------

### Implement Tri-State Checkboxes

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Creates checkboxes with three states: 'yes', 'no', and 'half'. Useful for representing partial states, such as a setting that is partially enabled.

```lua
local TriStateCheckboxes = Builder:Group {
    title = "Tri State Checkboxes",
    content = {
        Builder:Text "Tri State checkboxes allow you to have 3 states (yes, no and half) which can be useful for showing that something is partially enabled.",
        Builder:Spacer { },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_a",
            label = "Tri State A",
            default = "yes"
        },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_b",
            label = "Tri State B",
            default = "half"
        },
        Builder:Checkbox {
            tristate = true,
            key = "tribox_c",
            label = "Tri State C",
            default = "no"
        }
    }
}
```

--------------------------------

### Use Healthstone

Source: https://docs.tinkr.site/Routine/Conditions/clickitem

Provides an example of using a Healthstone on the player, demonstrating item usage.

```APIDOC
## POST /websites/tinkr_site/use_healthstone

### Description
Checks if the player has a Healthstone and, if so, uses it on the player. This is an example snippet.

### Method
POST

### Endpoint
/websites/tinkr_site/use_healthstone

### Parameters
None directly for this endpoint, logic is within the example.

### Request Body
None

### Response
#### Success Response (200)
- **used** (boolean) - Indicates if the Healthstone was used.

#### Response Example
```json
{
  "used": true
}
```
```

--------------------------------

### TraceLine Example: Check Line of Sight

Source: https://docs.tinkr.site/Lua/Utility/TraceLine

An example demonstrating how to use the TraceLine function to check the line of sight between two objects. It retrieves object positions, sets hit flags using bitwise OR operations, and then calls TraceLine.

```lua
local x1, y1, z1 = ObjectPosition('player')
local x2, y2, z2 = ObjectPosition('target')
local hitFlags = bit.bor(0x1, 0x10, 0x100, 0x100000)
local x, y, z = TraceLine(x1, y1, z1, x2, y2, z2, hitFlags)
```

--------------------------------

### Example of Using Click Item with Item Check (Tinkr Script - Placeholder)

Source: https://docs.tinkr.site/Routine/Conditions/clickitem

A placeholder example demonstrating how the clickitem function might be used in conjunction with checking for item availability. This pseudocode indicates a conditional use of the 'use' function based on item presence, intended to be replaced with actual code.

```Tinkr Script
-- if items(HealthStone) >= 0 then
--   return use(Healthstone, 'player')
-- end
-- if items(HealthStone) >= 0 then
--   return use(Healthstone, 'player')
-- end
```

--------------------------------

### Embed HTML Content

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Includes raw HTML content within the UI, allowing for rich text formatting, images, and links. This is useful for displaying static information or styled text.

```html
local HTMLTypographyGroup = Builder:SimpleGroup {
    Builder:HTML [[
        <br/>
        <img src="Interface\Glues\PROMOTIONS\enUS-SBC-Logo" align="center" width="256" height="128" />
        <br/>
        <h1>This is an H1 element</h1>
        <p>This is a paragraph element.  It contains text.</p>
        <br/>
        <h2>This is an H2 element</h2>
        <p>This is yes another paragraph element.  It contains even more text.</p>
        <br/>
        <h3>Here is an H3 element</h3>
        <p>This is <a href="https://tinkr.site/">a link</a>, clicking it will open the URL in your browser.</p>
        <br/>
    ]]
}
```

--------------------------------

### aroundunit Function Documentation

Source: https://docs.tinkr.site/Routine/Conditions/aroundunit

Provides details on the aroundunit function, its parameters, return values, and usage examples.

```APIDOC
## aroundunit Function

### Description
Returns the amount of party members around the unit, and their total health pool percentage for a given range.

### Method
Function call

### Parameters
#### Path Parameters
- **unita** (unit) - Required - The unit to measure proximity from.
- **range** (number) - Required - The range within which to count party members.

#### Query Parameters
None

#### Request Body
None

### Request Example
```lua
local count, pool = aroundunit('player', 30)

if count > 3 and pool < 60 then
  return cast(Effloresence, 'player'):click(playerx, playery, playerz)
end
```

### Response
#### Success Response (200)
- **count** (number) - The number of party members found within the specified range.
- **pool** (number) - The total health pool percentage of the found party members.

#### Response Example
```json
{
  "count": 5,
  "pool": 55.2
}
```
```

--------------------------------

### Example Usage of GeneratePath

Source: https://docs.tinkr.site/Lua/Movement/GeneratePath

Demonstrates how to call the GeneratePath function to find a path between the player and a target. It includes retrieving positions, map ID, calling the function, and iterating through the path points if a normal path is found.

```lua
local x1, y1, z1 = ObjectPosition('player')
local x2, y2, z2 = ObjectPosition('target')
local mapId = GetMapID()
local path, pathType = GeneratePath(x1, y1, z1, x2, y2, z2, mapId)
if pathType == PathTypes.PATHFIND_NORMAL then
    for index, point in ipairs(path) do
        -- do something with each point
        -- point.x, point.y, point.z
    end
end
local x1, y1, z1 = ObjectPosition('player')
local x2, y2, z2 = ObjectPosition('target')
local mapId = GetMapID()
local path, pathType = GeneratePath(x1, y1, z1, x2, y2, z2, mapId)
if pathType == PathTypes.PATHFIND_NORMAL then
    for index, point in ipairs(path) do
        -- do something with each point
        -- point.x, point.y, point.z
    end
end
```

--------------------------------

### Check Player Channeling Status (Lua)

Source: https://docs.tinkr.site/Routine/Conditions/channeling

Example for checking if the player unit is channeling. If the player is channeling, the function returns, potentially preventing further actions.

```Lua
if channeling('player') then 
  return 
end
```

--------------------------------

### Example: Get Player Name using ObjectType

Source: https://docs.tinkr.site/Lua/Objects/ObjectType

Demonstrates how to get the type of the 'player' object using the ObjectType function. The result can then be used to identify the player's type within the game.

```lua
local name = ObjectType('player')
```

--------------------------------

### Config Module Usage Example

Source: https://docs.tinkr.site/Modules/Util/Config

Demonstrates how to use the Util.Config module in Lua. It shows creating a new configuration, writing key-value pairs, and reading values, including handling default values when a key is not found. Assumes the Tinkr.Util.Config module is accessible.

```lua
local Tinkr = ...
local Config = Tinkr.Util.Config
 
local my_config = Config:New('my_config')
 
my_config:Write('foo', 'something')
my_config:Write('bar', 'awesome')
 
local foo = my_config:Read('foo', 'default value')
local baz = my_config:Read('baz', 'default value')
 
print(foo) -- something
print(baz) -- default value
```

--------------------------------

### Example Usage of Party Density Centroid (Lua)

Source: https://docs.tinkr.site/Routine/Conditions/partydensitycentroid

Demonstrates how to use party density calculations to determine if a spell should be cast. It checks party member count and health before calculating the density centroid and casting an ability.

```lua
local partyhealtharoundlowest = parthyhealth(lowest, 30)
local partycountlowest = partyaround(lowest, 30)

if partycountlowest > 3 and partyhealtharoundlowest <= 60 then
    local densityCentroid = partydensity(LowestHealth, 30)
    return cast(Effloresence, lowest):click(densityCentroid.x, densityCentroid.y,densityCentroid.z)
end
local partyhealtharoundlowest = parthyhealth(lowest, 30)
local partycountlowest = partyaround(lowest, 30)

if partycountlowest > 3 and partyhealtharoundlowest <= 60 then
    local densityCentroid = partydensity(LowestHealth, 30)
    return cast(Effloresence, lowest):click(densityCentroid.x, densityCentroid.y,densityCentroid.z)
end
```

--------------------------------

### Multi-Select Dropdown Configuration

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Defines a dropdown component that allows users to select multiple options from a predefined list. It includes configuration for the dropdown's description and the available values. No external dependencies are explicitly mentioned.

```lua
local DropdownGroup = Builder:Group {
    title = "Dropdowns",
    content = {
        Builder:Rows {
            Builder:Columns {
                Builder:Dropdown {
                    key = 'dropdown_a',
                    label = "Example Dropdown A",
                    description = "This dropdown allows selecting multiple values.",
                    values = {
                        option_a = "Option A",
                        option_b = "Option B",
                        option_c = "Option C",
                        option_d = "Option D",
                        option_e = "Option E",
                    }
                }
            }
        }
    }
}
```

--------------------------------

### GeneratePathWeighted Function Signature and Example

Source: https://docs.tinkr.site/Lua/Movement/GeneratePathWeighted

Defines the signature for GeneratePathWeighted, which takes start and end coordinates, a map ID, and a callback function for custom edge weighting. The example demonstrates its usage in Lua to find a path with dynamically calculated weights.

```lua
GeneratePathWeighted(x1, y1, z1, x2, y2, z2, mapId, callback) : {{ x, y, z }}...

local px, py, pz = ObjectPosition('player')
local tx, ty, tz = ObjectPosition('target')
local mapID = GetMapID()

local weighted = function(ax, ay, az, bx, by, bz)
    local extraWeight = 0.0 -- float
    -- poly edge A is ax, ay, az
    -- poly edge B is bx, by, bz
    -- callback is for movement between poly edge A and B

    -- higher weights are avoided
    return extraWeight
end

local path = GeneratePathWeighted(px, py, pz, tx, ty, tz, mapID, weighted)
```

--------------------------------

### Build and Manage Configuration GUI

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/integration

Implements a '/config' command to show or hide a custom GUI configuration window built using `Builder:Build`. It manages the window's state, creating it if it doesn't exist or releasing (closing) it if it's already shown. This relies on `MyCommands`, `Builder`, and a `MyRoutineConfig` table.

```lua
-- This will be used to keep a reference to the opened GUI
local MyRoutineWindow

-- Next, add a command to show the config GUI
MyCommands:Register("config", function()
    -- We don't have a window, lets build one
    if not MyRoutineWindow then
        MyRoutineWindow = Builder:Build(MyRoutineConfig)
    -- We have a window, lets release it, this also closes it
    elseif MyRoutineWindow:IsShown() then
        MyRoutineWindow:Release()
        MyRoutineWindow = false
    end
end, "Shows the config options window")
```

--------------------------------

### UI Typography Formatting Options

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Demonstrates various text formatting and layout options within a tabbed interface. It includes blocks of text, spacers, images, and nested padding, showcasing how to structure and style textual content and images using the Builder components.

```lua
local TypographyTabGroup = Builder:TabGroup {
    key = "typography_tabs",
    tabs = {
        Builder:Tab {
            title = "Formatting",
            content = {
                Builder:Padding {
                    padding = 5,
                    content = {
                        Builder:Rows {
                            Builder:Text [[ 
                                This is a simple block of text, you can write words here. Lorem ipsum dolor sit amet,
                                consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
                                aliqua.
                            ]],
                            Builder:Spacer {}, 
                            Builder:Text "Ut enim ad minim veniam, quis nostrud ... in voluptate velit esse cillum dolore eu fugiat nulla pariatur.",
                            Builder:Spacer {}, 
                            Builder:Columns {
                                Builder:Image {
                                    image = "Interface\Glues\PROMOTIONS\enUS-SBC-Logo",
                                    width = 256,
                                    height = 128,
                                    fit = true
                                },
                                Builder:Padding {
                                    padding = 5,
                                    content = {
                                        Builder:Text "Ut enim ad minim veniam, quis nostrud exercitation ullamco ... in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur."
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```

--------------------------------

### Example: Iterate Through Objects and Get Types

Source: https://docs.tinkr.site/Lua/Objects/ObjectType

Shows how to iterate through all available objects in the game using the Objects() function and then determine the type of each object using ObjectType. This is useful for processing multiple game objects.

```lua
for i, object in ipairs(Objects()) do
    local name = ObjectType(object)
    -- do something with name
end
```

--------------------------------

### Example: Iterate Through Objects and Get Names

Source: https://docs.tinkr.site/Lua/Objects/ObjectName

Shows how to loop through all available objects in the game using the Objects() function and retrieve the name of each object using ObjectName. This pattern is useful for performing actions on all objects or for debugging.

```Lua
for i, object in ipairs(Objects()) do
    local name = ObjectName(object)
    -- do something with name
end
```

```Lua
for i, object in ipairs(Objects()) do
    local name = ObjectName(object)
    -- do something with name
end
```

--------------------------------

### Build GUI Window with Tree Structure

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Constructs a main GUI window titled 'GUI Builder Kitchen Sink'. The window's content is organized using a tree structure with branches for 'Input' and 'Typography', each containing tab groups.

```lua
local Window = Builder:Window {
    key = "example_window",
    title = "GUI Builder Kitchen Sink",
    width = 800,
    height = 480,
    content = {
        TreeGroup
    }
}

Builder:Build(Window)
```

--------------------------------

### Example: Get Player Name using ObjectName

Source: https://docs.tinkr.site/Lua/Objects/ObjectName

Demonstrates how to retrieve the name of the player object. This is a common use case for the ObjectName function. It takes the string 'player' as an argument to identify the player's game object.

```Lua
local name = ObjectName('player')
```

```Lua
local name = ObjectName('player')
```

--------------------------------

### Retrieve Object GUID (Lua)

Source: https://docs.tinkr.site/Lua/Objects/ObjectGUID

This function returns the GUID of a WowGameObject. It takes an object reference as input, which can be a unit or another game object. The function returns a string representing the GUID or false if the object reference is invalid.

```lua
ObjectGUID(--[[(1)]]objectReference) : string | false
```

```lua
local guid = ObjectGUID('target')
local guid = ObjectGUID('target')
```

```lua
local pguid = ObjectGUID('player')
return pguid == guid
local pguid = ObjectGUID('player')
return pguid == guid
```

--------------------------------

### Create Text Elements with Formatting

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Defines and configures various text elements within a UI layout. Allows for rich text content, font styling, size adjustments, and color application. Dependencies include the Builder module for UI components.

```lua
local TypographyTabGroup = Builder:TabGroup {
    key = "typography_tabs",
    tabs = {
        Builder:Tab {
            title = "Formatting",
            content = {
                Builder:Padding {
                    padding = 5,
                    content = {
                        Builder:Rows {
                            Builder:Text [[ 
                                This is a simple block of text, you can write words here. Lorem ipsum dolor sit amet,
                                consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna
                                aliqua.
                            ]],
                            Builder:Spacer {},
                            Builder:Text "Ut enim ad minim veniam, quis nostrud ... in voluptate velit esse cillum dolore eu fugiat nulla pariatur.",
                            Builder:Spacer {},
                            Builder:Columns {
                                Builder:Image {
                                    image = "Interface\\Glues\\PROMOTIONS\\enUS-SBC-Logo",
                                    width = 256,
                                    height = 128,
                                    fit = true
                                },
                                Builder:Padding {
                                    padding = 5,
                                    content = {
                                        Builder:Text "Ut enim ad minim veniam, quis nostrud exercitation ullamco ... in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur."
                                    }
                                }
                            },
                            Builder:Columns {
                                Builder:Text {
                                    text = "You can change the font and size of the text using options. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua",
                                    size = 14,
                                    font = "Fonts\\MORPHEUS.TTF"
                                },
                                Builder:Text {
                                    text = "Color can be applied by passing a hex value.  This is optional and text will be white by default.",
                                    size = 14,
                                    font = "Fonts\\FRIZQT__.TTF",
                                    color = "3489eb",
                                }
                            },
                        },
                    }
                }
            }
        },
        Builder:Tab {
            title = "HTML",
            content = {
                HTMLTypographyGroup
            }
        }
    }
}
```

--------------------------------

### Perform Deprecated HTTP GET and POST Requests

Source: https://docs.tinkr.site/Lua/Network/HTTP

These methods (`HTTP:GET`, `HTTP:POST`) are deprecated and should not be used in new code. They provide simpler interfaces for basic GET and POST requests. The `HTTP:Params` helper can be used to format parameters for POST requests.

```lua
-- An example of a HTTP GET
HTTP:GET('https://example.com', function (status, res) 
    if status == 200 then
        print(res)
    end
end)
 
-- An example of the HTTP Params helper
local params = HTTP:Params({ foo = 'bar', baz = 'bang'})
 
-- An example of a HTTP POST
HTTP:POST('https://example.com', params, function (status, res) 
    if status == 200 then
        print(res)
    end
end)
```

--------------------------------

### Build Main Window with Tree and Tab Structures

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/examples

Constructs the main application window, incorporating a tree group and tab group for navigation and content display. The window has defined dimensions and a title. It relies on the Builder module for UI element creation.

```lua
local TreeGroup = Builder:TreeGroup {
    key = "example_tree",
    branches = {
        Builder:TreeBranch {
            title = "Input",
            icon = 134063,
            content = {
                TabGroup
            }
        },
        Builder:TreeBranch {
            title = "Typography",
            icon = 134332,
            content = {
                TypographyTabGroup
            }
        }
    }
}

local Window = Builder:Window {
    key = "example_window",
    title = "GUI Builder Kitchen Sink",
    width = 800,
    height = 480,
    content = {
        TreeGroup
    }
}

Builder:Build(Window)
```

--------------------------------

### Lua: Registering Routine Options and GUI Events

Source: https://docs.tinkr.site/Modules/Util/GUI%20Builder/integration

This snippet demonstrates registering custom routine logic, including a 'checked' function for option validation, and setting up a GUI builder to listen for and apply configuration changes to a local 'my_options' table. It covers the core setup for a Tinkr routine's options and their interaction with the GUI.

```lua
local Tinkr = ...
local Routine = Tinkr.Routine
local Commands = Tinkr.Util.Commands
local GUIBuilder = Tinkr.Util.GUIBuilder
 
-- Create your /myroutine slash command.
local MyCommands = Commands:New("myroutine")
 
-- A simple table to store your config options -- 
-- You can now keep your default values here, just remember to
-- use the GUI builder values, like "yes" and "no" instead of
-- true or false.
local my_options = {
    aoe = "yes"
}
 
-- Add a custom routine method to aid in the checking of "yes"/"no" values.
Routine:RegisterLibrary({
    checked = function(option)
        if my_options[option] == "yes" then return true end
        return false
    end
}) 
 
-- Register your routine with Tinkr
Routine:RegisterRoutine(function()
    -- here we check the new checked('aoe') before casting an AoE spell -- 
    if checked('aoe') and castable(Consecration) then 
        return cast(Consecration)
    end
end, Routine.Classes.Paladin, "my_routine")
 
-- Create a new GUI Builder instance for your routine
local Builder = GUIBuilder:New {
    config = "my_routine"
}
 
-- Listen to all GUI option changes, call our Apply function each time -- 
-- This acts as a proxy, sending all changes in the GUI, to our local
-- my_options table.  There are many ways to do this, this is just the
-- most simple.  You may find you need more control, in which case you
-- can listen to specific key values and handle them differently.
Builder:Listen('*', function(key, value)
    my_options[key] = value
end)
 
-- Create a new Window with a single Checkbox element inside it
local MyRoutineConfig = Builder:Window {
    key = "my_window",
    title = "My Routine Config",
    width = 350,
    height = 100,
    content = {
        Builder:Checkbox {
            key = "aoe",
            label = "Use AoE Spells",
            description = "Toggles the use of AoE spells",
            default = "yes"
        }
    }
}
 
-- This will be used to keep a reference to the opened GUI
local MyRoutineWindow
 
-- Next, add a command to show the config GUI
MyCommands:Register("config", function()
    -- We don't have a window, lets build one
    if not MyRoutineWindow then
        MyRoutineWindow = Builder:Build(MyRoutineConfig)
    -- We have a window, lets release it, this also closes it
    elseif MyRoutineWindow:IsShown() then
        MyRoutineWindow:Release()
        MyRoutineWindow = false
    end
end, "Shows the config options window")
 
-- We've moved this down to be after the GUI code. -- 
-- Register a command for toggling AoE on or off
MyCommands:Register("aoe", function()
    -- flips or "toggles" the value
    my_options.aoe =  my_options.aoe == 'yes' and 'no' or 'yes'
 
    if my_options.aoe == 'yes' then
        Tinkr:log("AoE Enabled")
        Builder:Emit('aoe', 'yes') -- send the new value to the GUI
    else
        Tinkr:log("AoE Disabled")
        Builder:Emit('aoe', 'no') -- send the new value to the GUI
    end
end, "Toggles AoE on or off") 
```

--------------------------------

### Get ObjectPosition (Lua)

Source: https://docs.tinkr.site/Lua/Objects/ObjectPosition

Retrieves the x, y, and z coordinates of a specified WowGameObject. Accepts an 'objectReference' as input. Useful for getting the position of specific entities like the player.

```lua
local x, y, z = ObjectPosition('player')
local x, y, z = ObjectPosition('player')
```

--------------------------------

### Example Usage of spellInRange

Source: https://docs.tinkr.site/Routine/Conditions/spellInRange

Demonstrates how to use the spellInRange function within a conditional statement to cast a spell if it's within range and off cooldown. The example uses FrostNova and checks against 'arena1'.

```lua
if spellInRange(FrostNova, 'arena1') and cooldown(FrostNova) == 0 then
  return cast(FrostNova)
end
if spellInRange(FrostNova, 'arena1') and cooldown(FrostNova) == 0 then
  return cast(FrostNova)
end
```
Tokens:
Raw