tf2/tf2_src/devtools/mapbuild/buildMaps.pl

#========= Copyright 1996-2008, Valve Corporation, All rights reserved. ==========
#
# Master script for performing automated compiles of bsp's with cubemaps, reslists,
# and nodegraphs. Compiles can be triggered manually by adding the vmf's absolute
# path to mapbuild\forcelist.txt, or by adding the "autocompile" keyword 
# to the checkin comments for a vmf.
#
#=================================================================================

use strict;
use warnings;
use Net::SMTP;

my $maxCompiles = 3; 		# Maximum number of simultaneous compiles.
my $running = 0;
my @g_CompileList;
my @finalizeList;
my @g_Finalizing;
my @g_CompileThreads;
my %g_ToolArgs;
my %g_RunningCompiles;
my @g_OutputFiles;
my $g_FilenameIdx = 0;
my @g_MainDirs;
my $g_MainDirIdx = 0;
my @g_MapsToBuild;

my $buildbsp = 1;		# Compile the bsp with vbsp, vvis, and vrad
my $buildreslists = 1;		# Build reslists for the map
my $buildnodegraphs = 1;	# Build the nodegraph (.ain) for the map

my $rootdir = "..\\..\\..\\..";	# Relative path from this script to one level above the "main" directory

system( "echo. > finalize.txt" );

$SIG{CHLD}='IGNORE';

# Generate filenames for the compile output files

for ( my $ct = 0; $ct < $maxCompiles * 2; ++$ct )
{
	my $filename = join( '', "$rootdir\\main1\\src\\devtools\\mapbuild\\buildqueue", $g_FilenameIdx++, ".txt" );
	push( @g_OutputFiles, $filename );
}

# Generate main directory names for each simultaneous compile

for ( my $ct = 1; $ct <= $maxCompiles; ++$ct )
{
	my $filename = join( '', "main", $ct );
	push( @g_MainDirs, $filename );
}


# Loop for infinity. If changes are made to this script, the process needs to
# be killed and restarted for those changes to take effect.  Note, any maps that
# are compiling or waiting in the queue will NOT be picked up again when the script
# is restarted. Any maps that were compiling or waiting to compile when the process
# was stopped will need to be started manually by adding the vmf absolute path
# to forcelist.txt. A map can be manually added to the queue at any time while the script
# is running by adding the vmf absolute path to forcelist.txt.

