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

round_start()
{
    if ( isdefined( level.round_prestart_func ) )
        [[ level.round_prestart_func ]]();
    else
    {
        n_delay = 2;

        if ( isdefined( level.zombie_round_start_delay ) )
            n_delay = level.zombie_round_start_delay;

        wait( n_delay );
    }

    level.zombie_health = level.zombie_vars["zombie_health_start"];

    if ( getdvarint( "scr_writeConfigStrings" ) == 1 )
    {
        wait 5;
        exitlevel();
        return;
    }

    if ( level.zombie_vars["game_start_delay"] > 0 )
        round_pause( level.zombie_vars["game_start_delay"] );

    flag_set( "begin_spawning" );

    if ( !isdefined( level.round_spawn_func ) )
        level.round_spawn_func = ::round_spawning;

    if ( !isdefined( level.round_wait_func ) )
        level.round_wait_func = ::round_wait;

    if ( !isdefined( level.round_think_func ) )
        level.round_think_func = ::round_think;

    level thread [[ level.round_think_func ]]();
}

round_spawning()
{
    level endon( "intermission" );
    level endon( "end_of_round" );
    level endon( "restart_round" );

    if ( level.intermission )
        return;

    if ( level.zombie_spawn_locations.size < 1 )
    {
        return;
    }

    ai_calculate_health( level.round_number );
    count = 0;
    players = get_players();

    for ( i = 0; i < players.size; i++ )
        players[i].zombification_time = 0;

    max = level.zombie_vars["zombie_max_ai"];
    multiplier = level.round_number / 5;

    if ( multiplier < 1 )
        multiplier = 1;

    if ( level.round_number >= 10 )
        multiplier *= ( level.round_number * 0.15 );

    player_num = get_players().size;

	max += int( ( player_num * 0.5 ) * level.zombie_vars["zombie_ai_per_player"] * multiplier );

    if ( !isdefined( level.max_zombie_func ) )
        level.max_zombie_func = ::default_max_zombie_func;

    if ( !( isdefined( level.kill_counter_hud ) && level.zombie_total > 0 ) )
    {
        level.zombie_total = [[ level.max_zombie_func ]]( max );
        level notify( "zombie_total_set" );
    }

    if ( isdefined( level.zombie_total_set_func ) )
        level thread [[ level.zombie_total_set_func ]]();

    if ( level.round_number < 10 || level.speed_change_max > 0 )
        level thread zombie_speed_up();

    mixed_spawns = 0;
    old_spawn = undefined;

    while ( true )
    {
        while ( get_current_zombie_count() >= level.zombie_ai_limit || level.zombie_total <= 0 )
            wait 0.1;

        while ( get_current_actor_count() >= level.zombie_actor_limit )
        {
            clear_all_corpses();
            wait 0.1;
        }

        flag_wait( "spawn_zombies" );

        while ( level.zombie_spawn_locations.size <= 0 )
            wait 0.1;

        run_custom_ai_spawn_checks();
        spawn_point = level.zombie_spawn_locations[randomint( level.zombie_spawn_locations.size )];

        if ( !isdefined( old_spawn ) )
            old_spawn = spawn_point;
        else if ( spawn_point == old_spawn )
            spawn_point = level.zombie_spawn_locations[randomint( level.zombie_spawn_locations.size )];

        old_spawn = spawn_point;

        if ( isdefined( level.mixed_rounds_enabled ) && level.mixed_rounds_enabled == 1 )
        {
            spawn_dog = 0;

            if ( level.round_number > 30 )
            {
                if ( randomint( 100 ) < 3 )
                    spawn_dog = 1;
            }
            else if ( level.round_number > 25 && mixed_spawns < 3 )
            {
                if ( randomint( 100 ) < 2 )
                    spawn_dog = 1;
            }
            else if ( level.round_number > 20 && mixed_spawns < 2 )
            {
                if ( randomint( 100 ) < 2 )
                    spawn_dog = 1;
            }
            else if ( level.round_number > 15 && mixed_spawns < 1 )
            {
                if ( randomint( 100 ) < 1 )
                    spawn_dog = 1;
            }

            if ( spawn_dog )
            {
                keys = getarraykeys( level.zones );

                for ( i = 0; i < keys.size; i++ )
                {
                    if ( level.zones[keys[i]].is_occupied )
                    {
                        akeys = getarraykeys( level.zones[keys[i]].adjacent_zones );

                        for ( k = 0; k < akeys.size; k++ )
                        {
                            if ( level.zones[akeys[k]].is_active && !level.zones[akeys[k]].is_occupied && level.zones[akeys[k]].dog_locations.size > 0 )
                            {
                                maps\mp\zombies\_zm_ai_dogs::special_dog_spawn( undefined, 1 );
                                level.zombie_total--;
                                wait_network_frame();
                            }
                        }
                    }
                }
            }
        }

        if ( isdefined( level.zombie_spawners ) )
        {
            if ( isdefined( level.use_multiple_spawns ) && level.use_multiple_spawns )
            {
                if ( isdefined( spawn_point.script_int ) )
                {
                    if ( isdefined( level.zombie_spawn[spawn_point.script_int] ) && level.zombie_spawn[spawn_point.script_int].size )
                        spawner = random( level.zombie_spawn[spawn_point.script_int] );
                }
                else if ( isdefined( level.zones[spawn_point.zone_name].script_int ) && level.zones[spawn_point.zone_name].script_int )
                    spawner = random( level.zombie_spawn[level.zones[spawn_point.zone_name].script_int] );
                else if ( isdefined( level.spawner_int ) && ( isdefined( level.zombie_spawn[level.spawner_int].size ) && level.zombie_spawn[level.spawner_int].size ) )
                    spawner = random( level.zombie_spawn[level.spawner_int] );
                else
                    spawner = random( level.zombie_spawners );
            }
            else
                spawner = random( level.zombie_spawners );

            ai = spawn_zombie( spawner, spawner.targetname, spawn_point );
        }

        if ( isdefined( ai ) )
        {
            level.zombie_total--;
            ai thread round_spawn_failsafe();
            count++;
        }

        wait( level.zombie_vars["zombie_spawn_delay"] );
        wait_network_frame();
    }
}

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

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

        wait 0.05;

        if ( isdefined( self.is_inert ) && self.is_inert )
		{
			prevorigin = self.origin;
			prevorigin_time = gettime();
			continue;
		}

		if ( isdefined( self.in_the_ground ) && self.in_the_ground )
		{
			prevorigin = self.origin;
			prevorigin_time = gettime();
			continue;
		}

		if ( isdefined( self.in_the_ceiling ) && self.in_the_ceiling )
		{
			prevorigin = self.origin;
			prevorigin_time = gettime();
			continue;
		}

        if ( isdefined( self.lastchunk_destroy_time ) )
        {
            if ( gettime() - self.lastchunk_destroy_time < 4000 )
			{
				prevorigin = self.origin;
				prevorigin_time = gettime();
				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 ) )
            {
                level.zombie_total++;
                level.zombie_total_subtract++;
            }

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

        if ( distancesquared( self.origin, prevorigin ) < 576 )
        {
			if ( gettime() - prevorigin_time < 15000 )
                continue;

            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.is_brutus ) && self.is_brutus ) )
                {
                    level.zombie_total++;
                    level.zombie_total_subtract++;

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

            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;
        }
		else
		{
			prevorigin = self.origin;
			prevorigin_time = gettime();
		}
    }
}

round_think( restart = 0 )
{
    level endon( "end_round_think" );

    if ( !( isdefined( restart ) && restart ) )
    {
        if ( isdefined( level.initial_round_wait_func ) )
            [[ level.initial_round_wait_func ]]();

        if ( !( isdefined( level.host_ended_game ) && level.host_ended_game ) )
        {
            players = get_players();

            foreach ( player in players )
            {
                if ( !( isdefined( player.hostmigrationcontrolsfrozen ) && player.hostmigrationcontrolsfrozen ) )
                {
                    player freezecontrols( 0 );
                }

                player maps\mp\zombies\_zm_stats::set_global_stat( "rounds", level.round_number );
            }
        }
    }

    setroundsplayed( level.round_number );

    for (;;)
    {
		if (!is_gametype_active("zgrief"))
		{
			level.player_starting_points = (level.round_number + 1) * 500;
			if (level.player_starting_points > 10000)
			{
				level.player_starting_points = 10000;
			}
		}

        maxreward = 50 * level.round_number;

        if ( maxreward > 500 )
            maxreward = 500;

        level.zombie_vars["rebuild_barrier_cap_per_round"] = maxreward;
        level.pro_tips_start_time = gettime();
        level.zombie_last_run_time = gettime();

        if ( isdefined( level.zombie_round_change_custom ) )
            [[ level.zombie_round_change_custom ]]();
        else
        {
            level thread maps\mp\zombies\_zm_audio::change_zombie_music( "round_start" );
            round_one_up();
        }

        maps\mp\zombies\_zm_powerups::powerup_round_start();
        players = get_players();
        array_thread( players, maps\mp\zombies\_zm_blockers::rebuild_barrier_reward_reset );

        if ( !( isdefined( level.headshots_only ) && level.headshots_only ) && !restart )
            level thread award_grenades_for_survivors();

        bbprint( "zombie_rounds", "round %d player_count %d", level.round_number, players.size );

        level.round_start_time = gettime();

        while ( level.zombie_spawn_locations.size <= 0 )
            wait 0.1;

        level thread [[ level.round_spawn_func ]]();
        level notify( "start_of_round" );
        recordzombieroundstart();
        players = getplayers();

        for ( index = 0; index < players.size; index++ )
        {
            zonename = players[index] get_current_zone();

            if ( isdefined( zonename ) )
                players[index] recordzombiezone( "startingZone", zonename );
        }

        if ( isdefined( level.round_start_custom_func ) )
            [[ level.round_start_custom_func ]]();

        [[ level.round_wait_func ]]();
        level.first_round = 0;
        level notify( "end_of_round" );
        level thread maps\mp\zombies\_zm_audio::change_zombie_music( "round_end" );
        uploadstats();

        if ( isdefined( level.round_end_custom_logic ) )
            [[ level.round_end_custom_logic ]]();

        players = get_players();

        if ( isdefined( level.no_end_game_check ) && level.no_end_game_check )
        {
            level thread last_stand_revive();
            level thread spectators_respawn();
        }
        else if ( 1 != players.size )
            level thread spectators_respawn();

        players = get_players();
        array_thread( players, maps\mp\zombies\_zm_pers_upgrades_system::round_end );
        timer = level.zombie_vars["zombie_spawn_delay"];

        if ( timer > 0.08 )
            level.zombie_vars["zombie_spawn_delay"] = timer * 0.95;
        else if ( timer < 0.08 )
            level.zombie_vars["zombie_spawn_delay"] = 0.08;

        if ( level.gamedifficulty == 0 )
            level.zombie_move_speed = level.round_number * level.zombie_vars["zombie_move_speed_multiplier_easy"];
        else
            level.zombie_move_speed = level.round_number * level.zombie_vars["zombie_move_speed_multiplier"];

        level.round_number++;

        setroundsplayed( level.round_number + int(level.round_number / 256) );
        matchutctime = getutc();
        players = get_players();

        foreach ( player in players )
        {
            if ( level.curr_gametype_affects_rank && level.round_number > 3 + level.start_round )
                player maps\mp\zombies\_zm_stats::add_client_stat( "weighted_rounds_played", level.round_number );

            player maps\mp\zombies\_zm_stats::set_global_stat( "rounds", level.round_number );
            player maps\mp\zombies\_zm_stats::update_playing_utc_time( matchutctime );
        }

        check_quickrevive_for_hotjoin();
        level round_over();
        level notify( "between_round_over" );
        restart = 0;
    }
}

