add_zombie_powerup( "perk",  		"zombie_bottle",	&"ZOMBIE_POWERUP_MAX_AMMO");

	//MM test  Change this if you want the same thing to keep spawning
//	powerup = "dog";
	switch ( powerup )
	{
	// Don't need to do anything special
	case "nuke":
	case "insta_kill":
	case "double_points":
	case "carpenter":
	//DUKIP - Added zombie perk.
	case "perk":
		break;

					case "carpenter":
						level thread start_carpenter( self.origin );
						players[i] thread powerup_vo("carpenter");
						break;
					//DUKIP - Added zombie perk
					case "perk":
						players[i] thread zombie_perk_powerup();
						break;

	switch(type)
	{
		case "nuke":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_nuke_" + rand;
			}
			break;
		case "insta_kill":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_insta_" + rand;
			}
			break;
		case "full_ammo":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_ammo_" + rand;
			}
			break;
		case "double_points":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_double_" + rand;
			}
			break;
		case "carpenter":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_carp_" + rand;
			}
			break;
		//DUKIP - Add zombie perk, don't do any plr vox sounds.
		case "perk":
			break;
	}

zombie_perk_powerup()
{
	self endon("disconnect");

	player = self;
	perk = getRandomPerk(player);
	//DUKIP - Make sure player doesn't have the perk and perk is defined.
	if(player HasPerk(perk) || !IsDefined(perk))
	{
		//DUKIP - 50/50 chance of playing the sound.
		if(cointoss())
			player PlayLocalSound("sam_nospawn");
		return;
	}

	//DUKIP - Moved this var to above the perk bottle give as there was a chance of getting "dual" perks.
	player.is_drinking = 1;

	// do the drink animation
	gun = player maps\_zombiemode_perks::perk_give_bottle_begin( perk );

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

	// restore player controls and movement
	player maps\_zombiemode_perks::perk_give_bottle_end( gun, perk );
	player.is_drinking = undefined;
	// TODO: race condition?
	if ( player maps\_laststand::player_is_in_laststand() )
		return;

	player SetPerk( perk );
	player thread maps\_zombiemode_perks::perk_vo(perk);
	player setblur( 4, 0.1 );
	wait(0.1);
	player setblur(0, 0.1);

	if(perk == "specialty_armorvest")
	{
		player.maxhealth = level.zombie_vars["zombie_perk_juggernaut_health"];
		player.health = level.zombie_vars["zombie_perk_juggernaut_health"];
	}

	player maps\_zombiemode_perks::perk_hud_create( perk );

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

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

	player thread maps\_zombiemode_perks::perk_think( perk );
}

getRandomPerk(player)
{
	//DUKIP - Make sure we're not drinking anything already.
	if(IsSubStr(player getCurrentWeapon(), "bottle") || (IsDefined(player.is_drinking) && player.is_drinking))
		return;

	all_perks = [];
	all_perks[0] = "specialty_armorvest";
	all_perks[1] = "specialty_quickrevive";
	all_perks[2] = "specialty_fastreload";
	all_perks[3] = "specialty_rof";
	//all_perks[NUM] = "specialty_XXXX";

	all_perks = array_randomize(all_perks);

	thePerk = random(all_perks);

	return thePerk;
}

include_powerup( "perk" );

/*******************************************************************
						Challenge - Target Practice
Objective:	Test your skills here! Shoot all the teddy's to win.
			----
*******************************************************************/
roomTargetPractice(player)
{
	level endon("end_game");
	level endon("room_tp_end");

	//DUKIP - Set the player before starting the TP.
	player tpSetupPlayer();
	level thread tpStartup(player);
	level thread challengeSetTimer(30, player, "target_practice");
}

tpStartup(player)
{
	level endon("end_game");
	level endon("room_tp_end");
	tpEnts = GetEntArray("room_tp_bears", "targetname");
	level.challenge_teddy_hit = 0;
	level.challenge_total_teddy = tpEnts.size;
	//fix this
	level.tp_angles_vector = (90, 0, 0);
	//play some sound/fx?
	//countdown 3-2-1-go!
	array_thread(tpEnts, ::tpMain);
}

tpMain()
{
	level endon("end_game");
	level endon("room_tp_end");
	self thread tpDamageFeedback();
	self thread tpMovementThink();
}

tpDamageFeedback()
{
	level endon("end_game");
	level endon("room_tp_end");
	self SetCanDamage(true);
	self waittill( "damage", damage, attacker );
	self SetCanDamage(false);
	level.challenge_teddy_hit++;
	//DUKIP - make sure to in _zombiemode -> add_sound( "ding", "sound_alias" );
	//self play_sound_on_ent("ding");
	//play some feather fx (or maybe the bear will already do it).
	self Hide();
	self.is_active = false;

	if(level.challenge_teddy_hit >= level.challenge_total_teddy)
		level thread tpCleanup(attacker);
}

tpCleanup(player)
{
	level endon("end_game");
	level endon("room_tp_end");

	level thread tpReset();
	level thread giveChallengeAward(player, "target_practice");
	tpEnts = GetEntArray("room_tp_bears", "targetname");
	for(i = 0; i < tpEnts.size; i ++)
	{
		tpEnts[i] Show();
		tpEnts[i] SetOrigin(tpEnts[i].original_pos);
	}
}

tpMovementThink()
{
	level endon("end_game");
	level endon("room_tp_end");

	self.original_pos = self.origin;
	self.moving_to_node = undefined;
	self.is_active = true;

	while(true && self.is_active)
	{
		goToNode = tpSelectNode(self);
		if(IsDefined(goToNode))
		{
			self.moving_to_node = true;
			goToNode.is_active = true;
			self MoveTo(goToNode.origin, 1, 0.05, 0.05);

			self waittill("movedone");

			self.moving_to_node = false;
			goToNode.is_active = false;
			continue;
		}

		wait 0.05;
	}
}

tpSelectNode(ent)
{
	level endon("end_game");
	level endon("room_tp_end");

	while(self.moving_to_node)
		wait 0.05;

	originalTPNodes = GetEntArray("room_tp_nodes", "targetname");
	filterNodes = tpGenerateFilteredNodes(originalTPNodes);

	goodNodes = array_exclude(originalTPNodes, filterNodes);
	//DUKIP - Need to generate node based on 1x1 away.
	//So fix asap.
	theNode = tpSelectRandomNode(goodNodes);

	return theNode;
}

tpSelectRandomNode(nodes)
{
	nodes = array_randomize(nodes);
	goodNode = undefined;
	while(true)
	{
		if(goodNode)
			break;
		for(i = 0; i <= nodes.size; i++)
		{
			coinflip = cointoss();
			if(coinflip) //go up
			{
				coinflip = cointoss();
				if(coinflip) //go left
				{

				}
				else //go right
				{

				}
			}
			else //go down
			{
				coinflip = cointoss();
				if(coinflip) //go left
				{

				}
				else //go right
				{

				}
			}
		}
	}
	return goodNode;
}

tpGenerateFilteredNodes(nodes)
{
	inUseNodes = [];
	for(i = 0; i < nodes.size; i++)
	{
		if(nodes[i].is_active)
			inUseNodes[inUseNodes.size] = nodes[i];
	}
	return inUseNodes;
}

tpSetupPlayer()
{
	level endon("end_game");
	level endon("room_tp_end");

	self AllowStand(true);
	self AllowCrouch(false);
	self AllowProne(false);
	self AllowSprint(false);
	self SetMoveSpeedScale(0);

	self SetPlayerAngles(level.tp_angles_vector);
	self thread giveTPRandomWeapon();
	self thread tpReEnableMovement();
}

