### BridgeNet2 ReferenceBridge and Fire Example

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Using Identifiers.md

This example demonstrates how to reference a BridgeNet2 bridge and fire data with human-readable keys.

```APIDOC
## BridgeNet2.ReferenceBridge and :Fire()

### Description
This example shows the basic usage of `BridgeNet2.ReferenceBridge` to create a reference to a bridge and then use the `:Fire()` method to send data with human-readable keys.

### Method
`BridgeNet2.ReferenceBridge(string bridgeName)`
`bridgeReference:Fire(table data)`

### Endpoint
N/A (This is a client-side Lua API)

### Parameters
#### BridgeNet2.ReferenceBridge
- **bridgeName** (string) - Required - The name of the bridge to reference.

#### bridgeReference:Fire
- **data** (table) - Required - A table containing the data to send. Keys can be strings.

### Request Example
```lua
local sendSomeData = BridgeNet2.ReferenceBridge("sendSomeData")

sendSomeData:Fire({
	firstThingToSend = 5,
	anotherThing = false,
})
```

### Response
N/A (This is a client-side API for sending data)

```

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

### Server-Client Communication Example

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

This example illustrates how to set up and use BridgeNet2 for real-time, bidirectional communication between a server script and client scripts in a Roblox environment. It covers defining shared identifiers, creating server and client bridges, handling player requests, sending responses, and broadcasting messages to other players.

```APIDOC
## Complete Server-Client Communication Example

A comprehensive example demonstrating bidirectional communication between server and client using BridgeNet2's full feature set.

### Server Script

This script runs on the server and handles incoming requests from clients, processes them, and sends back responses or broadcasts messages.

#### Setup

1.  **Require BridgeNet2**: `local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)`
2.  **Define Identifiers**: Use `BridgeNet2.ReferenceIdentifier` for efficient serialization of common keys like `ACTION`, `DATA`, `SUCCESS`, `ERROR`.
3.  **Create Bridges**: Instantiate server bridges for different communication channels (e.g., `RequestBridge`, `ResponseBridge`, `BroadcastBridge`).

#### Request Handling

-   The `requestBridge:Connect` function listens for incoming requests from players.
-   Requests are processed based on the `ACTION` identifier.
-   **`getData`**: Returns player-specific data.
-   **`saveData`**: Saves provided player data.
-   **`broadcast`**: Sends a message to all other players.
-   Unknown actions result in an error response.

#### Response Handling

-   Responses are sent back to the specific player using `responseBridge:Fire(player, responseData)`.
-   Responses include `ACTION`, `SUCCESS` (boolean), and either `DATA` or `ERROR`.

#### Broadcasting

-   Messages intended for multiple clients are sent using `broadcastBridge:Fire(BridgeNet2.PlayersExcept({ player }), broadcastData)` to send to all players except the sender.

#### Player Removal

-   The `Players.PlayerRemoving` event is used to clean up player-specific data when a player leaves.

```lua
-- Server Script (ServerScriptService)
local Players = game:GetService("Players")
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Define shared identifiers for efficient serialization
local ACTION = BridgeNet2.ReferenceIdentifier("action")
local DATA = BridgeNet2.ReferenceIdentifier("data")
local SUCCESS = BridgeNet2.ReferenceIdentifier("success")
local ERROR = BridgeNet2.ReferenceIdentifier("error")

-- Create bridges
local requestBridge = BridgeNet2.ServerBridge("RequestBridge")
local responseBridge = BridgeNet2.ServerBridge("ResponseBridge")
local broadcastBridge = BridgeNet2.ServerBridge("BroadcastBridge")

-- Player data storage
local playerData = {}

-- Handle player requests
requestBridge:Connect(function(player, request)
    local action = request[ACTION]
    local data = request[DATA]

    if action == "getData" then
        -- Return player's saved data
        responseBridge:Fire(player, {
            [ACTION] = "getData",
            [SUCCESS] = true,
            [DATA] = playerData[player.UserId] or { coins = 0, level = 1 }
        })

    elseif action == "saveData" then
        -- Save player data
        playerData[player.UserId] = data
        responseBridge:Fire(player, {
            [ACTION] = "saveData",
            [SUCCESS] = true
        })

    elseif action == "broadcast" then
        -- Broadcast message to all other players
        broadcastBridge:Fire(BridgeNet2.PlayersExcept({ player }), {
            [ACTION] = "playerMessage",
            [DATA] = {
                sender = player.Name,
                message = data.message
            }
        })
    else
        responseBridge:Fire(player, {
            [ACTION] = action,
            [SUCCESS] = false,
            [ERROR] = "Unknown action"
        })
    end
end)

