flagsys_shared.csc

Go to the documentation of this file.

#using scripts\shared\util_shared;
 
#insert scripts\shared\shared.gsh;
 
#namespace flagsys;
 
/*
 * flagsys treats undefined flags as "cleared" and won't assert if not initialized
 * Use regular flags by default and only use the flagsys functions when you need to
 * as these are more error prone.
 * 
 * Never use these for level progression.
*/
 
function ‪set( str_flag )
{
    if ( !isdefined( self.flag ) )
    {
        self.flag = [];
    }
    
    self.flag[ str_flag ] = true;
    self notify( str_flag );
}
 
function ‪set_for_time( n_time, str_flag )
{
    self notify( "__flag::set_for_time__" + str_flag );
    self endon( "__flag::set_for_time__" + str_flag );
    
    ‪set( str_flag );
    wait n_time;
    ‪clear( str_flag );
}
 
function ‪clear( str_flag )
{
    if ( isdefined( self.flag ) && ‪IS_TRUE( self.flag[ str_flag ] ) )
    {
        self.flag[ str_flag ] = undefined;
        self notify( str_flag );
    }
}
 
function ‪set_val( str_flag, b_val )
{
    Assert( isdefined( b_val ), "value must be specified in flagsys::set_val" );
    
    if ( b_val )
    {
        ‪set( str_flag );
    }
    else
    {
        ‪clear( str_flag );
    }
}
 
function ‪toggle( str_flag )
{
    ‪set( !‪get( str_flag ) );
}
 
function ‪get( str_flag )
{
    return ( isdefined( self.flag ) && ‪IS_TRUE( self.flag[ str_flag ] ) );
}
 
function ‪wait_till( str_flag )
{
    self endon( "death" );
    
    while ( !‪get( str_flag ) )
    {
        self waittill( str_flag );
    }
}
 
function ‪wait_till_timeout( n_timeout, str_flag )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till( str_flag );
}
 
function ‪wait_till_all( a_flags )
{
    self endon( "death" );
    
    for ( i = 0; i < a_flags.size; i++ )
    {
        str_flag = a_flags[i];
        
        if ( !‪get( str_flag ) )
        {
            self waittill( str_flag );
            i = -1;
        }
    }
}
 
function ‪wait_till_all_timeout( n_timeout, a_flags )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till_all( a_flags );
}
 
function ‪wait_till_any( a_flags )
{
    self endon( "death" );
    
    foreach ( flag in a_flags )
    {
        if ( ‪get( flag ) )
        {
            return flag;
        }
    }
 
    ‪util::waittill_any_array( a_flags );
}
 
function ‪wait_till_any_timeout( n_timeout, a_flags )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till_any( a_flags );
}
 
function ‪wait_till_clear( str_flag )
{
    self endon( "death" );
    
    while ( ‪get( str_flag ) )
    {
        self waittill( str_flag );
    }
}
 
function ‪wait_till_clear_timeout( n_timeout, str_flag )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till_clear( str_flag );
}
 
function ‪wait_till_clear_all( a_flags )
{
    self endon( "death" );
    
    for ( i = 0; i < a_flags.size; i++ )
    {
        str_flag = a_flags[i];
        
        if ( ‪get( str_flag ) )
        {
            self waittill( str_flag );
            i = -1;
        }
    }
}
 
function ‪wait_till_clear_all_timeout( n_timeout, a_flags )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till_clear_all( a_flags );
}
 
function ‪wait_till_clear_any( a_flags )
{
    self endon( "death" );
    
    while ( true )
    {
        foreach ( flag in a_flags )
        {
            if ( !‪get( flag ) )
            {
                return flag;
            }
        }
 
        ‪util::waittill_any_array( a_flags );
    }
}
 
function ‪wait_till_clear_any_timeout( n_timeout, a_flags )
{
    ‪TIMEOUT( n_timeout );
    ‪wait_till_clear_any( a_flags );
}
 
function delete( str_flag )
{
    ‪clear( str_flag );
}