spectators_respawn()
{
    level endon( "between_round_over" );

    if ( !isdefined( level.zombie_vars["spectators_respawn"] ) || !level.zombie_vars["spectators_respawn"] )
        return;

    if ( !isdefined( level.custom_spawnplayer ) )
        level.custom_spawnplayer = ::spectator_respawn;

    while ( true )
    {
        players = get_players();

        for ( i = 0; i < players.size; i++ )
        {
            if ( players[i].sessionstate == "spectator" && isdefined( players[i].spectator_respawn ) )
            {
                players[i] [[ level.spawnplayer ]]();
                thread refresh_player_navcard_hud();

				new_score = (level.round_number + 1) * 250;
				if (new_score > 1500)
				{
					new_score = 1500;
				}

                if ( players[i].score < new_score )
                {
                    players[i].old_score = players[i].score;

                    if ( isdefined( level.spectator_respawn_custom_score ) )
                        players[i] [[ level.spectator_respawn_custom_score ]]();

                    players[i].score = new_score;
                }
            }
        }

        wait 1;
    }
}

ai_calculate_health( round_number )
{
	level.zombie_health = level.zombie_vars[ "zombie_health_start" ];
	max_health = 100000;
	i = 2;

	while ( i <= round_number )
	{
		if( level.zombie_health > max_health )
		{
			level.zombie_health = max_health;
			return;
		}

		if ( i >= 10 )
		{
			old_health = level.zombie_health;
			level.zombie_health = level.zombie_health + int( level.zombie_health * level.zombie_vars[ "zombie_health_increase_multiplier" ] );

			if ( level.zombie_health < old_health )
			{
				level.zombie_health = old_health;
				return;
			}

			i++;
			continue;
		}

		level.zombie_health = int( level.zombie_health + level.zombie_vars[ "zombie_health_increase" ] );
		i++;
	}
}

onallplayersready()
{
    timeout = gettime() + 5000;

    while ( getnumexpectedplayers() == 0 && gettime() < timeout )
        wait 0.1;

    player_count_actual = 0;

    while ( getnumconnectedplayers() < getnumexpectedplayers() || player_count_actual != getnumexpectedplayers() )
    {
        players = get_players();
        player_count_actual = 0;

        for ( i = 0; i < players.size; i++ )
        {
            players[i] freezecontrols( 1 );

            if ( players[i].sessionstate == "playing" )
                player_count_actual++;
        }

        wait 0.1;
    }

    setinitialplayersconnected();

    if ( 1 == getnumconnectedplayers() && getdvarint( "scr_zm_enable_bots" ) == 1 )
    {
        level thread add_bots();
        flag_set( "initial_players_connected" );
    }
    else
    {
        players = get_players();

        if ( players.size == 1 && level.scr_zm_ui_gametype != "zgrief" )
        {
            flag_set( "solo_game" );
            level.solo_lives_given = 0;

            foreach ( player in players )
                player.lives = 0;

            level maps\mp\zombies\_zm::set_default_laststand_pistol( 1 );
        }

        flag_set( "initial_players_connected" );

        while ( !aretexturesloaded() )
            wait 0.05;

        thread start_zombie_logic_in_x_sec( 3.0 );
    }

	setDvar("team_axis", "");
	setDvar("team_allies", "");

    fade_out_intro_screen_zm( 5.0, 1.5, 1 );
}

fade_out_intro_screen_zm( hold_black_time, fade_out_time, destroyed_afterwards )
{
	flag_init( "hud_visible" );

    if ( !isdefined( level.introscreen ) )
    {
        level.introscreen = newhudelem();
        level.introscreen.x = 0;
        level.introscreen.y = 0;
        level.introscreen.horzalign = "fullscreen";
        level.introscreen.vertalign = "fullscreen";
        level.introscreen.foreground = 0;
        level.introscreen setshader( "black", 640, 480 );
        level.introscreen.immunetodemogamehudsettings = 1;
        level.introscreen.immunetodemofreecamera = 1;
        wait 0.05;
    }

    level.introscreen.alpha = 1;

    if ( isdefined( hold_black_time ) )
        wait( hold_black_time );
    else
        wait 0.2;

    if ( !isdefined( fade_out_time ) )
        fade_out_time = 1.5;

    level.introscreen fadeovertime( fade_out_time );
    level.introscreen.alpha = 0;
    wait 1.6;

	level.passed_introscreen = 1;

	players = get_players();
	foreach (player in players)
	{
		player setclientuivisibilityflag( "hud_visible", 1 );
	}

	flag_set( "hud_visible" );

	if ( isDedicated() || ( is_gametype_active("zgrief") && getDvarInt("ui_gametype_team_change") ) )
    {
		flag_init( "all_players_ready" );

		level thread wait_for_all_players_ready();

		flag_wait( "all_players_ready" );
	}

    players = get_players();
    for ( i = 0; i < players.size; i++ )
    {
        if ( !( isdefined( level.host_ended_game ) && level.host_ended_game ) )
        {
            if ( isdefined( level.player_movement_suppressed ) )
            {
                players[i] freezecontrols( level.player_movement_suppressed );
                continue;
            }

            if ( !( isdefined( players[i].hostmigrationcontrolsfrozen ) && players[i].hostmigrationcontrolsfrozen ) )
            {
                players[i] freezecontrols( 0 );
            }
        }
    }

    if ( destroyed_afterwards == 1 )
        level.introscreen destroy();

    flag_set( "initial_blackscreen_passed" );
}

wait_for_all_players_ready()
{
	if (!isDefined(level.prev_no_end_game_check))
	{
		level.prev_no_end_game_check = is_true(level.no_end_game_check);
	}

	level.no_end_game_check = 1;

	if ( !isDefined(level.pregame_hud) )
	{
		level.pregame_hud = createServerFontString( "objective", 1.5 );
		level.pregame_hud setPoint( "CENTER", "CENTER", 0, -95 );
		level.pregame_hud.color = ( 1, 1, 1 );
	}

	num_players = get_number_of_waiting_players();
	while ( num_players < level.pregame_minplayers )
	{
		if (is_gametype_active("zgrief"))
		{
			level thread check_for_team_change();
		}

		players = get_players();
		foreach ( player in players )
		{
			if ( is_true( player.afterlife ) )
			{
				player.infinite_mana = 1;
			}

			player freezecontrols( 1 );
		}

		num_waiting_for = level.pregame_minplayers - num_players;

		players_str = "PLAYERS";
		if ( num_waiting_for == 1 )
		{
			players_str = "PLAYER";
		}

		level.pregame_hud setText( "WAITING FOR " + num_waiting_for + " MORE " + players_str + " [" + num_players + "/" + level.pregame_minplayers + "]" );

		wait 0.05;

		num_players = get_number_of_waiting_players();
	}

	if ( !isDefined(level.ready_up_hud) )
	{
		level.ready_up_hud = createServerFontString( "objective", 1.5 );
		level.ready_up_hud setPoint( "CENTER", "CENTER", 0, -115 );
		level.ready_up_hud.color = ( 1, 1, 1 );
		level.ready_up_hud setText( "PRESS ^3[{+gostand}]^7 OR ^3[{+activate}]^7 TO READY UP" );
	}

	if ( isDedicated() && !(is_gametype_active("zgrief") && getDvarInt("ui_gametype_team_change")) )
    {
		level.ready_up_time = 60;
		level.ready_up_start_time = getTime();
		level.ready_up_start_players = get_players();

		if (!isDefined(level.ready_up_timer_hud))
		{
			level.ready_up_countdown_hud = countdown_hud("PRE-GAME ENDS IN", level.ready_up_time);
		}
	}

	level.ready_up_hud.alpha = 1;

	num_ready = get_number_of_ready_players();
	players = get_players();

	foreach ( player in players )
	{
		player.waiting = undefined;
		player playlocalsound( "zmb_perks_packa_ready" );

		player.playing_loop_sound = 1;
		player playloopsound( "zmb_perks_packa_ticktock" );
	}

	while ( num_ready < players.size || players.size < level.pregame_minplayers )
	{
		ready_up_timeout = 0;

		if ( isDefined(level.ready_up_time) )
		{
			time = getTime() - level.ready_up_start_time;

			if ( time >= level.ready_up_time * 1000 )
			{
				ready_up_timeout = 1;

				foreach ( player in level.ready_up_start_players )
				{
					if ( isDefined(player) && !isDefined(player.ready) )
					{
						kick(player getEntityNumber());
					}
				}

				wait 0.05;
			}
		}

		players = get_players();

		if ( players.size < level.pregame_minplayers )
		{
			foreach ( player in players )
			{
				player.ready = undefined;
				player.statusicon = "";
				player playlocalsound( "zmb_perks_packa_deny" );

				player.playing_loop_sound = undefined;
				player stoploopsound();
			}

			level.ready_up_hud.alpha = 0;

			if (isDefined(level.ready_up_countdown_hud))
			{
				level.ready_up_countdown_hud countdown_hud_destroy();
			}

			level thread wait_for_all_players_ready();

			return;
		}

		if (ready_up_timeout)
		{
			break;
		}

		if (is_gametype_active("zgrief"))
		{
			level thread check_for_team_change();
		}

		foreach ( player in players )
		{
			if ( !isDefined( player.playing_loop_sound ) )
			{
				player.playing_loop_sound = 1;
				player playloopsound( "zmb_perks_packa_ticktock" );
			}

			if ( is_true( player.afterlife ) )
			{
				player.infinite_mana = 1;
			}

			player freezecontrols( 1 );
		}

		num_waiting_for = players.size - num_ready;

		players_str = "PLAYERS";
		if ( num_waiting_for == 1 )
		{
			players_str = "PLAYER";
		}

		level.pregame_hud setText( "WAITING FOR " + num_waiting_for + " " + players_str + " TO BE READY [" + num_ready + "/" + players.size + "]" );

		wait 0.05;

		num_ready = get_number_of_ready_players();
		players = get_players();
	}

	if (is_gametype_active("zgrief"))
	{
		level thread check_for_team_change();
	}

	foreach ( player in players )
	{
		player.ready = undefined;
		player.statusicon = "";

		player.playing_loop_sound = undefined;
		player stoploopsound();

		if ( is_true( player.afterlife ) )
		{
			player.infinite_mana = 0;
		}
	}

	level.ready_up_hud destroy();
	level.pregame_hud destroy();

	if (isDefined(level.ready_up_countdown_hud))
	{
		level.ready_up_countdown_hud countdown_hud_destroy();
	}

	level.no_end_game_check = level.prev_no_end_game_check;

	flag_set( "all_players_ready" );
}

