Parallax

https://parallax-framework.github.io/parallax
Admin
Parallax provides a documentation portal offering a fast reference tree and deep API pages, designed...
Tokens:268,157
Snippets:3,035
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Realistic Parallax Database Configuration Example

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/database_setup

An example of a `database.yml` file with sample credentials. Note the use of quotes for string values and the specified port.

```yaml
database:
  adapter: "mysqloo"
  hostname: "db.glnodes.com"
  username: "u47_ABC123xyz"
  password: "MySecureP@ssw0rd!2025"
  database: "s47_parallax"
  port: 50000

```

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

### LDOC Documentation for Global Function

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/style

Example of LDOC-compliant documentation for a global function, including description, realm, parameters, and usage example.

```lua
-- Sends a chat message to the player.
-- @realm shared
-- @param client Player The player receiving the message.
-- @param ... any Message parts.
-- @usage ax.util:SendChatText(client, "Hello", Color(255, 255, 255), " world!")
function ax.util:SendChatText(client, ...)
    -- implementation
end

```

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

### Start Server with Custom Schema

Source: https://parallax-framework.github.io/parallax/manuals/00-INTRODUCTION

Command to start the GMod server with your custom schema and map. Alternatively, configure this in the server's configuration file.

```bash
srcds_run.exe +gamemode your-schema-name +map rp_city45_2013

```

```lua
gamemode "your-schema-name"

```

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

### ax.net:Start (name, ...)

Source: https://parallax-framework.github.io/parallax/libraries/ax/net

Starts a network stream, typically used for server-to-client communication when target is omitted.

```APIDOC
## ax.net:Start(name, ...)

### Description
Starts a stream.

### Parameters
#### Path Parameters
- **name** (string) - Description: Hook name.
- **...** (any) - Description: Additional arguments.
```

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

### MODULE:InitializeIntro

Source: https://parallax-framework.github.io/parallax/api/modules/cl_intro

Builds and optionally starts the intro sequence. This function is available on the client realm.

```APIDOC
## MODULE:InitializeIntro(bStart)

### Description
Builds and optionally starts the intro sequence.

### Parameters
#### Path Parameters
- **bStart** (boolean) - Required - Whether to start immediately
```

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

### Get and Set Configuration Values

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Retrieve configuration values using `ax.config:Get()` and set them using `ax.config:Set()`. A default value can be provided for `Get()` if the configuration is not set.

```lua
-- Get configuration value
local serverName = ax.config:Get("server.name")
local maxPlayers = ax.config:Get("server.max_players", 32)  -- With default

-- Set configuration
ax.config:Set("server.name", "New Server Name")


```

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

### ax.net:Start (with target)

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_net

Starts a stream to a specific target or broadcasts to all. This is the primary function for initiating network transmissions.

```APIDOC
## ax.net:Start(target, name, ...)

### Description
Starts a stream.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **target** (Player, table, vector or nil) - Optional - The target for the stream. Nil indicates broadcast or sending to the server.
- **name** (string) - Required - The hook name for the stream.
- **...** (any) - Optional - Additional arguments to send with the stream.

### Request Example
```json
{
  "target": null,
  "name": "player_joined",
  "...": ["player_id_123"]
}
```

### Response
#### Success Response (200)
- None

#### Response Example
```json
{
  "example": "null"
}
```
```

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

### ax.net:Start (target, name, ...)

Source: https://parallax-framework.github.io/parallax/libraries/ax/net

Starts a network stream to a specific target or broadcasts to all. The name parameter is the hook name.

```APIDOC
## ax.net:Start(target, name, ...)

### Description
Starts a stream.

### Parameters
#### Path Parameters
- **target** (Player, table, vector or nil) - Description: nil = broadcast or to server.
- **name** (string) - Description: Hook name.
- **...** (any) - Description: Additional arguments.
```

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

### Start Network Message (Server)

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Use ax.net:Start to send network messages from the server to clients. Specify recipients as nil for all clients, a single player, a table of players, or a Vector. Additional arguments are passed as message data.

```lua
ax.net:Start(nil, "my_message", data1, data2)

ax.net:Start(client, "my_message", arg1, arg2)

ax.net:StartPVS(position, "my_message", arg1, arg2)

ax.net:Start({client1, client2}, "my_message", arg1, arg2)
```

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

### ax.net:Start (without target)

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_net

Starts a stream, typically broadcasting to all clients or the server. This overload is used when a specific target is not required.

```APIDOC
## ax.net:Start(name, ...)

### Description
Starts a stream.

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **name** (string) - Required - The hook name for the stream.
- **...** (any) - Optional - Additional arguments to send with the stream.

### Request Example
```json
{
  "name": "game_state_update",
  "...": [{"score": 100}]
}
```

### Response
#### Success Response (200)
- None

#### Response Example
```json
{
  "example": "null"
}
```
```

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

### Get Configuration Value

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Use ax.config:Get to retrieve a server configuration setting. A fallback value can be provided to be returned if the key does not exist.

```lua
local serverName = ax.config:Get("server.name")
local maxPlayers = ax.config:Get("server.max_players", 32)
```

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

### Item Data Persistence Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/04-items

Demonstrates setting and getting item data. Parallax automatically persists data to the ax_items table as JSON on SetData.

