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

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

init()
{
	level.additionalprimaryweapon_limit = 3;
	level.perk_purchase_limit = 4;

	if (!level.createfx_enabled)
		perks_register_clientfield();

	if (!level.enable_magic)
		return;

	initialize_custom_perk_arrays();
	perk_machine_spawn_init();
	vending_weapon_upgrade_trigger = [];
	vending_triggers = getentarray("zombie_vending", "targetname");

	for (i = 0; i < vending_triggers.size; i++)
	{
		if (isdefined(vending_triggers[i].script_noteworthy) && vending_triggers[i].script_noteworthy == "specialty_weapupgrade")
		{
			vending_weapon_upgrade_trigger[vending_weapon_upgrade_trigger.size] = vending_triggers[i];
			arrayremovevalue(vending_triggers, vending_triggers[i]);
		}
	}

	old_packs = getentarray("zombie_vending_upgrade", "targetname");

	for (i = 0; i < old_packs.size; i++)
		vending_weapon_upgrade_trigger[vending_weapon_upgrade_trigger.size] = old_packs[i];

	flag_init("pack_machine_in_use");

	if (vending_triggers.size < 1)
		return;

	if (vending_weapon_upgrade_trigger.size >= 1)
		array_thread(vending_weapon_upgrade_trigger, ::vending_weapon_upgrade);

	level.machine_assets = [];

	if (!isdefined(level.custom_vending_precaching))
		level.custom_vending_precaching = ::default_vending_precaching;

	[[level.custom_vending_precaching]]();

	if (!isdefined(level.packapunch_timeout))
		level.packapunch_timeout = 15;

	set_zombie_var("zombie_perk_cost", 2000);
	set_zombie_var("zombie_perk_juggernaut_health", 160);
	set_zombie_var("zombie_perk_juggernaut_health_upgrade", 190);
	array_thread(vending_triggers, ::vending_trigger_think);
	array_thread(vending_triggers, ::electric_perks_dialog);

	if (isdefined(level.zombiemode_using_doubletap_perk) && level.zombiemode_using_doubletap_perk)
		level thread turn_doubletap_on();

	if (isdefined(level.zombiemode_using_marathon_perk) && level.zombiemode_using_marathon_perk)
		level thread turn_marathon_on();

	if (isdefined(level.zombiemode_using_juggernaut_perk) && level.zombiemode_using_juggernaut_perk)
		level thread turn_jugger_on();

	if (isdefined(level.zombiemode_using_revive_perk) && level.zombiemode_using_revive_perk)
		level thread turn_revive_on();

	if (isdefined(level.zombiemode_using_sleightofhand_perk) && level.zombiemode_using_sleightofhand_perk)
		level thread turn_sleight_on();

	if (isdefined(level.zombiemode_using_deadshot_perk) && level.zombiemode_using_deadshot_perk)
		level thread turn_deadshot_on();

	if (isdefined(level.zombiemode_using_tombstone_perk) && level.zombiemode_using_tombstone_perk)
		level thread turn_tombstone_on();

	if (isdefined(level.zombiemode_using_additionalprimaryweapon_perk) && level.zombiemode_using_additionalprimaryweapon_perk)
		level thread turn_additionalprimaryweapon_on();

	if (isdefined(level.zombiemode_using_chugabud_perk) && level.zombiemode_using_chugabud_perk)
		level thread turn_chugabud_on();

	if (level._custom_perks.size > 0)
	{
		a_keys = getarraykeys(level._custom_perks);

		for (i = 0; i < a_keys.size; i++)
		{
			if (isdefined(level._custom_perks[a_keys[i]].perk_machine_thread))
				level thread [[level._custom_perks[a_keys[i]].perk_machine_thread]]();
		}
	}

	if (isdefined(level._custom_turn_packapunch_on))
		level thread [[level._custom_turn_packapunch_on]]();
	else
		level thread turn_packapunch_on();

	if (isdefined(level.quantum_bomb_register_result_func))
		[[level.quantum_bomb_register_result_func]]("give_nearest_perk", ::quantum_bomb_give_nearest_perk_result, 10, ::quantum_bomb_give_nearest_perk_validation);

	level thread perk_hostmigration();
}