get_number_of_waiting_players()
{
    num = 0;
	players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
        if ( is_player_valid( players[i] ) || is_true( players[i].afterlife ) )
		{
			players[i].waiting = 1;
		}

		if ( is_true( players[i].waiting ) )
		{
			num++;
		}
    }

    return num;
}

get_number_of_ready_players()
{
    num = 0;
	players = get_players();

    for ( i = 0; i < players.size; i++ )
    {
		if ( players[i] jumpbuttonpressed() || players[i] usebuttonpressed() || players[i] is_bot() )
		{
			players[i].ready = 1;
		}

        if ( is_true( players[i].ready ) )
		{
			num++;
			players[i].statusicon = "menu_mp_killstreak_select";
		}
		else
		{
			players[i].statusicon = "menu_mp_contract_expired";
		}
    }

    return num;
}

check_for_team_change()
{
	if (level.allow_teamchange)
	{
		return;
	}

	team_change_player = undefined;
	axis_players = get_players("axis");
	allies_players = get_players("allies");

	if (axis_players.size - 1 > allies_players.size)
	{
		team_change_player = random(axis_players);
	}
	else if (allies_players.size  - 1 > axis_players.size)
	{
		team_change_player = random(allies_players);
	}

	if (isDefined(team_change_player))
	{
		team_change_player endon("disconnect");

		team_change_player scripts\zm\replaced\_zm_gametype::do_team_change();

		wait 0.05;

		team_change_player freezecontrols(1);
	}
}

countdown_hud(text, time)
{
	countdown_hud = createServerFontString( "objective", 2.2 );
	countdown_hud setPoint( "CENTER", "CENTER", 0, 0 );
	countdown_hud.color = ( 1, 1, 0 );
	countdown_hud maps\mp\gametypes_zm\_hud::fontpulseinit();
	countdown_hud thread countdown_hud_end_game_watcher();

	countdown_hud.countdown_text = createServerFontString( "objective", 1.5 );
	countdown_hud.countdown_text setPoint( "CENTER", "CENTER", 0, -40 );
	countdown_hud.countdown_text.color = ( 1, 1, 1 );

	countdown_hud thread countdown_hud_timer(time);

	countdown_hud.countdown_text setText(text);

	countdown_hud.alpha = 1;
	countdown_hud.countdown_text.alpha = 1;

	return countdown_hud;
}

countdown_hud_destroy()
{
	self.countdown_text destroy();
	self destroy();
}

countdown_hud_end_game_watcher()
{
	self endon("death");

	level waittill( "end_game" );

	self countdown_hud_destroy();
}

countdown_hud_timer(time)
{
	self endon("death");

	while(time > 0)
	{
		self setvalue(time);
		self thread maps\mp\gametypes_zm\_hud::fontpulse(level);
		wait 1;
		time--;
	}
}

last_stand_pistol_rank_init()
{
	level.pistol_values = [];
	level.pistol_values[ level.pistol_values.size ] = "m1911_zm";
	level.pistol_values[ level.pistol_values.size ] = "c96_zm";
	level.pistol_values[ level.pistol_values.size ] = "cz75_zm";
	level.pistol_values[ level.pistol_values.size ] = "cz75dw_zm";
	level.pistol_values[ level.pistol_values.size ] = "kard_zm";
	level.pistol_values[ level.pistol_values.size ] = "fiveseven_zm";
	level.pistol_values[ level.pistol_values.size ] = "beretta93r_zm";
	level.pistol_values[ level.pistol_values.size ] = "beretta93r_extclip_zm";
	level.pistol_values[ level.pistol_values.size ] = "fivesevendw_zm";
	level.pistol_values[ level.pistol_values.size ] = "rnma_zm";
	level.pistol_values[ level.pistol_values.size ] = "python_zm";
	level.pistol_values[ level.pistol_values.size ] = "judge_zm";
	level.pistol_values[ level.pistol_values.size ] = "cz75_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "cz75dw_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "kard_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "fiveseven_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "beretta93r_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "beretta93r_extclip_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "fivesevendw_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "rnma_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "python_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "judge_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "ray_gun_zm";
	level.pistol_values[ level.pistol_values.size ] = "ray_gun_upgraded_zm";
	level.pistol_value_solo_replace_below = level.pistol_values.size - 1;
	level.pistol_values[ level.pistol_values.size ] = "m1911_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "c96_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "raygun_mark2_zm";
	level.pistol_values[ level.pistol_values.size ] = "raygun_mark2_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "freezegun_zm";
	level.pistol_values[ level.pistol_values.size ] = "freezegun_upgraded_zm";
	level.pistol_values[ level.pistol_values.size ] = "microwavegundw_zm";
	level.pistol_values[ level.pistol_values.size ] = "microwavegundw_upgraded_zm";
}

last_stand_best_pistol()
{
    pistol_array = [];
    current_weapons = self getweaponslistprimaries();

    for ( i = 0; i < current_weapons.size; i++ )
    {
        class = weaponclass( current_weapons[i] );

        if ( issubstr( current_weapons[i], "knife_ballistic_" ) )
            class = "knife";

        if ( class == "pistol" || class == "pistolspread" || class == "pistol spread" )
        {
            if ( current_weapons[i] != level.default_laststandpistol && !flag( "solo_game" ) || !flag( "solo_game" ) && current_weapons[i] != level.default_solo_laststandpistol )
            {
				ammo_count = self getammocount( current_weapons[i] );

				dual_wield_name = weapondualwieldweaponname( current_weapons[i] );
				if ( dual_wield_name != "none" )
				{
					ammo_count += self getweaponammoclip( dual_wield_name );
				}

                if ( ammo_count <= 0 )
                    continue;
            }

            pistol_array_index = pistol_array.size;
            pistol_array[pistol_array_index] = spawnstruct();
            pistol_array[pistol_array_index].gun = current_weapons[i];
            pistol_array[pistol_array_index].value = 0;

            for ( j = 0; j < level.pistol_values.size; j++ )
            {
                if ( level.pistol_values[j] == current_weapons[i] )
                {
                    pistol_array[pistol_array_index].value = j;
                    break;
                }
            }
        }
    }

    self.laststandpistol = last_stand_compare_pistols( pistol_array );
}

can_track_ammo( weap )
{
    if ( !isdefined( weap ) )
        return false;

    switch ( weap )
    {
        case "zombie_tazer_flourish":
        case "zombie_sickle_flourish":
        case "zombie_knuckle_crack":
        case "zombie_fists_zm":
        case "zombie_builder_zm":
        case "zombie_bowie_flourish":
        case "time_bomb_zm":
        case "time_bomb_detonator_zm":
        case "tazer_knuckles_zm":
        case "tazer_knuckles_upgraded_zm":
        case "slowgun_zm":
        case "slowgun_upgraded_zm":
        case "screecher_arms_zm":
        case "riotshield_zm":
        case "none":
        case "no_hands_zm":
        case "lower_equip_gasmask_zm":
        case "humangun_zm":
        case "humangun_upgraded_zm":
        case "equip_gasmask_zm":
        case "equip_dieseldrone_zm":
        case "death_throe_zm":
        case "chalk_draw_zm":
        case "alcatraz_shield_zm":
		case "tomb_shield_zm":
            return false;
        default:
            if ( is_melee_weapon( weap ) || is_zombie_perk_bottle( weap ) || is_placeable_mine( weap ) || is_equipment( weap ) || issubstr( weap, "knife_ballistic_" ) || getsubstr( weap, 0, 3 ) == "gl_" || weaponfuellife( weap ) > 0 || weap == level.revive_tool )
                return false;
    }

    return true;
}

