Nixware CS2 API

https://docs.nixware.cc
Admin
Nixware CS2 API provides documentation and tools for developing Lua scripts for Counter-Strike 2,...
Tokens:12,314
Snippets:123
Trust Score:6.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Get Game Directory (Lua API)

Source: https://docs.nixware.cc/environment

Retrieves the full path to the game's installation directory as a string.

```APIDOC
get_game_directory(): string
Returns: string
```

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

### Lua: Load and Render Texture Example

Source: https://docs.nixware.cc/render

Demonstrates how to load a texture using `render.setup_texture` and then draw it on the screen at a specified position and size within a `paint` callback function.

```Lua
local texture = render.setup_texture("nix/scripts/resources/example.png")
register_callback("paint", function()
    render.texture(texture, vec2_t(100, 100), vec2_t(200, 200))
end)
```

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

### Lua: Load and Render Text Example

Source: https://docs.nixware.cc/render

Demonstrates how to load a font using `render.setup_font` and then draw text on the screen at a specified position with a given color within a `paint` callback function.

```Lua
local font = render.setup_font("C:/Windows/Fonts/verdana.ttf", 32, 0)
register_callback("paint", function()
    render.text("hello from lua api!", font, vec2_t(100, 100), color_t(1, 1, 1, 1))
end)
```

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

### Nixware CS2 API: override_view Callback

Source: https://docs.nixware.cc/events

Documents the `override_view` callback, triggered when the view setup needs to be modified. It provides a `view_setup_t` object for view configuration.

```APIDOC
override_view(view_setup: view_setup_t)
  view_setup: view_setup_t - View setup
```

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

### Nixware CS2 API: ray_t Constructors

Source: https://docs.nixware.cc/types/ray_t

Documents the various ways to construct a `ray_t` object in the Nixware CS2 API. This includes default initialization, initialization with a start offset, with an offset and radius, with min/max bounds, and with two center points and a radius.

```APIDOC
ray_t()
```

```APIDOC
ray_t(start_offset: vec3_t)
  start_offset: vec3_t
```

```APIDOC
ray_t(start_offset: vec3_t, radius: number)
  start_offset: vec3_t
  radius: number
```

```APIDOC
ray_t(mins: vec3_t, maxs: vec3_t)
  mins: vec3_t
  maxs: vec3_t
```

```APIDOC
ray_t(center_a: vec3_t, center_b: vec3_t, radius: number)
  center_a: vec3_t
  center_b: vec3_t
  radius: number
```

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

### Nixware CS2 API: console_input Callback and Example

Source: https://docs.nixware.cc/events

Documents the `console_input` callback, triggered when a user presses enter in the console. It provides the entered command string. Returning `false` from the callback prevents the in-game command execution. An example demonstrates how to use this callback in Lua to print the command and prevent 'quit' execution.

```APIDOC
console_input(cmd: string)
  cmd: string - Console command
```

```Lua
register_callback('console_input', function(cmd)
    print("user typed:", cmd)
    if cmd == 'quit' then
        return false -- prevents quit
    end
end)
```

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

### Lua Example: Using engine.trace_shape for Camera Raycasting

Source: https://docs.nixware.cc/engine

Demonstrates how to use `engine.trace_shape` in Lua to perform a ray trace from the camera's origin in its forward direction. It updates camera angles and origin on `override_view` and draws a 3D circle at the trace hit position on `paint` for visualization.

```Lua
local g_camera_angles = angle_t(0, 0, 0)
local g_camera_origin = vec3_t(0, 0, 0)
register_callback('override_view', function(view)
  g_camera_angles = view.angles
  g_camera_origin = view.origin
end)
register_callback('paint', function()
  local forward, _, _ = math.angle_vectors(g_camera_angles)
  local filter = trace_filter_t(0x2800100001, 3, true)
  local trace = engine.trace_shape(ray_t(), g_camera_origin, g_camera_origin + (forward * 10000), filter)
  render.circle_3d(trace.end_pos, 5, color_t(1, 1, 1, 1), 1, trace.hit_normal)
end)
```

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

### Nixware CS2 API: string_cmd Callback and Example

Source: https://docs.nixware.cc/events

Documents the `string_cmd` callback, triggered for string commands. It provides the command string. The return value can modify or block the command execution. An example demonstrates how to use this callback in Lua to block team communication or modify a 'say' command.

```APIDOC
string_cmd(cmd: string)
  cmd: string - Command
```

```Lua
register_callback('string_cmd', function(cmd)
    if cmd:find('say_team') then
        return nil --block team communication
    elseif cmd:find('say') then
        return 'say YOUR_MESSAGE'
    end
end)
```

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

### Render API: arc

Source: https://docs.nixware.cc/render

Draws a 2D arc with specified position, radius, start and end angles, and segment count. An optional thickness can be provided.

```APIDOC
render.arc(pos: vec2_t, radius: number, a_min: number, a_max: number, segments: number, color: color_t, thickness?: number)
  pos: vec2_t - Position of the arc
  radius: number - Radius of the arc
  a_min: number - Start angle of the arc in radians
  a_max: number - End angle of the arc in radians
  segments: number - Count of the arc segments
  color: color_t - Color of the arc
  thickness: number - Optional. Thickness of the arc
```

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

### Get User Name (Lua API)

Source: https://docs.nixware.cc/environment

