var	OBJ_SCENE		= 0;			

var	OBJ_PLAYER		= 1;			

var PLAYER_IMAGE	= 0;			

var	PLAYER_TEXT		= 1;			

var PLAYER_DRAW		= 2;			

var	NAME_SCENE		= "S"			

var	NAME_PLAYER		= "P"			

var	PLAYER_NAME_IMAGE	= "I"		

var	PLAYER_NAME_TEXT	= "T"
var PLAYER_NAME_DRAW	= "D"
var	IE_VISIBLE			= "visible";
var	IE_HIDDEN			= "hidden";
var	IE_INHERIT			= "inherit";
var	DUR_FOREVER				= -1;		

var	DEFAULT_PLAYER_DELAY	= 0;		

var	DELAY_NONE				= 0;		

var	DELAY_UNTIL_TRANSITION	= -1;		

var	DELAY_UNTIL_TRIGGER		= -2;		

var	DUR_UNTIL_DONE			= -1;		

var TT_ALL_MOUSE_EVENTS	= 0;		

var	TT_BUTTONDOWN			= 1;		

var	TT_BUTTONUP				= 2;		

var	TT_MOUSEOVER			= 3;		

var	TT_MOUSEOUT				= 4;		

var	TB_PAGE_TURNER			= -1;		

var	TB_START_PLAYER			= -2;		

var NULL_TRANSITION = -1;
var	TEXT_FLYIN      = 101;
var TEXT_TYPEWRITER = 102;
var TRANS_FADE      = 103;
var	FLYIN_TOP				= 0;
var	FLYIN_BOTTOM			= 1;
var	FLYIN_LEFT				= 2;
var	FLYIN_RIGHT				= 3;
var	FLYIN_ROTATE			= 4;
var	FLYIN_BY_LETTER			= 1;
var	FLYIN_BY_WORD			= 2;
var	FLYIN_BY_LINE			= 3;
var	FLYIN_PER_TICK = new Array (200, 160, 120, 80, 40);		

var	TRANSITION_RATES = new Array(1,2,3,4,5);				

var k_iDefaultSceneDuration = 10000;    

