User:00zX

Proposal - Noir theme with highlighter adjustments

Code Noir Redex

stylish - userstyle -00zX 01:50, 3 April 2009 (UTC)

[Monobook - noir]

Proposal - Replication

Replication

-00zX 06:24, 31 March 2009 (UTC)

Replication/Replication_(computer_science)

Declaring Replication using theReplication Block

Function Replication using the replication block?

Booleans Declared in actor that are useful in replication

http://wiki.beyondunreal.com/Introduction_to_replication#

Concept of servers and clients.

Replication Block

UE3:Actor_(UT3) - link to replication block
Previously in UT200x Reliable and Unreliable were used as part of the replication block as of Unreal Engine 3 this is no longer the case with the keywords becoming function modifiers.

UT200x

replication
{
  reliable/unreliable if ( replication condition )
    identifiers;
}

UT3

replication
{
   if ( replication condition )
    identifiers;
}

Identifiers can be of many types, certain types however arnt allowed like dynamic arrays.

Explain Why can loose sync! it is possible to crosscheck dynamic arrays but it would come at a cost.

Using the Replication Block

Actor Replication

Variable Value Replication

var() float NewEquipTime;
var() float NewPutDownTime;
 
replication
{
	if(bNetDirty && (Role == ROLE_Authority) && bNetInitial)
		NewEquipTime, NewPutDownTime;
}

• • Repnotify

• Function call replication*

[Array] Unlike any other data type in UnrealScript, dynamic arrays have absolutely no support for replication. Attempting to replicate a dynamic array variable will have no effect on the remote instance of that variable. Attempting to use a dynamic array as parameter of a replicated function will result in the parameter being empty when the function is executed on the remote side.

Like replicated variables, the replication of a function call can be tied to certain conditions. In Unreal Engine 1 and 2 this condition is specified via the replication block and typically involves comparing the actor's Role to the value ROLE_Authority, Unreal Engine 3 provides the special function modifiers client and server instead.

• Using Network modifiers for Functions

Reliable Unreliable

Client

/** Sets the clients weapon to use the replicated variables */
reliable client function SetWeapProps(UTWeapon W)
{
	W.EquipTime = NewEquipTime;
	W.PutDownTime = NewPutDownTime;
}

Server

/** Gets the times from the weapons and sets them to the replicated variables */
reliable server function GetWeapProps(UTWeapon W)
{
	NewEquipTime = W.default.EquipTime * 0.68;
	NewPutDownTime = W.default.PutDownTime * 0.70;
}

Relevance

Role and RemoteRole

Definition

The Actor class defines the NetRole enumeration and two variables, Role and RemoteRole, as follows:

• UE3:Actor_(UT3)#ENetRole

• UE1:Actor_enums_(UT)#ENetMode
• UE2:Actor_enums_(U2)#ENetRole
• UE2:Actor_enums_(UT2003)#ENetRole
• UE2:Actor_enums_(U2XMP)#ENetMode
• UE2:Actor_enums_(UT2004)#ENetRole

enum ENetRole
{
	ROLE_None,							// No role at all.
	ROLE_SimulatedProxy,		// Locally simulated proxy of this actor.
	ROLE_AutonomousProxy,	// Locally autonomous proxy of this actor.
	ROLE_Authority,					// Authoritative control over the actor.
};
var ENetRole RemoteRole, Role;

usage:

if (Role == ROLE_Authority)
{
	// This is the authorative copy of this actor, it was spawned on this machine.
	// It is not a guarantee that we are on the server or in single player!
}
 
if (Role < ROLE_Authortity)
{
	// This is a non-authorative copy of this actor that was replicated
	// from the server. In other words, we must be on a client.
}

As in the replication block of Actor.uc UT3

	// Physics
	if( (!bSkipActorPropertyReplication || bNetInitial) && bReplicateMovement
					&& ((RemoteRole == ROLE_SimulatedProxy) && (bNetInitial || bUpdateSimulatedPosition)) )

NetMode

