_zm_ai_dogs.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\aat_shared;
#using scripts\shared\array_shared;
#using scripts\shared\clientfield_shared;
#using scripts\shared\flag_shared;
#using scripts\shared\spawner_shared;
#using scripts\shared\system_shared;
#using scripts\shared\trigger_shared;
#using scripts\shared\util_shared;
 
#insert scripts\shared\archetype_shared\archetype_shared.gsh;
#insert scripts\shared\shared.gsh;
#insert scripts\shared\version.gsh;
 
#insert scripts\shared\aat_zm.gsh;
#using scripts\zm\_util;
#using scripts\zm\_zm;
#using scripts\zm\_zm_audio;
#using scripts\zm\_zm_net;
#using scripts\zm\_zm_powerups;
#using scripts\zm\_zm_score;
#using scripts\zm\_zm_spawner;
#using scripts\zm\_zm_stats;
#using scripts\zm\_zm_utility;
 
#using scripts\shared\ai\zombie_utility;
 
#insert scripts\zm\_zm_utility.gsh;
 
#precache( "fx", "zombie/fx_dog_lightning_buildup_zmb" );
#precache( "fx", "zombie/fx_dog_eyes_zmb" );
#precache( "fx", "zombie/fx_dog_explosion_zmb" );
#precache( "fx", "zombie/fx_dog_fire_trail_zmb" );
 
#define ZM_DOGS_HERO_WEAPON_KILL_POWER 2
 
#namespace zm_ai_dogs;
 
‪REGISTER_SYSTEM( "zm_ai_dogs", &‪__init__, "aat" )
    
function ‪__init__()
{
    ‪clientfield::register( "actor", "dog_fx", ‪VERSION_SHIP, 1, "int" );
    
    ‪init_dog_fx();
    ‪init();
}
 
function ‪init()
{
    level.dogs_enabled = true;
    level.dog_rounds_enabled = false;
    level.dog_round_count = 1;
 
    level.dog_spawners = [];
 
    //utility::flag_init( "dog_round" );
    level ‪flag::init( "dog_clips" );
 
    if ( GetDvarString( "zombie_dog_animset" ) == "" )
    {
        SetDvar( "zombie_dog_animset", "zombie" );
    }
 
    if ( GetDvarString( "scr_dog_health_walk_multiplier" ) == "" )
    {
        SetDvar( "scr_dog_health_walk_multiplier", "4.0" );
    }
 
    if ( GetDvarString( "scr_dog_run_distance" ) == "" )
    {
        SetDvar( "scr_dog_run_distance", "500" );
    }
 
    level.melee_range_sav  = GetDvarString( "ai_meleeRange" );
    level.melee_width_sav = GetDvarString( "ai_meleeWidth" );
    level.melee_height_sav  = GetDvarString( "ai_meleeHeight" );
 
    ‪zombie_utility::set_zombie_var( "dog_fire_trail_percent", 50 );
 
    // AAT IMMUNITIES
    level thread ‪aat::register_immunity( ‪ZM_AAT_BLAST_FURNACE_NAME, ‪ARCHETYPE_ZOMBIE_DOG, false, true, true );
    level thread ‪aat::register_immunity( ‪ZM_AAT_DEAD_WIRE_NAME, ‪ARCHETYPE_ZOMBIE_DOG, false, true, true );
    level thread ‪aat::register_immunity( ‪ZM_AAT_FIRE_WORKS_NAME, ‪ARCHETYPE_ZOMBIE_DOG, true, true, true );
    level thread ‪aat::register_immunity( ‪ZM_AAT_THUNDER_WALL_NAME, ‪ARCHETYPE_ZOMBIE_DOG, false, false, true );
    level thread ‪aat::register_immunity( ‪ZM_AAT_TURNED_NAME, ‪ARCHETYPE_ZOMBIE_DOG, true, true, true );
    
    // Init dog targets - mainly for testing purposes.
    //  If you spawn a dog without having a dog round, you'll get SREs on hunted_by.
    ‪dog_spawner_init();
 
    level thread ‪dog_clip_monitor();
}
 