g_utilDoc = parent.parent ;
window.onload  = OnLoad;
window.onerror = g_utilDoc.OnError;
function OnLoad ()
{  
InitScene (); 
StartScene ();
}
function InitBehaviors (obj)
{
var bhvIdx = 0;
if (obj.Bhv != null)
{
var bhv;
for (; (bhv = obj.Bhv[bhvIdx]) != null; bhvIdx++)
bhv.Init (obj, bhv);
}
obj.numBhv = bhvIdx; 

}
function StartBehaviors (obj)
{
if (obj.Bhv != null)
{
var bhv;
for (var bhvIdx = 0; bhvIdx < obj.numBhv; bhvIdx++)
{
bhv = obj.Bhv[bhvIdx];
if (bhv != null) 

{
if (null == bhv.delay || DELAY_NONE == bhv.delay)
bhv.Start (bhv);
else if (bhv.delay > 0)
g_utilDoc.StartOneShotTimer (bhv, bhv.delay, bhv.Start, g_utilDoc.TMR_SCENE);
}
}
}
}
function StopBehaviors (obj)
{
if (obj.Bhv != null)
{
var bhv;
for (var bhvIdx = 0; bhvIdx < obj.numBhv; bhvIdx++)
{
bhv = obj.Bhv[bhvIdx];
if (bhv != null) 

bhv.StopEverything (bhv);
}
}
}
function Scene (duration, name)
{
this.duration = duration;
this.name = name;
}
function InitScene ()
{
DocScene.HTML = document.all[DocScene.name];      

DocScene.HTML.style.visibility = IE_HIDDEN;    

if (null == DocScene.duration)
DocScene.duration = k_iDefaultSceneDuration;
InitPlayers (); 

if (null == DocScene.entryTrans)
{
DocScene.entryTrans = new Object();
DocScene.entryTrans.type = NULL_TRANSITION;
}
else if (DocScene.entryTrans.type == TRANS_FADE)
{
if (false == InitFade (DocScene))
DocScene.entryTrans.type = null;
}
InitBehaviors (DocScene);
}
function SceneExit (objScene)
{
g_utilDoc.DocSceneExit ();
}
function StartScene ()
{
StartBehaviors (DocScene);
StartScenePlayers (); 

StartTransition (DocScene, DocScene.entryTrans, IE_VISIBLE, SceneTransitionDone);
if (DocScene.duration != DUR_FOREVER)
g_utilDoc.StartOneShotTimer (DocScene, DocScene.duration, SceneExit, g_utilDoc.TMR_SCENE);
}
function StopEverythingOnScene ()
{
StopBehaviors (DocScene)
StopEverythingOnPlayers ();
}
function SceneTransitionDone (objScene)
{
if ( DocScene.Bhv != null )
for ( bhvIdx=0; bhvIdx< DocScene.numBhv; bhvIdx++ )	

{
var bhv = DocScene.Bhv[bhvIdx]
if ( bhv == null)								

continue;
if ( bhv.delay == DELAY_UNTIL_TRANSITION  )	

bhv.Start( bhv );									

}
StartScenePlayersAfterTransition ();	

}
function Player( delay, duration )
{
this.delay = delay;
this.duration = duration;
}
function ShowAllPlayers ()
{
var objPlayer = null;
for (playerName in DocScene.Players)
{
objPlayer = DocScene.Players[playerName].HTML;
objPlayer.style.visibility = IE_VISIBLE;
if (null != objPlayer.filters["alpha"]) 
objPlayer.filters["alpha"].Opacity = 100;
}
}
function InitPlayers ()
{
var objPlayer;							

var	playerNumber = 0;					

for ( playerName in DocScene.Players )
{
objPlayer = DocScene.Players[playerName];			

objPlayer.number = playerNumber;					

objPlayer.name = playerName;						

objPlayer.HTML = document.all[playerName];			

objPlayer.HTML.style.visibility = IE_HIDDEN;			

objPlayer.position = new Position(objPlayer);		

if ( objPlayer.delay == null )						

objPlayer.delay = DEFAULT_PLAYER_DELAY;			

if (objPlayer.entryTrans == null)
{
objPlayer.entryTrans = new Object();
objPlayer.entryTrans.type = NULL_TRANSITION;
}
else if (objPlayer.entryTrans.type == TRANS_FADE)
{
if (false == InitFade (objPlayer))
objPlayer.entryTrans.type = null;								

}
else if (GetPlayerTypeFromName (objPlayer.name) == PLAYER_TEXT)
{
if ( (objPlayer.entryTrans.type == TEXT_FLYIN) || (objPlayer.entryTrans.type == TEXT_TYPEWRITER) )
if (false == InitTextFlyin (objPlayer))
objPlayer.entryTrans.type = null;								

}
if ( objPlayer.exitTrans == null )
{
objPlayer.exitTrans = new Object();
objPlayer.exitTrans.type = NULL_TRANSITION;
}
else if (objPlayer.exitTrans.type == TRANS_FADE)
{
if (false == InitFade (objPlayer))
objPlayer.exitTrans.type = null;								

}
InitBehaviors (objPlayer);
playerNumber ++;					

}	
}
function StopEverythingOnPlayers ()
{
var objPlayer;							

for ( playerName in DocScene.Players )
{
objPlayer = DocScene.Players[playerName];			

StopBehaviors (objPlayer)
DisableTrigger( objPlayer );						

}	
}
function StartScenePlayers ()
{
for ( playerName in DocScene.Players )
{
objPlayer = DocScene.Players[playerName];			

if ( objPlayer.delay == DELAY_NONE )			

StartPlayer( objPlayer )						

else if ( objPlayer.delay	> 0 )					

g_utilDoc.StartOneShotTimer (objPlayer, objPlayer.delay, StartPlayer, g_utilDoc.TMR_SCENE);
}
}
function StartScenePlayersAfterTransition ()
{
for ( playerName in DocScene.Players )
{
objPlayer = DocScene.Players[playerName];			

if ( objPlayer.delay == DELAY_UNTIL_TRANSITION )	

StartPlayer( objPlayer )						

}
}
function StartPlayer( objPlayer )
{
StartBehaviors (objPlayer);
StartTransition( objPlayer, objPlayer.entryTrans, IE_VISIBLE, PlayerEntryTransitionDone );
if ( objPlayer.duration > 0 )
g_utilDoc.StartOneShotTimer (objPlayer, objPlayer.duration, PlayerExit, g_utilDoc.TMR_SCENE);
}
function PlayerEntryTransitionDone( objPlayer )
{
if ( objPlayer.Bhv != null )
for ( bhvIdx=0; bhvIdx < objPlayer.numBhv; bhvIdx++ )	

{
var bhv = objPlayer.Bhv[bhvIdx]
if ( bhv == null)								

continue;
if ( bhv.delay == DELAY_UNTIL_TRANSITION  )	

bhv.Start( bhv );									

}
if ( objPlayer.Triggers != null )
EnableTrigger( objPlayer );
}
function PlayerExit( objPlayer )
{
StartTransition( objPlayer, objPlayer.exitTrans, IE_HIDDEN, PlayerExitTransitionDone );
}
function PlayerExitTransitionDone (objPlayer)
{
if ( objPlayer.Bhv != null )
for ( bhvIdx=0; bhvIdx < objPlayer.numBhv; bhvIdx++ )	

{
var bhv = objPlayer.Bhv[bhvIdx]
if ( bhv == null)								

continue;
if ( bhv.duration == DUR_UNTIL_DONE  )			

bhv.Stop( bhv );							

}
objPlayer.HTML.style.visibility = IE_HIDDEN;    

if (objPlayer.HTML.Preview != null)
objPlayer.HTML.style.visibility = IE_VISIBLE; 
}
function Trigger( trigType, trigBhv, player, scene )
{
if (g_utilDoc.g_fMac && TT_BUTTONUP == trigType)
trigType = TT_BUTTONDOWN;
this.triggerType = trigType;
this.triggerBhv = trigBhv;
this.player = player;
this.nextSceneNum = scene;
}
function EnableTrigger( objPlayer )
{
objPlayer.HTML.style.cursor="hand";						

for ( trx in objPlayer.Triggers )						

{
var	trigger = objPlayer.Triggers[trx];				

if ( trigger.triggerType == null )
trigger.triggerType = 0;						

var tt = trigger.triggerType;						

if			( tt == TT_ALL_MOUSE_EVENTS )								

{
objPlayer.HTML.onmousedown = EventProcessor;
objPlayer.HTML.onmouseup = EventProcessor;	
objPlayer.HTML.onmouseover = EventProcessor;		
objPlayer.HTML.onmouseout = EventProcessor;
}
else if		( tt == TT_BUTTONDOWN )					

objPlayer.HTML.onmousedown = EventProcessor;
else if		( tt == TT_BUTTONUP )			
objPlayer.HTML.onmouseup = EventProcessor;
else if		( tt == TT_MOUSEOVER )			
objPlayer.HTML.onmouseover = EventProcessor;
else if		( tt == TT_MOUSEOUT )			
objPlayer.HTML.onmouseout = EventProcessor;
}
}
function DisableTrigger( objPlayer )
{
objPlayer.HTML.onmousedown = null;
objPlayer.HTML.onmouseup = null;	
objPlayer.HTML.onmouseover = null;		
objPlayer.HTML.onmouseout = null;
}
function EventProcessor( e )
{
var trigger;									

var	type;										

var	button;										

var	eventType;									

var objPlayer;									

if ( (objPlayer = GetPlayerFromName(this.id)) == null)	

return;
type = event.type;
button = event.button;
if (type == "mousedown")
{
if ( button != 1 )						

return;
eventType = TT_BUTTONDOWN;
}
else if (type == "mouseup")
{
if ( button != 1 )						

return;
eventType = TT_BUTTONUP;
}
else if (type == "mouseover")
{
eventType = TT_MOUSEOVER;
}
else if (type == "mouseout")
{
eventType = TT_MOUSEOUT;
}
var triggerArray = objPlayer.Triggers;			

var trigger;									

for ( var trx=0; (trigger=triggerArray[trx]) != null; trx++ )
{
if ( (trigger.triggerType == 0) || (trigger.triggerType == eventType) )
{
if ( trigger.triggerBhv == TB_PAGE_TURNER )
{
if ( (trigger.nextSceneNum == null) || (trigger.nextSceneNum == "") )
g_utilDoc.DocSceneExit ();
else
g_utilDoc.DocSceneExit (parseInt (trigger.nextSceneNum));
}
else if	( trigger.triggerBhv == TB_START_PLAYER )
StartPlayer( GetPlayerFromName( trigger.player ) );				

else 
{
var objTrigPlayer = GetPlayerFromName( trigger.player );		

var bhv = objTrigPlayer.Bhv[trigger.triggerBhv];				

bhv.Trigger( bhv, eventType );									

}  	
}
}
}
function Transition( type, rate, flyFrom, flySubtype )
{
this.type = type;
this.rate = rate;
if (TRANS_FADE == type)
{
this.startOpacity = flyFrom;
this.endOpacity = flySubtype;
}
else
{
this.flyFrom = flyFrom;
this.flySubtype = flySubtype;
}
}
function StartTransition( transObj, trans, visibility, callback )
{
var	playerType = GetObjectTypeFromName( transObj.name );		

if	((playerType == OBJ_PLAYER) && (trans.type == NULL_TRANSITION))
{
transObj.HTML.style.visibility = visibility;
callback( transObj );
return;
}
if ( ((trans.type == TEXT_FLYIN) || (trans.type == TEXT_TYPEWRITER)) && (visibility == IE_VISIBLE) )
{
StartTextFlyin( transObj );
return;
}
if (trans.type == TRANS_FADE)
{
StartFade (transObj, trans, callback);
return;
}
if ( navigator.platform != "Win32" )
{
transObj.HTML.style.visibility = visibility;
callback( transObj );
return;
}
if ( trans.type == NULL_TRANSITION )
{
if (g_utilDoc.g_iIEVersion < 5)
{
transObj.HTML.style.filter = "revealTrans(duration=0, transition=0)";
}
else
{
transObj.HTML.style.visibility = visibility;
callback( transObj );
return;
}
}
else		

{
duration = TRANSITION_RATES[trans.rate];
transObj.HTML.style.filter = "revealTrans(duration=" + duration + ", transition=" + trans.type + ")";
}
if (transObj.HTML.filters(0).Status != 2)
{
transObj.HTML.filters(0).Apply();					

transObj.HTML.style.visibility = visibility;        

transObj.HTML.filters(0).Play()						

transObj.HTML.onfilterchange = TransitionDoneEvent;	
}
else
transObj.HTML.style.visibility = visibility;        

}
function TransitionDoneEvent ()
{
var	type = GetObjectTypeFromName( event.srcElement.id );		

if ( type == OBJ_SCENE )
{
SceneTransitionDone (DocScene);
}
else if	( type == OBJ_PLAYER )			

{
var objPlayer = GetPlayerFromName( event.srcElement.id );
if ( this.style.visibility == IE_VISIBLE )					

PlayerEntryTransitionDone( objPlayer );  
else														

PlayerExitTransitionDone (objPlayer);
}
}
function InitFade (objPlayer)
{
var	fadeHTML = objPlayer.HTML;
if (null == fadeHTML.filters["alpha"])
fadeHTML.style.filter += " alpha (Opacity = 100)";
fadeHTML.realOpacity = fadeHTML.filters["alpha"].Opacity;
return true;
}
function StartFade (objPlayer, objTrans, TransitionDone)
{
var	fadeHTML = objPlayer.HTML;
fadeHTML.objTrans = objTrans;
fadeHTML.TransitionDone = TransitionDone;
fadeHTML.fltOpacityPerTick = (objTrans.endOpacity - objTrans.startOpacity)/(g_utilDoc.g_Timer.ticksPerSecond * TRANSITION_RATES[objTrans.rate]);
fadeHTML.fFadeIn = (0 < fadeHTML.fltOpacityPerTick);
fadeHTML.fltDesiredCurrentOpacity = objTrans.startOpacity;
fadeHTML.filters["alpha"].Opacity = objTrans.startOpacity;
fadeHTML.style.visibility = IE_VISIBLE;
g_utilDoc.StartAnimationTimer (objPlayer, FadeTick);
}
function FadeTick (objPlayer)
{
var	fadeHTML = objPlayer.HTML;
var	objTrans = fadeHTML.objTrans;
fadeHTML.fltDesiredCurrentOpacity += fadeHTML.fltOpacityPerTick;
if (fadeHTML.fFadeIn)
{
if (objTrans.endOpacity < fadeHTML.fltDesiredCurrentOpacity)
fadeHTML.fltDesiredCurrentOpacity = objTrans.endOpacity;
}
else
{
if (objTrans.endOpacity > fadeHTML.fltDesiredCurrentOpacity)
fadeHTML.fltDesiredCurrentOpacity = objTrans.endOpacity;
}
fadeHTML.filters["alpha"].Opacity = fadeHTML.fltDesiredCurrentOpacity;
if (fadeHTML.fltDesiredCurrentOpacity == objTrans.endOpacity)
{
fadeHTML.TransitionDone (objPlayer);
return true; 

}
return false; 

}
function InitTextFlyin (objPlayer)
{
var	transition = objPlayer.entryTrans;							

var	transUnits = transition.flySubtype;							

var	movePerTick	= parseInt(FLYIN_PER_TICK[transition.rate]);	

var	transDirection = (transition.type == TEXT_FLYIN) ? transition.flyFrom : FLYIN_TOP;		

{
var	textHTML	= objPlayer.HTML;					

var	oldInnerHTML	= textHTML.innerHTML;			

textHTML.oldInnerHTML = oldInnerHTML;               

var	newInnerHTML	= "";							

transition.textOrder = new Array();					

textOrder = transition.textOrder;					

var flyinIdx = 0;							

var	flyinBuffer = "";
var spanStyle = (transition.type == TEXT_FLYIN) ? " style='position:relative;visibility:hidden;'" : " style='visibility:hidden;'";
for ( var letterIdx=0; letterIdx < oldInnerHTML.length; )
{
tempID = objPlayer.name+"_tempID"+flyinIdx.toString();
newInnerHTML += "<span id=" + tempID + spanStyle + ">";
while ( letterIdx < oldInnerHTML.length )
{
if ( ( (charNext = oldInnerHTML.substring(letterIdx, letterIdx+1)) == "<") || (charNext == "&") )		

{
if ( charNext == "<" )																	

endTagIdx = oldInnerHTML.indexOf( ">", letterIdx );	
else
endTagIdx = oldInnerHTML.indexOf( ";", letterIdx );	
var tagString = oldInnerHTML.substring( letterIdx, ++endTagIdx );
newInnerHTML += tagString;
letterIdx = endTagIdx;												

if ( transUnits == FLYIN_BY_LETTER && charNext=="&" ) break;
if ( ((tagString == "</P>") || (tagString == "<BR>") || (tagString == "</UL>")) && ( transUnits != FLYIN_BY_LETTER ) )	

break;
}
else
{
thisChar = oldInnerHTML.substring( letterIdx, ++letterIdx );
newInnerHTML += thisChar;
if		( transUnits == FLYIN_BY_LETTER )			

break;											

else if	( (transUnits == FLYIN_BY_WORD ) && thisChar == " " )		

break;
}
}
newInnerHTML += "</span>"
textOrder[flyinIdx] = new Object();
textOrder[flyinIdx].name = tempID;										

flyinIdx++;																

}
if ( flyinIdx == 0 )
return false;
textHTML.innerHTML = newInnerHTML;
textHTML.newInnerHTML = newInnerHTML;               

transition.numUnits = flyinIdx;							

}
textOrder = transition.textOrder;
var currentEl = document.all[textOrder[0].name];		

var currentOffset = currentEl.offsetLeft;	
var previousEl, previousOffset;
var UltimateParent = currentEl.offsetParent;
var ParTop=0,ParLeft=0,DocHeight=0,DocWidth=0;
while( UltimateParent.offsetParent != null && UltimateParent != document.body )
{
ParLeft += UltimateParent.offsetLeft;
ParTop += UltimateParent.offsetTop;
if( UltimateParent.offsetHeight > DocHeight) DocHeight = UltimateParent.offsetHeight;
if( UltimateParent.offsetWidth  > DocWidth)  DocWidth  = UltimateParent.offsetWidth;
UltimateParent = UltimateParent.offsetParent;
}
for ( var count=0; count < transition.numUnits; count++ )			

{
previousOffset = currentOffset;								

previousEl = currentEl;
textElName = textOrder[count].name;						

currentEl = document.all[textElName];
currentEl.style.visibility = IE_HIDDEN;
currentOffset = currentEl.offsetTop;
if ( currentOffset != previousOffset )									

if ( previousEl.innerHTML == " " )										

previousEl.innerHTML = "<br>";
if ( transDirection == FLYIN_ROTATE )			

direction = count % FLYIN_ROTATE;				

else
direction = transDirection;
if		( direction == FLYIN_LEFT )
{
tempPos = -(currentEl.offsetParent.offsetLeft + currentEl.offsetParent.offsetWidth);
currentEl.style.posLeft = tempPos;						

textOrder[count].dx = -movePerTick;						

textOrder[count].dy = 0;
textOrder[count].iterations = tempPos / (-movePerTick);	

}
else if ( direction == FLYIN_RIGHT )
{
tempPos = DocWidth - currentEl.offsetParent.offsetLeft;
currentEl.style.posLeft = tempPos;
textOrder[count].dx = movePerTick;						

textOrder[count].dy = 0;
textOrder[count].iterations = tempPos / movePerTick;	

}
else if	( direction == FLYIN_TOP )
{
tempPos = -( ParTop + currentEl.offsetParent.offsetHeight );
currentEl.style.posTop = tempPos;
textOrder[count].dx = 0;
textOrder[count].dy = (-movePerTick);					

textOrder[count].iterations = tempPos / (-movePerTick);	

}
else if ( direction == FLYIN_BOTTOM )
{
tempPos = DocHeight 

currentEl.style.posTop = tempPos;
textOrder[count].dx = 0;
textOrder[count].dy = movePerTick;						

textOrder[count].iterations = tempPos / movePerTick;	

}
}
transition.charIdx = 0;								

transition.moveIdx = 0;								

textElName = transition.textOrder[0].name;
transition.currentEl = document.all[textElName];	

transition.currentEl.style.visibility = IE_VISIBLE;
return true;
}
function StartTextFlyin( objPlayer )
{
objPlayer.HTML.style.visibility = IE_VISIBLE;
g_utilDoc.StartAnimationTimer (objPlayer, TextFlyinTick);
}
function TextFlyinTick( objPlayer )
{
var	transition = objPlayer.entryTrans;						

var	spanObj = transition.textOrder[transition.charIdx];		

var textEl = transition.currentEl;							

if ( ++transition.moveIdx < spanObj.iterations)				

{
textEl.style.posTop -= spanObj.dy;						

textEl.style.posLeft -= spanObj.dx;
return false;											

}
textEl.style.posTop = 0;									

textEl.style.posLeft = 0;
if ( (charIdx = ++transition.charIdx) >= transition.textOrder.length )	

{
objPlayer.HTML.innerHTML = objPlayer.HTML.oldInnerHTML;
PlayerEntryTransitionDone( objPlayer );					

return true;											

}
else
{
transition.moveIdx = 0;									

textElName = transition.textOrder[charIdx].name;
transition.currentEl = document.all[textElName];		

transition.currentEl.style.visibility = IE_VISIBLE;		

return false;											

}															
}
var	SND_DUR_SCENE			= -1;	

