U2.U2UseManagerPlayer

//=============================================================================
// $Author: Mbaldwin $
// $Date: 12/15/02 2:21a $
// $Revision: 43 $
//=============================================================================

//------------------------------------------------------------------------------
// Name:	U2UseManagerPlayer.uc
// Author:	Aaron R Leiby
// Date:	18 December 2000
//------------------------------------------------------------------------------
// Description:	
//------------------------------------------------------------------------------
// Notes:
//------------------------------------------------------------------------------
// How to use this class:
//------------------------------------------------------------------------------

class U2UseManagerPlayer extends U2UseManager;

//------------------------------------------------------------------------------
// ui events
const UseReticleOnEvent			= "UseReticleOn";
const UseReticleOffEvent		= "UseReticleOff";
const ProximityReticleOnEvent	= "ProximityReticleOn";
const ProximityReticleOffEvent	= "ProximityReticleOff";

const ActorBracketPercent	= 0.80;					// portion of bounding box to span
const MainBracketPercent	= 1.00;
const PawnBracketPercent	= 0.80;

const ActorBracketWidth		= 16;					// Size of upper and lower bracket icons
const ActorBracketHeight	= 8;
const MainBracketWidth		= 26;					// Size of left and right bracket icons
const MainBracketHeight		= 15;
const PawnBracketWidth		= 15;
const PawnBracketHeight		= 16;

const MarginActorX			= 20;					// Minimum distances from the corners for the side / top brackets
const MarginPawnY			= 5;

const ScreenClampPctX		= 0.1;
const ScreenClampPctY		= 0.1;

const MinProximityAngleCos	= 0.643;				// spread angle of cone [0.643 ~= cos(50 degrees)]
const MaxProximityDist		= 512.0;				// depth of cone

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

var bool bEnabled;									// toggle to enable/disable the use reticle entirely
var float UseDistance;								// max distance at which actors can be used
var float Proximity;								// a measure of how close (distance and direction) the player is to the target

// Reticle
var bool bOn;										// is the reticle being displayed?
var Point MainBrackets[4];							// screen positions for corner brackets (all actors)
var Point ActorBrackets[4];							// screen positions for non-pawn brackets
var Point PawnBrackets[4];							// screen positions for pawn-specific brackets
var vector LineSize;								// length of line connecting brackets
var localized string TargetText;					// Text to display in use reticle

///////////////
// Interface //
///////////////

static function LookingAt( U2Pawn UsingPawn, Actor _Target )
{
	local int iMgr, iActor;
	local float Proximity;
	local actor A;
	local actor HitActor;
	local vector HitLocation, HitNormal, Extent;
	local vector CameraLocation;
	local rotator CameraRotation;
	local U2PlayerController U2PC;

	if( UsingPawn != None )
	{
		//UsingPawn.DMT( "LookingAt: " $ _Target ) ;
		if( _Target != None && !_Target.IsUsable( UsingPawn.Controller ) )
		{
			//UsingPawn.DMT( "  Target isn't useable" );
			_Target = None;
		}

		// remove reticles for actors that are no longer in the player's cone of detection
		for( iMgr=0; iMgr < UsingPawn.AlternateUseManagers.Length; iMgr++ )
		{
			A = UsingPawn.AlternateUseManagers[iMgr].Target;
			if( A!=None && (A == _Target || !ShouldShowAltReticle( UsingPawn, A, true )) )
			{
				//if( A == _Target ) UsingPawn.DMT(A @ "is going from proximity reticle to use reticle" );
				UsingPawn.AlternateUseManagers[iMgr].SetAlternate( UsingPawn, None, iMgr, 0.0 );
			}
		}

		// iterate through usable actors and highlight the ones that are in close enough proximity to the player.
		iMgr=0;
		for( iActor=0; iActor < UsingPawn.UsableActors.Length; iActor++ )
		{
			A = UsingPawn.UsableActors[iActor];
			if( A != _Target && ShouldShowAltReticle( UsingPawn, A, false ) )
			{
				Proximity = GetProximity( UsingPawn, A );
				if( Proximity > 0.0 )
				{
					// try to find an existing use manager that has this target
					for( iMgr=0; iMgr < UsingPawn.AlternateUseManagers.Length; iMgr++ )
						if( UsingPawn.AlternateUseManagers[iMgr].Target == A )
							break;

					// try to find an available alternate use manager
					if( iMgr >= UsingPawn.AlternateUseManagers.Length )
					{
						for( iMgr=0; iMgr < UsingPawn.AlternateUseManagers.Length; iMgr++ )
							if( UsingPawn.AlternateUseManagers[iMgr].Target == None )
								break;
					}

					// similar trace to that of the use manager
					U2PC = U2PlayerController(UsingPawn.Controller);
					U2PC.PlayerCalcView( HitActor, CameraLocation, CameraRotation );
					HitActor = U2PC.Trace( HitLocation, HitNormal, A.Location, CameraLocation, true, vect(0,0,0), /*material*/, TRACE_AllColliding | TRACE_Usable );
					if( HitActor == A )
						SetAlternate( UsingPawn, A, iMgr, Proximity );
				}
			}
		}

		// optimization (LookingAt called every Tick for player and often looking at same thing)
		if( UsingPawn.UseManager == None || 
			UsingPawn.UseManager.Target != _Target ||
			( U2UseManagerPlayer(UsingPawn.UseManager).bOn && _Target == None ) ) // shutdown reticle when target gets destroyed
			Super.LookingAt( UsingPawn, _Target );
	}
}

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

