Engine.Inventory

//=============================================================================
// Inventory
//
// Inventory is the parent class of all actors that can be carried by other actors.
// Inventory items are placed in the holding actor's inventory chain, a linked list
// of inventory actors.  Each inventory class knows what pickup can spawn it (its
// PickupClass).  When tossed out (using the DropFrom() function), inventory items
// spawn a DroppedPickup actor to hold them.
//
// Copyright 1998-2008 Epic Games, Inc. All Rights Reserved.
//=============================================================================

class Inventory extends Actor
	abstract
	native
	nativereplication;

//-----------------------------------------------------------------------------

var	Inventory			Inventory;				// Next Inventory in Linked List
var InventoryManager	InvManager;
var	databinding	localized string	ItemName;

var	bool				bRenderOverlays;		// If true, this inventory item will be given access to HUD Canvas. RenderOverlays() is called.
var bool				bReceiveOwnerEvents;	// If true, receive Owner events. OwnerEvent() is called.
/** if true, this inventory item should be dropped if the owner dies */
var bool bDropOnDeath;

//-----------------------------------------------------------------------------
// Pickup related properties
var bool bDelayedSpawn;
var		bool								bPredictRespawns;		// high skill bots may predict respawns for this item
var()	float								RespawnTime;			// Respawn after this time, 0 for instant.
var  float									MaxDesireability;		// Maximum desireability this item will ever have.
var() databinding	localized string						PickupMessage;			// Human readable description when picked up.
var() SoundCue PickupSound;
var() string PickupForce;
var			class<DroppedPickup>			DroppedPickupClass;
var			PrimitiveComponent				DroppedPickupMesh;
var			PrimitiveComponent				PickupFactoryMesh;
var			ParticleSystemComponent			DroppedPickupParticles;

// (cpptext)
// (cpptext)
// (cpptext)
// (cpptext)
// (cpptext)

// Network replication.
replication
{
	// Things the server should send to the client.
	if ( (Role==ROLE_Authority) && bNetDirty && bNetOwner )
		Inventory, InvManager;
}


/**
 * Access to HUD and Canvas. Set bRenderOverlays=true to receive event.
 * Event called every frame when the item is in the InventoryManager
 *
 * @param	HUD H
 */
simulated function RenderOverlays( HUD H );

/**
 * Access to HUD and Canvas.
 * Event always called when the InventoryManager considers this Inventory Item currently "Active"
 * (for example active weapon)
 *
 * @param	HUD H
 */
simulated function ActiveRenderOverlays( HUD H );

simulated function String GetHumanReadableName()
{
	return Default.ItemName;
}

event Destroyed()
{
	// Notify Pawn's inventory manager that this item is being destroyed (remove from inventory manager).
	if ( Pawn(Owner) != None && Pawn(Owner).InvManager != None )
	{
		Pawn(Owner).InvManager.RemoveFromInventory( Self );
	}
}

/* Inventory has an AI interface to allow AIControllers, such as bots, to assess the
 * desireability of acquiring that pickup.  The BotDesireability() method returns a
 * float typically between 0 and 1 describing how valuable the pickup is to the
 * AIController.  This method is called when an AIController uses the
 * FindPathToBestInventory() navigation intrinsic.
 * @param PickupHolder - Actor in the world that holds the inventory item (usually DroppedPickup or PickupFactory)
 * @param P - the Pawn the AI is evaluating this item for
 * @param C - the Controller that is evaluating this item. Might not be P.Controller - the AI may choose to
 * 		evaluate the usability of the item by the driver Pawn of a vehicle it is currently controlling, for example
 */
static function float BotDesireability(Actor PickupHolder, Pawn P, Controller C)
{
	local Inventory AlreadyHas;
	local float desire;

	desire = Default.MaxDesireability;

	if ( Default.RespawnTime < 10 )
	{
		AlreadyHas = P.FindInventoryType(Default.class);
		if ( AlreadyHas != None )
		{
			return -1;
		}
	}
	return desire;
}

/* DetourWeight()
value of this path to take a quick detour (usually 0, used when on route to distant objective, but want to grab inventory for example)
*/
static function float DetourWeight(Pawn Other,float PathWeight)
{
	return 0;
}

/* GiveTo:
	Give this Inventory Item to this Pawn.
	InvManager.AddInventory implements the correct behavior.
*/
final function GiveTo( Pawn Other )
{
	if ( Other != None && Other.InvManager != None )
	{
		Other.InvManager.AddInventory( Self );
	}
}