```lua
-- Both Helix and Parallax
item:SetData("ammo", 17)
local ammo = item:GetData("ammo", 0)

```

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

### Example: Construct and Execute MySQL Query

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Demonstrates building a SELECT query with WHERE and LIMIT clauses, setting a callback for processing results, and executing the query.

```lua
local query = mysql:Select("ax_characters")
    query:Where("faction", FACTION_CITIZEN)
    query:Limit(10)
    query:Callback(function(result, status) 
        if result then
            for i = 1, #result do
                print(result[i].name)
            end
        end
    end)
query:Execute()
```

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

### Prevent Specific Weapon Give

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Use `SCHEMA:PlayerGiveSWEP` to prevent players from receiving certain weapons. This example blocks non-superadmins from getting RPGs.

```lua
function SCHEMA:PlayerGiveSWEP(client, className, info)
    -- Prevent certain weapons
    if className == "weapon_rpg" and !client:IsSuperAdmin() then
        return false
    end
    return true
end
```

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

### Item API: Get, Spawn, and Transfer

Source: https://parallax-framework.github.io/parallax/manuals/02-CORE_SYSTEMS

Provides examples of using the ax.item API to retrieve item definitions or instances, spawn items into the game world on the server, and transfer items between inventories. Callbacks are available for asynchronous operations.

```lua
-- Get item definition by class
local itemDef = ax.item:Get("pistol")

-- Get item instance by ID
local itemInstance = ax.item:Get(123)

-- Spawn item in world (server)
ax.item:Spawn("pistol", Vector(0, 0, 0), Angle(0, 0, 0), function(entity, itemObj)
    -- Callback when spawned
end)

-- Transfer item between inventories (server)
local success, reason = ax.item:Transfer(item, fromInv, toInv, function(success)
    if success then
        print("Transfer complete")
    end
end)

-- Get item actions
local actions = ax.item:GetActionsForClass("pistol")

```

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

### Initialize Git Repository

Source: https://parallax-framework.github.io/parallax/manuals/07-BEST_PRACTICES

Basic Git commands to initialize a new repository, add files, and make the initial commit.

```bash
git init

git add .

git commit -m "Initial commit"

git checkout -b feature/new-faction
```

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

### ax.theme:Get

Source: https://parallax-framework.github.io/parallax/libraries/ax/theme

Get a theme definition by id.

```APIDOC
## ax.theme:Get

### Description
Get a theme definition by id. Returns the active theme when no id is supplied, and falls back to the dark theme when the requested id does not exist.

### Parameters
#### Path Parameters
- **id** (string) - Optional - The ID of the theme to retrieve.
```

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

### ax.schema:Initialize

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_schema

Initializes the active schema and loads all its components, including the boot file, directories, factions, classes, items, and modules.

```APIDOC
## ax.schema:Initialize

### Description
Initializes the active schema and loads all its components. Loads the schema's boot file, includes all directories in proper order, and initializes factions, classes, items, and modules.

### Method
Shared function

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```lua
ax.schema:Initialize()
```

### Response
#### Success Response (boolean)
- Returns `true` if initialization succeeded, `false` if the boot file failed to load.

#### Response Example
```lua
local success = ax.schema:Initialize()
```
```

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

### Get Localized Strings

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Retrieve localized strings using `ax.lang:Get()`. Specify the string key and the language code. Can also dynamically get the player's language for UI elements.

```lua
-- Get localized string
local welcomeMsg = ax.lang:Get("welcome", "en")  -- or use player's language

-- In UI
local label = vgui.Create("DLabel")
label:SetText(ax.lang:Get("ui.inventory", client:GetLanguage()))


```

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

### Framework Bootstrapping

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Sets core framework metadata and loads essential directories like libraries, meta-tables, core functionality, hooks, networking, and interface systems.

```lua
GM.Name = "Parallax"
GM.Author = "riggs9162 & bloodycop6385"
GM.Website = "https://discord.gg/yekEvSszW3"
GM.Email = "riggs9162@gmx.de"

-- Load directories in order
ax.util:IncludeDirectory("libraries")   -- Framework systems
ax.util:IncludeDirectory("meta")        -- Meta-tables
ax.util:IncludeDirectory("core")        -- Core functionality
ax.util:IncludeDirectory("hooks")       -- Framework hooks
ax.util:IncludeDirectory("networking")   -- Network handlers
ax.util:IncludeDirectory("interface")   -- UI systems

```

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

### Schema Bootstrapping Configuration

Source: https://parallax-framework.github.io/parallax/manuals/00-INTRODUCTION

Minimal schema configuration file (`boot.lua`) to define schema properties like name, description, and author.

```lua
SCHEMA.name = "My Roleplay Schema"
SCHEMA.description = "A custom roleplay schema based on Parallax."
SCHEMA.author = "YourName"

```

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

### Get Item Definition or Instance - ax.item:Get

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Use ax.item:Get to retrieve an item's definition by its class name or an item instance by its ID. Returns the item table or nil if not found.

```lua
local itemDef = ax.item:Get("pistol")
local itemInstance = ax.item:Get(123)
```

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

### Create MySQL Database and User via Command Line

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/database_setup

Use these SQL commands to create a new database, a user, and grant privileges. Ensure you replace 'your_password_here' with a strong password.