giveTPRandomWeapon()
{
	level endon("end_game");
	level endon("room_tp_end");
	self endon("death");
	self endon("disconnect");

	primaryWeapons = self GetWeaponsListPrimaries();
	weaponToGive = maps\_zombiemode_weapons::treasure_chest_ChooseRandomWeapon(self);
	self GiveWeapon(weaponToGive);
	self GiveMaxAmmo(weaponToGive);
	self SwitchToWeapon(weaponToGive);
	self DisableOffhandWeapons();
	self DisableWeaponCycling();

	//DUKIP - Modified function from T6, script resumes when one of these 4 notifies are received.
	waittill_any_ents_four( level, "room_tp_end", level, "end_game", self, "fake_death", self, "player_downed" );
	self thread reEnableWeapons(weaponToGive, primaryWeapons[0]);
}

tpReEnableMovement()
{
	level endon("end_game");
	level endon("room_tp_end");

	waittill_any_ents_four( level, "room_tp_end", level, "end_game", self, "fake_death", self, "player_downed" );

	if(maps\_laststand::player_is_in_laststand())
	{
		self SetMoveSpeedScale(1);
		return;
	}

	self AllowStand(true);
	self AllowCrouch(true);
	self AllowProne(true);
	self AllowSprint(true);
	self SetMoveSpeedScale(1);

}

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

init()
{

	PrecacheShader( "specialty_doublepoints_zombies" );
	PrecacheShader( "specialty_instakill_zombies" );
	//DUKIP - Add zombie blood.
	//PreCacheShader( "specialty_blood_zombies" );


	PrecacheShader( "black" );
	// powerup Vars
	set_zombie_var( "zombie_insta_kill", 				0 );
	set_zombie_var( "zombie_point_scalar", 				1 );
	set_zombie_var( "zombie_drop_item", 				0 );
	set_zombie_var( "zombie_timer_offset", 				350 );	// hud offsets
	set_zombie_var( "zombie_timer_offset_interval", 	30 );
	set_zombie_var( "zombie_powerup_insta_kill_on", 	false );
	set_zombie_var( "zombie_powerup_point_doubler_on", 	false );
	set_zombie_var( "zombie_powerup_point_doubler_time", 30 );	// length of point doubler
	set_zombie_var( "zombie_powerup_insta_kill_time", 	30 );	// length of insta kill
	set_zombie_var( "zombie_powerup_drop_increment", 	2000 );	// lower this to make drop happen more often
	set_zombie_var( "zombie_powerup_drop_max_per_round", 4 );	// lower this to make drop happen more often
	//DUKIP - Why make it level-wide it's not right?
	//This is not even used really.
	set_zombie_var( "zombie_powerup_zombie_blood_on", 0 );
	set_zombie_var( "zombie_powerup_zombie_blood_time", 30 );
	//DUKIP - Set vars through player like in T6.
	level thread onPlayerConnect();
	// powerups
	level._effect["powerup_on"] 				= loadfx( "misc/fx_zombie_powerup_on" );
	level._effect["powerup_grabbed"] 			= loadfx( "misc/fx_zombie_powerup_grab" );
	level._effect["powerup_grabbed_wave"] 		= loadfx( "misc/fx_zombie_powerup_wave" );

	init_powerups();

	thread watch_for_drop();
}

//DUKIP - Connecting functions
onPlayerConnect()
{
	for( ;; )
	{
		level waittill( "connecting", player );
		player thread init_player_zombie_blood_vars();
	}
}

//DUKIP - Follow how T6 does it.
init_player_zombie_blood_vars()
{
	self.zombie_vars[ "zombie_powerup_zombie_blood_on" ] = 0;
	self.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = 30;
}
//

init_powerups()
{
	if( !IsDefined( level.zombie_powerup_array ) )
	{
		level.zombie_powerup_array = [];
	}
	if ( !IsDefined( level.zombie_special_drop_array ) )
	{
		level.zombie_special_drop_array = [];
	}

	// Random Drops
	add_zombie_powerup( "nuke", 		"zombie_bomb",		&"ZOMBIE_POWERUP_NUKE", 			"misc/fx_zombie_mini_nuke" );
//	add_zombie_powerup( "nuke", 		"zombie_bomb",		&"ZOMBIE_POWERUP_NUKE", 			"misc/fx_zombie_mini_nuke_hotness" );
	add_zombie_powerup( "insta_kill", 	"zombie_skull",		&"ZOMBIE_POWERUP_INSTA_KILL" );
	add_zombie_powerup( "double_points","zombie_x2_icon",	&"ZOMBIE_POWERUP_DOUBLE_POINTS" );
	add_zombie_powerup( "full_ammo",  	"zombie_ammocan",	&"ZOMBIE_POWERUP_MAX_AMMO");
	add_zombie_powerup( "carpenter",  	"zombie_carpenter",	&"ZOMBIE_POWERUP_MAX_AMMO");
	//DUKIP - Add zombie blood.
	add_zombie_powerup( "blood",  		"zombie_blood",		&"ZOMBIE_POWERUP_MAX_AMMO");

	//	add_zombie_special_powerup( "monkey" );

	// additional special "drops"
//	add_zombie_special_drop( "nothing" );
	add_zombie_special_drop( "dog" );

	// Randomize the order
	randomize_powerups();

	level.zombie_powerup_index = 0;
	randomize_powerups();

	level thread powerup_hud_overlay();
}

powerup_hud_overlay()
{
	level.powerup_hud_array = [];
	level.powerup_hud_array[0] = true;
	level.powerup_hud_array[1] = true;
	//DUKIP - Same as below
	//deprecated as t4 uses level vars instead of self for powerup huds
	//requires rewriting, will keep it simple for now.
	//level.powerup_hud_array[2] = true;

	level.powerup_hud = [];
	level.powerup_hud_cover = [];
	level endon ("disconnect");

	//DUKIP - Change array creation to 0-2 rather than 0-1
	//deprecated back to 0-1
	//for(i = 0; i < 3; i++)
	for(i = 0; i < 2; i++)
	{
		level.powerup_hud[i] = create_simple_hud();
		level.powerup_hud[i].foreground = true;
		level.powerup_hud[i].sort = 2;
		level.powerup_hud[i].hidewheninmenu = false;
		level.powerup_hud[i].alignX = "center";
		level.powerup_hud[i].alignY = "bottom";
		level.powerup_hud[i].horzAlign = "center";
		level.powerup_hud[i].vertAlign = "bottom";
		level.powerup_hud[i].x = -32 + (i * 15);
		level.powerup_hud[i].y = level.powerup_hud[i].y - 35;
		level.powerup_hud[i].alpha = 0.8;
	}

	shader_2x = "specialty_doublepoints_zombies";
	shader_insta = "specialty_instakill_zombies";
	//DUKIP - Add ZM Blood shader
	//shader_blood = "specialty_blood_zombies";

	while(true)
	{
		if(level.zombie_vars["zombie_powerup_insta_kill_time"] < 5)
		{
			wait(0.1);
			level.powerup_hud[1].alpha = 0;
			wait(0.1);


		}
		else if(level.zombie_vars["zombie_powerup_insta_kill_time"] < 10)
		{
			wait(0.2);
			level.powerup_hud[1].alpha = 0;
			wait(0.18);

		}

		if(level.zombie_vars["zombie_powerup_point_doubler_time"] < 5)
		{
			wait(0.1);
			level.powerup_hud[0].alpha = 0;
			wait(0.1);


		}
		else if(level.zombie_vars["zombie_powerup_point_doubler_time"] < 10)
		{
			wait(0.2);
			level.powerup_hud[0].alpha = 0;
			wait(0.18);
		}

		if(level.zombie_vars["zombie_powerup_point_doubler_on"] == true && level.zombie_vars["zombie_powerup_insta_kill_on"] == true)
		{

			level.powerup_hud[0].x = -24;
			level.powerup_hud[1].x = 24;
			level.powerup_hud[0].alpha = 1;
			level.powerup_hud[1].alpha = 1;
			level.powerup_hud[0] setshader(shader_2x, 32, 32);
			level.powerup_hud[1] setshader(shader_insta, 32, 32);
			/*level.powerup_hud_cover[0].x = -36;
			level.powerup_hud_cover[1].x = 36;
			level.powerup_hud_cover[0] setshader(shader_white, 32, i);
			level.powerup_hud_cover[1] setshader(shader_white, 32, j);
			level.powerup_hud_cover[0].alpha = 1;
			level.powerup_hud_cover[1].alpha = 1;*/

		}
		else if(level.zombie_vars["zombie_powerup_point_doubler_on"] == true && level.zombie_vars["zombie_powerup_insta_kill_on"] == false)
		{
			level.powerup_hud[0].x = 0;
			//level.powerup_hud[0].y = level.powerup_hud[0].y - 70;
			level.powerup_hud[0] setshader(shader_2x, 32, 32);
			level.powerup_hud[1].alpha = 0;
			level.powerup_hud[0].alpha = 1;

		}
		else if(level.zombie_vars["zombie_powerup_insta_kill_on"] == true && level.zombie_vars["zombie_powerup_point_doubler_on"] == false)
		{

			level.powerup_hud[1].x = 0;
			//level.powerup_hud[1].y = level.powerup_hud[1].y - 70;
			level.powerup_hud[1] setshader(shader_insta, 32, 32);
			level.powerup_hud[0].alpha = 0;
			level.powerup_hud[1].alpha = 1;
		}
		else
		{

			level.powerup_hud[1].alpha = 0;
			level.powerup_hud[0].alpha = 0;

		}

		wait(0.01);
	}
}