static function SetEnabled( U2Pawn UsingPawn, bool bNewValue )
{
	local int i;
	local U2UseManagerPlayer U2UMP;
	
	if( UsingPawn != None )
	{
		U2UMP = U2UseManagerPlayer(UsingPawn.UseManager);
		if( U2UMP != None )
		{
			if( U2UMP.bEnabled && !bNewValue )
			{
				U2UMP.bOn = false;
				class'UIConsole'.static.SendEvent( UseReticleOffEvent );
				//U2UMP.DMT("Disabling Use Manager");
			}
			else
				//U2UMP.DMT("Enabling Use Manager");

			U2UMP.bEnabled = bNewValue;
		}


		for( i=0; i < UsingPawn.AlternateUseManagers.Length; i++ )
		{
			U2UMP = UsingPawn.AlternateUseManagers[i];
			if( U2UMP != None )
			{
				if( U2UMP.bEnabled && !bNewValue )
				{
					U2UMP.bOn = false;
					class'UIConsole'.static.SendEvent( ProximityReticleOffEvent $ i );
					//U2UMP.DMT("Disabling proximity reticle for" @ U2UMP.Target);
				}
				else
					//U2UMP.DMT("Enabling proximity reticle for" @ U2UMP.Target);
				U2UMP.bEnabled = bNewValue;
			}
		}
	}
}

/////////////
// Helpers //
/////////////

static protected function SetCurrent( U2Pawn UsingPawn, Actor _Target )
{
	local int i;
	local U2UseManagerPlayer U2UMP;
	local Actor OldTarget;

	// before we set the new target, cache the old one
	if( UsingPawn.UseManager != None )
		OldTarget = UsingPawn.UseManager.Target;

	Super.SetCurrent( UsingPawn, _Target );

	U2UMP = U2UseManagerPlayer(UsingPawn.UseManager);
	if( U2UMP.bEnabled )
	{
		if( U2UMP.Target != None )
		{
			U2UMP.TargetText = default.TargetText;
			if( U2UMP.Target.Speaker != "" )
				U2UMP.TargetText = U2UMP.Target.Speaker;
			if( U2UMP.Target.GetDescription() != "" )
				U2UMP.TargetText = U2UMP.Target.GetDescription();

			// turn off the use reticle for the old class of target
			// before displaying the reticle for the new target
			if( OldTarget == None )
			{
				//UsingPawn.DMT( "ReticleOn (old target = none)" );
				U2UMP.bOn=true;
				class'UIConsole'.static.SendEvent( UseReticleOnEvent );
			}
			else if( OldTarget.Class != _Target.Class )
			{
				//UsingPawn.DMT( "ReticleOn (old target class != new target class)" );
				U2UMP.bOn=true;
				class'UIConsole'.static.SendEvent( UseReticleOffEvent );
				class'UIConsole'.static.SendEvent( UseReticleOnEvent );
			}
			else
			{
				//UsingPawn.DMT( "ReticleOn (old target class SAME AS new target class)" );
			}

			for( i=0; i < _Target.UseReticleOnEvents.Length; i++ )
				class'UIConsole'.static.SendEvent( _Target.UseReticleOnEvents[i] );
		}
		else
		{
			//UsingPawn.DMT( "ReticleOff:  bOn" @ U2UMP.bOn );
			U2UMP.bOn=false;
			class'UIConsole'.static.SendEvent( UseReticleOffEvent );
		}
	}
}

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

