_zm_utility.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\array_shared;
#using scripts\shared\clientfield_shared;
#using scripts\shared\flag_shared;
#using scripts\shared\hud_message_shared;
#using scripts\shared\laststand_shared;
#using scripts\shared\util_shared;
 
#insert scripts\shared\shared.gsh;
#insert scripts\shared\statstable_shared.gsh;
 
#using scripts\shared\ai\zombie_utility;
 
#using scripts\zm\_util;
#using scripts\zm\_zm;
#using scripts\zm\_zm_ai_faller;
#using scripts\zm\_zm_audio;
#using scripts\zm\_zm_bgb;
#using scripts\zm\_zm_equipment;
#using scripts\zm\_zm_laststand;
#using scripts\zm\_zm_perks;
#using scripts\zm\_zm_power;
#using scripts\zm\_zm_powerups;
#using scripts\zm\_zm_server_throttle;
#using scripts\zm\_zm_stats;
#using scripts\zm\_zm_spawner;
#using scripts\zm\_zm_weapons;
 
#insert scripts\zm\_zm_perks.gsh;
#insert scripts\zm\_zm_utility.gsh;
 
#namespace zm_utility;
 
function ‪init_utility()
{
//  level thread edge_fog_start(); 
 
//  level thread hudelem_count(); 
}
 
function ‪is_Classic()
{
    return true;
}
 
function ‪is_Standard()
{
    dvar = GetDvarString( "ui_gametype" );
    
    if ( dvar == "zstandard" )
    {
        return true;
    }
    
    return false;
}
 
 
function ‪ConvertSecondsToMilliseconds( seconds )
{
    return ( seconds * 1000 );
}
 
function ‪is_player()
{
    return ( IsPlayer( self ) || ( IsDefined( self.pers ) && ‪IS_TRUE( self.pers[ "isBot" ] ) ) );
}
 
// self is Ai and chunk is selected piece
function ‪lerp( chunk )
{
    // anim_reach_aligned
    link = ‪Spawn( "script_origin", self GetOrigin() ); // link is a new origin of the ai
    link.angles = self.first_node.angles ; // link now has the angles of itself, perhaps these angles aren't coming over..
    self LinkTo(link); // link ai + origin to chunk + origin
 
    // link RotateTo(chunk.origin GetTagAngles("Tag_bottom"), level._CONTEXTUAL_GRAB_LERP_TIME); // this should angle him to spot
    // link MoveTo(chunk.origin GetTagOrigin("Tag_bottom"), level._CONTEXTUAL_GRAB_LERP_TIME); // this should move him over to spot
    
    // I need to have the offest for the bar
    link RotateTo(self.first_node.angles , level._CONTEXTUAL_GRAB_LERP_TIME); // this should angle him to spot
 
    link MoveTo(self.attacking_spot , level._CONTEXTUAL_GRAB_LERP_TIME); // this should move him over to spot
    //link RotateTo(self GetTagAngles ("Tag_player"), level._CONTEXTUAL_GRAB_LERP_TIME); // this should angle him to spot
    //link MoveTo(self GetTagOrigin ("Tag_player"), level._CONTEXTUAL_GRAB_LERP_TIME); // this should move him over to spot
    
    link ‪util::waittill_multiple("rotatedone", "movedone");
 
    self Unlink();
    link Delete();
    
    return;
}
 
function ‪recalc_zombie_array()
{
/*  
    enemies = [];
    level.current_zombie_array = [];
    enemies = GetAiSpeciesArray( level.zombie_team, "all" );
 
    for( i = 0; i < enemies.size; i++ )
    {
        if ( IS_TRUE( enemies[i].ignore_enemy_count ) )
        {
            continue;
        }
        ARRAY_ADD( level.current_zombie_array, enemies[i] );
    }
    
    level.current_zombie_count = level.current_zombie_array.size;
*/
}
 
function ‪init_zombie_run_cycle()
{
    if ( isdefined( level.speed_change_round ) )
    {
        if ( level.round_number >= level.speed_change_round )
        {
            speed_percent = 0.2 + ( ( level.round_number - level.speed_change_round ) * 0.2 );
            speed_percent = min( speed_percent, 1 );
 
            change_round_max = Int( level.speed_change_max * speed_percent );
            change_left = change_round_max - level.speed_change_num;
 
            if ( change_left == 0 )
            {
                self ‪zombie_utility::set_zombie_run_cycle();
                return;
            }
 
            change_speed = RandomInt( 100 );
            if ( change_speed > 80 )
            {
                self ‪change_zombie_run_cycle();
                return;
            }
 
            zombie_count = ‪zombie_utility::get_current_zombie_count();
            zombie_left = level.zombie_ai_limit - zombie_count;
 
            if ( zombie_left == change_left )   // need to force the speed change at this point
            {
                self ‪change_zombie_run_cycle();
                return;
            }
        }
    }
 
    self ‪zombie_utility::set_zombie_run_cycle();
}
 
function ‪change_zombie_run_cycle()
{
    level.speed_change_num++;
    if ( level.gamedifficulty == 0 )
    {
        self ‪zombie_utility::set_zombie_run_cycle( "sprint" );
    }
    else
    {
        /*
            iprintln( "walker round " + level.round_number + " change " + level.speed_change_num );
        */
        self ‪zombie_utility::set_zombie_run_cycle( "walk" );
    }
 
    self thread ‪speed_change_watcher();
}
 
function ‪make_supersprinter()
{
    self ‪zombie_utility::set_zombie_run_cycle( "super_sprint" );
}
 
function ‪speed_change_watcher()
{
    self waittill( "death" );
 
    if ( level.speed_change_num > 0 )
    {
        level.speed_change_num--;
    }
}
 
function ‪move_zombie_spawn_location(spot)
{
    self endon( "death" );
    
    if(IsDefined(self.spawn_pos))
    {
        self notify("risen", self.spawn_pos.script_string );
        return;
    }       
    self.spawn_pos = spot;
    
    // give target from spawn location to spawner to path
    if(IsDefined(spot.target))
    {
        self.target = spot.target;
    }   
 
    if(IsDefined(spot.zone_name))
    {
        self.zone_name = spot.zone_name;
        self.previous_zone_name = spot.zone_name;
    }   
 
    if(IsDefined(spot.script_parameters))
    {
        self.script_parameters = spot.script_parameters;
    }
 
    if(!IsDefined(spot.script_noteworthy))
    {
        spot.script_noteworthy = "spawn_location";
    }   
 
    tokens = StrTok( spot.script_noteworthy, " " );
    foreach ( index, token in tokens )
    {
        // time bomb needs to spawn zombies away from their original spawn point; this should point to a struct
        if ( IsDefined( self.spawn_point_override ) )
        {
            spot = self.spawn_point_override;
            token = spot.script_noteworthy;
        }
        
        if ( token == "custom_spawner_entry" )
        {
            next_token = index + 1;
            
            if ( IsDefined( tokens[ next_token ] ) )
            {
                str_spawn_entry = tokens[ next_token ];
                
                if ( IsDefined( level.custom_spawner_entry ) && IsDefined( level.custom_spawner_entry[ str_spawn_entry ] ) )
                {
                    self thread [[ level.custom_spawner_entry[ str_spawn_entry ] ]]( spot );
                    continue;
                }
            }
        }
        
        if(token == "riser_location")
        {
            self thread ‪zm_spawner::do_zombie_rise(spot);
        }
        else if (token == "faller_location")
        {
            self thread ‪zm_ai_faller::do_zombie_fall(spot); 
        }
        else if (token == "spawn_location" )
        {
            // anchor defined by some other custom spawner behavior, so bypass standard behavior
            if ( IsDefined( self.anchor ) )
            {
                return;
            }
                
            self.anchor = ‪spawn("script_origin", self.origin);
            self.anchor.angles = self.angles;
            self linkto(self.anchor);
            self.anchor thread ‪anchor_delete_failsafe( self );
            
            if( !isDefined( spot.angles ) )
            {
                spot.angles = (0, 0, 0);
            }
            
            self Ghost();
            self.anchor moveto(spot.origin, .05);
            self.anchor waittill("movedone");
            
            // face goal
            target_org = ‪zombie_utility::get_desired_origin();
            if (IsDefined(target_org))
            {
                anim_ang = VectorToAngles(target_org - self.origin);
                self.anchor RotateTo((0, anim_ang[1], 0), .05);
                self.anchor waittill("rotatedone");
            }
            if(isDefined(level.zombie_spawn_fx))
            {
                playfx(level.zombie_spawn_fx,spot.origin);
            }
            self unlink();
 
            if(isDefined(self.anchor))
            {
                self.anchor delete();
            }
            if(!‪IS_TRUE(self.dontShow))
            {
                self Show();
            }
            self notify("risen", spot.script_string );
        }
    }   
}   
 
 
// self is an anchor script_origin
//  There is a very small window where a zombie could be killed and the anchor would be left hanging around.
function ‪anchor_delete_failsafe( ai_zombie )
{
    ai_zombie endon( "risen" );
    
    ai_zombie waittill( "death" );
    
    if( isdefined( self ) )
    {
        self Delete();
    }
}
 
function ‪run_spawn_functions()
{
    self endon( "death" );
 
    waittillframeend;   // spawn functions should override default settings, so they need to be last
 
    for (i = 0; i < level.spawn_funcs[ self.team ].size; i++)
    {
        func = level.spawn_funcs[ self.team ][ i ];
        ‪util::single_thread(self, func[ "function" ], func[ "param1" ], func[ "param2" ], func[ "param3" ], func[ "param4" ], func[ "param5" ] );
    }
 
    if ( IsDefined( self.spawn_funcs ))
    {
        for (i = 0; i < self.spawn_funcs.size; i++)
        {
            func = self.spawn_funcs[ i ];
            ‪util::single_thread(self, func[ "function" ], func[ "param1" ], func[ "param2" ], func[ "param3" ], func[ "param4" ] );
        }
 
        /#
            self.saved_spawn_functions = self.spawn_funcs;
        #/
 
        self.spawn_funcs = undefined;
 
        /#
            // keep them around in developer mode, for debugging
            self.spawn_funcs = self.saved_spawn_functions;
            self.saved_spawn_functions = undefined;
        #/
 
        self.spawn_funcs = undefined;
    }
}
 
 
function ‪create_simple_hud( client, team )
{
    if ( IsDefined( team ) )
    {
        hud = NewTeamHudElem( team );
        hud.team = team;
    }
    else
    {
        if( IsDefined( client ) )
        {
            hud = NewClientHudElem( client ); 
        }
        else
        {
            hud = NewHudElem(); 
        }
    }
 
    level.hudelem_count++; 
 
    hud.foreground = true; 
    hud.sort = 1; 
    hud.hidewheninmenu = false; 
 
    return hud; 
}
 
function ‪destroy_hud()
{
    level.hudelem_count--; 
    self Destroy(); 
}
 
 
// self = exterior_goal which is barrier_chunks
function ‪all_chunks_intact( barrier, barrier_chunks )
{
    if(isdefined(barrier.zbarrier))
    {
        pieces = barrier.zbarrier GetZBarrierPieceIndicesInState("closed");
        
        if(pieces.size != barrier.zbarrier GetNumZBarrierPieces())
        {
            return false;
        }
    }
    else
    {
        for( i = 0; i < barrier_chunks.size; i++ ) // Count up barrier_chunks total size
        {
            if( barrier_chunks[i] ‪get_chunk_state() != "repaired" ) // if any piece has the state of not repaired then return false
            {
                return false; 
            }
        }
    }
    
    return true; // if the board has been repaired then return true 
}
 
 
// self = exterior_goal which is barrier_chunks
function ‪no_valid_repairable_boards( barrier, barrier_chunks )
{
 
    if(isdefined(barrier.zbarrier))
    {
        pieces = barrier.zbarrier GetZBarrierPieceIndicesInState("open");
        
        if(pieces.size)
        {
            return false;
        }
    }
    else
    {
        for( i = 0; i < barrier_chunks.size; i++ ) // Count up barrier_chunks total size
        {
            if( barrier_chunks[i] ‪get_chunk_state() == "destroyed" ) // if any piece has been destroyed return false
            {
                return false; 
            }
        }
    }
    
    return true; // if any piece is not destroyed then return true
}
 
function ‪is_Survival()
{
    return false;
}
 
function ‪is_Encounter()
{
    return false;
}
 
function ‪all_chunks_destroyed( barrier, barrier_chunks )
{
    if(isdefined(barrier.zbarrier))
    {
        pieces = ArrayCombine(barrier.zbarrier GetZBarrierPieceIndicesInState("open"), barrier.zbarrier GetZBarrierPieceIndicesInState("opening"), true, false);
        
        if(pieces.size !=  barrier.zbarrier GetNumZBarrierPieces())
        {
            return false;
        }
    }
    else if( IsDefined( barrier_chunks ) )
    {
        ASSERT( IsDefined(barrier_chunks), "zombie_utility::all_chunks_destroyed - Barrier chunks undefined" );
        for( i = 0; i < barrier_chunks.size; i++ )
        {
            if( barrier_chunks[i] ‪get_chunk_state() != "destroyed" )
            {
                return false; 
            }
        }
    }
    return true; 
}
 
function ‪check_point_in_playable_area( origin )
{
    playable_area = getentarray("player_volume","script_noteworthy");
 
    if ( !IsDefined( level.check_model ) )
    {
        level.check_model = ‪spawn ("script_model", origin + (0,0,40));
    }
    else
    {
        level.check_model.origin = origin + ( 0, 0, 40 );
    }
    
    valid_point = false;
    for (i = 0; i < playable_area.size; i++)
    {
        if (level.check_model istouching(playable_area[i]))
        {
            valid_point = true;
        }
    }
    
    return valid_point;
}
 
//*****************************************************************************
// origin - 
// zone_is_active - (optional) if set the zone must also be active as well
// player_zones - (optional) optimization
//*****************************************************************************
 
//aka check_point_in_active_zone( origin )
function ‪check_point_in_enabled_zone( origin, zone_is_active, player_zones )
{
    if( !IsDefined(player_zones) )
    {
        player_zones = getentarray("player_volume","script_noteworthy");
    }
 
    if( !isDefined( level.zones ) || !isDefined( player_zones ) )
    {
        return true;
    }
    
    if ( !isdefined( level.e_check_point ) )
    {
        // Just spawn the checker entity once and move it around as needed instead of creating and deleting all the time
        level.e_check_point = ‪spawn( "script_origin", origin+(0, 0, 40) );
    }
    else
    {
        level.e_check_point.origin = origin+(0,0,40);
    }
    
    one_valid_zone = false;
    for( i = 0; i < player_zones.size; i++ )
    {
        if( level.e_check_point IsTouching( player_zones[i] ) )
        {
            zone = level.zones[player_zones[i].targetname];
 
            if( IsDefined(zone) && ‪IS_TRUE(zone.is_enabled) )
            {
                if( IsDefined(zone_is_active) && (zone_is_active == true) && !‪IS_TRUE(zone.is_active) )
                {
                    continue;
                }
 
                one_valid_zone = true;
                break;
            }
        }
    }
    
    return one_valid_zone;
}
 
function ‪round_up_to_ten( score )
{
    new_score = score - score % 10; 
    if( new_score < score )
    {
        new_score += 10; 
    }
    return new_score; 
}
 
function ‪round_up_score( score, value )
{
    score = int(score); // Make sure it's an int or modulus will die
 
    new_score = score - score % value; 
    if( new_score < score )
    {
        new_score += value; 
    }
    return new_score; 
}
 
function ‪halve_score( n_score )
{
    n_score = n_score / 2;
    n_score = ‪zm_utility::round_up_score( n_score, 10 );
    
    return n_score; 
}
 
function ‪random_tan()
{
    rand = randomint( 100 ); 
    
    if(isDefined(level.char_percent_override) )
    {
        percentNotCharred = level.char_percent_override;
    }
    else
    {
        percentNotCharred = 65;
    }
    
//  if( rand > percentNotCharred )
//  {
//      self StartTanning(); 
//  }
    // PI_CHANGE_END
}
 
// Returns the amount of places before the decimal, ie 1000 = 4, 100 = 3...
function ‪places_before_decimal( num )
{
    abs_num = abs( num ); 
    count = 0; 
    while( 1 )
    {
        abs_num *= 0.1; // Really doing num / 10
        count += 1; 
 
        if( abs_num < 1 )
        {
            return count; 
        }
    }
}
 
function ‪create_zombie_point_of_interest( attract_dist, num_attractors, added_poi_value, start_turned_on, initial_attract_func, arrival_attract_func,poi_team )
{
    if( !isDefined( added_poi_value ) )
    {
        self.added_poi_value = 0;
    }
    else
    {
        self.added_poi_value = added_poi_value;
    }
    
    if( !isDefined( start_turned_on ) )
    {
        start_turned_on = true;
    }
    
    if ( !isdefined( attract_dist ) )
    {
        attract_dist = 1536; // Covers all available zombies within a given district
    }
    
    self.script_noteworthy = "zombie_poi";
    self.poi_active = start_turned_on;
 
    if( isDefined( attract_dist ) )
    {
        self.max_attractor_dist = attract_dist;
        self.poi_radius = attract_dist * attract_dist;
    }
    else // This poi has no maximum attract distance, it will attract all zombies
    {
        self.poi_radius = undefined;
    }
    self.num_poi_attracts = num_attractors;
    self.attract_to_origin = true;
    self.attractor_array = [];
    self.initial_attract_func = undefined;
    self.arrival_attract_func = undefined;
    if(isDefined(poi_team))
    {
        self._team = poi_team;
    }
    
    // any special functions for initial reaction or arrival at the poi are stored here for get_zombie_point_of_intrest
    if( IsDefined( initial_attract_func ) )
    {
        self.initial_attract_func = initial_attract_func;
    }
    
    if( IsDefined( arrival_attract_func ) )
    {
        self.arrival_attract_func = arrival_attract_func;
    }
 
    ‪ARRAY_ADD( level.zombie_poi_array, self );
    self thread ‪zm_utility::watch_for_poi_death();
    
}
 
function ‪watch_for_poi_death()
{
    self waittill( "death" );
    
    //Remove from list
    if ( IsInArray( level.zombie_poi_array, self ) )
    {
        ArrayRemoveValue( level.zombie_poi_array, self );
    }
}
 
function ‪debug_draw_new_attractor_positions()
{
    self endon( "death" );
 
    while ( 1 )
    {
        foreach( attract in self.attractor_positions )
        {
            passed = BulletTracePassed( attract[0] + (0, 0, 24), self.origin + (0, 0, 24), false, self );
            if ( passed )
            {
                /# debugstar( attract[0], 6, (1,1,1) ); #/
            }
            else
            {
                /# debugstar( attract[0], 6, (1,0,0) ); #/
            }
        }
        
        ‪WAIT_SERVER_FRAME;
    }
}
 
function ‪create_zombie_point_of_interest_attractor_positions( num_attract_dists, attract_dist )
{
    self endon( "death" );
 
    if( !isdefined( self.num_poi_attracts ) || (isDefined(self.script_noteworthy) && self.script_noteworthy != "zombie_poi" ))
    {
        return;
    }
    
    if( !isdefined( num_attract_dists ) ) // TODO Holdover from previous logic.  Should be reevaluated
    {
        num_attract_dists = 4;
    }
    
    // Creates matrix of attraction points and assigns them to grenade
    queryResult = PositionQuery_Source_Navigation( self.origin, (attract_dist / 2), self.max_attractor_dist, (attract_dist / 2), (attract_dist / 2), true, (attract_dist / 2) );
    
    if( queryResult.data.size < self.num_poi_attracts )
    {
        self.num_poi_attracts = queryResult.data.size;
    }
    for ( i = 0; i < self.num_poi_attracts; i++ )
    {
        if ( ‪IS_TRUE( level.validate_poi_attractors ) )
        {
            passed = BulletTracePassed( queryResult.data[i].origin + (0, 0, 24), self.origin + (0, 0, 24), false, self );
            if ( passed )
            {
                self.attractor_positions[i][0] = queryResult.data[i].origin;
                self.attractor_positions[i][1] = self;
            }
        }
        else
        {
            self.attractor_positions[i][0] = queryResult.data[i].origin;
            self.attractor_positions[i][1] = self;
        }
    }
    
    if( !IsDefined( self.attractor_positions ) )
    {
        self.attractor_positions = [];
    }
    
    self.num_attract_dists = num_attract_dists;
    
    // The last index in the attractor_position arrays for each of the possible distances. The array is a holdover from previous logic.
    self.last_index = [];
    for( i = 0; i < num_attract_dists; i++ )
    {
        self.last_index[i] = -1;
    }
    
    // Represents origin point TODO Holdover from previous logic.  Should be reevaluated
    self.last_index[0] = 1;
    
    // Represents total number of attraction points TODO Holdover from previous logic.  Should be reevaluated
    self.last_index[1] = self.attractor_positions.size;
    
    self.attract_to_origin = false;
    
    self notify( "attractor_positions_generated" );
    level notify( "attractor_positions_generated" );
 
//  self thread debug_draw_new_attractor_positions();
}
 
