UTPlusStandaloneHitSounds.UTPlusTag

/******************************************************************************
Abstract base class for information-holding actors that can be attached to
arbitrary other actors. Actors of the same subclass of UTPlusTag are linked as a
list and can be efficiently retrieved given the actor they are attached to.

Subclasses should expose the following public interface:

var UTPlusTagCustom nextTag
static function UTPlusTagCustom FindFor(KeeperClass Keeper)
static function UTPlusTagCustom SpawnFor(KeeperClass Keeper)

FindFor and SpawnFor can be implemented by means of calling the protected
functions InternalFindFor and InternalSpawnFor. Overwriting them in the
subclass gives it the opportunity to return a reference to a UTPlusTag instance
of that specific subclass and to restrict the class of actors it can be
attached to.

Internally, subclasses must overwrite the following protected functions
which take care of maintaining the linked list:

protected simulated function UTPlusTag InternalGetFirst()
protected simulated function       InternalSetFirst(UTPlusTag TagFirst)
protected simulated function UTPlusTag InternalGetNext()
protected simulated function       InternalSetNext(UTPlusTag TagNext)

InternalGetNext and InternalSetNext act as accessors for the nextTag
variable declared in the UTPlusTag subclass. InternalGetFirst and
InternalSetFirst access a centrally available reference to the first item
in the linked list. This may be anywhere, for instance in the globally
available instance of JBGameReplicationInfo.

Mixing UTPlusTag actors with inventory of any other kind is not advisable.

Copyright © 2002 Mychaeel <mychaeel@planetjailbreak.com>


Creation date: 2010-06-03 11:49
Last change: $Id$
This class was originally created as "Jailbreak.JBTag" by Mychaeel for JB200x,
I (Wormbo) only renamed it to fit the UTPlus naming scheme. Please direct any
questions about this code or any kind of reuse to him, not me.
******************************************************************************/

class UTPlusTag extends Inventory abstract notplaceable;


// ============================================================================
// Subclass Template
//
// Replace the following terms in the following code by existing symbols:
//
//   UTPlusTagCustom      Your custom subclass of UTPlusTag.
//   KeeperClass      Class of actors that keep items of your UTPlusTag subclass.
//   firstTagCustom   Reference to the first item in the linked list.
//
// Also introduce the firstTagCustom variable in JBGameReplicationInfo.
// ============================================================================

/*
var UTPlusTagCustom nextTag;

static function UTPlusTagCustom FindFor(KeeperClass Keeper) {
return UTPlusTagCustom(InternalFindFor(Keeper)); }
static function UTPlusTagCustom SpawnFor(KeeperClass Keeper) {
return UTPlusTagCustom(InternalSpawnFor(Keeper)); }

protected simulated function UTPlusTag InternalGetFirst() {
return class'UTPlusTagGame'.static.FindFor(Level).firstTagCustom; }
protected simulated function InternalSetFirst(UTPlusTag TagFirst) {
class'UTPlusTagGame'.static.FindFor(Level).firstTagCustom = UTPlusTagCustom(TagFirst); }
protected simulated function UTPlusTag InternalGetNext() {
return nextTag; }
protected simulated function InternalSetNext(UTPlusTag TagNext) {
nextTag = UTPlusTagCustom(TagNext); }
*/


// ============================================================================
// Replication
// ============================================================================

replication
{
	reliable if (Role == ROLE_Authority)
		Keeper, bIsRegisteredOnServer;
}


// ============================================================================
// Variables
// ============================================================================

var protected Actor Keeper;              // replicated keeper actor
var protected Actor KeeperLocal;         // local copy of keeper reference

var private bool bIsRegisteredOnServer;  // registered on the server
var private bool bIsRegisteredOnClient;  // registered on this client


// ============================================================================
// DestroyFor
//
// Finds and destroys the UTPlusTag actor of the calling subclass associated with
// the given keeper. Does nothing if none is found.
// ============================================================================

