_zombiemode_powerups.gsc

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

init()
{
	// 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
	set_zombie_var( "zombie_powerup_turrets_on", 	false );
	set_zombie_var( "zombie_powerup_turrets_time", 30 );	// length of turrets
	set_zombie_var( "zombie_powerup_forcefield_on", 	false );
	set_zombie_var( "zombie_powerup_forcefield_time", 30 );	// length of force fields

	// 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" );
	level._effect["force_field"] 		= loadfx( "misc/zct_forcefield" );
	level._effect["force_field_emitter"] 		= loadfx( "misc/zct_forcefield_emitter" );
  level._effect["force_field_hit"] = loadfx( "misc/zct_force_hit" );
  level._effect[ "self_defence" ] = loadfx( "misc/zct_self_defence" );

  // Define Shaders
	level.powerup_shaders["double_points"] = "zct_x2";
	level.powerup_shaders["insta_kill"] = "zct_instakill";
	level.powerup_shaders["force_field"] = "zct_force_field";
	level.powerup_shaders["turret_defence"] = "zct_turret_defence";

  // Precache Overlays
	PrecacheShader( "zct_x2" );
	PrecacheShader( "zct_instakill" );
	//PrecacheShader( "zct_nuke" );
	PrecacheShader( "zct_maxammo" );
	PrecacheShader( "zct_force_field" );
	PrecacheShader( "zct_turret_defence" );

	thread create_powerup_hud();
  level.powerup_hud_overlay = [];
  level.powerup = [];
	init_powerups();
  init_dont_include_powerup();
	init_include_powerup();
	thread watch_for_drop();
}

init_powerups()
{
	// Random Drops
	/*
	add_zombie_powerup( "fast_reload",  	"zombie_perk_bottle_sleight",	"Sleight Of Hand");
	add_zombie_powerup( "fast_revive",  	"zombie_perk_bottle_sleight",	"Quick Revive");
	add_zombie_powerup( "juggernaut",  	"zombie_perk_bottle_sleight",	"Juggernaut");
	add_zombie_powerup( "fast_rof",  	"zombie_perk_bottle_sleight",	"Double Tapp");
	add_zombie_powerup( "conditioning",  	"zombie_perk_bottle_sleight",	"Quick Revive");
	add_zombie_powerup( "stopping_power",  	"zombie_perk_bottle_sleight",	"Stopping Power");
	*/
	// Non-Standard
	add_zombie_powerup( "melee_damage",  	"zombie_perk_bottle_sleight",	"Quick Revive");
	add_zombie_powerup( "fast_rebuild",  	"zombie_perk_bottle_sleight",	"Fast Rebuild");
	add_zombie_powerup( "self_defence",  	"zombie_perk_bottle_sleight",	"Self Defence");
	add_zombie_powerup( "ammo_regen",  	"zombie_perk_bottle_sleight",	"Ammo Regen");
	// Instant
	add_zombie_powerup( "nuke", 		"zombie_bomb",		&"ZOMBIE_POWERUP_NUKE", 			"misc/fx_zombie_mini_nuke" );
	add_zombie_powerup( "full_ammo",  	"zombie_ammocan",	&"ZOMBIE_POWERUP_MAX_AMMO");
  // Timed Powerups
	add_zombie_powerup( "force_field",  	"zombie_teddybear",	"Force Field");
	add_zombie_powerup( "turret",  	"zombie_teddybear",	"Automatic Turrets");
	add_zombie_powerup( "insta_kill", 	"zombie_skull",		&"ZOMBIE_POWERUP_INSTA_KILL" );
	add_zombie_powerup( "double_points","zombie_x2_icon",	&"ZOMBIE_POWERUP_DOUBLE_POINTS" );

}

init_include_powerup()
{

	//include_powerup( "fast_reload", 100 );
	include_powerup( "nuke", 100 );
	//include_powerup( "fast_revive", 100 );
	include_powerup( "full_ammo", 100 );
	//include_powerup( "juggernaut", 100 );

	include_powerup( "force_field", 100 ); // 5
	//include_powerup( "fast_rof", 100 );
	include_powerup( "turret", 100 ); // 5
	//include_powerup( "stopping_power", 70 );
	include_powerup( "insta_kill", 100 ); // 15
	//include_powerup( "conditioning", 100 );
	include_powerup( "double_points", 50 ); // 15
	/*
	include_powerup( "melee_damage", 70 );
	include_powerup( "fast_rebuild", 100 ); //10
	include_powerup( "self_defence", 50 );
	include_powerup( "ammo_regen", 50 ); //10
	*/
}