randomize_powerups()
{
	level.zombie_powerup_array = array_randomize( level.zombie_powerup_array );
}

get_next_powerup()
{
	if( level.zombie_powerup_index >= level.zombie_powerup_array.size )
	{
		level.zombie_powerup_index = 0;
		randomize_powerups();
	}

	powerup = level.zombie_powerup_array[level.zombie_powerup_index];

	/#
		if( isdefined( level.zombie_devgui_power ) && level.zombie_devgui_power == 1 )
			return powerup;

	#/

	//level.windows_destroyed = get_num_window_destroyed();

	while( powerup == "carpenter" && get_num_window_destroyed() < 5)
	{


		if( level.zombie_powerup_index >= level.zombie_powerup_array.size )
		{
			level.zombie_powerup_index = 0;
			randomize_powerups();
		}


		powerup = level.zombie_powerup_array[level.zombie_powerup_index];
		level.zombie_powerup_index++;

		if( powerup != "carpenter" )
			return powerup;


		wait(0.05);
	}

	level.zombie_powerup_index++;

	return powerup;
}

get_num_window_destroyed()
{
	num = 0;
	for( i = 0; i < level.exterior_goals.size; i++ )
	{
		/*targets = getentarray(level.exterior_goals[i].target, "targetname");

		barrier_chunks = [];
		for( j = 0; j < targets.size; j++ )
		{
			if( IsDefined( targets[j].script_noteworthy ) )
			{
				if( targets[j].script_noteworthy == "clip" )
				{
					continue;
				}
			}

			barrier_chunks[barrier_chunks.size] = targets[j];
		}*/


		if( all_chunks_destroyed( level.exterior_goals[i].barrier_chunks ) )
		{
			num += 1;
		}

	}

	return num;
}

watch_for_drop()
{
	players = get_players();
	score_to_drop = ( players.size * level.zombie_vars["zombie_score_start"] ) + level.zombie_vars["zombie_powerup_drop_increment"];

	while (1)
	{
		players = get_players();

		curr_total_score = 0;

		for (i = 0; i < players.size; i++)
		{
			curr_total_score += players[i].score_total;
		}

		if (curr_total_score > score_to_drop )
		{
			level.zombie_vars["zombie_powerup_drop_increment"] *= 1.14;
			score_to_drop = curr_total_score + level.zombie_vars["zombie_powerup_drop_increment"];
			level.zombie_vars["zombie_drop_item"] = 1;
		}

		wait( 0.5 );
	}
}

add_zombie_powerup( powerup_name, model_name, hint, fx )
{
	if( IsDefined( level.zombie_include_powerups ) && !IsDefined( level.zombie_include_powerups[powerup_name] ) )
	{
		return;
	}

	PrecacheModel( model_name );
	PrecacheString( hint );

	struct = SpawnStruct();

	if( !IsDefined( level.zombie_powerups ) )
	{
		level.zombie_powerups = [];
	}

	struct.powerup_name = powerup_name;
	struct.model_name = model_name;
	struct.weapon_classname = "script_model";
	struct.hint = hint;

	if( IsDefined( fx ) )
	{
		struct.fx = LoadFx( fx );
	}

	level.zombie_powerups[powerup_name] = struct;
	level.zombie_powerup_array[level.zombie_powerup_array.size] = powerup_name;
	add_zombie_special_drop( powerup_name );
}


// special powerup list for the teleporter drop
add_zombie_special_drop( powerup_name )
{
	level.zombie_special_drop_array[ level.zombie_special_drop_array.size ] = powerup_name;
}

include_zombie_powerup( powerup_name )
{
	if( !IsDefined( level.zombie_include_powerups ) )
	{
		level.zombie_include_powerups = [];
	}

	level.zombie_include_powerups[powerup_name] = true;
}

powerup_round_start()
{
	level.powerup_drop_count = 0;
}

powerup_drop(drop_point)
{
	rand_drop = randomint(100);

	if( level.powerup_drop_count >= level.zombie_vars["zombie_powerup_drop_max_per_round"] )
	{
		println( "^3POWERUP DROP EXCEEDED THE MAX PER ROUND!" );
		return;
	}

	if( !isDefined(level.zombie_include_powerups) || level.zombie_include_powerups.size == 0 )
	{
		return;
	}

	// some guys randomly drop, but most of the time they check for the drop flag
	if (rand_drop > 2)
	{
		if (!level.zombie_vars["zombie_drop_item"])
		{
			return;
		}

		debug = "score";
	}
	else
	{
		debug = "random";
	}

	// never drop unless in the playable area
	playable_area = getentarray("playable_area","targetname");

	powerup = maps\_zombiemode_net::network_safe_spawn( "powerup", 1, "script_model", drop_point + (0,0,40));

	//chris_p - fixed bug where you could not have more than 1 playable area trigger for the whole map
	valid_drop = false;
	for (i = 0; i < playable_area.size; i++)
	{
		if (powerup istouching(playable_area[i]))
		{
			valid_drop = true;
		}
	}

	if(!valid_drop)
	{
		powerup delete();
		return;
	}

	powerup powerup_setup();
	level.powerup_drop_count++;

	//print_powerup_drop( powerup.powerup_name, debug );

	powerup thread powerup_timeout();
	powerup thread powerup_wobble();
	powerup thread powerup_grab();

	level.zombie_vars["zombie_drop_item"] = 0;


	//powerup = powerup_setup();


	// if is !is touching trig
	// return

	// spawn the model, do a ground trace and place above
	// start the movement logic, spawn the fx
	// start the time out logic
	// start the grab logic
}


//
//	Special power up drop - done outside of the powerup system.
special_powerup_drop(drop_point)
{
// 	if( level.powerup_drop_count == level.zombie_vars["zombie_powerup_drop_max_per_round"] )
// 	{
// 		println( "^3POWERUP DROP EXCEEDED THE MAX PER ROUND!" );
// 		return;
// 	}

	if( !isDefined(level.zombie_include_powerups) || level.zombie_include_powerups.size == 0 )
	{
		return;
	}

	powerup = spawn ("script_model", drop_point + (0,0,40));

	// never drop unless in the playable area
	playable_area = getentarray("playable_area","targetname");
	//chris_p - fixed bug where you could not have more than 1 playable area trigger for the whole map
	valid_drop = false;
	for (i = 0; i < playable_area.size; i++)
	{
		if (powerup istouching(playable_area[i]))
		{
			valid_drop = true;
			break;
		}
	}

	if(!valid_drop)
	{
		powerup Delete();
		return;
	}

	powerup special_drop_setup();
}