static protected function SetAlternate( U2Pawn UsingPawn, Actor _Target, int Index, float _Proximity )
{
	local int i;
	local U2UseManagerPlayer U2UMP;
	local actor OldTarget;

	if( UsingPawn==None ) return;

	if( Index < UsingPawn.AlternateUseManagers.Length )
	{
		U2UMP = UsingPawn.AlternateUseManagers[Index];
		OldTarget = U2UMP.Target;
	}
	else
	{
		//UsingPawn.DMT( "Creating a new alternate for:" @ _Target );
		UsingPawn.AlternateUseManagers[Index] = UsingPawn.Spawn( default.Class );
		U2UMP = UsingPawn.AlternateUseManagers[Index];
	}
		
	U2UMP.Target = _Target;
	U2UMP.Proximity = _Proximity;
	U2UMP.TargetText = "";

	if( U2UMP.bEnabled )
	{
		if( U2UMP.Target != None )
		{
			// turn off the use reticle for the old class of target
			// before displaying the reticle for the new target
			if( OldTarget == None )
			{
				//UsingPawn.DMT( "ReticleOn (old target = none)" );
				U2UMP.bOn=true;
				class'UIConsole'.static.SendEvent( ProximityReticleOnEvent $ Index );
			}
			else if( OldTarget.Class != _Target.Class )
			{
				//UsingPawn.DMT( "ReticleOn (old target class != new target class)" );
				U2UMP.bOn=true;
				class'UIConsole'.static.SendEvent( ProximityReticleOffEvent $ Index );
				class'UIConsole'.static.SendEvent( ProximityReticleOnEvent $ Index );
			}
			else
			{
				//UsingPawn.DMT( "ReticleOn (old target class SAME AS new target class)" );
			}

			for( i=0; i < _Target.ProximityReticleOnEvents.Length; i++ )
				class'UIConsole'.static.SendEvent( _Target.ProximityReticleOnEvents[i] $ Index );
		}
		else
		{
			//UsingPawn.DMT( "ReticleOff -- Index:" @ Index @ "OldTarget:" @ OldTarget @ "New Target:");
			if( OldTarget != None )
			{
				U2UMP.bOn=false;
				class'UIConsole'.static.SendEvent( ProximityReticleOffEvent $ Index );
			}
		}
	}
}

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

static function bool ShouldShowAltReticle( U2Pawn UsingPawn, Actor A, bool bTestProximity )
{
	local Trigger T;
	local float SavedUseDistance;
	local Actor HitActor;
	local vector HitLocation, HitNormal, Extent;
	local vector CameraLocation;
	local rotator CameraRotation;
	local U2PlayerController U2PC;

	T = Trigger(A);
	if( T != None )
	{
		// hide easter eggs
		if( T.bNoProximityReticle ) return false;

		// we need to do the usability test
		SavedUseDistance = T.UseDistance;
		T.UseDistance = 0;
	}

	// hide non-usable actors 
	if( !A.IsUsable(UsingPawn) ) return false;

	// restore trigger properties
	if( T != None )
		T.UseDistance = SavedUseDistance;

	// hide actors not in cone of detection
	if( bTestProximity && GetProximity( UsingPawn, A ) <= 0.0 ) return false;

	return true;
}

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

