bo1 perk script

#include maps\_utility;
#include common_scripts\utility;
#include maps\_zombiemode_utility;

//*******************************************************************************\\
/*
MODIFIED PERKS SCRIPT FOR ZOMBIES

Author: F3ARxReaper666 (death_reaper0 on UGX/fourms)

CHANGES/ADDITIONS:
changes functions to allow perks to be customized with 1 line each
ability to add custom perks easily
automatically detects any perks in the map ran (no need to add level variables)
customisable perk slots per player (default 4)
	-level.perk_limit = 4; -base perk slot limit
	-to add a perk slot for 1 player, call 	 maps\_zombiemode_perks::give_perk_slot();  on a player
	-to change base perk limit see line 28

see line 81 for how to add aditional perks

*/
//*******************************************************************************\\

init()
{
	place_additionalprimaryweapon_machine();
	level.perk_limit = 4;	//change to be perk limit for all players
	PrecacheItem( "zombie_knuckle_crack" );
	level.zombiemode_divetonuke_perk_func = ::divetonuke_explode;
	level._effect["divetonuke_groundhit"] = loadfx("maps/zombie/fx_zmb_phdflopper_exp");
	set_zombie_var( "zombie_perk_divetonuke_radius", 300 ); // WW (01/12/2011): Issue 74726:DLC 2 - Zombies - Cosmodrome - PHD Flopper - Increase the radius on the explosion (Old: 150)
	set_zombie_var( "zombie_perk_divetonuke_min_damage", 1000 );
	set_zombie_var( "zombie_perk_divetonuke_max_damage", 5000 );
	PrecacheModel("zombie_vending_packapunch_on");
	level._effect["doubletap_light"]				= loadfx("misc/fx_zombie_cola_dtap_on");
	level._effect["marathon_light"]					= loadfx("maps/zombie/fx_zmb_cola_staminup_on");
	level._effect["divetonuke_light"]				= loadfx("misc/fx_zombie_cola_dtap_on");
	level._effect["deadshot_light"]					= loadfx("misc/fx_zombie_cola_dtap_on");
	level._effect["additionalprimaryweapon_light"]	= loadfx("misc/fx_zombie_cola_arsenal_on");
	level._effect["jugger_light"]					= loadfx("misc/fx_zombie_cola_jugg_on");
	level._effect["revive_light"]					= loadfx("misc/fx_zombie_cola_revive_on");
	level._effect["sleight_light"]					= loadfx("misc/fx_zombie_cola_on");
	level._effect["packapunch_fx"]					= loadfx("maps/zombie/fx_zombie_packapunch");
	level._effect["revive_light_flicker"]			= loadfx("maps/zombie/fx_zmb_cola_revive_flicker");
	PrecacheString( &"ZOMBIE_PERK_PACKAPUNCH" );

	// Perks-a-cola vending machine use triggers
	vending_triggers = GetEntArray( "zombie_vending", "targetname" );

	// Pack-A-Punch weapon upgrade machine use triggers
	vending_weapon_upgrade_trigger = GetEntArray("zombie_vending_upgrade", "targetname");
	flag_init("pack_machine_in_use");
	flag_init( "solo_game" );

	if( level.mutators["mutator_noPerks"] )
	{
		for( i = 0; i < vending_triggers.size; i++ )
		{
			vending_triggers[i] disable_trigger();
		}
		for( i = 0; i < vending_weapon_upgrade_trigger.size; i++ )
		{
			vending_weapon_upgrade_trigger[i] disable_trigger();
		}
		return;
	}

	if ( vending_triggers.size < 1 )
	{
		return;
	}

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

//*******************************************************************************\\
/*
all items, materials and models WILL be precached from this, no need to do it above. only fx will not be

add_perk( vending_machine, specialty, light_fx, machine_change, cost, perk_name, perk_name_actual, shader, bottle_weapon, short_jingle, function);
vending_machine	 - targetname on machine
specialty		 - trigger specialty (script_noteworthy)
light_fx		 - name of fx used for machine (level._effect[ -> light_fx <- ]) e.g. "zombie_vending_jugg_on"
machine_change	 - name of model to change to when powers on (CAN leave undefined if none)
cost			 - cost of the perk (should be a whole number e.g. 2500 )
perk_name		 - string of perks name e.g. "Deadshot Daquari" (leave undefined if string is already made e.g. &"ZOMBIE_PERK_JUGGERNAUT")
perk_name_actual - use this if above is undefined ONLY! should be used if string exists e.g. "ZOMBIE_PERK_JUGGERNAUT"
shader			 - name of icon to show up in game e.g. "specialty_juggernaut_zombies"
bottle_weapon	 - name of bottle used when drinking e.g. "zombie_perk_bottle_jugg"
short_jingle	 - name of jingle to play upon purchase e.g. "mx_jugger_sting"
function		 - threaded fuction that will only play if perk exists e.g. ::my_fuction

add_custom_perk( vending_machine, specialty, light_fx, machine_change, cost, perk_name, perk_name_actual, shader, bottle_weapon, short_jingle, function);
 -same as everything above, but WILL NOT need a specific specialty, instead saves to an array on player
 -for these perks, you will need different checks for if the player has it (listed below)

HasPerk( specialty_NAME )		-|-	will become	-|-		maps\_zombiemode_perks::HasCustomPerk( specialty_NAME )
UnsetPerk( specialty_NAME )		-|-	will become	-|-		maps\_zombiemode_perks::UnsetCustomPerk( specialty_NAME )
SetPerk( specialty_NAME )		-|-	will become	-|-		maps\_zombiemode_perks::SetCustomPerk( specialty_NAME )

extra fuctions for custom specialty perks
maps\_zombiemode_perks::IsCustomPerk( specialty_NAME )		- returns true if specialty is listed as a custom specialty
maps\_zombiemode_perks::CreateCustomPerk( specialty_NAME )	- shouldnt be needed, but this will create a custom specialty (add_custom_perk() will automaticly use this)
maps\_zombiemode_perks::HasThePerk( specialty_NAME )		- finds out if player has that perk as custom or normal (it will find out if its custom or normal for you)
*/
//*******************************************************************************\\


	//	 				   vending_machine, specialty, 			  light_fx, 	  machine_change, 		   cost, perk_name, perk_name_actual,		 	shader, 					   bottle_weapon,			   short_jingle,	 function
	level thread add_perk("vending_jugg", "specialty_armorvest", "jugger_light", "zombie_vending_jugg_on", 2500, undefined, &"ZOMBIE_PERK_JUGGERNAUT", "specialty_juggernaut_zombies", "zombie_perk_bottle_jugg", "mx_jugger_sting", undefined);
	level thread add_perk("vending_sleight", "specialty_fastreload", "sleight_light", "zombie_vending_sleight_on", 3000, undefined, &"ZOMBIE_PERK_FASTRELOAD", "specialty_fastreload_zombies", "zombie_perk_bottle_sleight", "mx_speed_sting", undefined);
	level thread add_perk("vending_doubletap", "specialty_rof", "doubletap_light", "zombie_vending_doubletap_on", 2000, undefined, &"ZOMBIE_PERK_DOUBLETAP", "specialty_doubletap_zombies", "zombie_perk_bottle_doubletap", "mx_doubletap_sting", undefined);
	level thread add_perk("vending_revive", "specialty_quickrevive", "revive_light", "zombie_vending_revive_on", 1500, undefined, &"ZOMBIE_PERK_QUICKREVIVE", "specialty_quickrevive_zombies", "zombie_perk_bottle_revive", "mx_revive_sting", undefined);

	level thread add_perk("vending_divetonuke", "specialty_flakjacket", "divetonuke_light", "zombie_vending_nuke_on", 2000, "PHD Flopper", undefined, "specialty_divetonuke_zombies", "zombie_perk_bottle_nuke", undefined, undefined);
	level thread add_perk("vending_marathon", "specialty_longersprint", "marathon_light", "zombie_vending_marathon_on", 2000, "Stamin-Up", undefined, "specialty_marathon_zombies", "zombie_perk_bottle_marathon", undefined, undefined);
	level thread add_perk("vending_deadshot", "specialty_deadshot", "deadshot_light", "zombie_vending_ads_on", 1000, "Deadshot Daquari", undefined, "specialty_ads_zombies", "zombie_perk_bottle_deadshot", undefined, undefined);
	level thread add_perk("vending_additionalprimaryweapon", "specialty_additionalprimaryweapon", "additionalprimaryweapon_light", "zombie_vending_three_gun_on", 4000, "Mule Kick", undefined, "specialty_extraprimaryweapon_zombies", "zombie_perk_bottle_additionalprimaryweapon", undefined, undefined);

	level thread add_custom_perk("vending_bulletdamage", "specialty_bulletdamage", "revive_light", undefined, 3000, "Tufbrew", undefined, "specialty_tufbrew_zombies", "zombie_perk_bottle_doubletap", undefined, undefined);
	level thread add_custom_perk("vending_bulletaccuracy", "specialty_bulletaccuracy", "sleight_light", undefined, 2500, "Candolier Soda", undefined, "specialty_candolier_zombies", "zombie_perk_bottle_sleight", undefined, undefined);


	//custom perk fuctions
	maps\_zombiemode_spawner::register_zombie_damage_callback(::tufbrew_func);//tufbrew perk, double damage on bullet guns
	//level thread candolier();	//bandolier perk, 2 extra clips of ammo for each gun, add to weapon files of each gun



	//Perks machine
	if( !isDefined( level.packapunch_timeout ) )
	{
		level.packapunch_timeout = 15;
	}

	set_zombie_var( "zombie_perk_cost",					2000 );
	if( level.mutators["mutator_susceptible"] )
	{
		set_zombie_var( "zombie_perk_juggernaut_health",	80 );
		set_zombie_var( "zombie_perk_juggernaut_health_upgrade",	95 );
	}
	else
	{
		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 );

	level thread turn_PackAPunch_on();
	level thread perk_slot_setup();

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


place_additionalprimaryweapon_machine()
{
	if ( !isdefined( level.zombie_additionalprimaryweapon_machine_origin ) )
	{
		return;
	}

	machine = Spawn( "script_model", level.zombie_additionalprimaryweapon_machine_origin );
	machine.angles = level.zombie_additionalprimaryweapon_machine_angles;
	machine setModel( "zombie_vending_three_gun" );
	machine.targetname = "vending_additionalprimaryweapon";

	machine_trigger = Spawn( "trigger_radius_use", level.zombie_additionalprimaryweapon_machine_origin + (0, 0, 30), 0, 20, 70 );
	machine_trigger.targetname = "zombie_vending";
	machine_trigger.target = "vending_additionalprimaryweapon";
	machine_trigger.script_noteworthy = "specialty_additionalprimaryweapon";

	if ( isdefined( level.zombie_additionalprimaryweapon_machine_clip_origin ) )
	{
		machine_clip = spawn( "script_model", level.zombie_additionalprimaryweapon_machine_clip_origin );
		machine_clip.angles = level.zombie_additionalprimaryweapon_machine_clip_angles;
		machine_clip setmodel( "collision_geo_64x64x256" );
		machine_clip Hide();
	}

	if ( isdefined( level.zombie_additionalprimaryweapon_machine_monkey_origins ) )
	{
		machine.target = "vending_additionalprimaryweapon_monkey_structs";
		for ( i = 0; i < level.zombie_additionalprimaryweapon_machine_monkey_origins.size; i++ )
		{
			machine_monkey_struct = SpawnStruct();
			machine_monkey_struct.origin = level.zombie_additionalprimaryweapon_machine_monkey_origins[i];
			machine_monkey_struct.angles = level.zombie_additionalprimaryweapon_machine_monkey_angles;
			machine_monkey_struct.script_int = i + 1;
			machine_monkey_struct.script_notetworthy = "cosmo_monkey_additionalprimaryweapon";
			machine_monkey_struct.targetname = "vending_additionalprimaryweapon_monkey_structs";

			if ( !IsDefined( level.struct_class_names["targetname"][machine_monkey_struct.targetname] ) )
			{
				level.struct_class_names["targetname"][machine_monkey_struct.targetname] = [];
			}

			size = level.struct_class_names["targetname"][machine_monkey_struct.targetname].size;
			level.struct_class_names["targetname"][machine_monkey_struct.targetname][size] = machine_monkey_struct;
		}
	}

	level.zombiemode_using_additionalprimaryweapon_perk = true;
}

HasThePerk( perk )
{
	p = false;
	if(IsCustomPerk(perk))
		if(self HasCustomPerk( perk ))
			p = true;
	else
		if(self HasPerk( perk ))
			p = true;
	return p;
}

CreateCustomPerk( specialty )
{
	if(!isdefined(level.custom_perk_array))
		level.custom_perk_array = [];
	level.custom_perk_array[specialty] = true;
}

IsCustomPerk( specialty )
{
	if(isdefined(level.custom_perk_array))
//		for ( i = 0; i < level.custom_perk_array.size; i++ )
			if(isdefined(level.custom_perk_array[specialty]) && level.custom_perk_array[specialty] == true)
				return true;
	return false;
}

HasCustomPerk( specialty )
{
	if(!isdefined(self.custom_perk_array))
		self.custom_perk_array = [];
	if(isdefined(self.custom_perk_array))
//		for ( i = 0; i < self.custom_perk_array.size; i++ )
			if(isdefined(self.custom_perk_array[specialty]) && self.custom_perk_array[specialty] == true)
				return true;
	return false;
}

SetCustomPerk( specialty )
{
	if(!isdefined(self.custom_perk_array))
		self.custom_perk_array = [];
	self.custom_perk_array[specialty] = true;
}

UnsetCustomPerk( specialty )
{
	if(!isdefined(self.custom_perk_array))
		self.custom_perk_array = [];
	self.custom_perk_array[specialty] = undefined;
}

add_custom_perk(vending_machine, specialty, light_fx, machine_change, cost, perk_name, perk_name_actual, shader, bottle_weapon, sound, function)
{
	CreateCustomPerk( specialty );
	level thread add_perk(vending_machine, specialty, light_fx, machine_change, cost, perk_name, perk_name_actual, shader, bottle_weapon, sound, function);
}

add_perk(vending_machine, specialty, light_fx, machine_change, cost, perk_name, perk_name_actual, shader, bottle_weapon, sound, function)
{
	if (!isdefined(level.zombie_perks))
		level.zombie_perks = [];
	if (!isdefined(level.perk_total))
		level.perk_total =0;
	//make sure the map uses this perk
	perk_exists = false;
	vending_triggers = GetEntArray( "zombie_vending", "targetname" );
	for ( i = 0; i < vending_triggers.size; i++ )
	{
		perk = vending_triggers[i].script_noteworthy;
		if (perk == specialty)
			perk_exists = true;
	}
	if (!perk_exists) return;
	level.perk_total +=1;
	if(isDefined(machine_change))
		PrecacheModel(machine_change);
	if(isDefined(bottle_weapon))
		PrecacheItem(bottle_weapon);
	level thread turn_perk_on(vending_machine, specialty, light_fx, machine_change);
	perk = SpawnStruct();
	if(isDefined(perk_name_actual))
	{
		PrecacheString( perk_name_actual );
		perk.perk_name_actual = perk_name_actual;
	}
	else
		perk.perk_name = perk_name;
	perk.cost = cost;
	perk.bottle_weapon = bottle_weapon;
	PrecacheShader( shader );
	perk.shader = shader;
	if (isDefined(sound))
		perk.sound = sound;
	level.zombie_perks[specialty] = perk;
	if (isDefined(function))
		level thread [[function]]();
}

third_person_weapon_upgrade( current_weapon, origin, angles, packa_rollers, perk_machine )
{
	forward = anglesToForward( angles );
	interact_pos = origin + (forward*-25);
	PlayFx( level._effect["packapunch_fx"], origin+(0,1,-34), forward );

	worldgun = spawn( "script_model", interact_pos );
	worldgun.angles  = self.angles;
	worldgun setModel( GetWeaponModel( current_weapon ) );
	worldgun useweaponhidetags( current_weapon );
	worldgun rotateto( angles+(0,90,0), 0.35, 0, 0 );

	offsetdw = ( 3, 3, 3 );
	worldgundw = undefined;
	if ( maps\_zombiemode_weapons::weapon_is_dual_wield( current_weapon ) )
	{
		worldgundw = spawn( "script_model", interact_pos + offsetdw );
		worldgundw.angles  = self.angles;

		worldgundw setModel( maps\_zombiemode_weapons::get_left_hand_weapon_model_name( current_weapon ) );
		worldgundw useweaponhidetags( current_weapon );
		worldgundw rotateto( angles+(0,90,0), 0.35, 0, 0 );
	}

	wait( 0.5 );

	worldgun moveto( origin, 0.5, 0, 0 );
	if ( isdefined( worldgundw ) )
	{
		worldgundw moveto( origin + offsetdw, 0.5, 0, 0 );
	}

	self playsound( "zmb_perks_packa_upgrade" );
	if( isDefined( perk_machine.wait_flag ) )
	{
		perk_machine.wait_flag rotateto( perk_machine.wait_flag.angles+(179, 0, 0), 0.25, 0, 0 );
	}
	wait( 0.35 );

	worldgun delete();
	if ( isdefined( worldgundw ) )
	{
		worldgundw delete();
	}

	wait( 3 );

	self playsound( "zmb_perks_packa_ready" );

	worldgun = spawn( "script_model", origin );
	worldgun.angles  = angles+(0,90,0);
	worldgun setModel( GetWeaponModel( level.zombie_weapons[current_weapon].upgrade_name ) );
	worldgun useweaponhidetags( level.zombie_weapons[current_weapon].upgrade_name );
	worldgun moveto( interact_pos, 0.5, 0, 0 );

	worldgundw = undefined;
	if ( maps\_zombiemode_weapons::weapon_is_dual_wield( level.zombie_weapons[current_weapon].upgrade_name ) )
	{
		worldgundw = spawn( "script_model", origin + offsetdw );
		worldgundw.angles  = angles+(0,90,0);

		worldgundw setModel( maps\_zombiemode_weapons::get_left_hand_weapon_model_name( level.zombie_weapons[current_weapon].upgrade_name ) );
		worldgundw useweaponhidetags( level.zombie_weapons[current_weapon].upgrade_name );
		worldgundw moveto( interact_pos + offsetdw, 0.5, 0, 0 );
	}

	if( isDefined( perk_machine.wait_flag ) )
	{
		perk_machine.wait_flag rotateto( perk_machine.wait_flag.angles-(179, 0, 0), 0.25, 0, 0 );
	}

	wait( 0.5 );

	worldgun moveto( origin, level.packapunch_timeout, 0, 0);
	if ( isdefined( worldgundw ) )
	{
		worldgundw moveto( origin + offsetdw, level.packapunch_timeout, 0, 0);
	}

	worldgun.worldgundw = worldgundw;
	return worldgun;
}


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

	while(1)
	{
		players = get_players();

		for(i = 0; i < players.size; i ++)
		{
			if ( players[i] hacker_active() )
			{
				self SetInvisibleToPlayer( players[i], true );
			}
			else
			{
				self SetInvisibleToPlayer( players[i], false );
			}
		}
		wait(0.1);
	}
}