Definition

The WorldInfo (previously Level Class [ut2kx]) class defines the NetMode enumeration and two variables, Role and RemoteRole, as follows:

• UE3:WorldInfo_(UT3)#ENetMode
  • UE3:WorldInfo_internal_variables_(UT3)

• In LevelInfo for most Unreal Engine games pre UT3/GOW
  • UE1:LevelInfo_(UT)#ENetMode
  • UE2:LevelInfo_(U2)#ENetMode
  • UE2:LevelInfo_(UT2003)#ENetMode
  • UE2:LevelInfo_(U2XMP)#ENetMode
  • UE2:LevelInfo_(UT2004)#ENetMode

var enum ENetMode
{
	NM_Standalone,				// Standalone game.
	NM_DedicatedServer,		// Dedicated server, no local client.
	NM_ListenServer,			// Listen server, local client+server.
	NM_Client							// Client only, no local server.
} NetMode;

Standalone game Dedicated server, no local client Listen server, local client+server Client only, no local server

Examples

usage:

simulated event PostBeginPlay()
{
	if(WorldInfo.NetMode != NM_DedicatedServer)
	{
		// Code here will only be executed on Listen servers and game clients.
	}
 
	if(WorldInfo.NetMode == NM_DedicatedServer)
	{
		// Code here will only be executed on a server.
	}
}

or similarly like in the Role and RemoteRole example:

simulated event PostBeginPlay()
{
	if (WorldInfo.NetMode < NM_DedicatedServer)
	{
		// Code here will only be executed on Listen servers and game clients.
	}
 
	if (WorldInfo.NetMode > NM_DedicatedServer)
	{
		// Code here will only be executed on a server or standalone client.
	}
}

Useful Replication Properties

UT3 actor.uc

// Networking flags
var			  const	bool	bNetTemporary;				// Tear-off simulation in network play.
var			  const	bool	bOnlyRelevantToOwner;			// this actor is only relevant to its owner. If this flag is changed during play, all non-owner channels would need to be explicitly closed.
var transient				bool	bNetDirty;				// set when any attribute is assigned a value in unrealscript, reset when the actor is replicated
var					bool	bAlwaysRelevant;			// Always relevant for network.
var					bool	bReplicateInstigator;		// Replicate instigator to client (used by bNetTemporary projectiles).
var					bool	bReplicateMovement;			// if true, replicate movement/location related properties
var					bool	bSkipActorPropertyReplication; // if true, dont replicate actor class variables for this actor
var					bool	bUpdateSimulatedPosition;	// if true, update velocity/location after initialization for simulated proxies
var					bool	bTearOff;					// if true, this actor is no longer replicated to new clients, and
														// is "torn off" (becomes a ROLE_Authority) on clients to which it was being replicated.
var					bool	bOnlyDirtyReplication;		// if true, only replicate actor if bNetDirty is true - useful if no C++ changed attributes (such as physics)
														// bOnlyDirtyReplication only used with bAlwaysRelevant actors
 
 
/** Demo recording variables */
var transient				bool	bDemoRecording;		/** set when we are currently replicating this Actor into a demo */
var transient				bool	bClientDemoRecording;	/** set when we are recording a clientside demo */
var transient				bool	bRepClientDemo;		/** set if remote client is recording a clientside demo */
var					bool	bDemoOwner;					// Demo recording driver owns this actor.
 
/** Should replicate initial rotation.  This property should never be changed during execution, as the client and server rely on the default value of this property always being the same. */
var const           bool    bNetInitialRotation;
 
/** If true, never replicate rotation */
var					bool	bNeverReplicateRotation;
 
var					bool	bReplicateRigidBodyLocation;	// replicate Location property even when in PHYS_RigidBody
var					bool	bKillDuringLevelTransition;	// If set, actor and its components are marked as pending kill during seamless map transitions
/** whether we already exchanged Role/RemoteRole on the client, as removing then readding a streaming level
 * causes all initialization to be performed again even though the actor may not have actually been reloaded
 */