function ‪init_dog_fx()
{
    level._effect[ "lightning_dog_spawn" ]  = "zombie/fx_dog_lightning_buildup_zmb";
    level._effect[ "dog_eye_glow" ]         = "zombie/fx_dog_eyes_zmb";
    level._effect[ "dog_gib" ]              = "zombie/fx_dog_explosion_zmb";
    level._effect[ "dog_trail_fire" ]       = "zombie/fx_dog_fire_trail_zmb";
}
 
//
//  If you want to enable dog rounds, then call this.
//  Specify an override func if needed.
function ‪enable_dog_rounds()
{
    level.dog_rounds_enabled = true;
 
    if( !isdefined( level.dog_round_track_override ) )
    {
        level.dog_round_track_override =&‪dog_round_tracker;
    }
 
    level thread [[level.dog_round_track_override]]();
}
 
 
function ‪dog_spawner_init()
{
    level.dog_spawners = getEntArray( "zombie_dog_spawner", "script_noteworthy" ); 
    later_dogs = getentarray("later_round_dog_spawners", "script_noteworthy" );
    level.dog_spawners = ArrayCombine( level.dog_spawners, later_dogs, true, false );
    
    if( level.dog_spawners.size == 0 )
    {
        return;
    }
    
    for( i = 0; i < level.dog_spawners.size; i++ )
    {
        if ( ‪zm_spawner::is_spawner_targeted_by_blocker( level.dog_spawners[i] ) )
        {
            level.dog_spawners[i].is_enabled = false;
        }
        else
        {
            level.dog_spawners[i].is_enabled = true;
            level.dog_spawners[i].script_forcespawn = true;
        }
    }
 
    assert( level.dog_spawners.size > 0 );
    level.dog_health = 100;
 
    array::thread_all( level.dog_spawners,&‪spawner::add_spawn_function,&‪dog_init );
}
 
 
function ‪dog_round_spawning()
{
    level endon( "intermission" );
    level endon( "end_of_round" );
    level endon( "restart_round" );
    
    level.dog_targets = getplayers();
    for( i = 0 ; i < level.dog_targets.size; i++ )
    {
        level.dog_targets[i].hunted_by = 0;
    }
 
    level endon( "kill_round" );
 
    if( level.intermission )
    {
        return;
    }
 
    level.dog_intermission = true;
    level thread ‪dog_round_aftermath();
    players = GetPlayers();
    array::thread_all( players,&‪play_dog_round );   
    wait(1);
    level thread ‪zm_audio::sndAnnouncerPlayVox("dogstart");
    wait(6);
    
    if( level.dog_round_count < 3 )
    {
        max = players.size * 6;
    }
    else
    {
        max = players.size * 8;
    }
 
    level.zombie_total = max;
    ‪dog_health_increase();
 
 
 
    count = 0; 
    while( true )
    {
        // added ability to pause spawning
        level ‪flag::wait_till( "spawn_zombies" );
        
        while( ‪zombie_utility::get_current_zombie_count() >= level.zombie_ai_limit || level.zombie_total <= 0 )
        {
            wait 0.1;
        }
 
        num_player_valid = ‪zm_utility::get_number_of_valid_players();
    
        while( ‪zombie_utility::get_current_zombie_count() >= num_player_valid * 2 )
        {
            wait( 2 );
            num_player_valid = ‪zm_utility::get_number_of_valid_players();
        }
        
        //update the player array.
        players = GetPlayers();
        favorite_enemy = ‪get_favorite_enemy();
 
        if ( isdefined( level.dog_spawn_func ) )
        {
            spawn_loc = [[level.dog_spawn_func]]( level.dog_spawners, favorite_enemy );
 
            ai = ‪zombie_utility::spawn_zombie( level.dog_spawners[0] );
            if( isdefined( ai ) )   
            {
                ai.favoriteenemy = favorite_enemy;
                spawn_loc thread ‪dog_spawn_fx( ai, spawn_loc );
                level.zombie_total--;
                count++;
                level ‪flag::set( "dog_clips" );
            }
        }
        else
        {
            // Default method
            spawn_point = ‪dog_spawn_factory_logic( favorite_enemy );
            ai = ‪zombie_utility::spawn_zombie( level.dog_spawners[0] );
 
            if( isdefined( ai ) )   
            {
                ai.favoriteenemy = favorite_enemy;
                spawn_point thread ‪dog_spawn_fx( ai, spawn_point );
                level.zombie_total--;
                count++;
                level ‪flag::set( "dog_clips" );
            }
        }
 
        
        ‪waiting_for_next_dog_spawn( count, max );
    }
}
 