var	SND_DUR_PROJECT			= 0;	

var ST_WAV					= 1;	

var	ST_MID					= 2;	

var	NAV_EXT					= "nav"	

var MidiTag					= null;	

function Sound( delay, duration, loop, soundType, tagName, fileName )
{
this.Init = InitSound;
this.Start = StartSound;
this.Trigger = StartSound;
this.Stop = StopSound;
this.StopEverything = StopEverythingOnSounds;
this.delay = delay;
this.duration = duration;
this.loop = loop;
this.tagName = tagName;
this.fileName = fileName;
this.soundType = soundType;
}
function InitSound (objParent, objSound)
{
objSound.objParent = objParent;					

if (objSound.duration == SND_DUR_PROJECT)
{
objSound.html = g_utilDoc.GetProjectSoundHtml(objSound.fileName, objSound.soundType, true);
}
else
objSound.html = document.all[objSound.tagName];
if (null == objSound.html)
{
return;
}
if (objSound.soundType == ST_MID )
{
if ( MidiTag == null )						

MidiTag = objSound.html;				

else
objSound.html = MidiTag;				

}			
}
function StartSound( objSound )
{
if (null == objSound.html)
{
return;
}
objSound.html.loop = objSound.loop;				

objSound.html.src = objSound.fileName;			

if ( objSound.soundType == ST_WAV )			

objSound.html.volume = 0;						

if ( objSound.duration > 0 )
g_utilDoc.StartOneShotTimer (objSound, objSound.duration, objSound.Stop, g_utilDoc.TMR_PROJ);
}
function StopSound (objSound)
{
if (null == objSound.html)
{
return;
}
objSound.html.loop = 0;
objSound.html.src = "";             

if ( objSound.soundType == ST_WAV )
objSound.html.volume = -10000;
}
function StopEverythingOnSounds( objSound )
{
if (null == objSound.html)
{
return;
}
if (objSound.duration != SND_DUR_PROJECT)
{
StopSound (objSound);
if (g_utilDoc.g_fOSNT)					

objSound.html.volume = -500;	

}
}
var	TICKS_PER_FLASH = new Array (2,3,4,5,6); 