init_dont_include_powerup()
{
	if( !IsDefined( level.zombie_remove_powerups ) )
		level.zombie_remove_powerups = [];
  // Defined in map
  exclude_by_map = GetStructArray("disable_powerup","targetname"); // continue here, fetch excludes
  for(i=0; i<exclude_by_map.size; i++)
    level.zombie_remove_powerups[exclude_by_map[i].script_noteworthy] = true;
  // special turrets, if they aren't there, remove the powerup.
  turrets = GetEntArray("support_turret","targetname");
  if(turrets.size < 1)
    level.zombie_remove_powerups["turret"] = true;
  else
  {
    for(i=0; i<turrets.size; i++)
    {
      turrets[i] MakeTurretUnusable();
    }
  }
  // Force Fields
  forcefields = GetStructArray("force_field","targetname");
  if(forcefields.size < 1)
    level.zombie_remove_powerups["force_field"] = true;
  // Remove Bob The Builder if there are no blockers
  barricades = getstructarray( "exterior_goal", "targetname" );
  barricade_disable = true;
  for(i=0; i<barricades.size; i++)
  {
    if(IsDefined(barricades[i].target) && barricade_disable)
      barricade_disable = false;
  }
  if(barricade_disable)
    level.zombie_remove_powerups["fast_rebuild"] = true;
}

include_powerup( powerup_name, weight )
{
	if( !IsDefined( level.zombie_powerup_total_weight ) )
    level.zombie_powerup_total_weight = 0;
	if( !IsDefined( level.zombie_include_powerups ) )
		level.zombie_include_powerups = [];
  if( !IsDefined( level.zombie_remove_powerups[powerup_name] ))
  {
    level.zombie_include_powerups[powerup_name] = weight;
    level.zombie_powerup_total_weight = level.zombie_powerup_total_weight + weight;
  }
}

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 = [];
	}

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

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

get_next_powerup()
{
// WoO, update this to use a weight system.. pick at random.
// Add failsafe for last 2 powerups dropped.. so it won't drop the same 2 in 3 powerups.
  powerup_random = randomint(level.zombie_powerup_total_weight);
  powerup = "";
  keys = array_randomize( GetArrayKeys(level.zombie_include_powerups) );

  while(powerup == "")
  {
    for(i=0; i<keys.size; i++)
    {
      if(powerup_random < level.zombie_include_powerups[keys[i]])
      {
        powerup = keys[i];
        break;
      }
      else
      {
        powerup_random = powerup_random - level.zombie_include_powerups[keys[i]];
      }
    }
    // Done, failsafe, test.
    if(IsDefined(level.powerup[1]) && powerup == level.powerup[1])
      powerup = "";
    if(IsDefined(level.powerup[2]) && powerup == level.powerup[2])
      powerup = "";
    wait(0.01);
  }
  if(IsDefined(level.powerup[1]))
    level.powerup[2] = level.powerup[1];
  level.powerup[1] = powerup;
	return powerup;
}

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.05;
			score_to_drop = curr_total_score + level.zombie_vars["zombie_powerup_drop_increment"];
      // Added By WoO - Prevent Drop On Mass Kill
      if( !IsDefined( level.wro["disable_powerups"] ) )
        level.wro["disable_powerups"] = false;
      if( level.wro["disable_powerups"] == false )
      {
  			level.zombie_vars["zombie_drop_item"] = 1;
  		}
		}
    // WoO : Testing, Remove=============================================================================
  	// level.zombie_vars["zombie_drop_item"] = 1;
		wait( 0.5 );
	}
}