take_additionalprimaryweapon()
{
    weapon_to_take = undefined;
	self.a_saved_weapon = undefined;

    if ( isdefined( self._retain_perks ) && self._retain_perks || isdefined( self._retain_perks_array ) && ( isdefined( self._retain_perks_array["specialty_additionalprimaryweapon"] ) && self._retain_perks_array["specialty_additionalprimaryweapon"] ) )
        return weapon_to_take;

    primary_weapons_that_can_be_taken = [];
    primaryweapons = self getweaponslistprimaries();

    for ( i = 0; i < primaryweapons.size; i++ )
    {
        if ( maps\mp\zombies\_zm_weapons::is_weapon_included( primaryweapons[i] ) || maps\mp\zombies\_zm_weapons::is_weapon_upgraded( primaryweapons[i] ) )
            primary_weapons_that_can_be_taken[primary_weapons_that_can_be_taken.size] = primaryweapons[i];
    }

    pwtcbt = primary_weapons_that_can_be_taken.size;

	while ( pwtcbt >= 3 )
    {
        weapon_to_take = primary_weapons_that_can_be_taken[pwtcbt - 1];
        pwtcbt--;

		self.a_saved_weapon = maps\mp\zombies\_zm_weapons::get_player_weapondata(self, weapon_to_take);

		name = self.a_saved_weapon["name"];
		dw_name = weaponDualWieldWeaponName(name);
		alt_name = weaponAltWeaponName(name);

		clip_missing = weaponClipSize(name) - self.a_saved_weapon["clip"];
		if (clip_missing > self.a_saved_weapon["stock"])
		{
			clip_missing = self.a_saved_weapon["stock"];
		}
		self.a_saved_weapon["clip"] += clip_missing;
		self.a_saved_weapon["stock"] -= clip_missing;

		if (dw_name != "none")
		{
			clip_dualwield_missing = weaponClipSize(dw_name) - self.a_saved_weapon["lh_clip"];
			if (clip_dualwield_missing > self.a_saved_weapon["stock"])
			{
				clip_dualwield_missing = self.a_saved_weapon["stock"];
			}
			self.a_saved_weapon["lh_clip"] += clip_dualwield_missing;
			self.a_saved_weapon["stock"] -= clip_dualwield_missing;
		}

		if (alt_name != "none")
		{
			clip_alt_missing = weaponClipSize(alt_name) - self.a_saved_weapon["alt_clip"];
			if (clip_alt_missing > self.a_saved_weapon["alt_stock"])
			{
				clip_alt_missing = self.a_saved_weapon["alt_stock"];
			}
			self.a_saved_weapon["alt_clip"] += clip_alt_missing;
			self.a_saved_weapon["alt_stock"] -= clip_alt_missing;
		}

        if ( weapon_to_take == self getcurrentweapon() )
            self switchtoweapon( primary_weapons_that_can_be_taken[0] );

        self takeweapon( weapon_to_take );
    }

    return weapon_to_take;
}

restore_additionalprimaryweapon()
{
	if (!isDefined(self.a_saved_weapon))
	{
		return;
	}

	pap_triggers = getentarray( "specialty_weapupgrade", "script_noteworthy" );

	if (!additionalprimaryweapon_canplayerreceiveweapon(self, self.a_saved_weapon["name"], pap_triggers))
	{
		self.a_saved_weapon = undefined;
		return;
	}

	current = get_player_weapon_with_same_base( self.a_saved_weapon["name"] );

    if ( isdefined( current ) )
    {
        curweapondata = get_player_weapondata( self, current );
        self takeweapon( current );
        weapondata = merge_weapons( curweapondata, weapondata );
    }

    name = self.a_saved_weapon["name"];
	dw_name = weapondualwieldweaponname( name );
    alt_name = weaponaltweaponname( name );

    if ( !is_weapon_upgraded( name ) )
        self giveweapon( name );
    else
        self giveweapon( name, 0, self get_pack_a_punch_weapon_options( name ) );

    if ( name != "none" )
    {
        self setweaponammoclip( name, self.a_saved_weapon["clip"] );
        self setweaponammostock( name, self.a_saved_weapon["stock"] );

        if ( isdefined( self.a_saved_weapon["fuel"] ) )
            self setweaponammofuel( name, self.a_saved_weapon["fuel"] );

        if ( isdefined( self.a_saved_weapon["heat"] ) && isdefined( self.a_saved_weapon["overheat"] ) )
            self setweaponoverheating( self.a_saved_weapon["overheat"], self.a_saved_weapon["heat"], name );
    }

    if ( dw_name != "none" )
        self setweaponammoclip( dw_name, self.a_saved_weapon["lh_clip"] );

    if ( alt_name != "none" )
    {
        self setweaponammoclip( alt_name, self.a_saved_weapon["alt_clip"] );
        self setweaponammostock( alt_name, self.a_saved_weapon["alt_stock"] );
    }

	self switchtoweapon( name );

	self.a_saved_weapon = undefined;
}

additionalprimaryweapon_canplayerreceiveweapon( player, weapon, pap_triggers )
{
	if ( isDefined( player ) && player maps\mp\zombies\_zm_weapons::has_weapon_or_upgrade( weapon ) )
	{
		return 0;
	}

	if ( !maps\mp\zombies\_zm_weapons::limited_weapon_below_quota( weapon, player, pap_triggers ) )
	{
		return 0;
	}

	if ( !player maps\mp\zombies\_zm_weapons::player_can_use_content( weapon ) )
	{
		return 0;
	}

	if ( isDefined( level.custom_magic_box_selection_logic ) )
	{
		if ( !( [[ level.custom_magic_box_selection_logic ]]( weapon, player, pap_triggers ) ) )
		{
			return 0;
		}
	}

	if ( isDefined( player ) && isDefined( level.special_weapon_magicbox_check ) )
	{
		if ( !player [[ level.special_weapon_magicbox_check ]]( weapon ) )
		{
			return 0;
		}
	}

	if ( isSubStr( weapon, "staff" ) )
	{
		return 0;
	}

	return 1;
}