function ‪generated_radius_attract_positions( forward, offset, num_positions, attract_radius )
{
    self endon( "death" );
 
    epsilon = 1;
    failed = 0;
    degs_per_pos = 360 / num_positions;
    for( i = offset; i < 360+offset; i += degs_per_pos )
    {
        altforward = forward * attract_radius;
        rotated_forward = ( (cos(i)*altforward[0] - sin(i)*altforward[1]), (sin(i)*altforward[0] + cos(i)*altforward[1]), altforward[2] );
        
        if(isDefined(level.poi_positioning_func))
        {
            pos = [[level.poi_positioning_func]](self.origin, rotated_forward);
        }
        else if(‪IS_TRUE(level.use_alternate_poi_positioning))
        {
            pos = ‪zm_server_throttle::server_safe_ground_trace( "poi_trace", 10, self.origin + rotated_forward + ( 0, 0, 10 ) ); //only trace from 10 units above instead of 100 units
        }
        else
        {
            pos = ‪zm_server_throttle::server_safe_ground_trace( "poi_trace", 10, self.origin + rotated_forward + ( 0, 0, 100 ) );
        }
        
        if(!isDefined(pos))
        {
            failed++;
            continue;
        }
        
        if(‪IS_TRUE(level.use_alternate_poi_positioning)) // Attractors are defined and sent to the array here
        {
            if ( isDefined( self ) && isDefined( self.origin ) )
            {
                if( self.origin[2] >= (pos[2]-epsilon) && self.origin[2] - pos[2] <= 150 )
                {
                    pos_array = [];
                    pos_array[0] = pos;
                    pos_array[1] = self;
                    ‪ARRAY_ADD( self.attractor_positions , pos_array );
                }
            }
            else
            {
                failed++;
            }
        }
        else if(abs( pos[2] - self.origin[2] ) < 60 )
        {
            pos_array = [];
            pos_array[0] = pos;
            pos_array[1] = self;
            ‪ARRAY_ADD( self.attractor_positions , pos_array );
        }
        else
        {
            failed++;
        }
    }
    return failed;
}
 
function ‪debug_draw_attractor_positions()
{
    /#
    while( true )
    {
        while( !isDefined( self.attractor_positions ) )
        {
            ‪WAIT_SERVER_FRAME;
            continue;
        }
        for( i = 0; i < self.attractor_positions.size; i++ )
        {
            Line( self.origin, self.attractor_positions[i][0], (1, 0, 0), true, 1 );
        }
        ‪WAIT_SERVER_FRAME;
        if( !IsDefined( self ) )
        {
            return;
        }
    }
    #/
}
 
function ‪debug_draw_claimed_attractor_positions()
{
    /#
    while( true )
    {
        while( !isDefined( self.claimed_attractor_positions ) )
        {
            ‪WAIT_SERVER_FRAME;
            continue;
        }
        for( i = 0; i < self.claimed_attractor_positions.size; i++ )
        {
            Line( self.origin, self.claimed_attractor_positions[i][0], (0, 1, 0), true, 1 );
        }
        ‪WAIT_SERVER_FRAME;
        if( !IsDefined( self ) )
        {
            return;
        }
    }
    #/
}
 
function ‪get_zombie_point_of_interest( origin, poi_array )
{
    AIProfile_BeginEntry( "get_zombie_point_of_interest" );
        
    if ( ‪IS_TRUE( self.ignore_all_poi ) )
    {
        AIProfile_EndEntry();
        return undefined;
    }
 
    curr_radius = undefined;
    
    if ( isdefined( poi_array ) )
    {
        ent_array = poi_array;
    }
    else
    {
        ent_array = level.zombie_poi_array;//getEntArray( "zombie_poi", "script_noteworthy" );
    }
    
    best_poi = undefined;
    position = undefined;
    best_dist = 10000 * 10000;
    
    for( i = 0; i < ent_array.size; i++ )
    {
        if( !isDefined( ent_array[i] ) || !isDefined( ent_array[i].poi_active ) || !ent_array[i].poi_active  )
        {
            continue;
        }
 
        if ( isDefined( self.ignore_poi_targetname ) && self.ignore_poi_targetname.size > 0 )
        {
            if ( isDefined( ent_array[i].targetname ) )
            {
                ‪ignore = false;
                for ( j = 0; j < self.ignore_poi_targetname.size; j++ )
                {
                    if ( ent_array[i].targetname == self.ignore_poi_targetname[j] )
                    {
                        ‪ignore = true;
                        break;
                    }
                }
                if ( ‪ignore )
                {
                    continue;
                }
            }
        }
 
        if ( isDefined( self.ignore_poi ) && self.ignore_poi.size > 0 )
        {
            ‪ignore = false;
            for ( j = 0; j < self.ignore_poi.size; j++ )
            {
                if ( self.ignore_poi[j] == ent_array[i] )
                {
                    ‪ignore = true;
                    break;
                }
            }
            if ( ‪ignore )
            {
                continue;
            }
        }
        
        dist = distanceSquared( origin, ent_array[i].origin );
        
        dist -= ent_array[i].added_poi_value;
        
        if( isDefined( ent_array[i].poi_radius ) )
        {
            curr_radius = ent_array[i].poi_radius;
        }
        
        if( (!isDefined( curr_radius ) || dist < curr_radius) && dist < best_dist && ent_array[i] ‪can_attract(self) )
        {
            best_poi = ent_array[i];
            best_dist = dist;
        }
    }
    
    if( isDefined( best_poi ) )
    {
        if(isDefined(best_poi._team))
        {
            if(isDefined(self._race_team) && self._race_team != best_poi._team)
            {
                AIProfile_EndEntry();
                return undefined;
            }
        }
        if( ‪IS_TRUE( best_poi._new_ground_trace ) ) // needed for the bhb so it won't trace through metal clip
        {
            position = [];
            position[0] = ‪groundpos_ignore_water_new( best_poi.origin + (0, 0, 100) );
            position[1] = self;
        }
        else if( isDefined( best_poi.attract_to_origin ) && best_poi.attract_to_origin ) // Override, currently only used for monkeys in the air.
        {
            position = [];
            position[0] = ‪groundpos( best_poi.origin + (0, 0, 100) );
            position[1] = self;
        }
        else
        {
            position = self ‪add_poi_attractor( best_poi );
        }
        
        if( IsDefined( best_poi.initial_attract_func ) )
        {
            self thread [[ best_poi.initial_attract_func ]]( best_poi );
        }
        
        if( IsDefined( best_poi.arrival_attract_func ) )
        {
            self thread [[ best_poi.arrival_attract_func ]]( best_poi );
        }
    }
    
    AIProfile_EndEntry();
    return position;
}
 
function ‪activate_zombie_point_of_interest()
{
    if( self.script_noteworthy != "zombie_poi" )
    {
        return;
    }
    
    self.poi_active = true;
}
 
function ‪deactivate_zombie_point_of_interest( dont_remove )
{
    if( self.script_noteworthy != "zombie_poi" )
    {
        return;
    }
 
    self.attractor_array = ‪array::remove_undefined( self.attractor_array );
    for( i = 0; i < self.attractor_array.size; i++ )
    {
        self.attractor_array[i] notify( "kill_poi" );
    }
 
    self.attractor_array = [];
    self.claimed_attractor_positions = [];
    
    self.poi_active = false;
 
    if ( ‪IS_TRUE( dont_remove ) )
    {
        return;
    }
    
    //Remove from list
    if ( isdefined( self ) )
    {
        if ( IsInArray( level.zombie_poi_array, self ) )
        {
            ArrayRemoveValue( level.zombie_poi_array, self );
        }
    }   
}
 
//PI_CHANGE_BEGIN - 6/18/09 JV This works to help set "wait" points near the stage if all players are in the process teleportation.  
//It is unlike the previous function in that you dictate the poi.
function ‪assign_zombie_point_of_interest (origin, poi)
{
    position = undefined;
    doremovalthread = false;
 
    if (IsDefined(poi) && poi ‪can_attract(self))
    {
        //don't want to touch add poi attractor, but yeah, this is kind of weird
        if (!IsDefined(poi.attractor_array) || ( IsDefined(poi.attractor_array) && !IsInArray( poi.attractor_array, self ) ))
            doremovalthread = true;
        
        position = self ‪add_poi_attractor( poi );
        
        //now that I know this is the first time they've been added, set up the thread to remove them from the array
        if (IsDefined(position) && doremovalthread && IsInArray( poi.attractor_array, self  ))
            self thread ‪update_on_poi_removal( poi );       
    }
    
    return position;
}
//PI_CHANGE_END
 
function ‪remove_poi_attractor( zombie_poi )
{
    if( !isDefined( zombie_poi ) || !isDefined( zombie_poi.attractor_array ) )
    {
        return;
    }
    
    for( i = 0; i < zombie_poi.attractor_array.size; i++ )
    {
        if( zombie_poi.attractor_array[i] == self )
        {
            ArrayRemoveValue( zombie_poi.attractor_array, zombie_poi.attractor_array[i] );
            ArrayRemoveValue( zombie_poi.claimed_attractor_positions, zombie_poi.claimed_attractor_positions[i] );
            
            if ( isdefined( self ) )
            {
                self notify( "kill_poi" );
            }
        }
    }
}
 
function ‪array_check_for_dupes_using_compare( ‪array, single, is_equal_fn )
{
    for( i = 0; i < ‪array.size; i++ )
    {
        if( [[is_equal_fn]]( ‪array[i], single ) )
        {
            return false;
        }
    }
 
    return true;
}
 
function ‪poi_locations_equal( loc1, loc2 )
{
    return loc1[0]==loc2[0];
}
 
 
function ‪add_poi_attractor( zombie_poi )
{
    if( !isDefined( zombie_poi ) )
    {
        return;
    }
    if( !isDefined( zombie_poi.attractor_array ) )
    {
        zombie_poi.attractor_array = [];
    }
    
    // If we are not yet an attractor to this poi, claim an attractor position and start attracting to it
    if( !IsInArray( zombie_poi.attractor_array, self ) )
    {
        if( !isDefined( zombie_poi.claimed_attractor_positions ) )
        {
            zombie_poi.claimed_attractor_positions = [];
        }
        
        if( !isDefined( zombie_poi.attractor_positions ) || zombie_poi.attractor_positions.size <= 0 )
        {
            return undefined;
        }
        
        start = -1;
        ‪end = -1;
        last_index = -1;
        for( i = 0; i < 4; i++ )
        {
            if( zombie_poi.claimed_attractor_positions.size < zombie_poi.last_index[i] ) 
            {
                start = last_index+1;
                ‪end = zombie_poi.last_index[i];
                break;
            }
            last_index = zombie_poi.last_index[i];
        }
        
        
        best_dist = 10000*10000;
        best_pos = undefined;
        if( start < 0 )
        {
            start = 0;
        }
        if( ‪end < 0 )
        {
            return undefined;
        }
        for( i = int(start); i <= int(‪end); i++ )
        {
            if(!isDefined(zombie_poi.attractor_positions[i]))
            {
                continue;
            }
            //if( !IsInArray( zombie_poi.claimed_attractor_positions, zombie_poi.attractor_positions[i] ) )
            if( ‪array_check_for_dupes_using_compare( zombie_poi.claimed_attractor_positions, zombie_poi.attractor_positions[i], &‪poi_locations_equal ) )
            {
 
                if ( isDefined( zombie_poi.attractor_positions[i][0] ) && isDefined( self.origin ) )
                {
                    dist = distancesquared( zombie_poi.attractor_positions[i][0], zombie_poi.origin );
                    if( dist < best_dist || !isDefined( best_pos ) )
                    {
                        best_dist = dist;
                        best_pos = zombie_poi.attractor_positions[i];
                    }
                }
            }
        }
        
        if( !isDefined( best_pos ) )
        {
            if ( ‪IS_TRUE( level.validate_poi_attractors ) )
            {
                valid_pos = [];
                valid_pos[0] = zombie_poi.origin;
                valid_pos[1] = zombie_poi;
                return valid_pos;
            }
            
            return undefined;
        }
        
        ‪ARRAY_ADD( zombie_poi.attractor_array, self );
        self thread ‪update_poi_on_death( zombie_poi );      
        
        ‪ARRAY_ADD( zombie_poi.claimed_attractor_positions, best_pos );
        
        return best_pos;
    }
    else
    {
        for( i = 0; i < zombie_poi.attractor_array.size; i++ )
        {
            if( zombie_poi.attractor_array[i] == self )
            {
                if( isDefined( zombie_poi.claimed_attractor_positions ) && isDefined( zombie_poi.claimed_attractor_positions[i] ) )
                {
                    return zombie_poi.claimed_attractor_positions[i];
                }
            }
        }
    }
    
    return undefined;
}
 
function ‪can_attract( attractor )
{
    if( !isDefined( self.attractor_array ) )
    {
        self.attractor_array = [];
    }
    //Raven Begin - Allow only selected zombies to be attracted
    if( isDefined(self.attracted_array) && !IsInArray(self.attracted_array, attractor) )
    {
        return false;
    }
    //Raven End
    if( IsInArray( self.attractor_array, attractor ) )
    {
        return true;
    }
    if( isDefined(self.num_poi_attracts) && self.attractor_array.size >= self.num_poi_attracts )
    {
        return false;
    }
 
    return true;
}
 
function ‪update_poi_on_death( zombie_poi )
{
    self endon( "kill_poi" );
    
    self waittill( "death" );
    self ‪remove_poi_attractor( zombie_poi );
}
 
//PI_CHANGE_BEGIN - 6/18/09 JV This was set up to work with assign_zombie_point_of_interest (which works with the teleportation in theater).
//The poi attractor array needs to be emptied when a player is teleported out of projection room (if they were all in there).  
//As a result, we wait for the poi's death (I'm sending that notify via the level script)
function ‪update_on_poi_removal (zombie_poi )
{   
    zombie_poi waittill( "death" );
    
    if( !isDefined( zombie_poi.attractor_array ) )
        return;
    
    for( i = 0; i < zombie_poi.attractor_array.size; i++ )
    {
        if( zombie_poi.attractor_array[i] == self )
        {   
            ArrayRemoveIndex( zombie_poi.attractor_array, i );
            ArrayRemoveIndex( zombie_poi.claimed_attractor_positions, i );
        }
    }
    
}
//PI_CHANGE_END
 
function ‪invalidate_attractor_pos( attractor_pos, zombie )
{
    if( !isDefined( self ) || !isDefined( attractor_pos ) )
    {
        wait( 0.1 );
        return undefined;
    }
    
    if( isDefined( self.attractor_positions) && !‪array_check_for_dupes_using_compare( self.attractor_positions, attractor_pos, &‪poi_locations_equal ) )
    {
        index = 0;
        for( i = 0; i < self.attractor_positions.size; i++ )
        {
            if( ‪poi_locations_equal( self.attractor_positions[i], attractor_pos) )
            {
                index = i;
            }
        }
        
        for( i = 0; i < self.last_index.size; i++ )
        {
            if( index <= self.last_index[i] )
            {
                self.last_index[i]--;
            }
        }
        
        ArrayRemoveValue( self.attractor_array, zombie );
        ArrayRemoveValue( self.attractor_positions, attractor_pos );
        for( i = 0; i < self.claimed_attractor_positions.size; i++ )
        {
            if( self.claimed_attractor_positions[i][0] == attractor_pos[0] )
            {
                ArrayRemoveValue( self.claimed_attractor_positions, self.claimed_attractor_positions[i] );
            }
        }
    }
    else
    {
        wait( 0.1 );
    }
    
    return ‪get_zombie_point_of_interest( zombie.origin );
}
 
function ‪remove_poi_from_ignore_list( poi )
{
    if ( isDefined( self.ignore_poi ) && self.ignore_poi.size > 0 )
    {
        for ( i = 0; i < self.ignore_poi.size; i++ )
        {
            if ( self.ignore_poi[i] == poi )
            {
                ArrayRemoveValue( self.ignore_poi, self.ignore_poi[i] );
                return;
            }
        }
    }
}
 
function ‪add_poi_to_ignore_list( poi )
{
    if ( !isDefined( self.ignore_poi ) )
    {
        self.ignore_poi = [];
    }
 
    add_poi = true;
    if ( self.ignore_poi.size > 0 )
    {
        for ( i = 0; i < self.ignore_poi.size; i++ )
        {
            if ( self.ignore_poi[i] == poi )
            {
                add_poi = false;
                break;
            }
        }
    }
 
    if ( add_poi )
    {
        self.ignore_poi[self.ignore_poi.size] = poi;
    }
}
 
 
//-------------------------------------------------------------------------------
// player should be within a couple feet of enemy   
//-------------------------------------------------------------------------------
function ‪default_validate_enemy_path_length( player )
{
    max_dist = 1296;
 
    d = DistanceSquared( self.origin, player.origin );
    if ( d <= max_dist )
    {
        return true;
    }
 
    return false;
}
 
function ‪get_closest_valid_player( origin, ignore_player )
{
    AIProfile_BeginEntry( "get_closest_valid_player" );
    
    valid_player_found = false;
    players = GetPlayers();
    
    if( isdefined( level.get_closest_valid_player_override ) )
    {
        players = [[ level.get_closest_valid_player_override ]]();
    }
    
    b_designated_target_exists = false;
    for(i = 0; i < players.size; i++ )
    {
        player = players[i];
 
        //if( !is_player_valid( players[i], true ) )
        if( !player.am_i_valid )
        {
            continue;
        }
 
        if( isDefined( level.evaluate_zone_path_override ) )
        {
            if( ![[ level.evaluate_zone_path_override ]]( player ) )
            {
                ‪array::add( ignore_player, player );
            }
        }
        
        // is any player a designated target?
        if( ‪IS_TRUE( player.b_is_designated_target ) )
        {
            b_designated_target_exists = true;
        }
    }
    
    if( IsDefined( ignore_player ) )
    {
        for(i = 0; i < ignore_player.size; i++ )
        {
            ArrayRemoveValue( players, ignore_player[i] );
        }
    }
 
    // pre-cull any players that are in last stand or not designated target when a designated target is present
    done = false; 
    while ( players.size && !done )
    {
        done = true;
        for(i = 0; i < players.size; i++ )
        {
            player = players[i];
            //if( !is_player_valid( player, true ) )
            if( !player.am_i_valid )
            {
                ArrayRemoveValue( players, player ); 
                done = false;
                break;
            }
            if( b_designated_target_exists && !‪IS_TRUE( player.b_is_designated_target ) )
            {
                ArrayRemoveValue( players, player ); 
                done = false;
                break;
            }
        }
    }
 
    if( players.size == 0 )
    {
        AIProfile_EndEntry();
        return undefined; 
    }
    
    while( !valid_player_found )
    {
        // find the closest player
        if( IsDefined( self.closest_player_override ) )
        {
            player = [[ self.closest_player_override ]]( origin, players );
        }
        else if( isdefined( level.closest_player_override ) )
        {
            player = [[ level.closest_player_override ]]( origin, players );
        }
        else
        {
            player = ArrayGetClosest( origin, players );
        } 
 
        if( !isdefined( player ) || players.size == 0 )
        {
            AIProfile_EndEntry();
            return undefined; 
        }
        
        if( ‪IS_TRUE(level.allow_zombie_to_target_ai) || ‪IS_TRUE(player.allow_zombie_to_target_ai) )
        {
            AIProfile_EndEntry();
            return player;
        }
 
        // make sure they're not a zombie or in last stand
        //if( !is_player_valid( player, true ) )
        if( !player.am_i_valid )
        {
            // unlikely to get here unless there is a wait in one of the closest player overrides
            ArrayRemoveValue( players, player ); 
            if( players.size == 0 )
            {
                AIProfile_EndEntry();
                return undefined;
            }
        
            continue;
        }
        
        AIProfile_EndEntry();
        return player; 
    }
}
 
//modified version of get_closest_valid_player that gives perfect info and sets up ignoreEnts to respect the ignore_player array.
 