include_zombie_powerup( powerup_name )
{
  /*
  OBSOLETE, BUT REFERENCED IN MAPS, DOES NOTHING
  ALL POWERUPS ADDED UNLESS SPECIFIED IN THE MAP ITSELF.
	*/
}

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

	// 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;
		}
  	level.zombie_vars["zombie_drop_item"] = 0;
		debug = "score";
	}
	else
	{
  	level.zombie_vars["zombie_drop_item"] = 0;
		debug = "random";
	}

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

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

	for (i = 0; i < playable_area.size; i++)
	{
		if (!powerup istouching(playable_area[i]))
		{
			powerup delete();
    	level.zombie_vars["zombie_drop_item"] = 1;
			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();


}

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

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 && !(players[i].is_zombie || players[i] maps\_laststand::player_is_in_laststand() || players[i].sessionstate == "spectator"))
			{
				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
				{
				  level.zct[ "power_up_text" ] = players[i].playername;
					switch (self.powerup_name)
					{
						case "nuke":
							level thread nuke_powerup( self, players[i] );
							break;
						case "full_ammo":
							level thread full_ammo_powerup( self );
							break;
						case "double_points":
							level thread double_points_powerup( self );
							break;
						case "insta_kill":
							level thread insta_kill_powerup( self );
							break;
						case "turret":
							level thread turrets_powerup( self );
							break;
						case "force_field":
							level thread force_field_powerup( self, players[i] );
							break;
							/*
						case "fast_reload":
							level thread find_free_perk( players[i], "specialty_fastreload" );
							break;
						case "fast_revive":
							level thread find_free_perk( players[i], "specialty_quickrevive" );
							break;
						case "juggernaut":
							level thread find_free_perk( players[i], "specialty_armorvest" );
							break;
						case "fast_rof":
							level thread find_free_perk( players[i], "specialty_rof" );
							break;
						case "stopping_power":
							level thread find_free_perk( players[i], "specialty_bulletdamage" );
						 	break;
						case "conditioning":
							level thread find_free_perk( players[i], "specialty_longersprint" );
						 	break;
						case "fast_rebuild":
							level thread find_free_perk( players[i], "specialty_extraammo" );
						 	break;
						case "melee_damage":
							level thread find_free_perk( players[i], "specialty_quieter" );
						 	break;
						case "ammo_regen":
							level thread find_free_perk( players[i], "specialty_holdbreath" );
						 	break;
						case "self_defence":
							level thread find_free_perk( players[i], "specialty_detectexplosive" );
						 	break;
						*/
						default:
							IPrintLN ("Unrecognized powerup.");
						break;
					}
				}

				wait( 0.1 );

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

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

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

nuke_powerup( drop_item, player )
{
  level.zct[ "power_up_image" ] = "zct_nuke";
	level notify( "zct_powerup_hud_change" );

  zombies = getaiarray("axis");

	PlayFx( drop_item.fx, drop_item.origin );
	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( i < 5 )
		{
			zombies[i] thread animscripts\death::flame_death_fx();
		}
    player maps\_zombiemode_score::add_to_player_score( level.zombie_vars["zombie_score_damage"] * 10 * level.zombie_vars["zombie_point_scalar"] );
		zombies[i] maps\_zombiemode_spawner::zombie_head_gib();

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

nuke_flash()
{
	playsoundatposition("nuke_flash", (0,0,0));

	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.6;

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

	wait 1.1;
	fadetowhite destroy();
}

full_ammo_powerup( drop_item )
{
  level.zct[ "power_up_image" ] = "zct_maxammo";
	level notify( "zct_powerup_hud_change" );

  players = get_players();

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

		for( x = 0; x < primaryWeapons.size; x++ )
		{
			players[i] GiveMaxAmmo( primaryWeapons[x] );
		}
	}
	players = get_players();

	for (i = 0; i < players.size; i++)
	{
		players[i] playsound ("full_ammo");
	}
}

insta_kill_powerup( drop_item )
{
  level.zct[ "power_up_image" ] = "zct_instakill";
	level notify( "zct_powerup_hud_change" );

  level notify( "powerup instakill" );
	level endon( "powerup instakill" );

	level thread insta_kill_on_hud( drop_item );
	level.zombie_vars["zombie_insta_kill"] = 1;
	wait( 30 );
	level.zombie_vars["zombie_insta_kill"] = 0;
}

check_for_instakill( player, damage )
{
	if( IsDefined( player ) && IsAlive( player ) && level.zombie_vars["zombie_insta_kill"])
	{
		self maps\_zombiemode_spawner::zombie_head_gib();
		self DoDamage( self.health + 666, self.origin, player );
	}
	// add a check here for stopping power, increase damage * 1.25

}

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;
  level thread powerup_create_hud_overlay( "insta_kill", "zombie_powerup_insta_kill_time" );
	level thread time_remaning_on_insta_kill_powerup();

}

