flag_shared.csc

Go to the documentation of this file.

#using scripts\shared\util_shared;
 
#insert scripts\shared\shared.gsh;
 
#namespace flag;
 
function ‪init( str_flag, b_val = false, b_is_trigger = false )
{
    ‪DEFAULT( self.flag, [] );
    
    /#
    
    if ( !isdefined( level.first_frame ) )
    {
        Assert( !isdefined( self.flag[ str_flag ] ), "Attempt to reinitialize existing flag '" + str_flag + "' on entity." );
    }
    
    #/
 
    self.flag[ str_flag ] = b_val;
}
 
function ‪exists( str_flag )
{
    return ( isdefined( self.flag ) && isdefined( self.flag[ str_flag ] ) );
}
 
function ‪set( str_flag )
{
/#
    Assert( ‪exists( str_flag ), "Attempting to set a flag '" + str_flag + "' that's not initialized." );
#/
 
    self.flag[ str_flag ] = true;
    self notify( str_flag );
}
 
function ‪delay_set( n_delay, str_flag, str_cancel )
{
    self thread ‪_delay_set( n_delay, str_flag, str_cancel );
}
 
function ‪_delay_set( n_delay, str_flag, str_cancel )
{
    if ( isdefined( str_cancel ) )
    {
        self endon( str_cancel );
    }
    
    self endon( "death" );
    
    wait n_delay;
    
    ‪set( 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 )
{
    Assert( ‪exists( str_flag ), "Attempting to clear a flag '" + str_flag + "' that's not initialized." );
 
    if ( self.flag[ str_flag ] )
    {
        self.flag[ str_flag ] = false;
        self notify( str_flag );
    }
}
 
function ‪toggle( str_flag )
{
    if ( ‪get( str_flag ) )
    {
        ‪clear( str_flag );
    }
    else
    {
        ‪set( str_flag );
    }
}
 
function ‪get( str_flag )
{
    Assert( ‪exists( str_flag ), "Tried to get flag '" + str_flag + "' that's not initialized." );
    
    return 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 )
{
    if ( isdefined( self.flag[ str_flag ] ) )
    {
        self.flag[ str_flag ] = undefined;
    }
    else
    {
        /# PrintLn( "flag_delete() called on flag that does not exist: " + str_flag ); #/
    }
}