function ‪update_valid_players( origin, ignore_player )
{
    AIProfile_BeginEntry( "update_valid_players" );
    
    valid_player_found = false;
    players = ArrayCopy( level.players ); // Have to use ArrayCopy otherwise the ArrayRemove calls below will remove the players from level.players
    
    //new zombie enemy selection
    foreach( player in players )
    {
        self SetIgnoreEnt( player, true );
    }
    
    b_designated_target_exists = false;
    for(i = 0; i < players.size; i++ )
    {
        player = players[i];
 
        //if( !is_player_valid( players[i], true ) )
        if( !player.am_i_valid )
        {
            continue;
        }
 
        if( isDefined( level.evaluate_zone_path_override ) )
        {
            if( ![[ level.evaluate_zone_path_override ]]( player ) )
            {
                ‪array::add( ignore_player, player );
            }
        }
        
        // is any player a designated target?
        if( ‪IS_TRUE( player.b_is_designated_target ) )
        {
            b_designated_target_exists = true;
        }
    }
    
    if( IsDefined( ignore_player ) )
    {
        for(i = 0; i < ignore_player.size; i++ )
        {
            ArrayRemoveValue( players, ignore_player[i] );
        }
    }
 
    // pre-cull any players that are in last stand or not designated target when a designated target is present
    done = false; 
    while ( players.size && !done )
    {
        done = true;
        for(i = 0; i < players.size; i++ )
        {
            player = players[i];
            //if( !is_player_valid( player, true ) )
            if( !player.am_i_valid )
            {
                ArrayRemoveValue( players, player ); 
                done = false;
                break;
            }
            if( b_designated_target_exists && !‪IS_TRUE( player.b_is_designated_target ) )
            {
                ArrayRemoveValue( players, player ); 
                done = false;
                break;
            }
        }
    }
    
    //new zombie enemy selection
    foreach( player in players )
    {
        self SetIgnoreEnt( player, false );
        self GetPerfectInfo( player );
    }
    
    AIProfile_EndEntry();
}
 
function ‪is_player_valid( player, checkIgnoreMeFlag,ignore_laststand_players )
{
    if( !IsDefined( player ) ) 
    {
        return false; 
    }
 
    if( !IsAlive( player ) )
    {
        return false; 
    } 
 
    if( !IsPlayer( player ) )
    {
        return false;
    }
 
    if( IsDefined(player.is_zombie) && player.is_zombie == true )
    {
        return false; 
    }
 
    if( player.sessionstate == "spectator" )
    {
        return false; 
    }
 
    if( player.sessionstate == "intermission" )
    {
        return false; 
    }
 
    if( ‪IS_TRUE( level.intermission ) )
    {
        return false;
    }
 
    if( !‪IS_TRUE( ignore_laststand_players ) )
    {
        if( player ‪laststand::player_is_in_laststand() )
        {
            return false; 
        }
    }
 
//T6.5todo  if ( player isnotarget() )
//T6.5todo  {
//T6.5todo      return false;
//T6.5todo  }
    
    //We only want to check this from the zombie attack script
    if( ‪IS_TRUE(checkIgnoreMeFlag) && player.ignoreme )
    {
        //IPrintLnBold(" ignore me ");
        return false;
    }
    
    //for additional level specific checks
    if( IsDefined( level.is_player_valid_override ) )
    {
        return [[ level.is_player_valid_override ]]( player );
    }
    
    return true; 
}
 
function ‪get_number_of_valid_players()
{
 
    players = GetPlayers();
    num_player_valid = 0;
    for( i = 0 ; i < players.size; i++ )
    {
        if( ‪is_player_valid( players[i] ) )
            num_player_valid += 1;
    }
 
    
    return num_player_valid;
 
 
 
}
 
function ‪in_revive_trigger()
{
    if (isdefined(self.rt_time) && self.rt_time + 100 >= GetTime())
        return self.in_rt_cached;
    self.rt_time = GetTime();
    
    players = level.players;    //GetPlayers();
    for( i = 0; i < players.size; i++ )
    {
        current_player = players[i];
 
        //if( !IsDefined( current_player )) || !IsAlive( current_player ) ) 
        //{
        //  continue; 
        //}
    
        if( IsDefined( current_player ) && IsDefined( current_player.revivetrigger ) && IsAlive( current_player ) )
        {
            if( self IsTouching( current_player.revivetrigger ) )
            {
                self.in_rt_cached = true;
                return true;
            }
        }
    }
 
    self.in_rt_cached = false;
    return false;
}
 
function ‪get_closest_node( org, nodes )
{
    return ArrayGetClosest( org, nodes ); 
}
 
// bars are not damaged pull them off now.
function ‪non_destroyed_bar_board_order( origin, chunks )
{
    //bars = getentarray("bar","script_parameters");
    first_bars = []; // first set of 2 bars to be removed
    first_bars1 = []; // Added single check when combined with wood
    first_bars2 = []; // Added single check when combined with wood
 
    //-------------------------BOARDS----------------------------------------------------------
    // If all boards do the old system
    for( i=0;i<chunks.size;i++ ) // Go through the array 
    {
        if (IsDefined ( chunks[i].script_team ) && ( chunks[i].script_team == "classic_boards" ) )
        {
            if (IsDefined (chunks[i].script_parameters) && (chunks[i].script_parameters == "board") )   
            {   
                return ‪get_closest_2d( origin, chunks );
            }               
            // I need to add a script name team regular boards
            else if (IsDefined ( chunks[i].script_team ) && chunks[i].script_team == "bar_board_variant1" || chunks[i].script_team == "bar_board_variant2" ||
            chunks[i].script_team == "bar_board_variant4" || chunks[i].script_team == "bar_board_variant5" )
            {   
                return undefined;
            }
        }
        // DCS: adding new variable to start with like new condition repaired with boards.
        else if(IsDefined(chunks[i].script_team ) && chunks[i].script_team == "new_barricade")
        {
            if(IsDefined(chunks[i].script_parameters) && (chunks[i].script_parameters == "repair_board" || chunks[i].script_parameters == "barricade_vents"))
            {
                return ‪get_closest_2d( origin, chunks );
            }
        }
    }
    //-------------------------BOARDS----------------------------------------------------------
 
    //-------------------------BARS------------------------------------------------------------
    for(i=0;i<chunks.size;i++) // Go through the array 
    {
        if ( IsDefined (chunks[i].script_team ) && ( chunks[i].script_team == "6_bars_bent" )  || ( chunks[i].script_team == "6_bars_prestine" ) )
        {
            if (IsDefined (chunks[i].script_parameters) && (chunks[i].script_parameters == "bar") )
            {   
                if(isDefined(chunks[i].script_noteworthy))
                {
                    if(chunks[i].script_noteworthy == "4" || chunks[i].script_noteworthy == "6" ) // this two are defined create a new array that just keeps track of them
                    {
                        first_bars[first_bars.size] = chunks[i]; // In total this should be a size of two
                    }
                }
            }
        }
    }
    
    for(i=0;i<first_bars.size;i++) // Jl added second check if there is only peace
    {
        if ( IsDefined (chunks[i].script_team ) && ( chunks[i].script_team == "6_bars_bent" )  || ( chunks[i].script_team == "6_bars_prestine" ) )
        {           
            if (IsDefined (chunks[i].script_parameters) && (chunks[i].script_parameters == "bar") )
            {   
                //send back the first bars that are NOT destroyed
                if( !first_bars[i].destroyed )
                {
                    return first_bars[i];
                }
            }
        }
    }
    
    // Grab the remaining bars that are the closest to the ai
    for(i=0;i<chunks.size;i++)
    {
        if ( IsDefined (chunks[i].script_team ) && ( chunks[i].script_team == "6_bars_bent" )  || ( chunks[i].script_team == "6_bars_prestine" ) )
        {   
        
            if (IsDefined (chunks[i].script_parameters) && (chunks[i].script_parameters == "bar") )
            {   
                if( !chunks[i].destroyed )
                {
                    return ‪get_closest_2d( origin, chunks );
                    //return chunks[i];
                }
            }
        }
    }
    //-------------------------BARS------------------------------------------------------------
}
 
 
function ‪non_destroyed_grate_order( origin, chunks_grate )
{
    //-------------------------GRATES----------------------------------------------------------
    grate_order = [];
    grate_order1 =[]; // this sets up the order for the grates
    grate_order2 =[]; // this sets up the order for the grates
    grate_order3 =[]; // this sets up the order for the grates
    grate_order4 =[]; // this sets up the order for the grates
    grate_order5 =[]; // this sets up the order for the grates
    grate_order6 =[]; // this sets up the order for the grates
 
    
    if ( IsDefined ( chunks_grate ) )
    {
        for(i=0;i<chunks_grate.size;i++) // Go through the array 
        {
            if (IsDefined (chunks_grate[i].script_parameters) && (chunks_grate[i].script_parameters == "grate") )
            {   
                //return grate_order[i];
                
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "1" ) )
                {
                        grate_order1[grate_order1.size] = chunks_grate[i];
                        // send back order here
                }
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "2" ) )
                {
                        grate_order2[grate_order2.size] = chunks_grate[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "3" ) )
                {
                        grate_order3[grate_order3.size] = chunks_grate[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "4" ) )
                {
                        grate_order4[grate_order4.size] = chunks_grate[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "5" ) )
                {
                        grate_order5[grate_order5.size] = chunks_grate[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_grate[i].script_noteworthy ) && ( chunks_grate[i].script_noteworthy == "6" ) )
                {
                        grate_order6[grate_order6.size] = chunks_grate[i];
                            // send back order here
                }
            }
        }
        
        
        // I need to make this function also tell which piece to move again.
        for(i=0;i<chunks_grate.size;i++) // Go through the array 
        {
            if (IsDefined ( chunks_grate[i].script_parameters ) && ( chunks_grate[i].script_parameters == "grate") )
            {   
                if ( IsDefined ( grate_order1[i] ) )
                {
                    if( ( grate_order1[i].state == "repaired" )  )
                    {
                        grate_order2[i] thread ‪show_grate_pull();
                        return grate_order1[i];
                    }
                    if(  ( grate_order2[i].state == "repaired" )  )
                    {
                        /#
                        IPrintLnBold(" pull bar2 ");
                        #/
                        grate_order3[i] thread ‪show_grate_pull(); 
                        return grate_order2[i];
                        
                    }
                    else if( ( grate_order3[i].state == "repaired" ) )
                    {
                        /#
                        IPrintLnBold(" pull bar3 ");
                        #/
                        grate_order4[i] thread ‪show_grate_pull();
                        return grate_order3[i];
                         
                    }
                    else if( ( grate_order4[i].state == "repaired" ) )
                    {
                        /#
                        IPrintLnBold(" pull bar4 ");
                        #/
                        grate_order5[i] thread ‪show_grate_pull();
                        return grate_order4[i];
                    }
                    else if( ( grate_order5[i].state == "repaired" ) )
                    {
                        /#
                        IPrintLnBold(" pull bar5 ");
                        #/
                        grate_order6[i] thread ‪show_grate_pull();
                        return grate_order5[i];
                    }
                    else if( ( grate_order6[i].state == "repaired" ) )
                    {
                        // I need to return nothing here.
                        //return undefined();
                        return grate_order6[i];
                    }
                }
            }
        }
    }
    //-------------------------GRATES----------------------------------------------------------
}
 
//
// A seperate function is needed for each variant because there are different pull down and repair orders for each
// Also I had to add extra strings to idetify combined pieces that used the same script_noteworthy
//
// variant1 
function ‪non_destroyed_variant1_order( origin, chunks_variant1 )
{
    //-------------------------VARIANT1----------------------------------------------------------
    variant1_order = [];
    variant1_order1 =[]; // this sets up the order for the grates
    variant1_order2 =[]; // this sets up the order for the grates
    variant1_order3 =[]; // this sets up the order for the grates
    variant1_order4 =[]; // this sets up the order for the grates
    variant1_order5 =[]; // this sets up the order for the grates
    variant1_order6 =[]; // this sets up the order for the grates
 
    
    if ( IsDefined ( chunks_variant1 ) )
    {
        for(i=0;i<chunks_variant1.size;i++) // Go through the array 
        {
            if (IsDefined (chunks_variant1[i].script_team) && (chunks_variant1[i].script_team == "bar_board_variant1") )
            {   
                //return grate_order[i];
                
                if ( IsDefined ( chunks_variant1[i].script_noteworthy ) )
                {
                    if ( chunks_variant1[i].script_noteworthy == "1" )
                    {
                        variant1_order1[variant1_order1.size] = chunks_variant1[i];
                    }
                    if ( chunks_variant1[i].script_noteworthy == "2" )
                    {
                        variant1_order2[variant1_order2.size] = chunks_variant1[i];
                    }
                    if ( chunks_variant1[i].script_noteworthy == "3" )
                    {
                        variant1_order3[variant1_order3.size] = chunks_variant1[i];
                    }
                    if ( chunks_variant1[i].script_noteworthy == "4" )
                    {
                        variant1_order4[variant1_order4.size] = chunks_variant1[i];
                    }
                    if ( chunks_variant1[i].script_noteworthy == "5" )
                    {
                        variant1_order5[variant1_order5.size] = chunks_variant1[i];
                    }
                    if ( chunks_variant1[i].script_noteworthy == "6" )
                    {
                        variant1_order6[variant1_order6.size] = chunks_variant1[i];                     
                    }
                }
            }
        }
        
        
        // This needs a different order
        for(i=0;i<chunks_variant1.size;i++) // Go through the array 
        {
            if (IsDefined ( chunks_variant1[i].script_team ) && ( chunks_variant1[i].script_team == "bar_board_variant1") )
            {   
                if( IsDefined ( variant1_order2[i] ) )
                {
                    if( ( variant1_order2[i].state == "repaired" )  )
                    {
                        return variant1_order2[i];
                    }
                    else if(  ( variant1_order3[i].state == "repaired" ) )
                    {
                        return variant1_order3[i];
                    }
                    else if( ( variant1_order4[i].state == "repaired" ) )
                    {
                        return variant1_order4[i]; 
                    }
                    else if( ( variant1_order6[i].state == "repaired" ) )
                    {
                        return variant1_order6[i];
                    }
                    else if( ( variant1_order5[i].state == "repaired" ) )
                    {
                        return variant1_order5[i];
                    }
                    else if( ( variant1_order1[i].state == "repaired" ) )
                    {
                        return variant1_order1[i];
                    }
                }
            }
        }
    }
    
    //if( chunks_variant1.size == 0 )
    //{
    //  return undefined; // If there are no more pieces left then don't allow it to continue
    //}
    //-------------------------VARIANT1----------------------------------------------------------
}
 
// variant2
function ‪non_destroyed_variant2_order( origin, chunks_variant2 )
{
    //-------------------------VARIENT2----------------------------------------------------------
    variant2_order = [];
    variant2_order1 =[]; // this sets up the order for the grates
    variant2_order2 =[]; // this sets up the order for the grates
    variant2_order3 =[]; // this sets up the order for the grates
    variant2_order4 =[]; // this sets up the order for the grates
    variant2_order5 =[]; // this sets up the order for the grates
    variant2_order6 =[]; // this sets up the order for the grates
 
    
    if ( IsDefined ( chunks_variant2 ) )
    {
        for(i=0;i<chunks_variant2.size;i++) // Go through the array 
        {
            if (IsDefined (chunks_variant2[i].script_team) && (chunks_variant2[i].script_team == "bar_board_variant2") )
            {   
                //return grate_order[i];
                
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "1" ) )
                {
                        variant2_order1[variant2_order1.size] = chunks_variant2[i];
                        // send back order here
                }
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "2" ) )
                {
                        variant2_order2[variant2_order2.size] = chunks_variant2[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "3" ) )
                {
                        variant2_order3[variant2_order3.size] = chunks_variant2[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "4" ) )
                {
                        variant2_order4[variant2_order4.size] = chunks_variant2[i];
                            // send back order here
                }
                // I had to add another string to check against out of order noteworthy when combining board and wood
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "5" ) && IsDefined( chunks_variant2[i].script_location ) && (chunks_variant2[i].script_location == "5") )
                {
                        variant2_order5[variant2_order5.size] = chunks_variant2[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant2[i].script_noteworthy ) && ( chunks_variant2[i].script_noteworthy == "5" ) && IsDefined( chunks_variant2[i].script_location ) && (chunks_variant2[i].script_location == "6") )
                {
                        variant2_order6[variant2_order6.size] = chunks_variant2[i];
                            // send back order here
                }
            }
        }   
        
        // There is a different pull order for every variant
        for(i=0;i<chunks_variant2.size;i++) // Go through the array 
        {
            if (IsDefined ( chunks_variant2[i].script_team ) && ( chunks_variant2[i].script_team == "bar_board_variant2") )
            {   
                if( IsDefined ( variant2_order1[i] ) )
                {   
                    if( ( variant2_order1[i].state == "repaired" ) )
                    {
                        return variant2_order1[i];
                    }
                    else if(  ( variant2_order2[i].state == "repaired" ) )
                    {
                        return variant2_order2[i];
                    }
                    else if( ( variant2_order3[i].state == "repaired" ) )
                    {
                        return variant2_order3[i]; 
                    }
                    else if( ( variant2_order5[i].state == "repaired" ) )
                    {
                        return variant2_order5[i];
                    }
                    else if( ( variant2_order4[i].state == "repaired" ) )
                    {
                        return variant2_order4[i];
                    }
                    else if( ( variant2_order6[i].state == "repaired" ) )
                    {
                        return variant2_order6[i];
                    }
                }
            }
        }
    }
    //-------------------------VARIENT2----------------------------------------------------------
}
 
// variant4
function ‪non_destroyed_variant4_order( origin, chunks_variant4 )
{
    //-------------------------VARIENT4----------------------------------------------------------
    variant4_order = [];
    variant4_order1 =[]; // this sets up the order for the grates
    variant4_order2 =[]; // this sets up the order for the grates
    variant4_order3 =[]; // this sets up the order for the grates
    variant4_order4 =[]; // this sets up the order for the grates
    variant4_order5 =[]; // this sets up the order for the grates
    variant4_order6 =[]; // this sets up the order for the grates
 
    
    if ( IsDefined ( chunks_variant4 ) )
    {
        for(i=0;i<chunks_variant4.size;i++) // Go through the array 
        {
            if (IsDefined (chunks_variant4[i].script_team) && (chunks_variant4[i].script_team == "bar_board_variant4") )
            {   
                //return grate_order[i];
                
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "1" ) && !IsDefined( chunks_variant4[i].script_location ) )
                {
                        variant4_order1[variant4_order1.size] = chunks_variant4[i]; 
                        // send back order here
                }
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "2" ) ) 
                {
                        variant4_order2[variant4_order2.size] = chunks_variant4[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "3" ) ) 
                {
                        variant4_order3[variant4_order3.size] = chunks_variant4[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "1" ) && IsDefined( chunks_variant4[i].script_location ) && (chunks_variant4[i].script_location == "3") )
                {
                        variant4_order4[variant4_order4.size] = chunks_variant4[i];
                        // send back order here
                }
                // There isn't a noteworthy 4
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "5" ) )
                {
                        variant4_order5[variant4_order5.size] = chunks_variant4[i];
                            // send back order here
                }
                if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "6" ) )
                {
                        variant4_order6[variant4_order6.size] = chunks_variant4[i];
                            // send back order here
                }
            }
        }   
        
        // There is a different pull order for every variant
        for(i=0;i<chunks_variant4.size;i++) // Go through the array 
        {
            if (IsDefined ( chunks_variant4[i].script_team ) && ( chunks_variant4[i].script_team == "bar_board_variant4") )
            {   
                if( IsDefined ( variant4_order1[i] ) ) // last one here
                {   
                    if( ( variant4_order1[i].state == "repaired" ) )
                    {
                        return variant4_order1[i];
                    }
                    else if(  ( variant4_order6[i].state == "repaired" ) )
                    {
                        return variant4_order6[i];
                    }
                    else if( ( variant4_order3[i].state == "repaired" ) )
                    {
                        return variant4_order3[i]; 
                    }
                    else if( ( variant4_order4[i].state == "repaired" ) ) // second one
                    {
                        return variant4_order4[i];
                    }
                    else if( ( variant4_order2[i].state == "repaired" ) )
                    {
                        return variant4_order2[i];
                    }
                    else if( ( variant4_order5[i].state == "repaired" ) )
                    {
                        return variant4_order5[i];
                    }
                }
            }
        }
    }
    //-------------------------Variant2----------------------------------------------------------
}
 