function ‪waiting_for_next_dog_spawn( count, max )
{
    default_wait = 1.5;
 
    if( level.dog_round_count == 1)
    {
        default_wait = 3;
    }
    else if( level.dog_round_count == 2)
    {
        default_wait = 2.5;
    }
    else if( level.dog_round_count == 3)
    {
        default_wait = 2;
    }
    else 
    {
        default_wait = 1.5;
    }
 
    default_wait = default_wait - ( count / max );
    
    default_wait = max( default_wait, 0.05 ); 
 
    wait( default_wait );
}
 
function ‪dog_round_aftermath()
{
    level waittill( "last_ai_down", e_last );
 
    level thread ‪zm_audio::sndMusicSystem_PlayState( "dog_end" );
    
    power_up_origin = level.last_dog_origin;
    if ( isdefined(e_last) )
    {
        power_up_origin = e_last.origin;
    }
 
    if( isdefined( power_up_origin ) )
    {
        level thread ‪zm_powerups::specific_powerup_drop( "full_ammo", power_up_origin );
    }
    
    wait(2);
    ‪util::clientNotify( "dog_stop" );
    wait(6);
    level.dog_intermission = false;
 
    //level thread dog_round_aftermath();
 
}
 
 
//
//  In Factory, there's a single spawner and the struct is passed in as the second argument.
function ‪dog_spawn_fx( ai, ent )
{
    ai endon( "death" );
    
    /*if ( !IsDefined(ent) )
    {
        ent = struct::get( self.target, "targetname" );
    }*/
 
    ai SetFreeCameraLockOnAllowed( false );
//  if ( isdefined( ent ) )
    {
        Playfx( level._effect["lightning_dog_spawn"], ent.origin );
        playsoundatposition( "zmb_hellhound_prespawn", ent.origin );
        wait( 1.5 );
        playsoundatposition( "zmb_hellhound_bolt", ent.origin );
 
        Earthquake( 0.5, 0.75, ent.origin, 1000);
        //PlayRumbleOnPosition("explosion_generic", ent.origin);
        playsoundatposition( "zmb_hellhound_spawn", ent.origin );
 
        // face the enemy
        if ( IsDefined( ai.favoriteenemy ) )
        {
            angle = VectorToAngles( ai.favoriteenemy.origin - ent.origin );
            angles = ( ai.angles[0], angle[1], ai.angles[2] );
        }
        else
        {
            angles = ent.angles;
        }
        ai ForceTeleport( ent.origin, angles );
    }
 
    assert( isdefined( ai ), "Ent isn't defined." );
    assert( IsAlive( ai ), "Ent is dead." );
    assert( ai.isdog, "Ent isn't a dog;" );
    assert( ‪zm_utility::is_magic_bullet_shield_enabled( ai ), "Ent doesn't have a magic bullet shield." );
 
    ai ‪zombie_setup_attack_properties_dog();
    ai ‪util::stop_magic_bullet_shield();
 
    wait( 0.1 ); // dog should come out running after this wait
    ai show();
    ai SetFreeCameraLockOnAllowed( true );
    ai.ignoreme = false; // don't let attack dogs give chase until the wolf is visible
    ai notify( "visible" );
}
 
 
//
//  Dog spawning logic for Factory.  
//  Makes use of the _zm_zone_manager and specially named structs for each zone to
//  indicate dog spawn locations instead of constantly using ents.
//  
function ‪dog_spawn_factory_logic( favorite_enemy)
{
    dog_locs = array::randomize( level.zm_loc_types[ "dog_location" ] );
    //assert( dog_locs.size > 0, "Dog Spawner locs array is empty." );
 
    for( i = 0; i < dog_locs.size; i++ )
    {
        if( isdefined( level.old_dog_spawn ) && level.old_dog_spawn == dog_locs[i] )
        {
            continue;
        }
 
        if( !isdefined( favorite_enemy ) )
        {
            continue;   
        }
        
        dist_squared = DistanceSquared( dog_locs[i].origin, favorite_enemy.origin );
        if(  dist_squared > ( 400 * 400 ) && dist_squared < ( 1000 * 1000 ) )
        {
            level.old_dog_spawn = dog_locs[i];
            return dog_locs[i];
        }   
    }
 
    return dog_locs[0];
}
 
 
function ‪get_favorite_enemy()
{
    dog_targets = getplayers();
    least_hunted = dog_targets[0];
    for( i = 0; i < dog_targets.size; i++ )
    {
        if ( !isdefined( dog_targets[i].hunted_by ) )
        {
            dog_targets[i].hunted_by = 0;
        }
 
        if( !‪zm_utility::is_player_valid( dog_targets[i] ) )
        {
            continue;
        }
 
        if( !‪zm_utility::is_player_valid( least_hunted ) )
        {
            least_hunted = dog_targets[i];
        }
            
        if( dog_targets[i].hunted_by < least_hunted.hunted_by )
        {
            least_hunted = dog_targets[i];
        }
 
    }
    // do not return the default first player if he is invalid
    if( !‪zm_utility::is_player_valid( least_hunted ) )
    {
        return undefined;
    }
    else
    {
        least_hunted.hunted_by += 1;
 
        return least_hunted;
    }
 
}
 
 
function ‪dog_health_increase()
{
    players = getplayers();
 
    if( level.dog_round_count == 1 )
    {
        level.dog_health = 400;
    }
    else if( level.dog_round_count == 2 )
    {
        level.dog_health = 900;
    }
    else if( level.dog_round_count == 3 )
    {
        level.dog_health = 1300;
    }
    else if( level.dog_round_count == 4 )
    {
        level.dog_health = 1600;
    }
 
    if( level.dog_health > 1600 )
    {
        level.dog_health = 1600;
    }
}
 
