doors_shared.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\hud_util_shared;
#using scripts\shared\system_shared;
#using scripts\shared\flag_shared;
 
#insert scripts\shared\shared.gsh;
 
#namespace doors;
 
#define HACKING_PLAYER_WEAPON "pda_hack"
#define DOOR_CLEARANCE_TIMER    0.3
 
class ‪cDoor
{
    var ‪m_s_bundle;                         // Bundle with info regarding the door.
    var ‪m_str_targetname;
    var ‪m_str_target;
    var ‪m_str_script_flag;
    
    var ‪m_e_door;                           // Door Ent
 
    var ‪m_e_trigger;                        // Trigger Ent
    var ‪m_e_trigger_player;                 // Player who opens the door
    var ‪m_n_trigger_height;
    
    var ‪m_n_hack_pct;                       // percentage of the current hack completed.
    var ‪m_b_hacking;                        // true if hacking is currently taking place.
    
    var ‪m_e_hint_trigger;
 
    var ‪m_v_open_pos;                       // Door open and close positions (for slide doors)
    var ‪m_v_close_pos;
    
    var ‪m_n_door_connect_paths;             // Does door connect paths?
 
    var ‪m_b_is_open;                        // Is the door open?
 
    // Overrides that can be set in script
    var ‪m_override_swing_angle;
 
    var ‪m_door_open_delay_time;             // Ability to delat the door opening
    
    ‪constructor()
    {
        ‪m_n_trigger_height = 80;            // Default trigger height
        ‪m_override_swing_angle = undefined;
        ‪m_door_open_delay_time = 0;
        ‪m_e_trigger_player = undefined;
    }
 
    ‪destructor()
    {
        if( IsDefined(‪m_e_trigger) )
        {
            ‪m_e_trigger delete();
        }
    }
 
    function ‪init_xmodel( str_xmodel, ‪connect_paths, v_origin, v_angles )
    {
        if( !IsDefined(str_xmodel) )
        {
            str_xmodel = "script_origin";
            //ASSERTMSG( "No model found in Door Script Bundle" );
            //return;
        }
 
        ‪m_e_door = ‪spawn( "script_model", v_origin, 1 );
        ‪m_e_door setModel( str_xmodel );
        ‪m_e_door.angles = v_angles;
        
        if(‪connect_paths)
        {
            ‪m_e_door DisconnectPaths();
        }           
    }
    
    function ‪get_hack_pos()
    {
        v_trigger_offset = ‪m_s_bundle.v_trigger_offset;
    
        v_pos = ‪calculate_offset_position( ‪m_e_door.origin, ‪m_e_door.angles, v_trigger_offset );
        v_pos = ( v_pos[0], v_pos[1], v_pos[2]+50 );        // Its a look at trigger, so move the base of the trigger off the ground
        
        if ( IsDefined( ‪m_str_target ) )
        {
            ‪e_target = GetEnt( ‪m_str_target, "targetname" );
            if ( IsDefined( ‪e_target ) )
            {
                return ‪e_target.origin;
            }
        }
        
        return v_pos;
    }
    
    function ‪get_hack_angles()
    {
        v_angles = ‪m_e_door.angles;
        
        if ( IsDefined( ‪m_str_target ) )
        {
            ‪e_target = GetEnt( ‪m_str_target, "targetname" );
            if ( IsDefined( ‪e_target ) )
            {
                return ‪e_target.angles;
            }
        }
        
        return v_angles;
    }
    
    function ‪init_hint_trigger()
    {
        // Only certain types of doors have this trigger.
        //
        if ( ‪m_s_bundle.door_unlock_method == "default" && !‪IS_TRUE(‪m_s_bundle.door_trigger_at_target) )
        {
            return;
        }
        
        // Keys don't use a hint trigger.
        //
        if ( ‪m_s_bundle.door_unlock_method == "key" )
        {
            return;
        }
        
        v_offset = ‪m_s_bundle.v_trigger_offset;
        n_radius = ‪m_s_bundle.door_trigger_radius;
        
        v_pos = ‪calculate_offset_position( ‪m_e_door.origin, ‪m_e_door.angles, v_offset );
        
        // Its a look at trigger, so move the base of the trigger off the ground
        v_pos = ( v_pos[0], v_pos[1], v_pos[2]+50 );
 
        e_trig = ‪spawn( "trigger_radius_use", v_pos, 0, n_radius, ‪m_n_trigger_height );
        e_trig TriggerIgnoreTeam();
 
        e_trig SetVisibleToAll();
        e_trig SetTeamForTrigger( "none" );
        e_trig UseTriggerRequireLookAt();
 
        e_trig SetCursorHint( "HINT_NOICON" );
        
        ‪m_e_hint_trigger = e_trig;
        
        thread ‪process_hint_trigger_message();
    }
 
