Ownership and possession

Photon, Fusion, and Netcode attach ownership to every networked object individually. Alteruna attaches it to the Avatar only - a synced prop does not carry its own owner field the way a NetworkObject does.

avatar.IsMe
avatar.Possessor
avatar.Possessed(user)
// events: avatar.OnPossessed, avatar.OnUnpossessed

photonView.IsMine
photonView.Owner
photonView.RequestOwnership()
photonView.TransferOwnership(player)

Object.HasStateAuthority
Object.HasInputAuthority
Object.StateAuthority
Object.AssignInputAuthority(player)

IsOwner
OwnerClientId
networkObject.ChangeOwnership(clientId)

IsOwner
Owner
networkObject.GiveOwnership(conn)

If a gameplay object other than the player needs an "owner" concept (a vehicle, a held tool), that is a pattern you build on top - commonly by possessing a purpose-built Avatar for it, or by pairing it with resource locking below.

One thing worth being precise about: avatar.Possessed(user) is unilateral and client-declared, not arbitrated. Calling it just tells every other peer "this avatar is now possessed by this user" and they apply it on receipt - closer to Photon's OwnershipTransfer.Takeover mode than to Request mode, and with no equivalent to Netcode/FishNet's server-only ChangeOwnership/GiveOwnership. If two peers could plausibly call Possessed() on the same avatar at once, that race isn't resolved for you - see resource locking below.

Resource locking

Worth being precise about the framework side too, since "server-enforced" doesn't apply evenly across them. Netcode's ChangeOwnership and FishNet's GiveOwnership can only be called by the server/authority, so ownership changes there are genuinely gated by a single decision-maker - there's just no general-purpose lock for arbitrary resources, only for object ownership. Photon PUN 2's RequestOwnership() is not server-enforced at all: with OwnershipTransfer.Request, Photon relays the request to the current owner's client, and that client's own OnOwnershipRequest callback decides whether to grant it - Photon's servers just track who's registered as owner, they don't arbitrate. With OwnershipTransfer.Takeover there's no negotiation at all. Fusion's host/dedicated-server modes gate ownership the same way Netcode does; Shared Mode gives you authority transfer but, like the others, no request/deny handshake for an arbitrary shared resource.

Alteruna's TryLockResource is a genuine arbitrated queue, not a client-side declaration: the request is handled by whichever peer is host (locally if you are the host, relayed there otherwise), which grants the lock to whoever's next in a real FIFO queue and tells everyone else to wait. That makes it closer in strength to Netcode/FishNet's server-gated ownership than to Photon's owner-negotiated RequestOwnership() - but usable for any resource, not just tied to who owns a whole networked object. Request a lock, get told yes or no, release it when you're done.

multiplayer.OnLockAcquired.AddListener(e => draggable.BeginDrag());
multiplayer.OnLockDenied.AddListener(e => Debug.Log("already held"));

// on pickup attempt
multiplayer.TryLockResource(pickup);

// on release
multiplayer.UnlockResource(pickup);

Reach for this anywhere two peers could plausibly touch the same object at once - a lever, a held item, a turn-based board tile - since nothing else in the stack blocks that race for you. See Developer Guide Part 01 for the ownership API this is built on.

Reference