Remove Zombie Dying by Himself

[Ivobardolf]

Hello,

In order to stop Zombies from dying by being Idle for too long & if they are far from you, you change these functions ( This is for Origins, Other maps should be the same by replacing the names and some don't use a function from this ), First Idle:

tomb_round_spawn_failsafe()//tomp is Origins name

replace OR comment out:

self dodamage( self.health + 100, ( 0, 0, 0 ) );
level.zombie_total++;
level.zombie_total_subtract++;

zombie_damage_failsafe()//this for damaged or missing limbs

replace OR comment out:

self.enemy dodamage( self.enemy.health + 1000, self.enemy.origin, self, self, "none", "MOD_RIFLE_BULLET" );
continue_failsafe_damage = 1;

for far away:

delete_zombie_noone_looking( how_close, how_high )//every map has this

replace OR comment out:

self notify( "zombie_delete" );
self delete();
level.zombie_total++;           level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;

here is a GSC script for Origins:

#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\zombies\_zm_utility;


main()
{
    replaceFunc(maps\mp\zm_tomb_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);
    replaceFunc(maps\mp\zm_tomb::tomb_round_spawn_failsafe, ::tomb_round_spawn_failsafe);// tomb is origins name
    replaceFunc(maps\mp\zombies\_zm::round_spawn_failsafe, ::round_spawn_failsafe);
}

delete_zombie_noone_looking( how_close, how_high )
{
    self endon( "death" );

    if ( !isdefined( how_close ) )
        how_close = 1500;

    if ( !isdefined( how_high ) )
        how_high = 600;

    distance_squared_check = how_close * how_close;
    too_far_dist = distance_squared_check * 3;

    if ( isdefined( level.zombie_tracking_too_far_dist ) )
        too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;

    self.inview = 0;
    self.player_close = 0;
    n_distance_squared = 0;
    n_height_difference = 0;
    players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
        if ( players[i].sessionstate == "spectator" )
            continue;

        if ( isdefined( level.only_track_targeted_players ) )
        {
            if ( !isdefined( self.favoriteenemy ) || self.favoriteenemy != players[i] )
                continue;
        }

        can_be_seen = self player_can_see_me( players[i] );

        if ( can_be_seen && distancesquared( self.origin, players[i].origin ) < too_far_dist )
            self.inview++;

        n_modifier = 1.0;

        if ( isdefined( players[i].b_in_tunnels ) && players[i].b_in_tunnels )
            n_modifier = 2.25;

        n_distance_squared = distancesquared( self.origin, players[i].origin );
        n_height_difference = abs( self.origin[2] - players[i].origin[2] );

        if ( n_distance_squared < distance_squared_check * n_modifier && n_height_difference < how_high )
            self.player_close++;
    }

    if ( self.inview == 0 && self.player_close == 0 )
    {
        if ( !isdefined( self.animname ) || self.animname != "zombie" && self.animname != "mechz_zombie" )
            return;

        if ( isdefined( self.electrified ) && self.electrified == 1 )
            return;

        if ( isdefined( self.in_the_ground ) && self.in_the_ground == 1 )
            return;

        zombies = getaiarray( "axis" );

        if ( ( !isdefined( self.damagemod ) || self.damagemod == "MOD_UNKNOWN" ) && self.health < self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }
        else if ( zombies.size + level.zombie_total > 24 || zombies.size + level.zombie_total <= 24 && self.health >= self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 1;
                //level.zombie_total++;

                if ( self.health < level.zombie_health )
                    level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }

        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
        //self notify( "zombie_delete" );
        empty = 0;

        if ( isdefined( self.is_mechz ) && self.is_mechz )
        {
            self notify( "mechz_cleanup" );
            level.mechz_left_to_spawn++;
            wait_network_frame();
            level notify( "spawn_mechz" );
        }
        empty = 0;
        //self delete();
        recalc_zombie_array();
    }
}