time_remaning_on_insta_kill_powerup()
{

	temp_enta = spawn("script_origin", (0,0,0));
	temp_enta playloopsound("insta_kill_loop");

	while ( level.zombie_vars["zombie_powerup_insta_kill_time"] >= 0)
	{
		wait 1;
		level.zombie_vars["zombie_powerup_insta_kill_time"] = level.zombie_vars["zombie_powerup_insta_kill_time"] - 1;
	}

	players = get_players();
	for (i = 0; i < players.size; i++)
	{
		players[i] playsound("insta_kill");
	}

	temp_enta stoploopsound(2);
	level.zombie_vars["zombie_powerup_insta_kill_on"] = false;
	level.zombie_vars["zombie_powerup_insta_kill_time"] = 30;
	temp_enta delete();
}

// double the points
double_points_powerup( drop_item )
{
  level.zct[ "power_up_image" ] = "zct_x2";
	level notify( "zct_powerup_hud_change" );

  level notify ("powerup points scaled");
	level endon ("powerup points scaled");

	level thread point_doubler_on_hud( drop_item );

	level.zombie_vars["zombie_point_scalar"] *= 2;

	wait 30;

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

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

	if ( level.zombie_vars["zombie_powerup_point_doubler_on"] )
	{
		level.zombie_vars["zombie_powerup_point_doubler_time"] = 30;
		return;
	}

	level.zombie_vars["zombie_powerup_point_doubler_on"] = true;
  level thread powerup_create_hud_overlay( "double_points", "zombie_powerup_point_doubler_time" );
	level thread time_remaining_on_point_doubler_powerup();

}

time_remaining_on_point_doubler_powerup()
{

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

	while ( level.zombie_vars["zombie_powerup_point_doubler_time"] >= 0)
	{
		wait 1;
		level.zombie_vars["zombie_powerup_point_doubler_time"] = level.zombie_vars["zombie_powerup_point_doubler_time"] - 1;
	}

	level.zombie_vars["zombie_powerup_point_doubler_on"] = false;
	players = get_players();
	for (i = 0; i < players.size; i++)
	{
		players[i] playsound("points_loop_off");
	}
	temp_ent stoploopsound(2);

	level.zombie_vars["zombie_powerup_point_doubler_time"] = 30;
	temp_ent delete();
}

// forcefield powerup
force_field_powerup( drop_item, player )
{
  level.zct[ "power_up_image" ] = "zct_force_field";
  level notify( "zct_powerup_hud_change" );

	level notify ("powerup forcefield");
	level endon ("powerup forcefield");

	level thread force_field_on_hud( drop_item, player );

	wait 30;
}

force_field_on_hud( drop_item, player )
{
	self endon ("disconnect");

	if ( level.zombie_vars["zombie_powerup_forcefield_on"] )
	{
		// level.zombie_vars["zombie_powerup_forcefield_time"] = 30;
		return;
	}
  // thread the forcefield powerup here..
  level thread force_field_active( player );
	level.zombie_vars["zombie_powerup_forcefield_on"] = true;
  level thread powerup_create_hud_overlay( "force_field", "zombie_powerup_forcefield_time" );
	level thread time_remaining_on_force_field_powerup();

}

time_remaining_on_force_field_powerup()
{

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

	while ( level.zombie_vars["zombie_powerup_forcefield_time"] >= 0)
	{
		wait 1;
		level.zombie_vars["zombie_powerup_forcefield_time"] = level.zombie_vars["zombie_powerup_forcefield_time"] - 1;
	}

	level.zombie_vars["zombie_powerup_forcefield_on"] = false;
	players = get_players();
	for (i = 0; i < players.size; i++)
	{
		players[i] playsound("points_loop_off");
	}
	temp_ent stoploopsound(2);

	level.zombie_vars["zombie_powerup_forcefield_time"] = 30;
	temp_ent delete();
}