Retrieves the current user's name as a string.

```APIDOC
get_user_name(): string
Returns: string
```

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

### APIDOC: render.frame_count Method

Source: https://docs.nixware.cc/render

Retrieves the total number of frames rendered since the application started.

```APIDOC
render.frame_count(): number
```

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

### API Reference: engine.trace_shape

Source: https://docs.nixware.cc/engine

Documents the `engine.trace_shape` function, which performs a ray trace against the game world's shapes. It requires a ray, start and end positions, and a trace filter to define what to hit.

```APIDOC
engine.trace_shape(ray: ray_t, start: vec3_t, end: vec3_t, filter: trace_filter_t): trace_t

Parameters:
  ray: ray_t
  start: vec3_t
  end: vec3_t
  filter: trace_filter_t
```

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

### Get Entity FFI Pointer in Lua

Source: https://docs.nixware.cc/types/base_entity_t

Demonstrates how to retrieve the raw FFI pointer of an entity and access its properties using offsets, specifically showing how to get the local player's health using a netvar offset.

```Lua
local offset = engine.get_netvar_offset("client.dll", "C_BaseEntity", "m_iHealth")
local pawn = entitylist.get_local_player_pawn()
if pawn ~= nil then
    print("Localplayer HP: " .. ffi.cast("int*", pawn[offset])[0])
end
```

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

### Access Entity Netvars in Lua

Source: https://docs.nixware.cc/types/base_entity_t

Illustrates how to use netvars to access various properties of game entities, such as weapon data and player state (e.g., reloading status), and display them on screen using rendering functions. This example shows how to get weapon price and reloading status.

```Lua
local font = render.setup_font("C:/Windows/Fonts/verdana.ttf", 25)
register_callback("paint", function()
    local pawn = entitylist.get_local_player_pawn()
    if pawn == nil then return end

    local game_scene_node = pawn.m_pGameSceneNode
    if game_scene_node == nil then return end

    local weapon_services = pawn.m_pWeaponServices
    if weapon_services == nil then return end

    local weapon = weapon_services.m_hActiveWeapon
    if weapon == nil then return end

    local weapondata = weapon.m_pWeaponData
    if weapondata == nil then return end

    local origin2 = render.world_to_screen(game_scene_node.m_vecAbsOrigin)
    if origin2 ~= nil then
        render.text("weapon price: $" .. tostring(weapondata.m_nPrice), font, origin2, color_t(1, 1, 1, 1))
        if weapon.m_bInReload then
            render.text("reloading", font, origin2 + vec2_t(0, 20), color_t(1, 1, 1, 1))
        end
    end
end)
```

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

### Get Script Name (Lua API)

Source: https://docs.nixware.cc/environment

Retrieves the name of the currently executing Lua script as a string.

```APIDOC
get_script_name(): string
Returns: string
```

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

### net_channel_t:get_address - Get Network Address

Source: https://docs.nixware.cc/types/net_channel

Retrieves the network address associated with the `net_channel_t` instance. This method returns a string representing the address.

```APIDOC
net_channel:get_address(): string
```

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

### Lua: Visualize Player Head Hitbox Position

Source: https://docs.nixware.cc/engine

Registers callbacks to override the view and paint events. It iterates through player entities, gets their head hitbox position, converts it to screen coordinates, performs a trace to check visibility, and then draws a filled circle on the screen indicating visibility.

```Lua
local g_camera_origin = vec3_t(0, 0, 0)
register_callback('override_view', function(view)
    g_camera_origin = view.origin
end)
register_callback('paint', function()
    entitylist.get_entities("C_CSPlayerPawn", function(player)
        local head_pos = engine.get_hitbox_pos(player, 0)
        if head_pos == nil then return end

        local pos2d = render.world_to_screen(head_pos)
        if pos2d == nil then return end

        local trace = engine.trace_shape(ray_t(), g_camera_origin, head_pos, trace_filter_t(0x2800100001, 3, true))
        local visible = trace.fraction < 1 or trace.start_in_solid
        render.circle_filled(pos2d, 5, 0, visible and color_t(1, 0, 0, 0.5) or color_t(0, 1, 0, 0.5))
    end)
end)
```

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

### base_entity_t API Methods

Source: https://docs.nixware.cc/types/base_entity_t

Defines the core methods available for the `base_entity_t` object in the Nixware CS2 API, including conversion to string, retrieving absolute origin and rotation, getting class name, and obtaining the entity handle.

```APIDOC
entity:__tostring(): string
```

```APIDOC
entity:get_abs_origin(): vec3_t
```

```APIDOC
entity:get_abs_rotation(): angle_t
```

```APIDOC
entity:get_class_name(): string
```

```APIDOC
entity:get_entity_handle(): number
```

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

### net_channel_t:get_latency - Get Channel Latency

Source: https://docs.nixware.cc/types/net_channel

Retrieves the current latency (ping) of the `net_channel_t` instance. This method returns a number representing the latency.

```APIDOC
net_channel:get_latency(): number
```

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

### UI: Get Menu Rectangle Coordinates

Source: https://docs.nixware.cc/ui

Retrieves the bounding box coordinates of the user interface menu. The return value is a `vec4_t` object, typically representing (x, y, width, height) or (x1, y1, x2, y2).

```APIDOC
ui.get_menu_rect(): vec4_t
```

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

### Getting Convars in Nixware CS2 API (Lua)