tomb_round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 15;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < -3000 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) && !( isdefined( self.is_brutus ) && self.is_brutus ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( !level.zombie_vars["zombie_use_failsafe"] )
            return;

        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 30;

        if ( !self.has_legs )
            wait 10.0;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < level.zombie_vars["below_world_check"] )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

here is a GSC script for Buried:

#include maps\mp\gametypes_zm\_hud_util;
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_spawnlogic;

main()
{
    replaceFunc(maps\mp\zm_buried_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);
    replaceFunc(maps\mp\zombies\_zm::round_spawn_failsafe, ::round_spawn_failsafe);
}


delete_zombie_noone_looking( how_close, how_high )
{
    self endon( "death" );

    if ( self can_be_deleted_from_buried_special_zones() )
    {
        self.inview = 0;
        self.player_close = 0;
    }
    else
    {
        if ( !isdefined( how_close ) )
            how_close = 1000;

        if ( !isdefined( how_high ) )
            how_high = 500;

        if ( !( isdefined( self.has_legs ) && self.has_legs ) )
            how_close = how_close * 1.5;

        distance_squared_check = how_close * how_close;
        height_squared_check = how_high * how_high;
        too_far_dist = distance_squared_check * 3;

        if ( isdefined( level.zombie_tracking_too_far_dist ) )
            too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;

        self.inview = 0;
        self.player_close = 0;
        players = get_players();

        foreach ( player in players )
        {
            if ( player.sessionstate == "spectator" )
                continue;

            if ( isdefined( player.laststand ) && player.laststand && ( isdefined( self.favoriteenemy ) && self.favoriteenemy == player ) )
            {
                if ( !self can_zombie_see_any_player() )
                {
                    self.favoriteenemy = undefined;
                    self.zombie_path_bad = 1;
                    self thread escaped_zombies_cleanup();
                }
            }

            if ( isdefined( level.only_track_targeted_players ) )
            {
                if ( !isdefined( self.favoriteenemy ) || self.favoriteenemy != player )
                    continue;
            }

            can_be_seen = self player_can_see_me( player );
            distance_squared = distancesquared( self.origin, player.origin );

            if ( can_be_seen && distance_squared < too_far_dist )
                self.inview++;

            if ( distance_squared < distance_squared_check && abs( self.origin[2] - player.origin[2] ) < how_high )
                self.player_close++;
        }
    }

    wait 0.1;

    if ( self.inview == 0 && self.player_close == 0 )
    {
        if ( !isdefined( self.animname ) || isdefined( self.animname ) && self.animname != "zombie" )
            return;

        if ( isdefined( self.electrified ) && self.electrified == 1 )
            return;

        zombies = getaiarray( "axis" );

        if ( zombies.size + level.zombie_total > 24 || zombies.size + level.zombie_total <= 24 && self.health >= self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;

                if ( self.health < level.zombie_health )
                    level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }

        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
        //self notify( "zombie_delete" );

        if ( isdefined( self.anchor ) )
            //self.anchor delete();

        //self delete();
        recalc_zombie_array();
    }
}

round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( !level.zombie_vars["zombie_use_failsafe"] )
            return;

        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 30;

        if ( !self.has_legs )
            wait 10.0;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < level.zombie_vars["below_world_check"] )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

here is a GSC script for Mob of the Dead:

#include maps\mp\gametypes_zm\_hud_util;
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_spawnlogic;

main()
{
    replaceFunc(maps\mp\zm_alcatraz_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);
    replaceFunc(maps\mp\zm_prison::alcatraz_round_spawn_failsafe, ::alcatraz_round_spawn_failsafe);// tomb is origins name
    replaceFunc(maps\mp\zombies\_zm::round_spawn_failsafe, ::round_spawn_failsafe);
}