-- Clean up when players leave
Players.PlayerRemoving:Connect(function(player)
    playerData[player.UserId] = nil
end)
```

### Client Script

This script runs on the client and initiates requests to the server, listens for responses, and handles broadcasts from other players.

#### Setup

1.  **Require BridgeNet2**: `local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)`
2.  **Reference Identifiers**: Use the same `BridgeNet2.ReferenceIdentifier` instances as the server.
3.  **Connect to Bridges**: Instantiate client bridges that correspond to the server bridges (e.g., `RequestBridge`, `ResponseBridge`, `BroadcastBridge`).

#### Sending Requests

-   Requests are sent to the server using `requestBridge:Fire(requestData)`.
-   Requests must include an `ACTION` and optionally `DATA`.

#### Handling Responses

-   The `responseBridge:Connect` function listens for responses from the server.
-   Responses are checked for `SUCCESS`.
-   If successful, the `ACTION` is checked to determine how to handle the `DATA` (e.g., display loaded data, confirm save).
-   If unsuccessful, a warning is issued with the `ERROR` message.

#### Handling Broadcasts

-   The `broadcastBridge:Connect` function listens for messages broadcast from the server.
-   The `ACTION` is checked (e.g., `playerMessage`) to process the `DATA` accordingly (e.g., display the message and sender).

#### Example Usage

-   **Request Data**: `requestBridge:Fire({ [ACTION] = "getData", [DATA] = nil })`
-   **Save Data**: `requestBridge:Fire({ [ACTION] = "saveData", [DATA] = { coins = 100, level = 5 } })` (after a delay)
-   **Broadcast Message**: `requestBridge:Fire({ [ACTION] = "broadcast", [DATA] = { message = "Hello everyone!" } })` (after a further delay)

```lua
-- Client Script (StarterPlayerScripts)
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Reference the same identifiers
local ACTION = BridgeNet2.ReferenceIdentifier("action")
local DATA = BridgeNet2.ReferenceIdentifier("data")
local SUCCESS = BridgeNet2.ReferenceIdentifier("success")
local ERROR = BridgeNet2.ReferenceIdentifier("error")

-- Connect to bridges
local requestBridge = BridgeNet2.ClientBridge("RequestBridge")
local responseBridge = BridgeNet2.ClientBridge("ResponseBridge")
local broadcastBridge = BridgeNet2.ClientBridge("BroadcastBridge")

-- Handle responses from server
responseBridge:Connect(function(response)
    local action = response[ACTION]
    local success = response[SUCCESS]

    if success then
        if action == "getData" then
            local data = response[DATA]
            print("Loaded data - Coins:", data.coins, "Level:", data.level)
        elseif action == "saveData" then
            print("Data saved successfully!")
        end
    else
        warn("Request failed:", response[ERROR])
    end
end)

-- Handle broadcasts from other players
broadcastBridge:Connect(function(broadcast)
    if broadcast[ACTION] == "playerMessage" then
        local msgData = broadcast[DATA]
        print("[" .. msgData.sender .. "]:", msgData.message)
    end
end)

-- Request initial data from server
requestBridge:Fire({
    [ACTION] = "getData",
    [DATA] = nil
})

-- Example: Save data
task.delay(5, function()
    requestBridge:Fire({
        [ACTION] = "saveData",
        [DATA] = { coins = 100, level = 5 }
    })
end)

-- Example: Broadcast to other players
task.delay(10, function()
    requestBridge:Fire({
        [ACTION] = "broadcast",
        [DATA] = { message = "Hello everyone!" }
    })
end)
```
```

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

### Implement BridgeNet2 Server-Client Communication

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

This example demonstrates how to set up server-side request handlers and client-side listeners using BridgeNet2. It includes handling data retrieval, saving, and broadcasting messages to other players.