// variant5 
function ‪non_destroyed_variant5_order( origin, chunks_variant5 )
{
    //-------------------------VARIANT5----------------------------------------------------------
    variant5_order = [];
    variant5_order1 =[]; // this sets up the order for the grates
    variant5_order2 =[]; // this sets up the order for the grates
    variant5_order3 =[]; // this sets up the order for the grates
    variant5_order4 =[]; // this sets up the order for the grates
    variant5_order5 =[]; // this sets up the order for the grates
    variant5_order6 =[]; // this sets up the order for the grates
 
    
    if ( IsDefined ( chunks_variant5 ) )
    {
        for(i=0;i<chunks_variant5.size;i++) // Go through the array 
        {
            if (IsDefined (chunks_variant5[i].script_team) && (chunks_variant5[i].script_team == "bar_board_variant5") )
            {   
                //return grate_order[i];
                if ( IsDefined ( chunks_variant5[i].script_noteworthy ) )
                {
                    // if ( IsDefined ( chunks_variant4[i].script_noteworthy ) && ( chunks_variant4[i].script_noteworthy == "1" ) && !IsDefined( chunks_variant4[i].script_location ) )
                    if ( ( chunks_variant5[i].script_noteworthy == "1" ) && !IsDefined( chunks_variant5[i].script_location ) )
                    {
                        variant5_order1[variant5_order1.size] = chunks_variant5[i];
                    }
                    if ( chunks_variant5[i].script_noteworthy == "2" )
                    {
                        variant5_order2[variant5_order2.size] = chunks_variant5[i];
                    }
                    if ( IsDefined ( chunks_variant5[i].script_noteworthy ) && ( chunks_variant5[i].script_noteworthy == "1" ) && IsDefined( chunks_variant5[i].script_location ) && (chunks_variant5[i].script_location == "3") )
                    {
                        variant5_order3[variant5_order3.size] = chunks_variant5[i];
                    }
                    if ( chunks_variant5[i].script_noteworthy == "4" )
                    {
                        variant5_order4[variant5_order4.size] = chunks_variant5[i];
                    }
                    if ( chunks_variant5[i].script_noteworthy == "5" )
                    {
                        variant5_order5[variant5_order5.size] = chunks_variant5[i];
                    }
                    if ( chunks_variant5[i].script_noteworthy == "6" )
                    {
                        variant5_order6[variant5_order6.size] = chunks_variant5[i];                     
                    }
                }
            }
        }   
        for(i=0;i<chunks_variant5.size;i++) // Go through the array 
        {
            if (IsDefined ( chunks_variant5[i].script_team ) && ( chunks_variant5[i].script_team == "bar_board_variant5") )
            {   
                if( IsDefined ( variant5_order1[i] ) )
                {
                    if( ( variant5_order1[i].state == "repaired" )  )
                    {
                        return variant5_order1[i];
                    }
                    else if(  ( variant5_order6[i].state == "repaired" ) )
                    {
                        return variant5_order6[i];
                    }
                    else if( ( variant5_order3[i].state == "repaired" ) )
                    {
                        return variant5_order3[i]; 
                    }
                    else if( ( variant5_order2[i].state == "repaired" ) )
                    {
                        return variant5_order2[i];
                    }
                    else if( ( variant5_order5[i].state == "repaired" ) )
                    {
                        return variant5_order5[i];
                    }
                    else if( ( variant5_order4[i].state == "repaired" ) )
                    {
                        return variant5_order4[i];
                    }
                }
            }
        }
    }
    //-------------------------VARIANT5----------------------------------------------------------
}
 
function ‪show_grate_pull()
{
    wait(0.53);
    self Show();
    self vibrate(( 0, 270, 0 ), 0.2, 0.4, 0.4);
    // I could fx and sound from here as well.
}
 
 
function ‪get_closest_2d( origin, ents )
{
    if( !IsDefined( ents ) )
    {
        return undefined; 
    }
    
    dist = Distance2d( origin, ents[0].origin ); 
    index = 0; 
    temp_array = [];
        
    for( i = 1; i < ents.size; i++ )
    {
        if(IsDefined(ents[i].unbroken) && ents[i].unbroken == true)
        {
            ents[i].index = i; 
            ‪ARRAY_ADD(temp_array, ents[i]);
        }
    }   
 
    if(temp_array.size > 0)
    {
        index = temp_array[RandomIntRange(0, temp_array.size)].index; // must pick unbroken piece first! 
        return ents[index]; 
    }
    else
    {       
        for( i = 1; i < ents.size; i++ )
        {
            temp_dist = Distance2d( origin, ents[i].origin ); 
            if( temp_dist < dist )
            {
                dist = temp_dist; 
                index = i; 
            }
        }
        return ents[index]; 
    }
}
 
//edge_fog_start()
//{
//  playpoint = struct::get( "edge_fog_start", "targetname" ); 
//
//  if( !IsDefined( playpoint ) )
//  {
//      
//  } 
//  
//  while( isdefined( playpoint ) )
//  {
//      playfx( level._effect["edge_fog"], playpoint.origin ); 
//      
//      if( !isdefined( playpoint.target ) )
//      {
//          return; 
//      }
//      
//      playpoint = struct::get( playpoint.target, "targetname" ); 
//  }
//}
 
 
//chris_p - fix bug with this not being an ent array!
function ‪in_playable_area()
{
    playable_area = getentarray("player_volume","script_noteworthy");
 
    if( !IsDefined( playable_area ) )
    {
    /#  println( "No playable area playable_area found! Assume EVERYWHERE is PLAYABLE" );   #/
        return true;
    }
    
    for(i=0;i<playable_area.size;i++)
    {
 
        if( self IsTouching( playable_area[i] ) )
        {
            return true;
        }
    }
 
    return false;
}
 
// I beleive this is where I can do the check to see what 
// barrier_chunks is the total amount of bars or boards that the exterior_goal was connected to. 
function ‪get_closest_non_destroyed_chunk( origin, barrier, barrier_chunks ) 
{
    chunks = undefined; 
    chunks_grate = undefined;
    
    // This returns only if grate is defined
    chunks_grate = ‪get_non_destroyed_chunks_grate( barrier, barrier_chunks );
    
    // This grabs classic boards, 6 bar prestine set and 6 bar bent set
    chunks = ‪get_non_destroyed_chunks( barrier, barrier_chunks ); // Grab all the chunks that are repaired
 
    if(isdefined(barrier.zbarrier))
    {
        if(isdefined(chunks))
        {
            return array::randomize(chunks)[0];
        }
        
        if(isdefined(chunks_grate))
        {
            return array::randomize(chunks_grate)[0];
        }
    }
    else
    {
        // This returns an array of what chunks can be pulled
        
        if( IsDefined( chunks ) ) // && IsDefined ( chunks.script_parameters ) && chunks.script_parameters == "board" ) 
        {
                    // Jl This was the original call
                    // return get_closest_2d( origin, chunks ); 
            return ‪non_destroyed_bar_board_order ( origin, chunks ); // Go through all the repaired chunk pieces
        }
        
        else if ( IsDefined ( chunks_grate ) )
        {
            return  ‪non_destroyed_grate_order ( origin, chunks_grate ); // Go through all the repaired chunk pices
        }
    }
    
    return undefined; 
}
 
 
// Jluyties barrier_chunks is the total amount of bars or boards that the exterior_goal was connected to 
// The grates do not return random
function ‪get_random_destroyed_chunk( barrier, barrier_chunks )
{
    if(isdefined(barrier.zbarrier))
    {
        ret = undefined;
        
        pieces = barrier.zbarrier GetZBarrierPieceIndicesInState("open");
        
        if(pieces.size)
        {
            ret = array::randomize(pieces)[0];
        }
        
        return ret;
    }
    else
    {
        chunk = undefined; 
        chunks_repair_grate = undefined;
    
    
        chunks = ‪get_destroyed_chunks( barrier_chunks );
    
        chunks_repair_grate = ‪get_destroyed_repair_grates ( barrier_chunks );
    
    // for(i = 0; i < chunks.size; i++ )
        
        if ( IsDefined( chunks )  )
        {
            return chunks[RandomInt( chunks.size )]; 
            //return get_destroyed_chunks_without_grate ( chunks );
        } 
    
        else if( IsDefined( chunks_repair_grate ) )
        {
            return ‪grate_order_destroyed ( chunks_repair_grate );
        }
        
        return undefined; 
    }
}
 
function ‪get_destroyed_repair_grates( barrier_chunks )
{
    // I may have to do my check here
    ‪array = []; // Setup array
    for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
    {           
        if( IsDefined ( barrier_chunks[i] ) )
        {
            if( IsDefined ( barrier_chunks[i].script_parameters ) && ( barrier_chunks[i].script_parameters == "grate" ) )
            {
                ‪array[‪array.size] = barrier_chunks[i];  
            }
        }
    }
 
    if( ‪array.size == 0 )
    {
        return undefined; // If there are no more pieces left then don't allow it to continue
    }
 
    return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
}
 
 
// this is the layer I want to do the check
// I need to define each part of 
function ‪get_non_destroyed_chunks( barrier, barrier_chunks )
{
    if(isdefined(barrier.zbarrier))
    {
        return barrier.zbarrier GetZBarrierPieceIndicesInState("closed");
    }
    else
    {
        ‪array = []; // Setup array
        for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
        {   
            if(IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "classic_boards") )
            {
                if (IsDefined (barrier_chunks[i].script_parameters) && (barrier_chunks[i].script_parameters == "board") )       
                {               
                    if( barrier_chunks[i] ‪get_chunk_state() == "repaired" ) // If the state of the chunk is repaired then continue
                    {
                        if( barrier_chunks[i].origin == barrier_chunks[i].og_origin ) // If this chunk has its original origin then continue
                        {
                            ‪array[‪array.size] = barrier_chunks[i]; // 
                        }
                    }
                }
            }
            //DCS: new barricade added for pentagon.
            if(IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "new_barricade") )
            {
                if(IsDefined(barrier_chunks[i].script_parameters) && (barrier_chunks[i].script_parameters == "repair_board" || barrier_chunks[i].script_parameters == "barricade_vents"))
                {               
                    if( barrier_chunks[i] ‪get_chunk_state() == "repaired" ) // If the state of the chunk is repaired then continue
                    {
                        if( barrier_chunks[i].origin == barrier_chunks[i].og_origin ) // If this chunk has its original origin then continue
                        {
                            ‪array[‪array.size] = barrier_chunks[i]; // 
                        }
                    }
                }
            }       
            
            else if ( IsDefined (barrier_chunks[i].script_team ) && ( barrier_chunks[i].script_team == "6_bars_bent" ) )
            {
                if (IsDefined (barrier_chunks[i].script_parameters) &&  (barrier_chunks[i].script_parameters == "bar") )            
                {
                    if( barrier_chunks[i] ‪get_chunk_state() == "repaired" ) // If the state of the chunk is repaired then continue
                    {
        
                        if( barrier_chunks[i].origin == barrier_chunks[i].og_origin ) // If this chunk has its original origin then continue
                        {
                            ‪array[‪array.size] = barrier_chunks[i]; // 
                        }
                    }
                }
            }
            
            else if ( IsDefined (barrier_chunks[i].script_team ) && ( barrier_chunks[i].script_team == "6_bars_prestine" ) )
            {
                if (IsDefined (barrier_chunks[i].script_parameters) &&  (barrier_chunks[i].script_parameters == "bar") )            
                {
                    if( barrier_chunks[i] ‪get_chunk_state() == "repaired" ) // If the state of the chunk is repaired then continue
                    {
        
                        if( barrier_chunks[i].origin == barrier_chunks[i].og_origin ) // If this chunk has its original origin then continue
                        {
                            ‪array[‪array.size] = barrier_chunks[i]; // 
                        }
                    }
                }
            }
        }
    
        if( ‪array.size == 0 )
        {
            return undefined; // If there are no more pieces left then don't allow it to continue
        }
    
        return ‪array; // send back state of array 
    }
}
 
function ‪get_non_destroyed_chunks_grate( barrier, barrier_chunks )
{
    if(isdefined(barrier.zbarrier))
    {
        return barrier.zbarrier GetZBarrierPieceIndicesInState("closed");
    }
    else
    {
        ‪array = []; // Setup array
        for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
        {
            if (IsDefined (barrier_chunks[i].script_parameters) && (barrier_chunks[i].script_parameters == "grate") )
            {   
                if( IsDefined ( barrier_chunks[i] ) )
                {
                    ‪array[‪array.size] = barrier_chunks[i]; // 
                }
            }
        }
    
        if( ‪array.size == 0 )
        {
            return undefined; // If there are no more pieces left then don't allow it to continue
        }
    
        return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
    }
}
 
function ‪get_non_destroyed_variant1( barrier_chunks )
{
    ‪array = []; // Setup array
    for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
    {
        if (IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "bar_board_variant1") )
        {   
            if( IsDefined ( barrier_chunks[i] ) )
            {
                ‪array[‪array.size] = barrier_chunks[i];  
            }
        }
    }
 
    if( ‪array.size == 0 )
    {
        return undefined; // If there are no more pieces left then don't allow it to continue
    }
 
    return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
}
 
function ‪get_non_destroyed_variant2( barrier_chunks )
{
    ‪array = []; // Setup array
    for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
    {
        if (IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "bar_board_variant2") )
        {   
            if( IsDefined ( barrier_chunks[i] ) )
            {
                ‪array[‪array.size] = barrier_chunks[i];  
            }
        }
    }
 
    if( ‪array.size == 0 )
    {
        return undefined; // If there are no more pieces left then don't allow it to continue
    }
 
    return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
}
 
function ‪get_non_destroyed_variant4( barrier_chunks )
{
    ‪array = []; // Setup array
    for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
    {
        if (IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "bar_board_variant4") )
        {   
            if( IsDefined ( barrier_chunks[i] ) )
            {
                ‪array[‪array.size] = barrier_chunks[i]; // 
            }
        }
    }
 
    if( ‪array.size == 0 )
    {
        return undefined; // If there are no more pieces left then don't allow it to continue
    }
 
    return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
}
 
function ‪get_non_destroyed_variant5( barrier_chunks )
{
    ‪array = []; // Setup array
    for( i = 0; i < barrier_chunks.size; i++ ) // Cycle through and grab all chunks
    {
        if (IsDefined (barrier_chunks[i].script_team) && (barrier_chunks[i].script_team == "bar_board_variant5") )
        {   
            if( IsDefined ( barrier_chunks[i] ) )
            {
                ‪array[‪array.size] = barrier_chunks[i]; // 
            }
        }
    }
 
    if( ‪array.size == 0 )
    {
        return undefined; // If there are no more pieces left then don't allow it to continue
    }
 
    return ‪array; // send back state of array so it knows if boards are full or note and which board it is.
}
 
function ‪get_destroyed_chunks( barrier_chunks )
{
    ‪array = []; 
    for( i = 0; i < barrier_chunks.size; i++ )
    {
        if( barrier_chunks[i] ‪get_chunk_state() == "destroyed" ) // if the chunks state says it is destroyed then continue
        {
            if (IsDefined (barrier_chunks[i].script_parameters) && barrier_chunks[i].script_parameters == "board")
            {           
                ‪array[‪array.size] = barrier_chunks[i]; // create a new array from barrier chunks
            }
            else if (IsDefined (barrier_chunks[i].script_parameters) && barrier_chunks[i].script_parameters == "repair_board" || barrier_chunks[i].script_parameters == "barricade_vents")
            {           
                ‪array[‪array.size] = barrier_chunks[i]; // create a new array from barrier chunks
            }
            else if (IsDefined (barrier_chunks[i].script_parameters) && (barrier_chunks[i].script_parameters == "bar") )
            {
                ‪array[‪array.size] = barrier_chunks[i]; // create a new array from barrier chunks
            }   
            
            else if (IsDefined (barrier_chunks[i].script_parameters) && (barrier_chunks[i].script_parameters == "grate") )
            {
                // This makes sure that it isn't returned
                return undefined;
                //array[array.size] = barrier_chunks[i]; // create a new array from barrier chunks
            }   
        }
    }
    
    if( ‪array.size == 0 )
    {
        return undefined;
    }
    
    return ‪array;
    
    //if( IsDefined( barrier_chunks ) )
    //{
    //  return barrier_chunks; 
    //}
}
 
 
function ‪grate_order_destroyed( chunks_repair_grate )
{
    grate_repair_order = [];
    grate_repair_order1 =[]; // this sets up the order for the grates
    grate_repair_order2 =[]; // this sets up the order for the grates
    grate_repair_order3 =[]; // this sets up the order for the grates
    grate_repair_order4 =[]; // this sets up the order for the grates
    grate_repair_order5 =[]; // this sets up the order for the grates
    grate_repair_order6 =[]; // this sets up the order for the grates
    
    
    // DEBUG
    /*
    for(i=0;i<chunks_repair_grate.size;i++) // Go through the array 
    {
        if (IsDefined (chunks_repair_grate[i].script_parameters) && (chunks_repair_grate[i].script_parameters == "grate") )
        {   
            grate_repair_order[grate_repair_order.size] = chunks_repair_grate[i]; // now chunks is the total amount of grates connecte
        }
    }
    */
    
    for(i=0;i<chunks_repair_grate.size;i++)
    {
        if (IsDefined (chunks_repair_grate[i].script_parameters) && (chunks_repair_grate[i].script_parameters == "grate") )
        {   
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "1" ) )
            {
                    grate_repair_order1[grate_repair_order1.size] = chunks_repair_grate[i];
                    // send back order here
            }
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "2" ) )
            {
                    grate_repair_order2[grate_repair_order2.size] = chunks_repair_grate[i];
                        // send back order here
            }
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "3" ) )
            {
                    grate_repair_order3[grate_repair_order3.size] = chunks_repair_grate[i];
                        // send back order here
            }
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "4" ) )
            {
                    grate_repair_order4[grate_repair_order4.size] = chunks_repair_grate[i];
                        // send back order here
            }
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "5" ) )
            {
                    grate_repair_order5[grate_repair_order5.size] = chunks_repair_grate[i];
                        // send back order here
            }
            if ( IsDefined ( chunks_repair_grate[i].script_noteworthy ) && ( chunks_repair_grate[i].script_noteworthy == "6" ) )
            {
                    grate_repair_order6[grate_repair_order6.size] = chunks_repair_grate[i];
                        // send back order here
            }
        }
    }
    
    for(i=0;i<chunks_repair_grate.size;i++) // Go through the array 
    {
        if (IsDefined (chunks_repair_grate[i].script_parameters) && (chunks_repair_grate[i].script_parameters == "grate") )
        {   
            if( IsDefined ( grate_repair_order1[i] ) ) // last one here
            {   
            
                if( ( grate_repair_order6[i].state == "destroyed" )  )
                    {
                            /#
                            IPrintLnBold(" Fix grate6 ");
                            #/
                                // Here I will tell the other board to replace      
                            return grate_repair_order6[i];
                    }
                    if(  ( grate_repair_order5[i].state == "destroyed" )  )
                    {
                        /#
                        IPrintLnBold(" Fix grate5 ");
                        #/
                        grate_repair_order6[i] thread ‪show_grate_repair();      
                        return grate_repair_order5[i];
                    }
                    else if( ( grate_repair_order4[i].state == "destroyed" ) )
                    {
                        /#
                        IPrintLnBold(" Fix grate4 ");
                        #/
                        grate_repair_order5[i] thread ‪show_grate_repair();  
                        return grate_repair_order4[i];
                    }
                    else if( ( grate_repair_order3[i].state == "destroyed" ) )
                    {
                        /#
                        IPrintLnBold(" Fix grate3 ");
                        #/
                        grate_repair_order4[i] thread ‪show_grate_repair();  
                        return grate_repair_order3[i];
                    }
                    else if( ( grate_repair_order2[i].state == "destroyed" ) )
                    {
                        /#
                        IPrintLnBold(" Fix grate2 ");
                        #/
                        grate_repair_order3[i] thread ‪show_grate_repair();  
                        return grate_repair_order2[i];
                    }
                    else if( ( grate_repair_order1[i].state == "destroyed" ) )
                    {
                        /#
                        IPrintLnBold(" Fix grate1 ");
                        #/
                        grate_repair_order2[i] thread ‪show_grate_repair();  
                        // I need to return nothing here.
                        //return undefined();
                        return grate_repair_order1[i];
                    }
            }
        }
    }
}
 
// Self is grate
function ‪show_grate_repair()
{
    wait( 0.34 );
    self Hide();
}
 
function ‪get_chunk_state()
{
    assert( isdefined( self.state ) );
 
    return self.state;
}
 
function ‪array_limiter( ‪array, total )
{
    new_array = []; 
 
    for( i = 0; i < ‪array.size; i++ )
    {
        if( i < total )
        {
            new_array[new_array.size] = ‪array[i]; 
        }
    }
 
    return new_array; 
}
 
 
function ‪fake_physicslaunch( target_pos, power )
{
    start_pos = self.origin; 
    
    // Reverse the gravity so it's negative, you could change the gravity
    // by just putting a number in there, but if you keep the dvar, then the
    // user will see it change.
    gravity = GetDvarInt( "bg_gravity" ) * -1; 
 
    dist = Distance( start_pos, target_pos ); 
    
    time = dist / power; 
    delta = target_pos - start_pos; 
    drop = 0.5 * gravity *( time * time ); 
    
    velocity = ( ( delta[0] / time ), ( delta[1] / time ), ( delta[2] - drop ) / time ); 
 
    level thread ‪draw_line_ent_to_pos( self, target_pos );
    self MoveGravity( velocity, time );
    return time;
}
 