delete_zombie_noone_looking( how_close, how_high )
{
    self endon( "death" );

    if ( !isdefined( how_close ) )
        how_close = 1500;

    if ( !isdefined( how_high ) )
        how_close = 600;

    distance_squared_check = how_close * how_close;
    too_far_dist = distance_squared_check * 3;

    if ( isdefined( level.zombie_tracking_too_far_dist ) )
        too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;

    self.inview = 0;
    self.player_close = 0;
    players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
        if ( players[i].sessionstate == "spectator" )
            continue;

        if ( isdefined( level.only_track_targeted_players ) )
        {
            if ( !isdefined( self.favoriteenemy ) || self.favoriteenemy != players[i] )
                continue;
        }

        can_be_seen = self player_can_see_me( players[i] );

        if ( can_be_seen && distancesquared( self.origin, players[i].origin ) < too_far_dist )
            self.inview++;

        if ( distancesquared( self.origin, players[i].origin ) < distance_squared_check && abs( self.origin[2] - players[i].origin[2] ) < how_high )
            self.player_close++;
    }

    wait 0.1;

    if ( self.inview == 0 && self.player_close == 0 )
    {
        if ( !isdefined( self.animname ) || isdefined( self.animname ) && self.animname != "zombie" )
            return;

        if ( isdefined( self.electrified ) && self.electrified == 1 )
            return;

        if ( isdefined( self.in_the_ground ) && self.in_the_ground == 1 )
            return;

        zombies = getaiarray( "axis" );

        if ( ( !isdefined( self.damagemod ) || self.damagemod == "MOD_UNKNOWN" ) && self.health < self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;
                //level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }
        else if ( zombies.size + level.zombie_total > 24 || zombies.size + level.zombie_total <= 24 && self.health >= self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;

                if ( self.health < level.zombie_health )
                    level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }

        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
        //self notify( "zombie_delete" );
        //self delete();
        recalc_zombie_array();
    }
}

alcatraz_round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 15;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < -15000 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) && !( isdefined( self.is_brutus ) && self.is_brutus ) )
                {
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/

            if ( isdefined( self.is_brutus ) && self.is_brutus )
            {
                self.suppress_brutus_powerup_drop = 1;
                self.brutus_round_spawn_failsafe = 1;
            }

            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( !level.zombie_vars["zombie_use_failsafe"] )
            return;

        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 30;

        if ( !self.has_legs )
            wait 10.0;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < level.zombie_vars["below_world_check"] )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

here is a GSC script for Die Rise:

#include maps\mp\gametypes_zm\_hud_util;
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_spawnlogic;

main()
{
    replaceFunc(maps\mp\zm_highrise_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);
    replaceFunc(maps\mp\zombies\_zm::round_spawn_failsafe, ::round_spawn_failsafe);
}

delete_zombie_noone_looking( how_close, how_high )
{
    self endon( "death" );

    if ( !isdefined( how_close ) )
        how_close = 1000;

    if ( !isdefined( how_high ) )
        how_high = 500;

    distance_squared_check = how_close * how_close;
    height_squared_check = how_high * how_high;
    too_far_dist = distance_squared_check * 3;

    if ( isdefined( level.zombie_tracking_too_far_dist ) )
        too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;

    self.inview = 0;
    self.player_close = 0;
    players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
        if ( players[i].sessionstate == "spectator" )
            continue;

        if ( isdefined( level.only_track_targeted_players ) )
        {
            if ( !isdefined( self.favoriteenemy ) || self.favoriteenemy != players[i] )
                continue;
        }

        can_be_seen = self player_can_see_me( players[i] );

        if ( can_be_seen && distancesquared( self.origin, players[i].origin ) < too_far_dist )
            self.inview++;

        if ( distancesquared( self.origin, players[i].origin ) < distance_squared_check && abs( self.origin[2] - players[i].origin[2] ) < how_high )
            self.player_close++;
    }

    wait 0.1;

    if ( self.inview == 0 && self.player_close == 0 )
    {
        if ( !isdefined( self.animname ) || isdefined( self.animname ) && self.animname != "zombie" )
            return;

        if ( isdefined( self.electrified ) && self.electrified == 1 )
            return;

        zombies = getaiarray( "axis" );

        if ( zombies.size + level.zombie_total > 24 || zombies.size + level.zombie_total <= 24 && self.health >= self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;

                if ( self.health < level.zombie_health )
                    level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }

        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
        //self notify( "zombie_delete" );
        //self delete();
        recalc_zombie_array();
    }
}


