### Godot Game Scene Setup with TubeClient and MultiplayerSpawner

Source: https://context7.com/koopmyers/tube/llms.txt

This script sets up the main game scene, configuring the MultiplayerSpawner for player instantiation and handling peer connections/disconnections. It utilizes TubeClient for network management and Godot's high-level multiplayer API for RPCs and spawning.

```gdscript
extends Node2D

@onready var tube_client: TubeClient = $TubeClient
@onready var spawner: MultiplayerSpawner = $MultiplayerSpawner
@onready var players_container: Node2D = $Players

const PLAYER_SCENE = preload("res://player.tscn")

func _ready():
    # Configure spawner
    spawner.spawn_path = players_container.get_path()
    spawner.spawn_function = spawn_player

    tube_client.peer_connected.connect(_on_peer_connected)
    tube_client.peer_disconnected.connect(_on_peer_disconnected)
    tube_client.session_created.connect(_spawn_local_player)
    tube_client.session_joined.connect(_spawn_local_player)

func _spawn_local_player():
    # Spawn the local player
    await get_tree().process_frame  # Wait for multiplayer setup
    var player_id = multiplayer.get_unique_id()
    spawn_player_request.rpc_id(1, player_id)

@rpc("any_peer", "call_local", "reliable")
func spawn_player_request(player_id: int):
    # Server spawns player for all clients
    if not tube_client.is_server:
        return

    var spawn_position = Vector2(randf_range(100, 900), randf_range(100, 500))
    spawner.spawn([player_id, spawn_position])

func spawn_player(data: Array):
    var player_id = data[0]
    var spawn_pos = data[1]

    var player = PLAYER_SCENE.instantiate()
    player.name = str(player_id)
    player.position = spawn_pos
    players_container.add_child(player, true)

    return player

func _on_peer_disconnected(peer_id: int):
    # Remove disconnected player
    var player = players_container.get_node_or_null(str(peer_id))
    if player:
        player.queue_free()

```

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

### Create a Game Session with TubeClient

Source: https://github.com/koopmyers/tube/blob/main/README.md

This snippet demonstrates how to initiate a new game session. The player calling this function becomes the server and gains access to the session ID. It requires a TubeClient instance and a Label node to display the session ID.

```GDScript
@onready var label: Label = $Label
@onready var tube_client: TubeClient = $TubeClient


func _on_button_pressed():
    tube_client.create_session()
    label.text = tube_client.session_id
```

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

### Join an Existing Game Session with TubeClient

Source: https://github.com/koopmyers/tube/blob/main/README.md

This snippet shows how to join an existing game session using a provided session ID. It requires a TubeClient instance and a LineEdit node to input the session ID. The session ID should be obtained from the server through an external channel.

```GDScript
@onready var line_edit: LineEdit = $LineEdit

func _on_button_pressed():
    tube_client.join_session(line_edit.text)
```

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

### Create and Join Multiplayer Sessions with TubeClient

Source: https://context7.com/koopmyers/tube/llms.txt

This snippet outlines the core functionality for establishing multiplayer sessions using TubeClient. It details how one player creates a session (becoming the server) and how other players join using a shared session ID. The code also manages UI states based on the session's status.

```gdscript
extends Control

@onready var tube_client: TubeClient = $TubeClient
@onready var session_input: LineEdit = $SessionInput
@onready var create_button: Button = $CreateButton
@onready var join_button: Button = $JoinButton
@onready var leave_button: Button = $LeaveButton

func _ready():
    create_button.pressed.connect(_on_create_pressed)
    join_button.pressed.connect(_on_join_pressed)
    leave_button.pressed.connect(_on_leave_pressed)

    tube_client.session_created.connect(_on_session_created)
    tube_client.session_joined.connect(_on_session_joined)

    # Initially only show create/join options
    _update_ui_state()

func _on_create_pressed():
    # Create a new session (this player becomes the server)
    tube_client.create_session()
    create_button.disabled = true
    join_button.disabled = true

func _on_join_pressed():
    # Join existing session using entered session ID
    var session_id = session_input.text.strip_edges().to_upper()

    if session_id.length() != 5:
        printerr("Session ID must be exactly 5 characters")
        return

    tube_client.join_session(session_id)
    create_button.disabled = true
    join_button.disabled = true

func _on_session_created():
    # Display session ID for sharing with other players
    session_input.text = tube_client.session_id
    session_input.editable = false
    leave_button.disabled = false

    # Player can copy this ID and share via Discord, WhatsApp, etc.
    DisplayServer.clipboard_set(tube_client.session_id)
    print("Session ID copied to clipboard: ", tube_client.session_id)

func _on_session_joined():
    session_input.editable = false
    leave_button.disabled = false

func _on_leave_pressed():
    # Leave current session (if server, closes for all players)
    tube_client.leave_session()
    _update_ui_state()

func _update_ui_state():
    var is_idle = tube_client.state == TubeClient.State.IDLE
    create_button.disabled = not is_idle
    join_button.disabled = not is_idle
    leave_button.disabled = is_idle
    session_input.editable = is_idle

```

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

