Wikis / Unreal Wiki / Legacy:KActor Replication

class LawDogsKActor extends KActor
	placeable;
 
var() float MaxNetUpdateInterval;
var float NextNetUpdateTime;
 
var KRigidBodyState KState, KRepState;
var bool bNewKState;
var int StateCount, LastStateCount;
 
replication
{
	unreliable if(Role == ROLE_Authority)
		KRepState, StateCount;
}
 
function Tick(float Delta)
{
	PackState();
}
 
//Pack current state to be replicated
function PackState()
{
	local bool bChanged;
 
	if(!KIsAwake())
		return;
 
	KGetRigidBodyState(KState);
 
	bChanged = Level.TimeSeconds > NextNetUpdateTime;
	bChanged = bChanged || VSize(KRBVecToVector(KState.Position) - KRBVecToVector(KRepState.Position)) > 5;
	bChanged = bChanged || VSize(KRBVecToVector(KState.LinVel) - KRBVecToVector(KRepState.LinVel)) > 1;
	bChanged = bChanged || VSize(KRBVecToVector(KState.AngVel) - KRBVecToVector(KRepState.AngVel)) > 1;
 
	if(bChanged)
	{
		NextNetUpdateTime = Level.TimeSeconds + MaxNetUpdateInterval;
		KRepState = KState;
		StateCount++;
	}
	else
		return;
}
 
//New state recieved.
simulated event PostNetReceive()
{
	if(StateCount == LastStateCount)
		return;
}
 
//Apply new state.
simulated event bool KUpdateState(out KRigidBodyState newState)
{
	//This should never get called on the server - but just in case!
	if(Role == ROLE_Authority || StateCount == LastStateCount)
		return false;
 
	//Apply received data as new position of actor.
	newState = KRepState;
	StateCount = LastStateCount;
 
	return true;
}
 
defaultproperties
{
	MaxNetUpdateInterval=0.5
 
	StaticMesh=StaticMesh'MiscPhysicsMeshes.Barrels.Barrel'
 
    Begin Object Class=KarmaParams Name=KarmaParams0
        KMass=0.5
        bHighDetailOnly=False
        bKAllowRotate=True
        KFriction=0.2
        KRestitution=0.5
        KImpactThreshold=1000.0
        bClientOnly=False
        Name="KarmaParams0"
    End Object
	KParams=KarmaParams'KarmaParams0'
 
	RemoteRole=ROLE_SimulatedProxy
	bNetNotify=True
}

class ReplicatedKActor extends KActor placeable;
 
struct RepState
{
  var KRigidBodyState State;
  var byte	      Timestamp;
};
 
var bool     bUpdateState;
var byte     LastTimeStamp;
var RepState RepKState;
 
replication
{
  unreliable if(Role == ROLE_Authority)
    RepKState;
}
 
function Tick(float Delta)
{
  Super.Tick( Delta );
 
  PackState();
}
 
//Pack current state to be replicated
function PackState()
{
  local bool bChanged;
  local KRigidBodyState KState;
 
  if(!KIsAwake())
    return;
 
  KGetRigidBodyState(KState);
  if ( KState == RepKState.State )
    return;
 
  RepKState.State = KState;
  RepKState.TimeStamp++;
}
 
//New state recieved.
simulated event PostNetReceive()
{
  Super.PostNetRecieve();
 
  if ( RepKState.TimeStamp != LastTimeStamp )
  {
    LastTimeStamp = RepKState.TimeStamp;
    bUpdateState = true;
  }
}
 
//Apply new state.
simulated event bool KUpdateState(out KRigidBodyState newState)
{
  Super.KUpdateState( newState );
 
  if ( bUpdateState )
  {
    newState = KRepState;
    bUpdateState = false;
    return true;
  }
 
  return false;
}
 
defaultproperties
{
  StaticMesh=StaticMesh'MiscPhysicsMeshes.Barrels.Barrel'
 
  Begin Object Class=KarmaParams Name=KarmaParams0
    KMass=0.5
    bHighDetailOnly=False
    bKAllowRotate=True
    KFriction=0.2
    KRestitution=0.5
    KImpactThreshold=1000.0
    bClientOnly=False
    Name="KarmaParams0"
  End Object
  KParams=KarmaParams'KarmaParams0'
 
  RemoteRole=ROLE_SimulatedProxy
  bNetNotify=True
}