function ‪dog_round_wait_func()
{
    if( level ‪flag::get("dog_round" ) )
    {
        wait(7);
        while( level.dog_intermission )
        {
            wait(0.5);
        }   
        ‪zm::increment_dog_round_stat("finished");   
    }
    
    level.sndMusicSpecialRound = false;
}
 
function ‪dog_round_tracker()
{   
    level.dog_round_count = 1;
    
    // PI_CHANGE_BEGIN - JMA - making dog rounds random between round 5 thru 7
    // NOTE:  RandomIntRange returns a random integer r, where min <= r < max
    
    level.next_dog_round = level.round_number + randomintrange( 4, 7 ); 
    // PI_CHANGE_END
    
    old_spawn_func = level.round_spawn_func;
    old_wait_func  = level.round_wait_func;
 
    while ( 1 )
    {
        level waittill ( "between_round_over" );
 
        if ( level.round_number == level.next_dog_round )
        {
            level.sndMusicSpecialRound = true;
            old_spawn_func = level.round_spawn_func;
            old_wait_func  = level.round_wait_func;
            ‪dog_round_start();
            level.round_spawn_func = &‪dog_round_spawning;
            level.round_wait_func = &‪dog_round_wait_func;
 
            level.next_dog_round = level.round_number + randomintrange( 4, 6 );
        }
        else if ( level ‪flag::get( "dog_round" ) )
        {
            ‪dog_round_stop();
            level.round_spawn_func = old_spawn_func;
            level.round_wait_func  = old_wait_func;
            level.dog_round_count += 1;
        }
    }   
}
 
 
function ‪dog_round_start()
{
    level ‪flag::set( "dog_round" );
    level ‪flag::set( "special_round" );
    level ‪flag::set( "dog_clips" );
    
    level notify( "dog_round_starting" );
    level thread ‪zm_audio::sndMusicSystem_PlayState( "dog_start" );
    ‪util::clientNotify( "dog_start" );
 
    if(isdefined(level.dog_melee_range))
    {
        SetDvar( "ai_meleeRange", level.dog_melee_range ); 
    }
    else
    {
        SetDvar( "ai_meleeRange", 100 ); 
    }
}
 
 
function ‪dog_round_stop()
{
    level ‪flag::clear( "dog_round" );
    level ‪flag::clear( "special_round" );
    level ‪flag::clear( "dog_clips" );
    
    level notify( "dog_round_ending" );
    ‪util::clientNotify( "dog_stop" );
    
    SetDvar( "ai_meleeRange", level.melee_range_sav ); 
    SetDvar( "ai_meleeWidth", level.melee_width_sav );
    SetDvar( "ai_meleeHeight", level.melee_height_sav );
}
 
 
function ‪play_dog_round()
{
    self playlocalsound( "zmb_dog_round_start" );
    variation_count =5;
    
    wait(4.5);
 
    players = getplayers();
    num = randomintrange(0,players.size);
    players[num] ‪zm_audio::create_and_play_dialog( "general", "dog_spawn" );
}
 
 
function ‪dog_init()
{
    self.targetname = "zombie_dog";
    self.script_noteworthy = undefined;
    self.animname = "zombie_dog";       
    self.ignoreall = true; 
    self.ignoreme = true; // don't let attack dogs give chase until the wolf is visible
    self.allowdeath = true;             // allows death during animscripted calls
    self.allowpain = false;
    self.force_gib = true;      // needed to make sure this guy does gibs
    self.is_zombie = true;          // needed for melee.gsc in the animscripts
    // out both legs and then the only allowed stance should be prone.
    self.gibbed = false; 
    self.head_gibbed = false;
    self.default_goalheight = 40;
    self.ignore_inert = true;   
    
    self.holdfire           = true;
 
    //  self.disableArrivals = true; 
    //  self.disableExits = true; 
    self.grenadeawareness = 0;
    self.badplaceawareness = 0;
 
    self.ignoreSuppression = true;  
    self.suppressionThreshold = 1; 
    self.noDodgeMove = true; 
    self.dontShootWhileMoving = true;
    self.pathenemylookahead = 0;
 
    self.badplaceawareness = 0;
    self.chatInitialized = false;
 
    self.team = level.zombie_team;
    self.heroweapon_kill_power = ‪ZM_DOGS_HERO_WEAPON_KILL_POWER;
 
    self AllowPitchAngle( 1 );
    self setPitchOrient();
    self setAvoidanceMask( "avoid none" );
 
    self PushActors( true );
 
    health_multiplier = 1.0;
    if ( GetDvarString( "scr_dog_health_walk_multiplier" ) != "" )
    {
        health_multiplier = GetDvarFloat( "scr_dog_health_walk_multiplier" );
    }
 
    self.maxhealth = int( level.dog_health * health_multiplier );
    self.health = int( level.dog_health * health_multiplier );
 
    self.freezegun_damage = 0;
    
    self.zombie_move_speed = "sprint";
    self.a.nodeath = true;//Always explode on death
 
    self thread ‪dog_run_think();
    self thread ‪dog_stalk_audio();
 
    self thread ‪zombie_utility::round_spawn_failsafe();
    self ghost();
    self thread ‪util::magic_bullet_shield();
 
    self thread ‪dog_death();
    
    level thread ‪zm_spawner::zombie_death_event( self ); 
    self thread ‪zm_spawner::enemy_death_detection();
    self thread ‪zm_audio::zmbAIVox_NotifyConvert();
 
    self.a.disablePain = true;
    self ‪zm_utility::disable_react(); // SUMEET - zombies dont use react feature.
    self ClearGoalVolume();
 
    self.flame_damage_time = 0;
    self.meleeDamage = 40;
 
    self.thundergun_knockdown_func =&‪dog_thundergun_knockdown;
 
    self ‪zm_spawner::zombie_history( "zombie_dog_spawn_init -> Spawned = " + self.origin );
    
    if ( isdefined(level.achievement_monitor_func) )
    {
        self [[level.achievement_monitor_func]]();
    }
}
 