    function ‪lock()
    {
        self ‪flag::set( "locked" );
        ‪update_use_message();
    }
    
    function ‪unlock()
    {
        self ‪flag::clear( "locked" );
    }
 
    function ‪delete_door()
    {
        ‪m_e_door delete();
        ‪m_e_door = undefined;
 
        if( IsDefined(‪m_e_trigger) )
        {
            ‪m_e_trigger delete();
            ‪m_e_trigger = undefined;
        }
    }
    
    function ‪open()
    {
        self ‪flag::set( "open" );
    }
    
    function ‪close_internal()
    {
        self ‪flag::clear( "open" );
        ‪set_script_flags( false );
        
        self ‪flag::set( "animating" );
        
        if( ‪IS_TRUE( ‪m_s_bundle.b_loop_sound ) )
        {
            ‪m_e_door playsound( ‪m_s_bundle.door_start_sound );
            sndEnt = ‪spawn( "script_origin", ‪m_e_door.origin );
            sndEnt linkto( ‪m_e_door );
            sndEnt playloopsound( ‪m_s_bundle.door_loop_sound, 1 );
        }
        else if ( IsDefined(‪m_s_bundle.door_stop_sound) && ‪m_s_bundle.door_stop_sound != "" )
        {
            ‪m_e_door playsound( ‪m_s_bundle.door_stop_sound );
        }
 
        // Close Door
        if( ‪m_s_bundle.door_open_method == "slide" )
        {
            ‪m_e_door MoveTo( ‪m_v_close_pos, ‪m_s_bundle.door_open_time );
        }
        else if( ‪m_s_bundle.door_open_method == "swing" )
        {
            angle = ‪GetSwingAngle();
            v_angle = ( ‪m_e_door.angles[0], ‪m_e_door.angles[1]-angle, ‪m_e_door.angles[2] );
            ‪m_e_door RotateTo( v_angle, ‪m_s_bundle.door_open_time );
        }
        // TODO: Animated - Closing
 
        wait( ‪m_s_bundle.door_open_time );
 
        if( ‪IS_TRUE(‪m_n_door_connect_paths) )
        {
            ‪m_e_door DisconnectPaths();
        }
        
        if( ‪IS_TRUE( ‪m_s_bundle.b_loop_sound ) )
        {
            sndEnt delete();
            ‪m_e_door playsound( ‪m_s_bundle.door_stop_sound );
        }
        
        ‪flag::clear( "animating" );
        
        ‪update_use_message();
    }
    
    function ‪close()
    {
        self ‪flag::clear( "open" );
    }
    
    function ‪open_internal()
    {       
        self ‪flag::set( "animating" );
 
        ‪m_e_door notify( "door_opening" );
        
        // Play the opening sound.
        if ( IsDefined(‪m_s_bundle.door_start_sound) && ‪m_s_bundle.door_start_sound != "" )
        {
            ‪m_e_door playsound( ‪m_s_bundle.door_start_sound );
        }
        
        // Play the looping door "open" sound.
        if( ‪IS_TRUE( ‪m_s_bundle.b_loop_sound ) )
        {
            sndEnt = ‪spawn( "script_origin", ‪m_e_door.origin );
            sndEnt linkto( ‪m_e_door );
            sndEnt playloopsound( ‪m_s_bundle.door_loop_sound, 1 );
        }
 
        if( ‪m_s_bundle.door_open_method == "slide" )
        {
            ‪m_e_door MoveTo( ‪m_v_open_pos, ‪m_s_bundle.door_open_time );
        }
        else if( ‪m_s_bundle.door_open_method == "swing" )
        {
            angle = ‪GetSwingAngle();
            v_angle = ( ‪m_e_door.angles[0], ‪m_e_door.angles[1]+angle, ‪m_e_door.angles[2] );
            ‪m_e_door RotateTo( v_angle, ‪m_s_bundle.door_open_time );
        }
        
        if( ‪IS_TRUE(‪m_n_door_connect_paths) )
        {
            ‪m_e_door ConnectPaths();
        }
 
        wait( ‪m_s_bundle.door_open_time );
        
        if( ‪IS_TRUE( ‪m_s_bundle.b_loop_sound ) )
        {
            sndEnt delete();
        }
        
        if ( IsDefined(‪m_s_bundle.door_stop_sound) && ‪m_s_bundle.door_stop_sound != "" )
        {
            ‪m_e_door playsound( ‪m_s_bundle.door_stop_sound );
        }
        
        ‪flag::clear( "animating" );
        ‪set_script_flags( true );
        
        ‪update_use_message();
    }
    