//
//	Pick the next powerup in the list
powerup_setup()
{
	powerup = get_next_powerup();

	struct = level.zombie_powerups[powerup];
	self SetModel( struct.model_name );

	//TUEY Spawn Powerup
	playsoundatposition("spawn_powerup", self.origin);

	self.powerup_name 	= struct.powerup_name;
	self.hint 			= struct.hint;

	if( IsDefined( struct.fx ) )
	{
		self.fx = struct.fx;
	}

	self PlayLoopSound("spawn_powerup_loop");
}


//
//	Get the special teleporter drop
special_drop_setup()
{
	powerup = undefined;
	is_powerup = true;
	// Always give something at lower rounds or if a player is in last stand mode.
	if ( level.round_number <= 10 || maps\_laststand::player_num_in_laststand() )
	{
		powerup = get_next_powerup();
	}
	// Gets harder now
	else
	{
		powerup = level.zombie_special_drop_array[ RandomInt(level.zombie_special_drop_array.size) ];
		if ( level.round_number > 15 &&
			 ( RandomInt(100) < (level.round_number - 15)*5 ) )
		{
			powerup = "nothing";
		}
	}
	//MM test  Change this if you want the same thing to keep spawning
//	powerup = "dog";
	switch ( powerup )
	{
	// Don't need to do anything special
	case "nuke":
	case "insta_kill":
	case "double_points":
	case "carpenter":
	//DUKIP - Added zombie blood.
	case "blood":
		break;

	// Limit max ammo drops because it's too powerful
	case "full_ammo":
		if ( level.round_number > 10 &&
			 ( RandomInt(100) < (level.round_number - 10)*5 ) )
		{
			// Randomly pick another one
			powerup = level.zombie_powerup_array[ RandomInt(level.zombie_powerup_array.size) ];
		}
		break;

	case "dog":
		if ( level.round_number >= 15 )
		{
			is_powerup = false;
			dog_spawners = GetEntArray( "special_dog_spawner", "targetname" );
			maps\_zombiemode_dogs::special_dog_spawn( dog_spawners, 1 );
			//iprintlnbold( "Samantha Sez: No Powerup For You!" );
			thread play_sound_2d( "sam_nospawn" );
		}
		else
		{
			powerup = get_next_powerup();
		}
		break;

	// Nothing drops!!
	default:	// "nothing"
		is_powerup = false;
		Playfx( level._effect["lightning_dog_spawn"], self.origin );
		playsoundatposition( "pre_spawn", self.origin );
		wait( 1.5 );
		playsoundatposition( "bolt", self.origin );

		Earthquake( 0.5, 0.75, self.origin, 1000);
		PlayRumbleOnPosition("explosion_generic", self.origin);
		playsoundatposition( "spawn", self.origin );

		wait( 1.0 );
		//iprintlnbold( "Samantha Sez: No Powerup For You!" );
		thread play_sound_2d( "sam_nospawn" );
		self Delete();
	}

	if ( is_powerup )
	{
		Playfx( level._effect["lightning_dog_spawn"], self.origin );
		playsoundatposition( "pre_spawn", self.origin );
		wait( 1.5 );
		playsoundatposition( "bolt", self.origin );

		Earthquake( 0.5, 0.75, self.origin, 1000);
		PlayRumbleOnPosition("explosion_generic", self.origin);
		playsoundatposition( "spawn", self.origin );

//		wait( 0.5 );

		struct = level.zombie_powerups[powerup];
		self SetModel( struct.model_name );

		//TUEY Spawn Powerup
		playsoundatposition("spawn_powerup", self.origin);

		self.powerup_name 	= struct.powerup_name;
		self.hint 			= struct.hint;

		if( IsDefined( struct.fx ) )
		{
			self.fx = struct.fx;
		}

		self PlayLoopSound("spawn_powerup_loop");

		self thread powerup_timeout();
		self thread powerup_wobble();
		self thread powerup_grab();
	}
}

powerup_grab()
{
	self endon ("powerup_timedout");
	self endon ("powerup_grabbed");

	while (isdefined(self))
	{
		players = get_players();

		for (i = 0; i < players.size; i++)
		{
			if (distance (players[i].origin, self.origin) < 64)
			{
				playfx (level._effect["powerup_grabbed"], self.origin);
				playfx (level._effect["powerup_grabbed_wave"], self.origin);

				if( IsDefined( level.zombie_powerup_grab_func ) )
				{
					level thread [[level.zombie_powerup_grab_func]]();
				}
				else
				{
					switch (self.powerup_name)
					{
					case "nuke":
						level thread nuke_powerup( self );

						//chrisp - adding powerup VO sounds
						players[i] thread powerup_vo("nuke");
						zombies = getaiarray("axis");
						players[i].zombie_nuked = get_array_of_closest( self.origin, zombies );
						players[i] notify("nuke_triggered");

						break;
					case "full_ammo":
						level thread full_ammo_powerup( self );
						players[i] thread powerup_vo("full_ammo");
						break;
					case "double_points":
						level thread double_points_powerup( self );
						players[i] thread powerup_vo("double_points");
						break;
					case "insta_kill":
						level thread insta_kill_powerup( self );
						players[i] thread powerup_vo("insta_kill");
						break;
					case "carpenter":
						level thread start_carpenter( self.origin );
						players[i] thread powerup_vo("carpenter");
						break;
					//DUKIP - Add zombie blood
					case "blood":
						players[i] thread zombie_blood_powerup();
						break;

					default:
						println ("Unrecognized poweup.");
						break;
					}
				}

				wait( 0.1 );

				playsoundatposition("powerup_grabbed", self.origin);
				self stoploopsound();

				self delete();
				self notify ("powerup_grabbed");
			}
		}
		wait 0.1;
	}
}

start_carpenter( origin )
{

	level thread play_devil_dialog("carp_vox");
	window_boards = getstructarray( "exterior_goal", "targetname" );
	total = level.exterior_goals.size;

	//COLLIN
	carp_ent = spawn("script_origin", (0,0,0));
	carp_ent playloopsound( "carp_loop" );

	while(true)
	{
		windows = get_closest_window_repair(window_boards, origin);
		if( !IsDefined( windows ) )
		{
			carp_ent stoploopsound( 1 );
			carp_ent playsound( "carp_end", "sound_done" );
			carp_ent waittill( "sound_done" );
			break;
		}

		else
			window_boards = array_remove(window_boards, windows);


		while(1)
		{
			if( all_chunks_intact( windows.barrier_chunks ) )
			{
				break;
			}

			chunk = get_random_destroyed_chunk( windows.barrier_chunks );

			if( !IsDefined( chunk ) )
				break;

			windows thread maps\_zombiemode_blockers_new::replace_chunk( chunk, false, true );
			windows.clip enable_trigger();
			windows.clip DisconnectPaths();
			wait_network_frame();
			wait(0.05);
		}


		wait_network_frame();

	}


	players = get_players();
	for(i = 0; i < players.size; i++)
	{
		players[i].score += 200;
		players[i].score_total += 200;
		players[i] maps\_zombiemode_score::set_player_score_hud();
	}


	carp_ent delete();


}
get_closest_window_repair( windows, origin )
{
	current_window = undefined;
	shortest_distance = undefined;
	for( i = 0; i < windows.size; i++ )
	{
		if( all_chunks_intact(windows[i].barrier_chunks ) )
			continue;

		if( !IsDefined( current_window ) )
		{
			current_window = windows[i];
			shortest_distance = DistanceSquared( current_window.origin, origin );

		}
		else
		{
			if( DistanceSquared(windows[i].origin, origin) < shortest_distance )
			{

				current_window = windows[i];
				shortest_distance =  DistanceSquared( windows[i].origin, origin );
			}

		}

	}

	return current_window;


}