vending_trigger_think()
{
	self endon("death");
	wait 0.01;
	perk = self.script_noteworthy;
	solo = 0;
	start_on = 0;
	level.revive_machine_is_solo = 0;

	if (isdefined(perk) && (perk == "specialty_quickrevive" || perk == "specialty_quickrevive_upgrade"))
	{
		flag_wait("start_zombie_round_logic");
		solo = use_solo_revive();
		self endon("stop_quickrevive_logic");
		level.quick_revive_trigger = self;

		if (solo)
		{
			if (!is_true(level.revive_machine_is_solo))
			{
				start_on = 1;
				players = get_players();

				foreach (player in players)
				{
					if (!isdefined(player.lives))
						player.lives = 0;
				}

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

			level.revive_machine_is_solo = 1;
		}
	}

	self sethintstring(&"ZOMBIE_NEED_POWER");
	self setcursorhint("HINT_NOICON");
	self usetriggerrequirelookat();
	cost = level.zombie_vars["zombie_perk_cost"];

	switch (perk)
	{
		case "specialty_armorvest_upgrade":
		case "specialty_armorvest":
			cost = 2500;
			break;

		case "specialty_quickrevive_upgrade":
		case "specialty_quickrevive":
			if (solo)
				cost = 500;
			else
				cost = 1500;

			break;

		case "specialty_fastreload_upgrade":
		case "specialty_fastreload":
			cost = 3000;
			break;

		case "specialty_rof_upgrade":
		case "specialty_rof":
			cost = 2000;
			break;

		case "specialty_longersprint_upgrade":
		case "specialty_longersprint":
			cost = 2000;
			break;

		case "specialty_deadshot_upgrade":
		case "specialty_deadshot":
			cost = 1500;
			break;

		case "specialty_additionalprimaryweapon_upgrade":
		case "specialty_additionalprimaryweapon":
			cost = 4000;
			break;
	}

	if (isdefined(level._custom_perks[perk]) && isdefined(level._custom_perks[perk].cost))
		cost = level._custom_perks[perk].cost;

	self.cost = cost;

	if (!start_on)
	{
		notify_name = perk + "_power_on";

		level waittill(notify_name);
	}

	start_on = 0;

	if (!isdefined(level._perkmachinenetworkchoke))
		level._perkmachinenetworkchoke = 0;
	else
		level._perkmachinenetworkchoke++;

	for (i = 0; i < level._perkmachinenetworkchoke; i++)
		wait_network_frame();

	self thread maps\mp\zombies\_zm_audio::perks_a_cola_jingle_timer();
	self thread check_player_has_perk(perk);

	switch (perk)
	{
		case "specialty_armorvest_upgrade":
		case "specialty_armorvest":
			self sethintstring(&"ZOMBIE_PERK_JUGGERNAUT", cost);
			break;

		case "specialty_quickrevive_upgrade":
		case "specialty_quickrevive":
			if (solo)
				self sethintstring(&"ZOMBIE_PERK_QUICKREVIVE_SOLO", cost);
			else
				self sethintstring(&"ZOMBIE_PERK_QUICKREVIVE", cost);

			break;

		case "specialty_fastreload_upgrade":
		case "specialty_fastreload":
			self sethintstring(&"ZOMBIE_PERK_FASTRELOAD", cost);
			break;

		case "specialty_rof_upgrade":
		case "specialty_rof":
			self sethintstring(&"ZOMBIE_PERK_DOUBLETAP", cost);
			break;

		case "specialty_longersprint_upgrade":
		case "specialty_longersprint":
			self sethintstring(&"ZOMBIE_PERK_MARATHON", cost);
			break;

		case "specialty_deadshot_upgrade":
		case "specialty_deadshot":
			self sethintstring(&"ZOMBIE_PERK_DEADSHOT", cost);
			break;

		case "specialty_additionalprimaryweapon_upgrade":
		case "specialty_additionalprimaryweapon":
			self sethintstring(&"ZOMBIE_PERK_ADDITIONALPRIMARYWEAPON", cost);
			break;

		case "specialty_scavenger_upgrade":
		case "specialty_scavenger":
			self sethintstring(&"ZOMBIE_PERK_TOMBSTONE", cost);
			break;

		case "specialty_finalstand_upgrade":
		case "specialty_finalstand":
			self sethintstring(&"ZOMBIE_PERK_CHUGABUD", cost);
			break;

		default:
			self sethintstring(perk + " Cost: " + level.zombie_vars["zombie_perk_cost"]);
	}

	if (isdefined(level._custom_perks[perk]) && isdefined(level._custom_perks[perk].hint_string))
		self sethintstring(level._custom_perks[perk].hint_string, cost);

	for (;;)
	{
		self waittill("trigger", player);

		index = maps\mp\zombies\_zm_weapons::get_player_index(player);

		if (player maps\mp\zombies\_zm_laststand::player_is_in_laststand() || isdefined(player.intermission) && player.intermission)
			continue;

		if (player in_revive_trigger())
			continue;

		if (player isthrowinggrenade())
		{
			wait 0.1;
			continue;
		}

		if (player isswitchingweapons())
		{
			wait 0.1;
			continue;
		}

		if (player.is_drinking > 0)
		{
			wait 0.1;
			continue;
		}

		if (player hasperk(perk) || player has_perk_paused(perk))
		{
			cheat = 0;

			if (cheat != 1)
			{
				self playsound("evt_perk_deny");
				player maps\mp\zombies\_zm_audio::create_and_play_dialog("general", "perk_deny", undefined, 1);
				continue;
			}
		}

		if (isdefined(level.custom_perk_validation))
		{
			valid = self [[level.custom_perk_validation]](player);

			if (!valid)
				continue;
		}

		current_cost = cost;

		if (player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active())
			current_cost = player maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_double_points_cost(current_cost);

		if (player.score < current_cost)
		{
			self playsound("evt_perk_deny");
			player maps\mp\zombies\_zm_audio::create_and_play_dialog("general", "perk_deny", undefined, 0);
			continue;
		}

		if (player.num_perks >= player get_player_perk_purchase_limit())
		{
			self playsound("evt_perk_deny");
			player maps\mp\zombies\_zm_audio::create_and_play_dialog("general", "sigh");
			continue;
		}

		sound = "evt_bottle_dispense";
		playsoundatposition(sound, self.origin);
		player maps\mp\zombies\_zm_score::minus_to_player_score(current_cost, 1);
		player.perk_purchased = perk;
		self thread maps\mp\zombies\_zm_audio::play_jingle_or_stinger(self.script_label);
		self thread vending_trigger_post_think(player, perk);
	}
}

vending_trigger_post_think(player, perk)
{
	player endon("disconnect");
	player endon("end_game");
	player endon("perk_abort_drinking");
	player.pre_temp_weapon = player perk_give_bottle_begin(perk);
	evt = player waittill_any_return("fake_death", "death", "player_downed", "weapon_change_complete");

	if (evt == "weapon_change_complete")
		player thread wait_give_perk(perk, 1);

	player perk_give_bottle_end(player.pre_temp_weapon, perk);

	if (player maps\mp\zombies\_zm_laststand::player_is_in_laststand() || isdefined(player.intermission) && player.intermission)
	{
		player.lastactiveweapon = player.pre_temp_weapon;
		return;
	}

	player.pre_temp_weapon = undefined;

	player notify("burp");

	if (isdefined(level.pers_upgrade_cash_back) && level.pers_upgrade_cash_back)
		player maps\mp\zombies\_zm_pers_upgrades_functions::cash_back_player_drinks_perk();

	if (isdefined(level.pers_upgrade_perk_lose) && level.pers_upgrade_perk_lose)
		player thread maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_perk_lose_bought();

	if (isdefined(level.perk_bought_func))
		player [[level.perk_bought_func]](perk);

	player.perk_purchased = undefined;

	if (is_false(self.power_on))
	{
		wait 1;
		perk_pause(self.script_noteworthy);
	}

	bbprint("zombie_uses", "playername %s playerscore %d round %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, perk, self.origin, "perk");
}

perk_give_bottle_end(gun, perk)
{
	self endon("perk_abort_drinking");
	assert(!is_zombie_perk_bottle(gun));
	assert(gun != level.revive_tool);
	self enable_player_move_states();
	weapon = "";

	switch (perk)
	{
		case "specialty_rof_upgrade":
		case "specialty_rof":
			weapon = level.machine_assets["doubletap"].weapon;
			break;

		case "specialty_longersprint_upgrade":
		case "specialty_longersprint":
			weapon = level.machine_assets["marathon"].weapon;
			break;

		case "specialty_flakjacket_upgrade":
		case "specialty_flakjacket":
			weapon = level.machine_assets["divetonuke"].weapon;
			break;

		case "specialty_armorvest_upgrade":
		case "specialty_armorvest":
			weapon = level.machine_assets["juggernog"].weapon;
			self.jugg_used = 1;
			break;

		case "specialty_quickrevive_upgrade":
		case "specialty_quickrevive":
			weapon = level.machine_assets["revive"].weapon;
			break;

		case "specialty_fastreload_upgrade":
		case "specialty_fastreload":
			weapon = level.machine_assets["speedcola"].weapon;
			self.speed_used = 1;
			break;

		case "specialty_deadshot_upgrade":
		case "specialty_deadshot":
			weapon = level.machine_assets["deadshot"].weapon;
			break;

		case "specialty_additionalprimaryweapon_upgrade":
		case "specialty_additionalprimaryweapon":
			weapon = level.machine_assets["additionalprimaryweapon"].weapon;
			break;

		case "specialty_scavenger_upgrade":
		case "specialty_scavenger":
			weapon = level.machine_assets["tombstone"].weapon;
			break;

		case "specialty_finalstand_upgrade":
		case "specialty_finalstand":
			weapon = level.machine_assets["whoswho"].weapon;
			break;
	}

	if (isdefined(level._custom_perks[perk]) && isdefined(level._custom_perks[perk].perk_bottle))
		weapon = level._custom_perks[perk].perk_bottle;

	if (self maps\mp\zombies\_zm_laststand::player_is_in_laststand() || isdefined(self.intermission) && self.intermission)
	{
		self takeweapon(weapon);
		return;
	}

	self takeweapon(weapon);

	if (self is_multiple_drinking())
	{
		self decrement_is_drinking();
		return;
	}
	else if (gun != "none" && !is_equipment_that_blocks_purchase(gun))
	{
		self switchtoweapon(gun);

		if (is_melee_weapon(gun))
		{
			self decrement_is_drinking();
			return;
		}
	}
	else
	{
		primaryweapons = self getweaponslistprimaries();

		if (isdefined(primaryweapons) && primaryweapons.size > 0)
			self switchtoweapon(primaryweapons[0]);
	}

	self waittill("weapon_change_complete");

	if (!self maps\mp\zombies\_zm_laststand::player_is_in_laststand() && !(isdefined(self.intermission) && self.intermission))
		self decrement_is_drinking();
}

vending_weapon_upgrade()
{
	level endon("Pack_A_Punch_off");
	wait 0.01;
	perk_machine = getent(self.target, "targetname");
	self.perk_machine = perk_machine;
	perk_machine_sound = getentarray("perksacola", "targetname");
	packa_rollers = spawn("script_origin", self.origin);
	packa_timer = spawn("script_origin", self.origin);
	packa_rollers linkto(self);
	packa_timer linkto(self);

	if (isdefined(perk_machine.target))
		perk_machine.wait_flag = getent(perk_machine.target, "targetname");

	pap_is_buildable = self is_buildable();

	if (pap_is_buildable)
	{
		self trigger_off();
		perk_machine hide();

		if (isdefined(perk_machine.wait_flag))
			perk_machine.wait_flag hide();

		wait_for_buildable("pap");
		self trigger_on();
		perk_machine show();

		if (isdefined(perk_machine.wait_flag))
			perk_machine.wait_flag show();
	}

	self usetriggerrequirelookat();
	self sethintstring(&"ZOMBIE_NEED_POWER");
	self setcursorhint("HINT_NOICON");
	power_off = !self maps\mp\zombies\_zm_power::pap_is_on();

	if (power_off)
	{
		pap_array = [];
		pap_array[0] = perk_machine;
		level thread do_initial_power_off_callback(pap_array, "packapunch");

		level waittill("Pack_A_Punch_on");
	}

	self enable_trigger();

	if (isdefined(level.machine_assets["packapunch"].power_on_callback))
		perk_machine thread [[level.machine_assets["packapunch"].power_on_callback]]();

	self thread vending_machine_trigger_think();
	perk_machine playloopsound("zmb_perks_packa_loop");
	self thread shutoffpapsounds(perk_machine, packa_rollers, packa_timer);
	self thread vending_weapon_upgrade_cost();

	for (;;)
	{
		self.pack_player = undefined;

		self waittill("trigger", player);

		index = maps\mp\zombies\_zm_weapons::get_player_index(player);
		current_weapon = player getcurrentweapon();

		if ("microwavegun_zm" == current_weapon)
			current_weapon = "microwavegundw_zm";

		current_weapon = player maps\mp\zombies\_zm_weapons::switch_from_alt_weapon(current_weapon);

		if (isdefined(level.custom_pap_validation))
		{
			valid = self [[level.custom_pap_validation]](player);

			if (!valid)
				continue;
		}

		if (!player maps\mp\zombies\_zm_magicbox::can_buy_weapon() || player maps\mp\zombies\_zm_laststand::player_is_in_laststand() || isdefined(player.intermission) && player.intermission || player isthrowinggrenade() || !player maps\mp\zombies\_zm_weapons::can_upgrade_weapon(current_weapon))
		{
			wait 0.1;
			continue;
		}

		if (player isswitchingweapons())
		{
			wait 0.1;

			if (player isswitchingweapons())
				continue;
		}

		if (!maps\mp\zombies\_zm_weapons::is_weapon_or_base_included(current_weapon))
			continue;

		current_cost = self.cost;
		player.restore_ammo = undefined;
		player.restore_clip = undefined;
		player.restore_stock = undefined;
		player_restore_clip_size = undefined;
		player.restore_max = undefined;
		upgrade_as_attachment = will_upgrade_weapon_as_attachment(current_weapon);

		if (upgrade_as_attachment)
		{
			current_cost = self.attachment_cost;
			player.restore_ammo = 1;
			player.restore_clip = player getweaponammoclip(current_weapon);
			player.restore_clip_size = weaponclipsize(current_weapon);
			player.restore_stock = player getweaponammostock(current_weapon);
			player.restore_max = weaponmaxammo(current_weapon);
		}

		if (player maps\mp\zombies\_zm_pers_upgrades_functions::is_pers_double_points_active())
			current_cost = player maps\mp\zombies\_zm_pers_upgrades_functions::pers_upgrade_double_points_cost(current_cost);

		if (!upgrade_as_attachment && player.score < current_cost)
		{
			self playsound("evt_perk_deny");

			if (isdefined(level.custom_pap_deny_vo_func))
				player [[level.custom_pap_deny_vo_func]]();
			else
				player maps\mp\zombies\_zm_audio::create_and_play_dialog("general", "perk_deny", undefined, 0);

			continue;
		}

		self.pack_player = player;
		flag_set("pack_machine_in_use");
		maps\mp\_demo::bookmark("zm_player_use_packapunch", gettime(), player);
		player maps\mp\zombies\_zm_stats::increment_client_stat("use_pap");
		player maps\mp\zombies\_zm_stats::increment_player_stat("use_pap");
		self thread destroy_weapon_in_blackout(player);
		self thread destroy_weapon_on_disconnect(player);

		if (!upgrade_as_attachment)
		{
			player maps\mp\zombies\_zm_score::minus_to_player_score(current_cost, 1);
		}

		sound = "evt_bottle_dispense";
		playsoundatposition(sound, self.origin);
		self thread maps\mp\zombies\_zm_audio::play_jingle_or_stinger("mus_perks_packa_sting");
		player maps\mp\zombies\_zm_audio::create_and_play_dialog("weapon_pickup", "upgrade_wait");
		self disable_trigger();
		self sethintstring("");

		if (!(isdefined(upgrade_as_attachment) && upgrade_as_attachment))
			player thread do_player_general_vox("general", "pap_wait", 10, 100);
		else
			player thread do_player_general_vox("general", "pap_wait2", 10, 100);

		player thread do_knuckle_crack();
		self.current_weapon = current_weapon;
		upgrade_name = maps\mp\zombies\_zm_weapons::get_upgrade_weapon(current_weapon, upgrade_as_attachment);
		player third_person_weapon_upgrade(current_weapon, upgrade_name, packa_rollers, perk_machine, self);
		self enable_trigger();
		self sethintstring(&"ZOMBIE_GET_UPGRADED");

		if (isdefined(player))
		{
			self setinvisibletoall();
			self setvisibletoplayer(player);
			self thread wait_for_player_to_take(player, current_weapon, packa_timer, upgrade_as_attachment);
		}

		self thread wait_for_timeout(current_weapon, packa_timer, player);
		self waittill_any("pap_timeout", "pap_taken", "pap_player_disconnected");
		self.current_weapon = "";

		if (isdefined(self.worldgun) && isdefined(self.worldgun.worldgundw))
			self.worldgun.worldgundw delete();

		if (isdefined(self.worldgun))
			self.worldgun delete();

		if (isdefined(level.zombiemode_reusing_pack_a_punch) && level.zombiemode_reusing_pack_a_punch)
			self sethintstring(&"ZOMBIE_PERK_PACKAPUNCH_ATT", self.cost);
		else
			self sethintstring(&"ZOMBIE_PERK_PACKAPUNCH", self.cost);

		self setvisibletoall();
		self.pack_player = undefined;
		flag_clear("pack_machine_in_use");
	}
}

destroy_weapon_in_blackout(player)
{
	self endon("pap_timeout");
	self endon("pap_taken");
	self endon("pap_player_disconnected");

	level waittill("Pack_A_Punch_off");

	if (isDefined(self.worldgun))
	{
		if (isDefined(self.worldgun.worldgundw))
		{
			self.worldgun.worldgundw delete();
		}

		self.worldgun delete();
	}

	self.perk_machine.wait_flag rotateTo(self.perk_machine.angles + (0, 180, 180), 0.25, 0, 0);
}

give_perk(perk, bought)
{
	self setperk(perk);
	self.num_perks++;

	if (isDefined(bought) && bought)
	{
		self maps\mp\zombies\_zm_audio::playerexert("burp");

		if (isDefined(level.remove_perk_vo_delay) && level.remove_perk_vo_delay)
		{
			self maps\mp\zombies\_zm_audio::perk_vox(perk);
		}
		else
		{
			self delay_thread(1.5, maps\mp\zombies\_zm_audio::perk_vox, perk);
		}

		self notify("perk_bought");
	}

	self perk_set_max_health_if_jugg(perk, 1, 0);

	if (isDefined(level.disable_deadshot_clientfield) && !level.disable_deadshot_clientfield)
	{
		if (perk == "specialty_deadshot")
		{
			self setclientfieldtoplayer("deadshot_perk", 1);
		}
		else
		{
			if (perk == "specialty_deadshot_upgrade")
			{
				self setclientfieldtoplayer("deadshot_perk", 1);
			}
		}
	}

	if (perk == "specialty_scavenger")
	{
		self.hasperkspecialtytombstone = 1;
	}

	players = get_players();

	if (use_solo_revive() && perk == "specialty_quickrevive")
	{
		self.lives = 1;

		if (!isDefined(level.solo_lives_given))
		{
			level.solo_lives_given = 0;
		}

		if (isDefined(level.solo_game_free_player_quickrevive))
		{
			level.solo_game_free_player_quickrevive = undefined;
		}
		else
		{
			level.solo_lives_given++;
		}

		if (level.solo_lives_given >= 3)
		{
			flag_set("solo_revive");
		}

		self thread solo_revive_buy_trigger_move(perk);
	}

	if (perk == "specialty_finalstand")
	{
		self.hasperkspecialtychugabud = 1;
		self notify("perk_chugabud_activated");
	}

	if (perk == "specialty_additionalprimaryweapon")
	{
		self scripts\zm\replaced\_zm::restore_additionalprimaryweapon();
	}

	if (isDefined(level._custom_perks[perk]) && isDefined(level._custom_perks[perk].player_thread_give))
	{
		self thread [[level._custom_perks[perk].player_thread_give]]();
	}

	self set_perk_clientfield(perk, 1);
	maps\mp\_demo::bookmark("zm_player_perk", getTime(), self);
	self maps\mp\zombies\_zm_stats::increment_client_stat("perks_drank");
	self maps\mp\zombies\_zm_stats::increment_client_stat(perk + "_drank");
	self maps\mp\zombies\_zm_stats::increment_player_stat(perk + "_drank");
	self maps\mp\zombies\_zm_stats::increment_player_stat("perks_drank");

	if (!isDefined(self.perk_history))
	{
		self.perk_history = [];
	}

	self.perk_history = add_to_array(self.perk_history, perk, 0);

	if (!isDefined(self.perks_active))
	{
		self.perks_active = [];
	}

	self.perks_active[self.perks_active.size] = perk;
	self notify("perk_acquired");
	self thread perk_think(perk);
}

perk_think(perk)
{
	self endon("disconnect");

	perk_str = perk + "_stop";
	result = self waittill_any_return("fake_death", "death", "player_downed", perk_str);
	do_retain = 1;

	if (use_solo_revive() && perk == "specialty_quickrevive")
	{
		do_retain = 0;
	}

	if (do_retain)
	{
		if (is_true(self._retain_perks))
		{
			return;
		}
		else if (isDefined(self._retain_perks_array) && is_true(self._retain_perks_array[perk]))
		{
			return;
		}
	}

	self unsetperk(perk);
	self.num_perks--;

	switch (perk)
	{
		case "specialty_armorvest":
			self setmaxhealth(self.premaxhealth);
			break;

		case "specialty_additionalprimaryweapon":
			if (result == perk_str)
			{
				self maps\mp\zombies\_zm::take_additionalprimaryweapon();
			}

			break;

		case "specialty_deadshot":
			if (!is_true(level.disable_deadshot_clientfield))
			{
				self setclientfieldtoplayer("deadshot_perk", 0);
			}

			break;

		case "specialty_deadshot_upgrade":
			if (!is_true(level.disable_deadshot_clientfield))
			{
				self setclientfieldtoplayer("deadshot_perk", 0);
			}

			break;

		case "specialty_scavenger":
			self.hasperkspecialtytombstone = undefined;
			break;
	}

	if (isDefined(level._custom_perks[perk]) && isDefined(level._custom_perks[perk].player_thread_take))
	{
		self thread [[level._custom_perks[perk].player_thread_take]]();
	}

	self set_perk_clientfield(perk, 0);
	self.perk_purchased = undefined;

	if (isDefined(level.perk_lost_func))
	{
		self [[level.perk_lost_func]](perk);
	}

	if (isDefined(self.perks_active) && isinarray(self.perks_active, perk))
	{
		arrayremovevalue(self.perks_active, perk, 0);
	}

	if (isDefined(self.disabled_perks) && isDefined(self.disabled_perks[perk]))
	{
		self.disabled_perks[perk] = undefined;
	}

	self notify("perk_lost");
}

perk_set_max_health_if_jugg(perk, set_premaxhealth, clamp_health_to_max_health)
{
	max_total_health = undefined;

	if (perk == "specialty_armorvest")
	{
		if (set_premaxhealth)
		{
			self.premaxhealth = self.maxhealth;
		}

		max_total_health = level.zombie_vars["zombie_perk_juggernaut_health"];
	}
	else if (perk == "specialty_armorvest_upgrade")
	{
		if (set_premaxhealth)
		{
			self.premaxhealth = self.maxhealth;
		}

		max_total_health = level.zombie_vars["zombie_perk_juggernaut_health_upgrade"];
	}
	else if (perk == "jugg_upgrade")
	{
		if (set_premaxhealth)
		{
			self.premaxhealth = self.maxhealth;
		}

		if (self hasperk("specialty_armorvest"))
		{
			max_total_health = level.zombie_vars["zombie_perk_juggernaut_health"];
		}
		else
		{
			max_total_health = level.player_starting_health;
		}
	}
	else if (perk == "health_reboot")
	{
		if (self hasperk("specialty_armorvest"))
		{
			max_total_health = level.zombie_vars["zombie_perk_juggernaut_health"];
		}
		else
		{
			max_total_health = level.player_starting_health;
		}
	}

	if (isDefined(max_total_health))
	{
		if (self maps\mp\zombies\_zm_pers_upgrades_functions::pers_jugg_active())
		{
			max_total_health += level.pers_jugg_upgrade_health_bonus;
		}

		if (is_true(level.sudden_death))
		{
			max_total_health -= 100;
		}

		missinghealth = self.maxhealth - self.health;
		self setmaxhealth(max_total_health);
		self.health -= missinghealth;

		if (isDefined(clamp_health_to_max_health) && clamp_health_to_max_health == 1)
		{
			if (self.health > self.maxhealth)
			{
				self.health = self.maxhealth;
			}
		}
	}
}

set_perk_clientfield(perk, state)
{
	switch (perk)
	{
		case "specialty_additionalprimaryweapon":
			self setclientfieldtoplayer("perk_additional_primary_weapon", state);
			break;

		case "specialty_deadshot":
			self setclientfieldtoplayer("perk_dead_shot", state);
			break;

		case "specialty_flakjacket":
			self setclientfieldtoplayer("perk_dive_to_nuke", state);
			break;

		case "specialty_rof":
			self setclientfieldtoplayer("perk_double_tap", state);
			break;

		case "specialty_armorvest":
			self setclientfieldtoplayer("perk_juggernaut", state);
			break;

		case "specialty_movefaster":
			self setclientfieldtoplayer("perk_marathon", state);
			break;

		case "specialty_quickrevive":
			self setclientfieldtoplayer("perk_quick_revive", state);
			break;

		case "specialty_fastreload":
			self setclientfieldtoplayer("perk_sleight_of_hand", state);
			break;

		case "specialty_scavenger":
			self setclientfieldtoplayer("perk_tombstone", state);
			break;

		case "specialty_finalstand":
			self setclientfieldtoplayer("perk_chugabud", state);
			break;

		default:
			break;
	}

	if (isdefined(level._custom_perks[perk]) && isdefined(level._custom_perks[perk].clientfield_set))
		self [[level._custom_perks[perk].clientfield_set]](state);
}

initialize_custom_perk_arrays()
{
	if (!isDefined(level._custom_perks))
	{
		level._custom_perks = [];
	}

	level._custom_perks["specialty_movefaster"] = spawnStruct();
	level._custom_perks["specialty_movefaster"].cost = 2500;
	level._custom_perks["specialty_movefaster"].alias = "marathon";
	level._custom_perks["specialty_movefaster"].hint_string = &"ZOMBIE_PERK_MARATHON";
	level._custom_perks["specialty_movefaster"].perk_bottle = "zombie_perk_bottle_marathon";
	level._custom_perks["specialty_movefaster"].perk_machine_thread = ::turn_movefaster_on;

	struct = spawnStruct();
	struct.script_noteworthy = "specialty_longersprint";
	struct.scr_zm_ui_gametype = "zstandard";
	struct.scr_zm_map_start_location = "town";
	struct.origin_offset = (-4, 0, 0);
	move_perk_machine("zm_transit", "town", "specialty_quickrevive", struct);

	struct = spawnStruct();
	struct.script_noteworthy = "specialty_longersprint";
	struct.scr_zm_ui_gametype = "zclassic";
	struct.scr_zm_map_start_location = "transit";
	move_perk_machine("zm_transit", "town", "specialty_longersprint", struct);

	struct = spawnStruct();
	struct.origin = (1852, -825, -56);
	struct.angles = (0, 180, 0);
	struct.script_string = "zgrief";
	move_perk_machine("zm_transit", "town", "specialty_scavenger", struct);

	struct = spawnStruct();
	struct.script_noteworthy = "specialty_quickrevive";
	struct.scr_zm_ui_gametype = "zgrief";
	struct.scr_zm_map_start_location = "street";
	move_perk_machine("zm_buried", "street", "specialty_longersprint", struct);

	struct = spawnStruct();
	struct.script_noteworthy = "specialty_fastreload";
	struct.scr_zm_ui_gametype = "zgrief";
	struct.scr_zm_map_start_location = "street";
	struct.origin_offset = (0, -32, 0);
	move_perk_machine("zm_buried", "street", "specialty_quickrevive", struct);

	struct = spawnStruct();
	struct.script_noteworthy = "specialty_fastreload";
	struct.scr_zm_ui_gametype = "zclassic";
	struct.scr_zm_map_start_location = "processing";
	move_perk_machine("zm_buried", "street", "specialty_fastreload", struct);

	if (getDvar("g_gametype") == "zgrief" && getDvarIntDefault("ui_gametype_pro", 0))
	{
		remove_pap_machine();
	}
}

remove_pap_machine()
{
	exceptions = array("specialty_armorvest", "specialty_fastreload");

	structs = getStructArray("zm_perk_machine", "targetname");

	foreach (struct in structs)
	{
		if (isDefined(struct.script_noteworthy) && struct.script_noteworthy == "specialty_weapupgrade")
		{
			struct.script_string = "";
		}
	}
}

move_perk_machine(map, location, perk, move_struct)
{
	if (!(level.script == map && level.scr_zm_map_start_location == location))
	{
		return;
	}

	perk_struct = undefined;
	structs = getStructArray("zm_perk_machine", "targetname");

	foreach (struct in structs)
	{
		if (isDefined(struct.script_noteworthy) && struct.script_noteworthy == perk)
		{
			if (isDefined(struct.script_string) && isSubStr(struct.script_string, "perks_" + location))
			{
				perk_struct = struct;
				break;
			}
		}
	}

	if (!isDefined(perk_struct))
	{
		return;
	}

	if (isDefined(move_struct.script_string))
	{
		gametypes = strTok(move_struct.script_string, " ");

		foreach (gametype in gametypes)
		{
			perk_struct.script_string += " " + gametype + "_perks_" + location;
		}
	}

	if (isDefined(move_struct.origin))
	{
		perk_struct.origin = move_struct.origin;
		perk_struct.angles = move_struct.angles;

		return;
	}

	foreach (struct in structs)
	{
		if (isDefined(struct.script_noteworthy) && struct.script_noteworthy == move_struct.script_noteworthy)
		{
			if (isDefined(struct.script_string) && isSubStr(struct.script_string, move_struct.scr_zm_ui_gametype + "_perks_" + move_struct.scr_zm_map_start_location))
			{
				perk_struct.origin = struct.origin;
				perk_struct.angles = struct.angles;

				if (isDefined(move_struct.origin_offset))
				{
					perk_struct.origin += move_struct.origin_offset;
				}

				break;
			}
		}
	}
}

turn_movefaster_on()
{
	while (1)
	{
		machine = getentarray("vending_marathon", "targetname");
		machine_triggers = getentarray("vending_marathon", "target");
		i = 0;

		while (i < machine.size)
		{
			machine[i] setmodel(level.machine_assets["marathon"].off_model);
			i++;
		}

		array_thread(machine_triggers, ::set_power_on, 0);
		level thread do_initial_power_off_callback(machine, "marathon");
		level waittill("marathon_on");
		i = 0;

		while (i < machine.size)
		{
			machine[i] setmodel(level.machine_assets["marathon"].on_model);
			machine[i] vibrate(vectorScale((0, -1, 0), 100), 0.3, 0.4, 3);
			machine[i] playsound("zmb_perks_power_on");
			machine[i] thread perk_fx("marathon_light");
			machine[i] thread play_loop_on_machine();
			i++;
		}

		level notify("specialty_movefaster_power_on");
		array_thread(machine_triggers, ::set_power_on, 1);

		if (isDefined(level.machine_assets["marathon"].power_on_callback))
		{
			array_thread(machine, level.machine_assets["marathon"].power_on_callback);
		}

		level waittill("marathon_off");

		if (isDefined(level.machine_assets["marathon"].power_off_callback))
		{
			array_thread(machine, level.machine_assets["marathon"].power_off_callback);
		}

		array_thread(machine, ::turn_perk_off);
	}
}

turn_tombstone_on()
{
	level endon("tombstone_removed");

	while (true)
	{
		machine = getentarray("vending_tombstone", "targetname");
		machine_triggers = getentarray("vending_tombstone", "target");

		for (i = 0; i < machine.size; i++)
			machine[i] setmodel(level.machine_assets["tombstone"].off_model);

		level thread do_initial_power_off_callback(machine, "tombstone");
		array_thread(machine_triggers, ::set_power_on, 0);

		level waittill("tombstone_on");

		for (i = 0; i < machine.size; i++)
		{
			machine[i] setmodel(level.machine_assets["tombstone"].on_model);
			machine[i] vibrate(vectorscale((0, -1, 0), 100.0), 0.3, 0.4, 3);
			machine[i] playsound("zmb_perks_power_on");
			machine[i] thread perk_fx("tombstone_light");
			machine[i] thread play_loop_on_machine();
		}

		level notify("specialty_scavenger_power_on");
		array_thread(machine_triggers, ::set_power_on, 1);

		if (isdefined(level.machine_assets["tombstone"].power_on_callback))
			array_thread(machine, level.machine_assets["tombstone"].power_on_callback);

		level waittill("tombstone_off");

		if (isdefined(level.machine_assets["tombstone"].power_off_callback))
			array_thread(machine, level.machine_assets["tombstone"].power_off_callback);

		array_thread(machine, ::turn_perk_off);
		players = get_players();
	}
}

wait_for_player_to_take(player, weapon, packa_timer, upgrade_as_attachment)
{
	current_weapon = self.current_weapon;
	upgrade_name = self.upgrade_name;
	upgrade_weapon = upgrade_name;
	self endon("pap_timeout");
	level endon("Pack_A_Punch_off");

	while (true)
	{
		packa_timer playloopsound("zmb_perks_packa_ticktock");

		self waittill("trigger", trigger_player);

		if (isdefined(level.pap_grab_by_anyone) && level.pap_grab_by_anyone)
			player = trigger_player;

		packa_timer stoploopsound(0.05);

		if (trigger_player == player)
		{
			player maps\mp\zombies\_zm_stats::increment_client_stat("pap_weapon_grabbed");
			player maps\mp\zombies\_zm_stats::increment_player_stat("pap_weapon_grabbed");
			current_weapon = player getcurrentweapon();

			primaries = player getweaponslistprimaries();
			weapon_limit = get_player_weapon_limit(player);

			if (is_player_valid(player) && !(player.is_drinking > 0) && level.revive_tool != current_weapon && "none" != current_weapon && !player hacker_active() && (primaries.size < weapon_limit || (!is_melee_weapon(current_weapon) && !is_placeable_mine(current_weapon) && !is_equipment(current_weapon))))
			{
				maps\mp\_demo::bookmark("zm_player_grabbed_packapunch", gettime(), player);
				self notify("pap_taken");
				player notify("pap_taken");
				player.pap_used = 1;

				if (!(isdefined(upgrade_as_attachment) && upgrade_as_attachment))
					player thread do_player_general_vox("general", "pap_arm", 15, 100);
				else
					player thread do_player_general_vox("general", "pap_arm2", 15, 100);

				weapon_limit = get_player_weapon_limit(player);
				player maps\mp\zombies\_zm_weapons::take_fallback_weapon();
				primaries = player getweaponslistprimaries();

				if (isdefined(primaries) && primaries.size >= weapon_limit)
					player maps\mp\zombies\_zm_weapons::weapon_give(upgrade_weapon);
				else
				{
					player giveweapon(upgrade_weapon, 0, player maps\mp\zombies\_zm_weapons::get_pack_a_punch_weapon_options(upgrade_weapon));
					player givestartammo(upgrade_weapon);
					player notify("weapon_ammo_change");
				}

				player switchtoweapon(upgrade_weapon);

				if (isdefined(player.restore_ammo) && player.restore_ammo)
				{
					new_clip = player.restore_clip + weaponclipsize(upgrade_weapon) - player.restore_clip_size;
					new_stock = player.restore_stock + weaponmaxammo(upgrade_weapon) - player.restore_max;
					player setweaponammostock(upgrade_weapon, new_stock);
					player setweaponammoclip(upgrade_weapon, new_clip);
				}

				player.restore_ammo = undefined;
				player.restore_clip = undefined;
				player.restore_stock = undefined;
				player.restore_max = undefined;
				player.restore_clip_size = undefined;
				player maps\mp\zombies\_zm_weapons::play_weapon_vo(upgrade_weapon);
				return;
			}
		}

		wait 0.05;
	}
}

check_player_has_perk(perk)
{
	self endon("death");

	dist = 16384;

	while (true)
	{
		players = get_players();

		for (i = 0; i < players.size; i++)
		{
			if (distancesquared(players[i].origin, self.origin) < dist)
			{
				if (!players[i] hasperk(perk) && !players[i] has_perk_paused(perk) && !players[i] in_revive_trigger() && !is_equipment_that_blocks_purchase(players[i] getcurrentweapon()) && !players[i] hacker_active() && !players[i].is_drinking)
				{
					self setinvisibletoplayer(players[i], 0);
					continue;
				}

				self setinvisibletoplayer(players[i], 1);
			}
		}

		wait 0.05;
	}
}

perk_pause(perk)
{
	// disabled
}

perk_unpause(perk)
{
	// disabled
}