Legend.TracerStreak

//=============================================================================
// TracerStreak.uc
// $Author: Mfox $
// $Date: 4/30/02 12:22p $
// $Revision: 3 $
//=============================================================================

//------------------------------------------------------------------------------
// Description:	Effect for simulating a tracer bullet.
//------------------------------------------------------------------------------
// How to use this class:
//
// + Spawn it.
// + Set the endpoints for where the streak will be drawn from/to in the same tick.
// + The fading process is automatically started on the next tick.
//------------------------------------------------------------------------------
// How this class works:
//
// + Connects the two endpoints with large segments. 
// + Starting with the first segment, it is broken into two parts.
// + Then of those two new segments, the first one is broken into two parts.
// + Then of those two new segments, the first one is faded out. 
//   (Using ScaleGlow/Translucency).
// + Once the first segment is completely faded away, the second is faded out.
// + Then the second (next larger) segment is broken in two and those are 
//   faded out.
// + This continues until all the segments are faded out.
// + If bUseLifeSpan is set to true, streaks aren't faded out -- their LifeSpan
//   will determine how long they last (e.g. 0.0 ==> forever).
//------------------------------------------------------------------------------

class TracerStreak extends Effects;

//////////////////////
// Member variables //
//////////////////////

const MaxSegmentTypes = 16;

// Endpoints of streak.
var() vector Start;
var() vector End;
var() Texture SkinToUseForSegments;

var() class<TracerSeg> SegmentTypes[MaxSegmentTypes];
var bool bUseLifeSpan;				// if true don't fade out streaks

var TracerSeg CurrentSegment;

////////////////
// Interfaces //
////////////////

//------------------------------------------------------------------------------
// This function must be called on the server in the same tick within which it
// was spawned.  The fading process will begin automatically on the next tick.
//------------------------------------------------------------------------------
function SetEndpoints( vector StartPoint, vector EndPoint )
{
	Start = StartPoint;
	End = EndPoint;
}

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

function SetSkin( Texture NewSkin )
{
	SkinToUseForSegments = NewSkin;
}

//------------------------------------------------------------------------------
simulated function FinishedFading();

///////////
// Logic //
///////////

//------------------------------------------------------------------------------
simulated event Tick( float DeltaTime )
{
	if( Start != End )
	{
		GotoState('Fading');
	}
	else
	{
		Destroy();
	}
}

//------------------------------------------------------------------------------
simulated state Fading
{
	simulated event BeginState()
	{
		local vector CurrentPos;
		local vector StreakDirection;
		local rotator StreakRotation;
		local TracerSeg Seg, FirstSegment, NewSegment;
		local float DesiredLen, RemainingLen, TotalLenSoFar;
		local int SegIndex;

		StreakDirection = Normal(End - Start);
		StreakRotation = rotator(StreakDirection);

		CurrentPos = Start;
		SegIndex = 0;
		TotalLenSoFar = 0.0;
		DesiredLen = VSize( End - Start );

		while( (DesiredLen - TotalLenSoFar) >= 2.0 )
		{
			// use largest segment that will not exceed endpoint
			RemainingLen = DesiredLen - TotalLenSoFar;
			while( SegmentTypes[SegIndex+1] != None && SegmentTypes[SegIndex].default.SegmentLength > RemainingLen )
			{
				SegIndex++;
			}

			// spawn it at the current location
			NewSegment = Spawn( SegmentTypes[SegIndex],,, CurrentPos, StreakRotation );

			if( SkinToUseForSegments != None )
			{
				NewSegment.Skins[0] = SkinToUseForSegments;
			}

			// insert new segment into linked list
			if( TotalLenSoFar ~= 0.0 )
			{
				FirstSegment = NewSegment;
				Seg = NewSegment;
			}
			else
			{
				Seg.NextSegment = NewSegment;
				Seg = Seg.NextSegment;
			}
			Seg.Parent = Self;

			// update loop control vars
			CurrentPos += StreakDirection * SegmentTypes[SegIndex].default.SegmentLength;
			TotalLenSoFar += SegmentTypes[SegIndex].default.SegmentLength;
		}

		if( bUseLifeSpan )
		{
			Destroy();
		}
		else
		{
			Seg.NextSegment = None;

			CurrentSegment = FirstSegment;

			CurrentSegment.Fade();
		}
	}

	// Notification for when our currently fading segment is finished.
	simulated function FinishedFading()
	{
		CurrentSegment = CurrentSegment.NextSegment;
		if( CurrentSegment != None )
		{
			CurrentSegment.Fade();
		}
		else
		{
			Destroy();
		}
	}
}

defaultproperties
{
	bHidden=true
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}