powerup_vo(type)
{
	self endon("death");
	self endon("disconnect");

	index = maps\_zombiemode_weapons::get_player_index(self);
	sound = undefined;
	rand = randomintrange(0,3);
	vox_rand = randomintrange(1,100);  //RARE: This is to setup the Rare devil response lines
	percentage = 1;  //What percent chance the rare devil response line has to play

	if(!isdefined (level.player_is_speaking))
	{
		level.player_is_speaking = 0;
	}

	wait(randomfloatrange(1,2));

	switch(type)
	{
		case "nuke":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_nuke_" + rand;
			}
			break;
		case "insta_kill":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_insta_" + rand;
			}
			break;
		case "full_ammo":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_ammo_" + rand;
			}
			break;
		case "double_points":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_double_" + rand;
			}
			break;
		case "carpenter":
			if( vox_rand <= percentage )
			{
				//sound = "plr_" + index + "_vox_resp_dev_rare_" + rand;
				//iprintlnbold( "Whoopdedoo, rare Devil Response line" );
			}
			else
			{
				sound = "plr_" + index + "_vox_powerup_carp_" + rand;
			}
			break;
		//DUKIP - Add zombie blood, don't do any plr vox sounds though.
		case "blood":
			break;
	}

	//This keeps multiple voice overs from playing on the same player (both killstreaks and headshots).
	if (level.player_is_speaking != 1 && isDefined(sound))
	{
		level.player_is_speaking = 1;
		self playsound(sound, "sound_done");
		self waittill("sound_done");
		level.player_is_speaking = 0;
	}


}

powerup_wobble()
{
	self endon ("powerup_grabbed");
	self endon ("powerup_timedout");

	if (isdefined(self))
	{
		playfxontag (level._effect["powerup_on"], self, "tag_origin");
	}

	while (isdefined(self))
	{
		waittime = randomfloatrange(2.5, 5);
		yaw = RandomInt( 360 );
		if( yaw > 300 )
		{
			yaw = 300;
		}
		else if( yaw < 60 )
		{
			yaw = 60;
		}
		yaw = self.angles[1] + yaw;
		self rotateto ((-60 + randomint(120), yaw, -45 + randomint(90)), waittime, waittime * 0.5, waittime * 0.5);
		wait randomfloat (waittime - 0.1);
	}
}

powerup_timeout()
{
	self endon ("powerup_grabbed");

	wait 15;

	for (i = 0; i < 40; i++)
	{
		// hide and show
		if (i % 2)
		{
			self hide();
		}
		else
		{
			self show();
		}

		if (i < 15)
		{
			wait 0.5;
		}
		else if (i < 25)
		{
			wait 0.25;
		}
		else
		{
			wait 0.1;
		}
	}

	self notify ("powerup_timedout");
	self delete();
}

// kill them all!
nuke_powerup( drop_item )
{
	zombies = getaispeciesarray("axis");

	PlayFx( drop_item.fx, drop_item.origin );
	//	players = get_players();
	//	array_thread (players, ::nuke_flash);
	level thread nuke_flash();



	zombies = get_array_of_closest( drop_item.origin, zombies );

	for (i = 0; i < zombies.size; i++)
	{
		wait (randomfloatrange(0.1, 0.7));
		if( !IsDefined( zombies[i] ) )
		{
			continue;
		}

		if( zombies[i].animname == "boss_zombie" )
		{
			continue;
		}

		if( is_magic_bullet_shield_enabled( zombies[i] ) )
		{
			continue;
		}

		if( i < 5 && !( zombies[i] enemy_is_dog() ) )
		{
			zombies[i] thread animscripts\death::flame_death_fx();

		}

		if( !( zombies[i] enemy_is_dog() ) )
		{
			zombies[i] maps\_zombiemode_spawner::zombie_head_gib();
		}

		zombies[i] dodamage( zombies[i].health + 666, zombies[i].origin );
		playsoundatposition( "nuked", zombies[i].origin );
	}

	players = get_players();
	for(i = 0; i < players.size; i++)
	{
		players[i].score += 400;
		players[i].score_total += 400;
		players[i] maps\_zombiemode_score::set_player_score_hud();
	}

}

nuke_flash()
{
	players = getplayers();
	for(i=0; i<players.size; i ++)
	{
		players[i] play_sound_2d("nuke_flash");
	}
	level thread devil_dialog_delay();


	fadetowhite = newhudelem();

	fadetowhite.x = 0;
	fadetowhite.y = 0;
	fadetowhite.alpha = 0;

	fadetowhite.horzAlign = "fullscreen";
	fadetowhite.vertAlign = "fullscreen";
	fadetowhite.foreground = true;
	fadetowhite SetShader( "white", 640, 480 );

	// Fade into white
	fadetowhite FadeOverTime( 0.2 );
	fadetowhite.alpha = 0.8;

	wait 0.5;
	fadetowhite FadeOverTime( 1.0 );
	fadetowhite.alpha = 0;

	wait 1.1;
	fadetowhite destroy();
}

// double the points
double_points_powerup( drop_item )
{
	level notify ("powerup points scaled");
	level endon ("powerup points scaled");

	//	players = get_players();
	//	array_thread(level,::point_doubler_on_hud, drop_item);
	level thread point_doubler_on_hud( drop_item );

	level.zombie_vars["zombie_point_scalar"] = 2;
	wait 30;

	level.zombie_vars["zombie_point_scalar"] = 1;
}

full_ammo_powerup( drop_item )
{
	players = get_players();

	for (i = 0; i < players.size; i++)
	{
		primaryWeapons = players[i] GetWeaponsList();

		for( x = 0; x < primaryWeapons.size; x++ )
		{
			players[i] GiveMaxAmmo( primaryWeapons[x] );
		}
	}
	//	array_thread (players, ::full_ammo_on_hud, drop_item);
	level thread full_ammo_on_hud( drop_item );
}

insta_kill_powerup( drop_item )
{
	level notify( "powerup instakill" );
	level endon( "powerup instakill" );


	//	array_thread (players, ::insta_kill_on_hud, drop_item);
	level thread insta_kill_on_hud( drop_item );

	level.zombie_vars["zombie_insta_kill"] = 1;
	wait( 30 );
	level.zombie_vars["zombie_insta_kill"] = 0;
	players = get_players();
	for(i = 0; i < players.size; i++)
	{
		players[i] notify("insta_kill_over");

	}

}

check_for_instakill( player )
{
	if( IsDefined( player ) && IsAlive( player ) && level.zombie_vars["zombie_insta_kill"])
	{
		if( is_magic_bullet_shield_enabled( self ) )
		{
			return;
		}

		if( self.animname == "boss_zombie" )
		{
			return;
		}

		if(player.use_weapon_type == "MOD_MELEE")
		{
			player.last_kill_method = "MOD_MELEE";
		}
		else
		{
			player.last_kill_method = "MOD_UNKNOWN";

		}

		if( flag( "dog_round" ) )
		{
			self DoDamage( self.health + 666, self.origin, player );
			player notify("zombie_killed");
		}
		else
		{
			self maps\_zombiemode_spawner::zombie_head_gib();
			self DoDamage( self.health + 666, self.origin, player );
			player notify("zombie_killed");

		}
	}
}

