flag_shared.gsc

Go to the documentation of this file.

#using scripts\shared\trigger_shared;
#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;
    
    if ( b_is_trigger ) // TODO: this block should probably not be here, instead make sure it's actually needed and maybe move into the "trigger" namespace.
    {
        if ( !isdefined( level.trigger_flags ) )
        {
            ‪trigger::init_flags();
            level.trigger_flags[ str_flag ] = [];
        }
        else if ( !isdefined( level.trigger_flags[ str_flag ] ) )
        {
            level.trigger_flags[ str_flag ] = [];
        }
    }
}
 
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 );
    
    ‪trigger::set_flag_permissions( 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_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 ‪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 );
        ‪trigger::set_flag_permissions( 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 get_any( &‪array )
{
    foreach ( str_flag in ‪array )
    {
        if ( ‪get( str_flag ) )
        {
            return true;
        }
    }
    
    return false;
}
 
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 ); #/
    }
}
 
function ‪script_flag_wait()
{
    if ( isdefined( self.‪script_flag_wait ) )
    {
        self ‪wait_till( self.‪script_flag_wait );
        return true;
    }
    
    return false;
}