Source: https://docs.nixware.cc/cvars

Demonstrates how to access a console variable (convar) by its name using `cvars.CONVAR_NAME` and retrieve its float value. The return type for a convar is `convar_t`.

```Lua
print("Current sensitivity:" .. cvars.sensitivity:get_float())
```

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

### Get Content of Chat Message (chat_message_t)

Source: https://docs.nixware.cc/types/chat_message_t

This method extracts the actual text content of the chat message. It returns a string containing the message body. This is the primary method for accessing the user-typed or system-generated message.

```APIDOC
msg:get_message(): string
```

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

### Get Entity Associated with Chat Message (chat_message_t)

Source: https://docs.nixware.cc/types/chat_message_t

This method retrieves the `base_entity_t` associated with the chat message. It allows developers to access the entity that sent or is related to the message. The returned value is a reference to a `base_entity_t` object.

```APIDOC
msg:get_entity(): base_entity_t
```

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

### Get Sender Name from Chat Message (chat_message_t)

Source: https://docs.nixware.cc/types/chat_message_t

This method retrieves the name of the sender or the primary name associated with the chat message. It returns a string representing this name. This is typically used to display who sent the message in a user interface.

```APIDOC
msg:get_name(): string
```

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

### Get Message Name from Chat Message (chat_message_t)

Source: https://docs.nixware.cc/types/chat_message_t

This method returns the specific name of the chat message as a string. This 'message name' might be an identifier or a specific label for the message type. It provides a way to categorize or identify messages programmatically.

```APIDOC
msg:get_message_name(): string
```

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

### Get Position Associated with Chat Message (chat_message_t)

Source: https://docs.nixware.cc/types/chat_message_t

This method retrieves a string representing the position related to the chat message. The exact format or meaning of this 'position' string would depend on the API's context, but it likely provides spatial or contextual information. It can be used for location-aware features or debugging.

```APIDOC
msg:get_position(): string
```

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

### APIDOC: render.setup_texture Method

Source: https://docs.nixware.cc/render

Loads a texture from a specified file path. Returns a `texture_t` object on success, or `nil` if the file does not exist.

```APIDOC
render.setup_texture(filename: string): texture_t

Parameters:
  filename (string): Path to the texture

Returns:
  texture_t: The loaded texture object. Returns nil if the texture does not exist.
```

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

### APIDOC: render.setup_font Method

Source: https://docs.nixware.cc/render

Loads a font from a specified file path with a given size and optional flags. Returns a `font_t` object on success, or `nil` if the font file does not exist.

```APIDOC
render.setup_font(filename: string, size: number, flags?: number): font_t

Parameters:
  filename (string): Path to the font
  size (number): Font size
  flags (number, optional): Font flags

Returns:
  font_t: The loaded font object. Returns nil if the font does not exist.
```

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

### APIDOC: render.setup_texture_rgba Method

Source: https://docs.nixware.cc/render

Creates a texture from a raw RGBA pixel buffer and specified dimensions. The buffer is an `uint32` array containing pixel data.

```APIDOC
render.setup_texture_rgba(buffer: number[], size: vec2_t): texture_t

Parameters:
  buffer (number[]): Texture buffer. It's an uint32 array which contains RGBA pixels.
  size (vec2_t): Texture size

Returns:
  texture_t: The created texture object.
```

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

### APIDOC: render.setup_texture_from_memory Method

Source: https://docs.nixware.cc/render

Creates a texture from a byte array containing image data. This method is useful for loading images directly from memory.

```APIDOC
render.setup_texture_from_memory(buffer: number[]): texture_t

Parameters:
  buffer (number[]): Texture buffer. It's a byte array which contains image bytes.

Returns:
  texture_t: The created texture object.
```

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

### view_setup_t Structure Definition

Source: https://docs.nixware.cc/types/view_setup_t

Defines the `view_setup_t` structure, which encapsulates camera and view-related properties for the Nixware CS2 API. It includes fields for field of view, viewmodel field of view, camera angles, and camera origin.

```APIDOC
view_setup_t:
  Properties:
    fov: number
    fov_viewmodel: number
    angles: angle_t
    origin: vec3_t
```

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

### Nixware CS2 API: entitylist Module Reference

Source: https://docs.nixware.cc/entitylist

Comprehensive API documentation for the `entitylist` module, detailing functions to access various game entities and their properties.

```APIDOC
entitylist module API:
  get_local_player_controller(): base_entity_t
    Description: Retrieves the local player's controller entity.
  get_local_player_pawn(): base_entity_t
    Description: Retrieves the local player's pawn entity.
  get_entity_from_handle(handle: number): base_entity_t
    Description: Retrieves an entity by its unique handle.
    Parameters:
      handle: number - Handle of the entity.
  get_game_rules(): C_CSGameRules
    Description: Retrieves the current game rules entity.
  get_entities(class_name?: string, include_interits?: boolean): base_entity_t[]
    Description: Retrieves a list of entities, optionally filtered by class name and inheritance.
    Parameters:
      class_name: string (Optional) - Name of the class.
      include_interits: boolean (Optional) - Includes derived classes from `class_name`.
  get_entities(class_name?: string, include_interits?: boolean, callback: function)
    Description: Retrieves a list of entities, optionally filtered by class name and inheritance, processing them with a callback.
    Parameters:
      class_name: string (Optional) - Name of the class.
      include_interits: boolean (Optional) - Includes derived classes from `class_name`.
      callback: function - Callback function, that receives `base_entity_t` as an argument.
```

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