```lua
-- Server Script (ServerScriptService)
local Players = game:GetService("Players")
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local ACTION = BridgeNet2.ReferenceIdentifier("action")
local DATA = BridgeNet2.ReferenceIdentifier("data")
local SUCCESS = BridgeNet2.ReferenceIdentifier("success")
local ERROR = BridgeNet2.ReferenceIdentifier("error")

local requestBridge = BridgeNet2.ServerBridge("RequestBridge")
local responseBridge = BridgeNet2.ServerBridge("ResponseBridge")
local broadcastBridge = BridgeNet2.ServerBridge("BroadcastBridge")

local playerData = {}

requestBridge:Connect(function(player, request)
    local action = request[ACTION]
    local data = request[DATA]

    if action == "getData" then
        responseBridge:Fire(player, {
            [ACTION] = "getData",
            [SUCCESS] = true,
            [DATA] = playerData[player.UserId] or { coins = 0, level = 1 }
        })
    elseif action == "saveData" then
        playerData[player.UserId] = data
        responseBridge:Fire(player, {
            [ACTION] = "saveData",
            [SUCCESS] = true
        })
    elseif action == "broadcast" then
        broadcastBridge:Fire(BridgeNet2.PlayersExcept({ player }), {
            [ACTION] = "playerMessage",
            [DATA] = {
                sender = player.Name,
                message = data.message
            }
        })
    else
        responseBridge:Fire(player, {
            [ACTION] = action,
            [SUCCESS] = false,
            [ERROR] = "Unknown action"
        })
    end
end)

Players.PlayerRemoving:Connect(function(player)
    playerData[player.UserId] = nil
end)
```

```lua
-- Client Script (StarterPlayerScripts)
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local ACTION = BridgeNet2.ReferenceIdentifier("action")
local DATA = BridgeNet2.ReferenceIdentifier("data")
local SUCCESS = BridgeNet2.ReferenceIdentifier("success")
local ERROR = BridgeNet2.ReferenceIdentifier("error")

local requestBridge = BridgeNet2.ClientBridge("RequestBridge")
local responseBridge = BridgeNet2.ClientBridge("ResponseBridge")
local broadcastBridge = BridgeNet2.ClientBridge("BroadcastBridge")

responseBridge:Connect(function(response)
    local action = response[ACTION]
    local success = response[SUCCESS]

    if success then
        if action == "getData" then
            local data = response[DATA]
            print("Loaded data - Coins:", data.coins, "Level:", data.level)
        elseif action == "saveData" then
            print("Data saved successfully!")
        end
    else
        warn("Request failed:", response[ERROR])
    end
end)

broadcastBridge:Connect(function(broadcast)
    if broadcast[ACTION] == "playerMessage" then
        local msgData = broadcast[DATA]
        print("[" .. msgData.sender .. "]: " .. msgData.message)
    end
end)

requestBridge:Fire({
    [ACTION] = "getData",
    [DATA] = nil
})

task.delay(5, function()
    requestBridge:Fire({
        [ACTION] = "saveData",
        [DATA] = { coins = 100, level = 5 }
    })
end)

task.delay(10, function()
    requestBridge:Fire({
        [ACTION] = "broadcast",
        [DATA] = { message = "Hello everyone!" }
    })
end)
```

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

### Install BridgeNet2 via Wally

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Configuration for adding BridgeNet2 as a dependency in a Roblox project using the Wally package manager.

```toml
[dependencies]
BridgeNet2 = "ffrostfall/bridgenet2@1.0.0"
```

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

### Install BridgeNet2 via Wally

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Installation.md

Configures the BridgeNet2 dependency within a wally.toml file. This is the recommended approach for projects using the Wally package manager.

```toml
[dependencies]
BridgeNet2 = "ffrostfall/bridgenet2@latest"
```

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

### BridgeNet2 Identifier Optimization

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Using Identifiers.md

This example shows how to use BridgeNet2 identifiers to optimize bandwidth by replacing string keys with efficient identifiers.

```APIDOC
## BridgeNet2.ReferenceIdentifier for Bandwidth Optimization

### Description
This example demonstrates how to use `BridgeNet2.ReferenceIdentifier` to create efficient, short identifiers for data fields. This significantly reduces bandwidth usage compared to sending full string keys.

### Method
`BridgeNet2.ReferenceBridge(string bridgeName)`
`BridgeNet2.ReferenceIdentifier(string identifierName)`
`bridgeReference:Fire(table data)`

### Endpoint
N/A (This is a client-side Lua API)

### Parameters
#### BridgeNet2.ReferenceBridge
- **bridgeName** (string) - Required - The name of the bridge to reference.

#### BridgeNet2.ReferenceIdentifier
- **identifierName** (string) - Required - The human-readable name of the identifier.

#### bridgeReference:Fire
- **data** (table) - Required - A table containing the data to send. Keys should be the identifier objects returned by `BridgeNet2.ReferenceIdentifier`.

### Request Example
```lua
local sendSomeData = BridgeNet2.ReferenceBridge("sendSomeData")

