RuneI
Class RuneHUD

Core.Object
   |
   +--Engine.Actor
      |
      +--Engine.HUD
         |
         +--RuneI.RuneHUD

// Draw messages in the RuneMessageQueue

// Entry point for string messages.(OBSOLETE)

00001	//=============================================================================
00002	// RuneHUD.
00003	//=============================================================================
00004	class RuneHUD extends HUD;
00005	
00006	#exec TEXTURE IMPORT NAME=IconSkull  FILE=Textures\HUD\HealthIcon.pcx MIPS=OFF
00007	
00008	#exec TEXTURE IMPORT NAME=PowerTick FILE=Textures\HUD\Tick.pcx MIPS=OFF FLAGS=2
00009	#exec TEXTURE IMPORT NAME=NetOutage FILE=Textures\HUD\Plug.pcx MIPS=OFF FLAGS=2
00010	
00011	#exec TEXTURE IMPORT NAME=ShieldIcon FILE=Textures\HUD\ShieldIcon.pcx MIPS=OFF FLAGS=2
00012	#exec TEXTURE IMPORT NAME=AirIcon FILE=Textures\HUD\AirIcon.pcx MIPS=OFF FLAGS=2
00013	#exec TEXTURE IMPORT NAME=ShieldEmpty FILE=Textures\HUD\ShieldEmpty.pcx MIPS=OFF FLAGS=2
00014	#exec TEXTURE IMPORT NAME=AirEmpty FILE=Textures\HUD\AirEmpty.pcx MIPS=OFF FLAGS=2
00015	#exec TEXTURE IMPORT NAME=BloodEmpty FILE=Textures\HUD\BloodEmpty.pcx MIPS=OFF FLAGS=2
00016	#exec TEXTURE IMPORT NAME=ShieldFull FILE=Textures\HUD\ShieldFull.pcx MIPS=OFF FLAGS=2
00017	#exec TEXTURE IMPORT NAME=AirFull FILE=Textures\HUD\AirFull.pcx MIPS=OFF FLAGS=2
00018	#exec TEXTURE IMPORT NAME=BloodFull FILE=Textures\HUD\BloodFull.pcx MIPS=OFF FLAGS=2
00019	
00020	#exec TEXTURE IMPORT NAME=HealthIcon FILE=Textures\HUD\HealthIcon.pcx MIPS=OFF FLAGS=2
00021	#exec TEXTURE IMPORT NAME=HealthEmpty FILE=Textures\HUD\HealthEmpty.pcx MIPS=OFF FLAGS=2
00022	#exec TEXTURE IMPORT NAME=HealthFull FILE=Textures\HUD\HealthFull.pcx MIPS=OFF FLAGS=2
00023	#exec TEXTURE IMPORT NAME=HealthEmptyTop FILE=Textures\HUD\HealthEmptyTop.pcx MIPS=OFF FLAGS=2
00024	#exec TEXTURE IMPORT NAME=HealthFullTop FILE=Textures\HUD\HealthFullTop.pcx MIPS=OFF FLAGS=2
00025	
00026	#exec TEXTURE IMPORT NAME=RuneIcon FILE=Textures\HUD\RuneIcon.pcx MIPS=OFF FLAGS=2
00027	#exec TEXTURE IMPORT NAME=RuneEmpty FILE=Textures\HUD\RuneEmpty.pcx MIPS=OFF FLAGS=2
00028	#exec TEXTURE IMPORT NAME=RuneFull FILE=Textures\HUD\RuneFull.pcx MIPS=OFF FLAGS=2
00029	#exec TEXTURE IMPORT NAME=RuneEmptyTop FILE=Textures\HUD\RuneEmptyTop.pcx MIPS=OFF FLAGS=2
00030	#exec TEXTURE IMPORT NAME=RuneFullTop FILE=Textures\HUD\RuneFullTop.pcx MIPS=OFF FLAGS=2
00031	
00032	// SarkHud textures
00033	#exec TEXTURE IMPORT NAME=SarkShieldIcon FILE=Textures\HUD\SarkShieldIcon.pcx MIPS=OFF FLAGS=2
00034	#exec TEXTURE IMPORT NAME=SarkAirIcon FILE=Textures\HUD\SarkAirIcon.pcx MIPS=OFF FLAGS=2
00035	#exec TEXTURE IMPORT NAME=SarkShieldEmpty FILE=Textures\HUD\SarkShieldEmpty.pcx MIPS=OFF FLAGS=2
00036	#exec TEXTURE IMPORT NAME=SarkAirEmpty FILE=Textures\HUD\SarkAirEmpty.pcx MIPS=OFF FLAGS=2
00037	#exec TEXTURE IMPORT NAME=SarkBloodEmpty FILE=Textures\HUD\SarkBerserkEmpty.pcx MIPS=OFF FLAGS=2
00038	#exec TEXTURE IMPORT NAME=SarkShieldFull FILE=Textures\HUD\SarkShieldFull.pcx MIPS=OFF FLAGS=2
00039	#exec TEXTURE IMPORT NAME=SarkAirFull FILE=Textures\HUD\SarkAirFull.pcx MIPS=OFF FLAGS=2
00040	#exec TEXTURE IMPORT NAME=SarkBloodFull FILE=Textures\HUD\SarkBerserkFull.pcx MIPS=OFF FLAGS=2
00041	
00042	#exec TEXTURE IMPORT NAME=SarkHealthIcon FILE=Textures\HUD\SarkHealthIcon.pcx MIPS=OFF FLAGS=2
00043	#exec TEXTURE IMPORT NAME=SarkHealthEmpty FILE=Textures\HUD\SarkHealthEmpty.pcx MIPS=OFF FLAGS=2
00044	#exec TEXTURE IMPORT NAME=SarkHealthFull FILE=Textures\HUD\SarkHealthFull.pcx MIPS=OFF FLAGS=2
00045	#exec TEXTURE IMPORT NAME=SarkHealthEmptyTop FILE=Textures\HUD\SarkHealthEmptyTop.pcx MIPS=OFF FLAGS=2
00046	#exec TEXTURE IMPORT NAME=SarkHealthFullTop FILE=Textures\HUD\SarkHealthFullTop.pcx MIPS=OFF FLAGS=2
00047	
00048	#exec TEXTURE IMPORT NAME=SarkRuneIcon FILE=Textures\HUD\SarkRuneIcon.pcx MIPS=OFF FLAGS=2
00049	#exec TEXTURE IMPORT NAME=SarkRuneEmpty FILE=Textures\HUD\SarkRuneEmpty.pcx MIPS=OFF FLAGS=2
00050	#exec TEXTURE IMPORT NAME=SarkRuneFull FILE=Textures\HUD\SarkRuneFull.pcx MIPS=OFF FLAGS=2
00051	#exec TEXTURE IMPORT NAME=SarkRuneEmptyTop FILE=Textures\HUD\SarkRuneEmptyTop.pcx MIPS=OFF FLAGS=2
00052	#exec TEXTURE IMPORT NAME=SarkRuneFullTop FILE=Textures\HUD\SarkRuneFullTop.pcx MIPS=OFF FLAGS=2
00053	
00054	var float CineLoc;
00055	var() float CineSpeed;
00056	var() Texture TypingIcon;
00057	
00058	var() float HudScale; // DEBUG!
00059	
00060	// Variables used for smoothing out the fill bars
00061	var float HudHealth;
00062	var float HudPower;
00063	var float HudShield;
00064	var float HudBloodlust;
00065	var float HudAir;
00066	
00067	// Variables used for fading the various bars in and out
00068	var float FadeHealth;
00069	var float FadePower;
00070	var float FadeShield;
00071	var float FadeBloodlust;
00072	var float FadeAir;
00073	
00074	var bool bHealth;
00075	var bool bPower;
00076	var bool bShield;
00077	var bool bBloodLust;
00078	var bool bAir;
00079	var bool bResChanged;
00080	var bool bTimeDown;
00081	var int OldClipX;
00082	
00083	var float BloodScale;
00084	
00085	var globalconfig string FontInfoClass;
00086	var FontInfo MyFonts;
00087	
00088	struct HUDRuneMessage
00089	{
00090		var vector		Position;
00091		var string		Text;
00092		var float		Age;			// Time passed
00093		var float		LifeTime;		// Total time to live (not including fade in/out)
00094		var float		EndOfLife;		// Time to remove
00095		var color		DrawColor;
00096		var font		DrawFont;
00097		var float		FadeAlpha;		// Current fade alpha
00098		var float		FadeTime;		// Fade In/Out interval
00099		var bool		bFade;
00100		var bool		bUsed;
00101		var E_RMAlign	align;
00102	};
00103	
00104	const QueueSize		= 4;					// Size of MessageQueue
00105	var HUDLocalizedMessage MessageQueue[4];
00106	var HUDRuneMessage RuneMessageQueue[16];
00107	
00108	
00109	simulated function PostBeginPlay()
00110	{
00111		Super.PostBeginPlay();
00112		
00113		//FONT ALTER
00114		if(FontInfoClass != "")
00115			MyFonts = FontInfo(spawn(Class<Actor>(DynamicLoadObject(FontInfoClass, class'Class'))));
00116	
00117		HudHealth = 0;
00118		HudPower = 0;
00119		HudShield = 0;
00120		HudBloodlust = 0;
00121		HudAir = 0;	
00122	
00123		FadeHealth = 0;
00124		FadePower = 0;
00125		FadeShield = 0;
00126		FadeBloodlust = 0;
00127		FadeAir = 0;
00128	
00129		BloodScale = 0.5;
00130	
00131		SetTimer(1.0, True);
00132	}
00133	
00134	function Timer()
00135	{
00136		local int i, j;
00137	
00138		// Age the message queues
00139		for (i=0; i<QueueSize; i++)
00140		{	// Purge expired messages.
00141			if ( (MessageQueue[i].Message != None) && (Level.TimeSeconds >= MessageQueue[i].EndOfLife) )
00142				ClearMessage(MessageQueue[i]);
00143		}
00144	
00145		for (i=0; i<16; i++)
00146		{
00147			if ( RuneMessageQueue[i].bUsed && Level.TimeSeconds >= RuneMessageQueue[i].EndOfLife)
00148				RuneMessageQueue[i].bUsed = false;
00149		}
00150	
00151		// Clean empty slots.
00152		for (i=0; i<QueueSize-1; i++)
00153		{
00154			if ( MessageQueue[i].Message == None )
00155			{
00156				for (j=i; j<QueueSize; j++)
00157				{
00158					if ( MessageQueue[j].Message != None )
00159					{
00160						CopyMessage(MessageQueue[i],MessageQueue[j]);
00161						ClearMessage(MessageQueue[j]);
00162						break;
00163					}
00164				}
00165			}
00166		}
00167	}
00168	
00169	simulated function Tick(float DeltaSeconds)
00170	{
00171		local float delta;
00172		local Pawn P;
00173		local int i;
00174	
00175		Super.Tick(DeltaSeconds);
00176	
00177		P = Pawn(Owner);
00178		
00179		// Smooth Health		
00180		delta = P.Health - HudHealth;
00181		if(delta != 0)
00182		{
00183			HudHealth += delta * DeltaSeconds * 6;
00184			if((delta > 0 && HudHealth > P.Health) || (delta < 0 && HudHealth < P.Health))
00185				HudHealth = P.Health;
00186		}
00187	
00188		// Smooth Power	
00189		delta = P.RunePower - HudPower;
00190		if(delta != 0)
00191		{
00192			HudPower += delta * DeltaSeconds * 6;
00193			if((delta > 0 && HudPower > P.RunePower) || (delta < 0 && HudPower < P.RunePower))
00194				HudPower = P.RunePower;
00195		}
00196		
00197		// Smooth Shield
00198		if(P.Shield != None)
00199		{
00200			delta = P.Shield.Health - HudShield;
00201			if(delta != 0)
00202			{
00203				HudShield += delta * DeltaSeconds * 6;
00204				if((delta > 0 && HudShield > P.Shield.Health) || (delta < 0 && HudShield < P.Shield.Health))
00205					HudShield = P.Shield.Health;
00206			}
00207		}
00208	
00209		// Smooth Bloodlust
00210		delta = P.Strength - HudBloodlust;
00211		if(delta != 0)
00212		{
00213			HudBloodlust += delta * DeltaSeconds * 6;
00214			if((delta > 0 && HudBloodlust > P.Strength) || (delta < 0 && HudBloodlust < P.Strength))
00215				HudBloodlust = P.Strength;
00216		}	
00217		
00218		// Smooth Air
00219		if(P.HeadRegion.Zone.bWaterZone)
00220		{
00221			delta = P.PainTime - HudAir;
00222			if(delta != 0)
00223			{
00224				HudAir += delta * DeltaSeconds * 6;
00225				if((delta > 0 && HudAir > P.PainTime) || (delta < 0 && HudAir < P.PainTime))
00226					HudAir = P.PainTime;
00227			}
00228		}
00229		else
00230		{
00231			delta = P.UnderWaterTime - HudAir;
00232			if(delta != 0)
00233			{
00234				HudAir += delta * DeltaSeconds * 6;
00235				if((delta > 0 && HudAir > P.UnderWaterTime) || (delta < 0 && HudAir < P.UnderWaterTime))
00236					HudAir = P.UnderWaterTime;
00237			}
00238		}
00239		
00240		// Smooth out the fades
00241		if(bHealth)
00242		{
00243			FadeHealth += DeltaSeconds * 2;
00244			if(FadeHealth > 1)
00245				FadeHealth = 1;
00246		}
00247		else
00248		{
00249			FadeHealth -= DeltaSeconds * 2;
00250			if(FadeHealth < 0)
00251				FadeHealth = 0;
00252		}
00253	
00254		if(bPower)
00255		{
00256			FadePower += DeltaSeconds * 2;
00257			if(FadePower > 1)
00258				FadePower = 1;
00259		}
00260		else
00261		{
00262			FadePower -= DeltaSeconds * 2;
00263			if(FadePower < 0)
00264				FadePower = 0;
00265		}
00266	
00267		if(bBloodLust)
00268		{
00269			FadeBloodlust += DeltaSeconds * 2;
00270			if(FadeBloodlust > 1)
00271				FadeBloodlust = 1;
00272		}
00273		else
00274		{
00275			FadeBloodlust -= DeltaSeconds * 2;
00276			if(FadeBloodlust < 0)
00277				FadeBloodlust = 0;
00278		}
00279	
00280		if(bShield)
00281		{
00282			FadeShield += DeltaSeconds * 2;
00283			if(FadeShield > 1)
00284				FadeShield = 1;
00285		}
00286		else
00287		{
00288			FadeShield -= DeltaSeconds * 2;
00289			if(FadeShield < 0)
00290				FadeShield = 0;
00291		}
00292	
00293		if(bAir)
00294		{
00295			FadeAir += DeltaSeconds * 2;
00296			if(FadeAir> 1)
00297				FadeAir = 1;
00298		}
00299		else
00300		{
00301			FadeAir -= DeltaSeconds * 2;
00302			if(FadeAir < 0)
00303				FadeAir = 0;
00304		}
00305	
00306		// Smooth BloodLust Scale (scaled up when the player is bloodlusting)
00307		if(PlayerPawn(Owner).bBloodLust)
00308		{
00309			BloodScale += DeltaSeconds * 2;
00310			if(BloodScale > 1)
00311				BloodScale = 1.0;
00312		}
00313		else
00314		{
00315			BloodScale -= DeltaSeconds * 2;
00316			if(BloodScale < 0.5)
00317				BloodScale = 0.5;
00318		}
00319	
00320		// Fade RuneMessageQueue
00321		for (i=0; i<16; i++)
00322		{
00323			if (RuneMessageQueue[i].bUsed && RuneMessageQueue[i].bFade)
00324			{
00325				RuneMessageQueue[i].Age += DeltaSeconds;
00326				if (RuneMessageQueue[i].Age < RuneMessageQueue[i].FadeTime)
00327				{	// Fading In
00328					RuneMessageQueue[i].FadeAlpha = RuneMessageQueue[i].Age / RuneMessageQueue[i].FadeTime;
00329					if (RuneMessageQueue[i].FadeAlpha > 1)
00330						RuneMessageQueue[i].FadeAlpha = 1;
00331				}
00332				else if (RuneMessageQueue[i].Age > RuneMessageQueue[i].FadeTime + RuneMessageQueue[i].LifeTime)
00333				{	// Fading Out
00334					RuneMessageQueue[i].FadeAlpha = 1 - ((RuneMessageQueue[i].Age-RuneMessageQueue[i].LifeTime-RuneMessageQueue[i].FadeTime) / RuneMessageQueue[i].FadeTime);
00335					if (RuneMessageQueue[i].FadeAlpha < 0)
00336						RuneMessageQueue[i].FadeAlpha = 0;
00337					if (RuneMessageQueue[i].FadeAlpha > 1)
00338						RuneMessageQueue[i].FadeAlpha = 1;
00339				}
00340			}
00341		}
00342	}
00343	
00344	
00345	simulated function ChangeHud(int d)
00346	{
00347		HudMode = HudMode + d;
00348		if ( HudMode>1 ) HudMode = 0;
00349		else if ( HudMode < 0 ) HudMode = 1;
00350	}
00351	
00352	simulated function DefaultCanvas( canvas Canvas )
00353	{
00354		Canvas.Reset();
00355		Canvas.SpaceX=0;
00356		Canvas.SpaceY=0;
00357		Canvas.bNoSmooth = True;
00358		Canvas.DrawColor.r = 255;
00359		Canvas.DrawColor.g = 255;
00360		Canvas.DrawColor.b = 255;	
00361	//	FONT ALTER
00362	//	Canvas.Font = Canvas.LargeFont;
00363		if(MyFonts != None)
00364			Canvas.Font = MyFonts.GetStaticLargeFont();
00365		else
00366			Canvas.Font = Canvas.LargeFont;
00367	}
00368	
00369	
00370	simulated function CreateMenu()
00371	{
00372		if ( MainMenu == None )
00373			MainMenu = Spawn(MainMenuType, self);
00374			
00375		if ( MainMenu == None )
00376		{
00377			PlayerPawn(Owner).bShowMenu = false;
00378			Level.bPlayersOnly = false;
00379			return;
00380		}
00381		else
00382		{
00383			MainMenu.PlayerOwner = PlayerPawn(Owner);
00384			MainMenu.PlayEnterSound();
00385			MainMenu.MenuInit();
00386		}
00387	}
00388	
00389	simulated function DisplayMenu( canvas Canvas )
00390	{
00391		local float VersionW, VersionH;
00392	
00393		if ( MainMenu == None )
00394			CreateMenu();
00395		if ( MainMenu != None )
00396			MainMenu.DrawMenu(Canvas);
00397	
00398		if ( MainMenu.Class == MainMenuType )
00399		{
00400			Canvas.bCenter = false;
00401			//FONT ALTER
00402			//Canvas.Font = Canvas.MedFont;
00403			if(MyFonts != None)
00404				Canvas.Font = MyFonts.GetStaticMedFont();
00405			else
00406				Canvas.Font = Canvas.MedFont;
00407	
00408			Canvas.Style = 1;
00409			Canvas.StrLen(Level.EngineVersion, VersionW, VersionH);
00410			Canvas.SetPos(Canvas.ClipX - VersionW - 4, 4);	
00411			Canvas.DrawText(Level.EngineVersion, False);	
00412		}
00413	}
00414	
00415	simulated function DisplayProgressMessage( canvas Canvas )
00416	{
00417		local int i;
00418		local float YOffset, XL, YL;
00419	
00420		Canvas.SetColor(255, 255, 255);
00421		Canvas.bCenter = true;
00422		//FONT ALTER
00423		//Canvas.Font = Canvas.MedFont;
00424		if(MyFonts != None)
00425			Canvas.Font = MyFonts.GetStaticMedFont();
00426		else
00427			Canvas.Font = Canvas.MedFont;
00428	
00429		YOffset = 0;
00430		Canvas.StrLen("TEST", XL, YL);
00431		for (i=0; i<5; i++)
00432		{
00433			Canvas.SetPos(0, 0.25 * Canvas.ClipY + YOffset);
00434			Canvas.DrawColor = PlayerPawn(Owner).ProgressColor[i];
00435			Canvas.DrawText(PlayerPawn(Owner).ProgressMessage[i], false);
00436			YOffset += YL + 1;
00437		}
00438		Canvas.bCenter = false;
00439		Canvas.SetColor(255, 255, 255);
00440	}
00441	
00442	function RuneMessage( string Msg, vector Position, optional color DrawColor, optional Font aFont, optional float Life, optional bool bFade, optional float FadeTime, optional E_RMAlign align)
00443	{
00444		local int i;
00445	
00446		for (i=0; i<16; i++)
00447		{
00448			if (!RuneMessageQueue[i].bUsed)
00449			{
00450				RuneMessageQueue[i].bUsed = true;
00451				RuneMessageQueue[i].Text = Msg;
00452				RuneMessageQueue[i].Position = Position;
00453				RuneMessageQueue[i].Age = 0;
00454				RuneMessageQueue[i].LifeTime = Life;
00455				RuneMessageQueue[i].EndOfLife = Level.TimeSeconds + Life;
00456				RuneMessageQueue[i].DrawColor = DrawColor;
00457				RuneMessageQueue[i].bFade = bFade;
00458				RuneMessageQueue[i].Align = Align;
00459				if (bFade)
00460				{
00461					if (FadeTime != 0)
00462						RuneMessageQueue[i].FadeTime = FadeTime;
00463					else
00464						RuneMessageQueue[i].FadeTime = 1;
00465	
00466					RuneMessageQueue[i].FadeAlpha = 0;
00467					RuneMessageQueue[i].EndOfLife += FadeTime*2;
00468				}
00469				else
00470				{
00471					RuneMessageQueue[i].FadeAlpha = 1;
00472				}
00473				//FONT ALTER
00474				if (aFont != None)
00475				{
00476					if(MyFonts != None)
00477					{
00478					 	switch(aFont)
00479						{
00480						
00481						case Font'SmallFont':
00482							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticSmallFont();
00483							break;
00484						case Font'MedFont':
00485							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticMedFont();
00486							break;
00487						case Font'Haettenschweiler16': 
00488						case Font'RuneBig':
00489							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticBigFont();
00490							break;
00491						case Font'RuneLarge':
00492							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticLargeFont();
00493							break;
00494						case Font'RuneMed':
00495							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticRuneMedFont();
00496							break;
00497						case Font'RuneCred':
00498							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticCreditsFont();
00499							break;
00500						case Font'RuneButton':
00501							RuneMessageQueue[i].DrawFont = MyFonts.GetStaticButtonFont();
00502							break;
00503						default:
00504							RuneMessageQueue[i].DrawFont = aFont;
00505							break;
00506						}
00507					}
00508					else
00509						RuneMessageQueue[i].DrawFont = aFont;
00510				}
00511				else	//FONT ALTER
00512				{//RuneMessageQueue[i].DrawFont = class'Canvas'.Default.SmallFont;
00513					if(MyFonts != None)
00514						RuneMessageQueue[i].DrawFont = MyFonts.GetStaticSmallFont();
00515					else
00516						RuneMessageQueue[i].DrawFont = class'Canvas'.Default.SmallFont;
00517				}
00518				return;
00519			}
00520		}
00521	}
00522	
00523	
00524	simulated function Class<LocalMessage> DetermineClass(name MsgType)
00525	{
00526		local Class<LocalMessage> MessageClass;
00527	
00528		switch (MsgType)
00529		{
00530			case 'Subtitle':
00531				MessageClass=class'SubtitleMessage';
00532				break;
00533			case 'RedSubtitle':
00534				MessageClass=class'SubtitleRed';
00535				break;
00536			case 'Pickup':
00537				MessageClass=class'PickupMessage';
00538				break;
00539			case 'Say':
00540			case 'TeamSay':
00541				MessageClass=class'SayMessage';
00542				break;
00543			case 'NoRunePower':
00544				MessageClass=class'NoRunePowerMessage';
00545				break;
00546			case 'CriticalEvent':
00547			case 'DeathMessage':
00548			case 'Event':
00549			default:
00550				MessageClass=class'GenericMessage';
00551				break;
00552		}
00553		return MessageClass;
00554	}
00555	
00556	// Entry point for string messages.(OBSOLETE)
00557	simulated function Message( PlayerReplicationInfo PRI, coerce string Msg, name MsgType )
00558	{
00559		local Class<LocalMessage> MessageClass;
00560	
00561		switch (MsgType)
00562		{
00563			case 'Subtitle':
00564				MessageClass=class'SubtitleMessage';
00565				break;
00566			case 'RedSubtitle':
00567				MessageClass=class'SubtitleRed';
00568				break;
00569			case 'Pickup':
00570				MessageClass=class'PickupMessage';
00571				break;
00572			case 'Say':
00573			case 'TeamSay':
00574				MessageClass=class'SayMessage';
00575				break;
00576			case 'NoRunePower':
00577				MessageClass=class'NoRunePowerMessage';
00578				break;
00579			case 'CriticalEvent':
00580			case 'DeathMessage':
00581			case 'Event':
00582			default:
00583				MessageClass=class'GenericMessage';
00584				break;
00585		}
00586	
00587		LocalizedMessage(MessageClass, 0, PRI, None, None, Msg);
00588	}
00589	
00590	
00591	// Entry point for localized messages
00592	simulated function LocalizedMessage( class<LocalMessage> Message, optional int Switch, optional PlayerReplicationInfo RelatedPRI_1, optional PlayerReplicationInfo RelatedPRI_2, optional Object OptionalObject, optional String CriticalString )
00593	{
00594		local int i;
00595	
00596		if ( Message.Static.KillMessage() )
00597			return;
00598	
00599		if ( CriticalString == "" )
00600			CriticalString = Message.Static.GetString(Switch, RelatedPRI_1, RelatedPRI_2, OptionalObject);
00601	
00602		Message.Static.MangleString(CriticalString, RelatedPRI_1, RelatedPRI_2, OptionalObject);
00603	
00604		if ( Message.Default.bIsUnique )
00605		{	// If unique, stomp any identical existing message
00606			for (i=0; i<QueueSize; i++)
00607			{
00608				if (MessageQueue[i].Message != None)
00609				{
00610					if (MessageQueue[i].Message == Message)
00611					{
00612						MessageQueue[i].Message = Message;
00613						MessageQueue[i].Switch = Switch;
00614						MessageQueue[i].RelatedPRI = RelatedPRI_1;
00615						MessageQueue[i].OptionalObject = OptionalObject;
00616						MessageQueue[i].LifeTime = Message.Static.GetLifeTime(CriticalString);
00617						MessageQueue[i].EndOfLife = MessageQueue[i].LifeTime + Level.TimeSeconds;
00618						MessageQueue[i].StringMessage = CriticalString;
00619						MessageQueue[i].DrawColor = Message.Static.GetColor(Switch, RelatedPRI_1, RelatedPRI_2);
00620						MessageQueue[i].XL = 0;
00621						return;
00622					}
00623				}
00624			}
00625		}
00626		for (i=0; i<QueueSize; i++)
00627		{
00628			if (MessageQueue[i].Message == None)
00629			{
00630				MessageQueue[i].Message = Message;
00631				MessageQueue[i].Switch = Switch;
00632				MessageQueue[i].RelatedPRI = RelatedPRI_1;
00633				MessageQueue[i].OptionalObject = OptionalObject;
00634				MessageQueue[i].LifeTime = Message.Static.GetLifeTime(CriticalString);
00635				MessageQueue[i].EndOfLife = MessageQueue[i].LifeTime + Level.TimeSeconds;
00636				MessageQueue[i].StringMessage = CriticalString;
00637				MessageQueue[i].DrawColor = Message.Static.GetColor(Switch, RelatedPRI_1, RelatedPRI_2);
00638				MessageQueue[i].XL = 0;
00639				return;
00640			}
00641		}
00642	
00643		// No empty slots.  Force a message out.
00644		for (i=0; i<QueueSize-1; i++)
00645			CopyMessage(MessageQueue[i],MessageQueue[i+1]);
00646	
00647		MessageQueue[QueueSize-1].Message = Message;
00648		MessageQueue[QueueSize-1].Switch = Switch;
00649		MessageQueue[QueueSize-1].RelatedPRI = RelatedPRI_1;
00650		MessageQueue[QueueSize-1].OptionalObject = OptionalObject;
00651		MessageQueue[QueueSize-1].LifeTime = Message.Static.GetLifeTime(CriticalString);
00652		MessageQueue[QueueSize-1].EndOfLife = MessageQueue[QueueSize-1].LifeTime + Level.TimeSeconds;
00653		MessageQueue[QueueSize-1].StringMessage = CriticalString;
00654		MessageQueue[QueueSize-1].DrawColor = Message.Static.GetColor(Switch, RelatedPRI_1, RelatedPRI_2);				
00655		MessageQueue[QueueSize-1].XL = 0;
00656	}
00657	
00658	simulated function ClearMessagesOfType(name MsgType)
00659	{
00660		local Class<LocalMessage> MessageClass;
00661		local int i;
00662	
00663		MessageClass = DetermineClass(MsgType);
00664		if (MessageClass == None)
00665			return;
00666	
00667		for(i=0; i<QueueSize; i++)
00668		{
00669			if (MessageQueue[i].Message == MessageClass)
00670			{	// Kill Message
00671				ClearMessage(MessageQueue[i]);
00672			}
00673		}
00674	}
00675	
00676	simulated function bool DisplayMessages( canvas Canvas)
00677	{	// We are drawing messages instead of Console
00678		return true;
00679	//	return false;
00680	}
00681	
00682	simulated function DrawMessages(canvas Canvas)
00683	{
00684		local int i,j,k;
00685		local float XL, YL, YPos, FadeValue;
00686		local string Message;
00687	
00688		for (i=0; i<QueueSize; i++)
00689		{
00690			if ( MessageQueue[i].Message != None )
00691			{
00692				if (MessageQueue[i].Message.Default.bFadeMessage && Level.bHighDetailMode)
00693				{
00694					FadeValue = (MessageQueue[i].EndOfLife - Level.TimeSeconds);
00695					if (FadeValue <= 0.0)
00696						continue;
00697				}
00698	
00699				j++;
00700				//FONT ALTER
00701				//Canvas.Font = Canvas.BigFont;
00702				if(MyFonts != None)
00703					Canvas.Font = MyFonts.GetStaticBigFont();
00704				else
00705					Canvas.Font = Canvas.BigFont;
00706	
00707				if (MessageQueue[i].Message.Default.bCenter)
00708					Canvas.bCenter = true;
00709				Canvas.StrLen("TEST", XL, YL);
00710				if ( bResChanged || MessageQueue[i].XL == 0 )
00711				{	// Determine dimensions of text
00712					if ( MessageQueue[i].Message.Default.bComplexString )
00713						Canvas.StrLen(MessageQueue[i].Message.Static.AssembleString( 
00714												self,
00715												MessageQueue[i].Switch,
00716												MessageQueue[i].RelatedPRI,
00717												MessageQueue[i].StringMessage), 
00718									   MessageQueue[i].XL, MessageQueue[i].YL);
00719					else
00720						Canvas.StrLen(MessageQueue[i].StringMessage, MessageQueue[i].XL, MessageQueue[i].YL);
00721					MessageQueue[i].numLines = Max(1, MessageQueue[i].YL / YL);
00722				}
00723	
00724				// Set the position
00725				MessageQueue[i].YPos = MessageQueue[i].Message.Static.GetOffset(MessageQueue[i].Switch, MessageQueue[i].YL, Canvas.ClipY);
00726				if (MessageQueue[i].YPos == 0)
00727				{
00728					Canvas.SetPos(0, 2 + YL * YPos);
00729					YPos += MessageQueue[i].numLines;
00730				}
00731				else
00732				{
00733					Canvas.SetPos(0, MessageQueue[i].YPos);
00734				}
00735	
00736				// Draw the text
00737				if ( MessageQueue[i].Message.Default.bComplexString )
00738				{
00739					// Use this for string messages with multiple colors.
00740					MessageQueue[i].Message.Static.RenderComplexMessage( 
00741						Canvas,
00742						MessageQueue[i].XL,  YL,
00743						MessageQueue[i].StringMessage,
00744						MessageQueue[i].Switch,
00745						MessageQueue[i].RelatedPRI,
00746						None,
00747						MessageQueue[i].OptionalObject
00748						);
00749				} 
00750				else
00751				{
00752					if (MessageQueue[i].Message.Default.bFadeMessage && Level.bHighDetailMode)
00753					{
00754						Canvas.Style = ERenderStyle.STY_Translucent;
00755						Canvas.DrawColor = MessageQueue[i].DrawColor * (FadeValue/MessageQueue[i].LifeTime);
00756					}
00757					else
00758					{
00759						Canvas.DrawColor = MessageQueue[i].Message.Default.DrawColor;
00760					}
00761					Canvas.DrawText(MessageQueue[i].StringMessage, False);
00762	//				Canvas.DrawText(YPos@MessageQueue[i].StringMessage @ "NL="$MessageQueue[i].numLines @ "YL="$YL, False);
00763				}
00764	
00765				// Cleanup
00766				Canvas.bCenter = false;
00767				Canvas.Style = ERenderStyle.STY_Normal;
00768			}
00769		}
00770	}
00771	
00772	// Draw messages in the RuneMessageQueue
00773	simulated function DrawRuneMessages(canvas Canvas)
00774	{
00775		local int i;
00776		local int SX,SY;
00777		local float XL,YL;
00778	
00779		Canvas.Style = ERenderStyle.STY_Translucent;
00780	
00781		for (i=0; i<16; i++)
00782		{
00783			if ( RuneMessageQueue[i].bUsed )
00784			{
00785				Canvas.Font = RuneMessageQueue[i].DrawFont;
00786				Canvas.StrLen(RuneMessageQueue[i].Text, XL, YL);
00787	
00788				if (RuneMessageQueue[i].Position.Z != 0)
00789				{	// Transform from world coords
00790					Canvas.TransformPoint(RuneMessageQueue[i].Position, SX, SY);
00791	
00792					// Center message around transformed point
00793					SX -= XL/2;
00794					SY -= YL/2;
00795				}
00796				else
00797				{
00798					SX = RuneMessageQueue[i].Position.X * Canvas.ClipX / 640.0;
00799					SY = RuneMessageQueue[i].Position.Y * Canvas.ClipY / 480.0;
00800	
00801					switch(RuneMessageQueue[i].align)
00802					{
00803						case RMALIGN_CENTER:
00804							SX -= XL/2;
00805							SY -= YL/2;
00806							break;
00807						case RMALIGN_LEFT:
00808							break;
00809						case RMALIGN_RIGHT:
00810							SX -= XL;
00811							break;
00812					}
00813	
00814				}
00815				Canvas.SetPos(SX, SY);
00816				Canvas.DrawColor = RuneMessageQueue[i].DrawColor * RuneMessageQueue[i].FadeAlpha;
00817				Canvas.DrawTextClipped(RuneMessageQueue[i].Text, false);
00818			}
00819		}
00820	
00821		Canvas.bCenter = false;
00822		Canvas.Style = ERenderStyle.STY_Normal;	
00823	}
00824	
00825	simulated function string TwoDigitString(int Num)
00826	{
00827		if ( Num < 10 )
00828			return "0"$Num;
00829		else
00830			return string(Num);
00831	}
00832	
00833	simulated function DrawRemainingTime(canvas Canvas, int x, int y)
00834	{
00835		local int timeleft;
00836		local int Hours, Minutes, Seconds;
00837	
00838		if (PlayerPawn(Owner)==None || PlayerPawn(Owner).GameReplicationInfo==None)
00839			return;
00840	
00841		timeleft = PlayerPawn(Owner).GameReplicationInfo.RemainingTime;
00842		Hours   = timeleft / 3600;
00843		Minutes = timeleft / 60;
00844		Seconds = timeleft % 60;
00845		//FONT ALTER
00846		//Canvas.Font = Canvas.LargeFont;
00847		if(MyFonts != None)
00848			Canvas.Font = MyFonts.GetStaticLargeFont();
00849		else
00850			Canvas.Font = Canvas.LargeFont;
00851	
00852		Canvas.SetPos(x, y);
00853		if (timeleft <= 30)
00854			Canvas.SetColor(255,0,0);
00855		Canvas.DrawText(TwoDigitString(Minutes)$":"$TwoDigitString(Seconds), true);
00856		Canvas.SetColor(255,255,255);
00857	}
00858	
00859	simulated function DrawFragCount(canvas Canvas, int x, int y)
00860	{
00861		local float textwidth, textheight;
00862		local int score, fraglimit;
00863		local string text;
00864		local PlayerPawn PlayerOwner;
00865	
00866		PlayerOwner = PlayerPawn(Owner);
00867	
00868		// Draw Frag Icon
00869	//	Canvas.SetPos(X-100,Y);
00870	//	Canvas.DrawIcon(Texture'IconSkull', 1.0);	
00871	//	Canvas.CurX -= 19;
00872	//	Canvas.CurY += 23;
00873	
00874		if ( PlayerOwner.PlayerReplicationInfo == None )
00875			return;
00876	
00877		score = int(PlayerOwner.PlayerReplicationInfo.Score);
00878		if (RuneGameReplicationInfo(PlayerOwner.GameReplicationInfo) != None && 
00879			RuneGameReplicationInfo(PlayerOwner.GameReplicationInfo).FragLimit > 0)
00880		{
00881			fraglimit= RuneGameReplicationInfo(PlayerOwner.GameReplicationInfo).FragLimit;
00882			if (score == fraglimit-1)
00883				Canvas.SetColor(255,0,0);
00884			text = score$"/"$fraglimit$" ";
00885		}
00886		else
00887		{
00888			text = score$" ";
00889		}
00890		//FONT ALTER
00891		//Canvas.Font = Canvas.LargeFont;
00892		if(MyFonts != None)
00893			Canvas.Font = MyFonts.GetStaticLargeFont();
00894		else
00895			Canvas.Font = Canvas.LargeFont;
00896	
00897		Canvas.DrawTextRightJustify(text, X, Y);
00898		Canvas.SetColor(255,255,255);
00899	}
00900	
00901	
00902	simulated function DrawStrength(Canvas Canvas, int X, int Y)
00903	{
00904		local Texture TexFull, TexEmpty;
00905		local Pawn P;
00906		local float scale;
00907		local float percent;
00908	
00909		P = Pawn(Owner);
00910		if(P == None)
00911			return;
00912	
00913		if(Owner.IsA('SarkRagnar'))
00914		{ // Use Sark HUD
00915			TexFull = Texture'SarkBloodFull';
00916			TexEmpty = Texture'SarkBloodEmpty';
00917		}
00918		else
00919		{
00920			TexFull = Texture'BloodFull';
00921			TexEmpty = Texture'BloodEmpty';
00922		}
00923	
00924		scale = BloodScale * HudScale;
00925		
00926		// Set up for drawing actual bar	
00927		X -= TexFull.USize * scale * 0.5;
00928		Y -= TexFull.VSize * scale;
00929		Canvas.SetPos(X,Y);
00930	
00931		if(HudBloodlust == 0)
00932		{
00933			Canvas.DrawIcon(TexEmpty, scale);
00934		}
00935		else if(HudBloodlust == 100) // NOTE:  This should be the max bloodlust amount
00936		{
00937			Canvas.DrawIcon(TexFull, scale);
00938		}
00939		else
00940		{ // Left-right fill bar
00941			percent = (HudBloodlust / 100); // NOTE:  MaxShield
00942			Canvas.DrawTile(TexFull, TexFull.USize * scale * percent, scale * TexFull.VSize,
00943				0, 0, TexFull.USize * percent, TexFull.VSize);
00944			Canvas.SetPos(X + percent * scale * TexFull.USize, Y); // Adjust for the second half
00945			Canvas.DrawTile(TexEmpty, TexEmpty.USize * scale - TexEmpty.USize * scale * percent, TexEmpty.VSize * scale, 
00946				percent * TexEmpty.USize, 0, TexEmpty.USize * (1.0 - percent), TexEmpty.VSize);
00947		}
00948	}
00949	
00950	simulated function DrawPower(Canvas Canvas, int X, int Y)
00951	{
00952		local int i;
00953		local Texture TexFull, TexEmpty, TexIcon, TexTick;
00954		local Texture TexFullTop, TexEmptyTop;
00955		local Texture tex1, tex2;
00956		local float XSize, YSize;
00957		local Pawn P;
00958		local float scale;
00959		local int IconCount;
00960		local int Cell;
00961		local float percent;
00962		local float curY;
00963		local float PixelsPerPowerUnit;
00964			
00965		scale = HudScale; // TweakMe!
00966	
00967		curY = Y;
00968		
00969		P = Pawn(Owner);
00970		if(P == None)
00971			return;
00972	
00973		if(Owner.IsA('SarkRagnar'))
00974		{ // Use Sark HUD
00975			TexIcon = Texture'SarkRuneIcon';
00976			TexFull = Texture'SarkRuneFull';
00977			TexEmpty = Texture'SarkRuneEmpty';
00978			TexFullTop = Texture'SarkRuneFullTop';
00979			TexEmptyTop = Texture'SarkRuneEmptyTop';
00980			TexTick = Texture'PowerTick';
00981		}
00982		else
00983		{ // Normal Ragnar HUD
00984			TexIcon = Texture'RuneIcon';
00985			TexFull = Texture'RuneFull';
00986			TexEmpty = Texture'RuneEmpty';
00987			TexFullTop = Texture'RuneFullTop';
00988			TexEmptyTop = Texture'RuneEmptyTop';
00989			TexTick = Texture'PowerTick';
00990		}
00991	
00992		// Draw base icon
00993		curY -= TexIcon.VSize * scale;	
00994		Canvas.SetPos(X, curY);
00995	
00996		if (P.Weapon != None && P.Weapon.bCanBePoweredUp)
00997		{
00998			// Draw powerup icon
00999			if (P.Weapon.bPoweredUp)
01000				Canvas.DrawIcon(P.Weapon.PowerupIconAnim, scale);
01001			else
01002				Canvas.DrawIcon(P.Weapon.PowerupIcon, scale);
01003		}
01004		else
01005		{
01006			Canvas.DrawIcon(TexIcon, scale);
01007		}
01008	
01009		if (RunePlayer(Owner).RunePower <= 0)
01010			return;
01011	
01012		if(HudPower > P.MaxPower)
01013			HudPower = P.MaxPower;
01014			
01015		IconCount = (P.MaxPower - 1) / 20;
01016		if(IconCount > 10)
01017			IconCount = 10;
01018			
01019		Cell = int((HudPower - 1) / 20);
01020		if(Cell < 0)
01021			Cell = 0;
01022		else if(Cell > IconCount)
01023			Cell = IconCount;
01024					
01025		// Draw Full Icons
01026		curY -= TexFull.VSize * scale;
01027		for(i = 0; i < Cell; i++)
01028		{
01029			Canvas.SetPos(X, curY);
01030			Canvas.DrawIcon(TexFull, scale);
01031			curY -= TexFull.VSize * scale;
01032		}
01033		
01034		// Draw partially full icon
01035		if(HudPower > 0)
01036		{
01037			if(Cell == IconCount)
01038			{
01039				tex1 = TexEmptyTop;
01040				tex2 = TexFullTop;
01041			}
01042			else
01043			{
01044				tex1 = TexEmpty;
01045				tex2 = TexFull;
01046			}
01047	
01048			Canvas.SetPos(X, curY); // reset position
01049			percent = 1.0 - ((HudPower - 1) - Cell * 20) / 20;
01050		
01051			Canvas.DrawTile(tex1, 32 * Scale, percent * Scale * 32, 
01052				0, 0, 32, 32 * percent);
01053			Canvas.SetPos(X, curY + percent * Scale * 32); // Adjust for the second half
01054			Canvas.DrawTile(tex2, 32 * Scale, 32 * scale - percent * Scale * 32, 
01055				0, percent * 32, 32, 32 - 32 * percent);
01056			Canvas.SetPos(X, curY); // reset position
01057		}
01058		else
01059		{ // Draw an empty slot instead of the split when health is zero
01060			Canvas.SetPos(X, curY); // reset position
01061			Canvas.DrawIcon(TexEmpty, scale);
01062		}
01063		
01064		// Draw Empty Icons
01065		curY -= TexEmpty.VSize * scale;
01066		for(i = Cell; i < IconCount; i++)
01067		{
01068			Canvas.SetPos(X, curY);
01069	
01070			if(i == IconCount - 1)
01071				Canvas.DrawIcon(TexEmptyTop, scale);
01072			else
01073				Canvas.DrawIcon(TexEmpty, scale);
01074			
01075			curY -= TexEmpty.VSize * scale;
01076		}
01077	
01078		// Draw amount of rune power required
01079		if (P.Weapon != None && P.Weapon.bCanBePoweredUp)
01080		{
01081			PixelsPerPowerUnit = (TexEmpty.VSize*scale) / 20.0;
01082			curY = Y;
01083			curY -= TexIcon.VSize * scale;
01084			curY -= float(P.Weapon.RunePowerRequired)*PixelsPerPowerUnit;
01085			curY += 2.0*scale;
01086			curY -= TexTick.VSize/2;
01087	
01088			if (P.Weapon.RunePowerRequired <= P.MaxPower)	// Make sure not off the chart
01089			{
01090				if (P.RunePower >= P.Weapon.RunePowerRequired)
01091				{	// Use different graphic when powerupable?
01092				}
01093	
01094				Canvas.SetPos(X, curY);
01095				Canvas.DrawIcon(TexTick, scale);
01096			}
01097		}
01098	}
01099	
01100	simulated function DrawHealth(Canvas Canvas, int X, int Y)
01101	{
01102		local int i;
01103		local Texture TexFull, TexEmpty, TexIcon;
01104		local Texture TexFullTop, TexEmptyTop;
01105		local Texture tex1, tex2;
01106		local float XSize, YSize;
01107		local Pawn P;
01108		local float scale;
01109		local int IconCount;
01110		local int Cell;
01111		local float percent;
01112			
01113		scale = HudScale * (1.5 - BloodScale); // Health scales down if bloodlust is enabled
01114		
01115		P = Pawn(Owner);
01116		if(P == None)
01117			return;
01118	
01119		if(Owner.IsA('SarkRagnar'))
01120		{ // Use Sark HUD
01121			TexIcon = Texture'SarkHealthIcon';
01122			TexFull = Texture'SarkHealthFull';
01123			TexEmpty = Texture'SarkHealthEmpty';
01124			TexFullTop = Texture'SarkHealthFullTop';
01125			TexEmptyTop = Texture'SarkHealthEmptyTop';
01126		}
01127		else
01128		{ // Normal Ragnar HUD
01129			TexIcon = Texture'HealthIcon';
01130			TexFull = Texture'HealthFull';
01131			TexEmpty = Texture'HealthEmpty';
01132			TexFullTop = Texture'HealthFullTop';
01133			TexEmptyTop = Texture'HealthEmptyTop';
01134		}
01135		
01136		// Draw base icon
01137		Y -= TexIcon.VSize * scale;	
01138		Canvas.SetPos(X, Y);
01139		Canvas.DrawIcon(TexIcon, scale);
01140	
01141		if(HudHealth > P.MaxHealth)
01142			HudHealth = P.MaxHealth;
01143			
01144		IconCount = (P.MaxHealth - 1) / 20;
01145		if(IconCount > 10)
01146			IconCount = 10;
01147			
01148		Cell = int((HudHealth - 1) / 20);
01149		if(Cell < 0)
01150			Cell = 0;
01151		else if(Cell > IconCount)
01152			Cell = IconCount;
01153					
01154		// Draw Full Icons
01155		Y -= TexFull.VSize * scale;
01156		for(i = 0; i < Cell; i++)
01157		{
01158			Canvas.SetPos(X, Y);
01159			Canvas.DrawIcon(TexFull, scale);
01160			Y -= TexFull.VSize * scale;
01161		}
01162		
01163		// Draw partially full icon
01164		if(HudHealth > 0)
01165		{
01166			if(Cell == IconCount)
01167			{
01168				tex1 = TexEmptyTop;
01169				tex2 = TexFullTop;
01170			}
01171			else
01172			{
01173				tex1 = TexEmpty;
01174				tex2 = TexFull;
01175			}
01176	
01177			Canvas.SetPos(X, Y); // reset position
01178			percent = 1.0 - ((HudHealth - 1) - Cell * 20) / 20;
01179		
01180			Canvas.DrawTile(tex1, 32 * Scale, percent * Scale * 32, 
01181				0, 0, 32, 32 * percent);
01182			Canvas.SetPos(X, Y + percent * Scale * 32); // Adjust for the second half
01183			Canvas.DrawTile(tex2, 32 * Scale, 32 * scale - percent * Scale * 32, 
01184				0, percent * 32, 32, 32 - 32 * percent);
01185			Canvas.SetPos(X, Y); // reset position
01186		}
01187		else
01188		{ // Draw an empty slot instead of the split when health is zero
01189			Canvas.SetPos(X, Y); // reset position
01190			Canvas.DrawIcon(TexEmpty, scale);
01191		}
01192		
01193		
01194		// Draw Empty Icons
01195		Y -= TexEmpty.VSize * scale;
01196		for(i = Cell; i < IconCount; i++)
01197		{
01198			Canvas.SetPos(X, Y);
01199	
01200			if(i == IconCount - 1)
01201				Canvas.DrawIcon(TexEmptyTop, scale);
01202			else
01203				Canvas.DrawIcon(TexEmpty, scale);
01204			
01205			Y -= TexEmpty.VSize * scale;
01206		}
01207	}
01208	
01209	simulated function DrawShield(canvas Canvas, int X, int Y)
01210	{
01211		local Texture TexFull, TexEmpty, TexIcon;
01212		local float XSize, YSize;
01213		local Pawn P;
01214		local float scale;
01215		local float percent;
01216	
01217		P = Pawn(Owner);
01218		if(P == None)
01219			return;
01220	
01221		if(P.Shield == None)
01222			return;
01223	
01224		if(Owner.IsA('SarkRagnar'))
01225		{ // Use Sark HUD
01226			TexIcon = Texture'SarkShieldIcon';
01227			TexFull = Texture'SarkShieldFull';
01228			TexEmpty = Texture'SarkShieldEmpty';
01229		}
01230		else
01231		{
01232			TexIcon = Texture'ShieldIcon';
01233			TexFull = Texture'ShieldFull';
01234			TexEmpty = Texture'ShieldEmpty';
01235		}
01236	
01237		scale = HudScale * 0.5; // TweakMe!
01238		
01239		// Draw base icon
01240		Y -= TexIcon.VSize * scale;	
01241		Canvas.SetPos(X, Y);
01242		Canvas.DrawIcon(TexIcon, scale);
01243	
01244		// Set up for drawing actual bar	
01245		Y -= TexFull.VSize * scale;
01246		Canvas.SetPos(X,Y);
01247	
01248		HudShield = Clamp(HudShield, 0, 100);
01249		if(HudShield == 0)
01250		{
01251			Canvas.DrawIcon(TexEmpty, scale);
01252		}
01253		else if(HudShield == 100) // NOTE:  This should be the max shield amount
01254		{
01255			Canvas.DrawIcon(TexFull, scale);
01256		}
01257		else
01258		{
01259			percent = 1.0 - (HudShield / 100); // NOTE:  MaxShield
01260			Canvas.DrawTile(TexEmpty, TexEmpty.USize * Scale, percent * Scale * TexEmpty.VSize,
01261				0, 0, TexEmpty.USize, TexEmpty.VSize * percent);
01262			Canvas.SetPos(X, Y + percent * Scale * TexEmpty.VSize); // Adjust for the second half
01263			Canvas.DrawTile(TexFull, TexEmpty.USize * Scale, 
01264				TexEmpty.VSize * scale - percent * Scale * TexEmpty.VSize, 
01265				0, percent * TexEmpty.VSize, TexEmpty.USize, TexEmpty.VSize - TexEmpty.VSize * percent);
01266		}
01267	}
01268	
01269	simulated function DrawAir(canvas Canvas, int X, int Y)
01270	{
01271		local Texture TexFull, TexEmpty, TexIcon;
01272		local float XSize, YSize;
01273		local Pawn P;
01274		local float scale;
01275		local float percent;
01276	
01277		P = Pawn(Owner);
01278		if(P == None)
01279			return;
01280	
01281		if(Owner.IsA('SarkRagnar'))
01282		{ // Use Sark HUD
01283			TexIcon = Texture'SarkAirIcon';
01284			TexFull = Texture'SarkAirFull';
01285			TexEmpty = Texture'SarkAirEmpty';
01286		}
01287		else
01288		{
01289			TexIcon = Texture'AirIcon';
01290			TexFull = Texture'AirFull';
01291			TexEmpty = Texture'AirEmpty';
01292		}
01293	
01294		scale = HudScale * 0.5; // TweakMe!
01295			
01296		// Draw base icon
01297		Y -= TexIcon.VSize * scale;	
01298		Canvas.SetPos(X, Y);
01299		Canvas.DrawIcon(TexIcon, scale);
01300	
01301		// Set up for drawing actual bar	
01302		Y -= TexFull.VSize * scale;
01303		Canvas.SetPos(X,Y);
01304	
01305		if(HudAir == 0 || P.bDrowning)
01306		{
01307			Canvas.DrawIcon(TexEmpty, scale);
01308		}
01309		else if(HudAir >= P.UnderWaterTime)
01310		{
01311			Canvas.DrawIcon(TexFull, scale);
01312		}
01313		else
01314		{
01315			percent = 1.0 - (HudAir / P.UnderWaterTime);
01316			Canvas.DrawTile(TexEmpty, TexEmpty.USize * Scale, percent * Scale * TexEmpty.VSize,
01317				0, 0, TexEmpty.USize, TexEmpty.VSize * percent);
01318			Canvas.SetPos(X, Y + percent * Scale * TexEmpty.VSize); // Adjust for the second half
01319			Canvas.DrawTile(TexFull, TexEmpty.USize * Scale, 
01320				TexEmpty.VSize * scale - percent * Scale * TexEmpty.VSize, 
01321				0, percent * TexEmpty.VSize, TexEmpty.USize, TexEmpty.VSize - TexEmpty.VSize * percent);
01322		}
01323	}
01324	
01325	simulated function DrawWeapon(canvas Canvas, int X, int Y)
01326	{
01327		if (Pawn(Owner).Weapon == None)
01328			return;
01329	
01330		Canvas.SetPos(X,Y);
01331	}
01332	
01333	simulated function SetHudFade(canvas Canvas, float fade)
01334	{
01335		local float HudAlpha;
01336	
01337		if (PlayerPawn(Owner)!=None)
01338			HudAlpha = PlayerPawn(Owner).HudTranslucency;
01339		else
01340			HudAlpha = 1.0;
01341	
01342		Canvas.AlphaScale = fade * HudAlpha;
01343	
01344		if(HudAlpha < 1.0 || fade < 1.0)
01345			Canvas.Style = ERenderStyle.STY_AlphaBlend;
01346		else
01347			Canvas.Style = ERenderStyle.STY_Normal;	
01348	}
01349	
01350	simulated function PostRender( canvas Canvas )
01351	{
01352		local PlayerPawn thePlayer;
01353		local Texture Tex;
01354		local float XSize, YSize;
01355	
01356		thePlayer = PlayerPawn(Owner);
01357		if (thePlayer == None || thePlayer.RendMap == 0)
01358			return;
01359	
01360		if (HudMode==0)
01361		{	// Hud is off
01362			DrawMessages(Canvas);
01363			DrawRuneMessages(Canvas);
01364	
01365			// Draw Progress Bar
01366			Canvas.SetColor(255,255,255);
01367			if ( thePlayer.ProgressTimeOut > Level.TimeSeconds )
01368				DisplayProgressMessage(Canvas);
01369			Canvas.SetColor(255,255,255);
01370	
01371			// Reset the translucency of the HUD back to normal
01372			Canvas.Style = ERenderStyle.STY_Normal;		
01373			Canvas.DrawColor.R = 255;
01374			Canvas.DrawColor.G = 255;
01375			Canvas.DrawColor.B = 255;
01376			return;
01377		}
01378	
01379		DefaultCanvas(Canvas);
01380		bResChanged = (Canvas.ClipX != OldClipX);
01381		OldClipX = Canvas.ClipX;
01382	
01383		// Set the relative HUD scale to 640x480
01384		HudScale = Canvas.ClipX / 640;
01385	
01386		if (!Owner.IsA('Spectator'))
01387		{
01388			bHealth = true;
01389	
01390			if(thePlayer.bBloodLust)
01391				bBloodLust = true;
01392			else
01393				bBloodLust = false;
01394	
01395	/*
01396			if(thePlayer.Weapon != None)
01397			{ // Combat Mode
01398				bPower = true;
01399				bBloodLust = true;
01400				if(thePlayer.Shield != None)
01401					bShield = true;
01402				else
01403					bShield = false;
01404			}
01405			else
01406			{ // Explore mode
01407				bPower = false;
01408				bShield = false;
01409			}
01410	*/
01411	//		if(RunePlayer(Owner).RunePower > 0)
01412			if(thePlayer.Weapon != None || thePlayer.RunePower > 0)
01413				bPower = true;
01414	
01415			bBloodLust = true;
01416			if(thePlayer.Shield != None)
01417				bShield = true;
01418			else
01419				bShield = false;
01420	
01421	
01422			if(thePlayer.Region.Zone.bWaterZone)
01423				bAir = true;
01424			else
01425				bAir = false;
01426	
01427			// Draw Health/Shield/Strength Bars
01428			SetHudFade(Canvas, FadeHealth);
01429			DrawHealth(Canvas, 4 * HudScale, Canvas.ClipY - 4 * HudScale);
01430	
01431			if(FadeBloodlust > 0)
01432			{
01433				SetHudFade(Canvas, FadeBloodlust);
01434				DrawStrength(Canvas, Canvas.ClipX * 0.5, Canvas.ClipY - 4 * HudScale);
01435			}
01436			if(FadePower > 0)	
01437			{
01438				SetHudFade(Canvas, FadePower);
01439				DrawPower(Canvas, Canvas.ClipX - 36 * HudScale, Canvas.ClipY - 4 * HudScale);
01440			}
01441			if(FadeShield > 0)
01442			{
01443				SetHudFade(Canvas, FadeShield);
01444				DrawShield(Canvas, Canvas.ClipX - 60 * HudScale, Canvas.ClipY - 4 * HudScale);
01445			}
01446			if(FadeAir > 0 && Level.Netmode==NM_Standalone)
01447			{
01448				SetHudFade(Canvas, FadeAir);
01449				DrawAir(Canvas, 40 * HudScale, Canvas.ClipY - 4 * HudScale);
01450			}
01451		}
01452	
01453		DrawMessages(Canvas);
01454		DrawRuneMessages(Canvas);
01455	
01456		// Reset the translucency of the HUD back to normal
01457		Canvas.Style = ERenderStyle.STY_Normal;		
01458		Canvas.DrawColor.R = 255;
01459		Canvas.DrawColor.G = 255;
01460		Canvas.DrawColor.B = 255;
01461	
01462		// Draw scoreboard (if active)
01463		if ( thePlayer.bShowScores )
01464		{
01465			if ( (thePlayer.Scoring == None) && (thePlayer.ScoringType != None) )
01466				thePlayer.Scoring = Spawn(thePlayer.ScoringType, thePlayer);
01467			if ( thePlayer.Scoring != None )
01468			{ 
01469				thePlayer.Scoring.ShowScores(Canvas);
01470				return;
01471			}
01472		}
01473	
01474		DrawNetPlug(Canvas);
01475	
01476		// Draw Remaining Time
01477		if ( bTimeDown || (thePlayer.GameReplicationInfo != None && thePlayer.GameReplicationInfo.RemainingTime > 0) )
01478		{
01479			bTimeDown = true;
01480			DrawRemainingTime(Canvas, 0, 0);
01481		}
01482	
01483		if (!Owner.IsA('Spectator'))
01484		{
01485			// Draw Frag count
01486			if ( (Level.Game == None) || Level.Game.bDeathMatch ) 
01487			{
01488				DrawFragCount(Canvas, Canvas.ClipX, 0);
01489			}
01490		}
01491	
01492		if ( HUDMutator != None )
01493			HUDMutator.PostRender(Canvas);
01494	
01495		// Draw Menu (if active)
01496		if ( thePlayer.bShowMenu )
01497		{
01498			DisplayMenu(Canvas);
01499			return;
01500		}
01501	
01502		if ( Level.NetMode != NM_StandAlone)
01503			DrawTypingPlayers(Canvas);
01504	
01505		// Draw Progress Bar
01506		Canvas.SetColor(255,255,255);
01507		if ( thePlayer.ProgressTimeOut > Level.TimeSeconds )
01508			DisplayProgressMessage(Canvas);
01509		Canvas.SetColor(255,255,255);
01510	}
01511	
01512	simulated function DrawNetPlug(canvas Canvas)
01513	{
01514		local PlayerPawn thePlayer;
01515	
01516		if (Level.NetMode == NM_StandAlone)
01517			return;
01518		
01519		thePlayer = PlayerPawn(Owner);
01520		if (thePlayer == None || !thePlayer.bBadConnectionAlert)
01521			return;
01522	
01523		Canvas.SetPos(10,10);
01524		Canvas.DrawIcon(Texture'NetOutage', 1.0);
01525	}
01526	
01527	simulated function DrawTypingPlayers(canvas Canvas)
01528	{
01529		local RunePlayer P;
01530		local int SX,SY;
01531		local float scale, dist;
01532		local Texture Tex;
01533		local vector pos;
01534	
01535		if (TypingIcon==None || Pawn(Owner)==None)
01536			return;
01537	
01538		foreach AllActors(class'RunePlayer', P)
01539		{
01540			if (!P.bIsTyping)
01541				continue;
01542	//		if (P == self)
01543	//			continue;
01544	
01545			pos = P.Location+vect(0,0,1.2)*P.CollisionHeight;
01546			if (!FastTrace(pos, Pawn(Owner).ViewLocation))
01547				continue;
01548	
01549			Canvas.TransformPoint(pos, SX, SY);
01550			if (SX > 0 && SX < Canvas.ClipX &&
01551				SY > 0 && SY < Canvas.ClipY)
01552			{
01553				dist = VSize(P.Location-Pawn(Owner).ViewLocation);
01554				dist = FClamp(dist, 1, 10000);
01555				scale = 500.0/dist;
01556				scale = FClamp(scale, 0.01, 2.0);
01557	
01558				Canvas.SetPos(SX-(TypingIcon.USize*scale)*0.5, SY-TypingIcon.VSize*scale);
01559				Canvas.DrawIcon(TypingIcon, scale);
01560			}
01561		}
01562	}
01563	
01564	
01565	//=============================================================================
01566	//
01567	// STATE Idle
01568	//
01569	// Idle state.  For a HUD, this does nothing
01570	//=============================================================================
01571	
01572	state Idle
01573	{
01574	begin:
01575	}
01576	
01577	//=============================================================================
01578	//
01579	// STATE Cinematic
01580	//
01581	//=============================================================================
01582	
01583	state Cinematic
01584	{
01585		simulated function Tick(float DeltaSeconds)
01586		{
01587			CineLoc += CineSpeed * DeltaSeconds;
01588	
01589			if(CineSpeed > 0 && CineLoc > 1)
01590			{
01591				CineLoc = 1;
01592			}
01593			else if(CineSpeed < 0 && CineLoc < 0)
01594			{
01595				CineLoc = 0;
01596				GotoState('Idle');
01597			}
01598	
01599			global.Tick(DeltaSeconds);
01600		}
01601	
01602		simulated function PostRender( canvas Canvas )
01603		{
01604			local PlayerPawn thePlayer;
01605			local Texture Tex;
01606			local float XSize, YSize;
01607		
01608			thePlayer = PlayerPawn(Owner);
01609			if (thePlayer == None || thePlayer.RendMap == 0)
01610				return;
01611		
01612			DefaultCanvas(Canvas);
01613	
01614			Tex = Texture'RuneFX.Letterbox';
01615			XSize = Canvas.ClipX;
01616			YSize = Canvas.ClipY * 0.15;
01617				
01618			Canvas.SetPos(0, -YSize * (1.0 - CineLoc));
01619			Canvas.DrawTile(Tex, XSize, YSize, 0, 0, Tex.USize, Tex.VSize);
01620			Canvas.SetPos(0, Canvas.ClipY - YSize + YSize * (1.0 - CineLoc));
01621			Canvas.DrawTile(Tex, XSize, YSize, 0, 0, Tex.USize, Tex.VSize);
01622	
01623			DrawMessages(Canvas);
01624			DrawRuneMessages(Canvas);
01625			
01626			// Draw Menu (if active)
01627			if ( thePlayer.bShowMenu )
01628			{
01629				DisplayMenu(Canvas);
01630				return;
01631			}	
01632	
01633			// Draw Progress Bar
01634			Canvas.SetColor(255,255,255);
01635			if ( thePlayer.ProgressTimeOut > Level.TimeSeconds )
01636				DisplayProgressMessage(Canvas);
01637			Canvas.SetColor(255,255,255);
01638		}
01639	
01640		function BeginState()
01641		{
01642			CineLoc = 0;
01643			CineSpeed = 3;
01644		}
01645	
01646	begin:
01647	//	CineLoc = 0;
01648	//	CineSpeed = 3;
01649		Goto('wait');
01650	
01651	end:
01652		ClearMessagesOfType('Subtitle');
01653		ClearMessagesOfType('RedSubtitle');
01654		CineLoc = 1.0;
01655		CineSpeed = -3;
01656	
01657	wait:
01658	}
01659	
01660	//=============================================================================
01661	//
01662	// Debug
01663	//
01664	//=============================================================================
01665	
01666	simulated function Debug(Canvas canvas, int mode)
01667	{	
01668		Super.Debug(canvas, mode);
01669	
01670		Canvas.DrawText("RuneHUD:");
01671		Canvas.CurY -= 8;
01672		Canvas.DrawText("CineLoc: " $ CineLoc);
01673		Canvas.CurY -= 8;
01674		Canvas.DrawText("CineSpeed: " $ CineSpeed);
01675		Canvas.CurY -= 8;
01676		Canvas.DrawText("HudHealth: " $ HudHealth);
01677	}
01678	
01679	defaultproperties
01680	{
01681	     TypingIcon=Texture'RuneFX2.Wordballoon'
01682	     HudScale=1.000000
01683	}