### API: engine.get_product_version_string

Source: https://docs.nixware.cc/engine

Retrieves the product version string of the game.

```APIDOC
engine.get_product_version_string(): string
```

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

### API: render.text

Source: https://docs.nixware.cc/render

Renders a string of text on the screen at a specified position, using a given font, with optional color and size adjustments.

```APIDOC
render.text(text: string, font: font_t, pos: vec2_t, color?: color_t, size?: number)
  Description: Renders text on the screen.
  Parameters:
    text: string - Text to render
    font: font_t - Font object
    pos: vec2_t - Position of where text will be rendered
    color?: color_t - Optional. Text color
    size?: number - Optional. Text size
```

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

### API: engine.chat_print

Source: https://docs.nixware.cc/engine

Prints text to the in-game chat.

```APIDOC
engine.chat_print(text: string)
  text: string - Text to print
```

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

### API: render.circle

Source: https://docs.nixware.cc/render

Draws an outlined circle on the screen at a specified position and radius, with a given number of segments, color, and optional thickness.

```APIDOC
render.circle(pos: vec2_t, radius: number, segments: number, color: color_t, thickness?: number)
  Description: Draws an outlined circle.
  Parameters:
    pos: vec2_t - Position of the circle
    radius: number - Radius of the circle
    segments: number - Count of the circle segments
    color: color_t - Color of the circle
    thickness?: number - Optional. Thickness of the circle
```

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

### vec3_t Constructor

Source: https://docs.nixware.cc/types/vec3_t

Initializes a new `vec3_t` instance with specified x, y, and z coordinates.

```APIDOC
vec3_t(x: number, y: number, z: number)
  x: The x-coordinate of the vector.
  y: The y-coordinate of the vector.
  z: The z-coordinate of the vector.
```

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

### API: render.circle_filled

Source: https://docs.nixware.cc/render

Draws a solid, filled circle on the screen at a specified position and radius, with a given number of segments and color.

```APIDOC
render.circle_filled(pos: vec2_t, radius: number, segments: number, color: color_t)
  Description: Draws a filled circle.
  Parameters:
    pos: vec2_t - Position of the circle
    radius: number - Radius of the circle
    segments: number - Count of the circle segments
    color: color_t - Color of the circle
```

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

### API: engine.execute_client_cmd

Source: https://docs.nixware.cc/engine

Executes a client command within the game engine.

```APIDOC
engine.execute_client_cmd(command: string)
  command: string - Command to execute
```

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

### API: engine.play_sound

Source: https://docs.nixware.cc/engine

Plays a sound with a specified name and volume.

```APIDOC
engine.play_sound(sound_name: string, volume: number)
  sound_name: string - Sound name
  volume: number - Volume in the range [0.0, 1.0]
```

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

### Render API: poly_line

Source: https://docs.nixware.cc/render

Draws a 2D polyline connecting a series of screen positions. An optional thickness can be specified for the line.

```APIDOC
render.poly_line(points: vec2_t[], color: color_t, thickness?: number)
  points: vec2_t[] - Array of screen positions
  color: color_t - Color of the polyline
  thickness: number - Optional. Thickness of polyline
```

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

### Render API: circle_3d

Source: https://docs.nixware.cc/render

Draws a 3D circle at a specified position and radius. Optional parameters include thickness and a normal vector for rotation.

```APIDOC
render.circle_3d(pos: vec3_t, radius: number, color: color_t, thickness?: number, normal?: vec3_t)
  pos: vec3_t - Position of the circle
  radius: number - Radius of the circle
  color: color_t - Color of the circle
  thickness: number - Optional. Thickness of the circle
  normal: vec3_t - Optional. Rotation of the circle
```

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

### color_t Constructor

Source: https://docs.nixware.cc/types/color_t

Initializes a new instance of the `color_t` type with specified red, green, blue, and alpha values.

```APIDOC
color_t(r: number, g: number, b: number, a: number)
  r: number
  g: number
  b: number
  a: number
```

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

### API: engine.get_hitbox

Source: https://docs.nixware.cc/engine

Retrieves hitbox information for a given player pawn and hitbox index.

```APIDOC
engine.get_hitbox(pawn: base_entity_t, hitbox_index: number): hitbox_t
  pawn: base_entity_t - Player pawn
  hitbox_index: number - Hitbox index
```

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

### API: render.world_to_screen

Source: https://docs.nixware.cc/render

Converts a 3D world position to 2D screen coordinates. Returns `nil` if the world position is not currently on the screen.

```APIDOC
render.world_to_screen(pos: vec3_t)
  Description: Converts a 3D world position to 2D screen coordinates.
  Parameters:
    pos: vec3_t - World position
  Returns:
    vec2_t - Screen coordinates if on screen.
    nil - If world position is not on the screen.
```

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

### Convert World Position to Screen Coordinates and Draw Circle (Lua)

Source: https://docs.nixware.cc/render

This Lua snippet demonstrates how to use `render.world_to_screen` to convert a 3D world position (0,0,0) into 2D screen coordinates. If the position is visible on screen, it then draws a faded circle at that location using `render.circle_fade`.