insta_kill_on_hud( drop_item )
{
	self endon ("disconnect");

	// check to see if this is on or not
	if ( level.zombie_vars["zombie_powerup_insta_kill_on"] )
	{
		// reset the time and keep going
		level.zombie_vars["zombie_powerup_insta_kill_time"] = 30;
		return;
	}

	level.zombie_vars["zombie_powerup_insta_kill_on"] = true;

	// set up the hudelem
	//hudelem = maps\_hud_util::createFontString( "objective", 2 );
	//hudelem maps\_hud_util::setPoint( "TOP", undefined, 0, level.zombie_vars["zombie_timer_offset"] + level.zombie_vars["zombie_timer_offset_interval"]);
	//hudelem.sort = 0.5;
	//hudelem.alpha = 0;
	//hudelem fadeovertime(0.5);
	//hudelem.alpha = 1;
	//hudelem.label = drop_item.hint;

	// set time remaining for insta kill
	level thread time_remaning_on_insta_kill_powerup();

	// offset in case we get another powerup
	//level.zombie_timer_offset -= level.zombie_timer_offset_interval;
}

time_remaning_on_insta_kill_powerup()
{
	//self setvalue( level.zombie_vars["zombie_powerup_insta_kill_time"] );
	level thread play_devil_dialog("insta_vox");
	temp_enta = spawn("script_origin", (0,0,0));
	temp_enta playloopsound("insta_kill_loop");

	/*
	players = get_players();
	for (i = 0; i < players.size; i++)
	{
	players[i] playloopsound ("insta_kill_loop");
	}
	*/


	// time it down!
	while ( level.zombie_vars["zombie_powerup_insta_kill_time"] >= 0)
	{
		wait 0.1;
		level.zombie_vars["zombie_powerup_insta_kill_time"] = level.zombie_vars["zombie_powerup_insta_kill_time"] - 0.1;
	//	self setvalue( level.zombie_vars["zombie_powerup_insta_kill_time"] );
	}

	players = get_players();
	for (i = 0; i < players.size; i++)
	{
		//players[i] stoploopsound (2);

		players[i] playsound("insta_kill");

	}

	temp_enta stoploopsound(2);
	// turn off the timer
	level.zombie_vars["zombie_powerup_insta_kill_on"] = false;

	// remove the offset to make room for new powerups, reset timer for next time
	level.zombie_vars["zombie_powerup_insta_kill_time"] = 30;
	//level.zombie_timer_offset += level.zombie_timer_offset_interval;
	//self destroy();
	temp_enta delete();
}

point_doubler_on_hud( drop_item )
{
	self endon ("disconnect");

	// check to see if this is on or not
	if ( level.zombie_vars["zombie_powerup_point_doubler_on"] )
	{
		// reset the time and keep going
		level.zombie_vars["zombie_powerup_point_doubler_time"] = 30;
		return;
	}

	level.zombie_vars["zombie_powerup_point_doubler_on"] = true;
	//level.powerup_hud_array[0] = true;
	// set up the hudelem
	//hudelem = maps\_hud_util::createFontString( "objective", 2 );
	//hudelem maps\_hud_util::setPoint( "TOP", undefined, 0, level.zombie_vars["zombie_timer_offset"] );
	//hudelem.sort = 0.5;
	//hudelem.alpha = 0;
	//hudelem fadeovertime( 0.5 );
	//hudelem.alpha = 1;
	//hudelem.label = drop_item.hint;

	// set time remaining for point doubler
	level thread time_remaining_on_point_doubler_powerup();

	// offset in case we get another powerup
	//level.zombie_timer_offset -= level.zombie_timer_offset_interval;
}
play_devil_dialog(sound_to_play)
{
	if(!IsDefined(level.devil_is_speaking))
	{
		level.devil_is_speaking = 0;
	}
	if(level.devil_is_speaking == 0)
	{
		level.devil_is_speaking = 1;
		play_sound_2D( sound_to_play );
		wait 2.0;
		level.devil_is_speaking =0;
	}

}
time_remaining_on_point_doubler_powerup()
{
	//self setvalue( level.zombie_vars["zombie_powerup_point_doubler_time"] );

	temp_ent = spawn("script_origin", (0,0,0));
	temp_ent playloopsound ("double_point_loop");

	level thread play_devil_dialog("dp_vox");


	// time it down!
	while ( level.zombie_vars["zombie_powerup_point_doubler_time"] >= 0)
	{
		wait 0.1;
		level.zombie_vars["zombie_powerup_point_doubler_time"] = level.zombie_vars["zombie_powerup_point_doubler_time"] - 0.1;
		//self setvalue( level.zombie_vars["zombie_powerup_point_doubler_time"] );
	}

	// turn off the timer
	level.zombie_vars["zombie_powerup_point_doubler_on"] = false;
	players = get_players();
	for (i = 0; i < players.size; i++)
	{
		//players[i] stoploopsound("double_point_loop", 2);
		players[i] playsound("points_loop_off");
	}
	temp_ent stoploopsound(2);


	// remove the offset to make room for new powerups, reset timer for next time
	level.zombie_vars["zombie_powerup_point_doubler_time"] = 30;
	//level.zombie_timer_offset += level.zombie_timer_offset_interval;
	//self destroy();
	temp_ent delete();
}
devil_dialog_delay()
{
	wait(1.8);
	level thread play_devil_dialog("nuke_vox");

}
full_ammo_on_hud( drop_item )
{
	self endon ("disconnect");

	// set up the hudelem
	hudelem = maps\_hud_util::createFontString( "objective", 2 );
	hudelem maps\_hud_util::setPoint( "TOP", undefined, 0, level.zombie_vars["zombie_timer_offset"] - (level.zombie_vars["zombie_timer_offset_interval"] * 2));
	hudelem.sort = 0.5;
	hudelem.alpha = 0;
	hudelem fadeovertime(0.5);
	hudelem.alpha = 1;
	hudelem.label = drop_item.hint;

	// set time remaining for insta kill
	hudelem thread full_ammo_move_hud();

	// offset in case we get another powerup
	//level.zombie_timer_offset -= level.zombie_timer_offset_interval;
}

full_ammo_move_hud()
{

	players = get_players();
	level thread play_devil_dialog("ma_vox");
	for (i = 0; i < players.size; i++)
	{
		players[i] playsound ("full_ammo");

	}
	wait 0.5;
	move_fade_time = 1.5;

	self FadeOverTime( move_fade_time );
	self MoveOverTime( move_fade_time );
	self.y = 270;
	self.alpha = 0;

	wait move_fade_time;

	self destroy();
}

//
// DEBUG
//

print_powerup_drop( powerup, type )
{
	/#
		if( !IsDefined( level.powerup_drop_time ) )
		{
			level.powerup_drop_time = 0;
			level.powerup_random_count = 0;
			level.powerup_score_count = 0;
		}

		time = ( GetTime() - level.powerup_drop_time ) * 0.001;
		level.powerup_drop_time = GetTime();

		if( type == "random" )
		{
			level.powerup_random_count++;
		}
		else
		{
			level.powerup_score_count++;
		}

		println( "========== POWER UP DROPPED ==========" );
		println( "DROPPED: " + powerup );
		println( "HOW IT DROPPED: " + type );
		println( "--------------------" );
		println( "Drop Time: " + time );
		println( "Random Powerup Count: " + level.powerup_random_count );
		println( "Random Powerup Count: " + level.powerup_score_count );
		println( "======================================" );
#/
}

//DUKIP - Zombie blood code

//T6 common_scripts\utility.gsc
//Modified for three ents.
waittill_any_ents_three( ent1, string1, ent2, string2, ent3, string3 )
{
	assert( IsDefined( ent1 ) );
	assert( IsDefined( string1 ) );

	if ( ( IsDefined( ent2 ) ) && ( IsDefined( string2 ) ) )
		ent2 endon( string2 );

	if ( ( IsDefined( ent3 ) ) && ( IsDefined( string3 ) ) )
		ent3 endon( string3 );

	ent1 waittill( string1 );
}

