Ownership Modes

Overview

Authority determines which client is allowed to write a networked object's properties. Only the authority client's values are accepted by the server - all other clients receive read-only copies. Fusion has several owner modes that can be set on the FusionSharedReplicator node to control how authority is assigned and transferred.

For how properties are configured and synced, see Syncing Properties.

Owner Modes

Pick the mode that matches your use case:

Transaction

Server-confirmed ownership transfers, with two ways for authority to move between clients.

Live handshake (object currently owned). When another client calls want_authority(true) on an owned object, the authority_requested signal fires on the current owner with the requester's player id. The owner's handler returns true to grant the transfer or false to refuse, and the requester then receives authority_response with the result. On rejection, the requester typically calls want_authority(false) to drop its pending intent.

Orphan-then-claim (object released first). The current owner calls want_authority(false), which marks the object as an orphan (get_owner_id() == 0). Any other client can then claim it with want_authority(true) directly, with no authority_requested / authority_response round-trip. On disconnect the object stays alive as an orphan and other clients can claim it the same way.

While orphaned, the object's properties remain at their last replicated values. No client has write authority, so the state is frozen until another client claims it. If multiple clients claim an orphan simultaneously, the server grants it to the first request it processes; the others are silently ignored. Check has_authority() or listen for authority_changed to confirm a claim succeeded.

GDScript

# Pickup / vehicle pattern
func _on_interact(player):
    $FusionSharedReplicator.want_authority(true)   # claim when interacting

func _on_exit(player):
    $FusionSharedReplicator.want_authority(false)  # release when done

Player Attached

Same transfer mechanics as Transaction (live handshake when owned, orphan-then-claim after release), but with one key difference: when the owning player disconnects, the server automatically despawns the object. Use this for player avatars, player-owned inventory, or anything that should not outlive its owner.

Dynamic

Predictive authority designed for fast-paced ownership transfers where waiting for server confirmation would feel sluggish. Dynamic does not raise authority_requested or authority_response; the entire transfer is driven by the per-call send-rate update interval.

want_authority(true) immediately assigns ownership locally and the client starts sending data at full rate. If the server agrees, nothing further happens - the client simply continues as authority. If the server rejects the claim (because another client's data arrived first), authority reverts.

want_authority(false) lowers the send rate, signalling that this client is willing to give up ownership. The server can then accept another client's predictive claim. The client will not re-claim automatically once the server confirms someone else took over.

The low send rate for the authority is the way to allow the server to accept a dynamic request (gives enough slack for a new client to send a new version first). Override the default with a second argument; a larger number means a slower send rate, e.g. want_authority(false, 32) to release more decisively.

GDScript

# Physics ball - transfer ownership at midline (pong demo pattern)
func _physics_process(delta):
    if not $FusionSharedReplicator.has_authority():
        if ball_crossed_my_half():
            $FusionSharedReplicator.want_authority(true)   # predictive claim
    else:
        if ball_left_my_half():
            $FusionSharedReplicator.want_authority(false)  # yield ownership
        else:
            apply_physics(delta)

Master Client

Always owned by the current master client. Calls to want_authority() are ignored. If the master client disconnects, Photon assigns a new master and ownership transfers automatically - no application code required. Use this for shared singleton state: scoreboards, match timers, game-manager objects.

Requesting and Releasing Authority

GDScript

$FusionSharedReplicator.has_authority()         # am I the current owner?
$FusionSharedReplicator.get_owner_id()          # which player owns this object?
$FusionSharedReplicator.want_authority(true)    # claim ownership
$FusionSharedReplicator.want_authority(false)   # release ownership

The want_authority method accepts an optional second argument (update_interval) to control how often the client sends property updates (in ticks). This is mainly relevant for Dynamic mode.

authority_changed Signal

The authority_changed signal fires on the FusionSharedReplicator node whenever ownership resolves, regardless of mode. Connect to it to react to authority transitions:

GDScript

func _ready():
    $FusionSharedReplicator.authority_changed.connect(_on_authority_changed)

func _on_authority_changed(has_authority: bool):
    if has_authority:
        print("I now own this object")

authority_requested Signal

When another client asks for ownership of an object you currently own, the authority_requested(requester_id) signal fires on your FusionSharedReplicator. The handler returns true to grant the transfer or false to keep ownership; Fusion handles the intent and send-rate updates internally based on the returned bool. The signal applies to Transaction and Player Attached modes; Dynamic and Master Client never raise it.

GDScript

func _ready():
    $FusionSharedReplicator.authority_requested.connect(_on_authority_requested)

func _on_authority_requested(requester_id: int) -> bool:
    return not _is_busy_with(self)

If multiple handlers are connected, the vote is granted when any handler returns true.

authority_response Signal

After a want_authority(true) call resolves through a Transaction or Player-Attached handshake, the requester receives authority_response(accepted: bool) with the outcome. Use it to clean up the pending intent on rejection:

GDScript

func _ready():
    $FusionSharedReplicator.authority_response.connect(_on_authority_response)

func _on_authority_response(accepted: bool) -> void:
    if not accepted:
        $FusionSharedReplicator.want_authority(false)

The orphan-then-claim path does not raise this signal (no current owner to negotiate with); rely on authority_changed to confirm a successful direct claim. Dynamic and Master Client never raise it.