```sql
CREATE DATABASE parallax_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'parallax_user'@'localhost' IDENTIFIED BY 'your_password_here';
GRANT ALL PRIVILEGES ON parallax_db.* TO 'parallax_user'@'localhost';
FLUSH PRIVILEGES;

```

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

### Helix Attribute Definition Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/10-classes-and-attributes

An example of a Helix attribute file, defining a 'Strength' attribute with its properties.

```lua
-- schema/attributes/sh_strength.lua
ATTRIBUTE.name        = "Strength"
ATTRIBUTE.description = "Affects how much weight you can carry."
ATTRIBUTE.default     = 0
ATTRIBUTE.max         = 100

```

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

### Create a new store instance

Source: https://parallax-framework.github.io/parallax/api/framework/util/util_store

Use this function to create a new store for managing key/value settings. Specify the store's name, authority (server or client), persistence path, and networking channels.

```lua
local store = ax.util:CreateStore({
    name = "config",
    authority = "server",
    path = ax.util:BuildDataPath("config"),
    net = { init = "ax.config.init", set = "ax.config.set" }
})
```

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

### Parallax Module Hook Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/07-hooks

Example of a module hook in Parallax. This function is dispatched from ax.module.stored iteration.

```lua
function MODULE:PlayerSay(client, text)
    -- dispatched from ax.module.stored iteration
end
```

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

### Configure .gitignore

Source: https://parallax-framework.github.io/parallax/manuals/07-BEST_PRACTICES

Example .gitignore file to exclude common development and OS-specific files from Git tracking.

```gitignore
# Ignore GMod specific files
*.log
*.db

# Ignore OS files
.DS_Store
Thumbs.db

# Ignore IDE files
.vscode/
.idea/
```

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

### Helix Schema Hook Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/07-hooks

Example of a Schema hook in Helix. This function is dispatched from the Schema table.

```lua
function Schema:PlayerSay(client, text)
    -- dispatched from the Schema table
end
```

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

### Example Function with Indentation and Control Flow

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/style

Demonstrates standard indentation with 4 spaces and a basic if statement within a function.

```lua
function ax.util:ExampleFunction()
    local value = 10
    if ( value > 5 ) then
        print("Value is greater than 5")
    end
end

```

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

### Configure Server Settings

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Set general server parameters like name, description, and player limits. Also configures gameplay, economy, character, and inventory settings.

```lua
-- schema/config/sh_config.lua
-- Server settings
ax.config:Set("server.name", "My Roleplay Server")
ax.config:Set("server.description", "A custom roleplay server")
ax.config:Set("server.max_players", 32)

-- Gameplay settings
ax.config:Set("playtime.enabled", true)
ax.config:Set("playtime.interval", 60)  -- Update every 60 seconds

-- Economy settings
ax.config:Set("economy.starting_money", 500)
ax.config:Set("economy.max_money", 1000000)

-- Character settings
ax.config:Set("character.max_characters", 5)
ax.config:Set("character.default_health", 100)

-- Inventory settings
ax.config:Set("inventory.default_weight", 30)
ax.config:Set("inventory.weight_unit", "kg")

```

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

### Schema Initialization Boot

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Loads the schema's boot file, which is essential for initializing schema-specific configurations and systems.

```lua
-- From ax.schema:Initialize()
local active = SCHEMA.folder or engine.ActiveGamemode()
local boot = ax.util:Include(active .. "/gamemode/schema/boot.lua", "shared")

```

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

### Helix Plugin Hook Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/07-hooks

Example of a plugin hook in Helix. This function is dispatched from HOOKS_CACHE["PlayerSay"].

```lua
function PLUGIN:PlayerSay(client, text)
    -- dispatched from HOOKS_CACHE["PlayerSay"]
end
```

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

### Create Default Database Tables

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sv_database

Initializes the database by creating the default tables required by the framework, including schemas for players, characters, and inventories.

```lua
ax.database:CreateTables()

```

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

### tool:Deploy()

Source: https://parallax-framework.github.io/parallax/meta/tool

Called when the tool is selected by the player. Used for releasing ghost entities or running setup logic.

```APIDOC
## tool:Deploy()

### Description
Called when the tool is deployed (the player selects it).
Releases any ghost entity via `ReleaseGhostEntity`.
Override to show a preview ghost or run setup logic when the player switches to this tool.

### Realm
`shared`
```

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

### Initialize Faction System - ax.faction:Initialize

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_faction

Initializes the faction system by loading all faction files from framework, modules, and schema directories. This is typically called during framework boot.

```lua
ax.faction:Initialize()
```

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

### ax.faction:Initialize

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_faction

Initializes the faction system by loading all faction files from framework, modules, and schema directories.

```APIDOC
## ax.faction:Initialize()

### Description
Initialize the faction system by loading all faction files. Automatically includes factions from framework, modules, and schema directories. Called during framework boot to set up all available factions.
```

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

### Get Configuration Values

Source: https://parallax-framework.github.io/parallax/manuals/04-ADVANCED_TOPICS

Retrieve configuration values using `ax.config:Get`. You can also provide a default value to use if the setting is not found.