static function DestroyFor(Actor Keeper)
{
	local UTPlusTag TagDestroy;

	TagDestroy = InternalFindFor(Keeper);
	if (TagDestroy != None)
		TagDestroy.Destroy();
}


// ============================================================================
// GetGameReplicationInfo
//
// Returns a reference to the GameReplicationInfo actor.
// ============================================================================
/*
simulated function GameReplicationInfo GetGameReplicationInfo()
{
	if (Level.Game != None)
		return Level.Game.GameReplicationInfo;

	return Level.GetLocalPlayerController().GameReplicationInfo;
}
*/

// ============================================================================
// InternalFindFor
//
// Finds and returns a reference to the UTPlusTag actor of the calling subclass
// associated with the given keeper. Client-side, if no item is found in the
// keeper actor's inventory, tries to find it with DynamicActors and registers
// it locally in the keeper's inventory on success. Otherwise returns None.
// ============================================================================

protected static function UTPlusTag InternalFindFor(Actor Keeper)
{
	local UTPlusTag thisTag;
	local Inventory thisInventory;

	if (Keeper == None)
		return None;

	for (thisInventory = Keeper.Inventory; thisInventory != None; thisInventory = thisInventory.Inventory) {
		if (thisInventory.Class == Default.Class)
			return UTPlusTag(thisInventory);
	}
	if (Keeper.Role < ROLE_Authority) {
		foreach Keeper.DynamicActors(Class'UTPlusTag', thisTag) {
			if (thisTag.Class == Default.Class && thisTag.Keeper == Keeper)
				return thisTag.RegisterInInventory();
		}
	}
	return None;
}


// ============================================================================
// InternalSpawnFor
//
// If the given keeper actor doesn't already possess a UTPlusTag actor of the
// calling subclass, spawns one and returns a reference to it. Otherwise
// returns a reference to the existing item.
// ============================================================================

protected static function UTPlusTag InternalSpawnFor(Actor Keeper)
{
	local UTPlusTag TagSpawned;

	if (Keeper == None)
		return None;

	TagSpawned = InternalFindFor(Keeper);
	if (TagSpawned == None)
		TagSpawned = Keeper.Spawn(Default.Class, Keeper);

	return TagSpawned;
}


// ============================================================================
// InternalGetFirst
// InternalSetFirst
// InternalGetNext
// InternalSetNext
//
// Protected maintenance functions. Must be implemented in subclasses.
// ============================================================================

protected simulated function UTPlusTag InternalGetFirst();
protected simulated function       InternalSetFirst(UTPlusTag TagFirst);
protected simulated function UTPlusTag InternalGetNext();
protected simulated function       InternalSetNext(UTPlusTag TagNext);


// ============================================================================
// Register
//
// Registers this item both in the global linked list and in the keeper
// actor's inventory. Requires the item to be owned by its keeper actor before
// being called. Communicates the registration to all clients.
// ============================================================================

function Register()
{
	if (bIsRegisteredOnServer || Owner == None)
		return;

	Keeper = Owner;

	RegisterInList();
	RegisterInInventory();
	RegisterLocal();

	bIsRegisteredOnServer = True;  // triggers PostNetReceive on clients
}


// ============================================================================
// RegisterLocal
// UnregisterLocal
//
// Called locally on every client after this item has been registered or
// before it is unregistered.
// ============================================================================

protected simulated function RegisterLocal();
protected simulated function UnregisterLocal();


// ============================================================================
// Unregister
//
// Unregisters this item from both the global linked list and the keeper
// actor's inventory. Communicates the unregistration to all clients.
// ============================================================================

function Unregister()
{
	if (!bIsRegisteredOnServer)
		return;

	UnregisterLocal();
	UnregisterFromList();
	UnregisterFromInventory();

	Keeper = None;
	SetOwner(None);

	bIsRegisteredOnServer = False;  // triggers PostNetReceive on clients
}