while ( 1 )
{

# Generate a list of maps that need to be built. For vmf's that have been changed in
# Perforce, the checkin comments are parsed and if the word "autocompile"
# is found then that map will be added to the build list. All maps that are listed in 
# forcelist.txt are also added to the build list.

syncChangedMaps();


# Append the maps to the build queue while filtering out duplicates. We only
# want to filter duplicates out of the queue - if a map is already compiling
# then it's reasonable to add it to the queue again because it must have changed
# since the current build began.

my $updated = 0;
for my $map ( @g_MapsToBuild )
{
	if ( $map =~ /(\w*.vmf)/ )
	{
		# make sure it's not already in the queue

		my $duplicate = 0;
		my $testname = $1;
		for ( @g_CompileList )
		{
			if ( /$testname/ )
			{
				$duplicate = 1;
				last;
			}
		}

		system( "echo. >> log.txt" );

		if ( $duplicate != 1 )
		{
			print( "Adding to compile list $map\n" );
			system( "echo Adding to compile list $map >> log.txt" );
			push( @g_CompileList, $map );
			$updated = 1;
		}
		else
		{
			print( "Duplicate map found: $testname\n" );
			system( "echo Duplicate map found: $testname >> log.txt" );
		}
	}
}

splice( @g_MapsToBuild );

# If there is a build slot open, start building the next map

StartCompiles();

sleep( 60 ); # Time is arbitrary - just don't spam Perforce

# Load in the finalize queue

open( INFILE, "<finalize.txt" );
my @finalizeList = <INFILE>;
close( INFILE );

system( "echo. > finalize.txt" );

# Finalize the maps (cubemaps, reslist, nodegraph, and checkin). The finalize list
# also contains the compile output (times,args,etc.) that need to go in the checkin comments.

my $maindir	= "";
my $mod		= "";
my $mapname	= "";
my $strTime 	= "";
my $vbspargs 	= "";
my $vvisargs 	= "";
my $vradargs 	= "";
my $outfile	= "";

for ( @finalizeList )
{
	if ( /Finalize: (\w*) (\w*)/ )
	{
		$mod = $1;
		$mapname = $2;
		next;
	}
	elsif ( /maindir: (.*)/ )
	{
		$maindir = $1;
		next;
	}
	elsif ( /vbspargs: (.*)/ )
	{
		$vbspargs = $1;
		next;
	}
	elsif ( /vvisargs: (.*)/ )
	{
		$vvisargs = $1;
		next;
	}
	elsif ( /vradargs: (.*)/ )
	{
		$vradargs = $1;
		next;
	}
	elsif ( /time: (.*)/ )
	{
		$strTime = $1;
		next;
	}
	elsif ( /outfile: (.*)/ )
	{
		# This is the final entry for a map
		$outfile = $1;
	}
	else
	{
		next;
	}

	print( "\nFinalizing $mod\\$mapname.bsp\n" );
	system( "echo Finalizing $mapname.bsp >> log.txt" );

	# A compile slot has opened up

	--$running;
	push( @g_Finalizing, $mapname );

	# Let another compile start in the just-emptied slot.

	StartCompiles();

	my $ldrResult = 0;
	my $hdrResult = 0;

	# HACK: Make sure a zombie process can't hold up the system

	system( "taskkill /im hl2.exe /f" );

	chdir( "$rootdir\\$maindir\\src\\devtools\\mapbuild" );

	# Get the Perforce client and owner names for the checkin file
	my $g_client;
	my $g_owner;

	my @clientspec = readpipe "p4 client -o";

	for ( @clientspec )
	{
		if ( /^Client:[\s*](.*)/ )
		{
			$g_client = $1;
			print( "Using client $g_client\n" );
		}
		elsif ( /^Owner:[\s*](.*)/ )
		{
			$g_owner = $1;
			print( "Using owner $g_owner\n" );
		}
	}

	if ( $buildbsp == 1 )
	{
		# Build cubemaps

		system( "echo. >> $outfile" );
		system( "time /t >> $outfile" );
		system( "echo Building cubemaps for $mapname. >> $outfile" );

		if ( $vradargs =~ /-hdr|-both/ )
		{
			$hdrResult = system( "$rootdir\\$maindir\\game\\hl2.exe -allowdebug -game $mod -window -w 1152 -h 864 +mat_picmip 0 -dev +mat_hdr_level 2 +sv_cheats 1 +map $mapname -buildcubemaps" );
		}

		if ( $vradargs =~ /-ldr|-both/ )
		{
			$ldrResult = system( "$rootdir\\$maindir\\game\\hl2.exe -allowdebug -game $mod -window -w 1152 -h 864 +mat_picmip 0 -dev +mat_hdr_level 0 +sv_cheats 1 +map $mapname -buildcubemaps" );
		}
	}

	if ( $buildreslists == 1 )
	{	
		system( "echo. >> $outfile" );
		system( "time /t >> $outfile" );
		system( "echo Building reslists and nodegraph for $mapname. >> $outfile" );

		system( "del /s $rootdir\\$maindir\\game\\$mod\\reslists_temp\\*.lst" );

		system( "p4 edit $rootdir\\$maindir\\game\\$mod\\reslists_xbox\\$mapname.lst" );
		system( "p4 add $rootdir\\$maindir\\game\\$mod\\reslists_xbox\\$mapname.lst" );
		system( "del $rootdir\\$maindir\\game\\$mod\\reslists_xbox\\$mapname.lst" );
		my $extraflags = "";
#		if ( $mod =~ /portal/ )
#		{
#			$extraflags = "-tempcontent";
#		}
		system( "del  \/s $rootdir\\$maindir\\game\\modelsounds.cache" );
		system( "$rootdir\\$maindir\\game\\hl2.exe -allowdebug -game $mod -window -dev -makereslists makereslists_xbox.txt $extraflags +map $mapname" );
	}
	elsif ( $buildnodegraphs == 1 )
	{
		# system( "p4 edit $rootdir\\$maindir\\game\\$mod\\maps\\graphs\\$mapname.ain >> log.txt" );
		
		# TODO: Build nodegraphs method. Currently we get this for free when building reslists.
	}

	# Generate the checkin file

	system( "echo. >> $outfile" );
	system( "time /t >> $outfile" );
	system( "echo Submitting to Perforce. >> $outfile" );

	open( OUTFILE, ">checkin.txt" );
	print( OUTFILE "Change: new\n\n" );

	print( OUTFILE "Client: $g_client\n\n" );
	print( OUTFILE "User:	$g_owner\n\n" );

	print( OUTFILE "Status: new\n\n" );
	print( OUTFILE "Description: Autobuild for map $mapname.bsp\n" );
	print( OUTFILE "\n" );
	if ( $hdrResult == 1 )
	{
		print( OUTFILE "\tWARNING! There was an error while building HDR cubemaps.\n" );
		print( OUTFILE "\tHDR Cubemaps may need to be rebuilt before using this map.\n\n" );
	}
	if ( $ldrResult == 1 )
	{
		print( OUTFILE "\tWARNING! There was an error while building LDR cubemaps.\n" );
		print( OUTFILE "\tLDR Cubemaps may need to be rebuilt before using this map.\n\n" );
	}
	
	if ( $buildbsp == 1 )
	{
		print( OUTFILE "\tCOMPILE ARGS\n" );
		print( OUTFILE "\tvbsp:\t",$vbspargs,"\n" );
		print( OUTFILE "\tvvis:\t",$vvisargs,"\n" );
		print( OUTFILE "\tvrad:\t",$vradargs,"\n" );
		print( OUTFILE "\n" );
		print( OUTFILE "\tBuild time: $strTime\n" );
		print( OUTFILE "\n" );
	}

	# Add the comments from the last checkin of this map

	system( "p4 changes -m 1 -s submitted -l $rootdir\\$maindir\\content\\$mod\\maps\\$mapname.vmf > comments.txt" );

	open(INFILE, "comments.txt");
	my @comments = <INFILE>;
	close(INFILE);

	if ( $buildbsp == 1 )
	{
		print( OUTFILE "\tCheckin Comments: " );
		print( OUTFILE @comments,"\n\n" );
		print( OUTFILE "\tRebuilt bsp\n" );
	}
	if ( $buildnodegraphs == 1 )
	{
		print( OUTFILE "\n\tRebuilt nodegraph\n" );
	}
	if ( $buildreslists == 1 )
	{
		print( OUTFILE "\n\tRebuilt reslist\n" );
	}

	print( OUTFILE "Files:\n" );
	if ( $buildbsp == 1 )
	{
		print( OUTFILE "\t//ValveGames/staging/game/$mod/maps/$mapname.bsp\n" );
	}
	if ( $buildnodegraphs == 1 )
	{
		# Copy up to fileserver
		system( "copy $rootdir\\$maindir\\game\\$mod\\maps\\graphs\\$mapname.ain \"\\\\fileserver\\user\\xbox\\xbox_orange\\graphs\\$mod\\$mapname.ain\"" );
	}
	if ( $buildreslists == 1 )
	{
		print( OUTFILE "\t//ValveGames/staging/game/$mod/reslists_xbox/$mapname.lst\n" );
	}
	close( OUTFILE );

	# Check in the map
	
	system( "p4 submit -i < checkin.txt >> log.txt" );	

	# Send the build output in an email to the submitter

	my $email = "kerry\@valvesoftware.com";
	for ( @comments )
	{
		if ( /Change \d* on \S* by (\w*)@/ )
		{
			$email = join( '@', $1, "valvesoftware.com" );
		}
	}

	open(INFILE, "$outfile");
	my @compileoutput = <INFILE>;
	close(INFILE);

	my$smtp;
	$smtp = Net::SMTP->new('exchange2.valvesoftware.com');

	$smtp->mail("Mapbuilder");
	$smtp->to("$email");

	$smtp->data();
	$smtp->datasend( "To: $email\n" );
	$smtp->datasend( "Subject: $mapname has finished compiling.\n" );
	$smtp->datasend( @comments );
	$smtp->datasend( @compileoutput );
	$smtp->dataend();

	$smtp->quit;

	delete( $g_RunningCompiles{$outfile} );
	splice( @g_Finalizing );

	chdir( "$rootdir\\main1\\src\\devtools\\mapbuild" );
}


} # end while(1)