### TubeContext Resource Configuration

Source: https://context7.com/koopmyers/tube/llms.txt

Configure the TubeContext resource for multiplayer session management, including app identification, tracker servers, and STUN/TURN servers.

```APIDOC
## TubeContext Resource Configuration

A resource class that stores all configuration required for multiplayer session management, including app identification, tracker servers, and STUN/TURN servers for WebRTC.

### Method
N/A (Resource Configuration)

### Endpoint
N/A (Resource Configuration)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```gdscript
# Create a new TubeContext resource (in Godot: FileSystem -> Create New -> TubeContext)
var context = TubeContext.new()

# Generate and set a unique 15-character App ID (must be identical across all game instances)
context.app_id = "MyGame123!@#$%"  # Must be exactly 15 ASCII characters

# Configure session ID character set (used to generate 5-character session IDs)
context.session_id_characters_set = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"  # Excludes ambiguous chars

# Add WebTorrent tracker servers for online signaling
context.trackers_urls = [
    "wss://tracker.openwebtorrent.com",
    "wss://tracker.files.fm:7073/announce",
    "wss://tracker.btorrent.xyz/"
]

# Add STUN servers for NAT traversal
context.stun_servers_urls = [
    "stun:stun.l.google.com:19302",
    "stun:stun.cloudflare.com:3478"
]

# Optional: Add TURN server with credentials for relay fallback
context.turn_servers = [{
    "urls": "turn:turn.example.com:3478",
    "username": "user123",
    "credential": "pass456"
}]

# Validate configuration
if context.is_valid():
    print("Context is properly configured")
else:
    printerr("Invalid context configuration")

# Generate a random session ID
var session_id = context.generate_session_id()  # Returns 5-character string like "A3K9P"
```

### Response
N/A (Resource Configuration)

### Response Example
N/A (Resource Configuration)
```

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

### Configure TubeContext Resource for Multiplayer

Source: https://context7.com/koopmyers/tube/llms.txt

This snippet demonstrates how to configure the TubeContext resource, which holds all necessary settings for managing a multiplayer session. It includes setting the application ID, session ID character set, tracker URLs for signaling, and STUN/TURN server configurations for NAT traversal. The configuration must be identical across all game instances participating in the same session. Validation is performed using the `is_valid()` method.

```gdscript
var context = TubeContext.new()

context.app_id = "MyGame123!@#$%"  # Must be exactly 15 ASCII characters

context.session_id_characters_set = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"

context.trackers_urls = [
    "wss://tracker.openwebtorrent.com",
    "wss://tracker.files.fm:7073/announce",
    "wss://tracker.btorrent.xyz/"
]

context.stun_servers_urls = [
    "stun:stun.l.google.com:19302",
    "stun:stun.cloudflare.com:3478"
]

context.turn_servers = [{
    "urls": "turn:turn.example.com:3478",
    "username": "user123",
    "credential": "pass456"
}]

if context.is_valid():
    print("Context is properly configured")
else:
    printerr("Invalid context configuration")

var session_id = context.generate_session_id()
```

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

### Configure TubeClient Node in Godot

Source: https://context7.com/koopmyers/tube/llms.txt

This snippet demonstrates how to initialize and configure a TubeClient node within a Godot scene. It covers setting the context, optional timeout settings, assigning a custom multiplayer root node, and connecting various session-related signals.