    function ‪update_use_message()
    {       
        if ( !‪IS_TRUE( ‪m_s_bundle.door_use_trigger ) )
        {
            return;
        }
        
        if ( self ‪flag::get("open") )
        {
            if ( !‪IS_TRUE(‪m_s_bundle.door_closes) )
            {
//              m_e_trigger SetHintString( "" );
            } 
            else 
            {
//              m_e_trigger SetHintString( "Hold ^3[{+activate}]^7 to close door" );
            }
        } 
        else 
        {
            // TODO - Localize the string, &"HINT_DOOR"
            if( IsDefined(‪m_s_bundle.door_open_message) && (‪m_s_bundle.door_open_message != "") )
            {
//              m_e_trigger SetHintString( m_s_bundle.door_open_message );
            }
            else if (‪IS_TRUE(‪m_s_bundle.door_use_hold))
            {
//              m_e_trigger SetHintString( "Hold ^3[{+activate}]^7 to hold door open" );
            }
            else if (‪m_s_bundle.door_unlock_method == "key") 
            {
//              m_e_trigger SetHintString( "Hold ^3[{+activate}]^7 to open door [cost: 1 key]" );
            }
            else if( self ‪flag::get( "locked" ) )
            {
//              m_e_trigger SetHintString( &"SCRIPT_DOOR_LOCKED" );
            }
            else
            {
//              m_e_trigger SetHintString( "Hold ^3[{+activate}]^7 to open door" );
            }
        }
    }
    
    function ‪run_lock_fx()
    {       
        if ( !IsDefined(‪m_s_bundle.door_locked_fx) && !IsDefined(‪m_s_bundle.door_unlocked_fx) )
        {
            return;
        }
        
        e_fx = undefined;
        v_pos = ‪get_hack_pos();
        v_angles = ‪get_hack_angles();
        
        while ( true )
        {
            self ‪flag::wait_till( "locked" );
            
            if ( isdefined( e_fx ) )
            {
                e_fx delete();
                e_fx = undefined;
            }
            
            if ( IsDefined(‪m_s_bundle.door_locked_fx) )
            {
                e_fx = ‪Spawn( "script_model", v_pos );
                e_fx SetModel( "tag_origin" );
                e_fx.angles = v_angles;
                PlayFXOnTag( ‪m_s_bundle.door_locked_fx, e_fx, "tag_origin" );
            }
            
            self ‪flag::wait_till_clear( "locked" );
            
            if ( isdefined( e_fx ) )
            {
                e_fx delete();
                e_fx = undefined;
            }
            
            if ( IsDefined(‪m_s_bundle.door_unlocked_fx) )
            {
                e_fx = ‪Spawn( "script_model", v_pos );
                e_fx SetModel( "tag_origin" );
                e_fx.angles = v_angles;
                PlayFXOnTag( ‪m_s_bundle.door_unlocked_fx, e_fx, "tag_origin" );
            }
        }
    }
    
    function ‪process_hint_trigger_message()
    {
        str_hint = "";
        if ( ‪IS_TRUE( ‪m_s_bundle.door_trigger_at_target ) )
        {
            str_hint = "This door is controlled elsewhere";
        } 
        else if (‪m_s_bundle.door_unlock_method == "hack") 
        {
            str_hint = "This door is electronically locked";
        }
        
        while ( true )
        {
            ‪m_e_hint_trigger SetHintString(str_hint);
            
            if ( ‪IS_TRUE( ‪m_s_bundle.door_trigger_at_target ) )
            {
                self ‪flag::wait_till( "open" );
            } 
            else 
            {
                self ‪flag::wait_till_clear( "locked" );
            }
            
            ‪m_e_hint_trigger SetHintString("");
            
            if ( ‪IS_TRUE( ‪m_s_bundle.door_trigger_at_target ) )
            {
                self ‪flag::wait_till_clear( "open" );
            } 
            else 
            {
                self ‪flag::wait_till( "locked" );
            }
        }
    }
 
    function ‪init_trigger( v_offset, n_radius )
    {       
        v_pos = ‪calculate_offset_position( ‪m_e_door.origin, ‪m_e_door.angles, v_offset );
        
        // Its a look at trigger, so move the base of the trigger off the ground
        v_pos = ( v_pos[0], v_pos[1], v_pos[2]+50 );
        
        if ( ‪IS_TRUE( ‪m_s_bundle.door_trigger_at_target ) )
        {
            ‪e_target = GetEnt( ‪m_str_target, "targetname" );
            if ( IsDefined( ‪e_target ) )
            {
                v_pos = ‪e_target.origin;
            }
        }
 
        // Does the trigger need a USE prompt?      
        if( ‪IS_TRUE(‪m_s_bundle.door_use_trigger) )
        {
            ‪m_e_trigger = ‪spawn( "trigger_radius_use", v_pos, 0, n_radius, ‪m_n_trigger_height );
            ‪m_e_trigger TriggerIgnoreTeam();
 
            ‪m_e_trigger SetVisibleToAll();
            ‪m_e_trigger SetTeamForTrigger( "none" );
            ‪m_e_trigger UseTriggerRequireLookAt();
 
            ‪m_e_trigger SetCursorHint( "HINT_NOICON" );
        }
        else
        {
            ‪m_e_trigger = ‪spawn( "trigger_radius", v_pos, 0, n_radius, ‪m_n_trigger_height );
        }
    }
 
