////START GENERATOR SCRIPT////
function generators_init()
{
	//IMPORTANT RADIANT INSTRUCTIONS//
	//for a generator to activate a lander, the purchase trigger must have the same script_string as the lander (for example, loc_1)
	//for activating perks, the purchase trigger must have the key perk_to_power_one, perk_to_power_two, etc. for however many perks to power.
	// values that I know of for that: juggernog, sleight, revive, doubletap
	//Values that I think should work: electric_cherry, deadshot, marathon, widows_wine


	players = GetPlayers();
	wait(10);
	level.gen_zombies = 10;	//zombies that spawn when using generator
	level.gen_cost = 250;	//generator cost
	level.in_between_spawns_time = 0.5;	//time in between spawns; cannot be zero


	level.generators_complete = 0;
	level.generators = 0;

	trigs = GetEntArray("generator_trig","targetname");
	for(i=0;i<trigs.size;i++)
	{
		trigs[i] thread watch_for_gen_use();
		level.generators ++;
	}
}
function watch_for_gen_use()
{
	self endon("gen_fail");
	while(1)
	{
		self.players_in_trig = 0;
		self  SetHintString( "Press and Hold ^3[{+activate}]^7 to Activate Generator [Cost:" + level.gen_cost + "]");
		self waittill("trigger",player);
		if(player.score >= level.gen_cost)
		{
			player zm_score::minus_to_player_score(level.gen_cost);
			self SetHintString( "Generator Active");
			trig = GetEnt(self.target,"targetname");
			doors = GetEntArray(trig.target,"targetname");
			gen_zombie_spawns = Struct::Get_Array(doors[0].target,"targetname");
			for(i=0;i<doors.size;i++)
			{
				doors[i] MoveTo(doors[i].origin + doors[i].script_vector, 1);
			}
			foreach(player in level.players)
			{
				if(player isTouching(trig))
				{
					self thread check_for_gen_fail( player );
					self.players_in_trig ++;
				}
			}
			self.gen_zombies_to_spawn = (level.gen_zombies * self.players_in_trig);
			self thread spawn_gen_zombies( gen_zombie_spawns );
			self.players_downed = 0;

			IPrintLnBold(self.players_in_trig + " player(s) near generator");

			IPrintLnBold(self.gen_zombies_to_spawn + " zombies to spawn");

			self waittill("gen_done");
			IPrintLnBold("Generator Complete");

			for(i=0;i<doors.size;i++)
			{
				doors[i] MoveTo(doors[i].origin - doors[i].script_vector, 1);
			}
			self Delete();
			foreach(player in level.players)
			{
				if(player isTouching(trig))
				{
					player zm_score::add_to_player_score(500);
				}
			}
			self thread power_me_up_baby();

			level.generators_complete ++;
			if(level.generators_complete == level.generators)
			{
				level notify("all_generators_complete");
				IPrintLnBold("all generators complete");
			}

		}
	}
}
function spawn_gen_zombies( gen_zombie_spawns )
{


	self endon("gen_fail");
	spawner = GetEnt("generator_spawner","targetname");
	self.zombies_dead = 0;
	zombos_spawned = 0;
	IPrintLnBold("huh");
	IPrintLnBold(self.gen_zombies_to_spawn);
	while(zombos_spawned < self.gen_zombies_to_spawn)
	{
		IPrintLnBold("ok");
		rand = RandomIntRange( 0, gen_zombie_spawns.size );
		IPrintLnBold(rand + " spawner selected");
		zombie = zombie_utility::spawn_zombie( spawner, "zombie" ,gen_zombie_spawns[rand] );

		zombie thread zombie_utility::set_zombie_run_cycle( "sprint" );


		self thread check_for_gen_zombie_death( zombie );
		zombos_spawned ++;
		wait(level.in_between_spawns_time);
	}
}
function check_for_gen_zombie_death( zombie )
{
	zombie waittill("death");
	self.zombies_dead ++;
	IPrintLnBold(self.zombies_dead + " zombies dead");
	if(self.zombies_dead == self.gen_zombies_to_spawn)
	{
		self notify("gen_done");
	}
}
function check_for_gen_fail( player )
{
	self endon("gen_done");
	player waittill( "player_downed" );
	self.players_downed ++;
	if(self.players_downed == self.players_in_trig)
	{
		 self notify("gen_fail");
		 IPrintLnBold("Generator Failed");
		 self thread watch_for_gen_use();
	}
}
function power_me_up_baby()
{
	IPrintLnBold("power_me_up_baby");
	if(isDefined(self.perk_to_power_one))
	{
		level notify( self.perk_to_power_one + "_on" );
		IPrintLnBold(self.perk_to_power_one);
		util::wait_network_frame();
	}
	if(isDefined(self.perk_to_power_two))
	{
		level notify( self.perk_to_power_two + "_on" );
		util::wait_network_frame();
	}
	if(isDefined(self.perk_to_power_three))
	{
		level notify( self.perk_to_power_three + "_on" );
		util::wait_network_frame();
	}
	if(isDefined(self.perk_to_power_four))
	{
		level notify( self.perk_to_power_four + "_on" );
		util::wait_network_frame();
	}
	if(isDefined(self.perk_to_power_five))
	{
		level notify( self.perk_to_power_five + "_on" );
		util::wait_network_frame();
	}
	if(isDefined(self.script_string))
	{
		lander_trig = GetEnt(self.script_string,"script_string");
		lander_trig notify("lunar_lander_power_on");
	}
	//if(isDefined(self.target))
	//{
	//	self.target notify("lunar_lander_power_on");
	//}
}