static function float GetProximity( U2Pawn UsingPawn, Actor Target )
{
	local PlayerController PC;
	local vector TargetDir;
	local float AngleScaleFactor, DistScaleFactor, Result;
	local float Distance, DP;

	if( Target != None && Target != UsingPawn )
	{
		PC = PlayerController(UsingPawn.Controller);
		if( PC != None )
		{
			Distance = class'Util'.static.GetDistanceBetweenActors( UsingPawn, Target );
			if( Distance < MaxProximityDist )
			{
				TargetDir = Normal( Target.Location - UsingPawn.Location );
				DP = TargetDir dot vector(PC.Rotation);
				if( DP >= MinProximityAngleCos )
				{
					AngleScaleFactor = (DP - MinProximityAngleCos) / (1.0 - MinProximityAngleCos);
					DistScaleFactor = (MaxProximityDist - Distance) / MaxProximityDist;
					Result = AngleScaleFactor * DistScaleFactor;
					//UsingPawn.DMT("GetProximity(" @ Target @ ") AngleScale:" @ AngleScaleFactor @ "DistanceScaleFactor:" @ DistScaleFactor );
				}
			}
		}
	}

	return Result;
}

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

static simulated function RenderOverlaysStatic( U2Pawn UsingPawn, Canvas Canvas )
{
	local int i;
	
	if( UsingPawn != None && UsingPawn.Controller != None && Viewport(U2PlayerController(UsingPawn.Controller).Player) != None )
	{
		// render the use reticle
		if( U2UseManagerPlayer(UsingPawn.UseManager) != None )
			U2UseManagerPlayer(UsingPawn.UseManager).RenderOverlays( UsingPawn, Canvas );

		// render the proximity reticles
		for( i=0; i < UsingPawn.AlternateUseManagers.Length; i++ )
			UsingPawn.AlternateUseManagers[i].RenderOverlays( UsingPawn, Canvas );
	}
}

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

function RenderOverlays( Actor A, Canvas Canvas )
{
	local int i;
	local box Bbox;
	local vector Min, Max, Cur, Extent, HalfLineSize, Verts[8];
	local Point Center;
	local Dimension ScreenSize, Margin;

	//DMTN( "RenderOverlays: " $ A );

	// get updated screen coords for reticle
	if( Target != None && !Target.bDeleteMe )
	{
		// project all corners of the targets bounding box to the screen
		Bbox = Target.GetCollisionBoundingBox( Target );
		Extent = Bbox.Max - Bbox.Min;

		Verts[0] = Bbox.Min;
		Verts[1] = Bbox.Min + vect( 1, 0, 0 ) * Extent.X;
		Verts[2] = Bbox.Min + vect( 0, 1, 0 ) * Extent.Y;
		Verts[3] = Bbox.Min + vect( 0, 0, 1 ) * Extent.Z;
		Verts[4] = Bbox.Max - vect( 1, 0, 0 ) * Extent.X;
		Verts[5] = Bbox.Max - vect( 0, 1, 0 ) * Extent.Y;
		Verts[6] = Bbox.Max - vect( 0, 0, 1 ) * Extent.Z;
		Verts[7] = Bbox.Max;

		// Bound the projected 2D verts
		Min = Canvas.Project( Verts[0] );
		Max = Min;

		for( i=1; i<8; i++ )
		{
			Cur = Canvas.Project( Verts[i] );			
			Min.X = FMin( Cur.X, Min.X );
			Min.Y = FMin( Cur.Y, Min.Y );
			Max.X = FMax( Cur.X, Max.X );
			Max.Y = FMax( Cur.Y, Max.Y );
		}

		// clamp to the screen size
		ScreenSize = class'UIConsole'.static.GetComponentSize( class'UIConsole'.static.GetUIConsole().Root );
		Margin.Width  = ScreenSize.Width  * ScreenClampPctX;
		Margin.Height = ScreenSize.Height * ScreenClampPctY;
		Min.X = FMax( Min.X, Margin.Width );
		Min.Y = FMax( Min.Y, Margin.Height );
		Max.X = FMin( Max.X, ScreenSize.Width  - Margin.Width  );
		Max.Y = FMin( Max.Y, ScreenSize.Height - Margin.Height );

		// find the center of the reticle
		Center.X = (Min.X + Max.X) * 0.5;
		Center.Y = (Min.Y + Max.Y) * 0.5;

		// make sure min and max aren't too close together -- leave rooom for the assets
		if( Max.X - Center.X < ActorBracketWidth + MarginActorX )
		{
			Min.X = Center.X - ActorBracketWidth - MarginActorX;
			Max.X = Center.X + ActorBracketWidth + MarginActorX;
		}

		if( Max.Y - Center.Y < PawnBracketHeight + MarginPawnY )
		{
			Min.Y = Center.Y - PawnBracketHeight - MarginPawnY;
			Max.Y = Center.Y + PawnBracketHeight + MarginPawnY;
		}

		// compute line size based on leftover space
		LineSize.X = Max.X - Min.X - 2.0*(ActorBracketWidth+MarginActorX);
		LineSize.Y = Max.Y - Min.Y - 2.0*MainBracketHeight;
		LineSize.Z = Max.Y - Min.Y - 2.0*(PawnBracketHeight+MarginPawnY);

		// leave some space between the lines and the brackets (makes the reticle more dynamic looking)
		LineSize.X *= ActorBracketPercent;
		LineSize.Y *= MainBracketPercent;
		LineSize.Z *= PawnBracketPercent;

		// cache the half line size for the calculations below
		HalfLineSize = LineSize * 0.5;

		ActorBrackets[0].X = Center.X - HalfLineSize.X - ActorBracketWidth;		// NW
		ActorBrackets[0].Y = Min.Y;
		ActorBrackets[1].X = Center.X + HalfLineSize.X;							// NE
		ActorBrackets[1].Y = ActorBrackets[0].Y;

		ActorBrackets[2].X = ActorBrackets[0].X;								// SW
		ActorBrackets[2].Y = Max.Y - ActorBracketHeight;
		ActorBrackets[3].X = ActorBrackets[1].X;								// SE
		ActorBrackets[3].Y = Max.Y - ActorBracketHeight;

		MainBrackets[0].X = Min.X;												// NW
		MainBrackets[0].Y = Center.Y - HalfLineSize.Y - MainBracketHeight;
		MainBrackets[1].X = Min.X;												// SW
		MainBrackets[1].Y = Center.Y + HalfLineSize.Y;

		MainBrackets[2].X = Max.X - MainBracketWidth;							// NE
		MainBrackets[2].Y = MainBrackets[0].Y;
		MainBrackets[3].X = Max.X - MainBracketWidth;							// SE
		MainBrackets[3].Y = MainBrackets[1].Y;

		PawnBrackets[0].X = Min.X;												// NW
		PawnBrackets[0].Y = Center.Y - HalfLineSize.Z - PawnBracketHeight;
		PawnBrackets[1].X = Min.X;												// SW
		PawnBrackets[1].Y = Center.Y + HalfLineSize.Z;

		PawnBrackets[2].X = Max.X - PawnBracketWidth;							// NE
		PawnBrackets[2].Y = PawnBrackets[0].Y;
		PawnBrackets[3].X = Max.X - PawnBracketWidth;							// SE
		PawnBrackets[3].Y = PawnBrackets[1].Y;
	}
}

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