function Flash (delay, rate)
{
this.Init = InitFlash;
this.Start = StartFlash;
this.Trigger = StartFlash;
this.Stop = StopFlash;
this.StopEverything = StopFlash;
this.delay = delay;
this.rate = rate;
}
function InitFlash (objPlayer, objBhv)
{
objBhv.objPlayer = objPlayer;
objBhv.ElapsedTicks = 0;
}
function StartFlash (objBhv)
{
objBhv.objPlayer.HTML.style.visibility = IE_VISIBLE;
g_utilDoc.StartAnimationTimer (objBhv, FlashTick);
}
function StopFlash (objBhv)
{
objBhv.objPlayer.HTML.style.visibility = IE_VISIBLE;
}
function FlashTick (objBhv)
{
if (0 == (++objBhv.ElapsedTicks) % TICKS_PER_FLASH[objBhv.rate])
objBhv.objPlayer.HTML.style.visibility = IE_HIDDEN;
else
objBhv.objPlayer.HTML.style.visibility = IE_VISIBLE;
return false; 

}
var	WAVE_PER_TICK = new Array (5,4,3,2,1); 

function Wave (delay, rate)
{
this.Init = InitWave;
this.Start = StartWave;
this.Trigger = StartWave;
this.Stop = StopWave;
this.StopEverything = StopWave;
this.delay = delay;
this.rate = rate;
}
function InitWave (objPlayer, objBhv)
{
objBhv.objPlayer = objPlayer;
objBhv.WavePhase = 0;
objBhv.objPlayer.HTML.style.filter += " wave (freq=2, strength=6, phase=0, enabled=0)";
}
function StartWave (objBhv)
{
objBhv.objPlayer.HTML.filters["wave"].enabled = true;
objBhv.objPlayer.HTML.style.visibility = IE_VISIBLE;
g_utilDoc.StartAnimationTimer (objBhv, WaveTick);
}
function StopWave (objBhv)
{
objBhv.objPlayer.HTML.filters["wave"].enabled = false;
}
function WaveTick (objBhv)
{
objBhv.WavePhase = (objBhv.WavePhase+WAVE_PER_TICK[objBhv.rate]) % 101;
objBhv.objPlayer.HTML.filters["wave"].phase = objBhv.WavePhase;
return false; 

}
var	SND_DUR_SCENE			= -1;	