//
// STRINGS ======================================================================= 
// 
function ‪add_zombie_hint( ref, text )
{
    if( !IsDefined( level.zombie_hints ) )
    {
        level.zombie_hints = []; 
    }
 
    level.zombie_hints[ref] = text; 
}
 
function ‪get_zombie_hint( ref )
{
    if( IsDefined( level.zombie_hints[ref] ) )
    {
        return level.zombie_hints[ref]; 
    }
 
/#
    println( "UNABLE TO FIND HINT STRING " + ref ); 
#/
    return level.zombie_hints["undefined"]; 
}
 
// self is the trigger( usually spawned in on the fly )
// ent is the entity that has the script_hint info
function ‪set_hint_string( ent, default_ref, cost )
{
    ref = default_ref;
    if( IsDefined( ent.script_hint ) )
    {
        ref = ent.script_hint;
    }
    if ( ‪IS_TRUE( level.legacy_hint_system ) ) // T7TODO - this can be deleted
    {
        ref = ref + "_" + cost;
        self SetHintString( ‪get_zombie_hint( ref ) ); 
    }
    else
    {
        hint = ‪get_zombie_hint( ref );
        if (IsDefined(cost))
        {
            self SetHintString( hint, cost ); 
        }
        else
        {
            self SetHintString( hint ); 
        }
    }
}
 
function ‪get_hint_string(ent, default_ref, cost )
{
    ref = default_ref;
    if( IsDefined( ent.script_hint ) )
    {
        ref = ent.script_hint;
    }
    if ( ‪IS_TRUE( level.legacy_hint_system ) && IsDefined(cost) ) // T7TODO - this can be deleted
    {
        ref = ref + "_" + cost;
    }
    return ‪get_zombie_hint( ref );
}
 
function ‪unitrigger_set_hint_string( ent, default_ref, cost )
{
    triggers=[];
    if(self.trigger_per_player)
    {
        triggers = self.playertrigger;
    }
    else
    {
        triggers[0] = self.trigger;
    }
    foreach(trigger in triggers)
    {
        ref = default_ref;
        if( IsDefined( ent.script_hint ) )
        {
            ref = ent.script_hint;
        }
        if ( ‪IS_TRUE( level.legacy_hint_system ) ) // T7TODO - this can be deleted
        {
            ref = ref + "_" + cost;
            trigger SetHintString( ‪get_zombie_hint( ref ) ); 
        }
        else
        {
            hint = ‪get_zombie_hint( ref );
            if (IsDefined(cost))
            {
                trigger SetHintString( hint, cost ); 
            }
            else
            {
                trigger SetHintString( hint ); 
            }
        }
    }
}
 
//
// SOUNDS =========================================================== 
// 
 
function ‪add_sound( ref, alias )
{
    if( !IsDefined( level.zombie_sounds ) )
    {
        level.zombie_sounds = []; 
    }
 
    level.zombie_sounds[ref] = alias; 
}
 
function ‪play_sound_at_pos( ref, pos, ent )
{
    if( IsDefined( ent ) )
    {
        if( IsDefined( ent.script_soundalias ) )
        {
            PlaySoundAtPosition( ent.script_soundalias, pos ); 
            return;
        }
 
        if( IsDefined( self.script_sound ) )
        {
            ref = self.script_sound; 
        }
    }
 
    if( ref == "none" )
    {
        return; 
    }
 
    if( !IsDefined( level.zombie_sounds[ref] ) )
    {
        AssertMsg( "Sound \"" + ref + "\" was not put to the zombie sounds list, please use add_sound( ref, alias ) at the start of your level." ); 
        return; 
    }
    
    PlaySoundAtPosition( level.zombie_sounds[ref], pos ); 
}
 
function ‪play_sound_on_ent( ref )
{
    if( IsDefined( self.script_soundalias ) )
    {
        self PlaySound( self.script_soundalias ); 
        return;
    }
 
    if( IsDefined( self.script_sound ) )
    {
        ref = self.script_sound; 
    }
 
    if( ref == "none" )
    {
        return; 
    }
 
    if( !IsDefined( level.zombie_sounds[ref] ) )
    {
        AssertMsg( "Sound \"" + ref + "\" was not put to the zombie sounds list, please use add_sound( ref, alias ) at the start of your level." ); 
        return; 
    }
 
    self PlaySound( level.zombie_sounds[ref] ); 
}
 
function ‪play_loopsound_on_ent( ref )
{
    if( IsDefined( self.script_firefxsound ) )
    {
        ref = self.script_firefxsound; 
    }
 
    if( ref == "none" )
    {
        return; 
    }
 
    if( !IsDefined( level.zombie_sounds[ref] ) )
    {
        AssertMsg( "Sound \"" + ref + "\" was not put to the zombie sounds list, please use add_sound( ref, alias ) at the start of your level." ); 
        return; 
    }
 
    self PlaySound( level.zombie_sounds[ref] ); 
}
 
 
function ‪string_to_float( string )
{
    floatParts = strTok( string, "." );
    if ( floatParts.size == 1 )
        return int(floatParts[0]);
 
    whole = int(floatParts[0]);
    // Convert the decimal part into a floating point value
    decimal = 0;
    for ( i=floatParts[1].size-1; i>=0; i-- )
    {
        decimal = decimal/10 + int(floatParts[1][i])/10;
    }
 
    if ( whole >= 0 )
        return (whole + decimal);
    else
        return (whole - decimal);
}
 
//
// TABLE LOOK SECTION ============================================================
// 
 