local firstThingToSend = BridgeNet2.ReferenceIdentifier("firstThingToSend")
local anotherThing = BridgeNet2.ReferenceIdentifier("anotherThing")

sendSomeData:Fire({
	[firstThingToSend] = 5,
	[anotherThing] = false,
})
```

### Response
N/A (This is a client-side API for sending data)

```

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

### BridgeNet2 Initialization

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Demonstrates how to initialize BridgeNet2 on the server and client, and how to reference or create specific bridges.

```APIDOC
## BridgeNet2 Initialization

### Description
Initializes and references bridges using BridgeNet2. `ReferenceBridge` works on both client and server, while `ServerBridge` and `ClientBridge` provide type-safe access for their respective environments.

### Methods
- `BridgeNet2.ReferenceBridge(bridgeName: string)`: Creates or references a bridge by name. Must match on client and server.
- `BridgeNet2.ServerBridge(bridgeName: string)`: Creates a server-side bridge with type safety.
- `BridgeNet2.ClientBridge(bridgeName: string, [timeout: number]?)`: Creates a client-side bridge, yielding until available. An optional timeout can be provided.

### Server Script Example
```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Create/reference a bridge using the same string on both client and server
local myBridge = BridgeNet2.ReferenceBridge("PlayerDataBridge")

-- Create a server bridge with proper server-side typing
local inventoryBridge = BridgeNet2.ServerBridge("InventoryBridge")
```

### Client Script Example
```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Create a client bridge (yields until bridge is found)
-- Optional second parameter sets timeout in seconds
local inventoryBridge = BridgeNet2.ClientBridge("InventoryBridge", 10)
```
```

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

### Initialize BridgeNet2 via Standalone

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

How to require the BridgeNet2 module after inserting the standalone .rbxm file into ReplicatedStorage.

```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
```

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

### Initialize BridgeNet2 Bridges

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

Demonstrates how to create a bridge reference using generic or type-specific functions. Note that ClientBridge and ReferenceBridge on the client may yield.

```lua
local myFirstBridge = BridgeNet2.ReferenceBridge("myFirstBridge")
-- Type-specific versions for better autocomplete
local myFirstBridgeClientVersion = BridgeNet2.ClientBridge("myFirstBridge")
local myFirstBridgeServerVersion = BridgeNet2.ServerBridge("myFirstBridge")
```

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

### Fire Data from Client

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

Demonstrates how to send data from the client to the server using the Fire method without a target parameter.

```lua
local firstClientBridge = BridgeNet2.ClientBridge("myFirstBridge")
firstClientBridge:Fire("Hey, server!")
```

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

### Connect to Bridge Events

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

Shows how to listen for incoming data on both the client and the server using the Connect method.

```lua
-- Client side
myFirstBridge:Connect(function(message)
	print(message)
end)
-- Server side
myFirstBridge:Connect(function(player, message)
	print(`{player.Name} said {message}`)
end)
```

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

### Optimize bandwidth with ReferenceIdentifier

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Shows how to map string keys to compressed identifiers to reduce payload size. This technique replaces standard string keys with 1-3 byte identifiers, synchronized automatically between client and server.

```lua
-- Server Script: Define identifiers for efficient data keys
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Create identifiers for commonly used keys
local POSITION = BridgeNet2.ReferenceIdentifier("position")
local ROTATION = BridgeNet2.ReferenceIdentifier("rotation")
local VELOCITY = BridgeNet2.ReferenceIdentifier("velocity")
local HEALTH = BridgeNet2.ReferenceIdentifier("health")
local TIMESTAMP = BridgeNet2.ReferenceIdentifier("timestamp")

local syncBridge = BridgeNet2.ServerBridge("EntitySyncBridge")

-- Use identifiers as table keys instead of strings
syncBridge:Fire(BridgeNet2.AllPlayers(), {
    [POSITION] = Vector3.new(100, 50, 200),
    [ROTATION] = CFrame.Angles(0, math.pi / 2, 0),
    [VELOCITY] = Vector3.new(10, 0, 5),
    [HEALTH] = 85,
    [TIMESTAMP] = os.clock()
})
```