// All new, forcefields
force_field_active( player )
{
  activefx_field = [];
  activefx_emitter = [];
  force_field_damage = [];
  forcefields = GetStructArray("force_field", "targetname");
  for(i=0; i<forcefields.size; i++)
  {
    if(Distance( player.origin, forcefields[i].origin) < 1024)
    {
  // Rewrite cuz X was fuckin me up..
      // play sound FX here, once per barricade.
      playsoundatposition("zct_defence_barriers", forcefields[i].origin);
      forcefields[i] thread play_loop_sound_on_entity( "zct_barrier_hum", (0, 0, 0) );
      forcefields[i].active = true;
      activefx_field[i] = PlayLoopedFX(level._effect["force_field"],2, forcefields[i].origin, 0, AnglesToForward( forcefields[i].angles ) );
      force_emitter = GetEnt(forcefields[i].target,"targetname");
      activefx_emitter[i] = PlayLoopedFX(level._effect["force_field_emitter"],2, force_emitter.origin, 0, AnglesToForward( forcefields[i].angles ) );
      // spawn a trigger_radius here for monitor
      force_field_damage[i] = Spawn("trigger_radius", forcefields[i].origin - (0, 0, int(forcefields[i].script_noteworthy) ), 0, int(forcefields[i].script_noteworthy), int(forcefields[i].script_noteworthy)*2 );
      force_field_damage[i] thread force_field_monitor( player );
    }
  }
  wait(30); // non renewable.. by choice. if you hit a second one in a different position, it will activate a few
            // but we will call this a "cool down" that is required.
  for(i=0; i<forcefields.size; i++)
  {
    if(IsDefined(forcefields[i].active) && forcefields[i].active)
    {
      force_field_damage[i] notify("destroyed");
      force_field_damage[i] Delete();
      activefx_field[i] Delete();
      activefx_emitter[i] Delete();
      forcefields[i] thread stop_loop_sound_on_entity( "zct_barrier_hum" );
    }
  }
}

force_field_monitor( player )
{
  self endon("destroyed");
  afflicted = [];
  while(1)
  {
    ai = GetAIArray( "axis" );
    for(i=0; i<ai.size; i++)
    {
      ai_id = ai[i] GetEntityNumber();
      if(ai[i] IsTouching( self ) && !IsDefined(afflicted[ai_id]) )
      {
        // need to flag/kill phaze shifters who try to cross
        tmphealth = ai[i].health;
        if(IsDefined(ai[i].phazed) && ai[i].phazed == "1")
        {
          ai[i] notify("unphase");
          wait(0.2);
        }
        ai[i] DoDamage( (ai[i].health / 7), self.origin, player, "MOD_PISTOL_BULLET");
        // ai[i].health = ai[i].health/2;
        // maps\woo_toolkit::debug_print_ln("Damage, Now " + ai[i].health + " : Was " + tmphealth);
        afflicted[ai_id] = true;
        PlayFX(level._effect["force_field_hit"], ai[i].origin + (0, 0, 40) );
        playsoundatposition("zct_barrier_hit", ai[i].origin);
        // set fire?
      }
    }
    wait(0.01);
  }
}

// Turrets powerup
turrets_powerup( drop_item, player )
{
  level.zct[ "power_up_image" ] = "zct_turret_defence";
  level notify( "zct_powerup_hud_change" );

	level notify ("powerup turrets");
	level endon ("powerup turrets");
	level thread turrets_on_hud( drop_item, player );

	// wait 30;
}

turrets_on_hud( drop_item, player )
{
	self endon ("disconnect");

	if ( level.zombie_vars["zombie_powerup_turrets_on"] )
	{
		level.zombie_vars["zombie_powerup_turrets_time"] = 30;
		return;
	}
  // thread the turret powerup here..
  level thread turrets_active( player );
	level.zombie_vars["zombie_powerup_turrets_on"] = true;
  level thread powerup_create_hud_overlay( "turret_defence", "zombie_powerup_turrets_time" );
	level thread time_remaining_on_turrets_powerup();

}

time_remaining_on_turrets_powerup()
{

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

	while ( level.zombie_vars["zombie_powerup_turrets_time"] >= 0)
	{
		wait 1;
		level.zombie_vars["zombie_powerup_turrets_time"] = level.zombie_vars["zombie_powerup_turrets_time"] - 1;
	}

	level.zombie_vars["zombie_powerup_turrets_on"] = false;
	/*players = get_players();
	for (i = 0; i < players.size; i++)
	{
		players[i] playsound("points_loop_off");
	}
	temp_ent stoploopsound(2);*/
  level notify("turrets off");
	level.zombie_vars["zombie_powerup_turrets_time"] = 30;
	// temp_ent delete();
}