zombie_blood_powerup()
{
	self notify( "zombie_blood" );
	self endon( "zombie_blood" );
	self endon( "disconnect" );
	//DUKIP - Since no VO's just do the local sound.
	//self thread powerup_vo("zombie_blood");
	self PlayLocalSound("zombie_blood");
	self.ignoreme = true;
	self.zombie_vars["zombie_powerup_zombie_blood_on"] = true;
	self.zombie_vars["zombie_powerup_zombie_blood_time"] = 30;
	self SetClientDvar("cg_fovscale", 1.2);
	self VisionSetNaked("zm_blood", 0.5);
	self thread watch_zombie_blood_early_exit();
	while( self.zombie_vars["zombie_powerup_zombie_blood_time"] >= 0 )
	{
		wait 0.05;
		self.zombie_vars["zombie_powerup_zombie_blood_time"] -= 0.05;
		//IPrintLnBold(self.zombie_vars["zombie_powerup_zombie_blood_time"]);
	}
	self notify( "zombie_blood_over" );
	if ( !isDefined( self.early_exit ) )
		self.ignoreme = false;
	else
		self.early_exit = undefined;
	self SetClientDvar("cg_fovscale", 1);
	//DUKIP - Set this vision to whatever your map uses.
	self VisionSetNaked("zombie_factory", 0.5);
	self.zombie_vars["zombie_powerup_zombie_blood_on"] = false;
	self.zombie_vars["zombie_powerup_zombie_blood_time"] = 30;
}

watch_zombie_blood_early_exit()
{
	self notify( "early_exit_watch" );
	self endon( "early_exit_watch" );
	self endon( "zombie_blood_over" );
	self endon( "disconnect" );
	waittill_any_ents_three( self, "player_downed", level, "end_game", self, "fake_death" );
	self.zombie_vars[ "zombie_powerup_zombie_blood_time" ] = -0.05;
	self.early_exit = true;
}

include_powerups()
{
	include_powerup( "nuke" );
	include_powerup( "insta_kill" );
	include_powerup( "double_points" );
	include_powerup( "full_ammo" );
	include_powerup( "carpenter" );
	//DUKIP - Add zombie blood
	include_powerup( "blood" );
}

is_player_valid( player, ignoreMeFlag )
{
	if( !IsDefined( player ) )
	{
		return false;
	}

	if( !IsAlive( player ) )
	{
		return false;
	}

	if( !IsPlayer( player ) )
	{
		return false;
	}

	if( player.is_zombie == true )
	{
		return false;
	}

	if( player.sessionstate == "spectator" )
	{
		return false;
	}

	if( player.sessionstate == "intermission" )
	{
		return false;
	}

	if(  player maps\_laststand::player_is_in_laststand() )
	{
		return false;
	}

	if ( player isnotarget() )
	{
		return false;
	}

	//DUKIP - Ignore the player if they have the flag set.
	//As well as ignoreMeFlag is true
	if( is_true(ignoreMeFlag) && player.ignoreme )
	{
		return false;
	}

	return true;
}

//DUKIP - is_true function
is_true(check)
{
	return(IsDefined(check) && check);
}

name,platform,file,sequence,vol_min,vol_max,dist_min,dist_max,limit_count,limit_type,entity_limit_count,entity_limit_type,bus,volume_min_falloff_curve,volumefalloffcurve,reverb_send,dist_reverb_max,reverb_min_falloff_curve,reverb_falloff_curve,pitch_min,pitch_max,randomize_type,spatialized,type,probability,loop,masterslave,loadspec,subtitle,compression,secondaryaliasname,chainaliasname,startdelay,speakermap,lfe percentage,center percentage,envelop_min,envelop_max,envelop percentage,occlusion_level,occlusion_wet_dry,real_delay,distance_lpf,move_type,move_time,min_priority,max_priority,min_priority_threshold,max_priority_threshold,,isbig

zombie_blood,,bo2\vox\vox_zmba_powerup_zombie_blood.wav,,0.7,0.7,50,800,4,reject,,,full_vol,,curve4,1,1200,,curve2,1,1,,2d,,,,,,,,,,,,,,,,,0.25,,,,,,100,100,0.25,1,,

//DUKIP's version

r_glow						"0"
r_glowRadius0				"7"
r_glowRadius1				"7"
r_glowBloomCutoff			"0.99"
r_glowBloomDesaturation		"0.65"
r_glowBloomIntensity0		"0.36"
r_glowBloomIntensity1		"0.36"
r_glowSkyBleedIntensity0	"0.29"
r_glowSkyBleedIntensity1	"0.29"

r_filmEnable				"0"
r_filmContrast				"1"
r_filmBrightness			"0"
r_filmDesaturation			"0.2"
r_filmInvert				"0"
r_filmLightTint				"1 0 0"
r_filmDarkTint				"1 0 0"

r_reviveFX_enable				"1"
r_reviveFX_contrastEdge			"1.6"
r_reviveFX_brightnessEdge		"0.34"
r_reviveFX_desaturationEdge		"1"
r_reviveFX_darkTintEdge			"1 0 0"
r_reviveFX_lightTintEdge		"1 0 0"
r_reviveFX_blurRadiusEdge		"3.5"
r_reviveFX_motionblurWeight		"0"
r_reviveFX_contrastCenter		"1.76"
r_reviveFX_darkTintCenter		"0.978 1.01 0.975"
r_reviveFX_lightTintCenter		"1.02 1 0.99"

// ==========================================================
// Coding Projects
//
// Component: WaW
// Purpose: Stalker Script
//
// Initial author: DidUknowiPwn
// Started: 2015-01-15
//	© 2015 DidUknowiPwn™
// ==========================================================
#include common_scriptsutility;
#include maps\_utility;
#include maps\_zombiemode_utility;
#include maps\_loadout;

init()
{
	level thread onPlayerConnect();
}

onPlayerConnect()
{
	for(;;)
	{
		level waittill("connecting", player);
		player.speedScale = undefined;
		player thread onPlayerSpawned();
	}
}

onPlayerSpawned()
{
	self endon("disconnct");
	for(;;)
	{
		self waittill("spawned_player");
		self.speedScale = 1;
		self SetClientDvars(	"bg_bobAmplitudeDucked", "0.0075 0.0075",
													"bg_bobAmplitudeStanding", "0.007 0.007");
		self thread stalker_think();
	}
}

stalker_think()
{
	self endon("death");
	self endon("disconnect");
	self endon("player_downed");

	if(!IsDefined(self.speedScale))
		self.speedScale = 1;
	//DUKIP - Scoped vars initalized.	
	stalkerSpeedScale = undefined;
	currWeap = undefined;
 
	while(IsAlive(self))
	{
		//DUKIP - Grab our current weapon.
		currWeap = self getCurrentWeapon();
		//DUKIP - When ADS Button Pressed, ADS has been longer than 0.5 seconds(? or 50% done of adsTime from weapon file), IS NOT swiching weapons, IS NOT throwing nades,
		// and finally current weapon IS NOT perk bottle AND syrette.
		if(self ADSButtonPressed() && self playerADS() >= 0.5 && !self isSwitchingWeapons() && !self isThrowingGrenade() && (!IsSubStr(currWeap, "zombie_perk_bottle") && currWeap != "syrette"))
		{
			//DUKIP - My stalker sets all speed scales to speed of 1.5
			stalkerSpeedScale = self getStalkerSpeedScale(currWeap);
			if(stalkerSpeedScale != self.speedScale && IsDefined(level.zombie_include_weapons[currWeap]))
			{
				self SetMoveSpeedScale(stalkerSpeedScale);
				self.speedScale = stalkerSpeedScale;
				//DUKIP - Lower bobbing a bit on scoped weapons.
				if(self weaponIsScoped(currWeap))
					self SetClientDvars(	"bg_bobAmplitudeDucked", "0.002 0.002",
																"bg_bobAmplitudeStanding", "0.0025 0.0025");
			}
			//DUKIP - Since not included, print an error.
			if(!IsDefined(level.zombie_include_weapons[currWeap]))
				iprintlnbold("Weapon: ^1" + currWeap + "^7 is not an included weapon.");
		}
		else
		{
			//DUKIP -
			//Reset movement speed back to normal, SetMoveSpeedScale scales the movement speed based on param.
			//i.e.	zombie_colt = 1 + SetMoveSpeedScale(1) = 1 moveSpeedScale
			//			ptrs41_zombie = 0.75 + SetMoveSpeedScale(0.75) [from getNormalSpeedScale] = 0.5625 moveSpeedScale
			//			this is not what we want so, reset it back to original.
			self SetClientDvars(	"bg_bobAmplitudeDucked", "0.0075 0.0075",
														"bg_bobAmplitudeStanding", "0.007 0.007");
			self SetMoveSpeedScale(1);
			self.speedScale = 1;
		}
		wait 0.05;
	}
}