//
//	Pack-A-Punch Weapon Upgrade
//
vending_weapon_upgrade()
{
	perk_machine = GetEnt( self.target, "targetname" );
	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" );
	}

	self UseTriggerRequireLookAt();
	self SetHintString( &"ZOMBIE_NEED_POWER" );
	self SetCursorHint( "HINT_NOICON" );

	level waittill("Pack_A_Punch_on");

	self thread vending_machine_trigger_think();

	self thread maps\_zombiemode_weapons::decide_hide_show_hint();

	perk_machine playloopsound("zmb_perks_packa_loop");

	self thread vending_weapon_upgrade_cost();

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

		index = maps\_zombiemode_weapons::get_player_index(player);
		plr = "zmb_vox_plr_" + index + "_";
		current_weapon = player getCurrentWeapon();

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

		if( !player maps\_zombiemode_weapons::can_buy_weapon() ||
			player maps\_laststand::player_is_in_laststand() ||
			is_true( player.intermission ) ||
			player isThrowingGrenade() ||
			player maps\_zombiemode_weapons::is_weapon_upgraded( current_weapon ) )
		{
			wait( 0.1 );
			continue;
		}

		if( is_true(level.pap_moving)) //can't use the pap machine while it's being lowered or raised
		{
			continue;
		}

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

		if ( !IsDefined( level.zombie_include_weapons[current_weapon] ) )
		{
			continue;
		}

		if ( player.score < self.cost )
		{
			//player iprintln( "Not enough points to buy Perk: " + perk );
			self playsound("deny");
			player maps\_zombiemode_audio::create_and_play_dialog( "general", "perk_deny", undefined, 0 );
			continue;
		}

		flag_set("pack_machine_in_use");

		player maps\_zombiemode_score::minus_to_player_score( self.cost );
		sound = "evt_bottle_dispense";
		playsoundatposition(sound, self.origin);

		//TUEY TODO: Move this to a general init string for perk audio later on
		self thread maps\_zombiemode_audio::play_jingle_or_stinger("mus_perks_packa_sting");
		player maps\_zombiemode_audio::create_and_play_dialog( "weapon_pickup", "upgrade_wait" );

		origin = self.origin;
		angles = self.angles;

		if( isDefined(perk_machine))
		{
			origin = perk_machine.origin+(0,0,35);
			angles = perk_machine.angles+(0,90,0);
		}

		self disable_trigger();

		player thread do_knuckle_crack();

		// Remember what weapon we have.  This is needed to check unique weapon counts.
		self.current_weapon = current_weapon;

		weaponmodel = player third_person_weapon_upgrade( current_weapon, origin, angles, packa_rollers, perk_machine );

		self enable_trigger();
		self SetHintString( &"ZOMBIE_GET_UPGRADED" );
		self setvisibletoplayer( player );

		self thread wait_for_player_to_take( player, current_weapon, packa_timer );
		self thread wait_for_timeout( current_weapon, packa_timer );

		self waittill_either( "pap_timeout", "pap_taken" );

		self.current_weapon = "";
		if ( isdefined( weaponmodel.worldgundw ) )
		{
			weaponmodel.worldgundw delete();
		}
		weaponmodel delete();
		self SetHintString( &"ZOMBIE_PERK_PACKAPUNCH", self.cost );
		self setvisibletoall();
		flag_clear("pack_machine_in_use");

	}
}