```lua
-- Client Script: Use the same identifiers to receive data
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Reference the same identifiers (yields until available)
local POSITION = BridgeNet2.ReferenceIdentifier("position")
local HEALTH = BridgeNet2.ReferenceIdentifier("health")

local syncBridge = BridgeNet2.ClientBridge("EntitySyncBridge")

syncBridge:Connect(function(data)
    -- Access data using identifiers
    local entityPosition = data[POSITION]
    local entityHealth = data[HEALTH]

    print("Entity at:", entityPosition)
    print("Entity health:", entityHealth)
end)
```

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

### Fire Data to Players

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

Shows how to send data from the server to a specific player, all players, a subset of players, or excluding specific players.

```lua
local myFirstBridge = BridgeNet2.ReferenceBridge("myFirstBridge")
-- Fire to one player
myFirstBridge:Fire(player, "Hello!")
-- Fire to all
myFirstBridge:Fire(BridgeNet2.AllPlayers(), "Hello everyone!")
-- Fire to specific array
myFirstBridge:Fire(BridgeNet2.Players({ playerA, playerB }), "Hello special players!")
-- Fire to all except specific
myFirstBridge:Fire(BridgeNet2.PlayersExcept({ badPlayer }), "Everyone except badPlayer gets this!")
```

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

### Bridge:Fire Method (Server)

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Explains how to send data from the server to clients using various targeting options.

```APIDOC
## Bridge:Fire (Server)

### Description
Sends data from the server to one or more players. The first parameter specifies the target player(s), and the second parameter is the data payload (must be a single value, typically a table).

### Method
`bridge:Fire(targets, data)`

### Parameters
- **targets**: `Player | BridgeNet2.AllPlayers | BridgeNet2.Players | BridgeNet2.PlayersExcept` - Specifies the recipient(s) of the data.
- **data**: `any` - The data payload to send. Must be a single value (e.g., a table).

### Target Options
- `BridgeNet2.AllPlayers()`: Targets all players.
- `BridgeNet2.Players(playerList: {Player})`: Targets a specific list of players.
- `BridgeNet2.PlayersExcept(playerList: {Player})`: Targets all players except those in the provided list.

### Request Example
```lua
-- Server Script
local Players = game:GetService("Players")
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local combatBridge = BridgeNet2.ServerBridge("CombatBridge")

-- Fire to a single player
local targetPlayer = Players:FindFirstChild("Player1")
combatBridge:Fire(targetPlayer, {
    action = "damage",
    amount = 25,
    source = "Enemy"
})

-- Fire to all players using AllPlayers()
combatBridge:Fire(BridgeNet2.AllPlayers(), {
    action = "worldEvent",
    eventType = "bossSpawn",
    position = Vector3.new(100, 0, 200)
})

-- Fire to specific players using Players()
local specialPlayers = { Players.Player1, Players.Player2 }
combatBridge:Fire(BridgeNet2.Players(specialPlayers), {
    action = "secretMessage",
    content = "You found the hidden area!"
})

-- Fire to everyone except certain players using PlayersExcept()
local excludedPlayers = { Players.AFK_Player }
combatBridge:Fire(BridgeNet2.PlayersExcept(excludedPlayers), {
    action = "notification",
    message = "Active players only!"
})
```
```

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

### Create Client-Side Bridge

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Initializes a bridge for client-side usage. This function yields until the bridge is available on the client, with an optional timeout parameter.

```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
local inventoryBridge = BridgeNet2.ClientBridge("InventoryBridge", 10)
```

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

### Fire Data from Server

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Demonstrates sending data from the server to specific players, all players, or filtered groups using BridgeNet2's targeting methods.

```lua
local Players = game:GetService("Players")
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
local combatBridge = BridgeNet2.ServerBridge("CombatBridge")

-- Fire to a single player
combatBridge:Fire(Players:FindFirstChild("Player1"), { action = "damage", amount = 25 })

-- Fire to all players
combatBridge:Fire(BridgeNet2.AllPlayers(), { action = "worldEvent", eventType = "bossSpawn" })

-- Fire to specific players
combatBridge:Fire(BridgeNet2.Players({Players.Player1, Players.Player2}), { action = "secretMessage" })

-- Fire to everyone except specific players
combatBridge:Fire(BridgeNet2.PlayersExcept({Players.AFK_Player}), { action = "notification" })
```

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