    function ‪set_script_flags( b_set )
    {
        if ( IsDefined( ‪m_str_script_flag ) )
        {
            a_flags = StrTok(‪m_str_script_flag, ",");
            foreach( str_flag in a_flags )
            {
                if ( b_set )
                {
                    level ‪flag::set(str_flag);
                } 
                else 
                {
                    level ‪flag::clear(str_flag);
                }
            }
        }
    }
    
    function ‪init_movement( n_slide_up, n_slide_amount )
    {
        if( ‪m_s_bundle.door_open_method == "slide" )
        {
            // Setup the open and close offsets
            if( n_slide_up )
            {
                v_offset = ( 0, 0, n_slide_amount );
            }
            else
            {
                v_offset = ( n_slide_amount, 0, 0 );
            }
 
            ‪m_v_open_pos = ‪calculate_offset_position( ‪m_e_door.origin, ‪m_e_door.angles, v_offset );
            ‪m_v_close_pos = ‪m_e_door.origin;
        }
    }
 
    function ‪set_door_paths( n_door_connect_paths )
    {
        ‪m_n_door_connect_paths = n_door_connect_paths;
    }
 
    // TODO (Slone): There's no reason to pass these variables in.  The info is available via the bundle.
    //
    function ‪calculate_offset_position( v_origin, v_angles, v_offset )
    {
        v_pos = v_origin;
 
        if( v_offset[0] )
        {
            v_side = anglestoforward( v_angles );       // X Axis = Forward
            v_pos = v_pos + (v_offset[0] * v_side);
        }
        if( v_offset[1] )
        {
            v_dir = anglestoright( v_angles );
            v_pos = v_pos + (v_offset[1] * v_dir);
        }
        if( v_offset[2] )
        {
            v_up = anglestoup( v_angles );
            v_pos = v_pos + (v_offset[2] * v_up);
        }
        
        return( v_pos );
    }
 
    // Override the doors swing angle
    function ‪set_swing_angle( angle )
    {
        ‪m_override_swing_angle = angle;
    }
 
    function ‪GetSwingAngle()
    {
        if( IsDefined(‪m_override_swing_angle) )
        {
            angle = ‪m_override_swing_angle;
        }
        else
        {
            angle = ‪m_s_bundle.door_swing_angle;
        }
        return( angle );
    }
 
    function ‪SetDoorOpenDelay( delay_time )
    {
        ‪m_door_open_delay_time = delay_time;
    }
}
 
 
 
‪REGISTER_SYSTEM( "doors", &‪__init__, undefined )
 
function ‪__init__()
{   
    a_doors = ‪struct::get_array( "scriptbundle_doors", "classname" );       // "_doors" auto generates from the TYPE field in the bundle
    foreach ( s_instance in a_doors )
    {
        c_door = s_instance ‪init();
        if (isdefined(c_door) )
        {
            s_instance.c_door = c_door;
        }
    }
}
 
 
//*****************************************************************************
//*****************************************************************************
 
// self = door bundle instance (The Script Script Instance, holds position, angles, targetname etc..)
function ‪init()
{   
    if( !IsDefined(self.angles) )
    {   
        self.angles = (0, 0 ,0 );
    }
        
    s_door_bundle = level.scriptbundles[ "doors" ][ self.scriptbundlename ];
        
    return ‪setup_door_scriptbundle( s_door_bundle, self );
}
 
 
//*****************************************************************************
//*****************************************************************************
 