vending_weapon_upgrade_cost()
{
	while ( 1 )
	{
		self.cost = 5000;
		self SetHintString( &"ZOMBIE_PERK_PACKAPUNCH", self.cost );

		level waittill( "powerup bonfire sale" );

		self.cost = 1000;
		self SetHintString( &"ZOMBIE_PERK_PACKAPUNCH", self.cost );

		level waittill( "bonfire_sale_off" );
	}
}


//
//
wait_for_player_to_take( player, weapon, packa_timer )
{
	AssertEx( IsDefined( level.zombie_weapons[weapon] ), "wait_for_player_to_take: weapon does not exist" );
	AssertEx( IsDefined( level.zombie_weapons[weapon].upgrade_name ), "wait_for_player_to_take: upgrade_weapon does not exist" );

	upgrade_weapon = level.zombie_weapons[weapon].upgrade_name;

	self endon( "pap_timeout" );
	while( true )
	{
		packa_timer playloopsound( "zmb_perks_packa_ticktock" );
		self waittill( "trigger", trigger_player );
		packa_timer stoploopsound(.05);
		if( trigger_player == player )
		{
			current_weapon = player GetCurrentWeapon();
/#
if ( "none" == current_weapon )
{
	iprintlnbold( "WEAPON IS NONE, PACKAPUNCH RETRIEVAL DENIED" );
}
#/
			if( is_player_valid( player ) && !player is_drinking() && !is_placeable_mine( current_weapon ) && !is_equipment( current_weapon ) && "syrette_sp" != current_weapon && "none" != current_weapon && !player hacker_active())
			{
				self notify( "pap_taken" );
				player notify( "pap_taken" );
				player.pap_used = true;

				weapon_limit = 2;
				if ( player HasThePerk( "specialty_additionalprimaryweapon" ) )
				{
					weapon_limit = 3;
				}

				primaries = player GetWeaponsListPrimaries();
				if( isDefined( primaries ) && primaries.size >= weapon_limit )
				{
					player maps\_zombiemode_weapons::weapon_give( upgrade_weapon );
				}
				else
				{
					player GiveWeapon( upgrade_weapon, 0, player maps\_zombiemode_weapons::get_pack_a_punch_weapon_options( upgrade_weapon ) );
					player GiveStartAmmo( upgrade_weapon );
				}

				player SwitchToWeapon( upgrade_weapon );
				player maps\_zombiemode_weapons::play_weapon_vo(upgrade_weapon);
				return;
			}
		}
		wait( 0.05 );
	}
}