```lua
-- Get configuration value
local serverName = ax.config:Get("server.name")
local maxPlayers = ax.config:Get("server.max_players")

-- Get with default
local value = ax.config:Get("optional.setting", "default_value")

-- Get nested configuration
local startingMoney = ax.config:Get("economy.starting_money")
```

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

### Bootstrap First Admin (Console)

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/usergroups

Use the server console to assign the 'superadmin' usergroup to a player during initial setup.

```bash
ax_player_set_usergroup "player" "superadmin"

```

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

### Get Dominant Zone for Entity

Source: https://parallax-framework.github.io/parallax/libraries/ax/zones

A convenience method to get the dominant zone for a given entity. Returns the zone or nil if none is dominant.

```lua
ax.zones:GetDominant(ent)
```

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

### ax.reqwest:Get

Source: https://parallax-framework.github.io/parallax/libraries/ax/reqwest

Performs a GET request to the specified URL. It takes the URL, success callback, failure callback, and optional headers as arguments.

```APIDOC
## ax.reqwest:Get(url, onSuccess, onFailure, headers)

### Description
Performs a GET request.

### Parameters
#### Path Parameters
- **url** (string) - Required - Target URL.
- **onSuccess** (function) - Required - Callback function for successful requests.
- **onFailure** (function) - Required - Callback function for failed requests.
- **headers** (table) - Optional - Table of headers to include in the request.

### Returns
- **boolean**: True if the request was queued successfully.
```

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

### Schema Boot File Configuration

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Defines the basic metadata for your custom schema, such as its name, description, and author. This file is essential for identifying your schema within the framework.

```lua
-- schema/boot.lua
SCHEMA.name = "My Roleplay Schema"
SCHEMA.description = "A custom roleplay schema based on Parallax."
SCHEMA.author = "YourName"

```

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

### ax.faction:Initialize()

Source: https://parallax-framework.github.io/parallax/libraries/ax/faction

Initializes the faction system by loading all faction files, automatically including factions from framework, modules, and schema directories.

```APIDOC
## ax.faction:Initialize()

### Description
Initialize the faction system by loading all faction files. Automatically includes factions from framework, modules, and schema directories. Called during framework boot to set up all available factions.

### Usage
```lua
ax.faction:Initialize()
```
```

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

### Parallax Custom Hook Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/07-hooks

Example of a custom hook in Parallax, dispatched from ax.hook.stored.SCHEMA. Requires explicit registration via ax.hook:Register.

```lua
function SCHEMA:PlayerSay(client, text)
    -- dispatched from ax.hook.stored.SCHEMA
end
```

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

### Get Character by ID

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/05-characters-and-vars

Access a character object using its unique identifier. Helix uses a loaded table, while Parallax uses a Get method.

```lua
-- Helix
local char = ix.char.loaded[id]

-- Parallax
local char = ax.character:Get(id)

```

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

### Documenting Complex Logic for Faction Joining

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

Illustrates how to document complex conditional logic within a function, explaining the checks required for a player to join a faction.

```lua
-- Check if player can become faction based on multiple conditions:
-- 1. Player must be alive
-- 2. Player must not be arrested
-- 3. Player must have required flags
function FACTION:CanBecome(client)
    if !client:Alive() then
        return false, "You must be alive to join this faction"
    end

    -- ... more checks

    return true
end

```

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

### tool:Init()

Source: https://parallax-framework.github.io/parallax/meta/tool

Initializes the tool instance when it is created.

```APIDOC
## tool:Init()

### Description
Initializes the tool instance when it is created.

### Realm
`shared`
```

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

### Plugin System Mapping: Get Plugin

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/01-namespace-map

Maps Helix's method for retrieving a plugin by ID to Parallax's `Get` method for modules.

```lua
ix.plugin.Get(id)
```

```lua
ax.module:Get(id)
```

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

### Plugin System Mapping: Load Plugin from Directory

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/01-namespace-map

Compares Helix's `LoadFromDir` for plugins with Parallax's `Include` function, noting Parallax only supports directory inclusion.

```lua
ix.plugin.LoadFromDir(dir)
```

```lua
ax.module:Include(dir)
```

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

### tool:Init()

Source: https://parallax-framework.github.io/parallax/meta/tool

Called when the tool is first initialized. This method is empty by default but can be overridden in a tool definition to perform setup logic when the tool object is created, similar to the Init stub in the Sandbox tool base.

```APIDOC
## tool:Init()

### Description
Called when the tool is first initialised. Empty by default; override this in a tool definition to run setup logic when the tool object is created. Equivalent to the `Init` stub in the Sandbox tool base.

### Realm
`shared`
```

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

### Get Modules by Scope - ax.module:GetByScope

Source: https://parallax-framework.github.io/parallax/libraries/ax/module

Retrieves modules filtered by a specific scope, such as 'framework' or 'schema'. Use this to get modules belonging to a particular category.

```lua
local schemaModules = ax.module:GetByScope("schema")

```

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

### Minimal Schema Boot File

Source: https://parallax-framework.github.io/parallax/manuals/03-SCHEMA_DEVELOPMENT

A minimal schema boot file defining only the essential metadata: name, description, and author. This is sufficient for a basic schema to be recognized by the framework.

```lua
SCHEMA.name = "My Schema"
SCHEMA.description = "A roleplay schema"
SCHEMA.author = "YourName"

```

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

### ax.theme:Get

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/cl_theme