function ‪setup_door_scriptbundle( s_door_bundle, s_door_instance )
{
    c_door = new ‪cDoor();
    
    c_door ‪flag::init( "locked", false );
    c_door ‪flag::init( "open", false );
    c_door ‪flag::init( "animating", false );
 
    c_door.m_s_bundle = s_door_bundle;
    c_door.m_str_targetname = s_door_instance.targetname;
    c_door.m_str_target = s_door_instance.target;
    c_door.m_str_script_flag = s_door_instance.script_flag;
 
    //*************************
    // Get the Door Bundle Data
    //*************************
    
    if ( c_door.m_s_bundle.door_unlock_method == "key" )
    {       
        if ( IsDefined( c_door.m_s_bundle.door_key_model ) )
        {
            level.door_key_model = c_door.m_s_bundle.door_key_model;
        }
        
        if ( IsDefined( c_door.m_s_bundle.door_key_icon ) )
        {
            level.door_key_icon = c_door.m_s_bundle.door_key_icon;
        }
        
        if ( IsDefined( c_door.m_s_bundle.door_key_fx ) )
        {
            level.door_key_fx = c_door.m_s_bundle.door_key_fx;
        }
    }
    
    if ( c_door.m_s_bundle.door_unlock_method == "hack" && !‪IS_TRUE(level.door_hack_precached) )
    {
        level.door_hack_precached = true;
    }
 
    str_door_xmodel = c_door.m_s_bundle.model;
    
    // Trigger Offset
    if( IsDefined(c_door.m_s_bundle.door_triggerOffsetX) )
    {
        n_xOffset = c_door.m_s_bundle.door_triggerOffsetX;
    }
    else
    {
        n_xOffset = 0;
    }
    if( IsDefined(c_door.m_s_bundle.door_triggerOffsetY) )
    {
        n_yOffset = c_door.m_s_bundle.door_triggerOffsetY;
    }
    else
    {
        n_yOffset = 0;
    }
    if( IsDefined(c_door.m_s_bundle.door_triggerOffsetZ) )
    {
        n_zOffset = c_door.m_s_bundle.door_triggerOffsetZ;
    }
    else
    {
        n_zOffset = 0;
    }
 
    v_trigger_offset = ( n_xOffset, n_yOffset, n_zOffset );
    c_door.m_s_bundle.v_trigger_offset = v_trigger_offset;          // Store this for later use.
 
    n_trigger_radius = c_door.m_s_bundle.door_trigger_radius;
    if( ‪IS_TRUE(c_door.m_s_bundle.door_slide_horizontal) )
    {
        n_slide_up = 0;
    }
    else
    {
        n_slide_up = 1;
    }
    n_open_time = c_door.m_s_bundle.door_open_time;
    n_slide_amount = c_door.m_s_bundle.door_slide_open_units;
 
    if( !IsDefined(c_door.m_s_bundle.door_swing_angle) )
    {
        c_door.m_s_bundle.door_swing_angle = 0;
    }
 
    if( ‪IS_TRUE(c_door.m_s_bundle.door_closes) )
    {
        n_door_closes = 1;
    }
    else
    {
        n_door_closes = 0;
    }
 
    if( ‪IS_TRUE(c_door.m_s_bundle.door_connect_paths) )
    {
        n_door_connect_paths = 1;
    }
    else
    {
        n_door_connect_paths = 0;
    }
    
    if ( ‪IS_TRUE( c_door.m_s_bundle.door_start_open ) )
    {
        c_door ‪flag::set( "open" );
    }
    
    if ( IsDefined( c_door.m_str_script_flag ) )
    {
        a_flags = StrTok(c_door.m_str_script_flag, ",");
        foreach( str_flag in a_flags )
        {
            level ‪flag::init( str_flag );
        }
    }
 
    // Setup the Door
    [[ c_door ]]->init_xmodel( str_door_xmodel, n_door_connect_paths, s_door_instance.origin, s_door_instance.angles);
 
    // Setup the trigger - Just using radius triggers for now
    [[ c_door ]]->init_trigger( v_trigger_offset, n_trigger_radius, c_door.m_s_bundle );
    
    // Initialize the trigger to give hints regarding how to open the door.
    //
    [[ c_door ]]->init_hint_trigger();
    
    // Initialize any fx associated with this door being (or not being) locked.
    thread [[ c_door ]]->run_lock_fx();
    
    // Setup door movement
    [[ c_door ]]->init_movement( n_slide_up, n_slide_amount );
 
    if ( !IsDefined(c_door.m_s_bundle.door_open_time) )
    {
        c_door.m_s_bundle.door_open_time = 0.4;
    }
 
    [[ c_door ]]->set_door_paths( n_door_connect_paths );
    
    // Setup door sounds
    c_door.m_s_bundle.b_loop_sound = IsDefined( c_door.m_s_bundle.door_loop_sound ) && c_door.m_s_bundle.door_loop_sound != "";
 
    // Door update routine
    level thread ‪door_update( c_door );
    
    return c_door;
}
 
 
//*****************************************************************************
//*****************************************************************************
 