#----------------------------------------
# Start a compile if there is an open slot
#----------------------------------------
sub StartCompiles
{
	my $idx = 0;

	print( "Current maplist:\n" );
	for ( @g_CompileList )
	{
		print( "$_\n" );
	}

	my $skipCt = 0;
	while ( @g_CompileList > $skipCt && $running < $maxCompiles )
	{
		my $nextMap = splice( @g_CompileList, 0, 1 );

			# Make sure this map isn't already compiling in another slot

			my $duplicate = 0;
			for ( values %g_RunningCompiles )
			{
				$nextMap =~ /(\w*).vmf/;

				if ( /^$1$/ )
				{
					system( "echo $nextMap already compiling - skipping for now. >> log.txt" );

					push @g_CompileList, $nextMap;
					++$skipCt;
					$duplicate = 1;
					last;
				}
			}
		
			if ( $duplicate == 0 )
			{
				Compile( $nextMap );

				++$running;
				++$idx;

				my $mapct = @g_CompileList;
				system( "echo Maps waiting: $mapct >> log.txt" );
			}
	}

	UpdateStats();
}

#-----------------------------------------------------------
# Compile a single map - this subroutine forks the process
#-----------------------------------------------------------
sub Compile
{
	# sync the rest of the content and bins.

	my $maindir = $g_MainDirs[$g_MainDirIdx];
	$g_MainDirIdx = ( $g_MainDirIdx + 1 ) % $maxCompiles;

	chdir( "$rootdir\\$maindir\\src\\devtools\\mapbuild" );

	system( "p4 sync $rootdir\\$maindir\\game\\..." );
	system( "p4 sync $rootdir\\$maindir\\src\\..." );


	# parse the map and mod name from the full path

	my $fullpath = shift;
	my $mod;
	my $mapname;
	if ( $fullpath =~ /(\w*)\\maps\\(\w*).vmf/ )
	{
		$mod = $1;
		$mapname = $2;
	}
	else
	{
		print( "Error getting map name and mod\n" );
		exit();
	}

	# Get the next output file. All output from the build tools
	# (vbsp,vvis,vrad) will be redirected to this file.

	my $outfile = undef;
	for ( @g_OutputFiles )
	{
		unless ( defined $g_RunningCompiles{$_} )
		{
			$outfile = $_;
			last;
		}
	}
	unless ( defined $outfile )
	{
		my $filename = join( '', "buildqueue", $g_FilenameIdx++, ".txt" );
		push( @g_OutputFiles, $filename );
		$outfile = $filename;
	}

	$g_RunningCompiles{$outfile} = $mapname;
	
	# Force-sync the vmf and bsp

	system( "echo Compiling $mod\\$mapname.bsp > $outfile" );
	system( "echo. >> log.txt" );
	system( "date /t >> log.txt" );
	system( "time /t >> log.txt" );
	system( "echo Compling $mod\\$mapname.bsp >> log.txt" );

	system( "p4 sync -f ..\\..\\..\\content\\$mod\\maps\\$mapname.vmf >> log.txt" );
	system( "p4 sync -f $rootdir\\$maindir\\content\\$mod\\maps\\$mapname.vmf >> log.txt" );
	system( "p4 sync -f $rootdir\\$maindir\\game\\$mod\\maps\\$mapname.bsp >> log.txt" );

	if ( $buildbsp == 1 )
	{
		print "\nCompiling $mod\\$mapname.bsp\n";

		# load the map compile args for this mod

		if( !open( INFILE, "$rootdir\\$maindir\\game\\$mod\\scripts\\mapautocompile.txt") )
		{
			print( "Error opening autocompile.txt\n" );
		}
		my @lines = <INFILE>;
		close (INFILE);
	
		my $tool;
		my $rest;
		my $toolmap;
		for ( @lines )
		{
			if ( /map: (.*)/ )
			{
				$toolmap = $1;
			}
			elsif ( /\s+(.+)/ )
			{
				($tool, $rest) = split ( /:\s*/, $1, 2 );
				$g_ToolArgs{$toolmap}{$tool} = $rest;
			}
		}

		# Open the bsp for edit

		system( "p4 edit $rootdir\\$maindir\\game\\$mod\\maps\\$mapname.bsp" );
		system( "p4 add $rootdir\\$maindir\\game\\$mod\\maps\\$mapname.bsp" );
		system( "del $rootdir\\$maindir\\game\\$mod\\maps\\$mapname.bsp" );
	}

	chdir( "$rootdir\\main1\\src\\devtools\\mapbuild" );

	#--------------------------------------
	# fork this compile to a new process
	#--------------------------------------

	my $pid = fork();
	print "fork failed!" unless defined $pid;
	if ( $pid != 0 )
	{
		# I am the parent
		return;
	}

	my $strTime = "";
	my $vbspargs = "";
	my $vvisargs = "";
	my $vradargs = "";

	chdir( "$rootdir\\$maindir\\src\\devtools\\mapbuild" );

	if ( $buildbsp == 1 )
	{
		# Compile

		# delete the bsp to ensure that vbsp succeeded
		system( "del $rootdir\\$maindir\\content\\$mod\\maps\\$mapname.bsp" );
		
		my $startTime = time;
	
		$vbspargs = compileTool( $maindir, $mod, $mapname, "vbsp", $outfile );
		$vvisargs = compileTool( $maindir, $mod, $mapname, "vvis", $outfile );
		$vradargs = compileTool( $maindir, $mod, $mapname, "vrad", $outfile );

		my $totalTime = time - $startTime;
		my $hours = int($totalTime / 3600);
		$totalTime -= ($hours * 3600);
		my $minutes = int( $totalTime / 60 );
		$totalTime -= ($minutes * 60);
		my $seconds = $totalTime;
		$strTime = sprintf( "%02d:%02d:%02d", $hours, $minutes, $seconds );
	}

	chdir( "$rootdir\\main1\\src\\devtools\\mapbuild" );

	# Add the map's name to the finalize list

	while( !open( OUTFILE, ">>finalize.txt" ) ) {}
	print OUTFILE "Finalize: $mod $mapname\n";
	print OUTFILE "maindir: $maindir\n";

	if ( $buildbsp == 1 )
	{
		# Output the compile args and time

		print OUTFILE "vbspargs: $vbspargs\n";
		print OUTFILE "vvisargs: $vvisargs\n";
		print OUTFILE "vradargs: $vradargs\n";
		print OUTFILE "time: $strTime\n";
	} 

	print OUTFILE "outfile: $outfile\n";

	close( OUTFILE );
	
	# This child is finished

	exit();
}