/* AnnouncePickup
	This inventory item was just picked up (from a DroppedPickup or PickupFactory)
*/
function AnnouncePickup(Pawn Other)
{
	Other.HandlePickup(self);

	if (PickupSound != None)
	{
		Other.PlaySound( PickupSound );
	}
}

/**
 * This Inventory Item has just been given to this Pawn
 * (server only)
 *
 * @param	thisPawn			new Inventory owner
 * @param	bDoNotActivate		If true, this item will not try to activate
 */
function GivenTo( Pawn thisPawn, optional bool bDoNotActivate )
{
	Instigator = ThisPawn;
	ClientGivenTo(thisPawn, bDoNotActivate);
}

/**
 * This Inventory Item has just been given to this Pawn
 * (owning client only)
 *
 * @param	thisPawn			new Inventory owner
 * @param	bDoNotActivate		If true, this item will not try to activate
 */
reliable client function ClientGivenTo(Pawn NewOwner, bool bDoNotActivate)
{
	// make sure Owner is set - if Inventory item fluctuates Owners there is a chance this might not get updated normally
	SetOwner(NewOwner);
	Instigator = NewOwner;
	if (NewOwner != None && NewOwner.Controller != None)
	{
		NewOwner.Controller.NotifyAddInventory(self);
	}
}

/**
 * Event called when Item is removed from Inventory Manager.
 * Network: Authority
 */
function ItemRemovedFromInvManager();


/** DenyPickupQuery
	Function which lets existing items in a pawn's inventory
	prevent the pawn from picking something up.
 * @param ItemClass Class of Inventory our Owner is trying to pick up
 * @param Pickup the Actor containing that item (this may be a PickupFactory or it may be a DroppedPickup)
 * @return true to abort pickup or if item handles pickup
 */
function bool DenyPickupQuery(class<Inventory> ItemClass, Actor Pickup)
{
	// By default, you can only carry a single item of a given class.
	if ( ItemClass == class )
	{
		return true;
	}

	return false;
}


/**
 * Drop this item out in to the world
 *
 * @param	StartLocation 		- The World Location to drop this item from
 * @param	StartVelocity		- The initial velocity for the item when dropped
 */
function DropFrom(vector StartLocation, vector StartVelocity)
{
	local DroppedPickup P;

	if( Instigator != None && Instigator.InvManager != None )
	{
		Instigator.InvManager.RemoveFromInventory(Self);
	}

	// if cannot spawn a pickup, then destroy and quit
	if( DroppedPickupClass == None || DroppedPickupMesh == None )
	{
		Destroy();
		return;
	}

	P = Spawn(DroppedPickupClass,,, StartLocation);
	if( P == None )
	{
		Destroy();
		return;
	}

	P.SetPhysics(PHYS_Falling);
	P.Inventory	= self;
	P.InventoryClass = class;
	P.Velocity = StartVelocity;
	P.Instigator = Instigator;
	P.SetPickupMesh(DroppedPickupMesh);
	P.SetPickupParticles(DroppedPickupParticles);

	Instigator = None;
	GotoState('');
}


static function string GetLocalString(
	optional int Switch,
	optional PlayerReplicationInfo RelatedPRI_1,
	optional PlayerReplicationInfo RelatedPRI_2
	)
{
	return Default.PickupMessage;
}

/* OwnerEvent:
	Used to inform inventory when owner event occurs (for example jumping or weapon change)
	set bReceiveOwnerEvents=true to receive events.
*/
function OwnerEvent(name EventName);

defaultproperties
{
   MaxDesireability=0.100000
   PickupMessage="Snagged an item."
   DroppedPickupClass=Class'Engine.DroppedPickup'
   Begin Object Class=SpriteComponent Name=Sprite ObjName=Sprite Archetype=SpriteComponent'Engine.Default__SpriteComponent'
      HiddenGame=True
      AlwaysLoadOnClient=False
      AlwaysLoadOnServer=False
      Name="Sprite"
      ObjectArchetype=SpriteComponent'Engine.Default__SpriteComponent'
   End Object
   Components(0)=Sprite
   RemoteRole=ROLE_SimulatedProxy
   bHidden=True
   bOnlyRelevantToOwner=True
   bReplicateMovement=False
   bOnlyDirtyReplication=True
   NetPriority=1.400000
   CollisionType=COLLIDE_CustomDefault
   Name="Default__Inventory"
   ObjectArchetype=Actor'Engine.Default__Actor'
}