function ‪door_open_update( c_door )
{
    str_unlock_method = "default";
    if ( IsDefined( c_door.m_s_bundle.door_unlock_method ) )
    {
        str_unlock_method = c_door.m_s_bundle.door_unlock_method;
    }
    
    b_auto_close = (‪IS_TRUE(c_door.m_s_bundle.door_closes) && !‪IS_TRUE(c_door.m_s_bundle.door_use_trigger));
    b_hold_open = ‪IS_TRUE(c_door.m_s_bundle.door_use_hold);
    b_manual_close = ‪IS_TRUE(c_door.m_s_bundle.door_use_trigger) && ‪IS_TRUE(c_door.m_s_bundle.door_closes);
    
    // Wait for the player to hit the door trigger, unless it's already set to be open.
    while ( true )
    {
        c_door.m_e_trigger waittill( "trigger", e_who );
        c_door.m_e_trigger_player = e_who;
 
        if ( !(c_door ‪flag::get( "open" )) )
        {
            if ( !(c_door ‪flag::get( "locked" ) ))
            {
                if ( b_hold_open || b_auto_close )
                {
                    [[c_door]]->open();
                    
                    if ( b_hold_open )
                    {
                        e_who ‪player_freeze_in_place( true );
                        e_who DisableWeapons();
                        e_who DisableOffhandWeapons();
                    }
                    
                    ‪door_wait_until_clear( c_door, e_who );
                    [[c_door]]->close();
                    
                    if ( b_hold_open )
                    {
                        ‪WAIT_SERVER_FRAME;
                        c_door ‪flag::wait_till_clear( "animating" );
                        e_who ‪player_freeze_in_place( false );
                        e_who EnableWeapons();
                        e_who EnableOffhandWeapons();
                    }
                    
                } else if ( str_unlock_method == "key" )
                {
                    if ( e_who ‪player_has_key( "door" ) )
                    {
                        e_who ‪player_take_key( "door" );
                        [[c_door]]->open();
                    } else {
                        IPrintLnBold( "You need a key." );
                    }
                } else {
                    [[c_door]]->open();
                }
            }
        } else if ( b_manual_close )
        {
            [[c_door]]->close();
        }
    }
}
 
function ‪door_update( c_door )
{
    str_unlock_method = "default";
    if ( IsDefined( c_door.m_s_bundle.door_unlock_method ) )
    {
        str_unlock_method = c_door.m_s_bundle.door_unlock_method;
    }
    
    // "Key" doors aren't *really* unlocked.
    if ( ‪IS_TRUE( c_door.m_s_bundle.door_locked ) && str_unlock_method != "key" )
    {
        c_door ‪flag::set( "locked" );
        
        if (IsDefined(c_door.m_str_targetname))
        {
            thread ‪door_update_lock_scripted( c_door );
        }
    }
    
    thread ‪door_open_update( c_door );
 
    [[c_door]]->update_use_message();
 
    while( 1 )
    {       
        // Wait for the door to unlock.
        //
        if( c_door ‪flag::get( "locked" ) )
        {
            c_door ‪flag::wait_till_clear( "locked" );
        }
        
        c_door ‪flag::wait_till( "open" );
 
        // Check for a delay opening the door
        if( c_door.m_door_open_delay_time > 0 )
        {
            c_door.m_e_door notify( "door_waiting_to_open", c_door.m_e_trigger_player );
            wait( c_door.m_door_open_delay_time );
        }
 
        [[c_door]]->open_internal();
        
        c_door ‪flag::wait_till_clear( "open" );
        
        [[c_door]]->close_internal();
        
        // If the door stays open, tidyup and exit
        if( !‪IS_TRUE(c_door.m_s_bundle.door_closes) )
        {
            break;
        }
 
        ‪WAIT_SERVER_FRAME;
    }
 
    // Cleanup
    c_door.m_e_trigger delete();
    c_door.m_e_trigger = undefined;
}
 
function ‪door_update_lock_scripted( c_door )
{
    door_str = c_door.m_str_targetname;
    c_door.m_e_trigger.targetname = (door_str + "_trig");
    
    while ( true )
    {
        c_door.m_e_trigger waittill( "unlocked" );
        [[c_door]]->unlock();
    }
}
 
function ‪player_freeze_in_place( b_do_freeze )
{
    if ( !b_do_freeze )
    {
        if ( IsDefined(self.freeze_origin) )
        {
            self Unlink();
            self.freeze_origin Delete();
            self.freeze_origin = undefined;
        }
    } else {
        if ( !IsDefined(self.freeze_origin) )
        {
            self.freeze_origin = ‪Spawn( "script_model", self.origin );
            self.freeze_origin SetModel( "tag_origin" );
            self.freeze_origin.angles = self.angles;
            self PlayerLinkToDelta(self.freeze_origin, "tag_origin", 1.0, 45.0, 45.0, 45.0, 45.0 );
        }
    }
}
 
//*****************************************************************************
// Waits for a trigger to be clear of all ENTS for X time
//*****************************************************************************
 