var	SND_DUR_PROJECT			= 0;	

function Swapper( idle, hover, click, replace )
{
this.Init = InitSwap;
this.Start = StartSwap;
this.Trigger = TriggerSwap;
this.Stop = StopSwap;
this.StopEverything = StopSwap;
this.idle = idle;
this.hover = hover;
this.click = click;
this.replace = replace;
this.Swapped = false;
}
function InitSwap (objParent, objSwap)
{	
var	idle	= objSwap.idle;							

var	hover	= objSwap.hover;
var	click	= objSwap.click;
if ( (hover != null) && (hover != "") && (document.all[hover].src != null) )
{
document.all[hover].style.visibility = IE_HIDDEN;
objSwap.srcHover = document.all[hover].src;
document.all[hover].src = "";
}
else
objSwap.srcHover = document.all[idle].src;
if ( (click != null) && (click != "") && (document.all[click].src != null) )
{
document.all[click].style.visibility = IE_HIDDEN;
objSwap.srcClick = document.all[click].src;
document.all[click].src = "";
}
else
objSwap.srcClick = document.all[idle].src;
objSwap.srcIdle = document.all[idle].src;
}
function StartSwap( objSwap )
{
document.all[objSwap.idle].src = objSwap.srcIdle;
}
function TriggerSwap( objSwap, eventType )
{
if ( eventType == TT_BUTTONDOWN )
{
document.all[objSwap.idle].src = objSwap.srcClick;
if (true == objSwap.Swapped)
{
objSwap.Swapped = false;
if ((objSwap.hover == null) || (objSwap.hover == ""))
objSwap.srcHover = objSwap.srcIdle;
}
else
{
objSwap.Swapped = true;
if ((objSwap.hover == null) || (objSwap.hover == ""))
{
if (0 != objSwap.replace)
{
objSwap.srcHover = objSwap.srcClick;
}
}
}
}
else if ( eventType == TT_BUTTONUP )
document.all[objSwap.idle].src = objSwap.srcHover;
else if ( eventType == TT_MOUSEOVER )
document.all[objSwap.idle].src = objSwap.srcHover;
else if ( eventType == TT_MOUSEOUT )
{
if (true == objSwap.Swapped && 0 != objSwap.replace)
document.all[objSwap.idle].src = objSwap.srcClick;
else
document.all[objSwap.idle].src = objSwap.srcIdle;
}
}
function StopSwap (objSwap)
{
}
var	PATH_PER_TICK = new Array(50,40,30,20,10);		

