Engine.Pickup

//=============================================================================
// Pickup items.
//
// Pickup is the base class of actors that when touched by an appropriate pawn, 
// will create and place an Inventory actor in that pawn's inventory chain.  Each 
// pickup class has an associated inventory class (its InventoryType).  Pickups are 
// placed by level designers.  Pickups can only interact with pawns when in their 
// default Pickup state.  Pickups verify that they can give inventory to a pawn by 
// calling the GameInfo's PickupQuery() function.  After a pickup spawns an inventory 
// item for a pawn, it then queries the GameInfo by calling the GameInfo's 
// ShouldRespawn() function about whether it should remain active, enter its Sleep 
// state and later become active again, or destroy itself.
//
// When navigation paths are built, each pickup has an InventorySpot (a subclass 
// of NavigationPoint) placed on it and associated with it 
// (the Pickup's MyMarker== the InventorySpot, 
// and the InventorySpot's markedItem == the pickup).     
//
//=============================================================================
class Pickup extends Actor
	abstract
	placeable
	native
	nativereplication;

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

const StopFallingTimer = 'StopFalling';	// NEW

//-----------------------------------------------------------------------------
// AI related info.

var() float		  MaxDesireability;	  // Maximum desireability this item will ever have.
var	  InventorySpot MyMarker;
var() class<Inventory> InventoryType;
//NEW (mdf) (OLD - not used) var() bool		bInstantRespawn;	  // Can be tagged so this item respawns instantly.
var	  bool		bOnlyReplicateHidden;	// only replicate changes in bHidden (optimization for level pickups)
var(Display) bool bAmbientGlow;		  // Whether to glow or not.
var() float     RespawnTime;          // Respawn after this time, 0 for instant.

var() localized string PickupMessage; // Human readable description when picked up.
var() sound PickupSound;

//NEW: Pathing (player-only inventory)
var()  bool		bPlayerOnly;		// player-only pickups -- not picked up by NPCs, not in reachspecs
//OLD

var float FallingTimeoutDelay;		// NEW(mib) check for pickups stuck in PHYS_Falling

event Replication()
{
	if ( bOnlyReplicateHidden )
	{
		DOREP('bHidden');
//NEW MJL
		if( bNetInitial )
		{
			DOREP('Rotation');
			if( Physics == PHYS_Falling )
				FORCEREP('Velocity');
		}
//OLD
	}
	else
		Super.Replication();
}

//NEW MJL
simulated function PostRecvVelocity()
{
	SetPhysics( PHYS_Falling );
}
//OLD

//NEW: player-only pickups
event PostBeginPlay()
{
	Super.PostBeginPlay();

	if( bPlayerOnly )
		MaxDesireability = -999;

	if( bEditorPlaced )
		FallingTimeoutDelay = 5.0;
	else
		FallingTimeoutDelay = 15.0;

	AddTimer( StopFallingTimer, FallingTimeoutDelay );
}
//OLD

event Destroyed()
{
	if (MyMarker != None )
		MyMarker.markedItem = None;	
	if (Inventory != None )
		Inventory.Destroy();

	RemoveAllTimers(); //NEW(mib) falling timer cleanup
	Super.Destroyed();
}

/* Reset() 
reset actor to initial state - used when restarting level without reloading.
*/
function Reset()
{
	if ( Inventory != None )
		destroy();
	else
	{
		GotoState('Pickup');
		Super.Reset();
	}
}

/* Pickups have 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 
//NEW (mdf)
 FindBestInventory() navigation intrinsic (via the Controller's Desireability event).
//OLD 
 FindPathToBestInventory() navigation intrinsic.
*/
function float BotDesireability( pawn Bot )
{
	local Inventory AlreadyHas;
	local float desire;

	desire = MaxDesireability;

	if ( RespawnTime < 10 )
	{
		AlreadyHas = Bot.FindInventoryType(InventoryType); 
		if ( AlreadyHas != None ) 
		{
			if ( Inventory != None )
			{
				if( Inventory.Charge <= AlreadyHas.Charge )
					return -1;
			}
			else if ( InventoryType.Default.Charge <= AlreadyHas.Charge )
				return -1;
		}
	}
	return desire;
}

// Either give this inventory to player Other, or spawn a copy
// and give it to the player Other, setting up original to be respawned.
//
function inventory SpawnCopy( pawn Other )
{
	local inventory Copy;

	if ( Inventory != None )
	{
		Copy = Inventory;
		Inventory = None;
	}
	else
		Copy = spawn(InventoryType,Other,,,rot(0,0,0));

	if (Weapon(Copy)?) MaybeAddMoreAmmo(Weapon(Copy),Other);	//NEW
	Copy.GiveTo( Other );

//NEW
	Copy.TransferProperties( self );
//OLD
//NEW MJL code that is done by SetRespawn ... useless here
/*OLD
	if( Level.Game.ShouldRespawn(self) )
		StartSleeping();
	else
		Destroy();
*/
	return Copy;
}

function bool MaybeAddMoreAmmo( Weapon W, Pawn Other ){ return false; }	//NEW

function StartSleeping()
{
	GotoState('Sleeping');
}

function AnnouncePickup( Pawn Receiver )
{
	Receiver.HandlePickup(self);
	PlaySound( PickupSound,,2.0 );
	TriggerEvent( Event, Receiver, Receiver );	//NEW (mw)
	if ( Level.Game.StatLog != None )
		Level.Game.StatLog.LogPickup(self, Receiver);
	SetRespawn();
}