// self = trigger
function ‪trigger_wait_until_clear( c_door )
{
    self endon( "death" );
 
    last_trigger_time = gettime();
    self.ents_in_trigger = true;
 
    str_kill_trigger_notify = "trigger_now_clear";
    self thread ‪trigger_check_for_ents_touching( str_kill_trigger_notify );
 
    while( 1 )
    {
        time = gettime();
 
        // If there are still ents in the trigger, reset the time counter
        if( self.ents_in_trigger == true )
        {
            self.ents_in_trigger = false;
            last_trigger_time = time;
        }
 
        // Have we waited long enough for all ents to the       
        dt = ( time - last_trigger_time ) / 1000;
        if( dt >= ‪DOOR_CLEARANCE_TIMER )
        {
            break;
        }
 
        ‪WAIT_SERVER_FRAME;
    }
 
    self notify( str_kill_trigger_notify );
}
 
// Waits until the user releases the X button, or until they leave the area.
//
// self == interaction trigger
//
function ‪door_wait_until_user_release( c_door, e_triggerer, str_kill_on_door_notify )
{
    if ( IsDefined( str_kill_on_door_notify ) )
    {
        c_door endon( str_kill_on_door_notify );
    }
    
    // Brief grace period.
    wait 0.25;
    
    max_dist_sq = c_door.m_s_bundle.door_trigger_radius * c_door.m_s_bundle.door_trigger_radius;
    b_pressed = true;
    n_dist = 0.0;
    
    do {
        ‪WAIT_SERVER_FRAME;
        b_pressed = e_triggerer UseButtonPressed();
        n_dist = DistanceSquared(e_triggerer.origin, self.origin);
    }
    while ( b_pressed && n_dist < max_dist_sq );
}
 
//*****************************************************************************
// Waits for door to be clear of all ENTS for X time
//*****************************************************************************
function ‪door_wait_until_clear( c_door, e_triggerer )
{
    e_trigger = c_door.m_e_trigger;
    e_temp_trigger = undefined;
    
    // If the trigger is not at the door, we need to create a trigger at the door
    // for temporary purposes.
    if ( ‪IS_TRUE( c_door.m_s_bundle.door_trigger_at_target ) )
    {       
        e_door = c_door.m_e_door;
        v_trigger_offset = c_door.m_s_bundle.v_trigger_offset;
        v_pos = [[c_door]]->calculate_offset_position( e_door.origin, e_door.angles, v_trigger_offset );
        n_radius = c_door.m_s_bundle.door_trigger_radius;
        n_height = c_door.m_n_trigger_height;
        
        // Spawn a trigger
        e_temp_trigger = ‪spawn( "trigger_radius", v_pos, 0, n_radius, n_height );
        e_trigger = e_temp_trigger;
    }
    
    // Player must hold down the button to keep the door open.
    if ( IsPlayer( e_triggerer ) && ‪IS_TRUE(c_door.m_s_bundle.door_use_hold) )
    {
        c_door.m_e_trigger ‪door_wait_until_user_release( c_door, e_triggerer );
    }
    
    // Wait for trigger to be clear of any entity
    e_trigger ‪trigger_wait_until_clear( c_door );
    
    if ( IsDefined( e_temp_trigger ) )
    {
        e_temp_trigger Delete();
    }
}
 
 
//*****************************************************************************
// Waits for a trigger to be free of all ents
//*****************************************************************************
 
// self = trigger
function ‪trigger_check_for_ents_touching( str_kill_trigger_notify )
{
    self endon( "death" );
    self endon( str_kill_trigger_notify );
 
    while( 1 )
    {
        self waittill( "trigger", e_who );
        self.ents_in_trigger = true;
    }
}
 
 
//*****************************************************************************
//*****************************************************************************
 
// self = door trigger
function ‪door_debug_line( v_origin )
{
    self endon( "death" );
 
    while( 1 )
    {
        v_start = v_origin;
        v_end = v_start + ( 0, 0, 1000 );
        v_col = ( 0, 0, 1 );
 
/#
        line( v_start, v_end, (0,0,1) );
#/
 
        wait( 0.1 );
    }
}
 
function ‪player_has_key( str_key_type )
{
    if ( !IsDefined( self.collectible_keys ) )
    {
        return false;
    }
    
    if ( !IsDefined( self.collectible_keys[str_key_type] ) )
    {
        return false;
    }
    
    return self.collectible_keys[str_key_type].num_keys > 0;
}
 
function ‪player_take_key( str_key_type )
{
    if (!‪player_has_key( str_key_type ) )
    {
        return;
    }
    
    self.collectible_keys[str_key_type].num_keys--;
    if ( self.collectible_keys[str_key_type].num_keys <= 0 && IsDefined( self.collectible_keys[str_key_type].hudelem ) )
    {
        self.collectible_keys[str_key_type].hudelem Destroy();
        self.collectible_keys[str_key_type].hudelem = undefined;
    }
}
 
function ‪rotate_key_forever()
{
    self endon( "death" );
    while ( true )
    {
        self RotateYaw( 180, 3.0 );
        wait 2.5;
    }
}
 
