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. The current owner keeps authority until it explicitly releases with want_authority(false), at which point the server marks the object as an orphan (unowned). Any other client can then claim it with want_authority(true). On disconnect, the object stays alive as an orphan and other clients can claim it.

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 request ownership of an orphaned object simultaneously, the server grants it to the first request it processes - the other requests 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 request/release mechanics as Transaction, 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.

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). It's possible to override the default permissive interval by passing a second argument: want_authority(false, 12).

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, Player Attached, and Dynamic modes. Master Client objects cannot be transferred and never receive 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.