Get a theme definition by id. Returns the active theme when no id is supplied, and falls back to the dark theme when the requested id does not exist.

```APIDOC
## ax.theme:Get(id)

### Description
Get a theme definition by id. Returns the active theme when no id is supplied, and falls back to the dark theme when the requested id does not exist.

### Returns
- **theme** (table) - Theme definition table
```

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

### ax.recognition:Introduce(client, targetClient, alias)

Source: https://parallax-framework.github.io/parallax/libraries/ax/recognition

Introduces two clients to each other, establishing an initial familiarity level and optionally setting an alias.

```APIDOC
## ax.recognition:Introduce(client, targetClient, alias)

### Description
Introduces two clients to each other, establishing an initial familiarity level and optionally setting an alias.

### Parameters
#### Path Parameters
- **client** (Player) - Required - The client initiating the introduction
- **targetClient** (Player) - Required - The client being introduced to
- **alias** (string) - Optional - An alias to set for the target client
```

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

### ax.actionBar:Start(label, duration, onComplete, onCancel)

Source: https://parallax-framework.github.io/parallax/api/framework/interface/cl_actionbar

Initiates the display of an action bar with a specified label and duration. Optional callbacks can be provided for completion or cancellation.

```APIDOC
## ax.actionBar:Start(label, duration, onComplete, onCancel)

### Description
Start displaying an action bar.

### Parameters
* `label` (string): Label text to display (default: "Processing...")
* `duration` (number): Duration in seconds
* `onComplete` (function): Optional callback when action completes
* `onCancel` (function): Optional callback when action is cancelled
```

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

### Helix Class Definition Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/10-classes-and-attributes

Example of a Helix class definition, including name, description, faction, default status, weapons, and custom validation/event functions.

```lua
-- Helix (`schema/classes/sh_tcp.lua`):
CLASS.name        = "Transhuman Arm"
CLASS.description = "The elite of the Overwatch."
CLASS.faction     = FACTION_MPF
CLASS.isDefault   = false

CLASS.weapons = {
    "weapon_ar2",
    "weapon_frag",
}

function CLASS:CanSwitchTo(client)
    local char = client:GetCharacter()
    return char:GetData("canBecomeTCP", false)
end

function CLASS:OnSet(client)
    client:SetHealth(150)
end

CLASS_TCP = CLASS.index

```

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

### Initialize Schema with ax.schema

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_schema

Call this function to initialize the active schema and load all its components. It loads the boot file, includes directories, and initializes factions, classes, items, and modules. The function returns true on success and false if the boot file fails to load.

```lua
ax.schema:Initialize()

```

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

### Get Character by ID - ax.character:Get

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Retrieves a character object using its unique ID. Use this to access and manipulate existing character data. Ensure the ID is a number.

```lua
local character = ax.character:Get(123)
if character then
    print(character:GetName())
end

```

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

### Network Best Practice: Use PVS for Spatial Updates

Source: https://parallax-framework.github.io/parallax/manuals/04-ADVANCED_TOPICS

Demonstrates using `StartPVS` to send updates only to players who are potentially visible to the entity's position, optimizing for spatial relevance.

```lua
-- Only send to players who can see it
local pos = entity:GetPos()
ax.net:StartPVS(pos, "entity_update", entityData)
```

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

### Plugin Data Mapping: Get Data

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/01-namespace-map

Maps Helix's `GetData` for plugins to Parallax's `ax.data:Get`, showing parameter differences for scope and default values.

```lua
PLUGIN:GetData(default, global, ignoreMap)
```

```lua
ax.data:Get(key, default, { scope = ... })
```

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

### Get Loaded Module by Name - ax.module:Get

Source: https://parallax-framework.github.io/parallax/libraries/ax/module

Retrieves a module that has been previously loaded using its unique identifier. Use this when you need to access a specific, already loaded module.

```lua
local myModule = ax.module:Get("example_module")

```

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

### ax.class:Initialize

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_class

Initializes the class system by loading all available class files, typically called during framework startup.

```APIDOC
## ax.class:Initialize()

### Description
Initialize the class system by loading all class files. Automatically includes classes from framework, modules, and schema directories. Called during framework boot to set up all available classes.

### Returns
- None
```

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

### Parallax Class Definition Example

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/10-classes-and-attributes

Example of a Parallax class definition, mirroring Helix but using Parallax's CanBecome hook for validation and omitting direct weapon/health fields.

```lua
-- Parallax (`<your-schema>/gamemode/schema/classes/sh_tcp.lua`):
CLASS.name        = "Transhuman Arm"
CLASS.description = "The elite of the Overwatch."
CLASS.faction     = FACTION_MPF
CLASS.isDefault   = false

function CLASS:CanBecome(client)
    local char = client:GetCharacter()
    if ( !ax.character:GetVar(char, "data", "canBecomeTCP", false) ) then
        return false, "You are not authorized to join the Transhuman Arm."
    end
    return true
end

CLASS_TCP = CLASS.index

```

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

### Connect to Database

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sv_database

Establishes a connection to the database using the specified parameters. Supports different modules like 'mysql' and 'sqlite'.

```lua
ax.database:Connect("mysql", "localhost", "user", "pass", "gamedb")

```

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

### Initialize Class System

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_class