function ‪key_process_timeout( n_timeout_sec, e_trigger, e_model )
{
    e_trigger endon( "death" );
    
    const blinking_time = 5.0;
    if ( n_timeout_sec < blinking_time )
    {
        n_timeout_sec = blinking_time + 1.0;
    }
    
    wait n_timeout_sec - blinking_time;
    
    n_stepsize = 0.5;
    b_on = true;
    for ( f = 0.0; f < blinking_time; f += n_stepsize )
    {
        if ( b_on )
        {
            e_model Hide();
        } else {
            e_model Show();
        }
        b_on = !b_on;
        wait n_stepsize;
        
        // Blinking gets faster over time.
        if ( n_stepsize > 0.15 )
        {
            n_stepsize *= 0.9;
        }
    }
    
    level notify( "key_drop_timeout" );
    
    e_model Delete();
    e_trigger Delete();
}
 
function ‪give_ai_key_internal( n_timeout_sec, str_key_type )
{
    v_pos = self.origin;
    
    e_model = ‪spawn("script_model", v_pos + (0,0,80) );
    e_model.angles = (10,0,10);
    e_model SetModel( level.door_key_model );
    
    if ( IsDefined( level.door_key_fx ) )
    {
        PlayFXOnTag( level.door_key_fx, e_model, "tag_origin" );
    }
    
    while( IsAlive( self ) )
    {
        e_model MoveTo( self.origin + (0,0,80), 0.2 );
        e_model RotateYaw( 30, 0.2 );
        wait 0.1;
    }
    
    e_model MoveZ( -60, 1.0 );
    wait 1.0;
    
    e_model thread ‪rotate_key_forever();
    
    e_trigger = ‪spawn( "trigger_radius", e_model.origin, 0, 25.0, 100.0 );
    
    if ( isdefined( n_timeout_sec ) )
    {
        level thread ‪key_process_timeout( n_timeout_sec, e_trigger, e_model );
    }
    
    e_trigger endon( "death" );
    
    while ( true )
    {
        e_trigger waittill( "trigger", e_who );
        if ( IsPlayer( e_who ) )
        {
            e_who ‪give_player_key( str_key_type );
            break;
        }
    }
    
    e_model Delete();
    e_trigger Delete();
}
 
function ‪give_ai_key( n_timeout_sec = undefined, str_key_type = "door" )
{
    assert( isdefined( level.door_key_model ), "Attempting to give ai a key, but no key model is associated with any door in this level." );
    
    self thread ‪give_ai_key_internal( n_timeout_sec, str_key_type );
}
 
function ‪give_player_key( str_key_type = "door" )
{
    assert( isdefined( level.door_key_icon ), "Attempting to give player a key, but no key icon is associated with any door in this level." );
    
    if ( !IsDefined( self.collectible_keys ) )
    {
        self.collectible_keys = [];
    }
    
    if ( !IsDefined( self.collectible_keys[str_key_type] ) )
    {
        self.collectible_keys[str_key_type] = SpawnStruct();
        self.collectible_keys[str_key_type].num_keys = 0;
        self.collectible_keys[str_key_type].type = str_key_type;
    }
    
    hudelem = self.collectible_keys[str_key_type].hudelem;
    if ( !isdefined( hudelem ) )
    {
        hudelem = newclienthudelem( self );
    }
    
    hudelem.alignX = "right";
    hudelem.alignY = "bottom";
    hudelem.horzAlign = "right";
    hudelem.vertAlign = "bottom";
    hudelem.hidewheninmenu = true;
    hudelem.hideWhenInDemo = true;
    hudelem.y = -75;
    hudelem.x = -25;
    
    hudelem SetShader( level.door_key_icon, 16, 16 );
    
    self.collectible_keys[str_key_type].hudelem = hudelem;
    
    self.collectible_keys[str_key_type].num_keys++;
}
 
function ‪unlock_all( b_do_open = true )
{
    a_s_inst_list = ‪struct::get_array( "scriptbundle_doors", "classname" );
    foreach( s_inst in a_s_inst_list )
    {
        c_door = s_inst.c_door;
        if ( isdefined( c_door ) )
        {
            [[c_door]]->unlock();
        
            if ( b_do_open )
            {
                [[c_door]]->open();
            }
        }
    }
}
 
function ‪unlock( str_name, str_name_type = "targetname", b_do_open = true )
{
    a_s_inst_list = ‪struct::get_array( str_name, str_name_type );
    foreach( s_inst in a_s_inst_list )
    {
        if ( isdefined( s_inst.c_door ) )
        {
            [[s_inst.c_door]]->unlock();
            
            if ( b_do_open )
            {
                [[s_inst.c_door]]->open();
            }
        }
    }
}