### Connect to Bridge Events

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Registers a callback to handle incoming data. Server-side callbacks receive the player and data, while client-side callbacks receive only the data.

```lua
-- Server side
local requestBridge = BridgeNet2.ServerBridge("RequestBridge")
requestBridge:Connect(function(player, data)
    print(player.Name .. " sent request:", data)
end)

-- Client side
local updateBridge = BridgeNet2.ClientBridge("GameUpdateBridge")
updateBridge:Connect(function(data)
    print("Received update from server:", data)
end)
```

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

### Create Server-Side Bridge

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Initializes a bridge specifically for server-side usage, providing enhanced autocomplete and type safety for server-specific methods.

```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
local inventoryBridge = BridgeNet2.ServerBridge("InventoryBridge")
```

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

### Reference Bridge and Fire Data with Identifiers (Lua)

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Using Identifiers.md

This snippet demonstrates how to use BridgeNet2 to reference a bridge and fire data. It shows the initial method of sending data with string keys and then the optimized method using referenced identifiers for keys. This reduces bandwidth by replacing long strings with short identifiers.

```lua
local sendSomeData = BridgeNet2.ReferenceBridge("sendSomeData")

local firstThingToSend = BridgeNet2.ReferenceIdentifier("firstThingToSend")
local anotherThing = BridgeNet2.ReferenceIdentifier("anotherThing")

sendSomeData:Fire({
	[firstThingToSend] = 5,
	[anotherThing] = false,
})
```

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

### Bridge:Connect

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Registers a callback function to handle incoming data from the network.

```APIDOC
## [METHOD] Bridge:Connect

### Description
Registers a listener for incoming data. The callback signature differs between server and client.

### Parameters
- **callback** (Function) - Required - The function to execute when data is received.

### Callback Signatures
- **Server**: function(player, data)
- **Client**: function(data)

### Response Example
-- Server
bridge:Connect(function(player, data) print(player.Name, data) end)
```

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

### Fire Data from Client to Server

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Sends data from the client to the server using a defined bridge. This method does not require a player parameter as the server is the implicit target.

```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
local actionBridge = BridgeNet2.ClientBridge("PlayerActionBridge")
actionBridge:Fire({
    actionType = "jump",
    timestamp = os.clock(),
    position = game.Players.LocalPlayer.Character.HumanoidRootPart.Position
})
```

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

### Debug network traffic with Bridge Logging

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Explains how to enable the Logging property on a bridge to inspect outgoing and incoming data, including byte count estimates. This is a powerful tool for diagnosing network performance and data structure issues.

```lua
-- Server Script
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local debugBridge = BridgeNet2.ServerBridge("DebugBridge")

-- Enable logging to see all network traffic through this bridge
debugBridge.Logging = true

debugBridge:Fire(BridgeNet2.AllPlayers(), {
    testMessage = "Hello",
    number = 42
})

-- Disable logging when done debugging
debugBridge.Logging = false
```

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

### Initial Data Sending Without Identifiers (Lua)

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Using Identifiers.md

This code snippet illustrates the basic way to send data using BridgeNet2 without employing the identifier optimization. It directly uses string keys for data fields, which is less efficient in terms of bandwidth compared to using referenced identifiers.

```lua
local sendSomeData = BridgeNet2.ReferenceBridge("sendSomeData")

sendSomeData:Fire({
	firstThingToSend = 5,
	anotherThing = false,
})
```

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

### Client-Side Identifier Synchronization

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Technical Details/Identifiers.md

This snippet illustrates how the client initializes its local identifier maps by iterating over existing attributes on the RemoteEvent storage. This ensures the client can correctly deserialize incoming network packets.

```luau
for id, value in identifierStorage:GetAttributes() do
	fullIdentifierMap[id] = value
	compressedIdentifierMap[value] = id
end
```

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

### Targeting Players for Communication

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Demonstrates how to broadcast data to all players or a specific subset of players using BridgeNet2 symbols.