actor_damage_override( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
{
	if ( is_true( self.is_sloth ) )
	{
		return 0;
	}

	if ( !isDefined( self ) || !isDefined( attacker ) )
	{
		return damage;
	}

	if ( weapon == "tazer_knuckles_zm" || weapon == "jetgun_zm" )
	{
		self.knuckles_extinguish_flames = 1;
	}
	else if ( weapon != "none" )
	{
		self.knuckles_extinguish_flames = undefined;
	}

	if ( isDefined( attacker.animname ) && attacker.animname == "quad_zombie" )
	{
		if ( isDefined( self.animname ) && self.animname == "quad_zombie" )
		{
			return 0;
		}
	}

	if ( !isplayer( attacker ) && isDefined( self.non_attacker_func ) )
	{
		if ( is_true( self.non_attack_func_takes_attacker ) )
		{
			return self [[ self.non_attacker_func ]]( damage, weapon, attacker );
		}
		else
		{
			return self [[ self.non_attacker_func ]]( damage, weapon );
		}
	}

	if ( weapon == "zombie_bullet_crouch_zm" && meansofdeath == "MOD_RIFLE_BULLET" )
	{
		damage_scalar = damage / 600;
		min_damage = int( damage_scalar * level.zombie_health ) + 1;

		if ( damage < min_damage )
		{
			damage = min_damage;
		}
	}

	if ( weapon == "quadrotorturret_zm" && meansofdeath == "MOD_PISTOL_BULLET" )
	{
		if (!is_true(self.is_mechz))
		{
			damage_scalar = damage / 6000;
			min_damage = int( damage_scalar * level.zombie_health ) + 1;

			if ( damage < min_damage )
			{
				damage = min_damage;
			}
		}
	}

	if ( weapon == "tower_trap_zm" )
	{
		if (!is_true(self.is_brutus))
		{
			damage = level.zombie_health;
		}
	}

	if ( weapon == "tower_trap_upgraded_zm" )
	{
		if (!is_true(self.is_brutus))
		{
			damage_scalar = damage / 200;
			min_damage = int(damage_scalar * level.zombie_health) + 1;

			if (damage < min_damage)
			{
				damage = min_damage;
			}
		}
	}

	if ( !isplayer( attacker ) && !isplayer( self ) )
	{
		return damage;
	}

	if ( !isDefined( damage ) || !isDefined( meansofdeath ) )
	{
		return damage;
	}

	if ( meansofdeath == "" )
	{
		return damage;
	}

	old_damage = damage;
	final_damage = damage;

	if ( isDefined( self.actor_damage_func ) )
	{
		final_damage = [[ self.actor_damage_func ]]( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
	}

	if ( attacker.classname == "script_vehicle" && isDefined( attacker.owner ) )
	{
		attacker = attacker.owner;
	}

	if ( is_true( self.in_water ) )
	{
		if ( int( final_damage ) >= self.health )
		{
			self.water_damage = 1;
		}
	}

	attacker thread maps\mp\gametypes_zm\_weapons::checkhit( weapon );

	if(maps\mp\zombies\_zm_weapons::get_base_weapon_name(weapon, 1) == "saritch_zm")
	{
		final_damage *= 2;
	}

	if(weapon == "ray_gun_zm" && meansofdeath == "MOD_PROJECTILE")
	{
		final_damage = 1500;
	}

	if(weapon == "ray_gun_upgraded_zm" && meansofdeath == "MOD_PROJECTILE")
	{
		final_damage = 2000;
	}

	if(weapon == "blundergat_zm" || weapon == "blundergat_upgraded_zm")
	{
		if(!is_true(self.is_brutus))
		{
			damage_scalar = final_damage / 1000;
			min_damage = int(damage_scalar * level.zombie_health) + 1;

			if(final_damage < min_damage)
			{
				final_damage = min_damage;
			}
		}
	}

	if(weapon == "blundersplat_explosive_dart_zm")
	{
		if(!is_true(self.is_brutus))
		{
			damage_scalar = final_damage / 3000;
			min_damage = int(damage_scalar * level.zombie_health) + 1;

			if(final_damage < min_damage)
			{
				final_damage = min_damage;
			}
		}
	}

	if (weapon == "staff_revive_zm")
	{
		if (!is_true(self.is_mechz))
		{
			final_damage = level.zombie_health;
		}
	}

	if(attacker HasPerk("specialty_rof"))
	{
		if(meansofdeath == "MOD_PISTOL_BULLET" || meansofdeath == "MOD_RIFLE_BULLET")
		{
			final_damage *= 1.5;
		}
	}

	if(attacker HasPerk("specialty_deadshot"))
	{
		if(is_headshot(weapon, shitloc, meansofdeath))
		{
			if(meansofdeath == "MOD_PISTOL_BULLET" || meansofdeath == "MOD_RIFLE_BULLET")
			{
				if(!isSubStr(weaponClass(weapon), "spread") || maps\mp\zombies\_zm_weapons::get_base_weapon_name(weapon, 1) == "ksg_zm")
				{
					final_damage *= 2;
				}
			}
		}
	}

	if ( attacker maps\mp\zombies\_zm_pers_upgrades_functions::pers_mulit_kill_headshot_active() && is_headshot( weapon, shitloc, meansofdeath ) )
	{
		final_damage *= 2;
	}

	if(is_true(level.zombie_vars[attacker.team]["zombie_half_damage"]) && !is_true(self.marked_for_death))
	{
		final_damage /= 2;
	}

	if ( is_true( level.headshots_only ) && isDefined( attacker ) && isplayer( attacker ) )
	{
		if ( meansofdeath == "MOD_MELEE" && shitloc == "head" || meansofdeath == "MOD_MELEE" && shitloc == "helmet" )
		{
			return int( final_damage );
		}

		if ( is_explosive_damage( meansofdeath ) )
		{
			return int( final_damage );
		}
		else if ( !is_headshot( weapon, shitloc, meansofdeath ) )
		{
			return 0;
		}
	}

	return int( final_damage );
}

callback_playerdamage( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
{
	if ( isDefined( eattacker ) && isplayer( eattacker ) && eattacker.sessionteam == self.sessionteam && !eattacker hasperk( "specialty_noname" ) && isDefined( self.is_zombie ) && !self.is_zombie )
	{
		self maps\mp\zombies\_zm::process_friendly_fire_callbacks( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
		if ( self != eattacker )
		{
			return;
		}
		else if ( smeansofdeath != "MOD_GRENADE_SPLASH" && smeansofdeath != "MOD_GRENADE" && smeansofdeath != "MOD_EXPLOSIVE" && smeansofdeath != "MOD_PROJECTILE" && smeansofdeath != "MOD_PROJECTILE_SPLASH" && smeansofdeath != "MOD_BURNED" && smeansofdeath != "MOD_SUICIDE" )
		{
			return;
		}
	}
	if ( is_true( level.pers_upgrade_insta_kill ) )
	{
		self maps\mp\zombies\_zm_pers_upgrades_functions::pers_insta_kill_melee_swipe( smeansofdeath, eattacker );
	}
	if ( isDefined( self.overrideplayerdamage ) )
	{
		idamage = self [[ self.overrideplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
	}
	else if ( isDefined( level.overrideplayerdamage ) )
	{
		idamage = self [[ level.overrideplayerdamage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
	}
	if ( is_true( self.magic_bullet_shield ) )
	{
		maxhealth = self.maxhealth;
		self.health += idamage;
		self.maxhealth = maxhealth;
	}
	if ( isDefined( self.divetoprone ) && self.divetoprone == 1 )
	{
		if ( smeansofdeath == "MOD_GRENADE_SPLASH" )
		{
			dist = distance2d( vpoint, self.origin );
			if ( dist > 32 )
			{
				dot_product = vectordot( anglesToForward( self.angles ), vdir );
				if ( dot_product > 0 )
				{
					idamage = int( idamage * 0.5 );
				}
			}
		}
	}
	if ( isDefined( level.prevent_player_damage ) )
	{
		if ( self [[ level.prevent_player_damage ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime ) )
		{
			return;
		}
	}
	idflags |= level.idflags_no_knockback;
	if ( idamage > 0 && shitloc == "riotshield" )
	{
		shitloc = "torso_upper";
	}

	self maps\mp\zombies\_zm::finishplayerdamagewrapper( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
}

getfreespawnpoint( spawnpoints, player )
{
	if ( !isDefined( spawnpoints ) )
	{
		return undefined;
	}

	spawnpoints = array_randomize( spawnpoints );

	if ( !isDefined( game[ "spawns_randomized" ] ) )
	{
		game[ "spawns_randomized" ] = 1;
		random_chance = randomint( 100 );
		if ( random_chance > 50 )
		{
			set_game_var( "side_selection", 1 );
		}
		else
		{
			set_game_var( "side_selection", 2 );
		}
	}

	side_selection = get_game_var( "side_selection" );
	if ( get_game_var( "switchedsides" ) )
	{
		if ( side_selection == 2 )
		{
			side_selection = 1;
		}
		else
		{
			if ( side_selection == 1 )
			{
				side_selection = 2;
			}
		}
	}

	if ( isdefined( player ) && isdefined( player.team ) )
	{
		i = 0;
		while ( isdefined( spawnpoints ) && i < spawnpoints.size )
		{
			if ( side_selection == 1 )
			{
				if ( player.team != "allies" && isdefined( spawnpoints[ i ].script_int ) && spawnpoints[ i ].script_int == 1 )
				{
					arrayremovevalue( spawnpoints, spawnpoints[ i ] );
					i = 0;
				}
				else if ( player.team == "allies" && isdefined( spawnpoints[ i ].script_int) && spawnpoints[ i ].script_int == 2 )
				{
					arrayremovevalue( spawnpoints, spawnpoints[ i ] );
					i = 0;
				}
				else
				{
					i++;
				}
			}
			else
			{
				if ( player.team == "allies" && isdefined( spawnpoints[ i ].script_int ) && spawnpoints[ i ].script_int == 1 )
				{
					arrayremovevalue(spawnpoints, spawnpoints[i]);
					i = 0;
				}
				else if ( player.team != "allies" && isdefined( spawnpoints[ i ].script_int ) && spawnpoints[ i ].script_int == 2 )
				{
					arrayremovevalue( spawnpoints, spawnpoints[ i ] );
					i = 0;
				}
				else
				{
					i++;
				}
			}
		}
	}

	if ( !isdefined( self.playernum ) )
	{
		num = 0;
		players = get_players(self.team);

		for(num = 0; num < 4; num++)
		{
			valid_num = true;

			foreach(player in players)
			{
				if(player != self && isdefined(player.playernum) && player.playernum == num)
				{
					valid_num = false;
					break;
				}
			}

			if(valid_num)
			{
				break;
			}
		}

		self.playernum = num;
	}

	for ( j = 0; j < spawnpoints.size; j++ )
	{
		if ( !isdefined( game[ self.team + "_spawnpoints_randomized" ] ) )
		{
			game[ self.team + "_spawnpoints_randomized" ] = 1;

			for ( m = 0; m < spawnpoints.size; m++ )
			{
				spawnpoints[ m ].en_num = m;
			}
		}

		if ( spawnpoints[ j ].en_num == self.playernum )
		{
			return spawnpoints[ j ];
		}
	}

	return spawnpoints[ 0 ];
}

check_for_valid_spawn_near_team( revivee, return_struct )
{
	if ( isDefined( level.check_for_valid_spawn_near_team_callback ) )
	{
		spawn_location = [[ level.check_for_valid_spawn_near_team_callback ]]( revivee, return_struct );
		return spawn_location;
	}

	players = array_randomize(get_players());
	spawn_points = maps\mp\gametypes_zm\_zm_gametype::get_player_spawns_for_gametype();
	closest_group = undefined;
	closest_distance = 100000000;
	backup_group = undefined;
	backup_distance = 100000000;

	if ( spawn_points.size == 0 )
	{
		return undefined;
	}

	for ( i = 0; i < players.size; i++ )
	{
		if ( maps\mp\zombies\_zm_utility::is_player_valid( players[ i ], undefined, 1 ) && players[ i ] != self )
		{
			for ( j = 0; j < spawn_points.size; j++ )
			{
				if ( isdefined( spawn_points[ j ].script_int ) )
				{
					ideal_distance = spawn_points[ j ].script_int;
				}
				else
				{
					ideal_distance = 1000;
				}

				if ( spawn_points[ j ].locked == 0 )
				{
					plyr_dist = distancesquared( players[ i ].origin, spawn_points[ j ].origin );
					if ( plyr_dist < ideal_distance * ideal_distance )
					{
						if ( plyr_dist < closest_distance )
						{
							closest_distance = plyr_dist;
							closest_group = j;
						}
					}
					else
					{
						if ( plyr_dist < backup_distance )
						{
							backup_group = j;
							backup_distance = plyr_dist;
						}
					}
				}
			}
		}

		if ( !isdefined( closest_group ) )
		{
			closest_group = backup_group;
		}

		if ( isdefined( closest_group ) )
		{
			spawn_location = get_valid_spawn_location( revivee, spawn_points, closest_group, return_struct );
			if ( isdefined( spawn_location ) )
			{
				return spawn_location;
			}
		}
	}

	if ( !is_true( self.player_initialized ) )
	{
		return undefined;
	}

	for ( j = 0; j < spawn_points.size; j++ )
	{
		if ( isdefined( spawn_points[ j ].script_int ) )
		{
			ideal_distance = spawn_points[ j ].script_int;
		}
		else
		{
			ideal_distance = 1000;
		}

		if ( spawn_points[ j ].locked == 0 )
		{
			plyr_dist = distancesquared( self.origin, spawn_points[ j ].origin );
			if ( plyr_dist < ideal_distance * ideal_distance )
			{
				if ( plyr_dist < closest_distance )
				{
					closest_distance = plyr_dist;
					closest_group = j;
				}
			}
			else
			{
				if ( plyr_dist < backup_distance )
				{
					backup_group = j;
					backup_distance = plyr_dist;
				}
			}
		}
	}

	if ( !isdefined( closest_group ) )
	{
		closest_group = backup_group;
	}

	if ( isdefined( closest_group ) )
	{
		spawn_location = get_valid_spawn_location( revivee, spawn_points, closest_group, return_struct );
		if ( isdefined( spawn_location ) )
		{
			return spawn_location;
		}
	}

	return undefined;
}

get_valid_spawn_location( revivee, spawn_points, closest_group, return_struct )
{
	spawn_array = getstructarray( spawn_points[ closest_group ].target, "targetname" );
	spawn_array = array_randomize( spawn_array );
	k = 0;

	while ( k < spawn_array.size )
	{
		if ( positionwouldtelefrag( spawn_array[ k ].origin ) )
		{
			k++;
			continue;
		}

		if ( is_true( return_struct ) )
		{
			return spawn_array[ k ];
		}

		return spawn_array[ k ].origin;
	}

	if ( is_true( return_struct ) )
	{
		return spawn_array[ 0 ];
	}

	return spawn_array[ 0 ].origin;
}

player_damage_override( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime )
{
	if ( isDefined( level._game_module_player_damage_callback ) )
	{
		new_damage = self [[ level._game_module_player_damage_callback ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );

		if (isDefined(new_damage))
		{
			idamage = new_damage;
		}
	}

	idamage = self maps\mp\zombies\_zm::check_player_damage_callbacks( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );

	if ( is_true( self.use_adjusted_grenade_damage ) )
	{
		self.use_adjusted_grenade_damage = undefined;
		if ( self.health > idamage )
		{
			return idamage;
		}
	}

	if ( !idamage )
	{
		return 0;
	}

	if ( self maps\mp\zombies\_zm_laststand::player_is_in_laststand() )
	{
		return 0;
	}

	if ( isDefined( einflictor ) )
	{
		if ( is_true( einflictor.water_damage ) )
		{
			return 0;
		}
	}

	if ( isDefined( eattacker ) && is_true( eattacker.is_zombie ) || isplayer( eattacker ) )
	{
		if ( is_true( self.hasriotshield ) && isDefined( vdir ) )
		{
			if ( is_true( self.hasriotshieldequipped ) )
			{
				if ( self maps\mp\zombies\_zm::player_shield_facing_attacker( vdir, 0.2 ) && isDefined( self.player_shield_apply_damage ) )
				{
					self [[ self.player_shield_apply_damage ]]( 100, 0 );
					return 0;
				}
			}
			else if ( !isDefined( self.riotshieldentity ) )
			{
				if ( !self maps\mp\zombies\_zm::player_shield_facing_attacker( vdir, -0.2 ) && isDefined( self.player_shield_apply_damage ) )
				{
					self [[ self.player_shield_apply_damage ]]( 100, 0 );
					return 0;
				}
			}
		}
	}

	if ( isDefined( eattacker ) )
	{
		if ( isDefined( self.ignoreattacker ) && self.ignoreattacker == eattacker )
		{
			return 0;
		}

		if ( is_true( self.is_zombie ) && is_true( eattacker.is_zombie ) )
		{
			return 0;
		}

		if ( is_true( eattacker.is_zombie ) )
		{
			self.ignoreattacker = eattacker;
			self thread maps\mp\zombies\_zm::remove_ignore_attacker();

			if ( isDefined( eattacker.custom_damage_func ) )
			{
				idamage = eattacker [[ eattacker.custom_damage_func ]]( self );
			}
			else if ( isDefined( eattacker.meleedamage ) )
			{
				idamage = eattacker.meleedamage;
			}
			else
			{
				idamage = 50;
			}
		}

		eattacker notify( "hit_player" );

		if ( smeansofdeath != "MOD_FALLING" )
		{
			self thread maps\mp\zombies\_zm::playswipesound( smeansofdeath, eattacker );

			if ( is_true( eattacker.is_zombie ) || isplayer( eattacker ) )
			{
				self playrumbleonentity( "damage_heavy" );
			}

			canexert = 1;
			if ( is_true( level.pers_upgrade_flopper ) )
			{
				if ( is_true( self.pers_upgrades_awarded[ "flopper" ] ) )
				{
					if ( smeansofdeath != "MOD_PROJECTILE_SPLASH" && smeansofdeath != "MOD_GRENADE" && smeansofdeath != "MOD_GRENADE_SPLASH" )
					{
						canexert = smeansofdeath;
					}
				}
			}

			if ( is_true( canexert ) )
			{
				if ( randomintrange( 0, 1 ) == 0 )
				{
					self thread maps\mp\zombies\_zm_audio::playerexert( "hitmed" );
				}
				else
				{
					self thread maps\mp\zombies\_zm_audio::playerexert( "hitlrg" );
				}
			}
		}
	}

	finaldamage = idamage;

	if ( is_placeable_mine( sweapon ) || sweapon == "freezegun_zm" || sweapon == "freezegun_upgraded_zm" )
	{
		return 0;
	}

	// fix turrets damaging players
	if(sweapon == "zombie_bullet_crouch_zm" && smeansofdeath == "MOD_RIFLE_BULLET")
	{
		return 0;
	}

	if ( isDefined( self.player_damage_override ) )
	{
		self thread [[ self.player_damage_override ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
	}

	if ( smeansofdeath == "MOD_FALLING" )
	{
		if ( self hasperk( "specialty_flakjacket" ) && isDefined( self.divetoprone ) && self.divetoprone == 1 )
		{
			if ( isDefined( level.zombiemode_divetonuke_perk_func ) )
			{
				[[ level.zombiemode_divetonuke_perk_func ]]( self, self.origin );
			}

			return 0;
		}

		if ( is_true( level.pers_upgrade_flopper ) )
		{
			if ( self maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_flopper_damage_check( smeansofdeath, idamage ) )
			{
				return 0;
			}
		}

		vars = [];
		if (!self hasPerk("specialty_flakjacket"))
		{
			// remove fall damage being based off max health
			vars["ratio"] = self.maxhealth / 100;
			idamage = int(idamage / vars["ratio"]);

			// increase fall damage beyond 110
			vars["max_damage"] = 110;
			if (idamage >= vars["max_damage"])
			{
				vars["velocity"] = abs(self.fall_velocity);
				vars["min_velocity"] = getDvarInt("bg_fallDamageMinHeight") * 3.25;
				vars["max_velocity"] = getDvarInt("bg_fallDamageMaxHeight") * 2.5;
				if (self.divetoprone)
				{
					vars["min_velocity"] = getDvarInt("dtp_fall_damage_min_height") * 4.5;
					vars["max_velocity"] = getDvarInt("dtp_fall_damage_max_height") * 2.75;
				}

				idamage = int(((vars["velocity"] - vars["min_velocity"]) / (vars["max_velocity"] - vars["min_velocity"])) * vars["max_damage"]);

				if (idamage < vars["max_damage"])
				{
					idamage = vars["max_damage"];
				}
			}

			finaldamage = idamage;
		}
	}
	if ( smeansofdeath == "MOD_PROJECTILE" || smeansofdeath == "MOD_PROJECTILE_SPLASH" || smeansofdeath == "MOD_GRENADE" || smeansofdeath == "MOD_GRENADE_SPLASH" )
	{
		if ( self hasperk( "specialty_flakjacket" ) )
		{
			return 0;
		}

		if ( is_true( level.pers_upgrade_flopper ) )
		{
			if ( is_true( self.pers_upgrades_awarded[ "flopper" ] ) )
			{
				return 0;
			}
		}

		if ( sweapon == "slip_bolt_zm" || sweapon == "slip_bolt_upgraded_zm" )
		{
			return 0;
		}

		if ( self.health > 75 && !is_true( self.is_zombie ) )
		{
			return 75;
		}
	}

	if ( idamage < self.health )
	{
		if ( isDefined( eattacker ) )
		{
			if ( isDefined( level.custom_kill_damaged_vo ) )
			{
				eattacker thread [[ level.custom_kill_damaged_vo ]]( self );
			}
			else
			{
				eattacker.sound_damage_player = self;
			}

			if ( !is_true( eattacker.has_legs ) )
			{
				self maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "crawl_hit" );
			}
			else if ( isDefined( eattacker.animname ) && eattacker.animname == "monkey_zombie" )
			{
				self maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "monkey_hit" );
			}
		}

		return finaldamage;
	}
	if ( isDefined( eattacker ) )
	{
		if ( isDefined( eattacker.animname ) && eattacker.animname == "zombie_dog" )
		{
			self maps\mp\zombies\_zm_stats::increment_client_stat( "killed_by_zdog" );
			self maps\mp\zombies\_zm_stats::increment_player_stat( "killed_by_zdog" );
		}
		else if ( isDefined( eattacker.is_avogadro ) && eattacker.is_avogadro )
		{
			self maps\mp\zombies\_zm_stats::increment_client_stat( "killed_by_avogadro", 0 );
			self maps\mp\zombies\_zm_stats::increment_player_stat( "killed_by_avogadro" );
		}
	}

	self thread maps\mp\zombies\_zm::clear_path_timers();

	if ( level.intermission )
	{
		level waittill( "forever" );
	}

	if ( level.scr_zm_ui_gametype == "zcleansed" && idamage > 0 )
	{
		if ( (!is_true( self.laststand ) && !self maps\mp\zombies\_zm_laststand::player_is_in_laststand()) || !isDefined( self.last_player_attacker ) )
		{
			if(isDefined( eattacker ) && isplayer( eattacker ) && eattacker.team != self.team)
			{
				if ( isDefined( eattacker.maxhealth ) && is_true( eattacker.is_zombie ) )
				{
					eattacker.health = eattacker.maxhealth;
				}

				if ( isDefined( level.player_kills_player ) )
				{
					self thread [[ level.player_kills_player ]]( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, psoffsettime );
				}
			}
		}
	}

	if ( self hasperk( "specialty_finalstand" ) )
	{
		if ( isDefined( level.chugabud_laststand_func ) )
		{
			self thread [[ level.chugabud_laststand_func ]]();
			return 0;
		}
	}

	players = get_players();
	count = 0;
	for ( i = 0; i < players.size; i++ )
	{
		if ( players[ i ] == self || players[ i ].is_zombie || players[ i ] maps\mp\zombies\_zm_laststand::player_is_in_laststand() || players[ i ].sessionstate == "spectator" )
		{
			count++;
		}
	}

	if ( count < players.size || isDefined( level._game_module_game_end_check ) && ![[ level._game_module_game_end_check ]]() )
	{
		if ( isDefined( self.solo_lives_given ) && self.solo_lives_given < 3 && is_true( level.force_solo_quick_revive ) && self hasperk( "specialty_quickrevive" ) )
		{
			self thread maps\mp\zombies\_zm::wait_and_revive();
		}
		return finaldamage;
	}

	solo_death = self is_solo_death( players );
	non_solo_death = self is_non_solo_death( players, count );
	if ( ( solo_death || non_solo_death ) && !is_true( level.no_end_game_check ) )
	{
		level notify( "stop_suicide_trigger" );
		self thread scripts\zm\replaced\_zm_laststand::playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime );

		if ( !isDefined( vdir ) )
		{
			vdir = ( 1, 0, 0 );
		}

		self fakedamagefrom( vdir );

		if ( isDefined( level.custom_player_fake_death ) )
		{
			self thread [[ level.custom_player_fake_death ]]( vdir, smeansofdeath );
		}
		else
		{
			self thread maps\mp\zombies\_zm::player_fake_death();
		}
	}

	if ( count == players.size && !is_true( level.no_end_game_check ) )
	{
		if ( players.size == 1 && flag( "solo_game" ) )
		{
			if ( solo_death )
			{
				self.lives = 0;
				level notify( "pre_end_game" );
				wait_network_frame();

				if ( flag( "dog_round" ) )
				{
					maps\mp\zombies\_zm::increment_dog_round_stat( "lost" );
				}

				level notify( "end_game" );
			}
			else
			{
				return finaldamage;
			}
		}
		else
		{
			level notify( "pre_end_game" );
			wait_network_frame();

			if ( flag( "dog_round" ) )
			{
				maps\mp\zombies\_zm::increment_dog_round_stat( "lost" );
			}

			level notify( "end_game" );
		}

		return 0;
	}
	else
	{
		surface = "flesh";
		return finaldamage;
	}
}

is_solo_death( players )
{
	if ( players.size == 1 && flag( "solo_game" ) )
	{
		if(self.solo_lives_given >= 3)
		{
			return 1;
		}

		if(isDefined(self.e_chugabud_corpse))
		{
			return 0;
		}

		active_perks = 0;
		if(isDefined(self.perks_active))
		{
			active_perks = self.perks_active.size;
		}

		disabled_perks = 0;
		if(isDefined(self.disabled_perks))
		{
			disabled_perks = self.disabled_perks.size;
		}

		if(active_perks <= disabled_perks)
		{
			return 1;
		}
	}

	return 0;
}

is_non_solo_death( players, count )
{
	if ( count > 1 || players.size == 1 && !flag( "solo_game" ) )
	{
		return 1;
	}

	return 0;
}

player_laststand( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
{
	b_alt_visionset = 0;
	self allowjump( 0 );
	currweapon = self getcurrentweapon();
	statweapon = currweapon;
	if ( is_alt_weapon( statweapon ) )
	{
		statweapon = weaponaltweaponname( statweapon );
	}
	self addweaponstat( statweapon, "deathsDuringUse", 1 );
	if ( is_true( self.hasperkspecialtytombstone ) )
	{
		self.laststand_perks = scripts\zm\_zm_reimagined::tombstone_save_perks( self );
	}
	if ( isDefined( self.pers_upgrades_awarded[ "perk_lose" ] ) && self.pers_upgrades_awarded[ "perk_lose" ] )
	{
		self maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_perk_lose_save();
	}
	players = get_players();
	if ( players.size == 1 && flag( "solo_game" ) )
	{
		if ( self.solo_lives_given < 3 )
		{
			active_perks = 0;
			if(isDefined(self.perks_active))
			{
				active_perks = self.perks_active.size;
			}

			disabled_perks = 0;
			if(isDefined(self.disabled_perks))
			{
				disabled_perks = self.disabled_perks.size;
			}

			if(active_perks > disabled_perks || isDefined(self.e_chugabud_corpse))
			{
				self thread maps\mp\zombies\_zm::wait_and_revive();
			}
		}
	}
	if ( self hasperk( "specialty_additionalprimaryweapon" ) )
	{
		self.weapon_taken_by_losing_specialty_additionalprimaryweapon = maps\mp\zombies\_zm::take_additionalprimaryweapon();
	}
	if ( is_true( self.hasperkspecialtytombstone ) )
	{
		self [[ level.tombstone_laststand_func ]]();
		self thread [[ level.tombstone_spawn_func ]]();

		if (!is_true(self._retain_perks))
		{
			self.hasperkspecialtytombstone = undefined;
			self notify( "specialty_scavenger_stop" );
		}
	}
	self clear_is_drinking();
	self thread maps\mp\zombies\_zm::remove_deadshot_bottle();
	self thread maps\mp\zombies\_zm::remote_revive_watch();
	self maps\mp\zombies\_zm_score::player_downed_penalty();
	self disableoffhandweapons();
	self thread maps\mp\zombies\_zm::last_stand_grenade_save_and_return();
	if ( smeansofdeath != "MOD_SUICIDE" && smeansofdeath != "MOD_FALLING" )
	{
		if ( !is_true( self.intermission ) )
		{
			self maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "revive_down" );
		}
		else
		{
			if ( isDefined( level.custom_player_death_vo_func ) &&  !self [[ level.custom_player_death_vo_func ]]() )
			{
				self maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "exert_death" );
			}
		}
	}
	bbprint( "zombie_playerdeaths", "round %d playername %s deathtype %s x %f y %f z %f", level.round_number, self.name, "downed", self.origin );
	if ( isDefined( level._zombie_minigun_powerup_last_stand_func ) )
	{
		self thread [[ level._zombie_minigun_powerup_last_stand_func ]]();
	}
	if ( isDefined( level._zombie_tesla_powerup_last_stand_func ) )
	{
		self thread [[ level._zombie_tesla_powerup_last_stand_func ]]();
	}
	if ( self hasperk( "specialty_grenadepulldeath" ) )
	{
		b_alt_visionset = 1;
		if ( isDefined( level.custom_laststand_func ) )
		{
			self thread [[ level.custom_laststand_func ]]();
		}
	}
	if ( is_true( self.intermission ) )
	{
		bbprint( "zombie_playerdeaths", "round %d playername %s deathtype %s x %f y %f z %f", level.round_number, self.name, "died", self.origin );
		wait 0.5;
		self stopsounds();
		level waittill( "forever" );
	}
	if ( !b_alt_visionset )
	{
		visionsetlaststand( "zombie_last_stand", 1 );
	}
}

callback_playerlaststand( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration )
{
    self endon( "disconnect" );
    [[ scripts\zm\replaced\_zm_laststand::playerlaststand ]]( einflictor, eattacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration );
}

player_spawn_protection()
{
	self endon("disconnect");
	self endon("player_downed");
	self endon("meat_grabbed");
	self endon("meat_stink_player_start");

	self thread player_spawn_protection_timeout();

	self.spawn_protection = 1;

	for ( x = 0; x < 60; x++ )
	{
		self.ignoreme = 1;
		wait 0.05;
	}

	if (!isDefined(level.meat_player))
	{
		self.ignoreme = 0;
	}

	self.spawn_protection = 0;
	self notify("player_spawn_protection_end");
}

player_spawn_protection_timeout()
{
	self endon("disconnect");
	self endon("player_spawn_protection_end");

	self waittill_any("player_downed", "meat_grabbed", "meat_stink_player_start");

	self.spawn_protection = 0;
}

wait_and_revive()
{
	flag_set( "wait_and_revive" );
	if ( isDefined( self.waiting_to_revive ) && self.waiting_to_revive == 1 )
	{
		return;
	}
	if ( is_true( self.pers_upgrades_awarded[ "perk_lose" ] ) )
	{
		self maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_perk_lose_save();
	}
	self.waiting_to_revive = 1;
	if ( isDefined( level.exit_level_func ) )
	{
		self thread [[ level.exit_level_func ]]();
	}
	else if ( get_players().size == 1 )
	{
		self thread maps\mp\zombies\_zm::default_exit_level();
	}
	solo_revive_time = 10;
	self.revive_hud.y = -160;
	self.revive_hud settext( &"ZOMBIE_REVIVING" );
	self maps\mp\zombies\_zm_laststand::revive_hud_show_n_fade( solo_revive_time );
	if ( !isDefined( self.beingrevivedprogressbar ) )
	{
		self.beingrevivedprogressbar = self createprimaryprogressbar();
        self.beingrevivedprogressbar setpoint("CENTER", undefined, level.primaryprogressbarx, -1 * level.primaryprogressbary);
        self.beingrevivedprogressbar.bar.color = (0.5, 0.5, 1);
        self.beingrevivedprogressbar.hidewheninmenu = 1;
        self.beingrevivedprogressbar.bar.hidewheninmenu = 1;
        self.beingrevivedprogressbar.barframe.hidewheninmenu = 1;
		self.beingrevivedprogressbar.sort = 1;
        self.beingrevivedprogressbar.bar.sort = 2;
        self.beingrevivedprogressbar.barframe.sort = 3;
		self.beingrevivedprogressbar.barframe destroy();
	}
	self.beingrevivedprogressbar updatebar( 0.01, 1 / solo_revive_time );
	flag_wait_or_timeout( "instant_revive", solo_revive_time );
	self.revive_hud settext( "" );
	if ( isDefined( self.beingrevivedprogressbar ) )
	{
		self.beingrevivedprogressbar destroyelem();
	}
	flag_clear( "wait_and_revive" );
	self maps\mp\zombies\_zm_laststand::auto_revive( self );
	self.solo_lives_given++;

	self.waiting_to_revive = 0;
	if ( is_true( self.pers_upgrades_awarded[ "perk_lose" ] ) )
	{
		self thread maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_perk_lose_restore();
	}
}

player_revive_monitor()
{
	self endon( "disconnect" );
	self notify( "stop_player_revive_monitor" );
	self endon( "stop_player_revive_monitor" );
	while ( 1 )
	{
		self waittill( "player_revived", reviver );
		self playsoundtoplayer( "zmb_character_revived", self );
		if ( isDefined( level.isresetting_grief ) && level.isresetting_grief )
		{
			continue;
		}
		bbprint( "zombie_playerdeaths", "round %d playername %s deathtype %s x %f y %f z %f", level.round_number, self.name, "revived", self.origin );
		if ( isDefined( reviver ) )
		{
			self maps\mp\zombies\_zm_audio::create_and_play_dialog( "general", "revive_up" );
			if(reviver != self)
			{
				points = self.score_lost_when_downed;
				reviver maps\mp\zombies\_zm_score::player_add_points( "reviver", points );
			}
			self.score_lost_when_downed = 0;
		}
	}
}

player_out_of_playable_area_monitor()
{
    self notify( "stop_player_out_of_playable_area_monitor" );
    self endon( "stop_player_out_of_playable_area_monitor" );
    self endon( "disconnect" );
    level endon( "end_game" );

    while ( !isdefined( self.characterindex ) )
        wait 0.05;

    wait( 0.15 * self.characterindex );

    while ( true )
    {
        if ( self.sessionstate == "spectator" )
        {
            wait( get_player_out_of_playable_area_monitor_wait_time() );
            continue;
        }

        if ( is_true( level.hostmigration_occured ) )
        {
            wait( get_player_out_of_playable_area_monitor_wait_time() );
            continue;
        }

		if ( get_players().size == 1 && flag( "solo_game" ) && ( isdefined( self.waiting_to_revive ) && self.waiting_to_revive ) )
		{
			wait( get_player_out_of_playable_area_monitor_wait_time() );
            continue;
		}

        if ( !self in_life_brush() && ( self in_kill_brush() || !self in_enabled_playable_area() ) )
        {
            if ( !isdefined( level.player_out_of_playable_area_monitor_callback ) || self [[ level.player_out_of_playable_area_monitor_callback ]]() )
            {
                self maps\mp\zombies\_zm_stats::increment_map_cheat_stat( "cheat_out_of_playable" );
                self maps\mp\zombies\_zm_stats::increment_client_stat( "cheat_out_of_playable", 0 );
                self maps\mp\zombies\_zm_stats::increment_client_stat( "cheat_total", 0 );
                self playlocalsound( level.zmb_laugh_alias );
                wait 0.5;

				self.lives = 0;
				self dodamage( self.health + 1000, self.origin );

				if (isDefined(level.player_suicide_func))
				{
					wait 0.05;
					self thread [[level.player_suicide_func]]();
				}
				else
				{
					self.bleedout_time = 0;
				}
            }
        }

        wait( get_player_out_of_playable_area_monitor_wait_time() );
    }
}

get_player_out_of_playable_area_monitor_wait_time()
{
    return 1;
}

player_too_many_weapons_monitor()
{
    self notify( "stop_player_too_many_weapons_monitor" );
    self endon( "stop_player_too_many_weapons_monitor" );
    self endon( "disconnect" );
    level endon( "end_game" );
    scalar = self.characterindex;

    if ( !isdefined( scalar ) )
        scalar = self getentitynumber();

    wait( 0.15 * scalar );

    while ( true )
    {
        if ( self has_powerup_weapon() || self maps\mp\zombies\_zm_laststand::player_is_in_laststand() || self.sessionstate == "spectator" )
        {
            wait( get_player_too_many_weapons_monitor_wait_time() );
            continue;
        }

        weapon_limit = get_player_weapon_limit( self );
        primaryweapons = self getweaponslistprimaries();

        if ( primaryweapons.size > weapon_limit )
        {
            self maps\mp\zombies\_zm_weapons::take_fallback_weapon();
            primaryweapons = self getweaponslistprimaries();
        }

        primary_weapons_to_take = [];

        for ( i = 0; i < primaryweapons.size; i++ )
        {
            if ( maps\mp\zombies\_zm_weapons::is_weapon_included( primaryweapons[i] ) || maps\mp\zombies\_zm_weapons::is_weapon_upgraded( primaryweapons[i] ) )
                primary_weapons_to_take[primary_weapons_to_take.size] = primaryweapons[i];
        }

        if ( primary_weapons_to_take.size > weapon_limit )
        {
            if ( !isdefined( level.player_too_many_weapons_monitor_callback ) || self [[ level.player_too_many_weapons_monitor_callback ]]( primary_weapons_to_take ) )
            {
                self maps\mp\zombies\_zm_stats::increment_map_cheat_stat( "cheat_too_many_weapons" );
                self maps\mp\zombies\_zm_stats::increment_client_stat( "cheat_too_many_weapons", 0 );
                self maps\mp\zombies\_zm_stats::increment_client_stat( "cheat_total", 0 );
                self takeweapon( primary_weapons_to_take[ primary_weapons_to_take.size - 1 ] );
            }
        }

        wait( get_player_too_many_weapons_monitor_wait_time() );
    }
}

get_player_too_many_weapons_monitor_wait_time()
{
    return 1;
}

end_game()
{
	level waittill( "end_game" );
	maps\mp\zombies\_zm::check_end_game_intermission_delay();
	clientnotify( "zesn" );
	if ( isDefined( level.sndgameovermusicoverride ) )
	{
		level thread maps\mp\zombies\_zm_audio::change_zombie_music( level.sndgameovermusicoverride );
	}
	else
	{
		level thread maps\mp\zombies\_zm_audio::change_zombie_music( "game_over" );
	}
	players = get_players();
	for ( i = 0; i < players.size; i++ )
	{
		setclientsysstate( "lsm", "0", players[ i ] );
	}
	for ( i = 0; i < players.size; i++ )
	{
		players[ i ] enableInvulnerability();
		if ( players[ i ] maps\mp\zombies\_zm_laststand::player_is_in_laststand() )
		{
			players[ i ] recordplayerdeathzombies();
			players[ i ] maps\mp\zombies\_zm_stats::increment_player_stat( "deaths" );
			players[ i ] maps\mp\zombies\_zm_stats::increment_client_stat( "deaths" );
			players[ i ] maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_jugg_player_death_stat();
		}
		if ( isdefined( players[ i ].revivetexthud) )
		{
			players[ i ].revivetexthud destroy();
		}
	}
	stopallrumbles();
	level.intermission = 1;
	level.zombie_vars[ "zombie_powerup_insta_kill_time" ] = 0;
	level.zombie_vars[ "zombie_powerup_fire_sale_time" ] = 0;
	level.zombie_vars[ "zombie_powerup_point_doubler_time" ] = 0;
	wait 0.1;
	game_over = [];
	survived = [];
	players = get_players();
	if ( !isDefined( level._supress_survived_screen ) )
	{
		for ( i = 0; i < players.size; i++ )
		{
			if ( isDefined( level.custom_game_over_hud_elem ) )
			{
				game_over[ i ] = [[ level.custom_game_over_hud_elem ]]( players[ i ] );
			}
			else
			{
				game_over[ i ] = newclienthudelem( players[ i ] );
				game_over[ i ].alignx = "center";
				game_over[ i ].aligny = "middle";
				game_over[ i ].horzalign = "center";
				game_over[ i ].vertalign = "middle";
				game_over[ i ].y -= 130;
				game_over[ i ].foreground = 1;
				game_over[ i ].fontscale = 3;
				game_over[ i ].alpha = 0;
				game_over[ i ].color = ( 1, 1, 1 );
				game_over[ i ].hidewheninmenu = 1;
				game_over[ i ] settext( &"ZOMBIE_GAME_OVER" );
				game_over[ i ] fadeovertime( 1 );
				game_over[ i ].alpha = 1;
			}
			survived[ i ] = newclienthudelem( players[ i ] );
			survived[ i ].alignx = "center";
			survived[ i ].aligny = "middle";
			survived[ i ].horzalign = "center";
			survived[ i ].vertalign = "middle";
			survived[ i ].y -= 100;
			survived[ i ].foreground = 1;
			survived[ i ].fontscale = 2;
			survived[ i ].alpha = 0;
			survived[ i ].color = ( 1, 1, 1 );
			survived[ i ].hidewheninmenu = 1;

			if ( level.round_number < 2 )
			{
				if ( level.script == "zombie_moon" )
				{
					if ( !isDefined( level.left_nomans_land ) )
					{
						nomanslandtime = level.nml_best_time;
						player_survival_time = int( nomanslandtime / 1000 );
						player_survival_time_in_mins = maps\mp\zombies\_zm::to_mins( player_survival_time );
						survived[ i ] settext( &"ZOMBIE_SURVIVED_NOMANS", player_survival_time_in_mins );
					}
					else if ( level.left_nomans_land == 2 )
					{
						survived[ i ] settext( &"ZOMBIE_SURVIVED_ROUND" );
					}
				}
				else
				{
					survived[ i ] settext( &"ZOMBIE_SURVIVED_ROUND" );
				}
			}
			else
			{
				survived[ i ] settext( &"ZOMBIE_SURVIVED_ROUNDS", level.round_number );
			}
			survived[ i ] fadeovertime( 1 );
			survived[ i ].alpha = 1;
		}
	}
	if ( isDefined( level.custom_end_screen ) )
	{
		level [[ level.custom_end_screen ]]();
	}
	for ( i = 0; i < players.size; i++ )
	{
		players[ i ] setclientammocounterhide( 1 );
		players[ i ] setclientminiscoreboardhide( 1 );
	}
	uploadstats();
	maps\mp\zombies\_zm_stats::update_players_stats_at_match_end( players );
	maps\mp\zombies\_zm_stats::update_global_counters_on_match_end();
	wait 1;
	wait 3.95;
	players = get_players();
	foreach ( player in players )
	{
		if ( isdefined( player.sessionstate ) && player.sessionstate == "spectator" )
		{
			player.sessionstate = "playing";
		}
	}
	wait 0.05;
	players = get_players();
	if ( !isDefined( level._supress_survived_screen ) )
	{
		for(i = 0; i < players.size; i++)
		{
			survived[ i ] destroy();
			game_over[ i ] destroy();
		}
	}
	for ( i = 0; i < players.size; i++ )
	{
		if ( isDefined( players[ i ].survived_hud ) )
		{
			players[ i ].survived_hud destroy();
		}
		if ( isDefined( players[ i ].game_over_hud ) )
		{
			players[ i ].game_over_hud destroy();
		}
	}
	maps\mp\zombies\_zm::intermission();
	wait level.zombie_vars[ "zombie_intermission_time" ];
	level notify( "stop_intermission" );
	array_thread( get_players(), maps\mp\zombies\_zm::player_exit_level );
	bbprint( "zombie_epilogs", "rounds %d", level.round_number );
	wait 1.5;
	players = get_players();
	for ( i = 0; i < players.size; i++ )
	{
		players[ i ] cameraactivate( 0 );
	}

	if (is_true(level.map_restart))
	{
		map_restart();
	}
	else
	{
		exitlevel(0);
	}

	wait 666;
}

check_quickrevive_for_hotjoin(disconnecting_player)
{
	if ( level.scr_zm_ui_gametype == "zgrief" )
	{
		return;
	}

	solo_mode = 0;
	subtract_num = 0;

	if ( isdefined( disconnecting_player ) )
        subtract_num = 1;

	players = get_players();

    if ( players.size - subtract_num == 1 )
    {
		solo_mode = 1;
        flag_set( "solo_game" );
    }
    else
    {
        flag_clear( "solo_game" );
    }

	set_default_laststand_pistol( solo_mode );
}