////START ICE BOSS SCRIPT////
function ice_special_round()
{
	while(level.boss_round_active)
	{
		wait(0.05);
	}
}
function ice_boss_init()
{
	wait(10);
	level.boss_damage = 25; 	//amount of damage boss does
	level.boss_damage_time = 0.5;	 //how much time in between "hits" in seconds
	level.boss_damage_radius = 150;		//damaging radius
	level.speed = 100;		//speed variable for boss. Higher number, higher speed.
	level.hits_to_kill_boss = 3; 	//how many hits it takes to get to the center of a tootsie pop. Should be same number as amount of fire traps.
	level.seconds_of_silence = 2;		//time after boss spawns before he starts chasing people.
	level.time_before_bunker_doors_open = 5;	//exactly what you think it is
	level.ice_time_to_move = 2;		//how long various "ice" objects take to move, if they have a script_vector

	level.boss_round_active = false;
	level.only_bad_crumbs = false;
	ice = GetEntArray("ice","targetname");	//don't touch this. It's what hides the Ice effect intitially.
	for(i=0;i<ice.size;i++)
	{
		ice[i] Hide();
	}
	wait(5);



	thread ice_boss_round( 2 ); //here is where you put the rounds you want to be ice rounds. just copy and past the line and put the number of the round you want inside the parenthesis.
	thread ice_boss_round( 4 );
	thread ice_boss_round( RandomIntRange( 5, 6 ) ); //you can also randomize between two rounds if you want. In this example he could come at round 5 or 6.
	thread ice_boss_round( 7 );

	thread fire_trap_init();
}
function ice_boss_round( ice_round_number )
{

	while(1)
	{
		level waittill( "end_of_round" );
		IPrintLnBold("round " + (level.round_number + 1));
		if((level.round_number + 1) == ice_round_number)
		{
			level.boss_round_active = true;

			level flag::clear( "spawn_zombies" );
			level notify("boss_round");
			players = GetPlayers();
			ice_round_spawns = Struct::Get_Array("ice_round_spawn","targetname");

			ice = GetEntArray("ice","targetname");
			for(i=0;i<ice.size;i++)
			{
				ice[i] Show();
				if(isDefined(ice[i].script_vector))
				{
					ice[i] MoveTo(ice[i].origin + ice[i].script_vector, level.ice_time_to_move);
				}
			}


			for(i=0;i<players.size;i++)
			{
				players[i] DontInterpolate();
				players[i] SetOrigin( ice_round_spawns[i].origin);
				players[i] SetPlayerAngles( ice_round_spawns[i].angles );
			}
			bunker_door = GetEntArray("bunker_door","targetname");
			for(i=0;i<bunker_door.size;i++)
			{
				bunker_door[i] MoveTo(bunker_door[i].origin + bunker_door[i].script_vector, 0.05);
			}
			wait(level.seconds_of_silence);
			thread spawn_ice_boss();
			level flag::set( "spawn_zombies" );
			wait(level.time_before_bunker_doors_open);
			for(i=0;i<bunker_door.size;i++)
			{
				bunker_door[i] MoveTo(bunker_door[i].origin - bunker_door[i].script_vector, 2);
			}
		}
		else
		{
			wait(1);
		}
	}
}
function spawn_ice_boss()
{
	level.boss_spawns = Struct::Get_array("boss_spawn","targetname");
	rand = RandomIntRange( 0, level.boss_spawns.size );
	level.boss = util::spawn_model( "tag_origin", level.boss_spawns[rand].origin);
	PlayFxOnTag( BOSS_FX, level.boss, "tag_origin");
	level.boss.alive = true;
	level.boss.ice_boss = true;
	level.boss.hits = 0;

	wait(2);

	level.boss thread damage_players();
	level.boss thread player_breadcrumbs();
	level.boss check_for_da_damage();

}
function check_for_da_damage()
{
	while(1)
	{
		level waittill("boss_has_been_hit");
		IPrintLnBold("boss_has_been_hit");
		wait(1);
		if(self.hits == level.hits_to_kill_boss)
		{
			IPrintLnBold("boss killed");
			self notify("boss_dead");

			level.boss_round_active = false;

			self Delete();
			level.bosses_dead ++;
			level notify("boss_round_over");
			ice = GetEntArray("ice","targetname");
			for(i=0;i<ice.size;i++)
			{

				if(isDefined(ice[i].script_vector))
				{
					ice[i] MoveTo(ice[i].origin - ice[i].script_vector, level.ice_time_to_move);
				}
				wait(level.ice_time_to_move);
				ice[i] Hide();
			}
		}
		else
		{
			self thread player_breadcrumbs();
		}

	}
}
function fire_trap_init()
{
	level.fire_trap_cost = 500;	//cost
	level.fire_trap_time = 20;	//how long it is active for one use
	level.trap_cooldown_time = 10;	//how long trap is cooling down before you can use it again.

	trigs = GetEntArray("fire_trap_trig","targetname");
	//for(i=0;i<trigs.size;i++)
	//{
	//	trigs[i] SetHintString( &"ZOMBIE_NEED_POWER");
	//}
	//level flag::wait_till("power_on");
	while(1)
	{
		for(i=0;i<trigs.size;i++)
		{
			trigs[i] thread activation();
		}
		level waittill("boss_round");
		for(i=0;i<trigs.size;i++)
		{
			trigs[i] thread boss_round_activation();
		}
		level waittill("boss_round_over");
	}
}
function activation()
{

	level endon("boss_round");
	while(1)
	{
		self SetHintString( "Press and Hold ^3[{+activate}]^7 to Activate Trap [Cost:" + level.fire_trap_cost + "]");
		self waittill("trigger",player);
		if(player.score >= level.fire_trap_cost)
		{
			player zm_score::minus_to_player_score(level.fire_trap_cost);
			self SetHintString( "Fire Trap Active");
			hurt_trig = GetEnt(self.target,"targetname");
			fire_orgs = Struct::Get_Array(hurt_trig.target,"targetname");
			for(i=0;i<fire_orgs.size;i++)
			{

				fireorg[i] = util::spawn_model( "tag_origin", fire_orgs[i].origin);
				PlayFxOnTag( FIRE_TRAP_FX, fireorg[i], "tag_origin");
				//IPrintLnBold(fireorg[i].origin);
				fireorg[i] thread firetrap_check_yo_self();
			}
			hurt_trig thread check_for_creatures();
			wait(level.fire_trap_time);
			hurt_trig notify("trap_over");
			for(i=0;i<fire_orgs.size;i++)
			{
				fireorg[i] notify("trap_over");
				fireorg[i] Delete();
			}
			wait(level.trap_cooldown_time);
		}
		wait(0.05);
	}
}
function firetrap_check_yo_self()
{
	self endon("trap_over");
	level waittill("boss_round");
	self Delete();
}
function boss_round_activation()
{

	self SetHintString( "Press and Hold ^3[{+activate}]^7 to Activate Trap");
	self waittill("trigger",player);

	self SetHintString( "Fire Trap Active");
	hurt_trig = GetEnt(self.target,"targetname");
	hurt_trig.already_got_him = false;
	fire_orgs = Struct::Get_Array(hurt_trig.target,"targetname");
	for(i=0;i<fire_orgs.size;i++)
	{

		fireorg[i] = util::spawn_model( "tag_origin", fire_orgs[i].origin);
		IPrintLnBold(fireorg[i].origin);
		PlayFxOnTag( FIRE_TRAP_FX, fireorg[i], "tag_origin");
	}
	hurt_trig thread check_for_creatures();
	hurt_trig thread check_for_trap();
	wait(level.fire_trap_time);
	hurt_trig notify("trap_over");
	for(i=0;i<fire_orgs.size;i++)
	{
		fireorg[i] Delete();
	}
	self SetHintString( "Trap Already Used");
	if(hurt_trig.already_got_him == false)
	{
		self thread boss_round_activation();
	}
}
function check_for_creatures()
{
	level endon("boss_round");
	self endon("trap_over");
	while(1)
	{
		self waittill("trigger",ent);

		ent DoDamage( ent.health + 666, ent.origin);

		wait(0.05);
	}

}
function check_for_trap()
{
	self endon("trap_over");
	while(1)
	{
		if( level.boss IsTouching(self) && self.already_got_him == false)
		{
			level.boss.hits ++;
			self.already_got_him = true;
			level notify("boss_has_been_hit");
			level.boss MoveTo(level.boss.origin, 1);
		}
		wait(0.05);

	}
}
function damage_players()
{

	while(self.alive)
	{
		players_to_hurt = util::get_array_of_closest( self.origin, level.players , undefined , undefined, level.boss_damage_radius);
		foreach(player in players_to_hurt)
		{
			player DoDamage(level.boss_damage, self.origin);
			player ASMSetAnimationRate(0.8);
			player SetMoveSpeedScale(0.8);
			player thread back_to_normal();
		}
		wait(level.boss_damage_time);
	}
}
function back_to_normal()
{
	while(1)
	{
		dist = Distance( self.origin, level.boss.origin );
		if(dist > level.boss_damage_radius)
		{
			self ASMSetAnimationRate(1);
			self SetMoveSpeedScale(1);
			break;
		}
		wait(0.05);
	}
}
function player_breadcrumbs()
{
	level endon("boss_has_been_hit");
	distraction_points = Struct::Get_Array("ice_boss_distraction","targetname");
	rand = randomintrange( 0, distraction_points.size);
	while(1)
	{
		players = GetPlayers();
		self endon("boss_dead");

		for(i=0;i<players.size;i++)
		{
			if(players[i].laststand != true)
			{
				level.crumbs[i] = util::spawn_model( "tag_origin", players[i].origin + (0,0,40));
			}
			else
			{
				IPrintLnBold("anus");

				dist = Distance( self.origin, distraction_points[rand].origin );
				time = dist / level.speed;
				level.boss MoveTo( distraction_points[rand].origin, time);
				continue;
			}
		}
		good_to_go = false;
		times_looped = 0;
		while(good_to_go == false)
		{
			if(times_looped == level.players.size)
			{
				IPrintLnBold("break");
				level.only_bad_crumbs = true;
				break;
			}
			good_crumb = ArrayGetClosest( self.origin, level.crumbs );
			if(BulletTracePassed( self.origin, good_crumb.origin, false, false ))
			{
				good_crumb thread go_to_closest();
				good_to_go = true;
			}
			else
			{
				good_crumb Delete();
				IPrintLnBold("bad crumb deleted");
			}
			times_looped ++;
		}
		wait(0.5);
	}

}
function go_to_closest()
{
	level endon("boss_has_been_hit");
	dist = Distance( self.origin, level.boss.origin );
	time = dist / level.speed;

	level.boss MoveTo( self.origin, time);


	wait(1);

	if(level.only_bad_crumbs == false)
	{
		IprintlnBold("deletre");
		for(i=0;i<level.crumbs.size;i++)
		{
			level.crumbs[i] Delete();
		}
	}

}