Initializes the entire class system by loading all available class files from framework, modules, and schema directories. This is typically called during framework startup.

```lua
ax.class:Initialize()
```

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

### ax.net:Start

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Starts a network message, acting as a server-side function to send messages to specified recipients. Supports sending to all, specific players, players in PVS, or multiple players.

```APIDOC
## `ax.net:Start(recipients, message, ...)`

### Description
Starts network message (server).

### Parameters
#### Path Parameters
- `recipients` (nil|Player|table|Vector) - Required - Recipients (nil = all)
- `message` (string) - Required - Message name
- `...` (any) - Required - Message data

### Request Example
```lua
-- Send to all clients
ax.net:Start(nil, "my_message", data1, data2)

-- Send to specific player
ax.net:Start(client, "my_message", arg1, arg2)

-- Send to players in PVS
ax.net:StartPVS(position, "my_message", arg1, arg2)

-- Send to multiple players
ax.net:Start({client1, client2}, "my_message", arg1, arg2)
```
```

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

### Create Custom Derma Panel UI

Source: https://parallax-framework.github.io/parallax/manuals/04-ADVANCED_TOPICS

Creates a custom client-side UI panel using Derma. This example shows how to create a simple frame with a label and a button, and how to open it via a server command.

```lua
-- Client-side custom UI
local function OpenCustomMenu()
    local frame = vgui.Create("DFrame")
    frame:SetTitle("Custom Menu")
    frame:SetSize(400, 300)
    frame:Center()
    frame:MakePopup()

    local label = vgui.Create("DLabel", frame)
    label:SetText("Hello, World!")
    label:Dock(TOP)
    label:SetContentAlignment(5)
    label:SetHeight(30)

    local button = vgui.Create("DButton", frame)
    button:SetText("Click Me")
    button:Dock(BOTTOM)
    button.DoClick = function()
        chat.AddText("Button clicked!")
    end
end

-- Call from server command
ax.net:Hook("open_menu", OpenCustomMenu)


```

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

### Get Hook Reference: Helix vs. Parallax

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/02-plugins-to-modules

Use `ax.module:Get(id)` to retrieve a module and access its methods directly, as Parallax lacks a direct equivalent to Helix's `ix.plugin.GetHook`.

```lua
-- Helix
local fn = ix.plugin.GetHook("vendor", "PlayerUse")

-- Parallax
local mod = ax.module:Get("vendor")
local fn = mod and mod.PlayerUse
```

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

### Get Faction by Identifier - ax.faction:Get

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_faction

Retrieves a faction by its unique ID string, index number, name, or partial name match. Returns the faction table if found, otherwise nil.

```lua
local faction = ax.faction:Get("citizen")
```

```lua
local faction = ax.faction:Get(1)
```

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

### ax.command:Help

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_command

Generates a help string for a specified command.

```APIDOC
## ax.command:Help(name)

### Description
Generate a help string for a command.

### Parameters
#### Path Parameters
- **name** (string) - Required - The command name

### Returns
- `string` - Help text

### Usage Example
```lua
local help = ax.command:Help("pm")
```
```

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

### Inheritance Example

Source: https://parallax-framework.github.io/parallax/manuals/intermediate/item_creation

Items in subdirectories inherit from base items placed in the `base/` directory. Override fields and methods as needed to customize inherited items. For example, items in `items/weapons/` inherit from `base/sh_weapons.lua`.

```lua
-- Example: items/weapons/my_custom_gun.lua
-- Inherits from base/sh_weapons.lua

ITEM.name = "My Custom Gun"
ITEM.model = "models/weapons/my_gun.mdl"
-- Override other fields or add new ones
```

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

### Get Inventory by ID - ax.inventory:Get

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Retrieves an inventory by its unique ID. Use this when you need to access an existing inventory's properties or methods. Ensure to check if the returned inventory is not nil before accessing its methods.

```lua
local inventory = ax.inventory:Get(1)
if inventory then
    print(inventory:GetWeight())
end

```

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

### ax.reqwest:Get

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/thirdparty/sh_reqwest

Performs a GET request to the specified URL. It takes the URL, an optional success callback, an optional failure callback, and optional headers as parameters. Returns a boolean indicating if the request was queued successfully.

```APIDOC
## ax.reqwest:Get(url, onSuccess, onFailure, headers)

### Description
Performs a GET request.

### Parameters
#### Path Parameters
- **url** (string) - Required - Target URL.
- **onSuccess** (function) - Optional - Callback function for successful requests.
- **onFailure** (function) - Optional - Callback function for failed requests.
- **headers** (table) - Optional - Table of custom headers.

### Returns
- **boolean**: True if the request was queued successfully.
```

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

### Create and Restore Inventories in Helix

Source: https://parallax-framework.github.io/parallax/manuals/backporting/helix/08-inventory

Demonstrates synchronous inventory creation and asynchronous restoration with a callback in Helix.

```lua
-- Create a new inventory of fixed size
ix.inventory.Create(w, h, id)           -- synchronous

-- Restore an existing inventory from the database
ix.inventory.Restore(invID, w, h, cb)   -- async with callback

-- Bag inventories have their own IDs registered via:
ix.inventory.Register("bag_type", w, h, isBag)

```

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