```Lua
register_callback("paint", function()
    local w2s = render.world_to_screen(vec3_t(0, 0, 0))
    if w2s then
        render.circle_fade(w2s, 20, color_t(1, 0.25, 0.25, 0.5), color_t(0, 0, 0, 1))
    end
end)
```

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

### Render API: push_clip_rect

Source: https://docs.nixware.cc/render

Pushes a new 2D clipping rectangle onto the rendering stack. Subsequent drawing operations will be clipped to this rectangle. An option to intersect with the current clip rectangle is available.

```APIDOC
render.push_clip_rect(from: vec2_t, to: vec2_t, intersect_with_current_clip_rect?: boolean)
  from: vec2_t - Start position of the clip rect
  to: vec2_t - End position of the clip rect
  intersect_with_current_clip_rect: boolean - Optional. Allow intersections with other clips
```

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

### API: render.rect

Source: https://docs.nixware.cc/render

Draws an outlined rectangle on the screen defined by two corner points, with a specified color, and optional rounding and thickness.

```APIDOC
render.rect(from: vec2_t, to: vec2_t, color: color_t, rounding?: number, thickness?: number)
  Description: Draws an outlined rectangle.
  Parameters:
    from: vec2_t - Start position of the rectangle
    to: vec2_t - End position of the rectangle
    color: color_t - Color of the rectangle
    rounding?: number - Optional. Rounding of the rectangle
    thickness?: number - Optional. Thickness of the rectangle
```

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

### APIDOC: render.screen_size Method

Source: https://docs.nixware.cc/render

Retrieves the current screen dimensions as a `vec2_t` object.

```APIDOC
render.screen_size(): vec2_t
```

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

### Register Callback for Events (Lua API)

Source: https://docs.nixware.cc/environment

Registers a Lua function as a callback for a specified event. The 'name' parameter identifies the event, and 'func' is the Lua function to be executed when the event occurs. Refer to the events list for available event names.

```APIDOC
register_callback(name: string, func: function)
  name: string - Event name. Look [here](/events/) for event list
  func: function - Callback function
```

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

### API: render.line

Source: https://docs.nixware.cc/render

Draws a straight line between two specified 2D points on the screen, with a given color and optional thickness.

```APIDOC
render.line(from: vec2_t, to: vec2_t, color: color_t, thickness?: number)
  Description: Draws a line.
  Parameters:
    from: vec2_t - Start position of the line
    to: vec2_t - End position of the line
    color: color_t - Color of the line
    thickness?: number - Optional. Thickness of the line
```

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

### Nixware CS2 API: paint Event Callback

Source: https://docs.nixware.cc/events

Documents the `paint()` event callback, which is likely triggered for rendering or drawing operations.

```APIDOC
paint()
```

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

### Compile Lua Script using LuaJIT

Source: https://docs.nixware.cc/index

This command demonstrates how to compile a Lua script into a compiled Lua file using the LuaJIT compiler. The `-b` flag indicates the bytecode compilation mode, converting the source script into an optimized binary format.

```Shell
luajit.exe -b script.lua compiled.lua
```

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

### Find Memory Pattern (Lua API)

Source: https://docs.nixware.cc/environment

Searches for an IDA style pattern within a specified module's memory. The 'module' parameter is the target module name, 'pattern' is the IDA style pattern (with '?' as wildcard), and 'offset' is an optional byte offset to add to the found pointer. Returns 'nil' if the pattern is not found.

```APIDOC
find_pattern(module: string, pattern: string, offset?: number): userdata
  module: string - Module name to search the pattern in
  pattern: string - IDA style pattern to search for. Wildcard - `?`
  offset?: number - Optional. Offset in bytes which will be added to the pointer
Returns: userdata (nil if pattern is not found)
```

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

### math.angle_vectors API Reference

Source: https://docs.nixware.cc/math

Converts an angle_t into its corresponding forward, right, and up 3D vectors.

```APIDOC
math.angle_vectors(angles: angle_t): forward: vec3_t, right: vec3_t, up: vec3_t
  angles: angle_t - Angles
```

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

### API: render.rect_filled

Source: https://docs.nixware.cc/render

Draws a solid, filled rectangle on the screen defined by two corner points, with a specified color and optional rounding.

```APIDOC
render.rect_filled(from: vec2_t, to: vec2_t, color: color_t, rounding?: number)
  Description: Draws a filled rectangle.
  Parameters:
    from: vec2_t - Start position of a rectangle
    to: vec2_t - End position of the rectangle
    color: color_t - Color of the rectangle
    rounding?: number - Optional. Rounding of the rectangle
```

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

### Nixware CS2 API: angle_t Constructor

Source: https://docs.nixware.cc/types/angle_t

Initializes a new `angle_t` instance with specified pitch, yaw, and roll values.

```APIDOC
angle_t(pitch: number, yaw: number, roll: number)
  Parameters:
    pitch: number
    yaw: number
    roll: number
```

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

### vec2_t Constructor

Source: https://docs.nixware.cc/types/vec2_t

Initializes a new vec2_t instance with specified x and y coordinates.

```APIDOC
vec2_t(x: number, y: number)
  Parameters:
    x: number
    y: number
```

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

### trace_filter_t Constructor

Source: https://docs.nixware.cc/types/trace_filter_t

Initializes a new instance of the `trace_filter_t` structure. It allows specifying initial interaction layers, collision group, and whether to iterate entities, with an optional callback for custom entity hit logic.