#----------------------------------------
# Run a map build tool (vbsp, vvis, vrad)
#----------------------------------------
sub compileTool
{
	my $maindir = shift;
	my $mod = shift;
	my $map = shift;
	my $tool = shift;
	my $outfile = shift;

	# Load the compile arguments that were parsed from mapautocompile.txt.
	# If the map has its own custom args, then use those - otherwise,
	# just use the default set.

	my $toolArgs = $g_ToolArgs{"default"}{$tool};
	if ( exists $g_ToolArgs{$map}{$tool} )
	{
		$toolArgs = $g_ToolArgs{$map}{$tool};
	}

	system( "echo. >> $outfile" );
	system( "time /t >> $outfile" );
	system( "echo Starting $tool for $map >> $outfile" );
	system( "echo. >> $outfile" );

	# HACK: There is a crash bug when using -both in vrad. If the -both
	# flags is present, remove it and do two vrad compiles with -ldr and -hdr.

	if ( $tool =~ /vrad/ && $toolArgs =~ /-both/ )
	{
		system( "echo Found -both argument. Splitting into -ldr and -hdr >> $outfile" );
		my $newArgs = $toolArgs;
		$newArgs =~ s/-both //;

		system( "$rootdir\\$maindir\\game\\bin\\$tool -vproject $rootdir\\$maindir\\game\\$mod $newArgs -ldr $rootdir\\$maindir\\content\\$mod\\maps\\$map >> $outfile" );
		system( "$rootdir\\$maindir\\game\\bin\\$tool -vproject $rootdir\\$maindir\\game\\$mod $newArgs -hdr $rootdir\\$maindir\\content\\$mod\\maps\\$map >> $outfile" );
	}
	else
	{
		system( "$rootdir\\$maindir\\game\\bin\\$tool -vproject $rootdir\\$maindir\\game\\$mod $toolArgs $rootdir\\$maindir\\content\\$mod\\maps\\$map >> $outfile" );
	}

	# copy the new bsp into the maps directory

	system( "copy /Y $rootdir\\$maindir\\content\\$mod\\maps\\$map.bsp $rootdir\\$maindir\\game\\$mod\\maps" );

	system( "echo. >> $outfile" );
	system( "echo Finished >> $outfile" );

	return $toolArgs;
}