```gdscript
extends Control

@onready var tube_client: TubeClient = $TubeClient
@onready var session_label: Label = $SessionLabel
@onready var status_label: Label = $StatusLabel

func _ready():
    # Assign the configured context
    tube_client.context = preload("res://tube_context.tres")

    # Configure optional timeout settings
    tube_client.peer_signaling_timeout = 3.0  # Seconds before retry
    tube_client.peer_signaling_max_attempts = 5  # Max connection attempts

    # Optional: Set custom multiplayer root node (defaults to scene tree root)
    tube_client.multiplayer_root_node = get_node("/root/GameWorld")

    # Connect signals
    tube_client.session_created.connect(_on_session_created)
    tube_client.session_joined.connect(_on_session_joined)
    tube_client.session_left.connect(_on_session_left)
    tube_client.peer_connected.connect(_on_peer_connected)
    tube_client.peer_disconnected.connect(_on_peer_disconnected)
    tube_client.peer_unstabilized.connect(_on_peer_unstabilized)
    tube_client.peer_stabilized.connect(_on_peer_stabilized)
    tube_client.error_raised.connect(_on_error_raised)

func _on_session_created():
    session_label.text = "Session ID: " + tube_client.session_id
    status_label.text = "Waiting for players..."
    print("Created session as server, peer_id: ", tube_client.peer_id)
    print("is_server: ", tube_client.is_server)

func _on_session_joined():
    status_label.text = "Connected to session!"
    print("Joined session, peer_id: ", tube_client.peer_id)

func _on_session_left():
    session_label.text = ""
    status_label.text = "Disconnected"
    print("Left session or server closed")

func _on_peer_connected(peer_id: int):
    print("Peer connected: ", peer_id)
    status_label.text = "Players: " + str(tube_client.multiplayer_peer.get_peers().size() + 1)

func _on_peer_disconnected(peer_id: int):
    print("Peer disconnected: ", peer_id)

func _on_peer_unstabilized(peer_id: int):
    print("Connection unstable with peer: ", peer_id)

func _on_peer_stabilized(peer_id: int):
    print("Connection restored with peer: ", peer_id)

func _on_error_raised(code: TubeClient.SessionError, message: String):
    printerr("Error [", code, "]: ", message)
    status_label.text = "Error: " + message

```

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

### Implementing Multiplayer Game Logic with RPCs

Source: https://context7.com/koopmyers/tube/llms.txt

Integrates with Godot's high-level multiplayer API for synchronized gameplay using Remote Procedure Calls (RPCs) and multiplayer nodes. This script handles player input, movement synchronization, damage systems, and chat messages across peers. It requires a TubeClient node and utilizes `CharacterBody2D` for movement.

```gdscript
extends CharacterBody2D

@onready var tube_client: TubeClient = $ "/root/GameWorld/TubeClient"

# Synchronized player properties
@export var player_name: String = ""
var puppet_position: Vector2
var puppet_velocity: Vector2

func _ready():
    # Set authority based on peer ownership
    set_multiplayer_authority(name.to_int())

    if is_multiplayer_authority():
        # This is the local player
        player_name = "Player_" + str(multiplayer.get_unique_id())
    else:
        # This is a remote player puppet
        set_physics_process(false)

func _physics_process(delta):
    if not is_multiplayer_authority():
        # Interpolate puppet movement
        position = lerp(position, puppet_position, 0.3)
        velocity = puppet_velocity
        return

    # Local player input handling
    var input_dir = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
    velocity = input_dir * 300

    move_and_slide()

    # Sync position to all peers (authority only)
    if position != puppet_position or velocity != puppet_velocity:
        rpc("sync_movement", position, velocity)

@rpc("any_peer", "unreliable")
func sync_movement(new_position: Vector2, new_velocity: Vector2):
    puppet_position = new_position
    puppet_velocity = new_velocity

# Example: Damage system with server authority
func take_damage(damage: int, from_peer_id: int):
    # Send damage request to server for validation
    take_damage_request.rpc_id(1, damage, from_peer_id)

@rpc("any_peer", "call_local", "reliable")
func take_damage_request(damage: int, from_peer_id: int):
    # Only server processes damage
    if not tube_client.is_server:
        return

    var sender_id = multiplayer.get_remote_sender_id()

    # Validate sender matches claimed peer
    if sender_id != from_peer_id:
        printerr("Damage request validation failed")
        return

    # Process damage and broadcast result
    apply_damage.rpc(damage)

@rpc("authority", "call_local", "reliable")
func apply_damage(damage: int):
    # All clients apply the validated damage
    health -= damage
    if health <= 0:
        die()

# Example: Chat message
func send_chat_message(message: String):
    # Send to server for broadcast
    receive_chat.rpc_id(1, message)

@rpc("any_peer", "call_local", "reliable")
func receive_chat(message: String):
    if tube_client.is_server:
        # Server receives and broadcasts to all
        var sender_id = multiplayer.get_remote_sender_id()
        var formatted = "[%d]: %s" % [sender_id, message]
        broadcast_chat.rpc(formatted)
    else:
        # Clients display the message
        display_chat(message)

@rpc("authority", "call_local", "reliable")
func broadcast_chat(message: String):
    display_chat(message)

func display_chat(message: String):
    print("Chat: ", message)
```

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

### Implement Multiplayer Logic with Godot RPC

Source: https://github.com/koopmyers/tube/blob/main/README.md

This snippet illustrates how to implement multiplayer game logic using Godot's Remote Procedure Call (RPC) system. It shows sending input to the server and processing it on the server side, including identifying the sender. This requires a configured MultiplayerAPI on the SceneTree root.