//	Waiting for the weapon to be taken
//
wait_for_timeout( weapon, packa_timer )
{
	self endon( "pap_taken" );

	wait( level.packapunch_timeout );

	self notify( "pap_timeout" );
	packa_timer stoploopsound(.05);
	packa_timer playsound( "zmb_perks_packa_deny" );

	maps\_zombiemode_weapons::unacquire_weapon_toggle( weapon );
}


//	Weapon has been inserted, crack knuckles while waiting
//
do_knuckle_crack()
{
	gun = self upgrade_knuckle_crack_begin();

	self waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" );

	self upgrade_knuckle_crack_end( gun );

}


//	Switch to the knuckles
//
upgrade_knuckle_crack_begin()
{
	self increment_is_drinking();

	self AllowLean( false );
	self AllowAds( false );
	self AllowSprint( false );
	self AllowCrouch( true );
	self AllowProne( false );
	self AllowMelee( false );

	if ( self GetStance() == "prone" )
	{
		self SetStance( "crouch" );
	}

	primaries = self GetWeaponsListPrimaries();

	gun = self GetCurrentWeapon();
	weapon = "zombie_knuckle_crack";

	if ( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) )
	{
		self notify( "zmb_lost_knife" );
		self TakeWeapon( gun );
	}
	else
	{
		return;
	}

	self GiveWeapon( weapon );
	self SwitchToWeapon( weapon );

	return gun;
}

//	Anim has ended, now switch back to something
//
upgrade_knuckle_crack_end( gun )
{
	assert( gun != "zombie_perk_bottle_doubletap" );
	assert( gun != "zombie_perk_bottle_jugg" );
	assert( gun != "zombie_perk_bottle_revive" );
	assert( gun != "zombie_perk_bottle_sleight" );
	assert( gun != "zombie_perk_bottle_marathon" );
	assert( gun != "zombie_perk_bottle_nuke" );
	assert( gun != "zombie_perk_bottle_deadshot" );
	assert( gun != "zombie_perk_bottle_additionalprimaryweapon" );
	assert( gun != "syrette_sp" );

	self AllowLean( true );
	self AllowAds( true );
	self AllowSprint( true );
	self AllowProne( true );
	self AllowMelee( true );
	weapon = "zombie_knuckle_crack";

	// TODO: race condition?
	if ( self maps\_laststand::player_is_in_laststand() || is_true( self.intermission ) )
	{
		self TakeWeapon(weapon);
		return;
	}

	self decrement_is_drinking();

	self TakeWeapon(weapon);
	primaries = self GetWeaponsListPrimaries();
	if( self is_drinking() )
	{
		return;
	}
	else if( isDefined( primaries ) && primaries.size > 0 )
	{
		self SwitchToWeapon( primaries[0] );
	}
	else
	{
		self SwitchToWeapon( level.laststandpistol );
	}
}