#-----------------------------------
# Check if this map should build now
#-----------------------------------
sub syncChangedMaps
{
	# TODO: Get these mod names from a file?
	my @mods = ( "ep2", "portal", "episodic", "hl2", "tf" );

	# Query perforce for changed maps by doing a speculative sync. This generates a list
	# of files that it WOULD sync, without actually doing the sync.
	# BUG: This doesn't return new files that have been added - don't know why yet.

	my @maps;
	for my $mod ( @mods )
	{
		push ( @maps, readpipe "p4 sync -n ..\\..\\..\\content\\$mod\\maps\\*.vmf" );
	}

	# forcelist.txt allows maps to be manually added to the build. 

	open(INFILE, "forcelist.txt");
	my @forcemaps = <INFILE>;
	close( INFILE );

	system( "echo. > forcelist.txt" );

	# Run through the list of maps to see if any should be built

	for( @maps) 
	{
		if( /updating (.*)|adding (.*)/ )
		{
			# Check if this map should be built now
			if ( shouldBuild( $1 ) == 0 )
			{
				next;
			}
	
			# Add this map name to the build list

			system( "p4 sync -f $1" );
			push( @g_MapsToBuild, $1 );
			system( "echo Adding to the build list: $1 >> log.txt" );
		}
	}

	for( @forcemaps )
	{
		if ( /\.vmf/ )
		{
			# Add this map name to the build list

			$_ =~ /(.*)/;
			system( "p4 sync -f $1" );
			push( @g_MapsToBuild, $1 );
			system( "echo Forcing add to the build list: $1 >> log.txt" );
		}
	}
}