// Accessors (for UseReticleMonkey)
simulated function Point MainBracketNW()			{ return MainBrackets[0];	}
simulated function Point MainBracketSW()			{ return MainBrackets[1];	}
simulated function Point MainBracketNE()			{ return MainBrackets[2];	}
simulated function Point MainBracketSE()			{ return MainBrackets[3];	}

simulated function Point PawnBracketNW()			{ return PawnBrackets[0];	}
simulated function Point PawnBracketSW()			{ return PawnBrackets[1];	}
simulated function Point PawnBracketNE()			{ return PawnBrackets[2];	}
simulated function Point PawnBracketSE()			{ return PawnBrackets[3];	}

simulated function Point ActorBracketNW()			{ return ActorBrackets[0];	}
simulated function Point ActorBracketNE()			{ return ActorBrackets[1];	}
simulated function Point ActorBracketSW()			{ return ActorBrackets[2];	}
simulated function Point ActorBracketSE()			{ return ActorBrackets[3];	}

simulated function float LineWidth()				{ return LineSize.X;		}
simulated function float LineHeight()				{ return LineSize.Z;		}

simulated function float GetAlpha()					{ return Proximity * 255;	}

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

simulated function float GetHealth()
{
	if( Pawn(Target) != None )
		return float(Pawn(Target).Health) / float(Pawn(Target).default.Health);
	else
		return 0;
}

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

simulated function string GetUseText()
{
	//DMTN( "GetUseText: " $ Target );
	return TargetText;
}

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

defaultproperties
{
	bEnabled=true
	UseDistance=200.000000
	TargetText="Item"
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}