// PI_CHANGE_BEGIN
//	NOTE:  In the .map, you'll have to make sure that each Pack-A-Punch machine has a unique targetname
turn_PackAPunch_on()
{
	level waittill("Pack_A_Punch_on");

	vending_weapon_upgrade_trigger = GetEntArray("zombie_vending_upgrade", "targetname");
	for(i=0; i<vending_weapon_upgrade_trigger.size; i++ )
	{
		perk = getent(vending_weapon_upgrade_trigger[i].target, "targetname");
		if(isDefined(perk))
		{
			perk thread activate_PackAPunch();
		}
	}
}

activate_PackAPunch()
{
	self setmodel("zombie_vending_packapunch_on");
	self playsound("zmb_perks_power_on");
	self vibrate((0,-100,0), 0.3, 0.4, 3);
	/*
	self.flag = spawn( "script_model", machine GetTagOrigin( "tag_flag" ) );
	self.angles = machine GetTagAngles( "tag_flag" );
	self.flag setModel( "zombie_sign_please_wait" );
	self.flag linkto( machine );
	self.flag.origin = (0, 40, 40);
	self.flag.angles = (0, 0, 0);
	*/
	timer = 0;
	duration = 0.05;

	level notify( "Carpenter_On" );
}
// PI_CHANGE_END



//############################################################################
//		P E R K   M A C H I N E S
//############################################################################

//
//	Threads to turn the machines to their ON state.
//

turn_perk_on(vending_machine, specialty, light_fx, machine_change)
{
	machine = getentarray(vending_machine, "targetname");
	flag_wait( "all_players_connected" );
	players = get_players();
	if(players.size == 1 && specialty == "specialty_quickrevive")
	{
		machine_model = undefined;
		machine_clip = undefined;
		for( i = 0; i < machine.size; i++ )
		{
			if(IsDefined(machine[i].script_noteworthy) && machine[i].script_noteworthy == "clip")
			{
				machine_clip = machine[i];
			}
			else // then the model
			{
				machine[i] setmodel("zombie_vending_revive_on");
				machine_model = machine[i];
			}
		}
		wait_network_frame();
		if ( isdefined( machine_model ) )
		{
			machine_model thread revive_solo_fx(machine_clip);
		}
	}
	else
		level waittill_any("electricity_on", "juggernog_on", specialty+"_on");
	for( i = 0; i < machine.size; i++ )
	{
		if(isdefined(machine[i]))
		{
			if(isdefined(machine_change))
				machine[i] setmodel(machine_change);
			machine[i] vibrate((0,-100,0), 0.3, 0.4, 3);
			machine[i] playsound("zmb_perks_power_on");
			machine[i] thread perk_fx( light_fx );
		}
	}
	level notify( specialty + "_power_on" );
}

revive_solo_fx(machine_clip)
{
	flag_init( "solo_revive" );

	self.fx = Spawn( "script_model", self.origin );
	self.fx.angles = self.angles;
	self.fx SetModel( "tag_origin" );
	self.fx LinkTo(self);

	playfxontag( level._effect[ "revive_light" ], self.fx, "tag_origin" );
	playfxontag( level._effect[ "revive_light_flicker" ], self.fx, "tag_origin" );

	flag_wait( "solo_revive" );

	if ( isdefined( level.revive_solo_fx_func ) )
	{
		level thread [[ level.revive_solo_fx_func ]]();
	}
	wait(2.0);
	self playsound("zmb_box_move");
	playsoundatposition ("zmb_whoosh", self.origin );

	self moveto(self.origin + (0,0,40),3);
	if( isDefined( level.custom_vibrate_func ) )
	{
		[[ level.custom_vibrate_func ]]( self );
	}
	else
	{
	   direction = self.origin;
	   direction = (direction[1], direction[0], 0);

	   if(direction[1] < 0 || (direction[0] > 0 && direction[1] > 0))
	   {
            direction = (direction[0], direction[1] * -1, 0);
       }
       else if(direction[0] < 0)
       {
            direction = (direction[0] * -1, direction[1], 0);
       }

        self Vibrate( direction, 10, 0.5, 5);
	}

	self waittill("movedone");
	PlayFX(level._effect["poltergeist"], self.origin);
	playsoundatposition ("zmb_box_poof", self.origin);

    level clientNotify( "drb" );

	//self setmodel("zombie_vending_revive");
	self.fx Unlink();
	self.fx delete();
	self Delete();

	// DCS: remove the clip.
	machine_clip trigger_off();
	machine_clip ConnectPaths();
	machine_clip Delete();
}

divetonuke_explode( attacker, origin )
{
	// tweakable vars
	radius = level.zombie_vars["zombie_perk_divetonuke_radius"];
	min_damage = level.zombie_vars["zombie_perk_divetonuke_min_damage"];
	max_damage = level.zombie_vars["zombie_perk_divetonuke_max_damage"];

	// radius damage
	RadiusDamage( origin, radius, max_damage, min_damage, attacker, "MOD_GRENADE_SPLASH" );

	// play fx
	PlayFx( level._effect["divetonuke_groundhit"], origin );

	// play sound
	attacker playsound("zmb_phdflop_explo");

	// WW (01/12/11): start clientsided effects - These client flags are defined in _zombiemode.gsc & _zombiemode.csc
	// Used for zombie_dive2nuke_visionset() in _zombiemode.csc
	attacker SetClientFlag( level._ZOMBIE_PLAYER_FLAG_DIVE2NUKE_VISION );
	wait_network_frame();
	wait_network_frame();
	attacker ClearClientFlag( level._ZOMBIE_PLAYER_FLAG_DIVE2NUKE_VISION );
}
//
//
perk_fx( fx )
{
	wait(3);
	playfxontag( level._effect[ fx ], self, "tag_origin" );
}

electric_perks_dialog()
{
	//TODO  TEMP Disable Revive in Solo games
	flag_wait( "all_players_connected" );
	players = GetPlayers();
	if ( players.size == 1 )
	{
		return;
	}

	self endon ("warning_dialog");
	level endon("switch_flipped");
	timer =0;
	while(1)
	{
		wait(0.5);
		players = get_players();
		for(i = 0; i < players.size; i++)
		{
			dist = distancesquared(players[i].origin, self.origin );
			if(dist > 70*70)
			{
				timer = 0;
				continue;
			}
			if(dist < 70*70 && timer < 3)
			{
				wait(0.5);
				timer ++;
			}
			if(dist < 70*70 && timer == 3)
			{

				players[i] thread do_player_vo("vox_start", 5);
				wait(3);
				self notify ("warning_dialog");
				/#
				iprintlnbold("warning_given");
				#/
			}
		}
	}
}