function ‪dog_death()
{
    self waittill( "death" );
 
    if( ‪zombie_utility::get_current_zombie_count() == 0 && level.zombie_total == 0 )
    {
 
        level.last_dog_origin = self.origin;
        level notify( "last_ai_down", self );
 
    }
 
    // score
    if( IsPlayer( self.attacker ) )
    {
        event = "death";
        if ( self.damageweapon.isBallisticKnife )
        {
            event = "ballistic_knife_death";
        }   
        
        if ( !‪IS_TRUE( self.deathpoints_already_given ) )
        {
            self.attacker ‪zm_score::player_add_points( event, self.damagemod, self.damagelocation, true );
        }
        
        if( isdefined(level.hero_power_update))
        {
            [[level.hero_power_update]]( self.attacker, self );
        }       
        
        if( RandomIntRange(0,100) >= 80 )
        {
            self.attacker ‪zm_audio::create_and_play_dialog( "kill", "hellhound" );
        }
        
        //stats
        self.attacker ‪zm_stats::increment_client_stat( "zdogs_killed" );
        self.attacker ‪zm_stats::increment_player_stat( "zdogs_killed" );
    }
 
    // switch to inflictor when SP DoDamage supports it
    if( isdefined( self.attacker ) && isai( self.attacker ) )
    {
        self.attacker notify( "killed", self );
    }
 
    // sound
    self stoploopsound();
 
    // just explode if we died on an incline greater than 10 degrees
    if ( !‪IS_TRUE( self.‪a.nodeath ) )
    {
        ‪trace = GroundTrace( self.origin + ( 0, 0, 10 ), self.origin - ( 0, 0, 30 ), false, self );
        if ( ‪trace["fraction"] < 1 )
        {
            pitch = Acos( VectorDot( ‪trace["normal"], ( 0, 0, 1 ) ) );
            if ( pitch > 10 )
            {
                self.a.nodeath = true;
            }
        }
    }
 
    if ( isdefined( self.‪a.nodeath ) )
    {
        level thread ‪dog_explode_fx( self.origin );
        self delete();
    }
    else
    {
        self notify( "bhtn_action_notify", "death" );
    }
}
 
 
function ‪dog_explode_fx( origin )
{
    PlayFX( level._effect["dog_gib"], origin );
    PlaySoundAtPosition( "zmb_hellhound_explode", origin );
}
 
 
// this is where zombies go into attack mode, and need different attributes set up
function ‪zombie_setup_attack_properties_dog()
{
    self ‪zm_spawner::zombie_history( "zombie_setup_attack_properties()" );
    
    self thread ‪dog_behind_audio();
 
    // allows zombie to attack again
    self.ignoreall = false; 
 
    //self.pathEnemyFightDist = 64;
    self.meleeAttackDist = 64;
 
    // turn off transition anims
    self.disableArrivals = true; 
    self.disableExits = true; 
 
    if ( isdefined( level.dog_setup_func ) )
    {
        self [[level.dog_setup_func]]();
    }
}
 
 
//COLLIN'S Audio Scripts
function ‪stop_dog_sound_on_death()
{
    self waittill("death");
    self stopsounds();
}
 