```lua
-- Broadcast to all
local announcementBridge = BridgeNet2.ServerBridge("AnnouncementBridge")
announcementBridge:Fire(BridgeNet2.AllPlayers(), { message = "Restarting!" })

-- Target specific players
local teamBridge = BridgeNet2.ServerBridge("TeamBridge")
teamBridge:Fire(BridgeNet2.Players({player1, player2}), { message = "Hello team!" })
```

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

### Server: Sending a Table as a Single Argument with BridgeNet2

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

This server-side Lua code demonstrates how to send a table containing multiple values to clients using BridgeNet2. It references a specific bridge and fires the table to all players. The table can contain various data types.

```lua
local myFirstBridge = BridgeNet2.ReferenceBridge("myFirstBridge")

myFirstBridge:Fire(BridgeNet2.AllPlayers(), {
	"This is a fully intact array!",
	"Tables can store any data you need.",
	"You don't need multiple arguments if you can use tables."
})
```

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

### Client: Receiving a Table Sent via BridgeNet2

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Tutorials/Getting Started.md

This client-side Lua code shows how to receive a table that was sent from the server using BridgeNet2. It connects to the specified bridge and prints the received table to the output.

```lua
local myFirstBridge = BridgeNet2.ReferenceBridge("myFirstBridge")

myFirstBridge:Connect(function(array)
	print(array) -- Prints the array we sent from the server
end)
```

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

### Register One-Time Listeners

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Registers a callback that automatically disconnects after the first invocation. This is ideal for initialization or waiting for a specific response.

```lua
local joinBridge = BridgeNet2.ServerBridge("PlayerJoinBridge")
joinBridge:Once(function(player, data)
    print(player.Name .. " sent their first join data")
end)
```

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

### BridgeNet2.ReferenceIdentifier

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Creates or references a compressed identifier for string keys, optimizing bandwidth by reducing key size from multiple bytes to 1-3 bytes. Identifiers are automatically synchronized.

```APIDOC
## BridgeNet2.ReferenceIdentifier

### Description
Creates or references an identifier that compresses string keys to 1-3 bytes for bandwidth optimization. Identifiers are synchronized between server and client automatically.

### Method
`ReferenceIdentifier` (constructor)

### Endpoint
N/A (This is a utility function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```lua
-- Server Script: Define identifiers for efficient data keys
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Create identifiers for commonly used keys
local POSITION = BridgeNet2.ReferenceIdentifier("position")
local ROTATION = BridgeNet2.ReferenceIdentifier("rotation")

local syncBridge = BridgeNet2.ServerBridge("EntitySyncBridge")

-- Use identifiers as table keys instead of strings
syncBridge:Fire(BridgeNet2.AllPlayers(), {
    [POSITION] = Vector3.new(100, 50, 200),
    [ROTATION] = CFrame.Angles(0, math.pi / 2, 0)
})
```

### Response
Returns a unique identifier object.

### Response Example
```lua
-- Client Script: Use the same identifiers to receive data
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

-- Reference the same identifiers (yields until available)
local POSITION = BridgeNet2.ReferenceIdentifier("position")

local syncBridge = BridgeNet2.ClientBridge("EntitySyncBridge")

syncBridge:Connect(function(data)
    -- Access data using identifiers
    local entityPosition = data[POSITION]
    print("Entity at:", entityPosition)
end)
```
```

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

### Reference a Bridge

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Creates or retrieves a bridge object by name. This method is universal for both client and server, though client calls will yield until the bridge is available.

```lua
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)
local myBridge = BridgeNet2.ReferenceBridge("PlayerDataBridge")
```

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

### Bridge:Fire

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Sends data from the client to the server or server to the client. On the server, it supports targeting specific players or all players.

```APIDOC
## [METHOD] Bridge:Fire

### Description
Sends data across the network. When called on the client, it sends data to the server. When called on the server, it requires a target (player, array of players, or AllPlayers) followed by the data.

### Parameters
- **target** (Player | Array<Player> | Symbol) - Optional (Server only) - The recipient(s) of the data.
- **data** (Any) - Required - The payload to send (table, string, number, nil, etc.).

### Request Example
-- Client
actionBridge:Fire({ actionType = "jump", timestamp = os.clock() })

-- Server
announcementBridge:Fire(BridgeNet2.AllPlayers(), { message = "Hello!" })
```

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