round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( !level.zombie_vars["zombie_use_failsafe"] )
            return;

        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 30;

        if ( !self.has_legs )
            wait 10.0;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < level.zombie_vars["below_world_check"] )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

here is a GSC script for Tranzit:

#include maps\mp\gametypes_zm\_hud_util;
#include common_scripts\utility;
#include maps\mp\_utility;
#include maps\mp\zombies\_zm_utility;
#include maps\mp\gametypes_zm\_spawnlogic;


main()
{
    replaceFunc(maps\mp\zm_transit_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);
    replaceFunc(maps\mp\zombies\_zm::round_spawn_failsafe, ::round_spawn_failsafe);
}

delete_zombie_noone_looking( how_close )
{
    self endon( "death" );

    if ( !isdefined( how_close ) )
        how_close = 1000;

    distance_squared_check = how_close * how_close;
    too_far_dist = distance_squared_check * 3;

    if ( isdefined( level.zombie_tracking_too_far_dist ) )
        too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist;

    self.inview = 0;
    self.player_close = 0;
    players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
        if ( players[i].sessionstate == "spectator" )
            continue;

        if ( isdefined( level.only_track_targeted_players ) )
        {
            if ( !isdefined( self.favoriteenemy ) || self.favoriteenemy != players[i] )
                continue;
        }

        can_be_seen = self player_can_see_me( players[i] );

        if ( can_be_seen && distancesquared( self.origin, players[i].origin ) < too_far_dist )
            self.inview++;

        if ( distancesquared( self.origin, players[i].origin ) < distance_squared_check )
            self.player_close++;
    }

    wait 0.1;

    if ( self.inview == 0 && self.player_close == 0 )
    {
        if ( !isdefined( self.animname ) || isdefined( self.animname ) && self.animname != "zombie" )
            return;

        if ( isdefined( self.electrified ) && self.electrified == 1 )
            return;

        if ( isdefined( self.in_the_ground ) && self.in_the_ground == 1 )
            return;

        zombies = getaiarray( "axis" );

        if ( ( !isdefined( self.damagemod ) || self.damagemod == "MOD_UNKNOWN" ) && self.health < self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;
                //level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }
        else if ( zombies.size + level.zombie_total > 24 || zombies.size + level.zombie_total <= 24 && self.health >= self.maxhealth )
        {
            if ( !( isdefined( self.exclude_distance_cleanup_adding_to_total ) && self.exclude_distance_cleanup_adding_to_total ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                //level.zombie_total++;

                if ( self.health < level.zombie_health )
                    level.zombie_respawned_health[level.zombie_respawned_health.size] = self.health;
            }
        }

        self maps\mp\zombies\_zm_spawner::reset_attack_spot();
        //self notify( "zombie_delete" );
        //self delete();
        recalc_zombie_array();
    }
}

round_spawn_failsafe()
{
    self endon( "death" );
    prevorigin = self.origin;

    while ( true )
    {
        if ( !level.zombie_vars["zombie_use_failsafe"] )
            return;

        if ( isdefined( self.ignore_round_spawn_failsafe ) && self.ignore_round_spawn_failsafe )
            return;

        wait 30;

        if ( !self.has_legs )
            wait 10.0;

        if ( isdefined( self.is_inert ) && self.is_inert )
            continue;

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 8000 )
                continue;
        }

        if ( self.origin[2] < level.zombie_vars["below_world_check"] )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) && !( isdefined( self.isscreecher ) && self.isscreecher ) )
            {
                empty = 0;
                //level.zombie_total++;
                //level.zombie_total_subtract++;
            }

