#include common_scripts\utility;

#include maps\_utility;

#include maps\_zombiemode_utility;

extracted by xd366



#include maps\_zombiemode_zone_manager;

main()

{

level thread maps\zombie_coast_ffotd::main_start();

level.riser_type = "snow";

level.use_new_riser_water = 1;

level.riser_fx_on_client = 1;

level.use_clientside_rock_tearin_fx = 1;

level.use_clientside_board_fx = 1;

maps\zombie_coast_fx::main();

init_fx_anims();

level.poi_positioning_func = ::zombie_coast_poi_positioning_func;

PreCacheModel( "viewmodel_zom_gellar_arms" );

PreCacheModel( "viewmodel_zom_englund_arms" );

PreCacheModel( "viewmodel_zom_rooker_arms" );

PreCacheModel( "viewmodel_zom_trejo_arms" );

level._zombie_custom_add_weapons = ::custom_add_weapons;

level._CF_PLAYER_ZIPLINE_RUMBLE_QUAKE = 0;

level._CF_PLAYER_ZIPLINE_FAKE_PLAYER_SETUP = 1;

level._COAST_FOG_BLIZZARD = 2;

level._CF_PLAYER_FLINGER_FAKE_PLAYER_SETUP_PRONE =3;

level._CF_PLAYER_FLINGER_FAKE_PLAYER_SETUP_STAND =4;

level._CF_PLAYER_WATER_FROST = 5;

level._CF_PLAYER_WATER_FREEZE = 6;

level._CF_PLAYER_WATER_FROST_REMOVE = 7;

level._CF_PLAYER_ELECTRIFIED = 8;

level._ZOMBIE_ACTOR_FLAG_ELECTRIFIED = 2;

level._ZOMBIE_ACTOR_FLAG_DIRECTOR_LIGHT = 3;

level._ZOMBIE_ACTOR_FLAG_DIRECTORS_STEPS = 4;

level._ZOMBIE_ACTOR_FLAG_DIRECTOR_DEATH = 5;

level._ZOMBIE_ACTOR_FLAG_LAUNCH_RAGDOLL = 0;

if(GetDvarInt( #"artist") > 0)

{

return;

}

level.player_out_of_playable_area_monitor = true;

level.player_out_of_playable_area_monitor_callback = ::zombie_coast_player_out_of_playable_area_monitor_callback;

level.zombie_anim_override = maps\zombie_coast::anim_override_func;

level.player_intersection_tracker_override = ::zombie_coast_player_intersection_tracker_override;

maps\_zombiemode::register_player_damage_callback( ::zombie_coast_player_damage_level_override );

level._func_humangun_check = ::func_humangun_check;

level.check_for_alternate_poi = ::check_for_alternate_poi;

level.pay_turret_cost = 850;

level.plankB_cost = 1000;

level.random_pandora_box_start = true;

level.zombie_coast_visionset = "zombie_coast";

level thread maps\zombie_coast_cave_slide::cave_slide_anim_init();

level thread maps\_callbacksetup::SetupCallbacks();

level.dog_spawn_func = maps\_zombiemode_ai_dogs::dog_spawn_factory_logic;

maps\zombie_coast_flinger::main();

level.dogs_enabled = false;

level.custom_ai_type = [];

level.custom_ai_type = array_add( level.custom_ai_type, maps\_zombiemode_ai_director::init );

level.custom_ai_type = array_add( level.custom_ai_type, maps\_zombiemode_ai_faller::faller_init );

maps\zombie_coast_ai_director::init();

maps\zombie_coast_lighthouse::init();

maps\zombie_coast_water::init();

maps\zombie_coast_eggs::init();

level.door_dialog_function = maps\_zombiemode::play_door_dialog;

include_weapons();

include_powerups();

level.use_zombie_heroes = true;

level.zombiemode_using_marathon_perk = true;

level.zombiemode_using_divetonuke_perk = true;

level.zombiemode_using_deadshot_perk = true;

level.use_freezegun_features = true;

level.uses_tesla_powerup = true;

level.zombiemode_precache_player_model_override = ::coast_precache_custom_models;

level.zombiemode_give_player_model_override = ::coast_custom_third_person_override;

level.zombiemode_player_set_viewmodel_override = ::coast_custom_viewmodel_override;

level.register_offhand_weapons_for_level_defaults_override = ::coast_offhand_weapon_overrride;

level.zombiemode_offhand_weapon_give_override = ::coast_offhand_weapon_give_override;

level.max_perks = 5;

level.max_solo_lives = 3;

level.revive_solo_fx_func = ::coast_revive_solo_fx;

maps\_zombiemode::main();

maps\_sticky_grenade::init();

maps\_zombiemode_weap_sickle::init();

maps\_zombiemode_weap_humangun::init();

maps\_zombiemode_weap_sniper_explosive::init();

maps\_zombiemode_weap_nesting_dolls::init();

level thread maps\_zombiemode::register_sidequest( "ZOMBIE_COAST_EGG_SOLO", 43, "ZOMBIE_COAST_EGG_COOP", 44 );

level.director_should_drop_special_powerup = ::coast_director_should_drop_special_powerup;

battlechatter_off("allies");

battlechatter_off("axis");

level.zone_manager_init_func = ::coast_zone_init;

init_zones[0] = "beach_zone";

level thread maps\_zombiemode_zone_manager::manage_zones( init_zones );

level thread stairs_blocker_buyable();

level thread electric_switch();

level thread electric_door_function();

level thread maps\_zombiemode_auto_turret::init();

level thread maps\zombie_coast_achievement::init();

level thread maps\zombie_coast_ai_director::coast_director_start();

level thread coast_fade_in_notify();

level thread maps\zombie_coast_cave_slide::zombie_cave_slide_init();

maps\_zombiemode_player_zipline::main();

level thread setup_water_physics();

level thread setup_zcoast_water();

level thread maps\zombie_coast_distance_tracking::zombie_tracking_init();

SetSavedDvar( "zombiemode_path_minz_bias", 17 );

maps\zombie_coast_flinger::init_flinger();

init_sounds();

level thread maps\zombie_coast_amb::main();

level thread coast_power_on_lighthouse_react();

level thread coast_spawn_init_delay();

level thread maps\zombie_coast_fx:: manage_blizzard();

if(GetDvarInt( #"zombie_unlock_all") > 0)

{

level thread zombie_unlock_all();

}

level thread maps\zombie_coast_ffotd::main_end();

level thread check_to_set_play_outro_movie();

}

check_to_set_play_outro_movie()

{

flag_wait( "all_players_connected" );

if ( !level.onlineGame && !level.systemlink )

{

SetDvar("ui_playCoastOutroMovie", 1);

}

}

zombie_coast_player_out_of_playable_area_monitor_callback()

{

if ( is_true( self._being_flung ) || is_true( self.is_ziplining ) )

{

return false;

}

return true;

}

zombie_unlock_all()

{

flag_wait( "begin_spawning" );

players = GetPlayers();

flag_set( "power_on" );

zombie_doors = GetEntArray( "zombie_door", "targetname" );

for ( i = 0; i < zombie_doors.size; i++ )

{

zombie_doors[i] notify("trigger", players[0]);

}

zombie_debris = GetEntArray( "zombie_debris", "targetname" );

for ( i = 0; i < zombie_debris.size; i++ )

{

zombie_debris[i] notify("trigger", players[0]);

}

}

custom_add_weapons()

{

maps\_zombiemode_weapons::add_zombie_weapon( "humangun_zm", "humangun_upgraded_zm", &"ZOMBIE_WEAPON_HUMANGUN", 10, "human", "", undefined );

maps\_zombiemode_weapons::add_zombie_weapon( "sniper_explosive_zm", "sniper_explosive_upgraded_zm", &"ZOMBIE_WEAPON_SNIPER_EXPLOSIVE", 2500,	"ubersniper",	"", undefined );

}

coast_spawn_init_delay(director)

{

flag_wait( "begin_spawning" );

flag_clear( "spawn_zombies");

director_zomb = undefined;

while(!IsDefined(director_zomb))

{

zombs = GetAIArray ("axis");

for ( i = 0; i < zombs.size; i++ )

{

if(IsDefined(zombs[i].animname) && zombs[i].animname == "director_zombie")

{

director_zomb = zombs[i];

}

}

wait_network_frame();

}

director_zomb waittill_notify_or_timeout( "director_spawn_zombies", 30 );

flag_set( "spawn_zombies");

}

#using_animtree( "generic_human" );

anim_override_func()

{

level.scr_anim["zombie"]["walk3"] = %ai_zombie_walk_v2;

level.scr_anim["zombie"]["run6"] = %ai_zombie_run_v2;

}

coast_zone_init()

{

flag_init( "always_on" );

flag_set( "always_on" );

add_adjacent_zone( "start_zone", "lighthouse1_zone", "lighthouse_enter" );

add_zone_flags(	"lighthouse_enter", "start_beach_group" );

add_adjacent_zone( "start_cave_zone", "lighthouse1_zone", "lighthouse_lagoon_enter" );

add_adjacent_zone( "start_cave_zone", "rear_lagoon_zone", "lighthouse_lagoon_enter" );

add_zone_flags(	"lighthouse_lagoon_enter", "start_beach_group" );

add_adjacent_zone( "start_zone", "start_beach_zone", "start_beach_group" );

add_adjacent_zone( "start_beach_zone", "start_cave_zone", "start_beach_group", true );

add_adjacent_zone( "start_zone", "shipfront_bottom_zone", "enter_shipfront_bottom" );

add_zone_flags(	"enter_shipfront_bottom", "start_beach_group" );

add_adjacent_zone( "shipfront_bottom_zone", "shipfront_near_zone", "enter_shipfront_bottom" );

add_adjacent_zone( "shipfront_bottom_zone", "shipfront_near_zone", "plankA_enter" );

add_adjacent_zone( "shipfront_near_zone", "shipfront_far_zone", "shipfront_far_enter" );

add_adjacent_zone( "shipfront_near_zone", "shipfront_2_beach_zone", "enter_shipfront_bottom" );

add_adjacent_zone( "shipfront_near_zone", "shipfront_2_beach_zone", "plankA_enter" );

add_adjacent_zone( "beach_zone", "shipfront_2_beach_zone", "", true );

add_adjacent_zone( "shipfront_storage_zone", "shipfront_far_zone", "shipfront_deck_storage" );

add_adjacent_zone( "shipfront_bottom_zone", "shipfront_storage_zone", "shipfront_bottom_storage" );

add_adjacent_zone( "shipfront_near_zone", "shipback_near_zone", "plankA_enter" );

add_adjacent_zone( "shipback_near_zone", "shipback_far_zone", "shipback_far_enter" );

add_adjacent_zone( "shipback_near_zone", "shipback_near2_zone", "shipback_level2_enter" );

add_adjacent_zone( "shipback_near2_zone", "shipback_level3_zone", "ship_house3" );

add_adjacent_zone( "residence1_zone", "residence_roof_zone", "residence_beach_group" );

add_adjacent_zone( "residence_roof_zone", "beach_zone2", "residence_beach_group" );

add_adjacent_zone( "beach_zone2", "beach_zone", "side_beach_debris" );

add_zone_flags(	"side_beach_debris", "residence_beach_group" );

add_adjacent_zone( "shipback_near_zone", "beach_zone", "plankB_enter" );

add_adjacent_zone( "residence_roof_zone", "lighthouse2_zone", "balcony_enter" );

add_zone_flags(	"balcony_enter", "residence_beach_group" );

add_adjacent_zone( "residence1_zone", "lighthouse1_zone", "res_2_lighthouse1" );

add_zone_flags(	"res_2_lighthouse1", "residence_beach_group" );

add_adjacent_zone( "start_zone", "residence1_zone", "lighthouse_residence_front" );

add_zone_flags(	"lighthouse_residence_front", "residence_beach_group" );

add_zone_flags(	"lighthouse_residence_front", "start_beach_group" );

add_adjacent_zone( "lighthouse1_zone", "lighthouse2_zone", "lighthouse2_enter" );

add_adjacent_zone( "catwalk_zone", "lighthouse2_zone", "catwalk_enter" );

}

include_weapons()

{

include_weapon( "frag_grenade_zm", false );

include_weapon( "sticky_grenade_zm", false, true );

include_weapon( "claymore_zm", false, true );

include_weapon( "m1911_zm", false );

include_weapon( "m1911_upgraded_zm", false );

include_weapon( "python_zm" );

include_weapon( "python_upgraded_zm", false );

include_weapon( "cz75_zm" );

include_weapon( "cz75_upgraded_zm", false );

include_weapon( "m14_zm", false, true );

include_weapon( "m14_upgraded_zm", false );

include_weapon( "m16_zm", false, true );

include_weapon( "m16_gl_upgraded_zm", false );

include_weapon( "g11_lps_zm" );

include_weapon( "g11_lps_upgraded_zm", false );

include_weapon( "famas_zm" );

include_weapon( "famas_upgraded_zm", false );

include_weapon( "ak74u_zm", false, true );

include_weapon( "ak74u_upgraded_zm", false );

include_weapon( "mp5k_zm", false, true );

include_weapon( "mp5k_upgraded_zm", false );

include_weapon( "mpl_zm", false, true );

include_weapon( "mpl_upgraded_zm", false );

include_weapon( "pm63_zm", false, true );

include_weapon( "pm63_upgraded_zm", false );

include_weapon( "spectre_zm" );

include_weapon( "spectre_upgraded_zm", false );

include_weapon( "mp40_zm", false );

include_weapon( "mp40_upgraded_zm", false );

include_weapon( "cz75dw_zm" );

include_weapon( "cz75dw_upgraded_zm", false );

include_weapon( "ithaca_zm", false, true );

include_weapon( "ithaca_upgraded_zm", false );

include_weapon( "rottweil72_zm", false, true );

include_weapon( "rottweil72_upgraded_zm", false );

include_weapon( "spas_zm" );

include_weapon( "spas_upgraded_zm", false );

include_weapon( "hs10_zm" );

include_weapon( "hs10_upgraded_zm", false );

include_weapon( "aug_acog_zm" );

include_weapon( "aug_acog_mk_upgraded_zm", false );

include_weapon( "galil_zm" );

include_weapon( "galil_upgraded_zm", false );

include_weapon( "commando_zm" );

include_weapon( "commando_upgraded_zm", false );

include_weapon( "fnfal_zm" );

include_weapon( "fnfal_upgraded_zm", false );

include_weapon( "dragunov_zm" );

include_weapon( "dragunov_upgraded_zm", false );

include_weapon( "l96a1_zm" );

include_weapon( "l96a1_upgraded_zm", false );

include_weapon( "rpk_zm" );

include_weapon( "rpk_upgraded_zm", false );

include_weapon( "hk21_zm" );

include_weapon( "hk21_upgraded_zm", false );

include_weapon( "m72_law_zm" );

include_weapon( "m72_law_upgraded_zm", false );

include_weapon( "china_lake_zm" );

include_weapon( "china_lake_upgraded_zm", false );

include_weapon( "ray_gun_zm" );

include_weapon( "ray_gun_upgraded_zm", false );

include_weapon( "crossbow_explosive_zm" );

include_weapon( "crossbow_explosive_upgraded_zm", false );

include_weapon( "humangun_zm", true, false );

include_weapon( "humangun_upgraded_zm", false );

include_weapon( "sniper_explosive_zm", true );

include_weapon( "sniper_explosive_upgraded_zm", false );

include_weapon( "zombie_nesting_dolls", true, false );

include_weapon( "knife_ballistic_zm", true );

include_weapon( "knife_ballistic_upgraded_zm", false );

include_weapon( "knife_ballistic_sickle_zm", false );

include_weapon( "knife_ballistic_sickle_upgraded_zm", false );

level._uses_retrievable_ballisitic_knives = true;

maps\_zombiemode_weapons::add_limited_weapon( "m1911_zm", 0 );

maps\_zombiemode_weapons::add_limited_weapon( "humangun_zm", 1 );

maps\_zombiemode_weapons::add_limited_weapon( "sniper_explosive_zm", 1 );

maps\_zombiemode_weapons::add_limited_weapon( "crossbow_explosive_zm", 1 );

maps\_zombiemode_weapons::add_limited_weapon( "knife_ballistic_zm", 1 );

maps\_zombiemode_weapons::add_limited_weapon( "zombie_nesting_dolls", 1 );

precacheItem( "explosive_bolt_zm" );

precacheItem( "explosive_bolt_upgraded_zm" );

precacheItem( "sniper_explosive_bolt_zm" );

precacheItem( "sniper_explosive_bolt_upgraded_zm" );

level.collector_achievement_weapons = array_add( level.collector_achievement_weapons, "sickle_knife_zm" );

}

coast_director_should_drop_special_powerup()

{

return maps\_zombiemode::is_sidequest_previously_completed();

}

coast_offhand_weapon_overrride()

{

register_lethal_grenade_for_level( "frag_grenade_zm" );

register_lethal_grenade_for_level( "sticky_grenade_zm" );

level.zombie_lethal_grenade_player_init = "frag_grenade_zm";

register_tactical_grenade_for_level( "zombie_nesting_dolls" );

level.zombie_tactical_grenade_player_init = undefined;

register_placeable_mine_for_level( "claymore_zm" );

level.zombie_placeable_mine_player_init = undefined;

register_melee_weapon_for_level( "knife_zm" );

register_melee_weapon_for_level( "sickle_knife_zm" );

level.zombie_melee_weapon_player_init = "knife_zm";

}

coast_offhand_weapon_give_override( str_weapon )

{

self endon( "death" );

if( is_tactical_grenade( str_weapon ) && IsDefined( self get_player_tactical_grenade() ) && !self is_player_tactical_grenade( str_weapon ) )

{

self SetWeaponAmmoClip( self get_player_tactical_grenade(), 0 );

self TakeWeapon( self get_player_tactical_grenade() );

}

if( str_weapon == "zombie_nesting_dolls" )

{

self maps\_zombiemode_weap_nesting_dolls::player_give_nesting_dolls();

return true;

}

return false;

}

zombie_coast_player_intersection_tracker_override( other_player )

{

if ( is_true( self._being_flung ) || is_true( self.is_ziplining ) )

{

return true;

}

if ( is_true( other_player._being_flung ) || is_true( other_player.is_ziplining ) )

{

return true;

}

return false;

}

zombie_coast_player_damage_level_override( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, sWeapon, vPoint, vDir, sHitLoc, modelIndex, psOffsetTime )

{

if ( is_true( self._being_flung ) || is_true( self.is_ziplining ) )

{

return 0;

}

return -1;

}

include_powerups()

{

include_powerup( "nuke" );

include_powerup( "insta_kill" );

include_powerup( "double_points" );

include_powerup( "full_ammo" );

include_powerup( "carpenter" );

include_powerup( "fire_sale" );

PreCacheItem( "minigun_zm" );

include_powerup( "minigun" );

PreCacheItem( "tesla_gun_zm" );

include_powerup( "tesla" );

include_powerup( "free_perk" );

}

init_sounds()

{

maps\_zombiemode_utility::add_sound( "break_stone", "break_stone" );

maps\_zombiemode_utility::add_sound( "lighthouse_double_door", "zmb_lighthouse_double_door" );

maps\_zombiemode_utility::add_sound( "ship_door", "zmb_ship_door" );

maps\_zombiemode_utility::add_sound( "ship_container_door", "zmb_ship_container_door" );

}

electric_switch()

{

trig = getent("use_elec_switch","targetname");

trig sethintstring(&"ZOMBIE_ELECTRIC_SWITCH");

trig setcursorhint( "HINT_NOICON" );

level thread wait_for_power();

trig waittill("trigger",user);

trig delete();

flag_set( "power_on" );

Objective_State(8,"done");

}

wait_for_power()

{

master_switch = getent("elec_switch","targetname");

master_switch notsolid();

flag_wait( "power_on" );

master_switch rotateroll(-90,.3);

master_switch playsound("zmb_switch_flip");

level notify("revive_on");

wait_network_frame();

level notify("juggernog_on");

wait_network_frame();

level notify("sleight_on");

wait_network_frame();

level notify("doubletap_on");

wait_network_frame();

level notify("divetonuke_on");

wait_network_frame();

level notify("marathon_on");

wait_network_frame();

level notify("deadshot_on");

wait_network_frame();

level notify("Pack_A_Punch_on" );

wait_network_frame();

level notify("electric_door");

clientnotify("ZPO");

master_switch waittill("rotatedone");

playfx(level._effect["switch_sparks"] ,getstruct("elec_switch_fx","targetname").origin);

master_switch playsound("zmb_turn_on");

}

electric_door_function()

{

door_trigs = getentarray( "electric_door", "script_noteworthy" );

array_thread( door_trigs, ::set_door_unusable );

array_thread( door_trigs, ::play_door_dialog );

level waittill( "electric_door" );

array_thread( door_trigs, ::trigger_off );

thread open_electric_doors( door_trigs );

}

set_door_unusable()

{

self sethintstring(&"ZOMBIE_NEED_POWER");

self UseTriggerRequireLookAt();

}

open_electric_doors( door_trigs )

{

time = 1;

for(i=0;i<door_trigs.size;i++)

{

doors = getentarray(door_trigs[i].target,"targetname");

for ( j=0; j<doors.size; j++ )

{

doors[j] NotSolid();

time = 1;

if( IsDefined( doors[j].script_transition_time ) )

{

time = doors[j].script_transition_time;

}

doors[j] connectpaths();

if( door_trigs[i].type == "rotate" )

{

doors[j] NotSolid();

time = 1;

if( IsDefined( doors[j].script_transition_time ) )

{

time = doors[j].script_transition_time;

}

play_sound_at_pos( "door_rotate_open", doors[j].origin );

doors[j] RotateTo( doors[j].script_angles, time, 0, 0 );

doors[j] thread maps\_zombiemode_blockers::door_solid_thread();

doors[j] playsound ("door_slide_open");

}

else if( door_trigs[i].type == "move" || door_trigs[i].type == "slide_apart" )

{

doors[j] NotSolid();

time = 1;

if( IsDefined( doors[j].script_transition_time ) )

{

time = doors[j].script_transition_time;

}

play_sound_at_pos( "door_slide_open", doors[j].origin );

doors[j] MoveTo( doors[j].origin + doors[j].script_vector, time, time * 0.25, time * 0.25 );

doors[j] thread maps\_zombiemode_blockers::door_solid_thread();

doors[j] playsound ("door_slide_open");

}

wait(randomfloat(.15));

}

}

}

play_door_dialog()

{

self endon ("warning_dialog");

timer = 0;

while(1)

{

wait(0.05);

players = get_players();

for(i = 0; i < players.size; i++)

{

dist = distancesquared(players[i].origin, self.origin );

if(dist > 70*70)

{

timer =0;

continue;

}

while(dist < 70*70 && timer < 3)

{

wait(0.5);

timer++;

}

if(dist > 70*70 && timer >= 3)

{

self playsound("door_deny");

players[i] thread do_player_vo("vox_start", 5);

wait(3);

self notify ("warning_dialog");

}

}

}

}

check_plankB( from, forward )

{

trigger = getent( from, "targetname" );

trigger sethintstring( &"ZOMBIE_BUILD_BRIDGE" );

trigger setcursorhint( "HINT_NOICON" );

trigger endon( "plankB_done" );

user = undefined;

done = false;

while ( !done )

{

trigger waittill( "trigger", user );

if ( is_player_valid( user ) && user.score >= level.plankB_cost )

{

user maps\_zombiemode_score::minus_to_player_score( level.plankB_cost );

other = getent( trigger.target, "targetname" );

other notify( "plankB_done" );

other delete();

trigger delete();

clip = getent( "plankB_clip", "targetname" );

clip connectpaths();

clip delete();

if ( forward == true )

{

for ( i = 1; i <= 4; i++ )

{

bridge = getent( "residence2ship_walk" + i, "targetname" );

bridge show();

wait( 0.5 );

}

}

else

{

for ( i = 4; i >= 1; i-- )

{

bridge = getent( "residence2ship_walk" + i, "targetname" );

bridge show();

wait( 0.5 );

}

}

done = true;

flag_set( "plankB_enter" );

}

wait( .05 );

}

}

wait_for_respawn()

{

zone_name = self.script_noteworthy;

if ( isDefined( level.zones[ zone_name ] ) )

{

while ( !level.zones[ zone_name ].is_enabled )

{

wait( 0.5 );

}

self.locked = false;

}

}

stairs_blocker_buyable()

{

trigger = getentarray("buyable_stairs", "targetname");

for ( i = 0; i < trigger.size; i++ )

{

trigger[i] thread stairs_init();

}

}

stairs_init()

{

cost = 1000;

if( IsDefined( self.zombie_cost ) )

{

cost = self.zombie_cost;

}

self set_hint_string( self, "default_buy_debris_" + cost );

self SetCursorHint( "HINT_NOICON" );

if( isdefined (self.script_flag) && !IsDefined( level.flag[self.script_flag] ) )

{

flag_init( self.script_flag );

}

self UseTriggerRequireLookAt();

clip = undefined;

debris = undefined;

planks = getentarray( self.target, "targetname" );

for( i = 0; i < planks.size; i++ )

{

if( IsDefined( planks[i].script_noteworthy ) )

{

if( planks[i].script_noteworthy == "clip")

{

clip = planks[i];

planks = array_remove(planks, clip);

i--;

continue;

}

else if( planks[i].script_noteworthy == "debris_blocker" )

{

debris = planks[i];

planks = array_remove(planks, debris);

i--;

continue;

}

else

{

}

}

}

wait_network_frame();

self thread stairs_think(planks, debris, clip);

}

stairs_think(planks, debris, clip)

{

while( 1 )

{

self waittill( "trigger", who );

if( !who UseButtonPressed() )

{

continue;

}

if( who in_revive_trigger() )

{

continue;

}

if( is_player_valid( who ) )

{

if( who.score >= self.zombie_cost )

{

who maps\_zombiemode_score::minus_to_player_score( self.zombie_cost );

bbPrint( "zombie_uses: playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type debris", who.playername, who.score, level.round_number, self.zombie_cost, self.target, self.origin );

if( IsDefined( self.script_flag ) )

{

flag_set( self.script_flag );

}

play_sound_at_pos( "purchase", self.origin );

level notify ("junk purchased");

level.stairs_pieces = 0;

self set_hint_string( self, "" );

if( IsDefined( debris.script_linkTo ) )

{

debris_struct = getstruct( debris.script_linkTo, "script_linkname" );

if( IsDefined( debris_struct ))

{

debris thread special_debris_move(debris_struct);

}

}

if(IsDefined(clip))

{

clip moveto(clip.origin + (0, 0, -1000), 0.1);

wait(0.1);

clip connectpaths();

clip delete();

}

self delete();

}

else

{

play_sound_at_pos( "no_purchase", self.origin );

}

}

}

}

stairs_move( struct, planks, trigger )

{

self script_delay();

self notsolid();

selfpos = self.origin;

selfang = self.angles;

self moveto(struct.origin, 0.1);

wait(randomfloatrange(1.0, 10.0));

self show();

self play_sound_on_ent( "debris_move" );

playsoundatposition ("lightning_l", self.origin);

if( IsDefined( self.script_firefx ) )

{

PlayFX( level._effect[self.script_firefx], self.origin );

}

if( IsDefined( self.script_noteworthy ) )

{

if( self.script_noteworthy == "jiggle" )

{

num = RandomIntRange( 3, 5 );

og_angles = self.angles;

for( i = 0; i < num; i++ )

{

angles = og_angles + ( -5 + RandomFloat( 10 ), -5 + RandomFloat( 10 ), -5 + RandomFloat( 10 ) );

time = RandomFloatRange( 0.1, 0.4 );

self Rotateto( angles, time );

wait( time - 0.05 );

}

}

}

time = 0.5;

if( IsDefined( self.script_transition_time ) )

{

time = self.script_transition_time;

}

self MoveTo( selfpos, time, time * 0.5 );

self RotateTo( selfang, time * 0.75 );

self waittill( "movedone" );

level.stairs_pieces++;

if(level.stairs_pieces >= planks.size)

{

trigger notify("stairs_complete");

}

if( IsDefined( self.script_fxid ) )

{

PlayFX( level._effect[self.script_fxid], self.origin );

playsoundatposition("zombie_spawn", self.origin);

}

}

special_debris_move( struct )

{

self script_delay();

self notsolid();

self play_sound_on_ent( "debris_move" );

playsoundatposition ("lightning_l", self.origin);

if( IsDefined( self.script_firefx ) )

{

PlayFX( level._effect[self.script_firefx], self.origin );

}

num = RandomIntRange( 3, 5 );

og_angles = self.angles;

for( i = 0; i < num; i++ )

{

angles = og_angles + ( -5 + RandomFloat( 10 ), -5 + RandomFloat( 10 ), -5 + RandomFloat( 10 ) );

time = RandomFloatRange( 0.1, 0.4 );

self Rotateto( angles, time );

wait( time - 0.05 );

}

time = 0.5;

self MoveTo( struct.origin, time, time * 0.5 );

self RotateTo( struct.angles, time * 0.75 );

self waittill( "movedone" );

if( IsDefined( self.script_fxid ) )

{

PlayFX( level._effect[self.script_fxid], self.origin );

playsoundatposition("zombie_spawn", self.origin);

}

self Delete();

}

coast_precache_custom_models()

{

mptype\player_t5_zm_coast::precache();

}

coast_custom_third_person_override( entity_num )

{

if( IsDefined( self.zm_random_char ) )

{

entity_num = self.zm_random_char;

}

switch( entity_num )

{

case 0:

character\c_zom_sarah_michelle_gellar_player::main();

break;

case 1:

character\c_zom_robert_englund_player::main();

break;

case 2:

character\c_zom_danny_trejo_player::main();

break;

case 3:

character\c_zom_michael_rooker_player::main();

break;

}

}

coast_custom_viewmodel_override( entity_num )

{

switch( self.entity_num )

{

case 0:

self SetViewModel( "viewmodel_zom_gellar_arms" );

break;

case 1:

self SetViewModel( "viewmodel_zom_englund_arms" );

break;

case 2:

self SetViewModel( "viewmodel_zom_trejo_arms" );

break;

case 3:

self SetViewModel( "viewmodel_zom_rooker_arms" );

break;

}

}

setup_water_physics()

{

flag_wait( "all_players_connected" );

players = GetPlayers();

for (i = 0; i < players.size; i++)

{

players[i] SetClientDvars("phys_buoyancy",1);

}

}

setup_zcoast_water()

{

SetDvar( "r_waterWaveAngle", "0 45 90 180" );

SetDvar( "r_waterWaveWavelength", "350 150 450 650" );

SetDvar( "r_waterWaveAmplitude", "6 4 8 2" );

SetDvar( "r_waterWavePhase", "0 0 0 0" );

SetDvar( "r_waterWaveSteepness", "0.25 0.25 0.25 0.25" );

SetDvar( "r_waterWaveSpeed", "1 0.5 1 0.5" );

}

coast_fade_in_notify()

{

level waittill( "fade_in_complete" );

wait_network_frame();

level ClientNotify( "ZID" );

}

coast_power_on_lighthouse_react()

{

flag_wait( "power_on" );

exploder( 301 );

}

rock_wall_barricade()

{

rock_wall = getstruct("special_rock_wall", "script_noteworthy");

boards = GetEntArray(rock_wall.target, "targetname");

rock = undefined;

for (i = 0; i < boards.size; i++)

{

if(IsDefined(boards[i].target))

{

rock = GetEnt(boards[i].target, "targetname");

if(IsDefined(rock))

{

rock LinkTo(boards[i]);

}

}

}

}

coast_revive_solo_fx()

{

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

for ( i = 0; i < vending_triggers.size; i++ )

{

if ( vending_triggers[i].script_noteworthy == "specialty_quickrevive" )

{

vending_triggers[i] delete();

break;

}

}

}

func_humangun_check()

{

self notify("stop_melee_watch");

if ( is_true( self.electrified ) )

{

maps\_zombiemode_ai_director::zombie_clear_electric_buff();

}

}

check_for_alternate_poi()

{

if(!is_true(self.following_human_zombie) && !is_true(self.following_player_zipline))

{

return false;

}

return true;

}

#using_animtree("fxanim_props_dlc3");

init_fx_anims()

{

level.fxanims = [];

level.fxanims["hook_anim"] = %fxanim_zom_ship_crane01_hook_anim;

level.fxanims["boat_anim"] = %fxanim_zom_ship_lifeboat_anim;

}

zombie_coast_poi_positioning_func(origin, forward)

{

return maps\_zombiemode_server_throttle::server_safe_ground_trace_ignore_water( "poi_trace", 10, self.origin + forward + ( 0, 0, 10 ) );

}

    extracted by xd366



#include animscripts\zombie_utility;

#include common_scripts\utility;

#include maps\_utility;

#include maps\_zombiemode_utility;

#include maps\_ambientpackage;

#include maps\_music;

#include maps\_busing;

#include maps\_zombiemode_audio;

init()

{

level c_flags();

level c_anims();

level mic_test();

level thread c_overseer();

}

c_flags()

{

flag_init( "ffs" );

flag_init( "ffd" );

flag_init( "hgs" );

flag_init( "hg0" );

flag_init( "hg1" );

flag_init( "hg2" );

flag_init( "hg3" );

flag_init( "hgd" );

flag_init( "bs" );

flag_init( "bd" );

flag_init( "ke" );

flag_init( "aca" );

flag_init( "shs" );

flag_init( "sr" );

flag_init( "bp" );

flag_init( "mcs" );

flag_init( "hn" );

flag_init( "mm" );

flag_init( "ss" );

flag_init( "re" );

flag_init( "sa" );

flag_init( "s_s" );

flag_init( "sdm" );

flag_init( "dmf" );

}

#using_animtree ( "generic_human" );

c_anims()

{

level.scr_anim[ "dancer" ][ "breakdown" ] = %ai_zombie_flinger_flail;

level.scr_anim[ "dancer" ][ "spin" ] = %ai_zombie_dying_back_idle;

}

beat_break( str_anim )

{

self endon( "death" );

self endon( "switch" );

self.ignoreall = true;

self.ignoreme = true;

while( IsDefined( self ) && IsAlive( self ) )

{

dance_anim = str_anim;

self SetFlaggedAnimKnobAllRestart( "dance_anim", dance_anim, %body, 1, .1, 1 );

animscripts\traverse\zombie_shared::wait_anim_length( dance_anim, .02 );

}

}

mic_test()

{

PreCacheModel( "p_zom_vril_device" );

PreCacheModel( "p_zom_vodka_bottle" );

PreCacheModel( "p_zom_fuse" );

PreCacheModel( "p_zom_ice_chunk_03" );

PreCacheModel( "p_zom_minisub" );

PreCacheShader( "zom_hud_icon_fuse" );

PreCacheShader( "zom_hud_icon_bottle" );

PreCacheShader( "zom_hud_icon_vril" );

}

summon_the_shamans()

{

level.beginning = getstruct( "cheaters_never_prosper", "targetname" );

rough_note = StrTok( level.beginning.script_parameters, " " );

balance = StrTok( level.beginning.script_noteworthy, " " );

level.trials = StrTok( level.beginning.script_waittill, " " );

level.contact = StrTok( level.beginning.script_string, " " );

level.mermaid = [];

level.together_again = [];

for( i = 0; i < rough_note.size; i++ )

{

temp = Int( rough_note[i] );

level.mermaid = add_to_array( level.mermaid, temp, false );

}

for( i = 0; i < balance.size; i++ )

{

temp = Int( balance[i] );

level.together_again = add_to_array( level.together_again, temp, false );

}

that_one = GetEnt( "trig_mine", "targetname" );

that_one SetCursorHint( "HINT_NOICON" );

that_one SetHintString( "" );

}

c_overseer()

{

wait( 0.2 );

flag_wait( "all_players_connected" );

players = GetPlayers();

if( players.size > 1 )

{

level._e_group = true;

}

else

{

level._e_group = false;

}

level summon_the_shamans();

level thread knock_on_door();

level thread engage();

level thread noisemakers();

level thread rotary_styles();

players = GetPlayers();

level thread cancer();

level thread aries();

level thread pisces();

level thread leo();

level thread capricorn();

if( level._e_group )

{

level thread virgo();

level thread denlo();

level thread libra();

}

}

knock_on_door()

{

level endon( "scrambled" );

knock_trig = GetEnt( "e_gargoyle", "targetname" );

if( !IsDefined( knock_trig ) )

{

return;

}

flag_wait( "power_on" );

pneumatic_tube = GetEnt( "trig_deliver", "targetname" );

pneumatic_tube PlayLoopSound( "zmb_whooooosh_loop", 2 );

level.egg_sound_ent = GetEnt( "ent_loop_door_sounds", "targetname" );

knock_trig PlaySound( "zmb_haxorz_suxorz" );

level gargoyle_speaks( knock_trig );

while( 1 )

{

knock_trig waittill( "damage", i_amt, e_inflictor, vec_direction, vec_point, mod_type );

if( level.door_knock_vox_occurring )

{

wait( 1.0 );

continue;

}

if( is_player_valid( e_inflictor ) && mod_type == level.trials[2] )

{

if( !flag( "ffs" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, 1, 0, undefined );

flag_set( "ffs" );

wait( 1.0 );

continue;

}

if( flag( "ffs" ) && !flag( "ffd" ) && !IsDefined( e_inflictor._fuse_acquired ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 1 );

wait( 1.0 );

continue;

}

else if( flag( "ffs" ) && !flag( "ffd" ) && IsDefined( e_inflictor._fuse_acquired ) && e_inflictor._fuse_acquired == 1 )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 1 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgs" ) && !flag( "hgd" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 2 );

wait( 1.0 );

continue;

}

if( level._e_group )

{

if( flag( "ffd" ) && flag( "hgd" ) && !flag( "bs" ) )

{

flag_set( "bs" );

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, 4, 3, 5, undefined );

level.egg_sound_ent PlayLoopSound( "zmb_fantastical_worlds_loop", 1.5 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bs" ) && !flag( "bd" ) && !is_true( e_inflictor._bottle_acquired ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 3 );

wait( 1.0 );

continue;

}

else if( flag( "ffd" ) && flag( "hgd" ) && flag( "bs" ) && !flag( "bd" ) && is_true( e_inflictor._bottle_acquired ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 4 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && !flag( "ke" ) )

{

flag_set( "ke" );

level.egg_sound_ent StopLoopSound( 1.5 );

level thread delayed_song_loop();

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, 8, 4, 9, undefined );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && !flag( "aca" ) )

{

level.egg_sound_ent StopLoopSound( 1 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 5 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" ) && !flag( "mcs" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 6 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" )

&& flag( "mcs" ) && !flag( "mm" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 7 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" )

&& flag( "mcs" ) && flag( "mm" ) && !flag( "s_s" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 8 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" )

&& flag( "mcs" ) && flag( "mm" ) && flag( "s_s" ) && !flag( "sdm" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, 13, 5, 14, undefined );

level.egg_sound_ent PlayLoopSound( "zmb_fantastical_worlds_loop", 1.5 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" )

&& flag( "mcs" ) && flag( "mm" ) && flag( "s_s" ) && flag( "sdm" )

&& !flag( "dmf" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 9 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "bd" ) && flag( "aca" )

&& flag( "mcs" ) && flag( "mm" ) && flag( "s_s" ) && flag( "dmf" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

wait( 1.0 );

continue;

return;

}

}

else

{

if( flag( "ffd" ) && flag( "hgd" ) && !flag( "aca" ) )

{

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, 4, "3b", 9, undefined );

flag_set( "aca" );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "aca" ) && !flag( "mcs" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 3 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "mcs" ) && !flag( "ss" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 8 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "mcs" ) && flag( "s_s" )

&& flag( "sdm" ) && !flag( "dmf" ) )

{

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, undefined, undefined, undefined, 9 );

wait( 1.0 );

continue;

}

if( flag( "ffd" ) && flag( "hgd" ) && flag( "mcs" ) && flag( "s_s" )

&& flag( "dmf" ) )

{

wait( 1.0 );

continue;

return;

}

}

}

}

}

force_wait_for_forcefield_looper()

{

wait(21.5);

flag_set( "hgs" );

level.egg_sound_ent PlayLoopSound( "zmb_wizzybizzy_home_loop", 1.5 );

}

delayed_song_loop()

{

wait(27);

level.egg_sound_ent PlayLoopSound( "vox_egg_skit_song", 1 );

}

gargoyle_speaks( knock_trig )

{

trig = GetEnt( "trig_start_voices", "targetname" );

listener = undefined;

if( !IsDefined( trig ) )

{

return;

}

trig.spoken_word = 0;

speak_limit = 3;

level._end_door_intro = false;

chr = 0;

level thread gargoyle_watch_early_door_hit();

while( !level._end_door_intro )

{

trig waittill( "trigger", listener );

if( is_player_valid( listener ) )

{

if( chr >= 3 )

{

chr = 0;

}

knock_trig PlaySound( "vox_chr_" + chr + "_egg_response_0", "sounddone_introvox" );

knock_trig waittill( "sounddone_introvox" );

wait( 1.0 );

trig.spoken_word++;

chr++;

if( trig.spoken_word >= speak_limit )

{

level notify( "stop_watching_early_knock" );

while(1)

{

knock_trig waittill( "trigger", knocker );

if( is_player_valid( knocker ) )

{

level._end_door_intro = true;

break;

}

wait(.05);

}

}

}

}

level notify( "stop_watching_early_knock" );

level maps\zombie_coast_amb::play_characters_skits_etc( listener, knock_trig, undefined, 1, 0, undefined );

flag_set( "ffs" );

}

gargoyle_watch_early_door_hit()

{

level endon( "stop_watching_early_knock" );

knock_trig = GetEnt( "e_gargoyle", "targetname" );

hit = false;

while( !hit )

{

knock_trig waittill( "trigger", impatient_player );

if( is_player_valid( impatient_player ) )

{

level._end_door_intro = true;

}

}

}

engage()

{

ship_wheel = GetEnt( "sm_ship_wheel", "targetname" );

wheel_turn_right = GetEnt( "t_rotate_wheel_right", "targetname" );

wheel_turn_left = GetEnt( "t_rotate_wheel_left", "targetname" );

ship_wheel.spot = 0;

wheel_turn_right thread press_the_button( 1 );

wheel_turn_left thread press_the_button( 0 );

right_lever_trigger = GetEnt( "trig_eot_right_switch", "targetname" );

left_lever_trigger = GetEnt( "trig_eot_left_switch", "targetname" );

right_lever = GetEnt( right_lever_trigger.target, "targetname" );

right_lever.spot = 0;

left_lever = GetEnt( left_lever_trigger.target, "targetname" );

left_lever.spot = 0;

right_lever_trigger thread egg_drop_soup();

left_lever_trigger thread egg_drop_soup();

level thread eyes_on_the_wall( ship_wheel, right_lever, left_lever );

}

press_the_button( i_direction )

{

level endon( "shs" );

self UseTriggerRequireLookAt();

self SetHintString( "" );

wheel = GetEnt( self.target, "targetname" );

flag_wait( "power_on" );

while( !flag( "shs" ) )

{

self waittill( "trigger" );

if( i_direction == 0 )

{

wheel RotateRoll( 60, 0.2, 0, 0 );

wheel PlaySound( "zmb_galactic_rose" );

wheel waittill( "rotatedone" );

wheel.spot = wheel.spot - 1;

if( wheel.spot < 0 )

{

wheel.spot = 5;

}

}

else

{

wheel RotateRoll( -60, 0.2, 0, 0 );

wheel PlaySound( "zmb_galactic_rose" );

wheel waittill( "rotatedone" );

wheel.spot = wheel.spot + 1;

if( wheel.spot > 5 )

{

wheel.spot = 0;

}

}

}

}

egg_drop_soup()

{

level endon( "shs" );

self UseTriggerRequireLookAt();

self SetHintString( "" );

lever = GetEnt( self.target, "targetname" );

flag_wait( "power_on" );

while( !flag( "shs" ) )

{

self waittill( "trigger" );

if( lever.spot == 4 )

{

lever RotateRoll( -100, 0.2 );

lever.spot = 0;

lever PlaySound( "zmb_transatlantic_rose" );

lever waittill( "rotatedone" );

}

else

{

lever RotateRoll( 25, 0.2 );

lever.spot = lever.spot + 1;

lever PlaySound( "zmb_transatlantic_rose" );

lever waittill( "rotatedone" );

}

}

}

cancer()

{

level thread coast_egg_fuse_controller();

level thread coast_egg_fuse_box_think();

}

coast_egg_fuse_box_think()

{

fuse_box_trigger = GetEnt( "trig_fuse_replace", "targetname" );

fuse_box = GetEnt( "ent_fuse_box", "targetname" );

if( !IsDefined( fuse_box_trigger ) )

{

return;

}

fuse_box_trigger SetCursorHint( "HINT_NOICON" );

fuse_box_trigger SetHintString( "" );

fuse_box_trigger UseTriggerRequireLookAt();

flag_wait( "ffs" );

while( !flag( "ffd" ) )

{

fuse_box_trigger waittill( "trigger", who );

if( IsDefined( who._fuse_acquired ) && who._fuse_acquired == 1 )

{

who._fuse_acquired = undefined;

if( IsDefined( fuse_box ) )

{

spawn_spot = fuse_box GetTagOrigin( "tag_fuse" );

if( IsDefined( spawn_spot ) )

{

fuse_attached = Spawn( "script_model", spawn_spot );

fuse_attached.angles = fuse_box GetTagAngles( "tag_fuse" );

fuse_attached SetModel( "p_zom_fuse" );

fuse_attached PlaySound( "zmb_winepull" );

level.egg_sound_ent PlaySound( "zmb_craziness_supreme" );

exploder( 780 );

}

}

who thread coast_remove_eggs_hud();

fuse_placed = true;

flag_set( "ffd" );

level thread coast_egg_fuse_starts_holy( who );

}

else

{

wait( 0.1 );

}

}

}

coast_egg_fuse_controller()

{

fuse_array = getstructarray( "struct_ep", "targetname" );

fuse_delivered = undefined;

fuse_array = array_randomize( fuse_array );

flag_wait( "ffs" );

while( !flag( "ffd" ) )

{

for( i = 0; i < fuse_array.size; i++ )

{

fuse_array[i].object = Spawn( "script_model", fuse_array[i].origin );

fuse_array[i].object.angles = fuse_array[i].angles;

fuse_array[i].object SetModel( fuse_array[i].script_parameters );

fuse_array[i].object.starter = GetEnt( fuse_array[i].target, "targetname" );

fuse_array[i].object.starter UseTriggerRequireLookAt();

fuse_array[i].object.starter SetCursorHint( "HINT_NOICON" );

fuse_array[i].object.starter EnableLinkTo();

fuse_array[i].object.starter LinkTo( fuse_array[i].object );

fuse_array[i].object coast_egg_fuse_think();

fuse_delivered = coast_egg_fuse_lost( "fuse_lost", "ffd" );

if( IsDefined( fuse_delivered ) && is_true( fuse_delivered ) )

{

return;

}

}

wait( 1.0 );

}

for( i = 0; i < fuse_array.size; i++ )

{

if( !IsDefined( fuse_array[i].object.starter ) )

{

fuse_array[i].object.starter = GetEnt( fuse_array[i].target, "targetname" );

}

fuse_array[i].starter Delete();

if( IsDefined( fuse_array[i].object ) )

{

fuse_array[i].object Delete();

}

}

array_delete( fuse_array );

}

coast_egg_fuse_lost( str_endon, str_waittill )

{

level endon( str_endon );

level waittill( str_waittill );

return true;

}

coast_egg_fuse_think()

{

fuse_found = false;

while( !fuse_found )

{

self.starter waittill( "trigger", who );

if( IsDefined( who ) && is_player_valid( who ) )

{

who._fuse_acquired = 1;

who PlaySound( "zmb_grabit_wontyou" );

who maps\_zombiemode_audio::create_and_play_dialog( "eggs", "coast_response", undefined, 1 );

who thread coast_eggs_hud( "zom_hud_icon_fuse", "ffd" );

who thread coast_egg_clear_fuse_on_death();

fuse_found = true;

}

}

self trigger_off();

self Hide();

}

coast_egg_clear_fuse_on_death()

{

self endon( "disconnect" );

level endon( "ffd" );

level thread coast_egg_clear_fuse_on_disconnect( self );

self waittill_any( "death", "_zombie_game_over", "spawned_spectator" );

if( IsDefined( self ) )

{

self._fuse_acquired = undefined;

}

level notify( "fuse_lost" );

}

coast_egg_clear_fuse_on_disconnect( ent_ply )

{

level endon( "ffd" );

level endon( "fuse_lost" );

ent_ply endon( "death" );

ent_ply waittill( "disconnect" );

level notify( "fuse_lost" );

}

coast_egg_fuse_starts_holy( ent_player )

{

knock_trig = GetEnt( "e_gargoyle", "targetname" );

players = GetPlayers();

level thread force_wait_for_forcefield_looper();

level maps\zombie_coast_amb::play_characters_skits_etc( ent_player, knock_trig, 2, 2, 3, undefined );

}

aries()

{

flag_wait( "hgs" );

enta_made_the_shot_trigger = GetEntArray( "trig_holy_g_damage", "targetname" );

metal_door = GetEnt( "ent_metal_door", "targetname" );

if( !IsDefined( enta_made_the_shot_trigger ) )

{

return;

}

exploder( 770 );

for( i = 0; i < enta_made_the_shot_trigger.size; i++ )

{

if( level flag_exists( "hg" + i ) )

{

enta_made_the_shot_trigger[i] thread coast_egg_power_source_react( "hg" + i );

}

else

{

PrintLn( "***************************** more triggers than flags set up! *********************************************" );

}

}

level thread coast_egg_holy_grenade_watcher();

flag_wait( "hgd" );

stop_exploder( 770 );

}

coast_egg_power_source_react( str_flag )

{

rtg = getstruct( self.target, "targetname" );

field = undefined;

if( IsDefined( rtg ) )

{

field = Spawn( "script_model", rtg.origin );

field.angles = rtg.angles;

field SetModel( "tag_origin" );

field PlayLoopSound( "zmb_wizzybizzy_loop", 1 );

PlayFXOnTag( level._effect[ "rtg_field" ], field, "tag_origin" );

}

self._source_damaged = false;

while( !self._source_damaged )

{

self waittill( "damage", i_amount, e_attacker, v_direction, vec_position, i_dmg_type, str_model_name, str_tagname );

if( is_player_valid( e_attacker ) && ( i_dmg_type == level.trials[0] || i_dmg_type == level.trials[1] ) )

{

flag_set( str_flag );

self._source_damaged = true;

field StopLoopSound( .1 );

field PlaySound( "zmb_wizzybizzy_explo" );

}

}

if( IsDefined( field ) )

{

field Delete();

}

self trigger_off();

self Delete();

}

coast_egg_holy_grenade_watcher()

{

flag_wait_all( "hg0", "hg1", "hg2", "hg3" );

flag_set( "hgd" );

}

virgo()

{

enta_egg_ice_break_trigger = GetEntArray( "trig_egg_break_ice", "targetname" );

ice_blocks = GetEntArray( "ent_bartender", "targetname" );

holsters = getstructarray( "struct_that_thing", "targetname" );

if( !IsDefined( enta_egg_ice_break_trigger ) )

{

return;

}

if( !IsDefined( ice_blocks ) )

{

return;

}

if( !IsDefined( holsters ) )

{

return;

}

holsters = array_randomize( holsters );

flag_wait( "bs" );

level thread coast_egg_bottle_delivered();

level thread coast_egg_bartender( holsters );

}

coast_egg_bartender( structs )

{

level endon( "bd" );

while( !flag( "bd" ) )

{

for( i = 0; i < structs.size; i++ )

{

wait( 0.1 );

another = structs[i] coast_egg_bottle_think();

if( IsDefined( another ) && another )

{

level waittill_either( "butterfingers", "bd" );

}

}

wait( 0.1 );

structs = array_randomize( structs );

}

}

coast_egg_bottle_think()

{

level endon( "bd" );

second_spot = getstruct( self.target, "targetname" );

dropper = undefined;

e_ice_block = Spawn( "script_model", self.origin );

e_ice_block.angles = self.angles;

e_ice_block SetModel( "p_zom_ice_chunk_03" );

e_bottle = Spawn( "script_model", second_spot.origin );

e_bottle.angles = second_spot.angles;

e_bottle SetModel( "p_zom_vodka_bottle" );

e_icebreaker = Spawn( "trigger_damage", self.origin, 0, 11, 13 );

e_catch_trig = Spawn( "trigger_radius", e_bottle.origin, 0, 10, 10 );

e_inflictor = undefined;

Assert( IsDefined( e_icebreaker ) );

Assert( IsDefined( e_bottle ) );

Assert( IsDefined( e_catch_trig ) );

e_catch_trig EnableLinkTo();

e_catch_trig LinkTo( e_bottle );

e_icebreaker EnableLinkTo();

e_icebreaker LinkTo( e_ice_block );

bottle_end = e_bottle.origin + ( 0, 0, -500 );

ice_solid = true;

while( ice_solid )

{

e_icebreaker waittill( "damage", i_amt, e_inflictor, vec_direction, vec_point, mod_type );

if( is_player_valid( e_inflictor ) && mod_type == level.trials[2] )

{

ice_solid = false;

}

}

e_ice_block Delete();

e_icebreaker Delete();

end_point = PhysicsTrace( e_bottle.origin, bottle_end );

e_bottle NotSolid();

e_bottle MoveTo( end_point, 1.4, 0.2, 0 );

player_caught = e_bottle coast_egg_bottle_caught( e_catch_trig );

level notify( "stop_egg_debug" );

if( IsDefined( player_caught ) && is_player_valid( player_caught ) )

{

player_caught PlaySound( "zmb_worf_speed" );

player_caught maps\_zombiemode_audio::create_and_play_dialog( "eggs", "coast_response", undefined, 7 );

player_caught._bottle_acquired = 1;

player_caught thread coast_egg_clear_bottle_on_death();

player_caught thread coast_eggs_hud( "zom_hud_icon_bottle", "bd" );

e_catch_trig Unlink();

e_catch_trig Delete();

e_bottle Hide();

e_bottle Delete();

return true;

}

else

{

if( IsDefined( e_inflictor ) )

{

e_inflictor maps\_zombiemode_audio::create_and_play_dialog( "eggs", "coast_response", undefined, 6 );

}

e_bottle PlaySound( "zmb_worf_speed_fail" );

e_catch_trig Unlink();

e_catch_trig Delete();

e_bottle Hide();

e_bottle Delete();

return false;

}

}

coast_egg_bottle_caught( e_trigger )

{

self endon( "movedone" );

while( IsDefined( e_trigger ) )

{

e_trigger waittill( "trigger", who );

if( is_player_valid( who ) )

{

return who;

}

}

}

coast_egg_clear_bottle_on_death()

{

self endon( "disconnect" );

level endon( "bd" );

level thread coast_egg_clear_bottle_on_disconnect( self );

self waittill_any( "death", "_zombie_game_over", "spawned_spectator" );

if( IsDefined( self ) )

{

self._bottle_acquired = undefined;

}

level notify( "butterfingers" );

}

coast_egg_clear_bottle_on_disconnect( ent_ply )

{

level endon( "bd" );

level endon( "butterfingers" );

ent_ply endon( "death" );

ent_ply waittill( "disconnect" );

level notify( "butterfingers" );

}

coast_egg_bottle_delivered()

{

e_delivery_trigger = GetEnt( "trig_deliver", "targetname" );

delivery_tube = GetEnt( e_delivery_trigger.target, "targetname" );

if( !IsDefined( e_delivery_trigger ) )

{

return;

}

e_delivery_trigger SetHintString( "" );

while( IsDefined( e_delivery_trigger ) )

{

e_delivery_trigger waittill( "trigger", who );

if( IsDefined( who._bottle_acquired ) && who._bottle_acquired == 1 )

{

who thread coast_remove_eggs_hud();

who._bottle_acquired = 0;

if( IsDefined( delivery_tube ) )

{

spawn_point = delivery_tube GetTagOrigin( "tag_tube" );

device = Spawn( "script_model", spawn_point );

device.angles = delivery_tube GetTagAngles( "tag_tube" );

device SetModel( "p_zom_vodka_bottle" );

device PlaySound( "zmb_whooooosh" );

device MoveZ( 40, 1.0 );

device waittill( "movedone" );

device Delete();

}

break;

}

}

flag_set( "bd" );

}

coast_egg_bottle_cleanup()

{

e_bottle = GetEnt( self.target, "targetname" );

if( IsDefined( e_bottle ) )

{

e_bottle Delete();

}

self Delete();

}

denlo()

{

radios = GetEntArray( "hello_world", "targetname" );

for( i = 0; i < radios.size; i++ )

{

radios[i] SetCursorHint( "HINT_NOICON" );

radios[i] SetHintString( "" );

radios[i] UseTriggerRequireLookAt();

radios[i] thread coast_egg_art_critic_message();

}

}

coast_egg_art_critic_message()

{

level endon( "aca" );

if( !IsDefined( self.script_special ) )

{

return;

}

if( !IsDefined( self.script_string ) )

{

return;

}

flag_wait( "power_on" );

while( !flag( "aca" ) )

{

self waittill( "trigger", dj );

if( is_player_valid( dj ) )

{

if( !flag( "ke" ) )

{

self PlaySound( "zmb_radio_morse_static" );

wait( 0.1 );

}

if( flag( "ke" ) )

{

self PlaySound( self.script_string );

if( !IsDefined( level._reach ) )

{

level._reach = [];

}

heard = level call_out( self.script_parameters );

if( IsDefined( heard ) && heard )

{

flag_set( "aca" );

}

}

}

}

}

call_out( str_message )

{

level endon( "aca" );

level._reach = add_to_array( level._reach, str_message );

if( level._reach.size == level.contact.size )

{

for( i = 0; i < level.contact.size; i++ )

{

if( level._reach[i] != level.contact[i] )

{

level._reach = undefined;

return false;

}

}

return true;

}

}

pisces()

{

flag_wait( "aca" );

level._serenade = [];

ClientNotify( "lmc" );

level thread metal_horse();

flag_wait( "bp" );

flag_set( "mcs" );

}

eyes_on_the_wall( spinner, starboard, port )

{

Assert( IsDefined( spinner.spot ) );

Assert( IsDefined( starboard.spot ) );

Assert( IsDefined( port.spot ) );

flag_wait( "aca" );

while( 1 )

{

if( spinner.spot == level.mermaid[0] && starboard.spot == level.mermaid[2] && port.spot == level.mermaid[1] )

{

playsoundatposition( "zmb_ship_horn_poweron", (-694, -990, 1025 ) );

flag_set( "shs" );

ClientNotify( "slc" );

return;

}

wait( 0.1 );

}

}

metal_horse()

{

horse_struct = getstruct( "struct_thunder", "targetname" );

flag_wait( "shs" );

wait( 2.0 );

horse = Spawn( "script_model", horse_struct.origin );

horse.angles = horse_struct.angles;

horse SetModel( "p_zom_minisub" );

horse NotSolid();

horse PlaySound( "zmb_forward_march" );

horse MoveZ( 325, 5.0 );

horse waittill( "movedone" );

flag_set( "sr" );

if( level._e_group )

{

while( !flag( "bp" ) )

{

for( i = 0; i < level.mermaid.size; i++ )

{

sound = "zmb_sub_tone_" + level.mermaid[i];

horse PlaySound( sound );

wait( 2.0 );

}

song = coast_egg_fuse_lost( "can_not_sing", "bp" );

if( is_true( song ) )

{

break;

}

else

{

horse MoveZ( -325, 5.0 );

horse waittill( "movedone" );

flag_clear( "sr" );

level waittill( "between_round_over" );

wait( 5.0 );

horse PlaySound( "zmb_forward_march" );

horse MoveZ( 325, 10.0 );

horse waittill( "movedone" );

flag_set( "sr" );

}

}

}

else

{

for( i = 0; i < level.mermaid.size; i++ )

{

sound = "zmb_sub_tone_" + level.mermaid[i];

horse PlaySound( sound );

wait( 2.0 );

}

flag_set( "bp" );

flag_set( "ss" );

}

exploder( 750 );

if( !level._e_group )

{

exploder( 755 );

}

flag_wait( "re" );

stop_exploder( 750 );

horse MoveZ( -325, 2.0 );

horse waittill( "movedone" );

horse Delete();

}

noisemakers()

{

enta_sound_beacon_triggers = GetEntArray( "trig_use_sound_beacon", "targetname" );

array_thread( enta_sound_beacon_triggers, ::coast_egg_musical_chairs_beach_beacon_used );

}

coast_egg_musical_chairs_beach_beacon_used()

{

self UseTriggerRequireLookAt();

self SetHintString( "" );

while( 1 )

{

self waittill( "trigger", who );

if( is_player_valid( who ) )

{

if( flag( "power_on" ) )

{

sound = "zmb_sub_tone_" + self.script_int;

self PlaySound( sound );

}

if( flag( "sr" ) )

{

if( !IsDefined( level._serenade ) )

{

level._serenade = [];

}

level._serenade[ level._serenade.size ] = self.script_int;

if( level._serenade.size == level.mermaid.size )

{

if( coast_egg_musical_check() )

{

flag_set( "bp" );

}

else

{

level notify( "can_not_sing" );

level._serenade = undefined;

level._serenade = [];

}

}

}

}

}

}

coast_egg_musical_check()

{

Assert( IsDefined( level._serenade ) );

Assert( IsDefined( level.mermaid ) );

for( i = 0; i < level.mermaid.size; i++ )

{

if( level._serenade[i] != level.mermaid[i] )

{

return false;

}

}

return true;

}

libra()

{

flag_wait( "mcs" );

flag_set( "hn" );

flag_wait( "mm" );

flag_set( "ss" );

}

rotary_styles()

{

enta_harmony_triggers = GetEntArray( "trig_pure_harmony", "targetname" );

if( !IsDefined( enta_harmony_triggers ) )

{

return;

}

level._dials = [];

level._dials[0] = -1;

level._dials[1] = -1;

level._dials[2] = -1;

level._dials[3] = -1;

for( i = 0; i < enta_harmony_triggers.size; i++ )

{

rand = RandomInt( 9 );

enta_harmony_triggers[i] coast_egg_dial_setup( rand );

}

for( i = 0; i < enta_harmony_triggers.size; i++ )

{

enta_harmony_triggers[i] thread coast_egg_dial_think();

}

}

coast_egg_dial_setup( int_start_spot )

{

dial = GetEnt( self.target, "targetname" );

dial.pos = 0;

dial ent_flag_init( "rotating" );

level._dials[self.script_special] = dial;

if( IsDefined( int_start_spot ) )

{

for( i = 0; i < int_start_spot; i++ )

{

if( dial.pos == int_start_spot )

{

return;

}

level coast_egg_dial_rotate( dial );

}

}

}

coast_egg_dial_think()

{

dial = GetEnt( self.target, "targetname" );

partners = self.script_vector;

self SetHintString( "" );

self SetCursorHint( "HINT_NOICON" );

flag_wait( "power_on" );

sound = "zmb_harmonizer_tone_" + dial.pos;

dial PlayLoopSound( sound );

while( 1 )

{

self waittill( "trigger", who );

if( is_player_valid( who ) )

{

level coast_egg_dial_rotate( dial );

if( GetDvarInt( #"scr_coast_egg_debug" ) )

{

}

else

{

other_dials = GetEntArray( self.targetname, "targetname" );

for( i = 0; i < other_dials.size; i++ )

{

if( other_dials[i].script_special == partners[0] )

{

partner_dial = GetEnt( other_dials[i].target, "targetname" );

if( IsDefined( partner_dial ) )

{

level coast_egg_dial_rotate( partner_dial );

}

else

{

}

}

else if( other_dials[i].script_special == partners[1] )

{

partner_dial = GetEnt( other_dials[i].target, "targetname" );

if( IsDefined( partner_dial ) )

{

level coast_egg_dial_rotate( partner_dial );

}

else

{

}

}

else if( other_dials[i].script_special == partners[2] )

{

partner_dial = GetEnt( other_dials[i].target, "targetname" );

if( IsDefined( partner_dial ) )

{

level coast_egg_dial_rotate( partner_dial );

}

else

{

}

}

}

}

if( flag( "hn" ) )

{

if( coast_egg_dials_in_harmony() )

{

flag_set( "mm" );

exploder( 755 );

}

}

}

}

}

coast_egg_dial_rotate( ent_dial )

{

if( !IsDefined( ent_dial.pos ) )

{

ent_dial.pos = 0;

}

while( ent_dial ent_flag( "rotating" ) )

{

wait( 0.1 );

}

ent_dial ent_flag_set( "rotating" );

ent_dial RotatePitch( 36, 0.2 );

ent_dial waittill( "rotatedone" );

ent_dial.pos++;

if( ent_dial.pos > 9 )

{

ent_dial.pos = 0;

}

sound = "zmb_harmonizer_tone_" + ent_dial.pos;

if( flag( "power_on" ) )

{

ent_dial PlayLoopSound( sound );

}

ent_dial ent_flag_clear( "rotating" );

}

coast_egg_dials_in_harmony()

{

Assert( IsDefined( level._dials ) );

Assert( IsDefined( level.together_again ) );

match = true;

for( i = 0; i < level.together_again.size; i++ )

{

if( level._dials[i].pos != level.together_again[i] )

{

match = false;

}

}

return match;

}

leo()

{

flag_wait( "ss" );

level thread coast_egg_sacrifice_spot_start();

level thread coast_egg_device_delivered();

flag_wait( "re" );

flag_wait( "s_s" );

}

coast_egg_sacrifice_spot_start()

{

level._humangun_escape_override = getstruct( "struct_sacrifice_grabbed_by_light", "targetname" );

middle_of_the_light = getstruct( "struct_middle_of_light", "targetname" );

top_of_the_house = getstruct( "struct_top_of_the_house", "targetname" );

trig_reached_light = GetEnt( "trig_human_into_the_light", "targetname" );

trig_gotcha = GetEnt( "trig_mine", "targetname" );

reward = undefined;

light_mover = undefined;

who = undefined;

move_dist = undefined;

fx_spot = undefined;

if( !IsDefined( level._humangun_escape_override ) )

{

return;

}

trig_reached_light PlaySound( "zmb_varoooooom" );

trig_reached_light PlayLoopSound( "zmb_varoooooom_loop", 3 );

while( !flag( "re" ) )

{

while( !flag( "sa" ) )

{

trig_reached_light waittill( "trigger", who );

if( IsDefined( who ) && IsAlive( who ) && !IsPlayer( who ) && who.animname == "human_zombie" )

{

light_mover = Spawn( "script_model", who.origin );

light_mover.angles = who.angles;

light_mover SetModel( "tag_origin" );

who LinkTo( light_mover );

who.animname = "dancer";

who thread beat_break( %ai_zombie_flinger_flail );

light_mover thread watch_for_death( who );

light_mover thread rotate_while_moving();

who.ignoreme = true;

who disable_pain();

who._lighthouse_owned = true;

who thread magic_bullet_shield();

level._zombie_human_array = array_remove( level._zombie_human_array, who );

who.humangun_zombie_1st_hit_was_upgraded = undefined;

level._humangun_escape_override = undefined;

who thread rising_watch( light_mover );

light_mover MoveTo( middle_of_the_light.origin, 2.0 );

light_mover waittill_notify_or_timeout( "movedone", 2.0 );

if( IsDefined( who ) && IsAlive( who ) )

{

flag_set( "sa" );

}

if( !IsDefined( light_mover ) )

{

continue;

}

}

}

if( IsDefined( light_mover ) )

{

move_dist = top_of_the_house.origin[2] - middle_of_the_light.origin[2];

light_mover MoveZ( move_dist, 25 );

light_mover waittill_notify_or_timeout( "movedone", 25.0 );

if( !IsDefined( light_mover ) )

{

continue;

}

light_mover notify( "completed" );

fx_spot = Spawn( "script_model", light_mover.origin + ( 0, 0, -60 ) );

fx_spot SetModel( "tag_origin" );

fx_spot PlaySound( "zmb_northern_lights" );

PlayFXOnTag( level._effect[ "fx_zmb_coast_sacrifice_flash" ], fx_spot, "tag_origin" );

fx_spot thread rotate_while_moving();

}

if( IsDefined( who ) )

{

if( is_true( who._light_accept ) )

{

reward = Spawn( "script_model", light_mover.origin );

reward.angles = light_mover.angles;

reward SetModel( "p_zom_vril_device" );

reward PlayLoopSound( "zmb_shimmer_sweetly_loop" );

}

who._lighthouse_owned = undefined;

who thread stop_magic_bullet_shield();

who Unlink();

who Hide();

who DoDamage( who.health + 10, who.origin );

}

if( IsDefined( light_mover ) )

{

if( IsDefined( reward ) )

{

reward LinkTo( light_mover );

back_down = ( move_dist - 45 ) * -1;

light_mover thread rotate_while_moving();

light_mover MoveZ( back_down, 5.0 );

light_mover waittill( "movedone" );

grabbed = false;

while( !grabbed )

{

trig_gotcha waittill( "trigger", grabber );

if( is_player_valid( grabber ) )

{

level thread device_return_from_death( reward.origin );

grabber thread device_replace_on_death();

fx_spot notify( "completed" );

light_mover notify( "completed" );

fx_spot Delete();

reward StopLoopSound( .1 );

reward PlaySound( "zmb_tingling_sensation" );

grabber thread coast_eggs_hud( "zom_hud_icon_vril", "s_s" );

reward Unlink();

reward Delete();

grabber._has_device = true;

grabber maps\_zombiemode_audio::create_and_play_dialog( "eggs", "coast_response", undefined, 12 );

grabbed = true;

level._humangun_escape_override = undefined;

flag_set( "re" );

stop_exploder( 755 );

}

}

}

else

{

level._humangun_escape_override = getstruct( "struct_sacrifice_grabbed_by_light", "targetname" );

flag_clear( "sa" );

}

light_mover Delete();

}

wait( 0.1 );

}

}

device_return_from_death( vec_spot )

{

level endon( "s_s" );

trig_gotcha = GetEnt( "trig_mine", "targetname" );

while( !flag( "s_s" ) )

{

level waittill( "device_lost" );

device = Spawn( "script_model", vec_spot );

device thread rotate_while_moving();

device SetModel( "p_zom_vril_device" );

device PlayLoopSound( "zmb_shimmer_sweetly_loop" );

grabbed = false;

while( !grabbed )

{

trig_gotcha waittill( "trigger", who );

if( is_player_valid( who ) )

{

device notify( "completed" );

device StopLoopSound( .1 );

device PlaySound( "zmb_tingling_sensation" );

who thread coast_eggs_hud( "zom_hud_icon_vril", "s_s" );

device Delete();

who._has_device = true;

who maps\_zombiemode_audio::create_and_play_dialog( "eggs", "coast_response", undefined, 12 );

grabbed = true;

}

}

}

}

watch_for_death( ent_guy )

{

self endon( "completed" );

ent_guy waittill( "death" );

if( IsDefined( ent_guy ) )

{

ent_guy Unlink();

}

flag_clear( "sa" );

level._humangun_escape_override = getstruct( "struct_sacrifice_grabbed_by_light", "targetname" );

self Delete();

}

rotate_while_moving()

{

self endon( "completed" );

while( IsDefined( self ) )

{

self RotateYaw( 360, 4.0 );

self waittill( "rotatedone" );

}

}

device_replace_on_death()

{

self endon( "disconnect" );

level endon( "s_s" );

level thread lost_salvation( self );

self waittill_any( "death", "_zombie_game_over", "spawned_spectator" );

if( IsDefined( self ) )

{

self._has_device = undefined;

}

level notify( "device_lost" );

}

lost_salvation( ent_ply )

{

level endon( "s_s" );

ent_ply endon( "death" );

ent_ply waittill( "disconnect" );

level notify( "device_lost" );

}

rising_watch( org_mover )

{

self endon( "death" );

org_mover endon( "completed" );

players = GetPlayers();

self.essance = 5000 * players.size;

while( self.essance > 0 )

{

self waittill( "damage", i_amount, e_inflictor );

self.essance = self.essance - i_amount;

}

self notify( "switch" );

self thread beat_break( %ai_zombie_dying_back_idle );

self notify( "lighthouse_owned" );

self._light_accept = true;

}

coast_egg_device_delivered()

{

delivery_trig = GetEnt( "trig_deliver", "targetname" );

delivery_tube = GetEnt( delivery_trig.target, "targetname" );

knock_trig = GetEnt( "e_gargoyle", "targetname" );

if( !IsDefined( delivery_trig ) )

{

return;

}

flag_wait( "re" );

delivered = false;

while( !delivered )

{

delivery_trig waittill( "trigger", shorts_man );

if( is_player_valid( shorts_man ) && IsDefined( shorts_man._has_device ) && shorts_man._has_device == true )

{

delivered = true;

shorts_man._has_device = false;

shorts_man thread coast_remove_eggs_hud();

if( IsDefined( delivery_tube ) )

{

spawn_point = delivery_tube GetTagOrigin( "tag_tube" );

device = Spawn( "script_model", spawn_point );

device.angles = delivery_tube GetTagAngles( "tag_tube" );

device SetModel( "p_zom_vril_device" );

device PlaySound( "zmb_whooooosh" );

device MoveZ( 40, 1.0 );

device waittill( "movedone" );

device Delete();

}

flag_set( "s_s" );

level.egg_sound_ent StopLoopSound( 1.5 );

level maps\zombie_coast_amb::play_characters_skits_etc( shorts_man, knock_trig, 13, 5, 14, undefined );

level.egg_sound_ent PlayLoopSound( "zmb_fantastical_worlds_loop", 1.5 );

flag_set( "sdm" );

}

}

}

capricorn()

{

trig_hit = GetEnt( "trig_fix_tv", "targetname" );

fuse_box = GetEnt( "ent_fuse_box", "targetname" );

knock_trig = GetEnt( "e_gargoyle", "targetname" );

fixed = false;

if( !IsDefined( trig_hit ) )

{

return;

}

flag_wait( "sdm" );

level thread coast_egg_broken_spark( fuse_box );

while( !fixed )

{

trig_hit waittill( "damage", i_amount, e_inflictor, v_direction, v_point, mod_type );

if( is_player_valid( e_inflictor ) && mod_type == level.trials[2] )

{

fuse_box PlaySound( "zmb_wizzybizzy_explo" );

level.egg_sound_ent PlaySound( "zmb_craziness_supreme" );

level notify( "stop_spark" );

level maps\zombie_coast_amb::play_characters_skits_etc( e_inflictor, knock_trig, 15, 6, undefined, undefined );

fixed = true;

}

}

flag_set( "dmf" );

level notify( "scrambled" );

level notify( "coast_easter_egg_achieved" );

level thread consequences_will_never_be_the_same();

}

coast_egg_broken_spark( fuse_box )

{

level endon( "stop_spark" );

while( IsDefined( self ) )

{

exploder( 780 );

fuse_box PlaySound( "zmb_jumping_jacks" );

wait( RandomFloatRange( 0.5, 1.2 ) );

}

}

consequences_will_never_be_the_same()

{

struct = getstruct( "consequence", "targetname" );

if( IsDefined( struct ) )

{

level thread maps\_zombiemode_powerups::specific_powerup_drop( "tesla", struct.origin );

}

}

coast_eggs_hud( str_shader, str_endon )

{

self.eggHud = create_simple_hud( self );

self.eggHud.foreground = true;

self.eggHud.sort = 2;

self.eggHud.hidewheninmenu = false;

self.eggHud.alignX = "center";

self.eggHud.alignY = "bottom";

self.eggHud.horzAlign = "user_right";

self.eggHud.vertAlign = "user_bottom";

self.eggHud.x = -225;

self.eggHud.y = 0;

self.eggHud.alpha = 1;

self.eggHud setshader( str_shader, 32, 32 );

self thread	coast_eggs_hud_remove_on_death( str_endon );

}

coast_remove_eggs_hud()

{

self endon( "death" );

if( IsDefined( self.eggHud ) )

{

self.eggHud Destroy();

}

}

coast_eggs_hud_remove_on_death( str_endon )

{

level endon( str_endon );

self waittill_any( "death", "_zombie_game_over", "spawned_spectator" );

self thread coast_remove_eggs_hud();

}

coast_egg_debug_print3d( str_text )

{

self endon( "stop_egg_debug" );

self endon( "death" );

while( IsDefined( self ) )

{

Print3d( self.origin, str_text, ( 0.9, 0.9, 0.9 ), 1, 1, 10 );

wait( 0.5 );

}

}

coast_egg_play_anim( str_anim, str_notify, str_endon )

{

self endon( str_endon );

self endon( "death" );

while( IsDefined( self ) && IsAlive( self ) )

{

time = getAnimLength( str_anim );

self animscripted( str_notify, self.origin, self.angles, str_anim );

wait( time );

}

}