### Exclude players from broadcasts using PlayersExcept

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Demonstrates how to use BridgeNet2.PlayersExcept to send data to all players except a specific subset. This is primarily used for client-side prediction to avoid echoing data back to the sender.

```lua
-- Server Script
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local movementBridge = BridgeNet2.ServerBridge("MovementBridge")

-- When a player moves, broadcast to everyone except them (for client-side prediction)
movementBridge:Connect(function(player, moveData)
    -- Validate movement on server...

    -- Send movement update to all other players (exclude the sender)
    movementBridge:Fire(BridgeNet2.PlayersExcept({ player }), {
        playerId = player.UserId,
        position = moveData.position,
        velocity = moveData.velocity,
        timestamp = moveData.timestamp
    })
end)
```

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

### Bridge:Once

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Registers a one-time callback that automatically disconnects after the first invocation.

```APIDOC
## [METHOD] Bridge:Once

### Description
Useful for initialization or waiting for a single specific response. The listener is removed immediately after the first execution.

### Parameters
- **callback** (Function) - Required - The function to execute once.
```

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

### Server-Side Identifier Registration

Source: https://github.com/ffrostfall/bridgenet2/blob/master/docs/Technical Details/Identifiers.md

This snippet demonstrates how BridgeNet2 increments an identifier counter and packs it into a binary format using string.pack. It stores the mapping as an attribute on the RemoteEvent for client synchronization.

```luau
local packed = if identifierCount <= 255
	then string.pack("B", identifierCount)
	else string.pack("H", identifierCount)

identifierCount += 1
identifierStorage:SetAttribute(identifierName, packed)

fullIdentifierMap[identifierName] = packed
compressedIdentifierMap[packed] = identifierName
```

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

### Bridge.Logging

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Enables or disables logging for a specific BridgeNet2 bridge, providing detailed network traffic information including data content and byte count estimates for debugging purposes.

```APIDOC
## Bridge.Logging

### Description
Enable or disable logging for a specific bridge to debug network traffic. When enabled, BridgeNet2 logs all data sent/received with byte count estimates.

### Method
Set `Bridge.Logging` property to `true` or `false`.

### Endpoint
N/A (This is a property of a bridge instance)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```lua
-- Server Script
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local debugBridge = BridgeNet2.ServerBridge("DebugBridge")

-- Enable logging to see all network traffic through this bridge
debugBridge.Logging = true

debugBridge:Fire(BridgeNet2.AllPlayers(), {
    testMessage = "Hello",
    number = 42
})
-- Output: [BridgeNet2] DebugBridge -> AllPlayers: {testMessage = "Hello", number = 42} (28B)

-- Disable logging when done debugging
debugBridge.Logging = false
```

### Response
None (This is a property to control logging behavior)

### Response Example
None
```

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

### BridgeNet2.PlayersExcept

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Returns a symbol to exclude specific players when firing data. Useful for client-side prediction where the originating player should not receive their own update.

```APIDOC
## BridgeNet2.PlayersExcept

### Description
Returns a symbol that instructs the server bridge to fire data to all players except those specified. Ideal for client-side prediction where you want to exclude the originating player.

### Method
`Fire` (when used with `BridgeNet2.PlayersExcept`)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **players** (table) - Required - A table of player objects to exclude from receiving the data.

### Request Example
```lua
-- Server Script
local BridgeNet2 = require(game.ReplicatedStorage.BridgeNet2)

local movementBridge = BridgeNet2.ServerBridge("MovementBridge")

movementBridge:Connect(function(player, moveData)
    -- Send movement update to all other players (exclude the sender)
    movementBridge:Fire(BridgeNet2.PlayersExcept({ player }), {
        playerId = player.UserId,
        position = moveData.position,
        velocity = moveData.velocity,
        timestamp = moveData.timestamp
    })
end)
```

### Response
None (This is a method for controlling data distribution)

### Response Example
None
```

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

### BridgeNet2 Targeting Symbols

Source: https://context7.com/ffrostfall/bridgenet2/llms.txt

Special symbols used to define the scope of data transmission on the server.

```APIDOC
## [SYMBOL] BridgeNet2.AllPlayers / BridgeNet2.Players

### Description
Used as the first argument in Server-side Bridge:Fire to define recipients.

### Methods
- **BridgeNet2.AllPlayers()**: Targets everyone connected.
- **BridgeNet2.Players(table)**: Targets a specific list of Player objects.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.