### Schema Initialization Completion

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Prints a success message upon schema initialization and runs the 'OnSchemaLoaded' hook to allow further schema-specific setup.

```lua
ax.util:PrintSuccess("Schema \"" .. active .. "\" initialized successfully.")
hook.Run("OnSchemaLoaded")

```

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

### Client Gamemode Initialization

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Initializes the Parallax framework on the client. Sets up the global namespace and includes necessary client-side framework files.

```lua
DeriveGamemode("sandbox")

-- Initialize global namespace
ax = ax or {util = {}, config = {}, options = {}, character = {}, inventory = {}, item = {}}
ax._reload = ax._reload or { pingAt = 0, armed = false, frame = -1 }

-- Include client files
include("framework/util/boot.lua")
include("framework/boot.lua")

```

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

### ax.character:Get

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_character

Retrieves a character by their unique ID.

```APIDOC
## ax.character:Get(id)

### Description
Get a character by their unique ID.

### Parameters
#### Path Parameters
- **id** (number) - Required - The character's unique ID

### Returns
- **table|nil**: The character table if found, nil if invalid ID or not found

### Usage
```lua
local character = ax.character:Get(123)
```
```

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

### ax.inventory:Get

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Retrieves an inventory object by its unique ID.

```APIDOC
## ax.inventory:Get(id)

### Description
Get inventory by ID.

### Parameters
#### Path Parameters
- **id** (number): Inventory ID

### Returns
- **inventory** (table|nil): Inventory table or nil if not found.

### Example
```lua
local inventory = ax.inventory:Get(1)
if inventory then
    print(inventory:GetWeight())
end
```
```

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

### ax.elements:GetEntityDisplayText

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/cl_elements

Gets the display text for a given entity.

```APIDOC
## ax.elements:GetEntityDisplayText(entity)

### Description
Gets the display text for a given entity.

### Parameters
#### Path Parameters
- **entity** (Entity) - Required - The entity to get the display text for.

### Returns
- **string** - The display text of the entity.
```

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

### Include

Source: https://parallax-framework.github.io/parallax/libraries/ax/util

Includes a Lua file with automatic realm-based routing. It handles path normalization, realm detection, and routing to client or server environments.

```APIDOC
## ax.util:Include(path, realm)

### Description
Includes a Lua file with automatic realm-based routing. Normalises path separators and strips leading slashes, then detects the realm via `DetectFileRealm` if no hint is provided. Routing rules apply for client, server, and shared realms. Both `AddCSLuaFile` and `include` are wrapped with `pcall` internally. Returns false for invalid or non-`.lua` paths.

### Parameters
#### Path Parameters
- **path** (string) - Required - Path to the Lua file, relative to the `LUA` mount point.
- **realm** (string|nil) - Optional - Realm override: `"client"`, `"server"`, or `"shared"`. Detected automatically from the filename prefix when omitted.

### Returns
- boolean: True if an include or AddCSLuaFile was attempted, false on invalid input.

### Usage Examples
```lua
ax.util:Include("framework/sh_util.lua")
ax.util:Include("framework/sv_database.lua", "server")
```
```

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

### SCHEMA Table Usage Example

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Defines schema metadata like name, description, and author. The SCHEMA table is available everywhere after boot, and includes a callback for when the schema is loaded.

```lua
-- schema/boot.lua
SCHEMA.name = "My Schema"
SCHEMA.description = "A custom roleplay schema"
SCHEMA.author = "YourName"

-- Available everywhere after boot
function SCHEMA:OnSchemaLoaded()
    print("Schema loaded:", SCHEMA.name)
end

```

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

### ax.elements:GetEntityDisplayDescription

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/cl_elements

Gets the display description for a given entity.

```APIDOC
## ax.elements:GetEntityDisplayDescription(entity)

### Description
Gets the display description for a given entity.

### Parameters
#### Path Parameters
- **entity** (Entity) - Required - The entity to get the description for.

### Returns
- **string** - The display description of the entity.
```

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

### ax.theme:GetGlass

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/cl_theme

Get the active glass color palette.

```APIDOC
## ax.theme:GetGlass()

### Description
Get the active glass color palette.

### Returns
- **glass** (table) - Raw glass palette for the current theme
```

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

### Faction Methods

Source: https://parallax-framework.github.io/parallax/manuals/02-CORE_SYSTEMS

Illustrates how to use methods on a faction object to retrieve its models and check if a player can join.

```lua
-- Get models (with default fallback)
local models = faction:GetModels()

-- Check if player can join
local canJoin, reason = faction:CanBecome(client)

```

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

### ax.item:Get

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Retrieves the definition or instance of an item using its identifier.

```APIDOC
## `ax.item:Get(identifier)`

### Description
Get item definition or instance.

### Parameters
#### Path Parameters
- **identifier** (string|number): Item class or instance ID

### Returns
- (table|nil): Item definition/instance or nil

### Request Example
```lua
local itemDef = ax.item:Get("pistol")
local itemInstance = ax.item:Get(123)
```
```

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

### Framework Directory Tree

Source: https://parallax-framework.github.io/parallax/manuals/01-ARCHITECTURE

Illustrates the complete directory structure of the framework, including core systems, libraries, hooks, networking, interface, and utility modules.