//  Read a value from a table and set the related level.zombie_var
//
function ‪set_zombie_var( zvar, value, is_float, column, is_team_based )
{
    if ( !IsDefined( is_float ) )
    {
        is_float = false;
    }
    if ( !IsDefined(column) )
    {
        column = 1;
    }
 
    if ( ‪IS_TRUE( is_team_based ) )
    {
        foreach( team in level.teams )
        {
            level.zombie_vars[ team ][ zvar ] = value;
        }
    }
    else
    {
        level.zombie_vars[zvar] = value;
    }
    
    return value;
}
 
 
//  Read a value from a table and return the result
//
function ‪get_table_var( table, var_name, value, is_float, column )
{
    if ( !IsDefined(table) )
    {
        table = "mp/zombiemode.csv";
    }
    if ( !IsDefined(is_float) )
    {
        is_float = false;
    }
    if ( !IsDefined(column) )
    {
        column = 1;
    }
 
    // First look it up in the table
    table_value = TableLookUp( table, 0, var_name, column );
    if ( IsDefined( table_value ) && table_value != "" )
    {
        if( is_float )
        {
            value = ‪string_to_float( table_value );
        }
        else
        {
            value = int( table_value );
        }
    }
 
    return value;
}
 
 
function ‪hudelem_count()
{
/#
    max = 0; 
    curr_total = 0; 
    while( 1 )
    {
        if( level.hudelem_count > max )
        {
            max = level.hudelem_count; 
        }
        
        println( "HudElems: " + level.hudelem_count + "[Peak: " + max + "]" ); 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
function ‪debug_round_advancer()
{
/#
    while( 1 )
    {
        zombs = ‪zombie_utility::get_round_enemy_array(); 
        
        for( i = 0; i < zombs.size; i++ )
        {
            zombs[i] dodamage( zombs[i].health + 666, ( 0, 0, 0 ) ); 
            wait 0.5; 
        }
    }   
#/
}
 
function ‪print_run_speed( speed )
{
/#
    self endon( "death" ); 
    while( 1 )
    {
        print3d( self.origin +( 0, 0, 64 ), speed, ( 1, 1, 1 ) ); 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
function ‪draw_line_ent_to_ent( ent1, ent2 )
{
/#
    if( GetDvarInt( "zombie_debug" ) != 1 )
    {
        return; 
    }
 
    ent1 endon( "death" ); 
    ent2 endon( "death" ); 
 
    while( 1 )
    {
        line( ent1.origin, ent2.origin ); 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
function ‪draw_line_ent_to_pos( ent, pos, end_on )
{
/#
    if( GetDvarInt( "zombie_debug" ) != 1 )
    {
        return; 
    }
 
    ent endon( "death" ); 
 
    ent notify( "stop_draw_line_ent_to_pos" ); 
    ent endon( "stop_draw_line_ent_to_pos" ); 
 
    if( IsDefined( end_on ) )
    {
        ent endon( end_on ); 
    }
 
    while( 1 )
    {
        line( ent.origin, pos ); 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
function ‪debug_print( msg )
{
/#
    if( GetDvarInt( "zombie_debug" ) > 0 )
    {
        println( "######### ZOMBIE: " + msg ); 
    }
#/
}
 
function ‪debug_blocker( pos, rad, height )
{
/#
    self notify( "stop_debug_blocker" );
    self endon( "stop_debug_blocker" );
    
    for( ;; )
    {
        if( GetDvarInt( "zombie_debug" ) != 1 )
        {
            return;
        }
 
        ‪WAIT_SERVER_FRAME; 
        ‪drawcylinder( pos, rad, height ); 
        
    }
#/
}
 
function ‪drawcylinder( pos, rad, height )
{
/#
    currad = rad; 
    curheight = height; 
 
    for( r = 0; r < 20; r++ )
    {
        theta = r / 20 * 360; 
        theta2 = ( r + 1 ) / 20 * 360; 
 
        line( pos +( cos( theta ) * currad, sin( theta ) * currad, 0 ), pos +( cos( theta2 ) * currad, sin( theta2 ) * currad, 0 ) ); 
        line( pos +( cos( theta ) * currad, sin( theta ) * currad, curheight ), pos +( cos( theta2 ) * currad, sin( theta2 ) * currad, curheight ) ); 
        line( pos +( cos( theta ) * currad, sin( theta ) * currad, 0 ), pos +( cos( theta ) * currad, sin( theta ) * currad, curheight ) ); 
    }
#/
}
 
function ‪print3d_at_pos( msg, pos, thread_endon, offset )
{
/#
    self endon( "death" ); 
 
    if( IsDefined( thread_endon ) )
    {
        self notify( thread_endon ); 
        self endon( thread_endon ); 
    }
 
    if( !IsDefined( offset ) )
    {
        offset = ( 0, 0, 0 ); 
    }
 
    while( 1 )
    {
        print3d( self.origin + offset, msg ); 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
function ‪debug_breadcrumbs()
{
/#
    self endon( "disconnect" ); 
    self notify("stop_debug_breadcrumbs");
    self endon("stop_debug_breadcrumbs");
    
 
    while( 1 )
    {
        if( GetDvarInt( "zombie_debug" ) != 1 )
        {
            wait( 1 ); 
            continue; 
        }
 
        for( i = 0; i < self.zombie_breadcrumbs.size; i++ )
        {
            ‪drawcylinder( self.zombie_breadcrumbs[i], 5, 5 );
        }
 
        ‪WAIT_SERVER_FRAME; 
    }
#/
}
 
/#
function ‪debug_attack_spots_taken()
{
// this section was totally commented out.
    self notify("stop_debug_breadcrumbs");
    self endon("stop_debug_breadcrumbs");
    
    while( 1 )
    {
        if( GetDvarInt( "zombie_debug" ) != 2 )
        {
            wait( 1 ); 
            continue; 
        }
 
        ‪WAIT_SERVER_FRAME;
        count = 0;
        for( i = 0; i < self.attack_spots_taken.size; i++ )
        {
            if( self.attack_spots_taken[i] )
            {
                count++;
                circle(self.attack_spots[i], 12, (1,0,0), false, true, 1);
            }
            else
            {
                circle(self.attack_spots[i], 12, (0,1,0), false, true, 1);
            }
        }
 
        msg = "" + count + " / " + self.attack_spots_taken.size;
        print3d( self.origin, msg );
    }
 
}
#/
 
function ‪float_print3d( msg, time )
{
/#
    self endon( "death" );
 
    time = GetTime() + ( time * 1000 );
    offset = ( 0, 0, 72 );
    while( GetTime() < time )
    {
        offset = offset + ( 0, 0, 2 );
        print3d( self.origin + offset, msg, ( 1, 1, 1 ) );
        ‪WAIT_SERVER_FRAME;
    }
#/
}
function ‪do_player_vo(snd, variation_count)
{
    index = ‪get_player_index(self);
    
    // updated to new alias format - Steve G
    sound = "zmb_vox_plr_" + index + "_" + snd; 
    if(IsDefined (variation_count))
    {
        sound = sound + "_" + randomintrange(0, variation_count);
    }
    if(!isDefined(level.player_is_speaking))
    {
        level.player_is_speaking = 0;
    }
    
    if (level.player_is_speaking == 0)
    {   
        level.player_is_speaking = 1;
        self PlaySoundWithNotify(sound, "sound_done");          
        self waittill("sound_done");
        //This ensures that there is at least 3 seconds waittime before playing another VO.
        wait(2);
        level.player_is_speaking = 0;
    }   
}
 
function ‪is_magic_bullet_shield_enabled( ent )
{
    if( !IsDefined( ent ) )
        return false;
 
    //return ( IsDefined( ent.magic_bullet_shield ) && ent.magic_bullet_shield == true );
    return !‪IS_TRUE( ent.allowDeath );
}
 
function ‪really_play_2D_sound(sound)
{
    temp_ent = ‪spawn("script_origin", (0,0,0));
    temp_ent PlaySoundWithNotify (sound, sound + "wait");
    temp_ent waittill (sound + "wait");
    ‪WAIT_SERVER_FRAME;
    temp_ent delete();
}
 
 
function ‪play_sound_2D(sound)
{
    level thread ‪really_play_2D_sound(sound);
    
    /*
    if(!isdefined(level.playsound2dent))
    {
        level.playsound2dent = spawn("script_origin",(0,0,0));
    }
    
    //players=GetPlayers();
    level.playsound2dent playsound ( sound );
    */
    /*
    temp_ent = spawn("script_origin", (0,0,0));
    temp_ent PlaySoundWithNotify (sound, sound + "wait");
    temp_ent waittill (sound + "wait");
    WAIT_SERVER_FRAME;
    temp_ent delete();  
    */  
}
 
function ‪include_weapon( weapon_name, in_box )
{
/#  println( "ZM >> include_weapon = " + weapon_name ); #/
    if( !isDefined( in_box ) )
    {
        in_box = true;
    }
 
    ‪zm_weapons::include_zombie_weapon( weapon_name, in_box );
}
 
// Allows triggers to be un/seen by players
function ‪trigger_invisible( ‪enable )
{
    players = GetPlayers();
    for ( i = 0; i < players.size; i++ )
    {
        if ( isdefined( players[i] ) )
        {
            self SetInvisibleToPlayer( players[i], ‪enable );
        }
    }
}
 
 
// Print3d
function ‪print3d_ent( text, color, scale, offset, end_msg, overwrite )
{
    self endon("death");
 
    if ( IsDefined(overwrite) && overwrite && IsDefined( self._debug_print3d_msg ) )
    {
        // Kill the previous thread
        self notify( "end_print3d" );
        ‪WAIT_SERVER_FRAME;
    }
 
    self endon("end_print3d");
 
    if ( !IsDefined(color) )
    {
        color = (1,1,1);
    }
 
    if ( !IsDefined(scale) )
    {
        scale = 1.0;
    }
 
    if ( !IsDefined(offset) )
    {
        offset = (0,0,0);
    }
 
    if ( IsDefined(end_msg) )
    {
        self endon(end_msg);
    }
 
    // This way you can change the message dynamically by changing the var
    self._debug_print3d_msg = text;
    /#
    while ( !‪IS_TRUE( level.disable_print3d_ent ) )
    {
        print3d( self.origin+offset, self._debug_print3d_msg, color, scale );
        ‪WAIT_SERVER_FRAME;
    }
    #/
}
 
//
//
function ‪create_counter_hud( x )
{
    if( !IsDefined( x ) )
    {
        x = 0;
    }
 
    hud = ‪create_simple_hud();
    hud.alignX = "left"; 
    hud.alignY = "top";
    hud.horzAlign = "user_left"; 
    hud.vertAlign = "user_top";
    hud.color = ( 1, 1, 1 );
//  hud.color = ( 0.21, 0, 0 );
    hud.fontscale = 32;
    hud.x = x; 
    hud.alpha = 0;
 
    hud SetShader( "hud_chalk_1", 64, 64 );
 
    return hud;
}
 
 
//
//  Get the name of the zone that the entity is currently in
//  self is the entity to check on
function ‪get_current_zone( return_zone )
{
    level ‪flag::wait_till( "zones_initialized" );
 
    if ( IsDefined(self.cached_zone) )
    {
        zone = self.cached_zone; 
        zone_name = self.cached_zone_name;
        vol = self.cached_zone_volume;
        // check most recent zone and volume
        if ( self IsTouching(zone.volumes[vol]) )
        {
            if ( ‪IS_TRUE( return_zone ) )
            {
                return zone;
            }
            return zone_name;
        }
        // check other volumes in the most recent zone
        for (i = 0; i < zone.volumes.size; i++)
        {
            if ( i == vol )
                continue; 
            if ( self IsTouching(zone.volumes[i]) )
            {
                self.cached_zone = zone; 
                self.cached_zone_volume = i; 
                if ( ‪IS_TRUE( return_zone ) )
                {
                    return zone;
                }
                return zone_name;
            }
        }
    }
    
    // clear out active zone flags
    for( z=0; z<level.zone_keys.size; z++ )
    {
        zone_name = level.zone_keys[z];
        zone = level.zones[ zone_name ];
 
        if ( ‪IS_EQUAL( zone, self.cached_zone ) )
            continue; 
        
        // Okay check to see if the entity is in one of the zone volumes
        for (i = 0; i < zone.volumes.size; i++)
        {
            if ( self IsTouching(zone.volumes[i]) )
            {
                self.cached_zone = zone; 
                self.cached_zone_name = zone_name; 
                self.cached_zone_volume = i; 
                if ( ‪IS_TRUE( return_zone ) )
                {
                    return zone;
                }
                return zone_name;
            }
        }
    }
 
    self.cached_zone = undefined; 
    self.cached_zone_name = undefined; 
    self.cached_zone_volume = undefined; 
    
    return undefined;
}
 
function ‪remove_mod_from_methodofdeath( mod )
{
    /*modStrings = strtok( mod, "mod_" );
    modName = "";
    for ( i = 1; i < modStrings.size; i++ )//skip the MOD_
    {
        modName += modStrings[i];
    }*/
    
    return mod;
}
 
function ‪clear_fog_threads()
{
    players = GetPlayers();
 
    for( i = 0; i < players.size; i++ )
    {
        players[i] notify( "stop_fog" );
    }
}
 
function ‪display_message( titleText, notifyText, duration )
{
    notifyData = spawnStruct();
    notifyData.titleText = notifyText;//titleText;
    notifyData.notifyText = titleText;//notifyText;
    //notifyData.titleText = &"ZM_MEAT_GRAB";
    //notifyData.notifyText = "MEAT GRAB";
    notifyData.sound = "mus_level_up";
    notifyData.duration = duration;
    notifyData.glowColor = (1.0, 0.0, 0.0);
    notifyData.color = (0.0, 0.0, 0.0);
    notifyData.iconName = "hud_zombies_meat";
    self thread ‪hud_message::notifyMessage( notifyData );
}
 
function ‪is_quad()
{
    return self.animname == "quad_zombie";
}
 
function ‪is_leaper()
{
    return self.animname == "leaper_zombie";
}
 
function ‪shock_onpain()
{
    self endon( "death" ); 
    self endon( "disconnect" ); 
    
    self notify("stop_shock_onpain");
    self endon("stop_shock_onpain");
 
    if( GetDvarString( "blurpain" ) == "" )
    {
        SetDvar( "blurpain", "on" ); 
    }
 
    while( 1 )
    {
        oldhealth = self.health; 
        self waittill( "damage", ‪damage, attacker, direction_vec, point, mod ); 
 
        if( IsDefined( level.shock_onpain ) && !level.shock_onpain )
        {
            continue;
        }
 
        if( IsDefined( self.‪shock_onpain ) && !self.‪shock_onpain )
        {
            continue;
        }
 
        if( self.health < 1 )
        {
            continue;
        }
 
        if ( IsDefined(attacker) && IsDefined(attacker.custom_player_shellshock) )
        {
            self [[ attacker.custom_player_shellshock ]] ( ‪damage, attacker, direction_vec, point, mod ); 
        }
        else if( mod == "MOD_PROJECTILE" || mod == "MOD_PROJECTILE_SPLASH" )
        {
            continue;
        }
        else if( mod == "MOD_GRENADE_SPLASH" || mod == "MOD_GRENADE" ||  mod == "MOD_EXPLOSIVE" )
        {
            shockType = undefined;
            shockLight = undefined;
            
            if ( ‪IS_TRUE( self.is_burning ) )
            {
                shockType = "lava";
                shockLight = "lava_small";
            }
            
            self ‪shock_onexplosion( ‪damage, shockType, shockLight );
        }
        else
        {
            if( GetDvarString( "blurpain" ) == "on" )
            {
                self ShellShock( "pain_zm", 0.5 ); 
            }
        }
    }
}
 
function ‪shock_onexplosion( ‪damage, shockType, shockLight )
{
    time = 0; 
 
    scaled_damage = 100 * ‪damage / self.maxhealth;
 
    if( scaled_damage >= 90 )
    {
        time = 4; 
    }
    else if( scaled_damage >= 50 )
    {
        time = 3; 
    }
    else if( scaled_damage >= 25 )
    {
        time = 2; 
    }
    else if( scaled_damage > 10 )
    {
        time = 1; 
    }
 
    if( time )
    {
        if ( !IsDefined( shockType ) )
        {
            shockType = "explosion";
        }
        
        self ShellShock( shockType, time );
    }
    else if (IsDefined(shockLight))
    {
        self ShellShock( shockLight, time );
    }
}
 
 
function ‪increment_ignoreme()
{
    ‪DEFAULT( self.ignorme_count, 0 );
    self.ignorme_count++;
    self.ignoreme = ( self.ignorme_count > 0 );
}
 
function ‪decrement_ignoreme()
{
    ‪DEFAULT( self.ignorme_count, 0 );
    if( self.ignorme_count > 0 )
    {
        self.ignorme_count--;
    }
    else
    {
        AssertMsg( "making ignorme_count less than 0" );
    }
    
    self.ignoreme = ( self.ignorme_count > 0 );
}
 
 
 
 
// ww: increment the is_drinking variable on a player
function ‪increment_is_drinking()
{
    //self endon( "death" );
    /#
    if( ‪IS_TRUE(level.devgui_dpad_watch) ) 
    {
        self.is_drinking++;
        return;
    }
    #/  
    
    if( !isdefined(self.is_drinking) )
        self.is_drinking = 0;
 
    if( self.is_drinking == 0 )
    {
 
        self DisableOffhandWeapons();
        self DisableWeaponCycling();
    }
    
    self.is_drinking++;
}
 
// ww: checks is_drinking
//is_drinking()
//{
//  //self endon( "death" );
//  return ( self.is_drinking > 0 );
//}
 
// to check if more than one is active at once
function ‪is_multiple_drinking()
{
    //self endon( "death" );
    return ( self.is_drinking > 1 );
}
 
// ww: decrement drinking
function ‪decrement_is_drinking()
{
    //self endon( "death" );
    
    if( self.is_drinking > 0 )
    {
        self.is_drinking--;
    }
    else
    {
        AssertMsg( "making is_drinking less than 0" );
    }
 
    
    if( self.is_drinking == 0 )
    {
        self EnableOffhandWeapons();
        self EnableWeaponCycling();
    }
}
 
// ww: clear the variable, used for players going in to last stand
function ‪clear_is_drinking()
{
    //self endon( "death" );
    
    self.is_drinking = 0;
    
    self EnableOffhandWeapons();
    self EnableWeaponCycling();
}
 
// PORTIZ 7/27/16: At this point there are multiple mechanics prolonging solo games when player doesn't have Quick Revive, so we need a
// better way of supporting them in conjunction
function ‪increment_no_end_game_check()
{
    ‪DEFAULT( level.n_no_end_game_check_count, 0 );
    level.n_no_end_game_check_count++;
    level.no_end_game_check = ( level.n_no_end_game_check_count > 0 );
}
 
function ‪decrement_no_end_game_check()
{
    ‪DEFAULT( level.n_no_end_game_check_count, 0 );
    if( level.n_no_end_game_check_count > 0 )
    {
        level.n_no_end_game_check_count--;
    }
    else
    {
        AssertMsg( "making no_end_game_check_count less than 0" );
    }
    
    level.no_end_game_check = ( level.n_no_end_game_check_count > 0 );
    
    if ( !level.no_end_game_check )
    {
        level ‪zm::checkForAllDead(); // run this manually any time this is decremented back to a false state
    }
}
 
/*
function fade_out(time)
{
    if (!isDefined(time))
    {
        time = 1;
    }
    if( !IsDefined(level.introblack) )
    {
        level.introblack = NewHudElem(); 
        level.introblack.x = 0; 
        level.introblack.y = 0; 
        level.introblack.horzAlign = "fullscreen"; 
        level.introblack.vertAlign = "fullscreen"; 
        level.introblack.foreground = true;
        level.introblack SetShader( "black", 640, 480 );
        level.introblack.alpha = 0; 
        wait .05;
    }
 
    if( time > 0 )
    {
        level.introblack FadeOverTime( time ); 
    }
    level.introblack.alpha = 1; 
 
    players = GetPlayers();
    for(i = 0; i < players.size; i++)
    {
        players[i] freezecontrols(true);
    }
 
    wait time;
}
 
function fade_in( hold_black_time )
{
    if( !IsDefined(level.introblack) )
    {
        level.introblack = NewHudElem(); 
        level.introblack.x = 0; 
        level.introblack.y = 0; 
        level.introblack.horzAlign = "fullscreen"; 
        level.introblack.vertAlign = "fullscreen"; 
        level.introblack.foreground = true;
        level.introblack SetShader( "black", 640, 480 );
        level.introblack.alpha = 1; 
        wait .05;
    }
 
    level.introblack.alpha = 1; 
 
    if( IsDefined( hold_black_time ) )
        wait hold_black_time;
    else
        wait .2;
    
    level.introblack FadeOverTime( 1.5 ); 
    level.introblack.alpha = 0; 
    
    level notify("fade_introblack");
 
    wait 1.5;
 
    players = GetPlayers();
    for(i = 0; i < players.size; i++)
    {
        players[i] freezecontrols(false);
    }
    level notify("fade_in_complete");
}
*/
// WEAPONS
 
function ‪getWeaponClassZM( weapon )
{
    assert( isdefined( weapon ) );
    if ( !isdefined( weapon ) ) 
    {
        return undefined;
    }
 
    if ( !isdefined ( level.weaponClassArray ) ) 
    {
        level.weaponClassArray = [];
    }
 
    if ( isdefined( level.weaponClassArray[weapon] ) )
    {
        return level.weaponClassArray[weapon];
    }
 
    baseWeaponIndex =  GetBaseWeaponItemIndex( weapon );
    statsTableName = ‪util::getStatsTableName();
    weaponClass = tableLookup( statsTableName, 0, baseWeaponIndex, ‪STATS_TABLE_COL_GROUP); 
    level.weaponClassArray[weapon] = weaponClass;
    return weaponClass;
}
 
function ‪spawn_weapon_model( weapon, model, origin, angles, options )
{
    if ( !isdefined( model ) )
    {
        model = weapon.worldModel;
    }
    
    weapon_model = ‪spawn( "script_model", origin ); 
    if ( isdefined( angles ) )
    {
        weapon_model.angles = angles;
    }
 
    if ( isdefined( options ) )
    {
        weapon_model useweaponmodel( weapon, model, options );
    }
    else
    {
        weapon_model useweaponmodel( weapon, model );
    }
 
    return weapon_model;
}
 
 
function ‪spawn_buildkit_weapon_model( player, weapon, camo, origin, angles )
{
    weapon_model = ‪spawn( "script_model", origin ); 
    if ( isdefined( angles ) )
    {
        weapon_model.angles = angles;
    }
 
    upgraded = ‪zm_weapons::is_weapon_upgraded( weapon );
    if ( upgraded && (!IsDefined( camo ) || 0 > camo) )
    {
        camo = ‪zm_weapons::get_pack_a_punch_camo_index( undefined );
    }
 
    weapon_model UseBuildKitWeaponModel( player, weapon, camo, upgraded );
 
    return weapon_model;
}
 
 
function ‪is_player_revive_tool( weapon )
{
    if ( weapon == level.weaponReviveTool || ‪IS_EQUAL(weapon,self.weaponReviveTool) )
    {
        return true;
    }
 
    return false;
}
 
function ‪is_limited_weapon( weapon )
{
    if ( IsDefined( level.limited_weapons ) && IsDefined( level.limited_weapons[weapon] ) )
    {
        return true;
    }
 
    return false;
}
 
 
function ‪register_lethal_grenade_for_level( weaponname )
{
    weapon = GetWeapon( weaponname );
    if ( ‪is_lethal_grenade( weapon ) )
    {
        return;
    }
 
    if ( !isdefined( level.zombie_lethal_grenade_list ) )
    {
        level.zombie_lethal_grenade_list = [];
    }
 
    level.zombie_lethal_grenade_list[weapon] = weapon;
}
 
 
function ‪is_lethal_grenade( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( level.zombie_lethal_grenade_list ) )
    {
        return false;
    }
 
    return isdefined(level.zombie_lethal_grenade_list[weapon]);
}
 
 
function ‪is_player_lethal_grenade( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( self.current_lethal_grenade ) )
    {
        return false;
    }
 
    return self.current_lethal_grenade == weapon;
}
 
 
function ‪get_player_lethal_grenade()
{
    grenade = level.weaponNone;
    
    if(IsDefined(self.current_lethal_grenade))
    {
        grenade = self.current_lethal_grenade;
    }
    
    return grenade;
}
 
 
function ‪set_player_lethal_grenade( weapon )
{
    if ( !IsDefined( weapon ) )
    {
        weapon = level.weaponNone;
    }
 
    self notify( "new_lethal_grenade", weapon );
    self.current_lethal_grenade = weapon;
}
 
 
function ‪init_player_lethal_grenade()
{
    self ‪set_player_lethal_grenade( level.zombie_lethal_grenade_player_init );
}
 
 
function ‪register_tactical_grenade_for_level( weaponname )
{
    weapon = GetWeapon( weaponname );
    if ( ‪is_tactical_grenade( weapon ) )
    {
        return;
    }
 
    if ( !isdefined( level.zombie_tactical_grenade_list ) )
    {
        level.zombie_tactical_grenade_list = [];
    }
 
    level.zombie_tactical_grenade_list[weapon] = weapon;
}
 
 
function ‪is_tactical_grenade( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( level.zombie_tactical_grenade_list ) )
    {
        return false;
    }
 
    return isdefined(level.zombie_tactical_grenade_list[weapon]);
}
 
 
function ‪is_player_tactical_grenade( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( self.current_tactical_grenade ) )
    {
        return false;
    }
 
    return self.current_tactical_grenade == weapon;
}
 
 
function ‪get_player_tactical_grenade()
{
    tactical = level.weaponNone;
    
    if(IsDefined(self.current_tactical_grenade))
    {
        tactical = self.current_tactical_grenade;
    }
    
    return tactical;
}
 
 
function ‪set_player_tactical_grenade( weapon )
{
    if ( !IsDefined( weapon ) )
    {
        weapon = level.weaponNone;
    }
 
    self notify( "new_tactical_grenade", weapon );
    self.current_tactical_grenade = weapon;
}
 
 
function ‪init_player_tactical_grenade()
{
    self ‪set_player_tactical_grenade( level.zombie_tactical_grenade_player_init );
}
 
function ‪is_placeable_mine( weapon )
{
    ‪DEFAULT(level.placeable_mines,[]);
    
    if ( !isdefined( weapon ) || weapon == level.weaponNone )
    {
        return false;
    }
    
    return isdefined( level.placeable_mines[weapon.name] );
}
 
 
function ‪is_player_placeable_mine( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( self.current_placeable_mine ) )
    {
        return false;
    }
 
    return self.current_placeable_mine == weapon;
}
 
 
function ‪get_player_placeable_mine()
{
    placeable_mine = level.weaponNone;
    
    if(IsDefined(self.current_placeable_mine))
    {
        placeable_mine = self.current_placeable_mine;
    }
    
    return placeable_mine;
}
 
 
function ‪set_player_placeable_mine( weapon )
{
    if ( !IsDefined( weapon ) )
    {
        weapon = level.weaponNone;
    }
 
    self notify( "new_placeable_mine", weapon );
    self.current_placeable_mine = weapon;
}
 
 
function ‪init_player_placeable_mine()
{
    self ‪set_player_placeable_mine( level.zombie_placeable_mine_player_init );
}
 
 
function ‪register_melee_weapon_for_level( weaponname )
{
    weapon = GetWeapon( weaponname );
    if ( ‪is_melee_weapon( weapon ) )
    {
        return;
    }
 
    if ( !isdefined( level.zombie_melee_weapon_list ) )
    {
        level.zombie_melee_weapon_list = [];
    }
 
    level.zombie_melee_weapon_list[weapon] = weapon;
}
 
 
function ‪is_melee_weapon( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( level.zombie_melee_weapon_list ) || ( weapon == GetWeapon( "none" ) ) )
    {
        return false;
    }
 
    return isdefined(level.zombie_melee_weapon_list[weapon]);
}
 
 
function ‪is_player_melee_weapon( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( self.current_melee_weapon ) )
    {
        return false;
    }
 
    return self.current_melee_weapon == weapon;
}
 
 
function ‪get_player_melee_weapon()
{
    melee_weapon = level.weaponNone;
    
    if(IsDefined(self.current_melee_weapon))
    {
        melee_weapon = self.current_melee_weapon;
    }
    
    return melee_weapon;
}
 
 
function ‪set_player_melee_weapon( weapon )
{
    if ( !IsDefined( weapon ) )
    {
        weapon = level.weaponNone;
    }
 
    self notify( "new_melee_weapon", weapon );
    self.current_melee_weapon = weapon;
}
 
 
function ‪init_player_melee_weapon()
{
    self ‪set_player_melee_weapon( level.zombie_melee_weapon_player_init );
}
 
 
function ‪register_hero_weapon_for_level( weaponname )
{
    weapon = GetWeapon( weaponname );
    if ( ‪is_hero_weapon( weapon ) )
    {
        return;
    }
 
    if ( !isdefined( level.zombie_hero_weapon_list ) )
    {
        level.zombie_hero_weapon_list = [];
    }
 
    level.zombie_hero_weapon_list[weapon] = weapon;
}
 
function ‪is_hero_weapon( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( level.zombie_hero_weapon_list ) )
    {
        return false;
    }
 
    return isdefined(level.zombie_hero_weapon_list[weapon]);
}
 
 
function ‪is_player_hero_weapon( weapon )
{
    if ( !isdefined( weapon ) || !isdefined( self.current_hero_weapon ) )
    {
        return false;
    }
 
    return self.current_hero_weapon == weapon;
}
 
 
function ‪get_player_hero_weapon()
{
    hero_weapon = level.weaponNone;
    
    if(IsDefined(self.current_hero_weapon))
    {
        hero_weapon = self.current_hero_weapon;
    }
    
    return hero_weapon;
}
 
 
function ‪set_player_hero_weapon( weapon )
{
    if ( !IsDefined( weapon ) )
    {
        weapon = level.weaponNone;
    }
 
    self notify( "new_hero_weapon", weapon );
    self.current_hero_weapon = weapon;
}
 
function ‪init_player_hero_weapon()
{
    self ‪set_player_hero_weapon( level.zombie_hero_weapon_player_init );
}
 
function ‪has_player_hero_weapon()
{
    return (IsDefined(self.current_hero_weapon) && self.current_hero_weapon != level.weaponNone);
}
 
 
 
function ‪should_watch_for_emp()
{
    return ‪IS_TRUE( level.should_watch_for_emp );
}
 
function ‪register_offhand_weapons_for_level_defaults()
{
    if ( isdefined( level.register_offhand_weapons_for_level_defaults_override ) )
    {
        [[ level.register_offhand_weapons_for_level_defaults_override ]]();
        return;
    }
 
    ‪register_lethal_grenade_for_level( "frag_grenade" );
    level.zombie_lethal_grenade_player_init = GetWeapon( "frag_grenade" );
 
    ‪register_tactical_grenade_for_level( "cymbal_monkey" );
    level.zombie_tactical_grenade_player_init = undefined;
 
 
    level.zombie_placeable_mine_player_init = undefined;
 
    ‪register_melee_weapon_for_level( "knife" );
    ‪register_melee_weapon_for_level( "bowie_knife" );
    level.zombie_melee_weapon_player_init = GetWeapon( "knife" );
    
    level.zombie_equipment_player_init = undefined;
}
 
 
function ‪init_player_offhand_weapons()
{
    ‪init_player_lethal_grenade();
    ‪init_player_tactical_grenade();
    ‪init_player_placeable_mine();
    ‪init_player_melee_weapon();
    ‪init_player_hero_weapon();
    ‪zm_equipment::init_player_equipment();
}
 
 
function ‪is_offhand_weapon( weapon )
{
    return (‪is_lethal_grenade( weapon ) || ‪is_tactical_grenade( weapon ) || ‪is_placeable_mine( weapon ) || ‪is_melee_weapon( weapon ) || ‪is_hero_weapon( weapon ) || ‪zm_equipment::is_equipment( weapon ) );
}
 
 
function ‪is_player_offhand_weapon( weapon )
{
    return (self ‪is_player_lethal_grenade( weapon ) || self ‪is_player_tactical_grenade( weapon ) || self ‪is_player_placeable_mine( weapon ) || self ‪is_player_melee_weapon( weapon ) || self ‪is_player_hero_weapon( weapon ) || self ‪zm_equipment::is_player_equipment( weapon ) );
}
 
 
function ‪has_powerup_weapon()
{
    return ‪IS_TRUE( self.‪has_powerup_weapon );
}
 
function ‪has_hero_weapon()
{
    weapon = self GetCurrentWeapon();
    return ‪IS_TRUE( weapon.isheroweapon );
}
 
function ‪give_start_weapon( b_switch_weapon )
{
    ‪DEFAULT( self.hasCompletedSuperEE, self ‪zm_stats::get_global_stat( "DARKOPS_GENESIS_SUPER_EE" ) > 0 );
    
    if( self.hasCompletedSuperEE )
    {
        self ‪zm_weapons::weapon_give( level.start_weapon, false, false, true, false );
        self GiveMaxAmmo( level.start_weapon );
        self ‪zm_weapons::weapon_give( level.super_ee_weapon, false, false, true, b_switch_weapon );
    }
    else
    {
        self ‪zm_weapons::weapon_give( level.start_weapon, false, false, true, b_switch_weapon );
    }
}
 
 
 
function ‪array_flag_wait_any( flag_array )
{
    if( !IsDefined ( level._array_flag_wait_any_calls ) )
    {
        level._n_array_flag_wait_any_calls = 0;
    }
    else
    {
        level._n_array_flag_wait_any_calls ++; // Used to ensure that we can have multiple calls to this concurrently, that don't interfere with each other.
    }
    
    str_condition = "array_flag_wait_call_" + level._n_array_flag_wait_any_calls;
    
    for(index = 0; index < flag_array.size; index ++)
    {
        level thread ‪array_flag_wait_any_thread ( flag_array[ index ], str_condition );
    }
        
    level waittill( str_condition );
                
}
 
function ‪array_flag_wait_any_thread( flag_name, condition )
{
  level endon( condition );
  
  level ‪flag::wait_till( flag_name );
  
  level notify( condition );
}
 
function ‪groundpos( origin )
{
    return bullettrace( origin, ( origin + ( 0, 0, -100000 ) ), 0, self )[ "position" ];
}
 
function ‪groundpos_ignore_water( origin )
{
    return bullettrace( origin, ( origin + ( 0, 0, -100000 ) ), 0, self, true )[ "position" ];
}
 
function ‪groundpos_ignore_water_new( origin )
{
    return groundtrace( origin, ( origin + ( 0, 0, -100000 ) ), 0, self, true )[ "position" ];
}
 
function ‪self_delete()
{
    if (IsDefined(self))
    {
        self delete();
    }
}
 
function ‪ignore_triggers( ‪timer )
{
    // ignore triggers for awhile so others can trigger the trigger we're in.
    self endon( "death" ); 
    self.ignoreTriggers = true; 
    if( IsDefined( ‪timer ) )
    {
        wait( ‪timer ); 
    }
    else
    {
        wait( 0.5 ); 
    }
    self.ignoreTriggers = false; 
}
 
 
 
function ‪giveachievement_wrapper( achievement, all_players )
{
    if ( achievement == "" )
    {
        return;
    }
    
    //don't do stats stuff if stats are disabled
    if ( ‪IS_TRUE( level.zm_disable_recording_stats ) )
    {   
        return; 
    }   
 
    achievement_lower = tolower(achievement);
    global_counter = 0;
    
    if ( IsDefined( all_players ) && all_players )
    {
        players = GetPlayers();
        for ( i = 0; i < players.size; i++ )
        {
            players[i] GiveAchievement( achievement );
            
            has_achievement = false; // T7 DLC5 TODO: players[i] zm_stats::get_global_stat( achievement_lower );
            if(!‪IS_TRUE(has_achievement))
            {   
                global_counter++;
            }
            
            // T7 DLC5 TODO: players[i] zm_stats::increment_client_stat( achievement_lower,false );
            
            if( issplitscreen() && i == 0 || !issplitscreen() )
            {
                if(isDefined(level.achievement_sound_func))
                {
                    players[i] thread [[level.achievement_sound_func]](achievement_lower);
                }
            }
        }
    }
    else
    {
        if ( !IsPlayer( self ) )
        {
        /#  println( "^1self needs to be a player for util::giveachievement_wrapper()" );   #/
            return;
        }
 
        self GiveAchievement( achievement );
        
        //test the stat before updating it from 0 to 1
        has_achievement = false; // T7 DLC5 TODO: self zm_stats::get_global_stat( achievement_lower );
        if(!‪IS_TRUE(has_achievement))
        {   
            global_counter++;
        }
        // T7 DLC5 TODO: self zm_stats::increment_client_stat( achievement_lower,false );
        
        if(isDefined(level.achievement_sound_func))
        {
            self thread [[level.achievement_sound_func]](achievement_lower);
        }
        
    }
    if(global_counter)
    {
        incrementCounter( "global_" + achievement_lower,global_counter);
    }
 
}
 
function ‪GetYaw(org)
{
    angles = VectorToAngles(org-self.origin);
    return angles[1];
}
 
 
function ‪GetYawToSpot(spot)
{
    pos = spot;
    yaw = self.angles[1] - ‪GetYaw(pos);
    yaw = AngleClamp180( yaw );
    return yaw;
}
 
/*
=============
"Function Name: disable_react()"
<br/>"Summary: Disables reaction behavior of given AI"
"Module: Utility"
"CallOn: An ai"
<br/>"Example:level.zakhaev disable_react();"
<br/>"Single Player / Multi Player: singleplayer"
=============
*/
function ‪disable_react()
{
    assert( isalive( self ), "Tried to disable react on a non ai" );
    self.a.disableReact = true;
    self.allowReact = false;
}
 
 
/*
=============
"Function Name: enable_react()"
<br/>"Summary: Enables reaction behavior of given AI"
"Module: Utility"
"CallOn: An ai"
<br/>"Example:level.zakhaev enable_react();"
<br/>"Single Player / Multi Player: singleplayer"
=============
*/
function ‪enable_react()
{
    assert( isalive( self ), "Tried to enable react on a non ai" );
    self.a.disableReact = false;
    self.allowReact = true;
}
 
// MikeD (12/15/2007): IW abandoned the auto-adjust feature, however, we can use it for stats?
// SCRIPTER_MOD: JesseS (4/14/2008):  Added back in for Arcade mode
function ‪bullet_attack( type )
{
    if ( type == "MOD_PISTOL_BULLET" )
    {
        return true;
    }
    return type == "MOD_RIFLE_BULLET";
}
 
 
 
function ‪pick_up()
{
    player = self.owner;
    self ‪destroy_ent();
    
    clip_ammo = player GetWeaponAmmoClip( self.weapon );
    clip_max_ammo = self.weapon.clipSize;
    if( clip_ammo < clip_max_ammo )
    {
        clip_ammo++;
    }
    player SetWeaponAmmoClip( self.weapon, clip_ammo );
}
 
function ‪destroy_ent()
{
    self delete();
}
 
 
function ‪waittill_not_moving()
{
    self endon("death");
    self endon( "disconnect" ); 
    self endon( "detonated" );
    level endon( "game_ended" );
 
    if ( self.classname == "grenade" )
    {
        self waittill("stationary");
    }
    else
    {
        prevorigin = self.origin;
        while(1)
        {
            wait .15;
            if ( self.origin == prevorigin )
                break;
            prevorigin = self.origin;
        }
    }
}
 
 
function ‪get_closest_player( org )
{
    players = [];
    players = GetPlayers(); 
    return ArrayGetClosest( org, players ); 
}
 
 
function ‪ent_flag_init_ai_standards()
{
    message_array = [];
 
    message_array[ message_array.size ] = "goal";
    message_array[ message_array.size ] = "damage";
 
    for( i = 0; i < message_array.size; i++)
    {
        self ‪flag::init( message_array[ i ] );
        self thread ‪ent_flag_wait_ai_standards( message_array[ i ] );
    }   
}
 
function ‪ent_flag_wait_ai_standards( message )
{
    /*
    only runs the first time on the message, so for 
    example if it's waiting on goal, it will only set
    the goal to true the first time.  It also doesn't 
    call ent_set_flag() because that would notify the 
    message possibly twice in the same frame, or worse 
    in the next frame.
    */
    self endon("death");
    self waittill( message );
    self.ent_flag[ message ] = true;
}
 
 
function ‪flat_angle( angle )
{
    rangle = ( 0, angle[ 1 ], 0 );
    return rangle; 
}
 
function ‪clear_run_anim()
{
    self.alwaysRunForward = undefined;
    self.a.combatrunanim = undefined;
    self.run_noncombatanim = undefined;
    self.walk_combatanim = undefined;
    self.walk_noncombatanim = undefined;
    self.preCombatRunEnabled = true;
}
 
function ‪track_players_intersection_tracker()
{
    self endon( "disconnect" );
    self endon( "death" );
    level endon( "end_game" );
 
    wait( 5 );
    
    while ( 1 )
    {
        killed_players = false;
        players = GetPlayers();
        for ( i = 0; i < players.size; i++ )
        {
            if ( players[i] ‪laststand::player_is_in_laststand() || "playing" != players[i].sessionstate )                   
            {
                continue;
            }
            
            for ( j = 0; j < players.size; j++ )
            {
                if ( i == j  || players[j] ‪laststand::player_is_in_laststand() || "playing" != players[j].sessionstate )
                {
                    continue;
                }
                
                if ( isDefined( level.player_intersection_tracker_override ) )
                {
                    if ( players[i] [[level.player_intersection_tracker_override]]( players[j] ) )
                    {
                        continue;
                    }
                }
 
                playerI_origin = players[i].origin;
                playerJ_origin = players[j].origin;
                
                //Check height first
                if ( abs(playerI_origin[2] - playerJ_origin[2] ) > 60 )
                    continue;
                    
                //Check 2d distance 
                distance_apart = distance2d( playerI_origin, playerJ_origin );
                //IPrintLnBold( "player=", i, ",", j, "distance_apart=", distance_apart );
                
                if ( abs(distance_apart) > 18 )
                    continue;
                    
/#
                IPrintLnBold( "PLAYERS ARE TOO FRIENDLY!!!!!" );
#/
                players[i] dodamage( 1000, (0, 0, 0) );
                players[j] dodamage( 1000, (0, 0, 0) );
 
                if ( !killed_players )
                {
                    players[i] playlocalsound( level.zmb_laugh_alias );
                }
                players[i] ‪zm_stats::increment_map_cheat_stat( "cheat_too_friendly" );
                players[i] ‪zm_stats::increment_client_stat( "cheat_too_friendly",false );
                players[i] ‪zm_stats::increment_client_stat( "cheat_total",false );
                
                players[j] ‪zm_stats::increment_map_cheat_stat( "cheat_too_friendly" );
                players[j] ‪zm_stats::increment_client_stat( "cheat_too_friendly",false );
                players[j] ‪zm_stats::increment_client_stat( "cheat_total",false );
                
                killed_players = true;
            }   
        }
        wait( .5 );
    }
}
 
function ‪is_player_looking_at(origin, dot, do_trace, ignore_ent)
{
    assert(IsPlayer(self), "player_looking_at must be called on a player.");
 
    if (!IsDefined(dot))
    {
        dot = .7;
    }
 
    if (!IsDefined(do_trace))
    {
        do_trace = true;
    }
 
    eye = self ‪util::get_eye();
 
    delta_vec = AnglesToForward(VectorToAngles(origin - eye));
    view_vec = AnglesToForward(self GetPlayerAngles());
        
    new_dot = VectorDot( delta_vec, view_vec );
    if ( new_dot >= dot )
    {
        if (do_trace)
        {
            return BulletTracePassed( origin, eye, false, ignore_ent );
        }
        else
        {
            return true;
        }
    }
    
    return false;
}
 
 
 
function ‪add_gametype( gt, dummy1, ‪name, dummy2 )
{
}
 
function ‪add_gameloc( gl, dummy1, ‪name, dummy2 )
{
}
 
function ‪get_closest_index( org, ‪array, dist )
{
    if( !IsDefined( dist ) )
    {
        dist = 9999999;
    }
    distsq = dist*dist;
    if( ‪array.size < 1 )
    {
        return;
    }
    index = undefined;
    for( i = 0;i < ‪array.size;i++ )
    {
        newdistsq = distancesquared( ‪array[ i ].origin, org );
        if( newdistsq >= distsq )
        {
            continue;
        }
        distsq = newdistsq;
        index = i;
    }
    return index;
}
 
function ‪is_valid_zombie_spawn_point(point)
{
    liftedorigin = point.origin + (0,0,5);
    size = 48;
    height = 64;
    mins = (-1 * size,-1 * size,0 );
    maxs = ( size,size,height );
    absmins = liftedorigin + mins;
    absmaxs = liftedorigin + maxs;
    // check to see if we would telefrag any players
    if ( BoundsWouldTelefrag( absmins, absmaxs ) )
    {
        return false;
    }
    return true;
}
 
function ‪get_closest_index_to_entity( entity, ‪array, dist, extra_check )
{
    org = entity.origin;
    if( !IsDefined( dist ) )
    {
        dist = 9999999;
    }
    distsq = dist*dist;
    if( ‪array.size < 1 )
    {
        return;
    }
    index = undefined;
    for( i = 0;i < ‪array.size;i++ )
    {
        if (isdefined(extra_check) && ![[extra_check]](entity,‪array[ i ]) )
            continue;
        newdistsq = distancesquared( ‪array[ i ].origin, org );
        if( newdistsq >= distsq )
        {
            continue;
        }
        distsq = newdistsq;
        index = i;
    }
    return index;
}
 
function ‪set_gamemode_var(gvar, val)
{
    if(!isdefined(game["gamemode_match"]))
    {
        game["gamemode_match"] = [];
    }   
    
    game["gamemode_match"][gvar] = val;
}
 
function ‪set_gamemode_var_once(gvar, val)
{
    if(!isdefined(game["gamemode_match"]))
    {
        game["gamemode_match"] = [];
    }   
    
    if(!isdefined(game["gamemode_match"][gvar]))
    {
        game["gamemode_match"][gvar] = val;
    }
}
 
function ‪set_game_var(gvar, val)
{
    game[gvar] = val;
}
 
function ‪set_game_var_once(gvar, val)
{
    if(!isdefined(game[gvar]))
    {
        game[gvar] = val;
    }
}
 
function ‪get_game_var( gvar )
{
    if(isdefined(game[gvar]))
    {
        return game[gvar];
    }
    
    return undefined;
}
 
function ‪get_gamemode_var( gvar )
{
    if(isdefined(game["gamemode_match"]) && isdefined(game["gamemode_match"][gvar]))
    {
        return game["gamemode_match"][gvar];
    }
    
    return undefined;
}
 
function ‪waittill_subset(min_num, string1, string2, string3, string4, string5 )
{
    self endon ("death");
    ent = SpawnStruct();
    ent.threads = 0;
    returned_threads = 0;
 
    if (IsDefined (string1))
    {
        self thread ‪util::waittill_string(string1, ent);
        ent.threads++;
    }
    if (IsDefined (string2))
    {
        self thread ‪util::waittill_string(string2, ent);
        ent.threads++;
    }
    if (IsDefined (string3))
    {
        self thread ‪util::waittill_string(string3, ent);
        ent.threads++;
    }
    if (IsDefined (string4))
    {
        self thread ‪util::waittill_string(string4, ent);
        ent.threads++;
    }
    if (IsDefined (string5))
    {
        self thread ‪util::waittill_string(string5, ent);
        ent.threads++;
    }
 
    while (ent.threads)
    {
        ent waittill ("returned");
        ent.threads--;
        returned_threads++;
        if(returned_threads >= min_num ) //if we've got the minimum number of waittills returned, then that is good enough!
        {
            break;
        }
    }
 
    ent notify ("die");
}
 
function ‪is_headshot( weapon, sHitLoc, sMeansOfDeath )
{
    if( !isdefined( sHitLoc ) )
    {
        return false;   
    }
    
    if( (sHitLoc != "head" && sHitLoc != "helmet") )
    {
        return false;
    }
    
    //ballsitic knives 
    if( sMeansofDeath == "MOD_IMPACT" && weapon.isBallisticKnife )
    {
        return true;
    }
    
    return sMeansOfDeath != "MOD_MELEE" && sMeansOfDeath != "MOD_IMPACT" && sMeansofDeath != "MOD_UNKNOWN";
}
 
function ‪is_jumping()
{
    // this probably doesn't work correctly on the bus
    // checking PMF_JUMPING in code would give more accurate results
    ground_ent = self GetGroundEnt();
    return (!isdefined(ground_ent));
}
 
function ‪is_explosive_damage( mod )
{
    if( !IsDefined( mod ) )
        return false;   
 
    if( mod == "MOD_GRENADE" || mod == "MOD_GRENADE_SPLASH" || mod == "MOD_PROJECTILE" || mod == "MOD_PROJECTILE_SPLASH" || mod == "MOD_EXPLOSIVE" )
        return true;
 
    return false;
}
 
function ‪sndSwitchAnnouncerVox( who )
{
    switch( who )
    {
        case "sam":
            game["zmbdialog"]["prefix"] = "vox_zmba_sam";
            level.zmb_laugh_alias = "zmb_laugh_sam";
            level.sndAnnouncerIsRich = false;
            break;
    }
}
 
function ‪do_player_general_vox(category,type,‪timer,chance)
{
    
    if( isDefined(‪timer) && isDefined(level.votimer[type]) && level.votimer[type] > 0)
    {
        return;
    }
        
    self thread ‪zm_audio::create_and_play_dialog( category, type); 
        
    if(isDefined(‪timer))
    {
        level.votimer[type] = ‪timer;
        level thread ‪general_vox_timer( level.votimer[type],type );
    }   
}
 
function ‪general_vox_timer(‪timer,type)
{
    level endon("end_game");
    
    /#  println( "ZM >> VOX TIMER STARTED FOR  " + type + " ( " + ‪timer + ")" );    #/
    
    while(‪timer > 0 )
    {
        wait(1);
        ‪timer--;
    }
    level.votimer[type] = ‪timer;
    /#  println( "ZM >> VOX TIMER ENDED FOR  " + type + " ( " + ‪timer + ")" );  #/
    
    
}
 
function ‪create_vox_timer(type)
{
    level.votimer[type] = 0;
}
 
function ‪play_vox_to_player(category,type,force_variant )
{
    //self thread zm_audio::playVoxToPlayer( category, type, force_variant );
}
 
function ‪is_favorite_weapon(weapon_to_check)
{
    if(!isDefined(self.favorite_wall_weapons_list))
    {
        return false;
    }
    
    foreach(weapon in self.favorite_wall_weapons_list)
    {
        if (weapon_to_check == weapon )
        {
            return true;
        }
    }
    
    return false;
}
 
function ‪add_vox_response_chance(event,chance)
{
    level.response_chances[event] = chance;
}
 
function ‪set_demo_intermission_point()
{
    spawnpoints = getentarray("mp_global_intermission", "classname");
    if ( !spawnpoints.size )
    {
        return;
    }
 
    spawnpoint = spawnpoints[0];
    match_string = "";
 
    location = level.scr_zm_map_start_location;
    if ( (location == "default" || location == "") && IsDefined( level.default_start_location ) )
    {
        location = level.default_start_location;
    }       
 
    match_string = level.scr_zm_ui_gametype + "_" + location;
 
    for ( i = 0; i < spawnpoints.size; i++ )
    {
        if ( IsDefined( spawnpoints[i].script_string ) )
        {
            tokens = strtok( spawnpoints[i].script_string," " );
            foreach ( token in tokens )
            {
                if ( token == match_string )
                {
                    spawnpoint = spawnpoints[i];
                    i = spawnpoints.size; // to get out of the outer for loop
                    break;
                }
            }
        }
    }           
 
    setDemoIntermissionPoint( spawnpoint.origin, spawnpoint.angles );
}
 
function ‪register_map_navcard(navcard_on_map,navcard_needed_for_computer)
{
    level.navcard_needed = navcard_needed_for_computer;
    level.map_navcard = navcard_on_map;
}
 
function ‪does_player_have_map_navcard(player)
{
    return player ‪zm_stats::get_global_stat( level.map_navcard );
}
 
function ‪does_player_have_correct_navcard(player)
{
    if(!isDefined(level.navcard_needed ))
    {
        return false;
    }
    return player ‪zm_stats::get_global_stat( level.navcard_needed );
}
 
function ‪place_navcard( str_model, str_stat, org, angles )
{
    navcard = ‪spawn("script_model",org);
    navcard setmodel( str_model );
    navcard.angles = angles;
    
    wait 1; // delay between spawning card and picking it up
    
    navcard_pickup_trig = ‪Spawn( "trigger_radius_use", org, 0, 84, 72 );
    navcard_pickup_trig SetCursorHint( "HINT_NOICON" );
    navcard_pickup_trig SetHintString( &"ZOMBIE_NAVCARD_PICKUP" );
    navcard_pickup_trig TriggerIgnoreTeam();
    
    a_navcard_stats = ‪array( "navcard_held_zm_transit", "navcard_held_zm_highrise", "navcard_held_zm_buried" );
    
    is_holding_card = false;
    str_placing_stat = undefined;
    
    while(1)
    {
        navcard_pickup_trig waittill("trigger",who );
        
        if( ‪is_player_valid(who) )
        {
            // check for any currently held card.  If found, clear that stat and save which it was
            foreach ( str_cur_stat in a_navcard_stats )
            {
                if ( who ‪zm_stats::get_global_stat( str_cur_stat ) )
                {
                    str_placing_stat = str_cur_stat;
                    is_holding_card = true;
                    who ‪zm_stats::set_global_stat( str_cur_stat, 0 );
                }
            }
            
            who playsound( "zmb_buildable_piece_add" );
            who ‪zm_stats::set_global_stat( str_stat, 1 );
            who.navcard_grabbed = str_stat;
            ‪util::wait_network_frame();
 
            is_stat = who ‪zm_stats::get_global_stat( str_stat );
            
            thread ‪sq_refresh_player_navcard_hud();
            break;
        }
    }
    
    navcard delete();
    navcard_pickup_trig delete();       
    
    // if a card was held, place a new card with the stat of the one that was held (set down the old card)
    if ( is_holding_card )
    {
        level thread ‪place_navcard( str_model, str_placing_stat, org, angles );
    }
}
 
function ‪sq_refresh_player_navcard_hud()
{
    if (!IsDefined(level.navcards))
        return;
    players = GetPlayers();
    foreach( player in players )
    {
        player thread ‪sq_refresh_player_navcard_hud_internal();
    }
}
 
function ‪sq_refresh_player_navcard_hud_internal()
{
    self endon("disconnect");
    
    navcard_bits = 0;
    for(i = 0;i < level.navcards.size; i++)
    {
        hasit = self ‪zm_stats::get_global_stat( level.navcards[i] );
        if (isdefined(self.navcard_grabbed) && self.navcard_grabbed == level.navcards[i] )
            hasit = 1;
        if( hasit )
        {
            navcard_bits +=( 1 << i );
        }
    }
    ‪util::wait_network_frame();
    self ‪clientfield::set( "navcard_held", 0 );
    if ( navcard_bits > 0 )
    {
        ‪util::wait_network_frame();
        self ‪clientfield::set( "navcard_held", navcard_bits );
    }
}
 
 
function ‪disable_player_move_states(forceStanceChange)
{
    self AllowCrouch( true );
    self AllowLean( false );
    self AllowAds( false );
    self AllowSprint( false );
    self AllowProne( false );       
    self AllowMelee( false );
 
    if((isdefined(forceStanceChange)) && (forceStanceChange == true))
    {
        if ( self GetStance() == "prone" )
        {
            self SetStance( "crouch" );
        }   
    }
}
 
function ‪enable_player_move_states()
{
    if((!isdefined(self._allow_lean)) || (self._allow_lean == true))
    {
        self AllowLean( true );
    }
    
    if((!isdefined(self._allow_ads)) || (self._allow_ads == true))
    {
        self AllowAds( true );
    }
    
    if((!isdefined(self._allow_sprint)) || (self._allow_sprint == true))
    {
        self AllowSprint( true );
    }
    
    if((!isdefined(self._allow_prone)) || (self._allow_prone == true))
    {
        self AllowProne( true );        
    }
    
    if((!isdefined(self._allow_melee)) || (self._allow_melee == true))
    {
        self AllowMelee( true );    
    }
    
}
 
function ‪check_and_create_node_lists()
{
    if(!isdefined(level._link_node_list))
    {
        level._link_node_list = [];
    }
    
    if(!isdefined(level._unlink_node_list))
    {
        level._unlink_node_list = [];
    }
}
 
function ‪link_nodes(‪a, b, bDontUnlinkOnMigrate = false)
{
    if(NodesAreLinked(‪a,b))
    {
        return;
    }
    
    ‪check_and_create_node_lists();
 
    a_index_string = "" + ‪a.origin;
    b_index_string = "" + b.origin;
    
    if(!isdefined(level._link_node_list[a_index_string]))
    {
        level._link_node_list[a_index_string] = spawnstruct();
        level._link_node_list[a_index_string].node = ‪a;
        level._link_node_list[a_index_string].links = [];
        level._link_node_list[a_index_string].ignore_on_migrate = [];
    }
 
    if(!isdefined(level._link_node_list[a_index_string].links[b_index_string]))
    {
        level._link_node_list[a_index_string].links[b_index_string] = b;    // Add a record of the link.
        level._link_node_list[a_index_string].ignore_on_migrate[b_index_string] = bDontUnlinkOnMigrate;
    }
    
    if(isdefined(level._unlink_node_list[a_index_string]))
    {
        if(isdefined(level._unlink_node_list[a_index_string].links[b_index_string]))
        {
            level._unlink_node_list[a_index_string].links[b_index_string] = undefined;  // Remove record of earlier unlink
            level._unlink_node_list[a_index_string].ignore_on_migrate[b_index_string] = undefined;
        }
    }
    
//  /# println("Linking node at " + a.origin + " to node at " + b.origin); #/
    
    LinkNodes(‪a,b);
}
 
function ‪unlink_nodes(‪a,b, bDontLinkOnMigrate = false)
{
    if(!NodesAreLinked(‪a,b))
    {
        return;
    }
    
    ‪check_and_create_node_lists();
 
    a_index_string = "" + ‪a.origin;
    b_index_string = "" + b.origin;
 
    if(!isdefined(level._unlink_node_list[a_index_string]))
    {
        level._unlink_node_list[a_index_string] = spawnstruct();
        level._unlink_node_list[a_index_string].node = ‪a;
        level._unlink_node_list[a_index_string].links = [];
        level._unlink_node_list[a_index_string].ignore_on_migrate = [];
    }
    
    if(!isdefined(level._unlink_node_list[a_index_string].links[b_index_string]))
    {
        level._unlink_node_list[a_index_string].links[b_index_string] = b;  // Add a record of the unlink.
        level._unlink_node_list[a_index_string].ignore_on_migrate[b_index_string] = bDontLinkOnMigrate;
    }
    
 
    if(isdefined(level._link_node_list[a_index_string]))
    {
        if(isdefined(level._link_node_list[a_index_string].links[b_index_string]))
        {
            level._link_node_list[a_index_string].links[b_index_string] = undefined;    // Remove record of earlier link.
            level._link_node_list[a_index_string].ignore_on_migrate[b_index_string] = undefined;
        }
    }
    
//  /# println("Unlinking node at " + a.origin + " from node at " + b.origin); #/
    
    UnlinkNodes(‪a,b);
}
 
//spawn_path_node( (-6392, 4329, 0), (0,0,0), "targetname", "blah" );
 
function ‪spawn_path_node(origin, angles, k1, v1, k2, v2)
{
    if(!isdefined(level._spawned_path_nodes))
    {
        level._spawned_path_nodes = [];
    }
    
    node = spawnstruct();
    
    node.origin = origin;
    node.angles = angles;
    node.k1 = k1;
    node.v1 = v1;
    node.k2 = k2;
    node.v2 = v2;
    
    node.node = ‪spawn_path_node_internal(origin, angles, k1, v1, k2, v2);
    
    level._spawned_path_nodes[level._spawned_path_nodes.size] = node;
    
    return node.node;
}
 
function ‪spawn_path_node_internal(origin, angles, k1, v1, k2, v2)
{
    if(isdefined(k2))
    {
        return SpawnPathNode("node_pathnode", origin, angles, k1, v1, k2, v2);
    }
    else if(isdefined(k1))
    {
        return SpawnPathNode("node_pathnode", origin, angles, k1, v1);
    }
    else
    {
        return SpawnPathNode("node_pathnode", origin, angles);
    }
 
    return undefined;
}
 
function ‪delete_spawned_path_nodes()
{
/*  if(!isdefined(level._spawned_path_nodes))
    {
        return;
    }   
    
    //for(i = 0; i < level._spawned_path_nodes.size; i ++)
    for(i = level._spawned_path_nodes.size - 1; i > -1; i --)       
    {
        /# println("Deleting spawned path node @ " + level._spawned_path_nodes[i].origin); #/
        DeletePathNode(level._spawned_path_nodes[i].node);
        level._spawned_path_nodes[i].node = undefined;
    }*/
}
 
function ‪respawn_path_nodes()
{
    if(!isdefined(level._spawned_path_nodes))
    {
        return;
    }
    
    for(i = 0; i < level._spawned_path_nodes.size; i ++)
    {
        node_struct = level._spawned_path_nodes[i];
        
        /# println("Re-spawning spawned path node @ " + node_struct.origin); #/
        node_struct.node = ‪spawn_path_node_internal(node_struct.origin, node_struct.angles, node_struct.k1, node_struct.v1, node_struct.k2, node_struct.v2);
    }
}
 
function ‪link_changes_internal_internal(list, func)
{
    keys = GetArrayKeys(list);
    
    for(i = 0; i < keys.size; i ++)
    {
        node = list[keys[i]].node;
        
        node_keys = GetArrayKeys(list[keys[i]].links);
        
        for(j = 0; j < node_keys.size; j ++)
        {
            if(isdefined(list[keys[i]].links[node_keys[j]]))
            {
                
                if(‪IS_TRUE(list[keys[i]].ignore_on_migrate[node_keys[j]]))
                {
                    /# println("Node at " + keys[i] + " to node at " + node_keys[j] + " - IGNORED"); #/
                }
                else
                {
                    /# println("Node at " + keys[i] + " to node at " + node_keys[j]); #/
                    [[func]](node, list[keys[i]].links[node_keys[j]]);
                }
            }
        }
    }
}
 
function ‪link_changes_internal(func_for_link_list, func_for_unlink_list)
{
    if(isdefined(level._link_node_list))
    {
        /# println("Link List"); #/
        ‪link_changes_internal_internal(level._link_node_list, func_for_link_list);
    }
    
    if(isdefined(level._unlink_node_list))
    {
        /# println("UnLink List"); #/
        ‪link_changes_internal_internal(level._unlink_node_list, func_for_unlink_list);
    }
}
 
function ‪link_nodes_wrapper(‪a, b)
{
    if(!NodesAreLinked(‪a,b))
    {
        LinkNodes(‪a,b);
    }
}
 
function ‪unlink_nodes_wrapper(‪a, b)
{
    if(NodesAreLinked(‪a,b))
    {
        UnlinkNodes(‪a,b);
    }
}
 
function ‪undo_link_changes()
{
    /#  println("***");
        println("***");
        println("*** Undoing link changes"); #/
            
    ‪link_changes_internal( &‪unlink_nodes_wrapper, &‪link_nodes_wrapper);
        
    ‪delete_spawned_path_nodes();
        
}
 
function ‪redo_link_changes()
{
    /#  println("***");
        println("***");
        println("*** Redoing link changes"); #/
 
    ‪respawn_path_nodes();
            
    ‪link_changes_internal( &‪link_nodes_wrapper, &‪unlink_nodes_wrapper);
}
 
function ‪is_gametype_active( a_gametypes )
{
    b_is_gametype_active = false;
    
    if ( !IsArray( a_gametypes ) )
    {
        a_gametypes = Array( a_gametypes );
    }
    
    for ( i = 0; i < a_gametypes.size; i++ )
    {
        if ( GetDvarString( "g_gametype" ) == a_gametypes[ i ] )
        {
            b_is_gametype_active = true;
        }
    }
 
    return b_is_gametype_active;
}
 
function ‪register_custom_spawner_entry( spot_noteworthy, func )
{
    if ( !IsDefined( level.custom_spawner_entry ) )
    {
        level.custom_spawner_entry = [];
    }
    
    level.custom_spawner_entry[ spot_noteworthy ] = func;
}
 
function ‪get_player_weapon_limit( player )
{
    if ( IsDefined( self.‪get_player_weapon_limit ) )
    {
        return [[self.get_player_weapon_limit]]( player );
    }
 
    if ( IsDefined( level.get_player_weapon_limit ) )
    {
        return [[level.get_player_weapon_limit]]( player );
    }
 
    weapon_limit = 2;
    if ( player HasPerk( ‪PERK_ADDITIONAL_PRIMARY_WEAPON ) )
    {
        weapon_limit = level.additionalprimaryweapon_limit;
    }
 
    return weapon_limit;
}
 
function ‪get_player_perk_purchase_limit()
{
    n_perk_purchase_limit_override = level.perk_purchase_limit; // start with the default value
 
    // level-specific override
    if ( IsDefined( level.get_player_perk_purchase_limit ) )
    {
        n_perk_purchase_limit_override = self [[level.get_player_perk_purchase_limit]]();
    }
    
    return n_perk_purchase_limit_override;
}
 
function ‪can_player_purchase_perk()
{
    if ( self.num_perks < self ‪zm_utility::get_player_perk_purchase_limit() )
    {
        return true;
    }
 
    // you can always buy one more if you currently have unquenchable
    if ( self ‪bgb::is_enabled( "zm_bgb_unquenchable" ) || self ‪bgb::is_enabled( "zm_bgb_soda_fountain" ) )
    {
        return true;
    }
 
    return false;
}
 
//  Give player all perks
//      b_exclude_quick_revive - if you need to prevent a solo player from getting quick revive
function ‪give_player_all_perks( b_exclude_quick_revive = false ) // self == player
{
    // give the player all the perks in the map
    a_str_perks = GetArrayKeys( level._custom_perks );
    
    foreach( str_perk in a_str_perks )
    {
        if ( str_perk == ‪PERK_QUICK_REVIVE && b_exclude_quick_revive )
        {
            continue;
        }
        
        if( !self HasPerk( str_perk ) )
        {
            self ‪zm_perks::give_perk( str_perk, false );
                
            if ( isdefined( level.perk_bought_func ) )
            {
                self [[ level.perk_bought_func ]]( str_perk );
            }   
        }
    }
}
 
function ‪wait_for_attractor_positions_complete()
{
    self waittill( "attractor_positions_generated" );
    
    self.attract_to_origin = false;
}
 
// Migrated from _zm_weapons.
function ‪get_player_index( player )
{
    assert( IsPlayer( player ) );
    assert( IsDefined( player.characterIndex ) );
    
/#
    // used for testing to switch player's VO in-game from devgui
    if ( player.entity_num == 0 && GetDvarString( "zombie_player_vo_overwrite" ) != "" )
    {
        new_vo_index = GetDvarInt( "zombie_player_vo_overwrite" );
        return new_vo_index;
    }
#/
    return player.characterIndex;
}
 
// ****************************************
// get_specific_character() returns the player character associated with the index given.
// For zm_zod, the indices are defined as follows:
//      #define FLOYD 0
//      #define JACK 1
//      #define ROSE 2
//      #define NERO 3
// For other levels, indices will differ.
// Copied from zm_factory.gsc
function ‪get_specific_character( n_character_index )
{
    foreach( character in level.players )
    {
        if( character.characterIndex == n_character_index )
            return character;
    }
    return undefined;
}
 
function ‪zombie_goto_round( n_target_round )
{
    level notify( "restart_round" );
        
    if ( n_target_round < 1 )
    {
        n_target_round = 1;
    }
 
    level.zombie_total = 0;
    ‪zombie_utility::ai_calculate_health( n_target_round );
    ‪zm::set_round_number( n_target_round - 1 );
    
    // kill all active zombies
    zombies = ‪zombie_utility::get_round_enemy_array();
    if ( isdefined( zombies ) )
    {
        array::run_all( zombies, &Kill );
    }
    
    level.sndGotoRoundOccurred = true;
    
    level waittill( "between_round_over" );
}
 
// spawn ent at v_point and test if it's touching any enabled zone volume; return true/false
// this is a workaround for not having a good way of testing whether a point or struct is inside a volume for now
// ignore_zone - zone that we don't want to return true from
function ‪is_point_inside_enabled_zone( v_origin, ignore_zone )
{
    temp_ent = ‪Spawn( "script_origin", v_origin );
 
    foreach( zone in level.zones )
    {
        // If the zone hasn't been enabled, don't even bother checking
        if ( !zone.is_enabled  )
        {
            continue;
        }
        
        if( isdefined( ignore_zone ) && ( zone == ignore_zone ) )
        {
            continue;
        }
        
        // Okay check to see if an entity is in one of the zone volumes
        foreach( e_volume in zone.volumes )
        {
            if ( temp_ent IsTouching( e_volume ) )
            {
                temp_ent Delete();
                return true;
            }
        }
    }
 
    temp_ent Delete();
    return false;
}
 
 
function ‪clear_streamer_hint()
{
    if ( IsDefined(self.streamer_hint) )
    {
        self.streamer_hint Delete(); 
        self.streamer_hint = undefined; 
    }
    self notify("wait_clear_streamer_hint");
}
 
function ‪wait_clear_streamer_hint( lifetime ) 
{
    self endon("wait_clear_streamer_hint");
    wait lifetime; 
    if ( IsDefined(self) )
        self ‪clear_streamer_hint();
}
 
 
function ‪create_streamer_hint( origin, angles, value, lifetime )
{
    if ( self == level )
    {
        foreach( player in GetPlayers() )
        {
            player ‪clear_streamer_hint();
        }
    }
    self ‪clear_streamer_hint();
    self.streamer_hint = CreateStreamerHint( origin, value );
    if ( IsDefined(angles) )
        self.streamer_hint.angles = angles; 
    if ( self != level )
    {
        self.streamer_hint SetInvisibleToAll();
        self.streamer_hint SetVisibleToPlayer( self );  
    }
 
    self.streamer_hint SetIncludeMeshes( true );
 
    self notify("wait_clear_streamer_hint");
    if ( IsDefined(lifetime) && lifetime > 0 )
    {
        self thread ‪wait_clear_streamer_hint(lifetime); 
    }
}
 
function ‪approximate_path_dist( player )
{
    AIProfile_BeginEntry( "approximate_path_dist" );
    
    goal_pos = player.origin;
    if ( isdefined( player.last_valid_position ) )
    {
        goal_pos = player.last_valid_position;
    }
 
    if ( ‪IS_TRUE( player.b_teleporting ) )
    {
        if ( isdefined( player.teleport_location ) )
        {
            goal_pos = player.teleport_location;
            if ( !IsPointOnNavmesh( goal_pos, self ) )
            {
                position = GetClosestPointOnNavMesh( goal_pos, 100, 15 );
                if ( IsDefined( position ) )
                {
                    goal_pos = position;
                }
            }
        }
    }
    
    assert( IsDefined( level.pathdist_type ), "level.pathdist_type must be set before calling PathDistance" );
 
    //PathDistance( <start>, <end>, <generatePathForAccurateDist>, <pathEnt>, <pathDistanceType>, <maxCornerPredictions> )
    approx_dist = PathDistance( self.origin, goal_pos, true, self, level.pathdist_type );
 
    AIProfile_EndEntry();
    
    return approx_dist;
}
 
 
 
//  Helper function for slowdowns
function ‪register_slowdown( str_type, n_rate, n_duration )
{
    if ( !isdefined( level.a_n_slowdown_rates ) )
    {
        level.a_n_slowdown_rates = [];
    }
    
    level.a_s_slowdowns[ str_type ] = SpawnStruct();
    level.a_s_slowdowns[ str_type ].n_rate      = n_rate;
    level.a_s_slowdowns[ str_type ].n_duration  = n_duration;
}
 
 
//  All-purpose function to slow a zombie.  Can handle slowdowns from multiple sources.
//  The slowest rate will always be applied first, until it wears out, then the next highest one will be applied.
//      str_type is the reason for the slow
//      n_rate is the new animation rate
function ‪slowdown_ai( str_type )
{
    self notify( "starting_slowdown_ai" );
    self endon( "starting_slowdown_ai" );
    self endon( "death" );
    
    Assert( isdefined( level.a_s_slowdowns[ str_type ] ), "Slowdown \"" + str_type + "\" must be registered through register_slowdown first" );
 
    if ( !isdefined( self.a_n_slowdown_timeouts ) )
    {
        self.a_n_slowdown_timeouts = [];
    }
    
    n_time = GetTime();
    n_timeout = n_time + level.a_s_slowdowns[ str_type ].n_duration;
 
    // See if the slowdown is already being applied
    if ( !isdefined( self.a_n_slowdown_timeouts[ str_type ] ) ||
         self.a_n_slowdown_timeouts[ str_type ] < n_timeout )
    {
        self.a_n_slowdown_timeouts[ str_type ] = n_timeout;
    }
    
    // search for the lowest rate and apply that
    while ( self.a_n_slowdown_timeouts.size )
    {
        str_lowest_type = undefined;
        n_lowest_rate = 10.0;
        foreach( str_index, n_slowdown_timeout in self.a_n_slowdown_timeouts )
        {
            //TODO Make sure clearing an entry doesn't mess up the foreach
            //  remove old expired times
            if ( n_slowdown_timeout <= n_time )
            {
                self.a_n_slowdown_timeouts[ str_index ] = undefined;
                continue;
            }
            
            if ( level.a_s_slowdowns[ str_index ].n_rate < n_lowest_rate )
            {
                str_lowest_type = str_index;
                n_lowest_rate = level.a_s_slowdowns[ str_index ].n_rate;
            }
        }
        
        if ( isdefined ( str_lowest_type ) )
        {
            // Apply the slowest rate
            self ASMSetAnimationRate( n_lowest_rate );
            
            n_duration = self.a_n_slowdown_timeouts[ str_lowest_type ] - n_time;
            wait( n_duration );
    
            // Remove slowdown
            self.a_n_slowdown_timeouts[ str_lowest_type ] = undefined;
        }
    }
 
    // No more slowdowns, return to normal
    self ASMSetAnimationRate( 1.0 );
}
 
//*****************************************************************************
//*****************************************************************************
 
function ‪get_player_closest_to( ‪e_target )
{
    a_players= ArrayCopy( level.activeplayers );
    
    // If the target is also a player, remove it from the copied array of players.
    ArrayRemoveValue( a_players, ‪e_target );
        
    e_closest_player = ArrayGetClosest( ‪e_target.origin, a_players );
    
    return e_closest_player;
}
 
//*****************************************************************************
//*****************************************************************************
 
function ‪is_facing( facee, requiredDot = 0.5, b_2d = true )
{
    orientation = self getPlayerAngles();
    v_forward = anglesToForward( orientation );
    v_to_facee = facee.origin - self.origin;
    
    if( b_2d )
    {
        v_forward_computed = ( v_forward[0], v_forward[1], 0 );
        v_to_facee_computed = ( v_to_facee[0], v_to_facee[1], 0 );
    }
    else
    {
        v_forward_computed = v_forward;
        v_to_facee_computed = v_to_facee;
    }
    
    v_unit_forward_computed = VectorNormalize( v_forward_computed );
    v_unit_to_facee_computed = VectorNormalize( v_to_facee_computed );
    
    dotProduct = VectorDot( v_unit_forward_computed, v_unit_to_facee_computed );
    return ( dotProduct > requiredDot ); // reviver is facing player within given dot tolerance.
}
 
//Returns true if the player is in a solo game that cannot be hotjoined
function ‪is_solo_ranked_game()
{
    return ( level.players.size == 1 && GetDvarInt( "zm_private_rankedmatch", 0 ) );
}
 
function ‪upload_zm_dash_counters( force_upload = false ) {}
 
function ‪upload_zm_dash_counters_end_game() {}
 
function ‪increment_zm_dash_counter( counter_name, amount ) {}
 
function ‪zm_dash_stats_game_start() {}
 
function ‪zm_dash_stats_game_end() {}
 
function ‪zm_dash_stats_wait_for_consumable_use() {}