Engine.ScriptedLight

//NEW: ScriptedLight

//=============================================================================
// $Author: Mfox $
// $Date: 6/25/02 11:36p $
// $Revision: 3 $
//=============================================================================

//------------------------------------------------------------------------------
// Name:	ScriptedLight.uc
// Author:	Aaron R Leiby
// Date:	07 December 1999
//------------------------------------------------------------------------------
// Description:	A light that can be scripted to change its properties 
//				over time.
//------------------------------------------------------------------------------
// How to use this class:
//
// + Set up some templates by filling in the ScriptedLightData array.
//   (Slot 0 is associated with the letter A.  1 is B, 2 is C, etc.)
//
// + TweenToTime is the amount of time it takes to reach the desired
//   settings.  The color will tween using the associated RGB values
//   (rather than HSB) to avoid rainbow effects that would be caused
//   by iterating across Hue values.  If you want the transition to 
//   happen instantly, simply leave this value at zero.
//
// + Duration is the amount of time the light will remain at the desired
//   settings for that template, once it reaches it.  Once again, this
//   value can be left at zero if you simply want it to reach the settings
//   and then continue onto the next settings.  Most likely, you won't 
//   want both TweenToTime and Duration to be zero, since the settings 
//   won't show up in that case.
//
// + Brightness, Hue and Saturation are same as the settings for any
//   other light.  They get converted to RGB values under the hood for 
//   smooth transitioning, but that shouldn't affect how you use them.
//
// + Once you have a few templates filled in, you can then create a 
//   Script using that data by filling in the LightScript string.
//   Note: You should only use the capital letters A...Z.  All other 
//   ASCII values are undefined.
//   You can use any slot in the ScriptedLightData array.  There's nothing
//   sacred about starting with ABC.  If you want, you can go right to the
//   end and start with XYZ, or whatever your heart desires.  Personally,
//   I don't know what letter the number 14 represents without singing
//   through my alphabet, counting on my fingers.  So usually starting with
//   ABC is easiest.  I doubt most lights will use more than the first 
//   couple slot.  In any case, I've provide a quick reference chart to allow
//   you to look up the associated letters.
//   This Script can include any of the set templates, in any order, and
//   may be repeated as many times as desired.  (Example: ABCB)  This will
//   Use template A, then B, then C, then back to B, then it will start all
//   over again with ABCBABCBABCB... forever.  Obviously this will allow 
//   for some cool effects.
//
// + Finally, you can use the LightScriptTimeOffset, to offset the starting
//   time for the first template to be used.  This is generally used to
//   make lights that "propogate" -- first one turns on, then the next, then
//   the next... light runner lights at an airport.  This value is in seconds.
//   Because this time is only taken into account when the light is first
//   created, it makes it hard to visualize how it will all come out in the
//   editor.  In an effort to cater to this, if you turn off real-time mode
//   in the perspective window (the little joystick icon) for more than 3
//   seconds (or do any other operation that will stop time for more than 3
//   seconds -- light rebuilding the level or lighting or whatever), this
//   will reset the lights, and they will all start over at the same time,
//   bringing them back into sync.
//
//------------------------------------------------------------------------------
// Quick Reference:
//
// A=0
// B=1
// C=2
// D=3
// E=4
// F=5
// G=6
// H=7
// I=8
// J=9
// K=10
// L=11
// M=12
// N=13
// O=14
// P=15
// Q=16
// R=17
// S=18
// T=19
// U=20
// V=21
// W=22
// X=23
// Y=24
// Z=25
//------------------------------------------------------------------------------

class ScriptedLight extends Light
	native;

var() struct ScriptedLightInfo
{
	var() float	TweenToTime;
	var() float	Duration;		// Doesn't include TweenToTime.
	var() byte	Brightness,
				Hue,
				Saturation;
} ScriptedLightData[26];		// ABCDEF...Z

var() string	LightScript;			// Repeating light sequence.
var() string	LightScriptRampUp;		// Script executed when turned on  (non-repeating).
var() string	LightScriptRampDown;	// Script executed when turned off (non-repeating).
var() float		LightScriptTimeOffset;	// Countdown before execution once turned on.
var() bool		bRandomizeScript;		// Picks a random entry in LightScript each iteration,
										// rather than iterating through it sequentially.
										// (Does not affect RampUp or RampDown.)

var() bool		bReset;					// Set this to true to reset the light.
										// (Useful for getting a bunch of lights 
										// back in sync in the editor.)
										// [It will automatically be reset back to false for
										// you, so it works like a button.]