```APIDOC
trace_filter_t Constructor:
  trace_filter_t(interacts_with: number, collision_group: number, iterate_entities: boolean, should_hit_entity_callback?: function)
  Parameters:
    interacts_with: number
    collision_group: number
    iterate_entities: boolean
    should_hit_entity_callback: function - Optional.
```

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

### Render API: polygon

Source: https://docs.nixware.cc/render

Draws a 2D polygon using an array of screen positions. The polygon will be filled with the specified color.

```APIDOC
render.polygon(points: vec2_t[], color: color_t)
  points: vec2_t[] - Array of screen positions
  color: color_t - Color of the polygon
```

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

### vec4_t Constructor

Source: https://docs.nixware.cc/types/vec4_t

Initializes a new instance of the `vec4_t` type with specified numerical values for its x, y, z, and w components.

```APIDOC
vec4_t(x: number, y: number, z: number, w: number)
  Parameters:
    x: number
    y: number
    z: number
    w: number
```

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

### Lua: Loop through CS2 Player Pawns using entitylist.get_entities

Source: https://docs.nixware.cc/entitylist

This Lua snippet demonstrates how to use the `entitylist.get_entities` function to iterate through all player pawn entities in the game. It filters entities by the class name 'C_CSPlayerPawn' and processes each found entity using a callback function.

```Lua
entitylist.get_entities("C_CSPlayerPawn", function(entity)
    -- loop through all players
end)
```

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

### Print Colored Text (Lua API)

Source: https://docs.nixware.cc/environment

Prints the specified text to the console. An optional 'color' parameter can be provided to set the text color. Appending '\0' to the end of the 'text' string will prevent a newline character from being added.

```APIDOC
color_print(text: string, color?: color_t)
  text: string - Text to print
  color?: color_t - Optional. Text color
Note: You can put `\0` in the end of the text to prevent newline
```

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

### Render API: circle_fade

Source: https://docs.nixware.cc/render

Renders a 2D circle with a radial color fade effect. The color transitions from `color_in` at the center to `color_out` at the edge.

```APIDOC
render.circle_fade(pos: vec2_t, radius: number, color_in: color_t, color_out: color_t)
  pos: vec2_t - Position of the circle
  radius: number - Radius of the circle
  color_in: color_t - Color of the center of the circle
  color_out: color_t - Color of the edge of the circle
```

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

### Lua: Execute Client Command on Player Death

Source: https://docs.nixware.cc/engine

Registers a callback for the 'player_death' event. If the local player is the attacker, it executes the 'say 1' client command.

```Lua
register_callback("player_death", function(event)
    if event:get_pawn("attacker") == entitylist.get_local_player_pawn() then
         engine.execute_client_cmd("say 1")
    end
end)
```

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

### API: render.texture

Source: https://docs.nixware.cc/render

Renders a specified texture within a defined rectangular area on the screen, with optional color tinting and rounding.

```APIDOC
render.texture(texture: texture_t, from: vec2_t, to: vec2_t, color?: color_t, rounding?: number)
  Description: Renders a texture.
  Parameters:
    texture: texture_t - Texture object
    from: vec2_t - Start position of the texture
    to: vec2_t - End position of the texture
    color?: color_t - Optional. Texture color
    rounding?: number - Optional. Rounding of the texture
```

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

### API: render.rect_filled_fade

Source: https://docs.nixware.cc/render

Draws a filled rectangle with a gradient fade effect, allowing different colors for each of its four corners.

```APIDOC
render.rect_filled_fade(from: vec2_t, to: vec2_t, col_upr_left: color_t, col_upr_right: color_t, col_bot_right: color_t, col_bot_left: color_t)
  Description: Draws a filled rectangle with a fade effect.
  Parameters:
    from: vec2_t - Start position of a rectangle
    to: vec2_t - Font object
    col_upr_left: color_t - Color of the top left corner
    col_upr_right: color_t - Color of the top right corner
    col_bot_right: color_t - Color of the bottom right corner
    col_bot_left: color_t - Color of the bottom left corner
```

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

### Render API: circle_fade_3d

Source: https://docs.nixware.cc/render

Renders a 3D circle with a radial color fade effect. The color transitions from `color_in` at the center to `color_out` at the edge. An optional normal vector can be provided for rotation.

```APIDOC
render.circle_fade_3d(pos: vec3_t, radius: number, color_in: color_t, color_out: color_t, normal?: vec3_t)
  pos: vec3_t - Position of the circle
  radius: number - Radius of the circle
  color_in: color_t - Color of the center of the circle
  color_out: color_t - Color of the edge of the circle
  normal: vec3_t - Optional. Rotation of the circle
```

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

### APIDOC: render.calc_text_size Method

Source: https://docs.nixware.cc/render

Calculates the size of a given text string using a specified font and optional font size. Returns a `vec2_t` object representing the text dimensions, or `nil` if the font does not exist.

```APIDOC
render.calc_text_size(text: string, font: font_t, size?: number): vec2_t

Parameters:
  text (string): Text size of which will be calculated
  font (font_t): Font object
  size (number, optional): Font size

Returns:
  vec2_t: The calculated size of the text. Returns nil if the font does not exist.
```

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

### API: engine.get_hitbox_pos

Source: https://docs.nixware.cc/engine