function ‪dog_behind_audio()
{
    self thread ‪stop_dog_sound_on_death();
 
    self endon("death");
    self ‪util::waittill_any( "dog_running", "dog_combat" );
    
    self notify( "bhtn_action_notify", "close" );
    wait( 3 );
 
    while(1)
    {
        players = GetPlayers();
        for(i=0;i<players.size;i++)
        {
            dogAngle = AngleClamp180( vectorToAngles( self.origin - players[i].origin )[1] - players[i].angles[1] );
        
            if(isAlive(players[i]) && !isdefined(players[i].revivetrigger))
            {
                if ((abs(dogAngle) > 90) && distance2d(self.origin,players[i].origin) > 100)
                {
                    self notify( "bhtn_action_notify", "close" );
                    wait( 3 );
                }
            }
        }
        
        wait(.75);
    }
}
 
 
//
//  Keeps dog_clips up if there is a dog running around in the level.
function ‪dog_clip_monitor()
{
    clips_on = false;
    level.dog_clips = GetEntArray( "dog_clips", "targetname" );
    while (1)
    {
        for ( i=0; i<level.dog_clips.size; i++ )
        {
    //      level.dog_clips[i] TriggerEnable( false );
            level.dog_clips[i] ConnectPaths();
        }
 
        level ‪flag::wait_till( "dog_clips" );
        
        if(isdefined(level.no_dog_clip) && level.no_dog_clip == true)
        {
            return;
        }
        
        for ( i=0; i<level.dog_clips.size; i++ )
        {
    //      level.dog_clips[i] TriggerEnable( true );
            level.dog_clips[i] DisconnectPaths();
            ‪util::wait_network_frame();
        }
 
        dog_is_alive = true;
        while ( dog_is_alive || level ‪flag::get( "dog_round" ) )
        {
            dog_is_alive = false;
            dogs = GetEntArray( "zombie_dog", "targetname" );
            for ( i=0; i<dogs.size; i++ )
            {
                if ( IsAlive(dogs[i]) )
                {
                    dog_is_alive = true;
                }
            }
            wait( 1 );
        }
 
        level ‪flag::clear( "dog_clips" );
        wait(1);
    }
}
 
