BO2-Reimagined/scripts/zm/replaced/_zm.gsc

#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;

init_fx()
{
	if (level.script == "zm_buried" || level.script == "zm_prison")
	{
		level._uses_sticky_grenades = 1;
		level.disable_fx_zmb_wall_buy_semtex = 0;
	}

	if (level.script == "zm_prison")
	{
		register_lethal_grenade_for_level("sticky_grenade_zm");
	}

	level.createfx_callback_thread = ::delete_in_createfx;
	level._effect["wood_chunk_destory"] = loadfx("impacts/fx_large_woodhit");
	level._effect["fx_zombie_bar_break"] = loadfx("maps/zombie/fx_zombie_bar_break");
	level._effect["fx_zombie_bar_break_lite"] = loadfx("maps/zombie/fx_zombie_bar_break_lite");

	if (!(isdefined(level.fx_exclude_edge_fog) && level.fx_exclude_edge_fog))
		level._effect["edge_fog"] = loadfx("maps/zombie/fx_fog_zombie_amb");

	level._effect["chest_light"] = loadfx("maps/zombie/fx_zmb_tranzit_marker_glow");

	if (!(isdefined(level.fx_exclude_default_eye_glow) && level.fx_exclude_default_eye_glow))
		level._effect["eye_glow"] = loadfx("misc/fx_zombie_eye_single");

	level._effect["headshot"] = loadfx("impacts/fx_flesh_hit");
	level._effect["headshot_nochunks"] = loadfx("misc/fx_zombie_bloodsplat");
	level._effect["bloodspurt"] = loadfx("misc/fx_zombie_bloodspurt");

	if (!(isdefined(level.fx_exclude_tesla_head_light) && level.fx_exclude_tesla_head_light))
		level._effect["tesla_head_light"] = loadfx("maps/zombie/fx_zombie_tesla_neck_spurt");

	level._effect["zombie_guts_explosion"] = loadfx("maps/zombie/fx_zmb_tranzit_torso_explo");
	level._effect["rise_burst_water"] = loadfx("maps/zombie/fx_mp_zombie_hand_dirt_burst");
	level._effect["rise_billow_water"] = loadfx("maps/zombie/fx_mp_zombie_body_dirt_billowing");
	level._effect["rise_dust_water"] = loadfx("maps/zombie/fx_mp_zombie_body_dust_falling");
	level._effect["rise_burst"] = loadfx("maps/zombie/fx_mp_zombie_hand_dirt_burst");
	level._effect["rise_billow"] = loadfx("maps/zombie/fx_mp_zombie_body_dirt_billowing");
	level._effect["rise_dust"] = loadfx("maps/zombie/fx_mp_zombie_body_dust_falling");
	level._effect["fall_burst"] = loadfx("maps/zombie/fx_mp_zombie_hand_dirt_burst");
	level._effect["fall_billow"] = loadfx("maps/zombie/fx_mp_zombie_body_dirt_billowing");
	level._effect["fall_dust"] = loadfx("maps/zombie/fx_mp_zombie_body_dust_falling");
	level._effect["character_fire_death_sm"] = loadfx("env/fire/fx_fire_zombie_md");
	level._effect["character_fire_death_torso"] = loadfx("env/fire/fx_fire_zombie_torso");

	if (!(isdefined(level.fx_exclude_default_explosion) && level.fx_exclude_default_explosion))
		level._effect["def_explosion"] = loadfx("explosions/fx_default_explosion");

	if (!(isdefined(level._uses_default_wallbuy_fx) && !level._uses_default_wallbuy_fx))
	{
		level._effect["870mcs_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_870mcs");
		level._effect["vector_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_ak74u");
		level._effect["beretta93r_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_berreta93r");
		level._effect["bowie_knife_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_bowie");
		level._effect["claymore_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_claymore");
		level._effect["saritch_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_m14");
		level._effect["sig556_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_m16");
		level._effect["insas_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_mp5k");
		level._effect["ballista_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_olympia");
	}

	if (!(isdefined(level._uses_sticky_grenades) && !level._uses_sticky_grenades))
	{
		if (!(isdefined(level.disable_fx_zmb_wall_buy_semtex) && level.disable_fx_zmb_wall_buy_semtex))
		{
			grenade = "sticky_grenade_zm";

			if (level.script == "zm_buried")
			{
				grenade = "frag_grenade_zm";
			}

			level._effect[grenade + "_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_semtex");
		}
	}

	if (!(isdefined(level._uses_taser_knuckles) && !level._uses_taser_knuckles))
		level._effect["tazer_knuckles_zm_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_taseknuck");

	if (isdefined(level.buildable_wallbuy_weapons))
		level._effect["dynamic_wallbuy_fx"] = loadfx("maps/zombie/fx_zmb_wall_buy_question");

	if (!(isdefined(level.disable_fx_upgrade_aquired) && level.disable_fx_upgrade_aquired))
		level._effect["upgrade_aquired"] = loadfx("maps/zombie/fx_zmb_tanzit_upgrade");
}

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 pregame_think();

		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");
}