var const				bool	bExchangedRoles;

booleans

• (Level.NetMode == NM_Client && bNetOwner) – owner clients (special case of client where the local player is the Owner of the actor in question)

UT2004

NetUpdateFrequency

NetUpdateFrequency is another variable useful in replication. It effectively causes an otherwise relevant (not useful when the actor is not relevant) actor to be relevant NetUpdateFrequency times per second. This is useful when the data changes frequently but you only want periodic updates. For example, PlayerReplicationInfo contains a lot of data about the client. Stuff like the various player's pings may change quite frequently, and having the client keep track of such information would be quite a network hog. But since PlayerReplicationInfo has a NetUpdateFrequency of 2, it is only updated twice a second, which is much nicer for that player's bandwidth. The list of the current NetUpdateFrequency's for all UT classes are listed below:

Actor - 100 Hz (times per second)
ZoneInfo - 4 Hz
GameReplicationInfo - 4 Hz
PlayerReplicationInfo - 2 Hz
Inventory - 8 Hz

Using Replication

class UT_MDI_Weapon extends UT_MDI;
 
/** How long does it take to Equip this weapon */
var() repnotify float NewEquipTime;
 
/** How long does it take to put this weapon down */
var() repnotify float NewPutDownTime;
 
/** Weapon class so we can check owner is right type and set vars */
var UTWeapon Weap;
 
/** Replication Block */
replication
{
	if(bNetDirty && (Role == ROLE_Authority) && bNetInitial)
		NewEquipTime, NewPutDownTime;
}
 
/** Gets the times from the weapons and sets them to the replicated variables */
reliable server function GetWeapProps(UTWeapon W)
{
	NewEquipTime = W.default.EquipTime * 0.68;
	NewPutDownTime = W.default.PutDownTime * 0.70;
}
 
/** Sets the clients weapon to use the replicated variables */
reliable client function SetWeapProps(UTWeapon W)
{
	W.EquipTime = NewEquipTime;
	W.PutDownTime = NewPutDownTime;
}
 
/** Make sure we have an owner and its the right type before moving on */
simulated event PostBeginPlay()
{
	local int i;
 
	if(Owner == None || cUseforWeaps.length <= 0)
		Destroy();
 
	Weap = UTWeapon(Owner);
	if(Weap != None)
	{
				if(WorldInfo.NetMode != NM_Client)
					GetWeapProps(Weap);	
 
				SetTimer(0.01, false, 'SetPropsTimer');
	}
	else
		Destroy();
}
 
function SetPropsTimer()
{
	SetWeapProps(Weap);
}
 
defaultproperties
{
	//remove all from array
	//cUseforWeapons(0)=none
 
	RemoteRole=ROLE_SimulatedProxy
	bAlwaysRelevant=True
}

	if(Weap != None)
	{
				if(WorldInfo.NetMode != NM_Client)
					GetWeapProps(Weap);	
 
				SetTimer(0.01, false, 'SetPropsTimer');
	}

function SetPropsTimer()
{
	SetWeapProps(Weap);
}
		//Sets the properties to the values from the Server on the client

Related Topics

• Introduction To Replication
• Replication
• Replication Block
• Role and RemoteRole, and NetMode
• Netcode Idioms
• Replication Examples
• Replication De-Obfuscation

Proposal

Foo

-00zX 21:31, 29 March 2009 (UTC)

Bar

UE3:Object_static_native_functions_(UT3)

Legacy:Object_(UT3)/Operators

Legacy:Operators

Legacy:Scripting_Operators

Legacy:Iterator

Variables#Modifiers

Wiki

Contributions

• Using the UT2004 Mod System

Contact Me

IRC

_00zX on EnterTheGame

• #unrealscript on EnterTheGame
• #unrealwiki on EnterTheGame
• #unrealed on EnterTheGame
• #chaoticdreams on EnterTheGame

Other/Profiles

E-mail 00zX or on

• delicious
• Photobucket

---