array(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
{
	array = [];
	if ( IsDefined( a ) ) array[ 0] = a; else return array;
	if ( IsDefined( b ) ) array[ 1] = b; else return array;
	if ( IsDefined( c ) ) array[ 2] = c; else return array;
	if ( IsDefined( d ) ) array[ 3] = d; else return array;
	if ( IsDefined( e ) ) array[ 4] = e; else return array;
	if ( IsDefined( f ) ) array[ 5] = f; else return array;
	if ( IsDefined( g ) ) array[ 6] = g; else return array;
	if ( IsDefined( h ) ) array[ 7] = h; else return array;
	if ( IsDefined( i ) ) array[ 8] = i; else return array;
	if ( IsDefined( j ) ) array[ 9] = j; else return array;
	if ( IsDefined( k ) ) array[10] = k; else return array;
	if ( IsDefined( l ) ) array[11] = l; else return array;
	if ( IsDefined( m ) ) array[12] = m; else return array;
	if ( IsDefined( n ) ) array[13] = n; else return array;
	if ( IsDefined( o ) ) array[14] = o; else return array;
	if ( IsDefined( p ) ) array[15] = p; else return array;
	if ( IsDefined( q ) ) array[16] = q; else return array;
	if ( IsDefined( r ) ) array[17] = r; else return array;
	if ( IsDefined( s ) ) array[18] = s; else return array;
	if ( IsDefined( t ) ) array[19] = t; else return array;
	if ( IsDefined( u ) ) array[20] = u; else return array;
	if ( IsDefined( v ) ) array[21] = v; else return array;
	if ( IsDefined( w ) ) array[22] = w; else return array;
	if ( IsDefined( x ) ) array[23] = x; else return array;
	if ( IsDefined( y ) ) array[24] = y; else return array;
	if ( IsDefined( z ) ) array[25] = z;
	return array;
}
add_to_array( array, item, allow_dupes )
{
	if( !IsDefined( item ) )
	{
		return array;
	}
	if (!IsDefined(allow_dupes))
	{
		allow_dupes = true;
	}
	if( !IsDefined( array ) )
	{
		array[ 0 ] = item;
	}
	else if (allow_dupes || !is_in_array(array, item))
	{
		array[ array.size ] = item;
	}
	return array;
}
array_add( array, item )
{
	array[ array.size ] = item;
	return array;
}
array_delete( array )
{
	for( i = 0; i < array.size; i++ )
	{
		if(isDefined(array[i]))
		{
			array[ i ] delete();
		}
	}
}
array_randomize( array )
{
	for( i = 0; i < array.size; i++ )
	{
		j = RandomInt( array.size );
		temp = array[ i ];
		array[ i ] = array[ j ];
		array[ j ] = temp;
	}
	return array;
}
array_reverse( array )
{
	array2 = [];
	for( i = array.size - 1; i >= 0; i-- )
	{
		array2[ array2.size ] = array[ i ];
	}
	return array2;
}
array_removeUndefined( array )
{
	newArray = [];
	for( i = 0; i < array.size; i++ )
	{
		if( !IsDefined( array[ i ] ) )
		{
			continue;
		}
		newArray[ newArray.size ] = array[ i ];
	}
	return newArray;
}
array_insert( array, object, index )
{
	if( index == array.size )
	{
		temp = array;
		temp[ temp.size ] = object;
		return temp;
	}
	temp = [];
	offset = 0;
	for( i = 0; i < array.size; i++ )
	{
		if( i == index )
		{
			temp[ i ] = object;
			offset = 1;
		}
		temp[ i + offset ] = array[ i ];
	}
	return temp;
}
array_remove( ents, remover, keepArrayKeys )
{
	newents = [];
	keys = getArrayKeys( ents );
	if(IsDefined(keepArrayKeys))
	{
		for( i = keys.size - 1; i >= 0; i-- )
		{
			if( ents[ keys[ i ] ] != remover )
			{
				newents[ keys[i] ] = ents[ keys[ i ] ];
			}
		}
		return newents;
	}
	for( i = keys.size - 1; i >= 0; i-- )
	{
		if( ents[ keys[ i ] ] != remover )
		{
			newents[ newents.size ] = ents[ keys[ i ] ];
		}
	}
	return newents;
}
array_remove_nokeys( ents, remover )
{
	newents = [];
	for ( i = 0; i < ents.size; i++ )
	{
		if( ents[ i ] != remover )
		{
			newents[ newents.size ] = ents[ i ];
		}
	}
	return newents;
}
array_remove_index( array, index )
{
	newArray = [];
	keys = getArrayKeys( array );
	for( i = ( keys.size - 1 );i >= 0 ; i-- )
	{
		if( keys[ i ] != index )
		{
			newArray[ newArray.size ] = array[ keys[ i ] ];
		}
	}
	return newArray;
}
array_combine( array1, array2 )
{
	if( !array1.size )
	{
		return array2;
	}
	array3 = [];
	keys = GetArrayKeys( array1 );
	for( i = 0;i < keys.size;i++ )
	{
		key = keys[ i ];
		array3[ array3.size ] = array1[ key ];
	}
	keys = GetArrayKeys( array2 );
	for( i = 0;i < keys.size;i++ )
	{
		key = keys[ i ];
		array3[ array3.size ] = array2[ key ];
	}
	return array3;
}
array_merge( array1, array2 )
{
	if( array1.size == 0 )
	{
		return array2;
	}
	if( array2.size == 0 )
	{
		return array1;
	}
	newarray = array1;
	for( i = 0;i < array2.size;i++ )
	{
		foundmatch = false;
		for( j = 0;j < array1.size;j++ )
		{
			if( array2[ i ] == array1[ j ] )
			{
				foundmatch = true;
				break;
			}
		}
		if( foundmatch )
		{
			continue;
		}
		else
		{
			newarray[ newarray.size ] = array2[ i ];
		}
	}
	return newarray;
}
array_exclude( array, arrayExclude )
{
	newarray = array;
	if( IsArray( arrayExclude ) )
	{
		for( i = 0;i < arrayExclude.size;i++ )
		{
			if( is_in_array( array, arrayExclude[ i ] ) )
			{
				newarray = array_remove( newarray, arrayExclude[ i ] );
			}
		}
	}
	else
	{
		if( is_in_array( array, arrayExclude ) )
		{
			newarray = array_remove( newarray, arrayExclude );
		}
	}
	return newarray;
}
array_notify( ents, notifier )
{
	for( i = 0;i < ents.size;i++ )
	{
		ents[ i ] notify( notifier );
	}
}
array_wait(array, msg, timeout)
{
	keys = getarraykeys(array);
	structs = [];
	for (i = 0; i < keys.size; i++)
	{
		key = keys[i];
		structs[ key ] = spawnstruct();
		structs[ key ]._array_wait = true;
		structs[ key ] thread array_waitlogic1( array[ key ], msg, timeout );
	}
	for (i = 0; i < keys.size; i++)
	{
		key = keys[i];
		if( IsDefined( array[ key ] ) && structs[ key ]._array_wait)
		{
			structs[ key ] waittill( "_array_wait" );
		}
	}
}
array_wait_any(array, msg, timeout)
{
	if (array.size == 0)
	{
		return undefined;
	}
	keys = getarraykeys(array);
	structs = [];
	internal_msg = msg + "array_wait";
	for (i = 0; i < keys.size; i++)
	{
		key = keys[i];
		structs[ key ] = spawnstruct();
		structs[ key ]._array_wait = true;
		structs[ key ] thread array_waitlogic3( array[ key ], msg, internal_msg, timeout );
	}
	level waittill(internal_msg, ent);
	return ent;
}
array_waitlogic1( ent, msg, timeout )
{
	self array_waitlogic2( ent, msg, timeout );
	self._array_wait = false;
	self notify( "_array_wait" );
}
array_waitlogic2( ent, msg, timeout )
{
	ent endon( msg );
	ent endon( "death" );
	if( isdefined( timeout ) )
	{
		wait timeout;
	}
	else
	{
		ent waittill( msg );
	}
}
array_waitlogic3(ent, msg, internal_msg, timeout)
{
	if(msg !="death")
	{
		ent endon("death");
	}
	level endon(internal_msg);
	self array_waitlogic2(ent, msg, timeout);
	level notify(internal_msg, ent);
}
array_check_for_dupes( array, single )
{
	for( i = 0; i < array.size; i++ )
	{
		if( array[i] == single )
		{
			return false;
		}
	}
	return true;
}
array_swap( array, index1, index2 )
{
	assertEx( index1 < array.size, "index1 to swap out of range" );
	assertEx( index2 < array.size, "index2 to swap out of range" );
	temp = array[index1];
	array[index1] = array[index2];
	array[index2] = temp;
	return array;
}
array_average( array )
{
	assert( IsArray( array ) );
	assert( array.size > 0 );
	total = 0;
	for ( i = 0; i < array.size; i++ )
	{
		total += array[i];
	}
	return ( total / array.size );
}
array_std_deviation( array, mean )
{
	assert( IsArray( array ) );
	assert( array.size > 0 );
	tmp = [];
	for ( i = 0; i < array.size; i++ )
	{
		tmp[i] = ( array[i] - mean ) * ( array[i] - mean );
	}
	total = 0;
	for ( i = 0; i < tmp.size; i++ )
	{
		total = total + tmp[i];
	}
	return Sqrt( total / array.size );
}
random_normal_distribution( mean, std_deviation, lower_bound, upper_bound )
{
	x1 = 0;
	x2 = 0;
	w = 1;
	y1 = 0;
	while ( w >= 1 )
	{
		x1 = 2 * RandomFloatRange( 0, 1 ) - 1;
		x2 = 2 * RandomFloatRange( 0, 1 ) - 1;
		w = x1 * x1 + x2 * x2;
	}
	w = Sqrt( ( -2.0 * Log( w ) ) / w );
	y1 = x1 * w;
	number = mean + y1 * std_deviation;
	if ( IsDefined( lower_bound ) && number < lower_bound )
	{
		number = lower_bound;
	}
	if ( IsDefined( upper_bound ) && number > upper_bound )
	{
		number = upper_bound;
	}
	return( number );
}
random( array )
{
	keys = GetArrayKeys(array);
	return array[ keys[RandomInt( keys.size )] ];
}
is_in_array( aeCollection, eFindee )
{
	for( i = 0; i < aeCollection.size; i++ )
	{
		if( aeCollection[ i ] == eFindee )
		{
			return( true );
		}
	}
	return( false );
}
vector_compare(vec1, vec2)
{
	return (abs(vec1[0] - vec2[0]) < .001) && (abs(vec1[1] - vec2[1]) < .001) && (abs(vec1[2] - vec2[2]) < .001);
}
vector_scale(vec, scale)
{
	vec = (vec * scale);
	return vec;
}
vector_multiply( vec, vec2 )
{
	vec = (vec * vec2);
	return vec;
}
draw_debug_line(start, end, timer)
{
	for (i=0;i<timer*20;i++)
	{
		line (start, end, (1,1,0.5));
		wait (0.05);
	}
}
waittillend(msg)
{
	self waittillmatch (msg, "end");
}
randomvector(num)
{
	return (RandomFloat(num) - num*0.5, RandomFloat(num) - num*0.5,RandomFloat(num) - num*0.5);
}
angle_dif(oldangle, newangle)
{
	if (oldangle == newangle)
		return 0;
	while (newangle > 360)
	newangle -=360;
	while (newangle < 0)
	newangle +=360;
	while (oldangle > 360)
	oldangle -=360;
	while (oldangle < 0)
	oldangle +=360;
	olddif = undefined;
	newdif = undefined;
	if (newangle > 180)
		newdif = 360 - newangle;
	else
		newdif = newangle;
	if (oldangle > 180)
		olddif = 360 - oldangle;
	else
		olddif = oldangle;
	outerdif = newdif + olddif;
	innerdif = 0;
	if (newangle > oldangle)
		innerdif = newangle - oldangle;
	else
		innerdif = oldangle - newangle;
	if (innerdif < outerdif)
		return innerdif;
	else
		return outerdif;
}
sign( x )
{
	if ( x >= 0 )
		return 1;
	return -1;
}
track(spot_to_track)
{
	if(IsDefined(self.current_target))
	{
		if(spot_to_track == self.current_target)
			return;
	}
	self.current_target = spot_to_track;
}
clear_exception( type )
{
	assert( IsDefined( self.exception[ type ] ) );
	self.exception[ type ] = anim.defaultException;
}
set_exception( type, func )
{
	assert( IsDefined( self.exception[ type ] ) );
	self.exception[ type ] = func;
}
set_all_exceptions( exceptionFunc )
{
	keys = getArrayKeys( self.exception );
	for ( i=0; i < keys.size; i++ )
	{
		self.exception[ keys[ i ] ] = exceptionFunc;
	}
}
cointoss()
{
	return RandomInt( 100 ) >= 50 ;
}
waittill_string( msg, ent )
{
	if ( msg != "death" )
		self endon ("death");
	ent endon ( "die" );
	self waittill ( msg );
	ent notify ( "returned", msg );
}
waittill_multiple( string1, string2, string3, string4, string5 )
{
	self endon ("death");
	ent = SpawnStruct();
	ent.threads = 0;
	if (IsDefined (string1))
	{
		self thread waittill_string (string1, ent);
		ent.threads++;
	}
	if (IsDefined (string2))
	{
		self thread waittill_string (string2, ent);
		ent.threads++;
	}
	if (IsDefined (string3))
	{
		self thread waittill_string (string3, ent);
		ent.threads++;
	}
	if (IsDefined (string4))
	{
		self thread waittill_string (string4, ent);
		ent.threads++;
	}
	if (IsDefined (string5))
	{
		self thread waittill_string (string5, ent);
		ent.threads++;
	}
	while (ent.threads)
	{
		ent waittill ("returned");
		ent.threads--;
	}
	ent notify ("die");
}
waittill_multiple_ents( ent1, string1, ent2, string2, ent3, string3, ent4, string4 )
{
	self endon ("death");
	ent = SpawnStruct();
	ent.threads = 0;
	if ( IsDefined( ent1 ) )
	{
		assert( IsDefined( string1 ) );
		ent1 thread waittill_string( string1, ent );
		ent.threads++;
	}
	if ( IsDefined( ent2 ) )
	{
		assert( IsDefined( string2 ) );
		ent2 thread waittill_string ( string2, ent );
		ent.threads++;
	}
	if ( IsDefined( ent3 ) )
	{
		assert( IsDefined( string3 ) );
		ent3 thread waittill_string ( string3, ent );
		ent.threads++;
	}
	if ( IsDefined( ent4 ) )
	{
		assert( IsDefined( string4 ) );
		ent4 thread waittill_string ( string4, ent );
		ent.threads++;
	}
	while (ent.threads)
	{
		ent waittill ("returned");
		ent.threads--;
	}
	ent notify ("die");
}
waittill_any_return( string1, string2, string3, string4, string5, string6 )
{
	if ((!IsDefined (string1) || string1 != "death") &&
	(!IsDefined (string2) || string2 != "death") &&
	(!IsDefined (string3) || string3 != "death") &&
	(!IsDefined (string4) || string4 != "death") &&
	(!IsDefined (string5) || string5 != "death") &&
	(!IsDefined (string6) || string6 != "death"))
	self endon ("death");
	ent = SpawnStruct();
	if (IsDefined (string1))
		self thread waittill_string (string1, ent);
	if (IsDefined (string2))
		self thread waittill_string (string2, ent);
	if (IsDefined (string3))
		self thread waittill_string (string3, ent);
	if (IsDefined (string4))
		self thread waittill_string (string4, ent);
	if (IsDefined (string5))
		self thread waittill_string (string5, ent);
	if (IsDefined (string6))
		self thread waittill_string (string6, ent);
	ent waittill ("returned", msg);
	ent notify ("die");
	return msg;
}
waittill_any( string1, string2, string3, string4, string5 )
{
	assert( IsDefined( string1 ) );
	if ( IsDefined( string2 ) )
		self endon( string2 );
	if ( IsDefined( string3 ) )
		self endon( string3 );
	if ( IsDefined( string4 ) )
		self endon( string4 );
	if ( IsDefined( string5 ) )
		self endon( string5 );
	self waittill( string1 );
}
waittill_any_ents( ent1, string1, ent2, string2, ent3, string3, ent4, string4, ent5, string5, ent6, string6, ent7, string7 )
{
	assert( IsDefined( ent1 ) );
	assert( IsDefined( string1 ) );
	if ( ( IsDefined( ent2 ) ) && ( IsDefined( string2 ) ) )
		ent2 endon( string2 );
	if ( ( IsDefined( ent3 ) ) && ( IsDefined( string3 ) ) )
		ent3 endon( string3 );
	if ( ( IsDefined( ent4 ) ) && ( IsDefined( string4 ) ) )
		ent4 endon( string4 );
	if ( ( IsDefined( ent5 ) ) && ( IsDefined( string5 ) ) )
		ent5 endon( string5 );
	if ( ( IsDefined( ent6 ) ) && ( IsDefined( string6 ) ) )
		ent6 endon( string6 );
	if ( ( IsDefined( ent7 ) ) && ( IsDefined( string7 ) ) )
		ent7 endon( string7 );
	ent1 waittill( string1 );
}
isFlashed()
{
	if ( !IsDefined( self.flashEndTime ) )
		return false;
	return GetTime() < self.flashEndTime;
}
flag( message )
{
	assertEx( IsDefined( message ), "Tried to check flag but the flag was not defined." );
	assertEx( IsDefined( level.flag[ message ] ), "Tried to check flag " + message + " but the flag was not initialized." );
	if ( !level.flag[ message ] )
		return false;
	return true;
}
flag_init( message, val )
{
	if ( !IsDefined( level.flag ) )
	{
		level.flag = [];
		level.flags_lock = [];
	}
	if ( !IsDefined( level.sp_stat_tracking_func ) )
	{
		level.sp_stat_tracking_func = ::empty_init_func;
	}
	if ( !IsDefined( level.first_frame ) )
	{
		assertEx( !IsDefined( level.flag[ message ] ), "Attempt to reinitialize existing flag: " + message );
	}
	if (is_true(val))
	{
		level.flag[ message ] = true;
	}
	else
	{
		level.flag[ message ] = false;
	}
	if ( !IsDefined( level.trigger_flags ) )
	{
		init_trigger_flags();
		level.trigger_flags[ message ] = [];
	}
	else if ( !IsDefined( level.trigger_flags[ message ] ) )
	{
		level.trigger_flags[ message ] = [];
	}
	if ( issuffix( message, "aa_" ) )
	{
		thread [[ level.sp_stat_tracking_func ]]( message );
	}
}
empty_init_func( empty )
{
}
issuffix( msg, suffix )
{
	if ( suffix.size > msg.size )
		return false;
	for ( i = 0; i < suffix.size; i++ )
	{
		if ( msg[ i ] != suffix[ i ] )
			return false;
	}
	return true;
}
flag_set( message )
{
	level.flag[ message ] = true;
	level notify( message );
	set_trigger_flag_permissions( message );
}
flag_toggle( message )
{
	if (flag(message))
	{
		flag_clear(message);
	}
	else
	{
		flag_set(message);
	}
}
flag_wait( msg )
{
	while( !level.flag[ msg ] )
	level waittill( msg );
}
flag_clear( message )
{
	if (	level.flag[ message ] )
	{
		level.flag[ message ] = false;
		level notify( message );
		set_trigger_flag_permissions( message );
	}
}
flag_waitopen( msg )
{
	while( level.flag[ msg ] )
	level waittill( msg );
}
flag_exists( msg )
{
	if( self == level )
	{
		if( !IsDefined( level.flag ) )
			return false;
		if( IsDefined( level.flag[ msg ] ) )
			return true;
	}
	else
	{
		if( !IsDefined( self.ent_flag ) )
			return false;
		if( IsDefined( self.ent_flag[ msg ] ) )
			return true;
	}
	return false;
}
script_gen_dump_addline( string, signature )
{
	if ( !IsDefined( string ) )
		string = "nowrite";
	if ( !IsDefined( level._loadstarted ) )
	{
		if ( !IsDefined( level.script_gen_dump_preload ) )
			level.script_gen_dump_preload = [];
		struct = SpawnStruct();
		struct.string = string;
		struct.signature = signature;
		level.script_gen_dump_preload[ level.script_gen_dump_preload.size ] = struct;
		return;
	}
	if ( !IsDefined( level.script_gen_dump[ signature ] ) )
		level.script_gen_dump_reasons[ level.script_gen_dump_reasons.size ] = "Added: " + string;
	level.script_gen_dump[ signature ] = string;
	level.script_gen_dump2[ signature ] = string;
}
array_func(entities, func, arg1, arg2, arg3, arg4, arg5)
{
	if (!IsDefined( entities ))
	{
		return;
	}
	if (IsArray(entities))
	{
		if (entities.size)
		{
			keys = GetArrayKeys( entities );
			for (i = 0; i < keys.size; i++)
			{
				single_func(entities[keys[i]], func, arg1, arg2, arg3, arg4, arg5);
			}
		}
	}
	else
	{
		single_func(entities, func, arg1, arg2, arg3, arg4, arg5);
	}
}
single_func(entity, func, arg1, arg2, arg3, arg4, arg5)
{
	if(!IsDefined(entity))
	{
		entity = level;
	}
	if (IsDefined(arg5))
	{
		entity [[ func ]](arg1, arg2, arg3, arg4, arg5);
	}
	else if (IsDefined(arg4))
	{
		entity [[ func ]](arg1, arg2, arg3, arg4);
	}
	else if (IsDefined(arg3))
	{
		entity [[ func ]](arg1, arg2, arg3);
	}
	else if (IsDefined(arg2))
	{
		entity [[ func ]](arg1, arg2);
	}
	else if (IsDefined(arg1))
	{
		entity [[ func ]](arg1);
	}
	else
	{
		entity [[ func ]]();
	}
}
array_thread( entities, func, arg1, arg2, arg3, arg4, arg5 )
{
	AssertEX(IsDefined(entities), "Undefined array passed to common_scripts\utility::array_thread()");
	if (IsArray(entities))
	{
		if (entities.size)
		{
			keys = GetArrayKeys( entities );
			for (i = 0; i < keys.size; i++)
			{
				single_thread(entities[keys[i]], func, arg1, arg2, arg3, arg4, arg5);
			}
		}
	}
	else
	{
		single_thread(entities, func, arg1, arg2, arg3, arg4, arg5);
	}
}
single_thread(entity, func, arg1, arg2, arg3, arg4, arg5)
{
	AssertEX(IsDefined(entity), "Undefined entity passed to common_scripts\utility::single_thread()");
	if (IsDefined(arg5))
	{
		entity thread [[ func ]](arg1, arg2, arg3, arg4, arg5);
	}
	else if (IsDefined(arg4))
	{
		entity thread [[ func ]](arg1, arg2, arg3, arg4);
	}
	else if (IsDefined(arg3))
	{
		entity thread [[ func ]](arg1, arg2, arg3);
	}
	else if (IsDefined(arg2))
	{
		entity thread [[ func ]](arg1, arg2);
	}
	else if (IsDefined(arg1))
	{
		entity thread [[ func ]](arg1);
	}
	else
	{
		entity thread [[ func ]]();
	}
}
remove_undefined_from_array( array )
{
	newarray = [];
	for( i = 0; i < array.size; i ++ )
	{
		if ( !IsDefined( array[ i ] ) )
			continue;
		newarray[ newarray.size ] = array[ i ];
	}
	return newarray;
}
realWait(seconds)
{
	start = GetTime();
	while(GetTime() - start < seconds * 1000)
	{
		wait(.05);
	}
}
trigger_on( name, type )
{
	if ( IsDefined ( name ) && IsDefined( type ) )
	{
		ents = getentarray( name, type );
		array_thread( ents, ::trigger_on_proc );
	}
	else
		self trigger_on_proc();
}
trigger_on_proc()
{
	if ( IsDefined( self.realOrigin ) )
		self.origin = self.realOrigin;
	self.trigger_off = undefined;
}
trigger_off( name, type )
{
	if ( IsDefined ( name ) && IsDefined( type ) )
	{
		ents = getentarray( name, type );
		array_thread( ents, ::trigger_off_proc );
	}
	else
		self trigger_off_proc();
}
trigger_off_proc()
{
	if ( !IsDefined( self.realOrigin ) )
		self.realOrigin = self.origin;
	if ( self.origin == self.realorigin )
		self.origin += ( 0, 0, -10000 );
	self.trigger_off = true;
}
trigger_wait( strName, strKey )
{
	if( !IsDefined( strKey ) )
	{
		strKey = "targetname";
	}
	triggers = GetEntArray( strName, strKey );
	AssertEX( IsDefined(triggers) && triggers.size > 0, "trigger not found: " + strName + " key: " + strKey );
	ent = spawnstruct();
	array_thread( triggers, ::trigger_wait_think, ent );
	ent waittill( "trigger", eOther, trigger_hit );
	level notify( strName, eOther );
	if(IsDefined(trigger_hit))
	{
		trigger_hit.who = eother;
		return trigger_hit;
	}
	else
	{
		return eOther;
	}
}
trigger_wait_think( ent )
{
	self endon( "death" );
	ent endon( "trigger" );
	self waittill( "trigger", eother );
	ent notify( "trigger", eother, self );
}
set_trigger_flag_permissions( msg )
{
	if ( !IsDefined( level.trigger_flags ) )
		return;
	level.trigger_flags[ msg ] = remove_undefined_from_array( level.trigger_flags[ msg ] );
	array_thread( level.trigger_flags[ msg ], ::update_trigger_based_on_flags );
}
update_trigger_based_on_flags()
{
	true_on = true;
	if ( IsDefined( self.script_flag_true ) )
	{
		true_on = false;
		tokens = create_flags_and_return_tokens( self.script_flag_true );
		for( i=0; i < tokens.size; i++ )
		{
			if ( flag( tokens[ i ] ) )
			{
				true_on = true;
				break;
			}
		}
	}
	false_on = true;
	if ( IsDefined( self.script_flag_false ) )
	{
		tokens = create_flags_and_return_tokens( self.script_flag_false );
		for( i=0; i < tokens.size; i++ )
		{
			if ( flag( tokens[ i ] ) )
			{
				false_on = false;
				break;
			}
		}
	}
	[ [ level.trigger_func[ true_on && false_on ] ] ]();
}
create_flags_and_return_tokens( flags )
{
	tokens = strtok( flags, " " );
	for( i=0; i < tokens.size; i++ )
	{
		if ( !IsDefined( level.flag[ tokens[ i ] ] ) )
		{
			flag_init( tokens[ i ] );
		}
	}
	return tokens;
}
init_trigger_flags()
{
	level.trigger_flags = [];
	level.trigger_func[ true ] = ::trigger_on;
	level.trigger_func[ false ] = ::trigger_off;
}
getstruct( name, type )
{
	assertEx( IsDefined( level.struct_class_names ), "Tried to getstruct before the structs were init" );
	if (!IsDefined(type))
	{
		type = "targetname";
	}
	array = level.struct_class_names[ type ][ name ];
	if( !IsDefined( array ) )
	{
		return undefined;
	}
	if( array.size > 1 )
	{
		assertMsg( "getstruct used for more than one struct of type " + type + " called " + name + "." );
		return undefined;
	}
	return array[ 0 ];
}
getstructarray( name, type )
{
	assertEx( IsDefined( level.struct_class_names ), "Tried to getstruct before the structs were init" );
	if (!IsDefined(type))
	{
		type = "targetname";
	}
	array = level.struct_class_names[ type ][ name ];
	if ( !IsDefined( array ) )
		return [];
	return array;
}
struct_class_init()
{
	assertEx( !IsDefined( level.struct_class_names ), "level.struct_class_names is being initialized in the wrong place! It shouldn't be initialized yet." );
	level.struct_class_names = [];
	level.struct_class_names[ "target" ] = [];
	level.struct_class_names[ "targetname" ] = [];
	level.struct_class_names[ "script_noteworthy" ] = [];
	level.struct_class_names[ "script_linkname" ] = [];
	for ( i=0; i < level.struct.size; i++ )
	{
		if ( IsDefined( level.struct[ i ].targetname ) )
		{
			if ( !IsDefined( level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ] ) )
				level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ] = [];
			size = level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ].size;
			level.struct_class_names[ "targetname" ][ level.struct[ i ].targetname ][ size ] = level.struct[ i ];
		}
		if ( IsDefined( level.struct[ i ].target ) )
		{
			if ( !IsDefined( level.struct_class_names[ "target" ][ level.struct[ i ].target ] ) )
				level.struct_class_names[ "target" ][ level.struct[ i ].target ] = [];
			size = level.struct_class_names[ "target" ][ level.struct[ i ].target ].size;
			level.struct_class_names[ "target" ][ level.struct[ i ].target ][ size ] = level.struct[ i ];
		}
		if ( IsDefined( level.struct[ i ].script_noteworthy ) )
		{
			if ( !IsDefined( level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ] ) )
				level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ] = [];
			size = level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ].size;
			level.struct_class_names[ "script_noteworthy" ][ level.struct[ i ].script_noteworthy ][ size ] = level.struct[ i ];
		}
		if ( IsDefined( level.struct[ i ].script_linkname ) )
		{
			assertex( !IsDefined( level.struct_class_names[ "script_linkname" ][ level.struct[ i ].script_linkname ] ), "Two structs have the same linkname" );
			level.struct_class_names[ "script_linkname" ][ level.struct[ i ].script_linkname ][ 0 ] = level.struct[ i ];
		}
	}
	for( i = 0; i < level.struct.size; i++ )
	{
		if( !IsDefined( level.struct[i].target ) )
		{
			continue;
		}
		level.struct[i].targeted = level.struct_class_names["targetname"][level.struct[i].target];
	}
}
fileprint_start( file )
{
}
fileprint_map_start( file )
{
}
fileprint_chk( file , str )
{
}
fileprint_map_header( bInclude_blank_worldspawn )
{
	if ( !IsDefined( bInclude_blank_worldspawn ) )
		bInclude_blank_worldspawn = false;
	assert( IsDefined( level.fileprint ) );
}
fileprint_map_keypairprint( key1, key2 )
{
}
fileprint_map_entity_start()
{
}
fileprint_map_entity_end()
{
}
fileprint_end()
{
}
fileprint_radiant_vec( vector )
{
}
is_mature()
{
	if ( level.onlineGame )
		return true;
	return GetDvarInt( #"cg_mature" );
}
is_german_build()
{
	if( GetDvar( #"language" ) == "german" )
	{
		return true;
	}
	return false;
}
is_gib_restricted_build()
{
	if( GetDvar( #"language" ) == "german" )
	{
		return true;
	}
	if( GetDvar( #"language" ) == "japanese" )
	{
		return true;
	}
	return false;
}
is_true(check)
{
	return(IsDefined(check) && check);
}
is_false(check)
{
	return(IsDefined(check) && !check);
}
has_spawnflag(spawnflags)
{
	if (IsDefined(self.spawnflags))
	{
		return ((self.spawnflags & spawnflags) == spawnflags);
	}
	return false;
}
clamp(val, val_min, val_max)
{
	if (val < val_min)
	{
		val = val_min;
	}
	else if (val > val_max)
	{
		val = val_max;
	}
	return val;
}
linear_map(num, min_a, max_a, min_b, max_b)
{
	return clamp(( (num - min_a) / (max_a - min_a) * (max_b - min_b) + min_b ), min_b, max_b);
}
death_notify_wrapper( attacker, damageType )
{
	level notify( "face", "death", self );
	self notify( "death", attacker, damageType );
}
damage_notify_wrapper( damage, attacker, direction_vec, point, type, modelName, tagName, partName, iDFlags )
{
	level notify( "face", "damage", self );
	self notify( "damage", damage, attacker, direction_vec, point, type, modelName, tagName, partName, iDFlags );
}
explode_notify_wrapper()
{
	level notify( "face", "explode", self );
	self notify( "explode" );
}
alert_notify_wrapper()
{
	level notify( "face", "alert", self );
	self notify( "alert" );
}
shoot_notify_wrapper()
{
	level notify( "face", "shoot", self );
	self notify( "shoot" );
}
melee_notify_wrapper()
{
	level notify( "face", "melee", self );
	self notify( "melee" );
}
isUsabilityEnabled()
{
	return ( !self.disabledUsability );
}
_disableUsability()
{
	self.disabledUsability++;
	self DisableUsability();
}
_enableUsability()
{
	self.disabledUsability--;
	assert( self.disabledUsability >= 0 );
	if ( !self.disabledUsability )
		self EnableUsability();
}
resetUsability()
{
	self.disabledUsability = 0;
	self EnableUsability();
}
_disableWeapon()
{
	self.disabledWeapon++;
	self disableWeapons();
}
_enableWeapon()
{
	self.disabledWeapon--;
	assert( self.disabledWeapon >= 0 );
	if ( !self.disabledWeapon )
		self enableWeapons();
}
isWeaponEnabled()
{
	return ( !self.disabledWeapon );
}