Retrieves the 3D position of a specific hitbox for a player pawn. Returns `nil` if unsuccessful.

```APIDOC
engine.get_hitbox_pos(pawn: base_entity_t, hitbox_index: number): vec3_t
  pawn: base_entity_t - Player pawn
  hitbox_index: number - Hitbox index
```

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

### Render API: circle_filled_3d

Source: https://docs.nixware.cc/render

Draws a filled 3D circle at a specified position and radius. An optional normal vector can be provided for rotation.

```APIDOC
render.circle_filled_3d(pos: vec3_t, radius: number, color: color_t, normal?: vec3_t)
  pos: vec3_t - Position of the circle
  radius: number - Radius of the circle
  color: color_t - Color of the circle
  normal: vec3_t - Optional. Rotation of the circle
```

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

### Nixware CS2 API: game_event Callback

Source: https://docs.nixware.cc/events

Documents the `game_event` callback, which is triggered when a game event occurs. It provides a `game_event_t` object containing event details.

```APIDOC
game_event(event: game_event_t)
  event: game_event_t - Game event
```

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

### math.vector_angles API Reference

Source: https://docs.nixware.cc/math

Converts a forward 3D vector into an angle_t representation.

```APIDOC
math.vector_angles(forward: vec3_t): angle_t
  forward: vec3_t - Vector
```

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

### Render API: concave_polygon

Source: https://docs.nixware.cc/render

Draws a 2D concave polygon using an array of screen positions. This function is specifically for concave shapes and fills them with the given color.

```APIDOC
render.concave_polygon(points: vec2_t[], color: color_t)
  points: vec2_t[] - Array of screen positions
  color: color_t - Color of the polygon
```

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

### Unload Current Script (Lua API)

Source: https://docs.nixware.cc/environment

Immediately unloads the Lua script from which this function is called.

```APIDOC
unload_script()
```

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

### math.calc_angle API Reference

Source: https://docs.nixware.cc/math

Calculates the angle between a source 3D vector and a destination 3D vector, returning an angle_t type.

```APIDOC
math.calc_angle(src: vec3_t, dst: vec3_t): angle_t
  src: vec3_t - Source vector
  dst: vec3_t - Destination vector
```

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

### API Reference: engine.trace_bullet

Source: https://docs.nixware.cc/engine

Documents the `engine.trace_bullet` function, which simulates a bullet trace between two points, considering a specific player's weapon properties. This function returns a number indicating the hit or `nil` if the bullet cannot hit its target.

```APIDOC
engine.trace_bullet(from_pawn: base_entity_t, from: vec3_t, to: vec3_t): number

Parameters:
  from_pawn: base_entity_t - Player whose weapon will be used for this trace
  from: vec3_t - Position to start tracing from
  to: vec3_t - Position where the trace ends

Returns: number (nil if bullet can't hit)
```

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

### API: engine.get_net_channel

Source: https://docs.nixware.cc/engine

Retrieves the current network channel object.

```APIDOC
engine.get_net_channel(): net_channel_t
```

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

### API: engine.get_level_name

Source: https://docs.nixware.cc/engine

Retrieves the name of the current game level.

```APIDOC
engine.get_level_name(): string
```

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

### math.calc_fov API Reference

Source: https://docs.nixware.cc/math

Calculates the field of view (FOV) between a source angle and a destination angle, returning a numerical value.

```APIDOC
math.calc_fov(src: angle_t, dst: angle_t): number
  src: angle_t - Source angle
  dst: angle_t - Destination angle
```

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

### APIDOC: render.frame_time Method

Source: https://docs.nixware.cc/render

Retrieves the time elapsed in seconds since the last frame was rendered.

```APIDOC
render.frame_time(): number
```

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

### Nixware CS2 API: unload Event Callback

Source: https://docs.nixware.cc/events

Documents the `unload()` event callback, which is triggered when the script or module is being unloaded.

```APIDOC
unload()
```

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

### Nixware CS2 API: player_chat Callback

Source: https://docs.nixware.cc/events

Documents the `player_chat` callback, triggered when a chat message is received. It provides a `chat_message_t` object. Returning `false` from the callback prevents the chat message from being printed by the game.

```APIDOC
player_chat(msg: chat_message_t)
  msg: chat_message_t - Chat message
```

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

### vec3_t.__tostring Method

Source: https://docs.nixware.cc/types/vec3_t

Converts the `vec3_t` instance to its string representation.

```APIDOC
vec3:__tostring(): string
```

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

### convar_t API Reference

Source: https://docs.nixware.cc/types/convar_t

Defines the `convar_t` object and its methods for retrieving various properties of a console variable, such as its name, description, and current value in different data types.

```APIDOC
convar_t:
  get_name(): string
    Description: Retrieves the name of the convar.
  get_desc(): string
    Description: Retrieves the description of the convar.
  get_bool(): boolean
    Description: Retrieves the boolean value of the convar.
  get_int(): number
    Description: Retrieves the integer value of the convar.
  get_float(): number
    Description: Retrieves the float value of the convar.
  get_string(): string
    Description: Retrieves the string value of the convar.
```

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

### UI: Check if Menu is Open

Source: https://docs.nixware.cc/ui

Determines if the user interface menu is currently active or opened. This function returns a boolean value indicating the menu's state.

```APIDOC
ui.is_menu_opened(): boolean
```

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

### hitbox_t Structure Definition