// Used interally.
var private transient float		SL_Brightness;
var private transient vector	SL_Color;
var private transient float		SL_LastBrightness;
var private transient vector	SL_LastColor;
var private transient bool		SL_Initialized;
var private transient int		SL_Index;
var private transient float		SL_Duration;
var private transient float		SL_TweenTime;
var private transient float		SL_Countdown;
var private transient float		SL_TweenBrightness;
var private transient vector	SL_TweenColor;
var private transient byte		SL_DesiredBrightness;
var private transient vector	SL_DesiredColor;
var private transient float		SL_BrightnessRate;
var private transient vector	SL_ColorRate;
var private transient bool		SL_RampingUp;
var private transient bool		SL_RampingDown;

// Embedded data structure.
var private ScriptedLight NextScriptedLight;

///////////////////////
// Trigger mechanism //
///////////////////////

var() bool bInitiallyOn;
var() float TimerDuration;
var() name ProximityTypes[8];

////////////////////
// Initialization //
////////////////////

//------------------------------------------------------------------------------
simulated event PreBeginPlay()
{
	Super.PreBeginPlay();

	bReset = true;
	
	if( bInitiallyOn )
	{
		TurnOn();
	}
	else
	{
		LightType = LT_None;
		ScaleGlow = 0;
	}
}

///////////////////////
// Public interfaces //
///////////////////////

//------------------------------------------------------------------------------
public simulated function TurnOn()
{
	LightType = LT_Scripted;
	SL_RampingUp = true;
	SL_RampingDown = false;
	SL_Index = 0;
	SL_Initialized = false;
	SL_Duration = 0;			// start immediately.
}

//------------------------------------------------------------------------------
public simulated function TurnOff()
{
	LightType = LT_Scripted;	// just in case.
	SL_RampingUp = false;
	SL_RampingDown = true;		// this will eventually set LightType to LT_None.
	SL_Index = 0;
	SL_Initialized = false;
	SL_Duration = 0;			// start immediately.
}

////////////////////////
// Triggerable states //
////////////////////////

//------------------------------------------------------------------------------
// Toggles us on and off when triggered.
//------------------------------------------------------------------------------
simulated state() TriggerToggle
{
	//NEW (mdf)
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	simulated function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		if( LightType != LT_Scripted || SL_RampingDown )
		{
			TurnOn();
		}
		else
		{
			TurnOff();
		}
	}
}

//------------------------------------------------------------------------------
// Toggled when Triggered.
// Toggled back to initial state when UnTriggered.
//------------------------------------------------------------------------------
simulated state() TriggerControl
{
	//NEW (mdf)
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	simulated function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		if( bInitiallyOn )
		{
			TurnOff();
		}
		else
		{
			TurnOn();
		}
	}

	//NEW (mdf)
	simulated function UnTrigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	simulated function UnTrigger( Actor Other, Pawn EventInstigator )
	*/
	{
		if( bInitiallyOn )
		{
			TurnOn();
		}
		else
		{
			TurnOff();
		}
	}
}

//------------------------------------------------------------------------------
// Toggled when triggered.
// Toggled back to initial state after TimerDuration seconds.
//------------------------------------------------------------------------------
simulated state() TriggerTimed
{
	//NEW (mdf)
	simulated function Trigger( Actor Other, Pawn EventInstigator, optional name EventName )
	/*OLD
	simulated function Trigger( Actor Other, Pawn EventInstigator )
	*/
	{
		if( bInitiallyOn )
		{
			TurnOff();
		}
		else
		{
			TurnOn();
		}
		
		SetTimer( TimerDuration, false );
	}

	simulated event Timer()
	{
		if( bInitiallyOn )
		{
			TurnOn();
		}
		else
		{
			TurnOff();
		}
	}
}

//------------------------------------------------------------------------------
simulated state() ProximityBased
{
	public simulated event BeginState()
	{
		SetCollision( true, bBlockActors, bBlockPlayers );
	}

	public simulated event EndState()
	{
		SetCollision( bCollideActors, bBlockActors, bBlockPlayers );
	}

	public simulated event Touch( Actor Other )
	{
		if( ValidTouch(Other) )
		{
			if( bInitiallyOn ) TurnOff();
			else               TurnOn();
		}
	}

	public simulated event UnTouch( Actor Other )
	{
		if( ValidTouch(Other) )
		{
			if( bInitiallyOn ) TurnOn();
			else               TurnOff();
		}
	}

	protected simulated function bool ValidTouch( Actor Other )
	{
		local int i;

		if( Other != None )
			for( i=0; i<ArrayCount(ProximityTypes); i++ )
				if( Other.IsA( ProximityTypes[i] ) )
					return true;

		return false;
	}
}



//OLD

defaultproperties
{
	bInitiallyOn=true
	ProximityTypes(0)='Pawn'
	LightType=LT_Scripted
	bStatic=false
     UseReticleOnEvents(0)="UseReticleText"
     UseReticleOnEvents(1)="UseReticleCorners"
     UseReticleOnEvents(2)="UseReticleTopBars"
     ProximityReticleOnEvents(0)="ProximityReticleCorners"
     ProximityReticleOnEvents(1)="ProximityReticleTopBars"
}