Wikis / Unreal Wiki / Legacy:Role

Role is a concept in replication. Actors have two properties to define their role on server and client in network games: Role and RemoteRole. Role always tells us (and the engine :)) about the actor's local role while RemoteRole tells about the actor's role on the other side of the network. When an actor is replicated to a client, its Role and RemoteRole properties are swapped there, so the serverside Role value becomes the clientside RemoteRole value and vice versa. When we talk about an actor's Role or RemoteRole on this page we always mean "as viewed from the local machine."

• All actors existing on the server have Role == ROLE_Authority there, while their RemoteRole can be either ROLE_None, ROLE_DumbProxy, ROLE_SimulatedProxy or ROLE_AutonomousProxy.
• On the clients the replicated actors have their Role and RemoteRole swapped, i.e. RemoteRole == ROLE_Authority and Role is any of the other values according to the Actor's RemoteRole on the server.
• Client-side actors (i.e. actors that weren't replicated, but spawned on the client) have Role == ROLE_Authority on the network client. These actors only exist on the client they were spawned on. They can't be replicated to any other client or the server.

What do the different net roles mean?

The net roles are defined in the Actor class, as the enum ENetRole (see Actor/Enums for others).

ROLE_None 

In RemoteRole This means that none of the actor's attributes or functions will be replicated at all. Examples for this kind of actors are the GameInfo, Mutators and GameRules as well as some explosion effects and decals in UT. In Role it is contradictory, as it implies the actor does not exist on the machine this script is executing on.
Note: is is perfectly possible to instantiate an Actor on multiple network machines by using simulated functions. However these will not be tied together by replication and the client copies will not function as proxies for the server copy. For instance, destroying the actor on the server will not destroy any corresponding actor on the client (and vice-versa).

ROLE_DumbProxy 

The actor is replicated, but most (if not all) of its logic stays on the server. Theoretically the actor may execute simulated functions and simulated state code, but this is rarely used. Usually clientside behavior is purely a result of replicating variables.
If you see this in Role it means we are looking at the proxy instance, not the copy that was authoratively spawned.

ROLE_SimulatedProxy 

The actor is replicated and may execute simulated functions and simulated state code on the remote side. Often this kind of actor simulates its behavior based on initially replicated properties without (much) further "help" from the server.

ROLE_AutonomousProxy 

The client has autonomous control over the actor replicated to it. The actor is not restricted to simulated functions and can execute non-simulated functions and state code as well. For other clients these actors appear as regular simulated proxies.
This (Remote)Role is usually used for the player actor (PlayerPawn in UE1, PlayerController in UE2) and important actors controlled by it, like the GuidedWarshell (the guided redeemer warhead) in UT or all kind of Pawns in UT2003 (including UT2004 Vehicles).

ROLE_Authority 

All functions can be executed. This must appear in Role on the machine the actor was spawned on, and must appear in either Role or RemoteRole (but not both) for every actor. In standalone games all Actors have Role == ROLE_Authority. In net play nearly all Actors have this Role on the server. The exception is actors that cannot influence other players, such as Karma ragdolls. Never manually set the RemoteRole on the authorative version of an actor or the Role on a replicated version of the actor to this value.

When your script sees RemoteRole == ROLE_Authority it means it is executing on the proxy version of the Actor. Usually it's more useful to check the value of Role though.

Possible Combinations of Roles

It's not unusual that an actor's clientside role changes. The last example is a special case which happens only when the server sets bTearOff=True on a simulated proxy after the actor has been replicated. The server and client versions of the actor become completely independent and nothing is replicated between them anymore. In UT pickups often change between simulated and dumb proxies when they are picked up or dropped.

Related Topics

• Replication
• Netcode Idioms – useful code to pick out different types of machine
• NetMode – tells you what type of game is running: server, client, etc.
• Simulated Function
• Replicated Function