//
//
vending_trigger_think()
{
	//self thread turn_cola_off();
	perk = self.script_noteworthy;
	solo = false;
	flag_init( "_start_zm_pistol_rank" );

	//TODO  TEMP Disable Revive in Solo games
	if ( IsDefined(perk) &&
		(perk == "specialty_quickrevive" || perk == "specialty_quickrevive_upgrade") )
	{
		flag_wait( "all_players_connected" );
		players = GetPlayers();
		if ( players.size == 1 )
		{
			solo = true;
			flag_set( "solo_game" );
			level.solo_lives_given = 0;
			players[0].lives = 0;
			level maps\_zombiemode::zombiemode_solo_last_stand_pistol();
		}
	}

	flag_set( "_start_zm_pistol_rank" );

	if ( !solo )
	{
		self SetHintString( &"ZOMBIE_NEED_POWER" );
	}

	self SetCursorHint( "HINT_NOICON" );
	self UseTriggerRequireLookAt();

	cost = level.zombie_vars["zombie_perk_cost"];
	cost = level.zombie_perks[perk].cost;

	players = get_players();
	if(players.size == 1 && perk == "specialty_quickrevive")
		cost = 500;

	self.cost = cost;

	if ( !solo )
	{
		notify_name = perk + "_power_on";
		level waittill( notify_name );
	}

	if(!IsDefined(level._perkmachinenetworkchoke))
	{
		level._perkmachinenetworkchoke = 0;
	}
	else
	{
		level._perkmachinenetworkchoke ++;
	}

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

	//Turn on music timer
	self thread maps\_zombiemode_audio::perks_a_cola_jingle_timer();

	perk_hum = spawn("script_origin", self.origin);
	perk_hum playloopsound("zmb_perks_machine_loop");

	self thread check_player_has_perk(perk);

	self thread vending_set_hintstring(perk);

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

		index = maps\_zombiemode_weapons::get_player_index(player);

		if (player maps\_laststand::player_is_in_laststand() || is_true( 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() )
		{
			wait( 0.1 );
			continue;
		}

		if ( player HasThePerk( perk ) )
		{
			cheat = false;

			/#
			if ( GetDvarInt( #"zombie_cheat" ) >= 5 )
			{
				cheat = true;
			}
			#/

			if ( cheat != true )
			{
				//player iprintln( "Already using Perk: " + perk );
				self playsound("deny");
				player maps\_zombiemode_audio::create_and_play_dialog( "general", "perk_deny", undefined, 1 );


				continue;
			}
		}

		if ( player.score < cost )
		{
			//player iprintln( "Not enough points to buy Perk: " + perk );
			self playsound("evt_perk_deny");
			player maps\_zombiemode_audio::create_and_play_dialog( "general", "perk_deny", undefined, 0 );
			continue;
		}

		if ( player.num_perks >= level.perk_limit+player.perk_slots )
		{
			//player iprintln( "Too many perks already to buy Perk: " + perk );
			self playsound("evt_perk_deny");
			// COLLIN: do we have a VO that would work for this? if not we'll leave it at just the deny sound
			player maps\_zombiemode_audio::create_and_play_dialog( "general", "sigh" );
			continue;
		}

		sound = "evt_bottle_dispense";
		playsoundatposition(sound, self.origin);
		player maps\_zombiemode_score::minus_to_player_score( cost );

		player.perk_purchased = perk;

		if(isdefined(self.script_label))
			self thread maps\_zombiemode_audio::play_jingle_or_stinger (self.script_label);
		else if(isdefined(level.zombie_perks[perk].sound))
			self thread maps\_zombiemode_audio::play_jingle_or_stinger (level.zombie_perks[perk].sound);

		// do the drink animation
		gun = player perk_give_bottle_begin( perk );
		player waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" );

		// restore player controls and movement
		player perk_give_bottle_end( gun, perk );

		// TODO: race condition?
		if ( player maps\_laststand::player_is_in_laststand() || is_true( player.intermission ) )
		{
			continue;
		}

		if ( isDefined( level.perk_bought_func ) )
		{
			player [[ level.perk_bought_func ]]( perk );
		}

		player.perk_purchased = undefined;

		player give_perk( perk, true );

		//player iprintln( "Bought Perk: " + perk );
		bbPrint( "zombie_uses: playername %s playerscore %d teamscore %d round %d cost %d name %s x %f y %f z %f type perk",
			player.playername, player.score, level.team_pool[ player.team_num ].score, level.round_number, cost, perk, self.origin );
	}
}

// ww: tracks the player's lives in solo, once a life is used then the revive trigger is moved back in to position
solo_revive_buy_trigger_move( revive_trigger_noteworthy )
{
	self endon( "death" );

	revive_perk_trigger = GetEnt( revive_trigger_noteworthy, "script_noteworthy" );

	revive_perk_trigger trigger_off();

	if( level.solo_lives_given >= 3 )
	{
		if(IsDefined(level._solo_revive_machine_expire_func))
		{
			revive_perk_trigger [[level._solo_revive_machine_expire_func]]();
		}

		return;
	}

	while( self.lives > 0 )
	{
		wait( 0.1 );
	}

	revive_perk_trigger trigger_on();
}

unlocked_perk_upgrade( perk )
{
	ch_ref = string(tablelookup( "mp/challengeTable_zmPerk.csv", 12, perk, 7 ));
	ch_max = int(tablelookup( "mp/challengeTable_zmPerk.csv", 12, perk, 4 ));
	ch_progress = self getdstat( "challengeStats", ch_ref, "challengeProgress" );

	if( ch_progress >= ch_max )
	{
		return true;
	}
	return false;
}

give_perk( perk, bought )
{
	if(IsCustomPerk(perk))
		self SetCustomPerk( perk );
	else
		self SetPerk( perk );
	self.num_perks++;

	if ( is_true( bought ) )
	{
		//AUDIO: Ayers - Sending Perk Name over to audio common script to play VOX
		self thread maps\_zombiemode_audio::perk_vox( perk );
		self setblur( 4, 0.1 );
		wait(0.1);
		self setblur(0, 0.1);
		//earthquake (0.4, 0.2, self.origin, 100);

		self notify( "perk_bought", perk );
	}

	if(perk == "specialty_armorvest")
	{
		self.preMaxHealth = self.maxhealth;
		self SetMaxHealth( level.zombie_vars["zombie_perk_juggernaut_health"] );
	}
	else if(perk == "specialty_armorvest_upgrade")
	{
		self.preMaxHealth = self.maxhealth;
		self SetMaxHealth( level.zombie_vars["zombie_perk_juggernaut_health_upgrade"] );
	}

	// WW (02-03-11): Deadshot csc call
	if( perk == "specialty_deadshot" )
	{
		self SetClientFlag(level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK);
	}
	else if( perk == "specialty_deadshot_upgrade" )
	{
		self SetClientFlag(level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK);
	}

	// quick revive in solo gives an extra life
	players = getplayers();
	if ( players.size == 1 && perk == "specialty_quickrevive" )
	{
		self.lives = 1;

		level.solo_lives_given++;

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

		self thread solo_revive_buy_trigger_move( perk );

		// self disable_trigger();
	}

	self perk_hud_create( perk );

	//stat tracking
	self.stats["perks"]++;

	self thread perk_think( perk );
}

check_player_has_perk(perk)
{
	self endon( "death" );
/#
	if ( GetDvarInt( #"zombie_cheat" ) >= 5 )
	{
		return;
	}
#/

	dist = 128 * 128;
	while(true)
	{
		players = get_players();
		for( i = 0; i < players.size; i++ )
		{
			if(DistanceSquared( players[i].origin, self.origin ) < dist)
			{
				if(!players[i] HasThePerk(perk) && !(players[i] in_revive_trigger()) && (!players[i] hacker_active()))
				{
					self setinvisibletoplayer(players[i], false);
				}
				else
				{
					self SetInvisibleToPlayer(players[i], true);
				}
			}
		}
		wait(0.1);

	}
}


vending_set_hintstring( perk )
{
	self UseTriggerRequireLookAt();
	players = get_players();
	if(players.size == 1 && perk == "specialty_quickrevive")
		self SetHintString( "Press & hold &&1 to buy Quick Revive [Cost: 500]" );
	if(isdefined(level.zombie_perks[perk].perk_name_actual))
		self SetHintString( level.zombie_perks[perk].perk_name_actual );
	else
		self SetHintString( "Press & hold &&1 to buy "+level.zombie_perks[perk].perk_name+" [Cost: "+level.zombie_perks[perk].cost+"]" );
}


perk_think( perk )
{
/#
	if ( GetDvarInt( #"zombie_cheat" ) >= 5 )
	{
		if ( IsDefined( self.perk_hud[ perk ] ) )
		{
			return;
		}
	}
#/

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

	do_retain = true;

	if( (get_players().size == 1) && perk == "specialty_quickrevive")
	{
		do_retain = false;
	}

	if(do_retain && IsDefined(self._retain_perks) && self._retain_perks)
	{
		return;
	}

	if(IsCustomPerk(perk))
		self UnsetCustomPerk( perk );
	else
		self UnsetPerk( perk );
	self.num_perks--;

	switch(perk)
	{
		case "specialty_armorvest":
			self SetMaxHealth( 100 );
			break;

		case "specialty_additionalprimaryweapon":
			if ( result == perk_str )
			{
				self maps\_zombiemode::take_additionalprimaryweapon();
			}
			break;

		case "specialty_deadshot":
			self ClearClientFlag(level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK);
			break;

		case "specialty_deadshot_upgrade":
			self ClearClientFlag(level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK);
			break;
	}

	self perk_hud_destroy( perk );
	self.perk_purchased = undefined;
	//self iprintln( "Perk Lost: " + perk );


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

	self notify( "perk_lost" );
}


perk_hud_create( perk )
{
	if ( !IsDefined( self.perk_hud ) )
	{
		self.perk_hud = [];
	}

/#
	if ( GetDvarInt( #"zombie_cheat" ) >= 5 )
	{
		if ( IsDefined( self.perk_hud[ perk ] ) )
		{
			return;
		}
	}
#/


	shader = level.zombie_perks[perk].shader;

	hud = create_simple_hud( self );
	hud.foreground = true;
	hud.sort = 1;
	hud.hidewheninmenu = false;
	hud.alignX = "left";
	hud.alignY = "bottom";
	hud.horzAlign = "user_left";
	hud.vertAlign = "user_bottom";
	hud.x = self.perk_hud.size * 30;
	hud.y = hud.y - 70;
	hud.alpha = 1;
	hud SetShader( shader, 24, 24 );

	self.perk_hud[ perk ] = hud;
}


perk_hud_destroy( perk )
{
	self.perk_hud[ perk ] destroy_hud();
	self.perk_hud[ perk ] = undefined;
}

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

	self.flash = 1;
	self ScaleOverTime( 0.05, 32, 32 );
	wait( 0.3 );
	self ScaleOverTime( 0.05, 24, 24 );
	wait( 0.3 );
	self.flash = 0;
}

perk_flash_audio( perk )
{
    alias = undefined;

    switch( perk )
    {
        case "specialty_armorvest":
            alias = "zmb_hud_flash_jugga";
            break;

        case "specialty_quickrevive":
            alias = "zmb_hud_flash_revive";
            break;

        case "specialty_fastreload":
            alias = "zmb_hud_flash_speed";
            break;

        case "specialty_longersprint":
            alias = "zmb_hud_flash_stamina";
            break;

        case "specialty_flakjacket":
            alias = "zmb_hud_flash_phd";
            break;

        case "specialty_deadshot":
            alias = "zmb_hud_flash_deadshot";
            break;

        case "specialty_additionalprimaryweapon":
            alias = "zmb_hud_flash_additionalprimaryweapon";
            break;
    }

    if( IsDefined( alias ) )
        self PlayLocalSound( alias );
}

perk_hud_start_flash( perk )
{
	if ( self HasThePerk( perk ) && isdefined( self.perk_hud ) )
	{
		hud = self.perk_hud[perk];
		if ( isdefined( hud ) )
		{
			if ( !is_true( hud.flash ) )
			{
				hud thread perk_hud_flash();
				self thread perk_flash_audio( perk );
			}
		}
	}
}

perk_hud_stop_flash( perk, taken )
{
	if ( self HasThePerk( perk ) && isdefined( self.perk_hud ) )
	{
		hud = self.perk_hud[perk];
		if ( isdefined( hud ) )
		{
			hud.flash = undefined;
			if ( isdefined( taken ) )
			{
				hud notify( "stop_flash_perk" );
			}
		}
	}
}

perk_give_bottle_begin( perk )
{
	self increment_is_drinking();

	self AllowLean( false );
	self AllowAds( false );
	self AllowSprint( false );
	self AllowCrouch( true );
	self AllowProne( false );
	self AllowMelee( false );

	wait( 0.05 );

	if ( self GetStance() == "prone" )
	{
		self SetStance( "crouch" );
	}

	gun = self GetCurrentWeapon();
	weapon = "";

	weapon = level.zombie_perks[perk].bottle_weapon;

	self GiveWeapon( weapon );
	self SwitchToWeapon( weapon );

	return gun;
}


perk_give_bottle_end( gun, perk )
{
	assert( gun != "zombie_perk_bottle_doubletap" );
	assert( gun != "zombie_perk_bottle_jugg" );
	assert( gun != "zombie_perk_bottle_revive" );
	assert( gun != "zombie_perk_bottle_sleight" );
	assert( gun != "zombie_perk_bottle_marathon" );
	assert( gun != "zombie_perk_bottle_nuke" );
	assert( gun != "zombie_perk_bottle_deadshot" );
	assert( gun != "zombie_perk_bottle_additionalprimaryweapon" );
	assert( gun != "syrette_sp" );

	self AllowLean( true );
	self AllowAds( true );
	self AllowSprint( true );
	self AllowProne( true );
	self AllowMelee( true );
	weapon = "";
	weapon = level.zombie_perks[perk].bottle_weapon;


	// TODO: race condition?
	if ( self maps\_laststand::player_is_in_laststand() || is_true( self.intermission ) )
	{
		self TakeWeapon(weapon);
		return;
	}

	self TakeWeapon(weapon);

	if( self is_multiple_drinking() )
	{
		self decrement_is_drinking();
		return;
	}
	else if( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) )
	{
		self SwitchToWeapon( gun );
		// ww: the knives have no first raise anim so they will never get a "weapon_change_complete" notify
		// meaning it will never leave this funciton and will break buying weapons for the player
		if( is_melee_weapon( gun ) )
		{
			self decrement_is_drinking();
			return;
		}
	}
	else
	{
		// try to switch to first primary weapon
		primaryWeapons = self GetWeaponsListPrimaries();
		if( IsDefined( primaryWeapons ) && primaryWeapons.size > 0 )
		{
			self SwitchToWeapon( primaryWeapons[0] );
		}
	}

	self waittill( "weapon_change_complete" );

	if ( !self maps\_laststand::player_is_in_laststand() && !is_true( self.intermission ) )
	{
		self decrement_is_drinking();
	}
}

give_random_perk()
{
	vending_triggers = GetEntArray( "zombie_vending", "targetname" );

	perks = [];
	for ( i = 0; i < vending_triggers.size; i++ )
	{
		perk = vending_triggers[i].script_noteworthy;

		if ( isdefined( self.perk_purchased ) && self.perk_purchased == perk )
		{
			continue;
		}

		if ( !self HasThePerk( perk ) )
		{
			perks[ perks.size ] = perk;
		}
	}

	if ( perks.size > 0 )
	{
		perks = array_randomize( perks );
		self give_perk( perks[0] );
	}
}


lose_random_perk()
{
	vending_triggers = GetEntArray( "zombie_vending", "targetname" );

	perks = [];
	for ( i = 0; i < vending_triggers.size; i++ )
	{
		perk = vending_triggers[i].script_noteworthy;

		if ( isdefined( self.perk_purchased ) && self.perk_purchased == perk )
		{
			continue;
		}

		if ( self HasThePerk( perk ) )
		{
			perks[ perks.size ] = perk;
		}
	}

	if ( perks.size > 0 )
	{
		perks = array_randomize( perks );
		perk = perks[0];

		perk_str = perk + "_stop";
		self notify( perk_str );

		if ( flag( "solo_game" ) && perk == "specialty_quickrevive" )
		{
			self.lives--;
		}
	}
}

update_perk_hud()
{
	if ( isdefined( self.perk_hud ) )
	{
		keys = getarraykeys( self.perk_hud );
		for ( i = 0; i < self.perk_hud.size; i++ )
		{
			self.perk_hud[ keys[i] ].x = i * 30;
		}
	}
}

quantum_bomb_give_nearest_perk_validation( position )
{
	vending_triggers = GetEntArray( "zombie_vending", "targetname" );

	range_squared = 180 * 180; // 15 feet
	for ( i = 0; i < vending_triggers.size; i++ )
	{
		if ( DistanceSquared( vending_triggers[i].origin, position ) < range_squared )
		{
			return true;
		}
	}

	return false;
}


quantum_bomb_give_nearest_perk_result( position )
{
	[[level.quantum_bomb_play_mystery_effect_func]]( position );

	vending_triggers = GetEntArray( "zombie_vending", "targetname" );

	nearest = 0;
	for ( i = 1; i < vending_triggers.size; i++ )
	{
		if ( DistanceSquared( vending_triggers[i].origin, position ) < DistanceSquared( vending_triggers[nearest].origin, position ) )
		{
			nearest = i;
		}
	}

	players = getplayers();
	perk = vending_triggers[nearest].script_noteworthy;
	for ( i = 0; i < players.size; i++ )
	{
		player = players[i];

		if ( player.sessionstate == "spectator" || player maps\_laststand::player_is_in_laststand() )
		{
			continue;
		}

		if ( !player HasThePerk( perk ) && ( !isdefined( player.perk_purchased ) || player.perk_purchased != perk) && RandomInt( 5 ) ) // 80% chance
		{
			if( player == self )
			{
				self thread maps\_zombiemode_audio::create_and_play_dialog( "kill", "quant_good" );
			}

			player give_perk( perk );
			player [[level.quantum_bomb_play_player_effect_func]]();
		}
	}
}
perk_slot_setup()
{
	flag_wait( "all_players_connected" );
	players = get_players();
	for ( i = 0; i < players.size; i++ )
		players[i].perk_slots = 0;
}
give_perk_slot()
{
	if(!isdefined(self.perk_slots))
		self.perk_slots = 0;
	self.perk_slots +=1;
}

tufbrew_func( mod, hit_location, hit_origin, player, amount )
{
	if(player HasThePerk("specialty_bulletdamage") && ( mod == "MOD_RIFLE_BULLET" || mod == "MOD_PISTOL_BULLET" ) )
	{
		if(amount >= self.health)
			player maps\_zombiemode_score::player_add_points( "death", mod, hit_location, self.isdog );
		self DoDamage( amount, player.origin );
	}
	return false;
}

/////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////candolier/////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//note: stock ammo of all weapons should be 2 clip sizes higher than normal ammo
candolier()
{
	flag_wait( "all_players_connected" );
	players = get_players();
	for ( i = 0; i < players.size; i++ )
		players[i] thread candolier_ammo();
}
candolier_ammo()
{
	while(1)
	{
		player_weapons = self GetWeaponsListPrimaries();
		for( i=0; i<player_weapons.size; i++ )
		{
			clip = weaponClipSize(player_weapons[i])*2;
			candolier_ammo = WeaponMaxAmmo(player_weapons[i]);
			if (!( self HasThePerk( "specialty_bulletaccuracy" )))
				candolier_ammo -= clip;
			if(self GetWeaponAmmoStock(player_weapons[i]) <= candolier_ammo)
				continue;
			if(self GetAmmoCount(player_weapons[i]) > candolier_ammo)
				self SetWeaponAmmoStock(player_weapons[i], candolier_ammo);
		}
		wait .05;
	}
}