cpptext
{
#ifdef WITH_KARMA
	// Actor interface.
	virtual UBOOL Tick(FLOAT DeltaTime, enum ELevelTick TickType);
	virtual void PostNetReceive();
 
	// SVehicle interface.
	virtual void UpdateVehicle(FLOAT DeltaTime);
 
	// SCar interface.
	virtual void ProcessCarInput();
	virtual void ChangeGear(UBOOL bReverse);
	virtual void PackState();
#endif
}

simulated function DoPush() {
	local vector StartTrace, EndTrace, HitLocation, HitNormal;
	local Actor hit;
 
	StartTrace = Location + EyePosition();
	EndTrace = StartTrace + 196 * vector(Controller.GetViewRotation());
	hit = Trace(HitLocation, HitNormal, EndTrace, StartTrace, true);
 
	Debug(self$": I hit a "$hit);
	if(hit != None) {
		hit.KWake();
	   hit.KAddImpulse(34000 * (-hitnormal), location);
	   bumpfactor = 7; // we add several wait-ticks before next bump, so we aren't adding that to it too
	}
}

class Ball extends Actor;
 
var float MaxNetUpdateInterval;
var float NextNetUpdateTime;
var float LastUpdateTime;
 
var KRigidBodyState KState;
var bool bChanged;
 
var int counter;
 
 
struct repinfo {
	var KRigidBodyState state;
	var float timestamp;
};
 
var repinfo KRepState;
 
replication
{
    unreliable if(Role == ROLE_Authority)
        KRepState, bChanged;
}
 
function Tick(float Delta)
{
	if(Role == ROLE_Authority) {
	    if(KIsAwake()) {
	        counter = 30;
	    } else {
	        if(counter > 0) counter--;
	    }
    	PackState();
    }
}
 
function PackState()
{
    if(counter < 1 && !KIsAwake())
	    return;
    bChanged = false;
    KGetRigidBodyState(KState);
 
    if(VSize(KRBVecToVector(KState.Position) - KRBVecToVector(KRepState.state.Position)) > 10) {
    	//log(self@"Position Change");
        bChanged = true;
    }
    if(VSize(KRBVecToVector(KState.LinVel) - KRBVecToVector(KRepState.state.LinVel)) > 10) {
        //log(self@"LinVel Change");
    	bChanged = true;
    }
    if(VSize(KRBVecToVector(KState.AngVel) - KRBVecToVector(KRepState.state.AngVel)) > 10) {
    	//log(self@"AngVel");
        bChanged = true;
    }
    if(bChanged == false && Level.TimeSeconds > NextNetUpdateTime) {
    	//log(self@"MaxNetUpdateInterval reached");
        bChanged = true;
    }
    if(bChanged == true) {
        KRepState.state = KState;
        NextNetUpdateTime = Level.TimeSeconds + MaxNetUpdateInterval;
		KRepState.timestamp = Level.TimeSeconds;
	}
 
}
 
simulated event bool KUpdateState(out KRigidBodyState newState)
{
    if(Role == ROLE_Authority)
        return false;
    if(bChanged == false) return false;
    if(LastUpdateTime > KRepState.timestamp) return false;
    newState = KRepState.state;
    LastUpdateTime = KRepState.timestamp;
	bChanged = false;
    return true;
}
 
simulated event PreBeginPlay() {
	KarmaParams(KParams).bClientOnly = false;
}
 
 
DefaultProperties
{
	MaxNetUpdateInterval=0.2
	bBlockZeroExtentTraces = true
	bBlockNonZeroExtentTraces = true
    //NetUpdateFrequency = 1
	//bUpdateSimulatedPosition=true
	//bGameRelevant=true
	bAlwaysRelevant=true
	bCollideWorld=true
	bNetNotify=true
	RemoteRole=ROLE_SimulatedProxy
	DrawScale=2.75
	Physics=PHYS_Karma
	Begin Object Class=KarmaParams Name=KParams0
		bHighDetailOnly			=	False
		bKNonSphericalInertia	=	False
		KActorGravScale			=	0.55
		KAngularDamping			=	0.2
		KBuoyancy				=	1.01
		KLinearDamping			=	0.2
		KMass					=	0.45
		KStartEnabled			=	False
		KFriction				=	0.40
		KRestitution			=	0.50
		KImpactThreshold		=	5
	End Object
	KParams=KarmaParams'KParams0'
	StaticMesh=StaticMesh'UZGMeshes.Body.Head'
	DrawType=DT_StaticMesh
//	 bNoDelete=True
	 bCollideActors=True
	 bBlockActors=True
	 bBlockPlayers=True
	 bProjTarget=True
	 bBlockKarma=True
}