//
//  Allows dogs to be spawned independent of the round spawning
function ‪special_dog_spawn( num_to_spawn, spawners, spawn_point )
{
    dogs = GetAISpeciesArray( "all", "zombie_dog" );
 
    if ( isdefined( dogs ) && dogs.size >= 9 )
    {
        return false;
    }
    
    if ( !isdefined(num_to_spawn) )
    {
        num_to_spawn = 1;
    }
 
    spawn_point = undefined;
    count = 0;
    while ( count < num_to_spawn )
    {
        //update the player array.
        players = GetPlayers();
        favorite_enemy = ‪get_favorite_enemy();
 
        if ( isdefined( spawners ) )
        {
            if ( !isdefined( spawn_point ) )
            {
                spawn_point = spawners[ RandomInt(spawners.size) ];
            }
            ai = ‪zombie_utility::spawn_zombie( spawn_point );
 
            if( isdefined( ai ) )   
            {
                ai.favoriteenemy = favorite_enemy;
                spawn_point thread ‪dog_spawn_fx( ai );
                count++;
                level ‪flag::set( "dog_clips" );
            }
        }
        else
        {
            if ( isdefined( level.dog_spawn_func ) )
            {
                spawn_loc = [[level.dog_spawn_func]]( level.dog_spawners, favorite_enemy );
 
                ai = ‪zombie_utility::spawn_zombie( level.dog_spawners[0] );
                if( isdefined( ai ) )   
                {
                    ai.favoriteenemy = favorite_enemy;
                    spawn_loc thread ‪dog_spawn_fx( ai, spawn_loc );
                    count++;
                    level ‪flag::set( "dog_clips" );
                }
            }
            else
            {
                // Default method
                spawn_point = ‪dog_spawn_factory_logic( favorite_enemy );
                ai = ‪zombie_utility::spawn_zombie( level.dog_spawners[0] );
 
                if( isdefined( ai ) )   
                {
                    ai.favoriteenemy = favorite_enemy;
                    spawn_point thread ‪dog_spawn_fx( ai, spawn_point );
                    count++;
                    level ‪flag::set( "dog_clips" );
                }
            }
        }
 
        ‪waiting_for_next_dog_spawn( count, num_to_spawn );
    }
 
    return true;
}
 
function ‪dog_run_think()
{
    self endon( "death" );
 
    // these should go back in when the stalking stuff is put back in, the visible check will do for now
    //self util::waittill_any( "dog_running", "dog_combat" );
    //self playsound( "zdog_close" );
    self waittill( "visible" );
    
    // decrease health
    if ( self.health > level.dog_health )
    {
        self.maxhealth = level.dog_health;
        self.health = level.dog_health;
    }
    
    // start glowing eyes & fire trail
    self ‪clientfield::set( "dog_fx", 1 );
    self playloopsound( "zmb_hellhound_loop_fire" );
 
    //Check to see if the enemy is not valid anymore
    while( true )
    {
        if( !‪zm_utility::is_player_valid(self.favoriteenemy) )
        {
            //We are targetting an invalid player - select another one
            self.favoriteenemy = ‪get_favorite_enemy();
        }
        if( isdefined( level.custom_dog_target_validity_check ) )
        {
            self [[ level.custom_dog_target_validity_check ]]();
        } 
        wait( 0.2 );
    
    }
}
 
function ‪dog_stalk_audio()
{
    self endon( "death" );
    self endon( "dog_running" );
    self endon( "dog_combat" );
    
    while(1)
    {
        self notify( "bhtn_action_notify", "ambient" );
        wait randomfloatrange(2,4);     
    }
}
 
function ‪dog_thundergun_knockdown( player, ‪gib )
{
    self endon( "death" );
 
    ‪damage = int( self.maxhealth * 0.5 );
    self DoDamage( ‪damage, player.origin, player );
}