```tree
gamemode/
├── init.lua                  -- Server initialization
├── cl_init.lua               -- Client initialization
├── framework/                -- Framework core
│   ├── boot.lua             -- Framework boot
│   ├── libraries/           -- System libraries
│   │   ├── cl_bind.lua
│   │   ├── cl_font.lua
│   │   ├── cl_motion.lua
│   │   ├── cl_skin.lua
│   │   ├── sh_character.lua
│   │   ├── sh_chat.lua
│   │   ├── sh_class.lua
│   │   ├── sh_command.lua
│   │   ├── sh_config.lua
│   │   ├── sh_data.lua
│   │   ├── sh_ease.lua
│   │   ├── sh_faction.lua
│   │   ├── sh_flags.lua
│   │   ├── sh_hook.lua
│   │   ├── sh_inventory.lua
│   │   ├── sh_item.lua
│   │   ├── sh_localization.lua
│   │   ├── sh_module.lua
│   │   ├── sh_net.lua
│   │   ├── sh_notification.lua
│   │   ├── sh_option.lua
│   │   ├── sh_player.lua
│   │   ├── sh_rank.lua
│   │   ├── sh_relay.lua
│   │   ├── sh_schema.lua
│   │   ├── sh_type.lua
│   │   ├── sv_character.lua
│   │   ├── sv_database.lua
│   │   └── thirdparty/
│   ├── core/                -- Core systems
│   │   ├── sh_character.lua
│   │   ├── sh_chat.lua
│   │   ├── sh_commands.lua
│   │   ├── sh_config.lua
│   │   ├── sh_ents.lua
│   │   ├── sh_flags.lua
│   │   ├── sh_options.lua
│   │   └── sh_player.lua
│   ├── hooks/               -- Framework hooks
│   ├── networking/          -- Network handlers
│   ├── interface/           -- UI systems
│   ├── meta/                -- Meta-tables
│   └── util/                -- Utilities
│       ├── util_bots.lua
│       ├── util_core.lua
│       ├── util_file.lua
│       ├── util_find.lua
│       ├── util_print.lua
│       ├── util_sound.lua
│       ├── util_store.lua
│       └── util_text.lua
└── schema/                   -- Schema-specific content
    ├── boot.lua              -- Schema definition
    ├── config/               -- Configuration
    ├── factions/             -- Faction definitions
    │   ├── sh_admin.lua
    │   ├── sh_citizen.lua
    │   └── ...
    ├── items/                -- Item definitions
    │   ├── base/            -- Base items
    │   ├── weapons/         -- Weapons
    │   ├── food/            -- Food items
    │   └── sh_scrap_metal.lua
    ├── hooks/                -- Schema hooks
    │   ├── cl_hooks.lua
    │   ├── sh_hooks.lua
    │   └── sv_hooks.lua
    ├── meta/                 -- Schema meta-tables
    │   └── sh_character.lua
    ├── languages/            -- Localization
    │   ├── cl_english.lua
    │   └── ...
    ├── libraries/            -- Schema libraries
    ├── core/                -- Schema core systems
    ├── networking/          -- Schema networking
    └── interface/            -- Schema UI

```

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

### Get All Factions

Source: https://parallax-framework.github.io/parallax/manuals/05-API_REFERENCE

Retrieve a table containing all available factions in the system.

```lua
local factions = ax.faction:GetAll()
for id, faction in pairs(factions) do
    print(id, faction.name)
end
```

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

### Create and Configure ax.button

Source: https://parallax-framework.github.io/parallax/manuals/08-UI_THEME_GUIDELINES

Use to create a state-driven button with animated transitions. Size it to its contents and dock it appropriately.

```lua
local btn = panel:Add( "ax.button" )
btn:SetText( "Confirm" )
btn:SizeToContents()
btn:Dock( BOTTOM )
btn:DockMargin( 0, ax.util:ScreenScaleH( 8 ), 0, 0 )

```

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

### ax.theme:GetThemeId

Source: https://parallax-framework.github.io/parallax/libraries/ax/theme

Get the active theme identifier from client options.

```APIDOC
## ax.theme:GetThemeId

### Description
Get the active theme identifier from client options. Falls back to "dark" when the options library is unavailable.

### Returns
- **string**: themeId - The identifier of the active theme.
```

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

### Initialize Rank System

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/sh_rank

Initializes the rank system by loading all available rank files from the framework, modules, and schema directories. This is typically called during framework startup.

```lua
ax.rank:Initialize()
```

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

### ax.elements:Get

Source: https://parallax-framework.github.io/parallax/libraries/ax/elements

Retrieves an element from the registry using its unique identifier.

```APIDOC
## ax.elements:Get(uniqueID)

### Description
Retrieves an element from the registry using its unique identifier.

### Parameters
#### Path Parameters
- **uniqueID** (string) - Required - The unique identifier of the element to retrieve.
```

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

### ax.elements:GetDisplayEntity

Source: https://parallax-framework.github.io/parallax/api/framework/libraries/cl_elements

Gets the display entity associated with a given entity.

```APIDOC
## ax.elements:GetDisplayEntity(entity)

### Description
Gets the display entity associated with a given entity.

### Parameters
#### Path Parameters
- **entity** (Entity) - Required - The entity to get the display entity for.

### Returns
- **Entity** - The display entity.
```
Tokens:
Raw