#-----------------------------------
# Check if this map should build now
#-----------------------------------
sub shouldBuild
{
	my $map = shift;

	# if the map line contains the force flag, build the map

	if ( $map =~ /-forcebuild/ )
	{
		return 1;
	}

	# Get the comments from the last checkin of this map
	# and look for the autocompile keyword

	my @comments = readpipe "p4 changes -m 1 -s submitted -l $map";

	for( @comments )
	{
		if ( /autocompile/i )
		{
			return 1;
		}
	}

	return 0;
}


#----------------------------------------------------------------------------------
# Hacky little routine to build an html file that contains the current state
# of the autocompiler (running, maps building, maps waiting, etc.) and a frameset
# that shows the compile output for each map that's currently building. This way
# users of the autocompiler can keep an eye on their map's progress.
#----------------------------------------------------------------------------------
sub UpdateStats
{
	my $noCompiles = 0;
	my $noWaiting = 0;
	if ( keys( %g_RunningCompiles ) == 0 && @g_Finalizing == 0 )
	{
		$noCompiles = 1;
	}
	if ( @g_CompileList == 0 )
	{
		$noWaiting = 1;
	}

	# Start building the main html page

	open( OUTFILE, ">buildlist.htm" );
	print( OUTFILE "<html>\n" );
	print( OUTFILE "<META HTTP-EQUIV=\"Refresh\" CONTENT=\"10; URL=buildlist.htm\">\n" );
	print( OUTFILE "Mapbuilder state: <font color=#009900><b>" );
	if ( $noCompiles == 1 && $noWaiting == 1 )
	{
		print( OUTFILE "Ready</b></font><br>\n" );
	}
	else
	{
		print( OUTFILE "RUNNING</b></font><br>\n" );
	}
	print( OUTFILE "Max simultaneous compiles: $maxCompiles\n" );
	print( OUTFILE "<p>\n" );
	print( OUTFILE "<b>Active:</b>\n<p>\n" );
		
	# Show a list of maps that are currently compiling

	my $filect = 0;
	if ( $noCompiles == 1 )
	{
		print( OUTFILE "None" );
	}
	else
	{
		for ( @g_OutputFiles )
		{
			if ( defined( $g_RunningCompiles{$_} ) )
			{
				my $testname = $g_RunningCompiles{$_};
				my $filename = $_;
				if ( $filename =~ /(\w*\.txt)/ )
				{
					$filename = $1;
				}
				my $finishing = 0;

				for ( @g_Finalizing )
				{
					if ( /$testname/ )
					{
						$finishing = 1;
					}
				}

				print( OUTFILE "<a href=\"$filename\" TARGET=\"_parent\">$testname.bsp</a>" );
				++$filect;

				if ( $finishing == 1 )
				{
					print( OUTFILE " - Finishing (cubemaps, reslist, nodegraph.)\n<br>\n" );
				}
				else
				{
					print( OUTFILE " - Compiling\n<br>\n" );
				}
			}
		}
	}

	# Show a list of maps that are waiting to compile

	print( OUTFILE "<p>\n<b>Waiting:</b>\n<p>\n" );
	if ( $noWaiting == 1 )
	{
		print( OUTFILE "None" );
	}
	else
	{
		for ( @g_CompileList )
		{
			/(\w*).vmf/;
			print( OUTFILE "$1.bsp\n<br>\n" );
		}
	}
	print( OUTFILE "</html>\n" );	
	close( OUTFILE );

	# create the main page

	open( OUTFILE, ">buildqueue.htm" );
	print( OUTFILE "<html>\n" );
	print( OUTFILE "<META HTTP-EQUIV=\"Refresh\" CONTENT=\"30; URL=buildqueue.htm\">\n" );
	my $size = 0;	
	if ( $filect != 0 )
	{
		print( OUTFILE "<frameset rows=\"30%" );
		$size = 70 / $filect;
	}
	else
	{
		print( OUTFILE "<frameset rows=\"100%" );
	}
	for ( my $ct = 0; $ct < $filect; ++$ct )
	{
		print( OUTFILE ",$size%" );
	}
	print( OUTFILE "\">\n" );
	print( OUTFILE "<frame src=\"buildlist.htm\">\n" );
	for ( @g_OutputFiles )
	{
		if ( defined( $g_RunningCompiles{$_} ) )
		{
			my $filename = $_;
			if ( $filename =~ /(\w*\.txt)/ )
			{
				$filename = $1;
			}
			print( OUTFILE "<frame src=\"$filename\">\n" );
		}
	}
	print( OUTFILE "</frameset>\n" );
	print( OUTFILE "</html>\n" );

	close( OUTFILE );
}