/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
            if ( isdefined( level.put_timed_out_zombies_back_in_queue ) && level.put_timed_out_zombies_back_in_queue && !flag( "dog_round" ) )
            {
                if ( !self.ignoreall && !( isdefined( self.nuked ) && self.nuked ) && !( isdefined( self.marked_for_death ) && self.marked_for_death ) && !( isdefined( self.isscreecher ) && self.isscreecher ) && ( isdefined( self.has_legs ) && self.has_legs ) )
                {
                    empty = 0;
                    //level.zombie_total++;
                    //level.zombie_total_subtract++;
                }
            }

            level.zombies_timeout_playspace++;
/#

#/
            empty = 0;
            //self dodamage( self.health + 100, ( 0, 0, 0 ) );
            break;
        }

        prevorigin = self.origin;
    }
}

[Claronte]

This post is deleted!

[Ivobardolf]

iluisey each map has the same checks, it just a name change

replaceFunc(maps\mp\zm_tomb::tomb_round_spawn_failsafe, ::tomb_round_spawn_failsafe)
replaceFunc(maps\mp\zm_tomb_distance_tracking::delete_zombie_noone_looking, ::delete_zombie_noone_looking);

zm_tomb is orignis, zm_transit is for tranzit etc

[xNando]

Ivobardolf but in the code you can write multiple replaceFunc with the names of each map?? Or do you need to create a script for each map...?

[Ivobardolf]

xNando you can make on big replace func and add a check for each map so it auto loads from one script

or make a file for each map

I might do it later

[xNando]

Ivobardolf If you can, do your best!

[JezuzLizard]

Ivobardolf You need to use getfunction if you want to do it in one file. Otherwise you'll get unresolved externals when loading on a map that doesn't have the functions you reference.

[Ivobardolf]

JezuzLizard don't know how it works

[JezuzLizard]

Ivobardolf https://github.com/JezuzLizard/t6-fastfile-mods/blob/f7f3ed71b798fc0977cda1268bdc8946a895ddb4/zm_ai_pack/pluto_sys.gsc#L68

[Honey-_badger]

anti depressants

[Ivobardolf]

Update: All maps have been added, except Nuketown

[xNando]

Ivobardolf I don't know what I'm doing wrong... (I've tried it in origins)

[Ivobardolf]

xNando hmm, did you just copy the script of origins?

every map has its own thing, some things are the same though

[xNando]

Ivobardolf yes, and also I uncommented the commented lines

[Ivobardolf]

xNando compare your script with the one from the post above, see where you made a difference, I just tried the one in the post and it works

[T.Re.Viento]

i tried it in origins, works like a charm, but i got one minnor issue, if some zombies spawn in crazy place and the player go out, the zombies got stuck in the crazy place, i know its something related to zombies far away respawn locked in this mod, there is a fix for this or messes the whole script?

[WolflexZ]

I'm pretty sure zombies has a time limit before they die. It's to prevent in case a zombie bugs out of the map etc. In any case, many of you don't really need this script. Cause if a zombie doesn't hit you before that time limit, it leads to it dying. Letting the zombie hit you once between time intervals allows it to stay alive. Although I could be wrong.

[Ivobardolf]

T.Re.Viento Thanks for trying it, but I'm curious, why do you use it ?

yeah, Origins and Motd and some areas in other maps need the things I disable here for them to respawn the zombies, I can think of a way to make it work, but that isn't what I intended for the script, only thing you can do is only move out and in the crazy place if the rounds are changing.

[Ivobardolf]

WolflexZ They Respawn/Die if they have met certain conditions that I disabled here:
1 - Zombie is far away
2 - Zombie is Idle (he stands in place for too long)
I couldn't find anything related to needing to hit the player

As you said, many people don't need this script, and it might do them more harm then good, it's intended for some uses and not normal play.

[T.Re.Viento]

Ivobardolf Hi mate, thanks for the reply, I'm playing with a friend and we wanted to do the easter egg quietly, without having to babysit a crawler. But I remembered from our old days on ps3 the last zombies would die by themselves if you went too far or a certain amount of time passed, that's why I wanted to try this script. Yesterday we completed the easter egg but it was too easy, the script also makes the zombies never run, I guess this is not intentional. greetings