pregame_think()
{
	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;

	setroundsplayed(0);

	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 = &"ZOMBIE_WAITING_FOR_MORE_PLAYERS_CAPS";

		if (num_waiting_for == 1)
		{
			players_str = &"ZOMBIE_WAITING_FOR_MORE_PLAYER_CAPS";
		}

		level.pregame_hud setText(players_str, num_waiting_for, 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(&"ZOMBIE_READY_UP_HOWTO_CAPS");
	}

	level.ready_up_hud.alpha = 1;

	ready_up_time = 0;
	ready_up_timeout = 0;
	ready_up_start_time = undefined;
	ready_up_start_players = undefined;

	if (isDedicated() && !(is_gametype_active("zgrief") && getDvarInt("ui_gametype_team_change")))
	{
		ready_up_time = 60;
	}

	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 (ready_up_time > 0)
		{
			if (num_ready > 0 && !isdefined(ready_up_start_time))
			{
				ready_up_start_time = getTime();
				ready_up_start_players = get_players();

				if (!isDefined(level.ready_up_countdown_hud))
				{
					level.ready_up_countdown_hud = countdown_hud(&"ZOMBIE_PRE_GAME_ENDS_IN_CAPS", undefined, ready_up_time);
				}
			}

			if (isdefined(ready_up_start_time))
			{
				time = getTime() - ready_up_start_time;

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

					foreach (player in 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 pregame_think();

			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 = &"ZOMBIE_WAITING_FOR_PLAYERS_READY_CAPS";

		if (num_waiting_for == 1)
		{
			players_str = &"ZOMBIE_WAITING_FOR_PLAYER_READY_CAPS";
		}

		level.pregame_hud setText(players_str, num_waiting_for, 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, text_param, 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);

	if (isdefined(text_param))
	{
		countdown_hud.countdown_text setText(text, text_param);
	}
	else
	{
		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] = "fnp45_zm";
	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] = "fnp45_upgraded_zm";
	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 undefined;

	self scripts\zm\_zm_reimagined::additionalprimaryweapon_update_weapon_slots();

	weapon_to_take = self.weapon_to_take_by_losing_specialty_additionalprimaryweapon;

	if (!isDefined(weapon_to_take) || !self hasWeapon(weapon_to_take))
	{
		return undefined;
	}

	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())
	{
		for (i = 0; i < self.weapon_slots.size; i++)
		{
			if (isdefined(self.weapon_slots[i]) && self.weapon_slots[i] != weapon_to_take)
			{
				self switchtoweapon(self.weapon_slots[i]);
				break;
			}
		}
	}

	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 (issubstr(weapon, "one_inch_punch") && damage <= 5)
	{
		return 0;
	}

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

	if (scripts\zm\_zm_reimagined::is_tazer_weapon(weapon) || weapon == "jetgun_zm" || weapon == "riotshield_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 = scale_damage(damage, 600);
	}

	if (weapon == "willy_pete_zm")
	{
		if (!is_true(self.is_brutus))
		{
			if (is_true(self.real_willy_pete_damage))
			{
				self.real_willy_pete_damage = undefined;
			}
			else
			{
				// hack to make Smoke Grenade use MOD_UNKNOWN so zombies don't gib
				self.real_willy_pete_damage = 1;
				self dodamage(self.health, inflictor.origin, attacker, self, "none", "MOD_UNKNOWN", 0, weapon);
				return 0;
			}
		}
	}

	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 = scale_damage(damage, 200);
		}
	}

	if (weapon == "quadrotorturret_zm" && meansofdeath == "MOD_PISTOL_BULLET")
	{
		if (!is_true(self.is_mechz))
		{
			damage = scale_damage(damage, 6000);
		}
	}

	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 (weapon == "blundergat_zm")
	{
		if (!is_true(self.is_brutus))
		{
			final_damage = scale_damage(final_damage, 500);
		}
	}

	if (weapon == "blundergat_upgraded_zm")
	{
		if (!is_true(self.is_brutus))
		{
			final_damage = scale_damage(final_damage, 1000);
		}
	}

	if (weapon == "blundersplat_explosive_dart_zm")
	{
		if (!is_true(self.is_brutus))
		{
			final_damage = scale_damage(final_damage, 4000);
		}
	}

	if (weapon == "blundersplat_explosive_dart_upgraded_zm")
	{
		if (!is_true(self.is_brutus))
		{
			final_damage = scale_damage(final_damage, 8000);
		}
	}

	if (issubstr(weapon, "metalstorm"))
	{
		if (issubstr(weapon, "upgraded"))
		{
			final_damage = scale_damage(final_damage, 10000);
		}
		else
		{
			final_damage = scale_damage(final_damage, 5000);
		}
	}

	if (weapon == "titus6_explosive_dart_zm")
	{
		final_damage = scale_damage(final_damage, 3000);
	}

	if (weapon == "titus6_explosive_dart_upgraded_zm")
	{
		final_damage = scale_damage(final_damage, 6000);
	}

	if (weapon == "mk_titus6_zm")
	{
		final_damage = scale_damage(final_damage, 500);
	}

	if (weapon == "mk_titus6_upgraded_zm")
	{
		final_damage = scale_damage(final_damage, 1000);
	}

	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);
}

scale_damage(damage, damage_to_kill)
{
	scalar = damage / damage_to_kill;
	scaled_damage = int(scalar * level.zombie_health) + 1;

	if (damage < scaled_damage)
	{
		return scaled_damage;
	}

	return 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"))
		{
			if (is_true(self.divetoprone))
			{
				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 (sweapon == "willy_pete_zm")
		{
			return 0;
		}

		exp_damage = 75;

		if (sweapon == "titus6_explosive_dart_zm" || sweapon == "titus6_explosive_dart_upgraded_zm")
		{
			exp_damage = 15;
		}

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

	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();

	if (level.script != "zm_nuked")
	{
		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);
	}

	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);
}