////////START ROCKET STUFF//////////

function rocket_init()
{
	level.rocket_launch_sound = "rocket_launch"; //set equal to what your rocket launch sound is called in its alias

	level.blink_time = 0.5;
	level.amount_of_blinks = 3;

	level.sign_updates = 0;
	sign_2 = GetEntArray("sign_2","targetname");
	for(i=0;i<sign_2.size;i++)
	{
		sign_2[i] Hide();
	}
	sign_3 = GetEntArray("sign_3","targetname");
	for(i=0;i<sign_3.size;i++)
	{
		sign_3[i] Hide();
	}
	sign_4 = GetEntArray("sign_4","targetname");
	for(i=0;i<sign_4.size;i++)
	{
		sign_4[i] Hide();
	}

	rocket();
}
function rocket()
{
	wait(5);
	//level flag::wait_till("power_on");
	level.rocket_launch_is_ready_now = false;
	thread check_for_lander_use();
	level waittill("all_generators_complete");

	thread play_2D_sound("rocket_power_on");

	thread fake_lander();
	IPrintlnBold("rocket intiated");
	rocket = GetEnt("rocket","targetname");
	arm = GetEnt("arm_up","targetname");
	rocket_parts = GetEntArray("rocket_piece","targetname");
	arm_parts = GetEntArray("arm","targetname");
	base = GetEnt("base","targetname");
	level flag::wait_till("power_on");
	for(i=0;i<rocket_parts.size;i++)
	{
		rocket_parts[i] MoveX(240,5);
	}
	for(i=0;i<arm_parts.size;i++)
	{
		arm_parts[i] MoveX(240,5);
	}
	base MoveX(240,5);
	rocket MoveX(240,5);
	arm MoveX(240,5);
	wait(5);
	for(i=0;i<rocket_parts.size;i++)
	{
		rocket_parts[i] LinkTo( rocket);
	}
	for(i=0;i<arm_parts.size;i++)
	{
		arm_parts[i] LinkTo( arm);
	}
	IPrintlnBold("first movement complete");
	rocket LinkTo( arm);
	wait(2);
	arm RotateTo( (90, 0, 0), 15, 3, 5);
	wait(16);
	rocket unlink();
	rocket MoveZ( -20, 3 );
	IPrintlnBold("second movement complete");
	check_for_rocket_launch_ready();
	//level waittill("rocket_launch_is_ready");
	arm RotateTo( (0, 0, 0), 15 );
	rocket_launch_ready();

}
function check_for_rocket_launch_ready()
{
	while(level.rocket_launch_is_ready_now == false)
	{
		wait(0.05);
	}
}
function fake_lander()	///ONLY FOR TESTING PURPOSES
{
	fake_landers = GetEntArray("fake_lander","targetname");
	for(i=0;i<fake_landers.size;i++)
	{
		fake_landers[i] SetHintString( "Hold ^3&&1^7 to use Fake Lander" );
		fake_landers[i] thread fake_wait_for_activation();
	}
}
function fake_wait_for_activation()  ///ONLY FOR TESTING PURPOSES
{
	while(1)
	{
		self waittill("trigger",player);
		level.last_lander_used = self.script_string;
		level notify("lander_used");
		wait(0.05);
	}
}
function check_for_lander_use()
{
	loc_1_used_already = false;
	loc_2_used_already = false;
	loc_3_used_already = false;

	while(1)
	{
		level waittill("lander_used");
		if(level.last_lander_used == "loc_1")
		{
			if(loc_1_used_already != true)
			{
				thread update_rocket_status();
			}
			loc_1_used_already = true;
		}
		if(level.last_lander_used == "loc_2")
		{
			if(loc_2_used_already != true)
			{
				thread update_rocket_status();
			}
			loc_2_used_already = true;
		}
		if(level.last_lander_used == "loc_3")
		{
			if(loc_3_used_already != true)
			{
				thread update_rocket_status();
			}
			loc_3_used_already = true;
		}
		wait(0.5);
	}
}
function update_rocket_status()
{
	level.sign_updates ++;
	if(level.sign_updates == 1)
	{
		sign_2 = GetEntArray("sign_2","targetname");
		play_2D_sound("objective_complete");///
		for(i=0;i<sign_2.size;i++)
		{
			sign_2[i] Show();
			sign_2[i] thread blink();
		}
	}
	if(level.sign_updates == 2)
	{
		sign_3 = GetEntArray("sign_3","targetname");
		play_2D_sound("objective_complete");///
		for(i=0;i<sign_3.size;i++)
		{
			sign_3[i] Show();
			sign_3[i] thread blink();
		}
	}
	if(level.sign_updates == 3)
	{
		sign_4 = GetEntArray("sign_4","targetname");
		play_2D_sound("objective_complete");///
		for(i=0;i<sign_4.size;i++)
		{
			sign_4[i] Show();
			sign_4[i] thread blink();
		}
		level.rocket_launch_is_ready_now = true;
	}
}
function blink()
{
	blinks = 0;
	while(level.amount_of_blinks > blinks)
	{
		wait(level.blink_time);
		self Hide();
		wait(level.blink_time);
		self Show();
		blinks ++;
	}
}
function rocket_launch_ready()
{
	trig = GetEnt("rocket_launch_trig","targetname");
	trig SetHintString( "Rocket is not ready for launch yet" );
	level waittill("rocket_launch_is_ready");
	trig SetHintString( "Hold ^3&&1^7 to launch the Rocket" );
	trig waittill("trigger",player);
	trig Delete();
	thread play_2D_sound(level.rocket_launch_sound);

	level.gantry_r rotateyaw(60,6);
	level.gantry_l rotateyaw(-60,6);

	wait(10);

	Earthquake( RandomFloatRange( 0.15, 0.35 ), RandomFloatRange(.25,.5), self.origin, 5500 );
	fx_structs = Struct::Get_Array("rocket_fx","targetname");
	for(i=0;i<fx_structs.size;i++)
	{
		fxOrg = util::spawn_model( "tag_origin", fx_structs[i].origin);
		fx = PlayFxOnTag( FLAME_FX, fxOrg, "tag_origin" );
		fxOrg thread rocket_fx();
	}

	wait(1);

	//Actual Rocket Movement
	self moveto(self.origin + (0,0,50000),50,45);

	//rocket_pieces = getentarray(self.target, "targetname");
	//for(i=0;i<rocket_pieces.size;i++)
	//{
	//	rocket_pieces[i] thread rocket_piece_monitor_for_damage();
	//}
	//self thread rocket_piece_monitor_for_damage();
	trig = GetEnt("rocket_damage_trig","targtname");
	trig thread trig_watch_for_damage();
	trig moveto(self.origin + (0,0,50000),50,45);

	self thread the_dablage();
	level endon("rocket_dmg");

	wait(20);
	self Delete();
	trig Delete();
	level notify("no_rocket_damage");

}
function the_dablage()
{
	level waittill("rocket_dmg");
	self thread piece_crash_down();
	rocket_pieces = getentarray(self.target, "targetname");
	for(i=0;i<rocket_pieces.size;i++)
	{
		rocket_pieces[i] Unlink();
		rocket_pieces[i] thread piece_crash_down();
	}
}
function trig_watch_for_damage()
{
	self waittill("trigger",player);
	self Delete();
	IPrintLnBold("rocket hit");///
	level notify("rocket_dmg");
	level.temp_ent StopSound(level.rocket_launch_sound);
	wait(0.05);
	level.temp_ent Delete();
}
function rocket_piece_monitor_for_damage()
{
	level endon("no_rocket_damage");
	self setcandamage(true);
	self waittill("damage", dmg_amount, attacker, dir, point, dmg_type);
	if( isplayer( attacker ) && ( dmg_type == "MOD_PROJECTILE" || dmg_type == "MOD_PROJECTILE_SPLASH" || dmg_type == "MOD_EXPLOSIVE" || dmg_type == "MOD_EXPLOSIVE_SPLASH" || dmg_type == "MOD_GRENADE" || dmg_type == "MOD_GRENADE_SPLASH" ) )
	{
		IPrintLnBold("rocket hit");
		level notify("rocket_dmg");
		level.temp_ent StopSound(level.rocket_launch_sound);
		wait(0.05);
		level.temp_ent Delete();
	}
}
function piece_crash_down( num )
{

	trace = bullettrace(self.origin,self.origin + (randomintrange(-100,100),randomintrange(-100,100),-20000),false,self);
	ground_pos = trace["position"] + ( 0, 0, 1.5 );

	self moveto(ground_pos,3);

	self rotateto( (randomintrange(-360,360),randomintrange(-360,360),randomintrange(-360,360)) ,3.9);
	wait(3.9);
	Earthquake( RandomFloatRange( 0.25, 0.45 ), RandomFloatRange(.65,.75), self.origin, 5500 );

	if( IsDefined( num ) )
	{
	    if( num == 0 )
	        self PlaySound( "zmb_rocket_top_crash" );
	    else if( num == 1 )
	        self PlaySound( "zmb_rocket_bottom_crash" );
	}

	wait(1);
	self hide();
	wait(10);
	self delete();

}

function rocket_fx()
{
	wait(1);
	self moveto(self.origin + (0,0,50000),50,45);
}
function play_2D_sound(sound, songname)
{
	level.temp_ent = spawn("script_origin", (0,0,0));
	if(IsDefined(songname))
		IPrintLnBold( "Playing:  " + songname  );
	level.temp_ent PlaySoundWithNotify(sound, sound + "wait");
	level.temp_ent waittill (sound + "wait");
	wait(0.05);
	level.temp_ent delete();
}