// ============================================================================
// RegisterInList
//
// Registers this item in the global linked list. Doesn't check whether the
// item is present there already and thus assumes that this isn't the case.
// Returns a reference to the item.
// ============================================================================

private /*simulated*/ function UTPlusTag RegisterInList()
{
	InternalSetNext(InternalGetFirst());
	InternalSetFirst(Self);

	return Self;
}


// ============================================================================
// RegisterInInventory
//
// Registers this item in its keeper actor's inventory. Doesn't check whether
// the item is present there already and thus assumes that this isn't the case.
// Returns a reference to the item.
// ============================================================================

private simulated function UTPlusTag RegisterInInventory()
{
	if (Keeper == None)
		return Self;

	KeeperLocal = Keeper;

	Inventory = KeeperLocal.Inventory;
	KeeperLocal.Inventory = Self;

	return Self;
}


// ============================================================================
// UnregisterFromList
//
// Removes this item from the global linked list.
// ============================================================================

private /*simulated*/ function UnregisterFromList()
{
	local UTPlusTag thisTag;

	if (InternalGetFirst() == Self)
		InternalSetFirst(InternalGetNext());
	else {
		for (thisTag = InternalGetFirst(); thisTag != None; thisTag = thisTag.InternalGetNext()) {
			if (thisTag.InternalGetNext() == Self)
				thisTag.InternalSetNext(InternalGetNext());
		}
	}
}


// ============================================================================
// UnregisterFromInventory
//
// Removes this item from its keeper actor's inventory and resets the keeper
// actor reference.
// ============================================================================

private simulated function UnregisterFromInventory()
{
	local Inventory thisInventory;

	if (KeeperLocal != None) {
		if (KeeperLocal.Inventory == Self) {
			KeeperLocal.Inventory = Inventory;
		}
		else {
			for (thisInventory = KeeperLocal.Inventory; thisInventory != None; thisInventory = thisInventory.Inventory) {
				if (thisInventory.Inventory == Self)
					thisInventory.Inventory = Inventory;
			}
		}
	}
	KeeperLocal = None;
}


// ============================================================================
// BeginPlay
//
// Registers this item server-side. Client-side registration is taken care of
// by the PostNetReceive event.
// ============================================================================

event BeginPlay()
{
	Register();
}


// ============================================================================
// PostNetReceive
//
// Called when a replication update is received. Client-side, checks whether
// a change in the server-side registration change occurred and registers or
// unregisters the item accordingly.
// ============================================================================

simulated event PostNetReceive()
{
	if (Role == ROLE_Authority || bIsRegisteredOnClient == bIsRegisteredOnServer)
		return;

	if (bIsRegisteredOnServer)
		GotoState('Registering');
	else {
		UnregisterLocal();
		UnregisterFromList();
		UnregisterFromInventory();
	}

	bIsRegisteredOnClient = bIsRegisteredOnServer;
}


// ============================================================================
// Destroyed
//
// Automatically unregisters this UTPlusTag item.
// ============================================================================

simulated event Destroyed()
{
	UnregisterLocal();
	UnregisterFromList();
	UnregisterFromInventory();
}


// ============================================================================
// state Registering
//
// Used for client-side registration of this actor. Waits until the
// GameReplicationInfo actor has been replicated and is available on the
// client, then registers itself.
// ============================================================================

simulated state Registering
{
Begin:
	while (Keeper == None)
		Sleep(0.0);  // sleep for a tick

	RegisterInList();
	RegisterInInventory();
	RegisterLocal();

} // state Registering


// ============================================================================
// Defaults
// ============================================================================

defaultproperties
{
	RemoteRole = ROLE_None;  // may be changed in subclasses

	bAlwaysRelevant = True;
	bNetNotify = True;
	bOnlyRelevantToOwner = False;
	bSkipActorPropertyReplication = True;
	NetUpdateFrequency = 10.0;
}