```GDScript
func _on_some_input():
    transfer_some_input.rpc_id(1)


@rpc("any_peer", "call_local", "reliable")
func transfer_some_input():
    var sender_id = multiplayer.get_remote_sender_id()
    # Process the input and affect game logic.
```

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

### Server Session Control with TubeClient

Source: https://context7.com/koopmyers/tube/llms.txt

Manages server-specific capabilities for connected peers, such as kicking players and refusing new connections. It connects to various TubeClient signals to handle session events and player management. Dependencies include the TubeClient node.

```gdscript
extends Node

@onready var tube_client: TubeClient = $TubeClient

func _ready():
    tube_client.session_created.connect(_on_session_created)
    tube_client.peer_connected.connect(_on_peer_connected)
    tube_client.peer_refused.connect(_on_peer_refused)

func _on_session_created():
    if tube_client.is_server:
        print("Server started. Can now control session.")

func _on_peer_connected(peer_id: int):
    if tube_client.is_server:
        print("New peer connected: ", peer_id)

        # Example: Check if we've reached max players
        var connected_peers = tube_client.multiplayer_peer.get_peers()
        if connected_peers.size() >= 4:  # Max 4 clients + 1 server = 5 total
            tube_client.refuse_new_connections = true
            print("Max players reached, refusing new connections")

func kick_player(peer_id: int):
    # Only server can kick peers
    if not tube_client.is_server:
        printerr("Cannot kick peer: not server")
        return

    tube_client.kick_peer(peer_id)
    print("Kicked peer: ", peer_id)

func close_session_to_new_players():
    # Prevent new players from joining (existing stay connected)
    if tube_client.is_server:
        tube_client.refuse_new_connections = true
        print("Session locked to new connections")

func open_session_to_new_players():
    if tube_client.is_server:
        tube_client.refuse_new_connections = false
        print("Session open to new connections")

func _on_peer_refused(peer_id: int):
    print("Refused connection from peer: ", peer_id)
```

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

### TubeClient Node - Session Management

Source: https://context7.com/koopmyers/tube/llms.txt

The TubeClient node manages network connections, multiplayer peers, and session lifecycle. It must be added to the scene tree and remain present while a session is active.

```APIDOC
## TubeClient Node - Session Management

The main node that manages network connections, multiplayer peers, and session lifecycle. Must be added to the scene tree and remain present while a session is active.

### Method
N/A (Node Behavior)

### Endpoint
N/A (Node Behavior)

### Parameters
N/A (Node Behavior)

### Request Example
```gdscript
# Assuming TubeClient is a Node and added to the scene tree
# e.g., in your main scene:
# [node name="TubeClient" parent="." instance=ExtResource(X)]

# To create and host a session:
var client = $TubeClient
var context = load("res://path/to/your/TubeContext.tres").duplicate() # Load and duplicate your context resource
client.create_session(context)

# To join an existing session:
var client = $TubeClient
var context = load("res://path/to/your/TubeContext.tres").duplicate()
var session_id_to_join = "ABCDE" # The session ID shared by the host
client.join_session(context, session_id_to_join)

# To leave a session:
client.leave_session()

# Accessing multiplayer API (after session is established):
var multiplayer = client.multiplayer
multiplayer.rpc("my_remote_function", arg1, arg2)
```

### Response
N/A (Node Behavior)

### Response Example
N/A (Node Behavior)
```

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

### Godot Player Character with MultiplayerSynchronizer

Source: https://context7.com/koopmyers/tube/llms.txt

This script defines a player character with networked synchronization capabilities. It uses MultiplayerSynchronizer to replicate player position, velocity, and health across peers, and handles input processing based on network authority.

```gdscript
extends CharacterBody2D

@onready var sync: MultiplayerSynchronizer = $MultiplayerSynchronizer

# These properties are automatically synchronized by MultiplayerSynchronizer
@export var player_position: Vector2
@export var player_velocity: Vector2
@export var health: int = 100

func _ready():
    # Configure synchronizer properties in the inspector:
    # - Root path: "."
    # - Replication interval: 0.0 (every frame)
    # - Delta interval: 0.0
    # - Public visibility: true
    # - Synchronized properties: player_position, player_velocity, health

    set_multiplayer_authority(name.to_int())
    sync.set_multiplayer_authority(name.to_int())

    if not is_multiplayer_authority():
        set_physics_process(false)

func _physics_process(delta):
    if is_multiplayer_authority():
        var input_dir = Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
        velocity = input_dir * 300
        move_and_slide()

        # Update synchronized properties
        player_position = position
        player_velocity = velocity
    else:
        # Use synchronized data for puppets
        position = player_position
        velocity = player_velocity

```

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