getStalkerSpeedScale(weapon)
{
	speedScale = undefined;
	//DUKIP - To get the "Stalker" speed scale to 1.5 or so, divide it by the moveSpeedScale in weapon file.
	switch(weapon)
	{
		case "zombie_colt":
		case "zombie_doublebarrel":
		case "zombie_mp40":
		case "zombie_ppsh":
		case "zombie_shotgun":
		case "zombie_stg44":
		case "zombie_thompson":
		case "zombie_type100_smg":
		case "m7_launcher_zombie":
		case "tesla_gun":
		case "zombie_bar":
		case "zombie_fg42":
		case	"ray_gun":
			speedScale = 1.5;
		break;
 
		case "zombie_gewehr43":
		case "zombie_kar98k":
		case "zombie_m1carbine":
		case "zombie_m1garand":
		case "zombie_sw_357":
		case "m1garand_gl_zombie":
			speedScale = 1.67;
		break;
 
		case "zombie_mg42":
		case "panzerschrek_zombie":
		case "ptrs41_zombie":
		case "zombie_30cal":
			speedScale = 2;
		break;
 
		case "m2_flamethrower_zombie":
			speedScale = 2.239;
		break;

		//DUKIP - Upgraded weapons can be handled differently.
		case "zombie_colt_upgraded":
		case "zombie_doublebarrel_upgraded":
		case "zombie_mp40_upgraded":
		case "zombie_ppsh_upgraded":
		case "zombie_shotgun_upgraded":
		case "zombie_stg44_upgraded":
		case "zombie_thompson_upgraded":
		case "zombie_type100_smg_upgraded":
		case "m7_launcher_zombie_upgraded":
		case "tesla_gun_upgraded":
		case "zombie_bar_upgraded":
		case "zombie_fg42_upgraded":
		case "ray_gun_upgraded":
			speedScale = 1.5;
		break;
 
		case "zombie_gewehr43_upgraded":
		case "zombie_kar98k_upgraded":
		case "zombie_m1carbine_upgraded":
		case "zombie_m1garand_upgraded":
		case "zombie_sw_357_upgraded":
		case "m1garand_gl_zombie_upgraded":
			speedScale = 1.67;
		break;
 
		case "zombie_mg42_upgraded":
		case "panzerschrek_zombie_upgraded":
		case "ptrs41_zombie_upgraded":
		case "zombie_30cal_upgraded":
			speedScale = 2;
		break;
 
		case "m2_flamethrower_zombie_upgraded":
			speedScale = 2.239;
		break;
 
		default:
			iprintlnbold("Weapon: ^1" + weapon + "^7 has no Stalker speedScale.");
			speedScale = 1;
		break;
	}
	return speedScale;
}

weaponIsScoped(weapon)
{
	hasScope = undefined;
 
	switch(weapon)
	{
		case "ptrs41_zombie":
		case "ptrs41_zombie_upgraded":
			hasScope = true;
		break;
 
		default:
			hasScope = false;
		break;
	}
	return hasScope;
}

//DUKIP - Probably won't be used again, will keep it here for reference.
//Contains missing weapon/bad names.
/*
getNormalSpeedScale(weapon)
{
	speedScale = undefined;
 
	if(maps\_zombiemode_weapons::is_weapon_upgraded(weapon)) 
		weapon = GetSubStr(weapon, 0);
 
	switch(weapon)
	{
		case "zombie_colt":
		case "zombie_doublebarrel":
		case "zombie_mp40":
		case "zombie_ppsh":
		case "zombie_shotgun":
		case "zombie_stg44":
		case "zombie_thompson":
		case "zombie_type100_smg":
		case "m7_launcher_zombie":
		case "tesla_gun":
		case "zomibe_bar":
			speedScale = 1;
		break;
 
		case "zombie_gewehr43":
		case "zombie_kar98k":
		case "zombie_m1carbine":
		case "zombie_m1garand":
		case "zombie_sw_357":
		case "m1_garand_gl_zombie":
			speedScale = 0.9;
		break;
 
		case "zombie_mg42":
		case "panzerschrek_zombie":
		case "ptrs41_zombie":
		case "zombie_30cal":
			speedScale = 0.75;
		break;
 
		case "m2_flamethrower_zombie":
			speedScale = 0.67;
		break;
 
		default:
			ASSERTMSG("Weapon: ^1" + weapon + "^7 has no speedScale in getNormalSpeedScale()");
		break;
	}
	return speedScale;
}*/

// ==========================================================
// Coding Projects
//
// Component: WaW
// Purpose: Code for dropping a weapon through script
//			PROPERLY!!!
//
// Initial author: DidUknowiPwn
// Started: 2014-12-13
//	© 2014 DidUknowiPwn™
// ==========================================================
#include common_scriptsutility;
#include maps\_utility;
#include maps\_zombiemode_utility;
#include maps\_loadout;

init()
{
	level thread onPlayerConnect();
}

onPlayerConnect()
{
	for(;;)
	{
		level waittill("connecting", player);
		player thread onPlayerSpawned();
	}
}

onPlayerSpawned()
{
	self endon("disconnct");
	for(;;)
	{
		self waittill("spawned_player");
		wait 2;
		self thread DropLeWeapon("zombie_kar98k");
	}
}

DropLeWeapon( weapon_name )
{
	weapon = weapon_name;
	item = Spawn( "weapon_" + weapon_name, self.origin + (0,0,12) );
	item SetModel( GetWeaponModel(weapon) );
	clipAmmo = RandomInt( WeaponClipSize(weapon) );
	stockAmmo = RandomIntRange( WeaponClipSize(weapon), WeaponMaxAmmo( weapon ) + 1 );
	stockMax = WeaponMaxAmmo( weapon );
	if ( stockAmmo > stockMax )
		stockAmmo = stockMax;

	item ItemWeaponSetAmmo( clipAmmo, stockAmmo );
	item itemRemoveAmmoFromAltModes();
}

itemRemoveAmmoFromAltModes()
{
	origweapname = self getItemWeaponName();

	curweapname = weaponAltWeaponName( origweapname );

	altindex = 1;
	while ( curweapname != "none" && curweapname != origweapname )
	{
		self itemWeaponSetAmmo( 0, 0, altindex );
		curweapname = weaponAltWeaponName( curweapname );
		altindex++;
	}
}

getItemWeaponName()
{
	classname = self.classname;
	assert( getsubstr( classname, 0, 7 ) == "weapon_" );
	weapname = getsubstr( classname, 7 );
	return weapname;
}

1) Navigate to your WaW folder, raw/english/fonts/ rename the folder to fonts_backup
2) Create a folder called fonts and place the files inside generated inside that folder
3) Navigate to your mods folder, mods/modname/images/ place the image "gamefonts_pc.iwi" inside it
4) Check the image gamefonts_pc.iwi inside IWD List in Launcher
5) Add this in your mod.csv:
font,fonts/bigFont,,
font,fonts/boldFont,,
font,fonts/consoleFont,,
font,fonts/extraBigFont,,
font,fonts/normalFont,,
font,fonts/objectiveFont,,
font,fonts/smallFont,,
6) Compile IWD and mod.ff