//
// Set up respawn waiting if desired.
//
function SetRespawn()
{
	if( Level.Game.ShouldRespawn(self) )
		GotoState('Sleeping');
	else
		Destroy();
}

// HUD Messages

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

function InitDroppedPickupFor(Inventory Inv)
{
	SetPhysics(PHYS_Falling);
	GotoState('');
/*OLD: Don't store old Inventory -- this causes lots of problems
	Inventory = Inv;
*/
//NEW MJL: optimized code, not relying on these
/*OLD
	bAlwaysRelevant = false;
	bOnlyReplicateHidden = false;
*/
}

function bool ReadyToPickup(float MaxWait)
{
	return false;
}

event Landed(Vector HitNormal)
{
	RemoveTimer( StopFallingTimer ); //NEW
	GotoState('Pickup');
}

//NEW (mib) falling timer prevents pickups from stay in PHYS_Falling (performance)
function StopFalling()
{
	SetPhysics( PHYS_None );
	GotoState('Pickup');
}
//OLD

//=============================================================================
// Pickup state: this inventory item is sitting on the ground.

auto state Pickup
{
//NEW (mdf) Pathing -- player-only inventory 
	function float BotDesireability( pawn Bot )
	{
		if( bPlayerOnly )
		{
			return -999;
		}
		else
		{
			return Global.BotDesireability( Bot );
		}
	}
//OLD

	function bool ReadyToPickup(float MaxWait)
	{
		return true;
	}

	/* ValidTouch()
	 Validate touch (if valid return true to let other pick me up and trigger event).
	*/
	function bool ValidTouch( actor Other )
	{
		// make sure its a live player
//NEW (mdf) PlayerOnlyPickups
		if ( (Pawn(Other) == None) || !Pawn(Other).bCanPickupInventory || (Pawn(Other).Health <= 0) || (bPlayerOnly && PlayerController(Pawn(Other).Controller) == None) )
/*OLD
		if ( (Pawn(Other) == None) || !Pawn(Other).bCanPickupInventory || (Pawn(Other).Health <= 0) )
*/
			return false;

		//!!ARL (mdf) is this why you can now pick things up through walls (e.g. inside 
		// lockers)? The test should probably just be made more robust -- e.g. if 
		// !FastTrace then call CanSeeActor etc. with a flag to control this.
		/*OLD (arl): We don't really need this, and it actually makes pickups harder to pickup in places that you should be able to.
		// make sure not touching through wall
		if ( !FastTrace(Other.Location, Location) )
			return false;
		*/
		
		// make sure game will let player pick me up
		if( Level.Game.PickupQuery(Pawn(Other), self) )
		{
			TriggerEvent(Event, self, Pawn(Other));
			return true;
		}
		return false;
	}
		
	// When touched by an actor.
	event Touch( actor Other )
	{
		local Inventory Copy;

		// If touched by a player pawn, let him pick this up.
		if( ValidTouch(Other) )
		{
			Copy = SpawnCopy(Pawn(Other));
			AnnouncePickup(Pawn(Other));
			Copy.PickupFunction(Pawn(Other));
		}
/*OLD MJL: DO allow it to pile up, or you can accidentally lose weapons/inventory, which sucks
		// don't allow inventory to pile up (frame rate hit)
		else if ( (Inventory != None) && Other.IsA('Pickup')
				&& (Pickup(Other).Inventory != None) )
				Destroy();
*/
	}

	// Make sure no pawn already touching (while touch was disabled in sleep).
	function CheckTouching()
	{
		local Pawn P;

		ForEach TouchingActors(class'Pawn', P)
			Touch(P);
	}

	event Timer()
	{
		if ( Inventory != None )
		{
			if (  (FRand() < 0.1) || !PlayerCanSeeMe() )
				Destroy();
			else
				SetTimer(3.0, true);
		}
	}

	event BeginState()
	{
/*OLD (arl) we don't want pickups to disappear in singleplayer.
		if ( Inventory != None )
			SetTimer(20, false);
*/
	}

Begin:
	CheckTouching();
}


//=============================================================================
// Sleeping state: Sitting hidden waiting to respawn.

State Sleeping
{
	ignores Touch;

	function bool ReadyToPickup(float MaxWait)
	{
		return (LatentFloat < MaxWait);
	}

	function StartSleeping() {}

	event BeginState()
	{
		bHidden = true;
	}
	event EndState()
	{
		bHidden = false;
	}			
Begin:
	//NEW (mdf) 
	/*
	Note that FindBestInventory pathing code assumes that LatentFloat 
	represents time left to respawn! If any pickup state calls a latent 
	function for any other reason than to sleep while pickup is hidden
	this could bork pathing code. It would pbly be best to have a
	separate property (RespawnTime) to track this.
	*/
	//OLD
	Sleep( ReSpawnTime );
	Sleep( Level.Game.PlaySpawnEffect(self) );
	GoToState( 'Pickup' );
}

defaultproperties
{
	MaxDesireability=0.005000
	bOnlyReplicateHidden=true
	PickupMessage="Snagged an item."
	Physics=PHYS_Falling
	DrawType=DT_Mesh
	bOrientOnSlope=true
	bIgnoreSingularityDamage=false
	bIgnoreSingularityForces=false
	bAlwaysRelevant=true
	RemoteRole=ROLE_SimulatedProxy
	Texture=Texture'Engine.S_Inventory'
	bCollideActors=true
	bCollideWorld=true
	bFixedRotationDir=true
	DesiredRotation=(Yaw=30000)
	NetPriority=1.400000
	NetUpdateFrequency=8.000000
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}