turrets_active(player)
{
  turrets = GetEntArray("support_turret", "targetname");
  for(i=0;i<turrets.size;i++)
  {
    playsoundatposition("zct_defence_turrets", turrets[i].origin);
    turrets[i].script_delay_min = 0.001;
    turrets[i].script_delay_max = 0.005;
    // turrets[i].script_burst_min = 0.2;
    // turrets[i].script_burst_max = 0.3;
  	turrets[i] setTurretTeam( "allies" );
  	turrets[i] SetMode( "auto_nonai" );
    turrets[i] thread maps\_mgturret::burst_fire_unmanned();
    turrets[i] thread turret_alarm();
  }

  level waittill("turrets off");

  for(i=0;i<turrets.size;i++)
  {
  	turrets[i] notify("stop_burst_fire_unmanned");
  	turrets[i] SetMode( "manual" );
    turrets[i] stop_loop_sound_on_entity( "zct_turret_alarm" );
  }
}

turret_alarm()
{
  wait(3);
	self play_loop_sound_on_entity( "zct_turret_alarm", (0, 0, 0) );
}

powerup_create_hud_overlay( powerup, zombievar )
{
  // need to recreate this properly.
	level.powerup_hud_overlay[powerup] = create_simple_hud();
	level.powerup_hud_overlay[powerup].foreground = true;
	level.powerup_hud_overlay[powerup].sort = 2;
	level.powerup_hud_overlay[powerup].hidewheninmenu = false;
	level.powerup_hud_overlay[powerup].alignX = "right";
	level.powerup_hud_overlay[powerup].alignY = "top";
	level.powerup_hud_overlay[powerup].horzAlign = "right";
	level.powerup_hud_overlay[powerup].vertAlign = "top";
	level.powerup_hud_overlay[powerup].x = -11;
	level.powerup_hud_overlay[powerup].y = 35 + ((level.powerup_hud_overlay.size - 1) * 35);
	// level.powerup_hud_overlay[powerup].alpha = 0.8;
  // level.powerup_positions[powerup] = powerup_hud.size -1;


	while ( level.zombie_vars[zombievar] > 0)
	{
  	level.powerup_hud_overlay[powerup].alpha = 1;
  	level.powerup_hud_overlay[powerup] setshader(level.powerup_shaders[powerup], 32, 32);

		if(level.zombie_vars[zombievar] < 5)
		{
			wait(0.1);
			level.powerup_hud_overlay[powerup].alpha = 0;
			wait(0.1);
		}
		else if(level.zombie_vars[zombievar] < 10)
		{
			wait(0.2);
			level.powerup_hud_overlay[powerup].alpha = 0;
			wait(0.18);
		}
    wait(0.05);
	}
	// remove the hud.
	level.powerup_hud_overlay[powerup] Destroy();
	level.powerup_hud_overlay[powerup] = undefined;
  // resort the powerup hud
	resort_powerup_hud_overlay();

}

resort_powerup_hud_overlay()
{
  keys = GetArrayKeys(level.powerup_hud_overlay);
  for(i=0; i<keys.size; i++)
  {
    level.powerup_hud_overlay[keys[i]].y = 35 + (i * 35);
  }
}