var	PE_STOP		= 0;								

var	PE_AGAIN	= 1;								

var	PE_REV		= 2;								

var	PE_EXIT		= 3;								

var	PD_FWD		= 1;
var	PD_BACK		= -1;
function Point( x, y, rate )
{
this.x = x;
this.y = y;
this.rate = rate;
}
function Paths( delay, edgeEffect )
{
this.Init = InitPathAnimation;
this.Start = StartPathAnimation;
this.Trigger = StartPathAnimation;
this.Stop = StopPathAnimation;
this.StopEverything = StopPathAnimation;
this.delay = delay;
this.edgeEffect = edgeEffect;
}
function InitPathAnimation( objPlayer, path )
{
var	segment;									

var pathIndex;
var totalDistance;								

var	distanceX;									

var	distanceY;
var dx;											

var	dy;
var travelTime;									

var	remX;										

var	remY;
path.objPlayer = objPlayer;						

halfWidth = Math.floor(objPlayer.HTML.offsetWidth/2);		

halfHeight = Math.floor(objPlayer.HTML.offsetHeight/2);
path[0].x -= halfWidth;
path[0].y -= halfHeight;
objPlayer.position.SetPosition( path[0].x, path[0].y );
for ( pathIndex=0; path[pathIndex+1] != null; pathIndex++ )	

{
px = parseInt(pathIndex);					

segment = path[px];							

path[px+1].x -= halfWidth;
path[px+1].y -= halfHeight;
distanceX = path[px+1].x - segment.x;		

distanceY = path[px+1].y - segment.y;		

totalDistance = Math.sqrt( (distanceX*distanceX) + (distanceY*distanceY) );
travelTime = Math.round(totalDistance / PATH_PER_TICK[segment.rate]);
if( travelTime > 0 )
{
if ( distanceX > 0 )							

dx = Math.floor( distanceX / travelTime );	

else if ( distanceX < 0 )						

dx = Math.ceil( distanceX / travelTime );	

else
dx = 0;
if ( distanceY > 0 )							

dy = Math.floor( distanceY / travelTime );
else if ( distanceY < 0 )
dy = Math.ceil( distanceY / travelTime );
else
dy = 0;
}
else
{
dx = dy = 0;
}
remX = distanceX - dx*travelTime;
remY = distanceY - dy*travelTime;
segment.number = px;							

segment.ticks  = 0;
segment.travelTime = travelTime;
segment.dx = dx;
segment.dy = dy;
segment.remX = remX;
segment.remY = remY;
}
path.numSegs = parseInt(pathIndex);					

path.dir = PD_FWD;											

}
function StartPathAnimation( path )
{
path.currentSegment = path[0];		

path.currentSegment.ticks = 0;		

path.cntSegs = 0;									

if ( path.dir == PD_BACK )								

{
for ( var ii=0; ii < path.numSegs; ii++ )				

{
path[ii].dx *= -1;
path[ii].dy *= -1;
path[ii].remX *= -1;
path[ii].remY *= -1;
}
path.dir = PD_FWD;									

}
g_utilDoc.StartAnimationTimer (path, PathAnimationTick);
}
function StopPathAnimation (path)
{
}
function PathAnimationTick( path )
{
var	objPlayer = path.objPlayer;				

var segment = path.currentSegment;			

var	currentPosition = objPlayer.position;	

if ( ++segment.ticks <= segment.travelTime )		

{
var newX = currentPosition.x + segment.dx;			

if ( segment.ticks <= Math.abs(segment.remX) )	

segment.remX > 0 ? newX++ : newX--;
var newY = currentPosition.y + segment.dy;			

if ( segment.ticks <= Math.abs(segment.remY) )	

segment.remY > 0 ? newY++ : newY--;
currentPosition.SetPosition( newX, newY );	

return false;								

}
else if( segment.ticks==1 && segment.travelTime==0 )
{
currentPosition.SetPosition( currentPosition.x + segment.remX, currentPosition.y + segment.remY);	

return false;								

} 
if ( ++path.cntSegs < path.numSegs )
{
path.currentSegment = path[segment.number+path.dir];		

path.currentSegment.ticks = 0;								

return false;
}
if			( path.edgeEffect == PE_AGAIN )		

{
objPlayer.position.SetPosition( path[0].x, path[0].y );
path.currentSegment = path[0];					

path.currentSegment.ticks = 0;					

path.cntSegs = 0;								

return false;									

}							
else if		( path.edgeEffect == PE_REV )			

{
path.dir *= -1;									

for ( var ii=0; ii < path.numSegs; ii++ )
{
path[ii].dx *= -1;
path[ii].dy *= -1;
path[ii].remX *= -1;
path[ii].remY *= -1;
}
path.currentSegment.ticks = 0;					

path.cntSegs = 0;								

return false;
}
else if	( path.edgeEffect == PE_EXIT )
{
PlayerExit( objPlayer );
return true;
}
else
return true;									

}
var	GROW_PER_TICK = new Array(20,14,8,4,1);		