Source: https://docs.nixware.cc/types/hitbox_t

Defines the structure of a `hitbox_t` object, detailing its properties such as name, surface properties, bone information, dimensions, and various identifiers used within the Nixware CS2 API. This structure is crucial for understanding how hitboxes are represented and manipulated.

```APIDOC
hitbox_t:
  name: string
  surface_property: string
  bone_name: string
  mins: vec3_t
  maxs: vec3_t
  shape_radius: number
  bone_name_hash: number
  group_id: number
  shape_type: number
  translation_only: boolean
  crc: number
  hitbox_index: number
```

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

### API: engine.get_netvar_offset

Source: https://docs.nixware.cc/engine

Retrieves the offset of a network variable given its module, table, and property names.

```APIDOC
engine.get_netvar_offset(module_name: string, table_name: string, prop_name: string): number
  module_name: string - Module name
  table_name: string - Name of the table
  prop_name: string - Name of the property
```

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

### Nixware CS2 API: angle_t __tostring Method

Source: https://docs.nixware.cc/types/angle_t

Converts the `angle_t` instance into a string representation.

```APIDOC
angle:__tostring(): string
```

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

### color_t:__tostring Method

Source: https://docs.nixware.cc/types/color_t

Returns a string representation of the `color_t` object, useful for debugging or logging.

```APIDOC
color:__tostring(): string
```

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

### Nixware CS2 API: trace_t Structure Definition

Source: https://docs.nixware.cc/types/trace_t

Defines the `trace_t` structure, which encapsulates the results of a ray trace operation within the Nixware CS2 API. It provides detailed information about the collision, including the hit entity, hit point, surface normal, and other relevant attributes.

```APIDOC
trace_t Structure:
  hit_entity: base_entity_t - The entity that was hit.
  hitbox: hitbox_t - The hitbox that was hit.
  contents: number - Contents on other side of surface hit.
  shape_attributes: rn_collision_attr_t - Collision attributes of the hit shape.
  start_pos: vec3_t - Start position of the ray.
  end_pos: vec3_t - Final position of the ray.
  hit_normal: vec3_t - Surface normal at impact.
  hit_point: vec3_t - Exact hit point if exact_hit_point is true, otherwise equal to end_pos.
  hit_offset: number - Surface normal hit offset.
  fraction: number - Time completed, 1.0 = didn't hit anything.
  triangle: number - The index of the triangle that was hit.
  hitbox_bone_index: number - The index of the hitbox bone that was hit.
  ray_type: number - Type of the ray.
  start_in_solid: boolean - If true, the initial point was in a solid area.
  exact_hit_point: boolean - If true, then hit_point is the exact hit point of the query and the shape.
```

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

### game_event_t API Reference

Source: https://docs.nixware.cc/types/game_event_t

Documentation for the `game_event_t` type, which represents a game event in the Nixware CS2 API. It provides methods to retrieve and modify event properties such as names, integer values, float values, strings, pawn entities, and controller entities.

```APIDOC
game_event_t API:
  get_name(): string
    Description: Retrieves the name of the game event.

  get_int(key_name: string): number
    Description: Retrieves an integer value from the event.
    Parameters:
      key_name: string - Key name

  get_float(key_name: string): number
    Description: Retrieves a float value from the event.
    Parameters:
      key_name: string - Key name

  get_string(key_name: string): string
    Description: Retrieves a string value from the event.
    Parameters:
      key_name: string - Key name

  get_pawn(key_name: string): base_entity_t
    Description: Retrieves a pawn entity from the event.
    Parameters:
      key_name: string - Key name

  get_controller(key_name: string): base_entity_t
    Description: Retrieves a controller entity from the event.
    Parameters:
      key_name: string - Key name

  set_int(key_name: string, value: number)
    Description: Sets an integer value in the event.
    Parameters:
      key_name: string - Key name
      value: number - Value

  set_float(key_name: string, value: number)
    Description: Sets a float value in the event.
    Parameters:
      key_name: string - Key name
      value: number - Value

  set_string(key_name: string, value: string)
    Description: Sets a string value in the event.
    Parameters:
      key_name: string - Key name
      value: string - Value
```

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

### math.normalize_angle API Reference

Source: https://docs.nixware.cc/math

Normalizes a given angle, returning the normalized numerical value.

```APIDOC
math.normalize_angle(angle: number): number
  angle: number - Angle
```

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

### color_t:lerp Method

Source: https://docs.nixware.cc/types/color_t

Performs linear interpolation between the current color and another `color_t` object based on a given fraction. This method is useful for smooth color transitions.

```APIDOC
color:lerp(other: color_t, fraction: number): color_t
  other: color_t - Other color
  fraction: number - Fraction
```

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

### vec2_t __tostring Method

Source: https://docs.nixware.cc/types/vec2_t

Converts the vec2_t instance to its string representation.

```APIDOC
vec2:__tostring(): string
```

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

### vec4_t __tostring Method

Source: https://docs.nixware.cc/types/vec4_t

Converts the `vec4_t` instance into its string representation.

```APIDOC
vec4:__tostring(): string
```

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

### Render API: pop_clip_rect

Source: https://docs.nixware.cc/render

Removes the last 2D clipping rectangle from the rendering stack, restoring the previous clipping area.

```APIDOC
render.pop_clip_rect()
```
Tokens:
Raw