// -----------------------------------------------------------------------------
// ---- Mike adding some crap in here for perks.                            ----
// -----------------------------------------------------------------------------
/*
find_free_perk( player, preferred )
{
  // appears they had the perk, find a free one.
  perk_given = "";
  perks_free = [];
  perks_available = [];
  if(!player HasPerk(preferred))
  {
    perk_given = preferred;
  }
  // only pick from ones that are enabled..
  if( !IsDefined( level.zombie_remove_powerups["fast_reload"] ))
    perks_available["specialty_fastreload"] = "zct_slight";

  if( !IsDefined( level.zombie_remove_powerups["fast_revive"] ))
    perks_available["specialty_quickrevive"] = "zct_quickrevive";

  if( !IsDefined( level.zombie_remove_powerups["juggernaut"] ))
    perks_available["specialty_armorvest"] = "zct_jugg";

  if( !IsDefined( level.zombie_remove_powerups["fast_rof"] ))
    perks_available["specialty_rof"] = "zct_doubletap";

  if( !IsDefined( level.zombie_remove_powerups["stopping_power"] ))
    perks_available["specialty_bulletdamage"] = "zct_stoppower";

  if( !IsDefined( level.zombie_remove_powerups["conditioning"] ))
    perks_available["specialty_longersprint"] = "zct_extremecon";

  if( !IsDefined( level.zombie_remove_powerups["fast_rebuild"] ))
    perks_available["specialty_extraammo"] = "zct_fast_rebuild";

  if( !IsDefined( level.zombie_remove_powerups["melee_damage"] ))
    perks_available["specialty_quieter"] = "zct_melee";

  if( !IsDefined( level.zombie_remove_powerups["ammo_regen"] ))
    perks_available["specialty_holdbreath"] = "zct_ammo_regen";

  if( !IsDefined( level.zombie_remove_powerups["self_defence"] ))
    perks_available["specialty_detectexplosive"] = "zct_self_defence";

 	players = get_players();
  if(perk_given == "")
  {
    keys = GetArrayKeys( perks_available );
    for(i=0; i<keys.size; i++)
    {
      if(!player HasPerk( keys[i] ))
      {
        perks_free[keys[i]] = true;
        maps\woo_toolkit::debug_print_ln(" Does Not Have " + keys[i]);
      }
      else
      {
        maps\woo_toolkit::debug_print_ln(" Has " + keys[i]);
      }
    }
    if(perks_free.size < 1 && players.size > 1)
    {
      level.zct[ "power_up_image" ] = "zct_maxammo";
      level.zct[ "power_up_text" ] = " Except " + player.playername + ", Perk Whore";
    	level notify( "zct_powerup_hud_change" );
    	for (i = 0; i < players.size; i++)
    	{
        if(players[i] != player)
        {
      		primaryWeapons = players[i] GetWeaponsListPrimaries();

      		for( x = 0; x < primaryWeapons.size; x++ )
      		{
      			players[i] GiveMaxAmmo( primaryWeapons[x] );
      		}
    		}
    	}
      // max ammo - player, perk whore.
    }
    if(perks_free.size < 1 && players.size == 1)
    {
      if(level.zct[ "power_up_image" ] != "zct_maxammo")
      {
        level.zct[ "power_up_image" ] = "zct_maxammo";
        level.zct[ "power_up_text" ] = player.playername;
      	level notify( "zct_powerup_hud_change" );
      	for (i = 0; i < players.size; i++)
      	{
      		primaryWeapons = players[i] GetWeaponsListPrimaries();

      		for( x = 0; x < primaryWeapons.size; x++ )
      		{
      			players[i] GiveMaxAmmo( primaryWeapons[x] );
      		}
      	}
    	}
    }
    else
    {
      keys = GetArrayKeys( perks_free );
      perk_given = keys[ RandomInt( keys.size ) ];
    }
  }
  if(perk_given != "")
  {
    player maps\_zombiemode_perks_woo::setup_perk (perk_given);
    level.zct[ "power_up_image" ] = perks_available[perk_given];
    level notify( "zct_powerup_hud_change" );
  }
}
*/

create_powerup_hud()
{
  current_image = "";
  current_text = "";

	powerup_hud = create_simple_hud();
	powerup_hud.foreground = true;
	powerup_hud.sort = 2;
	powerup_hud.hidewheninmenu = false;
	powerup_hud.alignX = "left";
	powerup_hud.alignY = "top";
	powerup_hud.horzAlign = "left";
	powerup_hud.vertAlign = "top";
	powerup_hud.x = 70; //  + (i * 15);
	powerup_hud.y = 20;
	powerup_hud.alpha = 0.8;

	powerup_hud_text = create_simple_hud();
	powerup_hud_text.foreground = true;
	powerup_hud_text.sort = 2;
	powerup_hud_text.hidewheninmenu = false;
	powerup_hud_text.alignX = "left";
	powerup_hud_text.alignY = "top";
	powerup_hud_text.horzAlign = "left";
	powerup_hud_text.vertAlign = "top";
	powerup_hud_text.fontScale = 8;
	powerup_hud_text.x = 92; //  + (i * 15);
	powerup_hud_text.y = 18;
	// powerup_hud_text.alpha = 0.8;

  while(1)
  {

    level waittill( "zct_powerup_hud_change" );

    if( IsDefined( level.zct[ "power_up_image" ] ) )
    {
  		powerup_hud.alpha = 1;
  		powerup_hud setshader(level.zct[ "power_up_image" ], 16, 16);
		}
    if( IsDefined( level.zct[ "power_up_text" ] ) )
    {
  		powerup_hud_text.label = level.zct[ "power_up_text" ];
		}
		wait(0.05);
  }
}
//
// 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( "======================================" );
#/
}