var	GROW_TOPLEFT     = 0;
var	GROW_TOPRIGHT    = 1;
var	GROW_BOTTOMRIGHT = 2;
var	GROW_BOTTOMLEFT  = 3;
var	GROW_CENTER      = 4;
function Size( zoom, rate )
{
this.zoom = zoom;
this.rate = rate;
}
function Grows (delay, iAnchor)
{
this.Init = InitGrowAnimation;
this.Start = StartGrowAnimation;
this.Trigger = StartGrowAnimation;
this.Stop = StopGrowAnimation;
this.StopEverything = StopGrowAnimation;
this.delay = delay;
this.iAnchor = iAnchor;
}
function InitGrowAnimation (objPlayer, grow)
{
var	child = objPlayer.HTML.children[0];
if (child.tagName == "A")
child = child.children[0];
var playerType = GetPlayerTypeFromName( objPlayer.name );	

{
if (objPlayer.realWidth == null)
{
objPlayer.realWidth = child.width;
objPlayer.realHeight = child.height;
objPlayer.realPosition = new Position (objPlayer);
}
grow.realWidth = objPlayer.realWidth;
grow.realHeight = objPlayer.realHeight;
grow.AnchorPosition = new Position (objPlayer);
grow.AnchorPosition.x = objPlayer.realPosition.x;
grow.AnchorPosition.y = objPlayer.realPosition.y;
if (GROW_TOPRIGHT == grow.iAnchor) 
grow.AnchorPosition.x += objPlayer.realWidth;
if (GROW_BOTTOMLEFT == grow.iAnchor) 
grow.AnchorPosition.y += objPlayer.realHeight;
if (GROW_BOTTOMRIGHT == grow.iAnchor) 
{
grow.AnchorPosition.x += objPlayer.realWidth;
grow.AnchorPosition.y += objPlayer.realHeight;
}
if (GROW_CENTER == grow.iAnchor) 
{
grow.AnchorPosition.x += objPlayer.realWidth/2;
grow.AnchorPosition.y += objPlayer.realHeight/2;
}
}
if (playerType == PLAYER_TEXT)	

{
grow = null;											

return;
}
grow.objPlayer = objPlayer;									

grow.currentSegment = grow[0];								

grow.currentGrowth = grow.currentSegment.zoom;				

if (objPlayer.firstGrowDelay == null || objPlayer.firstGrowDelay > grow.delay)
{
objPlayer.firstGrowDelay = grow.delay;
child.width = grow.realWidth * (grow.currentSegment.zoom / 100);	

child.height = grow.realHeight * (grow.currentSegment.zoom / 100);
GrowSetPosition (child, grow);
}
for ( var growIndex=0; grow[growIndex] != null; growIndex++ )	

{
gx = parseInt(growIndex);					

segment = grow[gx];							

if ( grow[gx+1] == null )					

{
grow.finalSegment = grow[gx-1];			

break;									

}
growth = grow[gx+1].zoom - segment.zoom;					

if ( growth >= 0 )											

growthFactor = GROW_PER_TICK[segment.rate];				

else
growthFactor = -(GROW_PER_TICK[segment.rate]);
growthTicks = growth / growthFactor;			

segment.number = gx;							

segment.growth = growth;
segment.growthFactor = growthFactor;
segment.growthTicks = growthTicks;
segment.currentTicks = 0;
}
}
function StartGrowAnimation( grow )
{	
grow.currentSegment = grow[0];							

grow.currentTicks = 0;
g_utilDoc.StartAnimationTimer (grow, GrowAnimationTick);
}
function StopGrowAnimation (grow)
{
grow.objPlayer.firstGrowDelay = null;
}
function GrowAnimationTick( grow )
{
var	objPlayer = grow.objPlayer;							

var	child = objPlayer.HTML.children[0];
if (child.tagName == "A")
child = child.children[0];
var segment = grow.currentSegment;						

var EndZoom = grow[segment.number+1].zoom;
var NewcurrentGrowth = grow.currentGrowth + segment.growthFactor; 
if (segment.growthFactor < 0 && NewcurrentGrowth < EndZoom)  

NewcurrentGrowth = EndZoom;
if (segment.growthFactor >= 0 && NewcurrentGrowth > EndZoom) 

NewcurrentGrowth = EndZoom;
if (NewcurrentGrowth != grow.currentGrowth)
{
grow.currentGrowth = NewcurrentGrowth;
child.width = grow.realWidth*(grow.currentGrowth/100);
child.height = grow.realHeight*(grow.currentGrowth/100);
GrowSetPosition (child, grow);
}
if ( ++grow.currentTicks <= segment.growthTicks )		

return false;										

if ( grow.currentSegment == grow.finalSegment )			

return true;										

grow.currentSegment = grow[ segment.number+1 ];			

grow.currentTicks = 0;
return false;											

}
function GrowSetPosition (child, grow)
{
if (GROW_TOPLEFT == grow.iAnchor) 
return; 

var x = grow.AnchorPosition.x;
var y = grow.AnchorPosition.y;
if (GROW_TOPRIGHT == grow.iAnchor) 
{
x -= child.width;
}
if (GROW_BOTTOMLEFT == grow.iAnchor) 
{
y -= child.height;
}
if (GROW_BOTTOMRIGHT == grow.iAnchor) 
{
x -= child.width;
y -= child.height;
}
if (GROW_CENTER == grow.iAnchor) 
{
x -= (child.width/2);
y -= (child.height/2);
}
grow.objPlayer.position.SetPosition (x, y);
}
function Position (obj)
{
this.object = obj;                          

this.x = obj.HTML.style.pixelLeft;          

this.y = obj.HTML.style.pixelTop;           

this.SetPosition = SetPosition;
}
function SetPosition (newX, newY) 
{
var el = this.object.HTML;
el.style.pixelTop = newY;
el.style.pixelLeft = newX;
this.x = newX;
this.y = newY;
}
function GetPlayerFromName( playerName )
{
var objPlayer;
if ( (DocScene) && (DocScene.Players !=null) && ((objPlayer = DocScene.Players[playerName]) != null) )
return objPlayer;
return null;									

}
function GetObjectTypeFromName( nameString )
{
var type = nameString.substr(0,1);		

if (type == NAME_SCENE) 

return OBJ_SCENE;
else if	(type == NAME_PLAYER) 

return OBJ_PLAYER;
}
function GetPlayerTypeFromName( nameString )
{
var type = nameString.substr(1,1);		

if (type == PLAYER_NAME_IMAGE) 

return PLAYER_IMAGE;
else if	(type == PLAYER_NAME_DRAW) 

return PLAYER_DRAW;
else if	(type == PLAYER_NAME_TEXT) 

return PLAYER_TEXT;
}