diff --git a/zm_prison_patch/maps/mp/_sticky_grenade.gsc b/zm_prison_patch/maps/mp/_sticky_grenade.gsc new file mode 100644 index 0000000..eb8885c --- /dev/null +++ b/zm_prison_patch/maps/mp/_sticky_grenade.gsc @@ -0,0 +1,12 @@ +#include common_scripts/utility; +#include maps/mp/_utility; + +init() +{ + loadfx( "weapon/crossbow/fx_trail_crossbow_blink_grn_os" ); + loadfx( "weapon/crossbow/fx_trail_crossbow_blink_red_os" ); +} + +watch_bolt_detonation( owner ) +{ +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_amb.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_amb.gsc new file mode 100644 index 0000000..9ff7358 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_amb.gsc @@ -0,0 +1,761 @@ +#include maps/mp/zombies/_zm_sidequests; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/_ambientpackage; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +main() +{ + level.sndperksacolaloopoverride = ::sndperksacolaloop; + level.sndperksacolajingleoverride = ::sndperksacolajingle; + thread sndstingersetup(); + thread sndlastlifesetup(); + thread sndsetupendgamemusicstates(); + thread sndspectatorsetup(); + if ( is_classic() ) + { + thread sndmusicegg(); + } +} + +sndspectatorsetup() +{ + flag_wait( "initial_players_connected" ); + players = getplayers(); + _a31 = players; + _k31 = getFirstArrayKey( _a31 ); + while ( isDefined( _k31 ) ) + { + player = _a31[ _k31 ]; + player thread sndspectatorafterliferevert(); + _k31 = getNextArrayKey( _a31, _k31 ); + } +} + +sndspectatorafterliferevert() +{ + self endon( "disconnect" ); + while ( 1 ) + { + self waittill( "spawned_spectator" ); + while ( self.sessionstate == "spectator" ) + { + wait 1; + } + self clientnotify( "sndSR" ); + } +} + +sndsetupendgamemusicstates() +{ + flag_wait( "start_zombie_round_logic" ); + level thread maps/mp/zombies/_zm_audio::setupmusicstate( "game_over_final_good", "mus_zombie_game_over_final_good", 1, 0, undefined, "SILENCE" ); + level thread maps/mp/zombies/_zm_audio::setupmusicstate( "game_over_final_bad", "mus_zombie_game_over_final_bad", 1, 0, undefined, "SILENCE" ); + level thread maps/mp/zombies/_zm_audio::setupmusicstate( "game_over_nomove", "mus_zombie_game_over_nomove", 1, 0, undefined, "SILENCE" ); +} + +sndperksacolajingle( perksacola ) +{ + if ( !isDefined( self.jingle_is_playing ) ) + { + self.jingle_is_playing = 0; + } + if ( !isDefined( self.script_sound ) ) + { + return; + } + if ( !isDefined( self.sndent ) ) + { + return; + } + if ( self.jingle_is_playing == 0 && level.music_override == 0 ) + { + self.jingle_is_playing = 1; + self.sndent stoploopsound( 1 ); + self.sndent playsoundwithnotify( self.script_sound, "sndJingleDone" ); + self.sndent waittill( "sndJingleDone" ); + self.sndent playloopsound( "zmb_perksacola_alcatraz_loop", 1 ); + self.jingle_is_playing = 0; + } +} + +sndperksacolaloop() +{ + self endon( "death" ); + self.sndent = spawn( "script_origin", self.origin ); + self.sndent playloopsound( "zmb_perksacola_alcatraz_loop", 1 ); + while ( 1 ) + { + wait randomfloatrange( 31, 45 ); + if ( randomint( 100 ) < 15 ) + { + self thread sndperksacolajingle(); + } + } +} + +sndeventstingertriggers() +{ + flag_wait( "start_zombie_round_logic" ); + triggers = getentarray( "sndMusicEventStinger", "targetname" ); + _a105 = triggers; + _k105 = getFirstArrayKey( _a105 ); + while ( isDefined( _k105 ) ) + { + trigger = _a105[ _k105 ]; + trigger thread sndeventstingertriggerthink(); + _k105 = getNextArrayKey( _a105, _k105 ); + } +} + +sndeventstingertriggerthink() +{ + struct = getstruct( self.target, "targetname" ); + while ( 1 ) + { + self waittill( "trigger" ); + playsoundatposition( struct.script_sound, struct.origin ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "trigger_stinger" ); + wait 5; + } +} + +sndeventtension() +{ + flag_wait( "start_zombie_round_logic" ); + wait 30; + struct = spawnstruct(); + while ( 1 ) + { + tension = sndgettensionlevel( struct ); + waittime = tension.waittime; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( tension.tension_level ); + level thread waitfornexttension( waittime ); + level waittill( "sndNextTensionEvent" ); + } +} + +sndgettensionlevel( struct ) +{ + tension_level = 0; + players = getplayers(); + _a148 = players; + _k148 = getFirstArrayKey( _a148 ); + while ( isDefined( _k148 ) ) + { + player = _a148[ _k148 ]; + if ( is_true( player.laststand ) ) + { + tension_level++; + } + _k148 = getNextArrayKey( _a148, _k148 ); + } + num_zombs = get_current_zombie_count(); + if ( num_zombs >= 12 ) + { + tension_level++; + } + enemies = getaispeciesarray( "axis", "all" ); + _a161 = enemies; + _k161 = getFirstArrayKey( _a161 ); + while ( isDefined( _k161 ) ) + { + enemy = _a161[ _k161 ]; + if ( enemy.animname == "brutus_zombie" ) + { + tension_level++; + } + _k161 = getNextArrayKey( _a161, _k161 ); + } + if ( tension_level > 2 ) + { + struct.tension_level = "tension_high"; + struct.waittime = 90; + } + else + { + struct.tension_level = "tension_low"; + struct.waittime = 140; + } + return struct; +} + +waitfornexttension( time ) +{ + level endon( "sndNextTensionEvent" ); + wait time; + level notify( "sndNextTensionEvent" ); +} + +sndboardmonitor() +{ + while ( 1 ) + { + level waittill( "last_board_torn", barrier_origin ); + players = getplayers(); + _a194 = players; + _k194 = getFirstArrayKey( _a194 ); + while ( isDefined( _k194 ) ) + { + player = _a194[ _k194 ]; + if ( distancesquared( player.origin, barrier_origin ) <= 22500 ) + { + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "boards_gone" ); + break; + } + else + { + _k194 = getNextArrayKey( _a194, _k194 ); + } + } + } +} + +locationstingersetup() +{ + level thread locationstingerwait(); +} + +locationstingerwait( zone_name, type ) +{ + array = sndlocationsarray(); + sndnorepeats = 3; + numcut = 0; + level.sndlastzone = undefined; + level thread sndlocationbetweenroundswait(); + for ( ;; ) + { + while ( 1 ) + { + level waittill( "newzoneActive", activezone ); + while ( !sndlocationshouldplay( array, activezone ) ) + { + continue; + } + if ( is_true( level.sndroundwait ) ) + { + } + } + else while ( is_true( level.sndstinger.isplaying ) ) + { + level thread sndlocationqueue( activezone ); + } + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( activezone ); + array = sndcurrentlocationarray( array, activezone, numcut, sndnorepeats ); + level.sndlastzone = activezone; + if ( numcut >= sndnorepeats ) + { + numcut = 0; + } + else + { + numcut++; + } + level waittill( "between_round_over" ); + while ( is_true( level.sndroundwait ) ) + { + wait 0,1; + } + } +} + +sndlocationsarray() +{ + array = []; + array[ 0 ] = "zone_cellblock_east"; + array[ 1 ] = "cellblock_shower"; + array[ 2 ] = "zone_infirmary"; + array[ 3 ] = "zone_citadel_stairs"; + array[ 4 ] = "zone_roof"; + array[ 5 ] = "zone_dock"; + array[ 6 ] = "zone_studio"; + array[ 7 ] = "zone_warden_office"; + return array; +} + +sndlocationshouldplay( array, activezone ) +{ + shouldplay = 0; + _a280 = array; + _k280 = getFirstArrayKey( _a280 ); + while ( isDefined( _k280 ) ) + { + place = _a280[ _k280 ]; + if ( place == activezone ) + { + shouldplay = 1; + } + _k280 = getNextArrayKey( _a280, _k280 ); + } + if ( shouldplay == 0 ) + { + return shouldplay; + } + playersinlocal = 0; + players = getplayers(); + _a291 = players; + _k291 = getFirstArrayKey( _a291 ); + while ( isDefined( _k291 ) ) + { + player = _a291[ _k291 ]; + if ( player maps/mp/zombies/_zm_zonemgr::is_player_in_zone( activezone ) ) + { + if ( !is_true( player.afterlife ) ) + { + playersinlocal++; + } + } + _k291 = getNextArrayKey( _a291, _k291 ); + } + if ( playersinlocal >= 1 ) + { + shouldplay = 1; + } + else + { + shouldplay = 0; + } + return shouldplay; +} + +sndcurrentlocationarray( current_array, activezone, numcut, max_num_removed ) +{ + if ( numcut >= max_num_removed ) + { + current_array = sndlocationsarray(); + } + _a314 = current_array; + _k314 = getFirstArrayKey( _a314 ); + while ( isDefined( _k314 ) ) + { + place = _a314[ _k314 ]; + if ( place == activezone ) + { + arrayremovevalue( current_array, place ); + break; + } + else + { + _k314 = getNextArrayKey( _a314, _k314 ); + } + } + return current_array; +} + +sndlocationbetweenrounds() +{ + level endon( "newzoneActive" ); + activezones = maps/mp/zombies/_zm_zonemgr::get_active_zone_names(); + _a331 = activezones; + _k331 = getFirstArrayKey( _a331 ); + while ( isDefined( _k331 ) ) + { + zone = _a331[ _k331 ]; + if ( isDefined( level.sndlastzone ) && zone == level.sndlastzone ) + { + } + else + { + players = getplayers(); + _a337 = players; + _k337 = getFirstArrayKey( _a337 ); + while ( isDefined( _k337 ) ) + { + player = _a337[ _k337 ]; + if ( is_true( player.afterlife ) ) + { + } + else + { + if ( player maps/mp/zombies/_zm_zonemgr::is_player_in_zone( zone ) ) + { + wait 0,1; + level notify( "newzoneActive" ); + return; + } + } + _k337 = getNextArrayKey( _a337, _k337 ); + } + } + _k331 = getNextArrayKey( _a331, _k331 ); + } +} + +sndlocationbetweenroundswait() +{ + flag_wait( "afterlife_start_over" ); + while ( is_true( level.sndroundwait ) ) + { + wait 0,1; + } + while ( 1 ) + { + level thread sndlocationbetweenrounds(); + level waittill( "between_round_over" ); + while ( is_true( level.sndroundwait ) ) + { + wait 0,1; + } + } +} + +sndlocationqueue( zone ) +{ + level endon( "newzoneActive" ); + while ( is_true( level.sndstinger.isplaying ) ) + { + wait 0,5; + } + level notify( "newzoneActive" ); +} + +sndstingersetup() +{ + level.sndmusicstingerevent = ::sndplaystinger; + level.sndstinger = spawnstruct(); + level.sndstinger.ent = spawn( "script_origin", ( 0, 0, 0 ) ); + level.sndstinger.queue = 0; + level.sndstinger.isplaying = 0; + level.sndstinger.states = []; + level.sndroundwait = 1; + createstingerstate( "door_open", "mus_event_group_03", 2,5, "ignore" ); + createstingerstate( "gondola", "mus_event_tension_strings_01", 0,1, "reject" ); + createstingerstate( "boards_gone", "mus_event_group_02", 0,5, "ignore" ); + createstingerstate( "trigger_stinger", "mus_event_group_02", 0,1, "ignore" ); + createstingerstate( "brutus_spawn", "mus_event_brutus_spawn", 1,5, "queue" ); + createstingerstate( "brutus_death", "mus_event_brutus_death", 0,1, "ignore" ); + createstingerstate( "tension_low", "mus_event_tension_piano_01", 0,75, "reject" ); + createstingerstate( "tension_high", "mus_event_tension_piano_02", 0,75, "reject" ); + createstingerstate( "zone_cellblock_east", "mus_event_location_cellblock", 0,75, "queue" ); + createstingerstate( "zone_infirmary", "mus_event_location_infirmary", 0,75, "queue" ); + createstingerstate( "zone_studio", "mus_event_location_powerroom", 0,75, "queue" ); + createstingerstate( "zone_roof", "mus_event_location_roof", 0,75, "queue" ); + createstingerstate( "cellblock_shower", "mus_event_location_shower", 0,75, "queue" ); + createstingerstate( "zone_citadel_stairs", "mus_event_location_stairwell", 0,75, "queue" ); + createstingerstate( "zone_dock", "mus_event_location_dock", 0,75, "queue" ); + createstingerstate( "zone_warden_office", "mus_event_location_warden", 0,75, "queue" ); + createstingerstate( "piece_1", "mus_event_piece_1", 0, "queue" ); + createstingerstate( "piece_2", "mus_event_piece_2", 0, "queue" ); + createstingerstate( "piece_3", "mus_event_piece_3", 0, "queue" ); + createstingerstate( "piece_4", "mus_event_piece_4", 0, "queue" ); + createstingerstate( "piece_5", "mus_event_piece_5", 0, "queue" ); + createstingerstate( "piece_mid", "mus_event_piece_mid", 0, "ignore" ); + createstingerstate( "gas_1", "mus_event_piece_1", 0, "reject" ); + createstingerstate( "gas_2", "mus_event_piece_2", 0, "reject" ); + createstingerstate( "gas_3", "mus_event_piece_3", 0, "reject" ); + createstingerstate( "gas_4", "mus_event_piece_4", 0, "reject" ); + createstingerstate( "gas_5", "mus_event_piece_5", 0, "reject" ); + createstingerstate( "plane_crafted_1", "mus_event_plane_1", 0, "reject" ); + createstingerstate( "plane_crafted_2", "mus_event_plane_2", 0, "reject" ); + createstingerstate( "plane_crafted_3", "mus_event_plane_3", 0, "reject" ); + createstingerstate( "plane_crafted_4", "mus_event_plane_4", 0, "reject" ); + createstingerstate( "plane_crafted_5", "mus_event_plane_5", 0, "reject" ); + createstingerstate( "trap", "mus_event_trap", 0, "reject" ); + createstingerstate( "tomahawk_1", "mus_event_tomahawk_2", 0,5, "ignore" ); + createstingerstate( "tomahawk_2", "mus_event_tomahawk_3", 0,5, "ignore" ); + createstingerstate( "tomahawk_3", "mus_event_tomahawk_4", 0,5, "ignore" ); + createstingerstate( "quest_generic", "mus_event_quest_generic", 0,5, "reject" ); + createstingerstate( "laundry_defend", "mus_laundry_defend", 0, "ignore" ); + createstingerstate( "plane_takeoff", "mus_event_plane_takeoff", 0, "ignore" ); + createstingerstate( "at_golden_gate", "mus_event_golden_gate", 0, "ignore" ); + createstingerstate( "spoon", "mus_event_spoon", 0, "ignore" ); + createstingerstate( "spork", "mus_event_spork", 0, "ignore" ); + level thread sndstingerroundwait(); + level thread sndboardmonitor(); + level thread locationstingersetup(); +} + +createstingerstate( state, alias, prewait, interrupt ) +{ + s = level.sndstinger; + if ( !isDefined( s.states[ state ] ) ) + { + s.states[ state ] = spawnstruct(); + s.states[ state ].alias = alias; + s.states[ state ].prewait = prewait; + s.states[ state ].interrupt = interrupt; + } +} + +sndplaystinger( state, player ) +{ + s = level.sndstinger; + if ( !isDefined( s.states[ state ] ) ) + { + return; + } + interrupt = s.states[ state ].interrupt == "ignore"; + if ( !is_true( s.isplaying ) || is_true( interrupt ) ) + { + if ( interrupt ) + { + wait s.states[ state ].prewait; + playstinger( state, player, 1 ); + } + else if ( !level.sndroundwait ) + { + s.isplaying = 1; + wait s.states[ state ].prewait; + playstinger( state, player, 0 ); + level notify( "sndStingerDone" ); + s.isplaying = 0; + } + else + { + if ( s.states[ state ].interrupt == "queue" ) + { + level thread sndqueuestinger( state, player ); + } + } + return; + } + if ( s.states[ state ].interrupt == "queue" ) + { + level thread sndqueuestinger( state, player ); + } +} + +playstinger( state, player, ignore ) +{ + s = level.sndstinger; + if ( !isDefined( s.states[ state ] ) ) + { + return; + } + if ( is_true( level.music_override ) ) + { + return; + } + if ( is_true( ignore ) ) + { + if ( isDefined( player ) ) + { + player playsoundtoplayer( s.states[ state ].alias, player ); + } + else + { + s.ent playsound( s.states[ state ].alias ); + } + } + else if ( isDefined( player ) ) + { + player playsoundtoplayer( s.states[ state ].alias, player ); + wait 8; + } + else + { + s.ent playsoundwithnotify( s.states[ state ].alias, "sndStingerDone" ); + s.ent waittill( "sndStingerDone" ); + } +} + +sndqueuestinger( state, player ) +{ + s = level.sndstinger; + if ( is_true( s.queue ) ) + { + return; + } + else + { + s.queue = 1; + while ( 1 ) + { + if ( is_true( level.sndroundwait ) || is_true( s.isplaying ) ) + { + wait 0,5; + continue; + } + else + { + } + } + level thread sndplaystinger( state, player ); + s.queue = 0; + } +} + +sndstingerroundwait() +{ + flag_wait( "afterlife_start_over" ); + wait 28; + level.sndroundwait = 0; + while ( 1 ) + { + level waittill( "end_of_round" ); + level notify( "sndStopBrutusLoop" ); + level thread sndstingerroundwait_start(); + } +} + +sndstingerroundwait_start() +{ + level.sndroundwait = 1; + wait 0,05; + level thread sndstingerroundwait_end(); +} + +sndstingerroundwait_end() +{ + level endon( "end_of_round" ); + level waittill( "between_round_over" ); + wait 28; + level.sndroundwait = 0; +} + +sndlastlifesetup() +{ + flag_wait( "start_zombie_round_logic" ); + if ( flag( "solo_game" ) ) + { + level thread sndlastlife_solo(); + } + else + { + level thread sndlastlife_multi(); + } +} + +sndlastlife_solo() +{ + return; + player = getplayers()[ 0 ]; + while ( 1 ) + { + player waittill( "sndLifeGone" ); + if ( player.lives == 0 ) + { + while ( is_true( player.afterlife ) ) + { + wait 0,1; + } + level notify( "sndStopBrutusLoop" ); + level thread maps/mp/zombies/_zm_audio::change_zombie_music( "last_life" ); + level waittill( "end_of_round" ); + } + } +} + +sndlastlife_multi() +{ + level endon( "end_of_round" ); + level thread sndlastlife_multi_reset(); + sndplayersdead = 0; + while ( 1 ) + { + level waittill( "bleed_out" ); + sndplayersdead++; + players = getplayers(); + if ( ( players.size - sndplayersdead ) <= 1 ) + { + last_alive = sndlastlife_multi_getlastplayer(); + while ( last_alive.lives > 0 ) + { + wait 0,1; + } + while ( is_true( last_alive.afterlife ) ) + { + wait 0,1; + } + level notify( "sndStopBrutusLoop" ); + level thread maps/mp/zombies/_zm_audio::change_zombie_music( "last_life" ); + return; + } + } +} + +sndlastlife_multi_getlastplayer() +{ + level endon( "end_of_round" ); + wait 0,5; + players = getplayers(); + _a645 = players; + _k645 = getFirstArrayKey( _a645 ); + while ( isDefined( _k645 ) ) + { + dude = _a645[ _k645 ]; + if ( dude.sessionstate == "spectator" ) + { + } + else + { + return dude; + } + _k645 = getNextArrayKey( _a645, _k645 ); + } +} + +sndlastlife_multi_reset() +{ + level waittill( "end_of_round" ); + level thread sndlastlife_multi(); +} + +sndmusicegg() +{ + origins = []; + origins[ 0 ] = ( 338, 10673, 1378 ); + origins[ 1 ] = ( 2897, 9475, 1564 ); + origins[ 2 ] = ( -1157, 5217, -72 ); + level.meteor_counter = 0; + level.music_override = 0; + i = 0; + while ( i < origins.size ) + { + level thread sndmusicegg_wait( origins[ i ] ); + i++; + } +} + +sndmusicegg_wait( bottle_origin ) +{ + temp_ent = spawn( "script_origin", bottle_origin ); + temp_ent playloopsound( "zmb_meteor_loop" ); + temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::sndmusicegg_override ); + temp_ent waittill( "main_music_egg_hit", player ); + temp_ent stoploopsound( 1 ); + player playsound( "zmb_meteor_activate" ); + level.meteor_counter += 1; + if ( level.meteor_counter == 3 ) + { + level thread sndmuseggplay( temp_ent, "mus_zmb_secret_song", 170 ); + level thread easter_egg_song_vo( player ); + } + else + { + wait 1,5; + temp_ent delete(); + } +} + +sndmusicegg_override() +{ + if ( is_true( level.music_override ) ) + { + return 0; + } + return 1; +} + +sndmuseggplay( ent, alias, time ) +{ + level.music_override = 1; + wait 1; + ent playsound( alias ); + level thread sndeggmusicwait( time ); + level waittill_either( "end_game", "sndSongDone" ); + ent stopsounds(); + wait 0,05; + ent delete(); + level.music_override = 0; +} + +sndeggmusicwait( time ) +{ + level endon( "end_game" ); + wait time; + level notify( "sndSongDone" ); +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_craftables.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_craftables.gsc new file mode 100644 index 0000000..f2ffda6 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_craftables.gsc @@ -0,0 +1,1006 @@ +#include maps/mp/zm_alcatraz_travel; +#include maps/mp/zm_alcatraz_sq_vo; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_unitrigger; +#include maps/mp/zombies/_zm_craftables; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_weapons; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +init_craftables() +{ + precachestring( &"ZM_PRISON_KEY_DOOR" ); + level.craftable_piece_count = 10; + register_clientfields(); + add_zombie_craftable( "alcatraz_shield_zm", &"ZM_PRISON_CRAFT_RIOT", undefined, &"ZOMBIE_BOUGHT_RIOT", undefined, 1 ); + add_zombie_craftable_vox_category( "alcatraz_shield_zm", "build_zs" ); + make_zombie_craftable_open( "alcatraz_shield_zm", "t6_wpn_zmb_shield_dlc2_dmg0_world", vectorScale( ( 0, 0, 0 ), 90 ), ( 0, 0, level.riotshield_placement_zoffset ) ); + add_zombie_craftable( "packasplat", &"ZM_PRISON_CRAFT_PACKASPLAT", undefined, undefined, ::onfullycrafted_packasplat, 1 ); + add_zombie_craftable_vox_category( "packasplat", "build_bsm" ); + make_zombie_craftable_open( "packasplat", "p6_anim_zm_al_packasplat", vectorScale( ( 0, 0, 0 ), 90 ) ); + level.craftable_piece_swap_allowed = 0; + add_zombie_craftable( "quest_key1" ); + add_zombie_craftable( "plane", &"ZM_PRISON_CRAFT_PLANE", &"ZM_PRISON_CRAFTING_PLANE", undefined, ::onfullycrafted_plane ); + add_zombie_craftable( "refuelable_plane", &"ZM_PRISON_REFUEL_PLANE", &"ZM_PRISON_REFUELING_PLANE", undefined, ::onfullycrafted_refueled ); + in_game_checklist_setup(); +} + +include_key_craftable( craftable_name, model_name ) +{ + part_key = generate_zombie_craftable_piece( craftable_name, undefined, model_name, 32, 15, 0, undefined, ::onpickup_key, undefined, undefined, undefined, undefined, undefined, undefined, 1 ); + part = spawnstruct(); + part.name = craftable_name; + part add_craftable_piece( part_key ); + part.triggerthink = ::maps/mp/zombies/_zm_craftables::setup_craftable_pieces; + include_craftable( part ); +} + +include_craftables() +{ + level.zombie_include_craftables[ "open_table" ].custom_craftablestub_update_prompt = ::prison_open_craftablestub_update_prompt; + craftable_name = "alcatraz_shield_zm"; + riotshield_dolly = generate_zombie_craftable_piece( craftable_name, "dolly", "t6_wpn_zmb_shield_dlc2_dolly", 32, 64, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_riotshield_dolly", 1, "build_zs" ); + riotshield_door = generate_zombie_craftable_piece( craftable_name, "door", "t6_wpn_zmb_shield_dlc2_door", 48, 15, 25, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_riotshield_door", 1, "build_zs" ); + riotshield_clamp = generate_zombie_craftable_piece( craftable_name, "clamp", "t6_wpn_zmb_shield_dlc2_shackles", 32, 15, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_riotshield_clamp", 1, "build_zs" ); + riotshield = spawnstruct(); + riotshield.name = craftable_name; + riotshield add_craftable_piece( riotshield_dolly ); + riotshield add_craftable_piece( riotshield_door ); + riotshield add_craftable_piece( riotshield_clamp ); + riotshield.onbuyweapon = ::onbuyweapon_riotshield; + riotshield.triggerthink = ::riotshieldcraftable; + include_craftable( riotshield ); + craftable_name = "packasplat"; + packasplat_case = generate_zombie_craftable_piece( craftable_name, "case", "p6_zm_al_packasplat_suitcase", 48, 36, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_packasplat_case", 1, "build_bsm" ); + packasplat_fuse = generate_zombie_craftable_piece( craftable_name, "fuse", "p6_zm_al_packasplat_engine", 32, 36, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_packasplat_fuse", 1, "build_bsm" ); + packasplat_blood = generate_zombie_craftable_piece( craftable_name, "blood", "p6_zm_al_packasplat_iv", 32, 15, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_packasplat_blood", 1, "build_bsm" ); + packasplat = spawnstruct(); + packasplat.name = craftable_name; + packasplat add_craftable_piece( packasplat_case ); + packasplat add_craftable_piece( packasplat_fuse ); + packasplat add_craftable_piece( packasplat_blood ); + packasplat.triggerthink = ::packasplatcraftable; + include_craftable( packasplat ); + include_key_craftable( "quest_key1", "p6_zm_al_key" ); + craftable_name = "plane"; + plane_cloth = generate_zombie_craftable_piece( craftable_name, "cloth", "p6_zm_al_clothes_pile_lrg", 48, 15, 0, undefined, ::onpickup_plane, ::ondrop_plane, ::oncrafted_plane, undefined, "tag_origin", undefined, 1 ); + plane_fueltanks = generate_zombie_craftable_piece( craftable_name, "fueltanks", "veh_t6_dlc_zombie_part_fuel", 32, 15, 0, undefined, ::onpickup_plane, ::ondrop_plane, ::oncrafted_plane, undefined, "tag_feul_tanks", undefined, 2 ); + plane_engine = generate_zombie_craftable_piece( craftable_name, "engine", "veh_t6_dlc_zombie_part_engine", 32, 62, 0, undefined, ::onpickup_plane, ::ondrop_plane, ::oncrafted_plane, undefined, "tag_origin", undefined, 3 ); + plane_steering = generate_zombie_craftable_piece( craftable_name, "steering", "veh_t6_dlc_zombie_part_control", 32, 15, 0, undefined, ::onpickup_plane, ::ondrop_plane, ::oncrafted_plane, undefined, "tag_control_mechanism", undefined, 4 ); + plane_rigging = generate_zombie_craftable_piece( craftable_name, "rigging", "veh_t6_dlc_zombie_part_rigging", 32, 15, 0, undefined, ::onpickup_plane, ::ondrop_plane, ::oncrafted_plane, undefined, "tag_origin", undefined, 5 ); + if ( level.is_forever_solo_game ) + { + plane_cloth.is_shared = 1; + plane_fueltanks.is_shared = 1; + plane_engine.is_shared = 1; + plane_steering.is_shared = 1; + plane_rigging.is_shared = 1; + plane_cloth.client_field_state = undefined; + plane_fueltanks.client_field_state = undefined; + plane_engine.client_field_state = undefined; + plane_steering.client_field_state = undefined; + plane_rigging.client_field_state = undefined; + } + plane_cloth.pickup_alias = "sidequest_sheets"; + plane_fueltanks.pickup_alias = "sidequest_oxygen"; + plane_engine.pickup_alias = "sidequest_engine"; + plane_steering.pickup_alias = "sidequest_valves"; + plane_rigging.pickup_alias = "sidequest_rigging"; + plane = spawnstruct(); + plane.name = craftable_name; + plane add_craftable_piece( plane_cloth ); + plane add_craftable_piece( plane_engine ); + plane add_craftable_piece( plane_fueltanks ); + plane add_craftable_piece( plane_steering ); + plane add_craftable_piece( plane_rigging ); + plane.triggerthink = ::planecraftable; + plane.custom_craftablestub_update_prompt = ::prison_plane_update_prompt; + include_craftable( plane ); + craftable_name = "refuelable_plane"; + refuelable_plane_gas1 = generate_zombie_craftable_piece( craftable_name, "fuel1", "accessories_gas_canister_1", 32, 15, 0, undefined, ::onpickup_fuel, ::ondrop_fuel, ::oncrafted_fuel, undefined, undefined, undefined, 6 ); + refuelable_plane_gas2 = generate_zombie_craftable_piece( craftable_name, "fuel2", "accessories_gas_canister_1", 32, 15, 0, undefined, ::onpickup_fuel, ::ondrop_fuel, ::oncrafted_fuel, undefined, undefined, undefined, 7 ); + refuelable_plane_gas3 = generate_zombie_craftable_piece( craftable_name, "fuel3", "accessories_gas_canister_1", 32, 15, 0, undefined, ::onpickup_fuel, ::ondrop_fuel, ::oncrafted_fuel, undefined, undefined, undefined, 8 ); + refuelable_plane_gas4 = generate_zombie_craftable_piece( craftable_name, "fuel4", "accessories_gas_canister_1", 32, 15, 0, undefined, ::onpickup_fuel, ::ondrop_fuel, ::oncrafted_fuel, undefined, undefined, undefined, 9 ); + refuelable_plane_gas5 = generate_zombie_craftable_piece( craftable_name, "fuel5", "accessories_gas_canister_1", 32, 15, 0, undefined, ::onpickup_fuel, ::ondrop_fuel, ::oncrafted_fuel, undefined, undefined, undefined, 10 ); + if ( level.is_forever_solo_game ) + { + refuelable_plane_gas1.is_shared = 1; + refuelable_plane_gas2.is_shared = 1; + refuelable_plane_gas3.is_shared = 1; + refuelable_plane_gas4.is_shared = 1; + refuelable_plane_gas5.is_shared = 1; + refuelable_plane_gas1.client_field_state = undefined; + refuelable_plane_gas2.client_field_state = undefined; + refuelable_plane_gas3.client_field_state = undefined; + refuelable_plane_gas4.client_field_state = undefined; + refuelable_plane_gas5.client_field_state = undefined; + } + refuelable_plane = spawnstruct(); + refuelable_plane.name = craftable_name; + refuelable_plane add_craftable_piece( refuelable_plane_gas1 ); + refuelable_plane add_craftable_piece( refuelable_plane_gas2 ); + refuelable_plane add_craftable_piece( refuelable_plane_gas3 ); + refuelable_plane add_craftable_piece( refuelable_plane_gas4 ); + refuelable_plane add_craftable_piece( refuelable_plane_gas5 ); + refuelable_plane.triggerthink = ::planefuelable; + plane.custom_craftablestub_update_prompt = ::prison_plane_update_prompt; + include_craftable( refuelable_plane ); +} + +register_clientfields() +{ + bits = 1; + registerclientfield( "world", "piece_riotshield_dolly", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_riotshield_door", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_riotshield_clamp", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_packasplat_fuse", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_packasplat_case", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_packasplat_blood", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_key_warden", 9000, bits, "int", undefined, 0 ); + bits = getminbitcountfornum( 10 ); + registerclientfield( "world", "piece_player1", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_player2", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_player3", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_player4", 9000, bits, "int", undefined, 0 ); + bits = getminbitcountfornum( 7 ); + registerclientfield( "world", "quest_state1", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state2", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state3", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state4", 9000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state5", 9000, bits, "int", undefined, 0 ); + bits = 1; + registerclientfield( "world", "quest_plane_craft_complete", 9000, bits, "int", undefined, 0 ); +} + +riotshieldcraftable() +{ + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "riotshield_zm_craftable_trigger", "alcatraz_shield_zm", "alcatraz_shield_zm", &"ZOMBIE_GRAB_RIOTSHIELD", 1, 1 ); +} + +packasplatcraftable() +{ + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "packasplat_craftable_trigger", "packasplat", "packasplat", undefined, 1, 0 ); +} + +planecraftable() +{ + level thread alcatraz_craftable_trigger_think( "plane_craftable_trigger", "plane", "plane", "", 1, 0 ); + level setclientfield( "quest_plane_craft_complete", 0 ); + i = 1; + while ( i <= 5 ) + { + level setclientfield( "quest_state" + i, 2 ); + i++; + } +} + +planefuelable() +{ + level thread planefuelable_think(); +} + +planefuelable_think() +{ + flag_wait( "spawn_fuel_tanks" ); + t_plane_fuelable = getent( "plane_fuelable_trigger", "targetname" ); + t_plane_fuelable trigger_on(); + i = 1; + while ( i <= 5 ) + { + level setclientfield( "quest_state" + i, 5 ); + i++; + } + alcatraz_craftable_trigger_think( "plane_fuelable_trigger", "refuelable_plane", "refuelable_plane", "", 1, 0 ); +} + +ondrop_common( player ) +{ +/# + println( "ZM >> Common part callback onDrop()" ); +#/ + self droponmover( player ); + self.piece_owner = undefined; +} + +onpickup_common( player ) +{ +/# + println( "ZM >> Common part callback onPickup()" ); +#/ + player playsound( "zmb_craftable_pickup" ); + self pickupfrommover(); + self.piece_owner = player; +} + +ondisconnect_common( player ) +{ + level endon( "crafted_" + self.piecename ); + level endon( "dropped_" + self.piecename ); + player_num = player getentitynumber() + 1; + player waittill( "disconnect" ); + switch( self.piecename ) + { + case "cloth": + field_name = "quest_state1"; + in_game_checklist_plane_piece_dropped( "sheets" ); + break; + case "fueltanks": + field_name = "quest_state2"; + in_game_checklist_plane_piece_dropped( "fueltank" ); + break; + case "engine": + field_name = "quest_state3"; + in_game_checklist_plane_piece_dropped( "engine" ); + break; + case "steering": + field_name = "quest_state4"; + in_game_checklist_plane_piece_dropped( "contval" ); + break; + case "rigging": + field_name = "quest_state5"; + in_game_checklist_plane_piece_dropped( "rigging" ); + break; + } + level setclientfield( field_name, 2 ); + level setclientfield( "piece_player" + player_num, 0 ); + m_plane_piece = get_craftable_piece_model( "plane", self.piecename ); + if ( isDefined( m_plane_piece ) ) + { + playfxontag( level._effect[ "quest_item_glow" ], m_plane_piece, "tag_origin" ); + } + m_fuel_can = get_craftable_piece_model( "refuelable_plane", self.piecename ); + if ( isDefined( m_fuel_can ) ) + { + playfxontag( level._effect[ "quest_item_glow" ], m_fuel_can, "tag_origin" ); + } +} + +prison_open_craftablestub_update_prompt( player, b_set_hint_string_now, trigger ) +{ + valid = maps/mp/zombies/_zm_craftables::open_craftablestub_update_prompt( player ); + return valid; +} + +onpickup_key( player ) +{ + flag_set( "key_found" ); + if ( level.is_master_key_west ) + { + level clientnotify( "fxanim_west_pulley_up_start" ); + } + else + { + level clientnotify( "fxanim_east_pulley_up_start" ); + } + a_m_checklist = getentarray( "plane_checklist", "targetname" ); + _a429 = a_m_checklist; + _k429 = getFirstArrayKey( _a429 ); + while ( isDefined( _k429 ) ) + { + m_checklist = _a429[ _k429 ]; + m_checklist showpart( "j_check_key" ); + m_checklist showpart( "j_strike_key" ); + _k429 = getNextArrayKey( _a429, _k429 ); + } + a_door_structs = getstructarray( "quest_trigger", "script_noteworthy" ); + _a437 = a_door_structs; + _k437 = getFirstArrayKey( _a437 ); + while ( isDefined( _k437 ) ) + { + struct = _a437[ _k437 ]; + if ( isDefined( struct.unitrigger_stub ) ) + { + struct.unitrigger_stub maps/mp/zombies/_zm_unitrigger::run_visibility_function_for_all_triggers(); + } + _k437 = getNextArrayKey( _a437, _k437 ); + } + player playsound( "evt_key_pickup" ); + player thread do_player_general_vox( "quest", "sidequest_key_response", undefined, 100 ); + level setclientfield( "piece_key_warden", 1 ); +} + +prison_plane_update_prompt( player, b_set_hint_string_now, trigger ) +{ + return 1; +} + +ondrop_plane( player ) +{ +/# + println( "ZM >> Common part callback onDrop()" ); +#/ + level notify( "dropped_" + self.piecename ); + level.plane_pieces_picked_up -= 1; + self droponmover( player ); + self.piece_owner = undefined; + playfxontag( level._effect[ "quest_item_glow" ], self.model, "tag_origin" ); + switch( self.piecename ) + { + case "cloth": + field_name = "quest_state1"; + in_game_checklist_plane_piece_dropped( "sheets" ); + break; + case "fueltanks": + field_name = "quest_state2"; + in_game_checklist_plane_piece_dropped( "fueltank" ); + break; + case "engine": + field_name = "quest_state3"; + in_game_checklist_plane_piece_dropped( "engine" ); + break; + case "steering": + field_name = "quest_state4"; + in_game_checklist_plane_piece_dropped( "contval" ); + break; + case "rigging": + field_name = "quest_state5"; + in_game_checklist_plane_piece_dropped( "rigging" ); + break; + } + level setclientfield( field_name, 2 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, 0 ); + } +} + +onpickup_plane( player ) +{ +/# + println( "ZM >> Common part callback onPickup()" ); +#/ + if ( !isDefined( level.plane_pieces_picked_up ) ) + { + level.plane_pieces_picked_up = 0; + level.sndplanepieces = 1; + } + level.plane_pieces_picked_up += 1; + if ( level.plane_pieces_picked_up == 5 ) + { + level thread roof_nag_vo(); + } + if ( level.sndplanepieces == level.plane_pieces_picked_up ) + { + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "piece_" + level.sndplanepieces ); + level.sndplanepieces++; + } + player playsound( "zmb_craftable_pickup" ); + vo_alias_call = undefined; + vo_alias_response = undefined; + self pickupfrommover(); + self.piece_owner = player; + switch( self.piecename ) + { + case "cloth": + field_name = "quest_state1"; + in_game_checklist_plane_piece_picked_up( "sheets" ); + break; + case "fueltanks": + field_name = "quest_state2"; + in_game_checklist_plane_piece_picked_up( "fueltank" ); + flag_set( "docks_gates_remain_open" ); + break; + case "engine": + field_name = "quest_state3"; + in_game_checklist_plane_piece_picked_up( "engine" ); + break; + case "steering": + field_name = "quest_state4"; + in_game_checklist_plane_piece_picked_up( "contval" ); + break; + case "rigging": + field_name = "quest_state5"; + in_game_checklist_plane_piece_picked_up( "rigging" ); + break; + } + level setclientfield( field_name, 3 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, self.client_field_state ); + } + vo_alias_call = self check_if_newly_found(); + if ( isDefined( vo_alias_call ) ) + { + level thread play_plane_piece_call_and_response_vo( player, vo_alias_call ); + } + self thread ondisconnect_common( player ); +} + +check_if_newly_found() +{ + if ( !flag( self.piecename + "_found" ) ) + { + switch( self.piecename ) + { + case "fueltanks": + vo_alias_call = "sidequest_oxygen"; + break; + case "cloth": + vo_alias_call = "sidequest_sheets"; + break; + case "engine": + vo_alias_call = "sidequest_engine"; + break; + case "steering": + vo_alias_call = "sidequest_valves"; + break; + case "rigging": + vo_alias_call = "sidequest_rigging"; + break; + } + level.n_plane_pieces_found++; + flag_set( self.piecename + "_found" ); + if ( self.piecename == "cloth" ) + { + level clientnotify( "fxanim_dryer_hide_start" ); + } + return vo_alias_call; + } +} + +play_plane_piece_call_and_response_vo( player, vo_alias_call ) +{ + player endon( "death" ); + player endon( "disconnect" ); + n_response_range = 1500; + players = getplayers(); + if ( !flag( "story_vo_playing" ) ) + { + flag_set( "story_vo_playing" ); + player do_player_general_vox( "quest", vo_alias_call, undefined, 100 ); + wait 5; + if ( players.size > 1 ) + { + arrayremovevalue( players, player ); + closest_other_player = getclosest( player.origin, players ); + if ( isDefined( closest_other_player ) ) + { + n_dist = distance( player.origin, closest_other_player.origin ); + if ( isDefined( closest_other_player ) && n_dist < n_response_range ) + { + if ( level.n_plane_pieces_found < 5 ) + { + vo_alias_response = "sidequest_parts" + level.n_plane_pieces_found + "_prog"; + } + else + { + vo_alias_response = "sidequest_all_parts"; + } + closest_other_player do_player_general_vox( "quest", vo_alias_response, undefined, 100 ); + } + } + } + flag_clear( "story_vo_playing" ); + } +} + +roof_nag_vo() +{ + level notify( "roof_nag_vo" ); + level endon( "roof_nag_vo" ); + zone_roof = getent( "zone_roof", "targetname" ); + zone_roof_infirmary = getent( "zone_roof_infirmary", "targetname" ); + n_roof_nag_wait = 60; + n_roof_nag_max_times = 3; + while ( !flag( "plane_built" ) && n_roof_nag_max_times > 0 ) + { + wait n_roof_nag_wait; + b_is_a_player_on_the_roof = 0; + players = getplayers(); + _a696 = players; + _k696 = getFirstArrayKey( _a696 ); + while ( isDefined( _k696 ) ) + { + player = _a696[ _k696 ]; + if ( player istouching( zone_roof ) || player istouching( zone_roof_infirmary ) ) + { + b_is_a_player_on_the_roof = 1; + } + _k696 = getNextArrayKey( _a696, _k696 ); + } + if ( !b_is_a_player_on_the_roof ) + { + if ( level.plane_pieces_picked_up == 5 ) + { + player = players[ randomintrange( 0, players.size ) ]; + if ( isDefined( player ) ) + { + player do_player_general_vox( "quest", "sidequest_roof_nag", undefined, 100 ); + n_roof_nag_wait *= 1,5; + n_roof_nag_max_times--; + + } + } + } + } +} + +oncrafted_plane( player ) +{ + level notify( "crafted_" + self.piecename ); + m_plane_hideable_engine = getent( "plane_hideable_engine", "targetname" ); + m_plane_hideable_clothes_pile = getent( "plane_hideable_clothes_pile", "targetname" ); + m_plane_hideable_engine ghost(); + m_plane_hideable_clothes_pile ghost(); + plane_craftable = getent( "plane_craftable", "targetname" ); + plane_craftable hidepart( "tag_support_upper" ); + plane_craftable hidepart( "tag_wings_down" ); + plane_craftable hidepart( "tag_wing_skins_down" ); + plane_craftable hidepart( "tag_wing_skins_up" ); + plane_craftable hidepart( "tag_engines_down" ); + plane_craftable hidepart( "tag_engines_up" ); + plane_craftable hidepart( "tag_engines_down" ); + plane_craftable hidepart( "tag_engines_up" ); + plane_craftable hidepart( "tag_engine_ground" ); + plane_craftable hidepart( "tag_clothes_ground" ); + plane_craftable hidepart( "tag_fuel_hose" ); + if ( !isDefined( level.sndplanecrafted ) ) + { + level.sndplanecrafted = 0; + } + level.sndplanecrafted++; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "plane_crafted_" + level.sndplanecrafted ); + if ( is_part_crafted( "plane", "rigging" ) ) + { + plane_craftable showpart( "tag_support_upper" ); + if ( is_part_crafted( "plane", "cloth" ) ) + { + plane_craftable showpart( "tag_wing_skins_up" ); + } + if ( is_part_crafted( "plane", "engine" ) ) + { + plane_craftable showpart( "tag_engines_up" ); + } + } + else + { + plane_craftable showpart( "tag_wings_down" ); + if ( is_part_crafted( "plane", "cloth" ) ) + { + m_plane_hideable_clothes_pile show(); + } + if ( is_part_crafted( "plane", "engine" ) ) + { + m_plane_hideable_engine show(); + } + } + if ( is_part_crafted( "plane", "steering" ) && is_part_crafted( "plane", "fueltanks" ) ) + { + plane_craftable showpart( "tag_fuel_hose" ); + } + switch( self.piecename ) + { + case "cloth": + field_name = "quest_state1"; + in_game_checklist_plane_piece_crafted( "sheets" ); + break; + case "fueltanks": + field_name = "quest_state2"; + in_game_checklist_plane_piece_crafted( "fueltank" ); + break; + case "engine": + field_name = "quest_state3"; + in_game_checklist_plane_piece_crafted( "engine" ); + break; + case "steering": + field_name = "quest_state4"; + in_game_checklist_plane_piece_crafted( "contval" ); + break; + case "rigging": + field_name = "quest_state5"; + in_game_checklist_plane_piece_crafted( "rigging" ); + break; + } + level setclientfield( field_name, 4 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, 0 ); + } +} + +ondrop_fuel( player ) +{ + level notify( "dropped_" + self.piecename ); + self.piece_owner = undefined; + playfxontag( level._effect[ "quest_item_glow" ], self.model, "tag_origin" ); + if ( isDefined( level.sndfuelpieces ) ) + { + level.sndfuelpieces--; + + } + switch( self.piecename ) + { + case "fuel1": + field_name = "quest_state1"; + break; + case "fuel2": + field_name = "quest_state2"; + break; + case "fuel3": + field_name = "quest_state3"; + break; + case "fuel4": + field_name = "quest_state4"; + break; + case "fuel5": + field_name = "quest_state5"; + break; + } + level setclientfield( field_name, 5 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, 0 ); + } +} + +onpickup_fuel( player ) +{ + player playsound( "zmb_craftable_pickup" ); + if ( !isDefined( level.sndfuelpieces ) || level.sndfuelpieces >= 5 ) + { + level.sndfuelpieces = 0; + } + level.sndfuelpieces++; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "gas_" + level.sndfuelpieces ); + self pickupfrommover(); + self.piece_owner = player; + if ( isDefined( player ) ) + { + player do_player_general_vox( "quest", "fuel_pickup", undefined, 100 ); + } + switch( self.piecename ) + { + case "fuel1": + field_name = "quest_state1"; + break; + case "fuel2": + field_name = "quest_state2"; + break; + case "fuel3": + field_name = "quest_state3"; + break; + case "fuel4": + field_name = "quest_state4"; + break; + case "fuel5": + field_name = "quest_state5"; + break; + } + level setclientfield( field_name, 6 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, self.client_field_state ); + } + self thread ondisconnect_common( player ); +} + +oncrafted_fuel( player ) +{ + level notify( "crafted_" + self.piecename ); + level.n_plane_fuel_count++; + switch( self.piecename ) + { + case "fuel1": + field_name = "quest_state1"; + break; + case "fuel2": + field_name = "quest_state2"; + break; + case "fuel3": + field_name = "quest_state3"; + break; + case "fuel4": + field_name = "quest_state4"; + break; + case "fuel5": + field_name = "quest_state5"; + break; + } + level setclientfield( field_name, 7 ); + if ( !level.is_forever_solo_game ) + { + player_num = player getentitynumber() + 1; + level setclientfield( "piece_player" + player_num, 0 ); + } +} + +onfullycrafted_plane( player ) +{ + flag_set( "plane_built" ); + level thread maps/mp/zm_alcatraz_sq_vo::escape_flight_vo(); + level notify( "roof_nag_vo" ); + level setclientfield( "quest_plane_craft_complete", 1 ); + return 0; +} + +onfullycrafted_packasplat( player ) +{ + t_upgrade = getent( "blundergat_upgrade", "targetname" ); + t_upgrade.target = self.target; + t_upgrade.origin = self.origin; + t_upgrade.angles = self.angles; + t_upgrade.m_upgrade_machine = get_craftable_model( "packasplat" ); + return 1; +} + +onfullycrafted_refueled( player ) +{ + flag_set( "plane_built" ); + level thread maps/mp/zm_alcatraz_sq_vo::escape_flight_vo(); + level notify( "roof_nag_vo" ); + thread onfullycrafted_refueled_think( player ); + return 0; +} + +onfullycrafted_refueled_think( player ) +{ + flag_wait( "spawn_fuel_tanks" ); + i = 1; + while ( i <= 5 ) + { + level setclientfield( "quest_state" + i, 5 ); + i++; + } + maps/mp/zombies/_zm_craftables::stub_uncraft_craftable( self, 1, undefined, undefined, 1 ); +} + +sqcommoncraftable() +{ + level.sq_craftable = maps/mp/zombies/_zm_craftables::craftable_trigger_think( "sq_common_craftable_trigger", "sq_common", "sq_common", "", 1, 0 ); +} + +onbuyweapon_riotshield( player ) +{ + if ( isDefined( player.player_shield_reset_health ) ) + { + player [[ player.player_shield_reset_health ]](); + } + if ( isDefined( player.player_shield_reset_location ) ) + { + player [[ player.player_shield_reset_location ]](); + } +} + +onbuyweapon_plane( player ) +{ + level notify( "plane_takeoff" ); + iprintlnbold( "Plane Bought" ); +} + +droponmover( player ) +{ + while ( isDefined( player ) && player maps/mp/zm_alcatraz_travel::is_player_on_gondola() ) + { + str_location = undefined; + if ( isDefined( level.e_gondola.is_moving ) && level.e_gondola.is_moving && isDefined( level.e_gondola.destination ) ) + { + str_location = level.e_gondola.destination; + } + else + { + str_location = level.e_gondola.location; + } + if ( !isDefined( str_location ) ) + { + str_location = "roof"; + } + a_s_part_teleport = getstructarray( "gondola_dropped_parts_" + str_location, "targetname" ); + _a1104 = a_s_part_teleport; + _k1104 = getFirstArrayKey( _a1104 ); + while ( isDefined( _k1104 ) ) + { + struct = _a1104[ _k1104 ]; + if ( isDefined( struct.occupied ) && !struct.occupied ) + { + self.model.origin = struct.origin; + self.model.angles = struct.angles; + struct.occupied = 1; + self.unitrigger.struct_teleport = struct; + return; + } + else + { + _k1104 = getNextArrayKey( _a1104, _k1104 ); + } + } + } +} + +pickupfrommover() +{ + if ( isDefined( self.unitrigger ) ) + { + if ( isDefined( self.unitrigger.struct_teleport ) ) + { + self.unitrigger.struct_teleport.occupied = 0; + self.unitrigger.struct_teleport = undefined; + } + } +} + +in_game_checklist_setup() +{ + a_m_checklist = getentarray( "plane_checklist", "targetname" ); + a_str_partnames = []; + a_str_partnames[ 0 ] = "sheets"; + a_str_partnames[ 1 ] = "fueltank"; + a_str_partnames[ 2 ] = "engine"; + a_str_partnames[ 3 ] = "contval"; + a_str_partnames[ 4 ] = "rigging"; + a_str_partnames[ 5 ] = "key"; + _a1143 = a_m_checklist; + _k1143 = getFirstArrayKey( _a1143 ); + while ( isDefined( _k1143 ) ) + { + m_checklist = _a1143[ _k1143 ]; + _a1145 = a_str_partnames; + _k1145 = getFirstArrayKey( _a1145 ); + while ( isDefined( _k1145 ) ) + { + str_partname = _a1145[ _k1145 ]; + m_checklist hidepart( "j_check_" + str_partname ); + m_checklist hidepart( "j_strike_" + str_partname ); + _k1145 = getNextArrayKey( _a1145, _k1145 ); + } + _k1143 = getNextArrayKey( _a1143, _k1143 ); + } +} + +in_game_checklist_plane_piece_picked_up( str_partname ) +{ + a_m_checklist = getentarray( "plane_checklist", "targetname" ); + _a1157 = a_m_checklist; + _k1157 = getFirstArrayKey( _a1157 ); + while ( isDefined( _k1157 ) ) + { + m_checklist = _a1157[ _k1157 ]; + m_checklist showpart( "j_check_" + str_partname ); + _k1157 = getNextArrayKey( _a1157, _k1157 ); + } +} + +in_game_checklist_plane_piece_dropped( str_partname ) +{ + a_m_checklist = getentarray( "plane_checklist", "targetname" ); + _a1167 = a_m_checklist; + _k1167 = getFirstArrayKey( _a1167 ); + while ( isDefined( _k1167 ) ) + { + m_checklist = _a1167[ _k1167 ]; + m_checklist hidepart( "j_check_" + str_partname ); + _k1167 = getNextArrayKey( _a1167, _k1167 ); + } +} + +in_game_checklist_plane_piece_crafted( str_partname ) +{ + a_m_checklist = getentarray( "plane_checklist", "targetname" ); + _a1177 = a_m_checklist; + _k1177 = getFirstArrayKey( _a1177 ); + while ( isDefined( _k1177 ) ) + { + m_checklist = _a1177[ _k1177 ]; + m_checklist showpart( "j_strike_" + str_partname ); + _k1177 = getNextArrayKey( _a1177, _k1177 ); + } +} + +alcatraz_craftable_trigger_think( trigger_targetname, equipname, weaponname, trigger_hintstring, delete_trigger, persistent ) +{ + return alcatraz_setup_unitrigger_craftable( trigger_targetname, equipname, weaponname, trigger_hintstring, delete_trigger, persistent ); +} + +alcatraz_setup_unitrigger_craftable( trigger_targetname, equipname, weaponname, trigger_hintstring, delete_trigger, persistent ) +{ + trig = getent( trigger_targetname, "targetname" ); + if ( !isDefined( trig ) ) + { + return; + } + trig.script_length = 386; + return alcatraz_setup_unitrigger_craftable_internal( trig, equipname, weaponname, trigger_hintstring, delete_trigger, persistent ); +} + +alcatraz_setup_unitrigger_craftable_internal( trig, equipname, weaponname, trigger_hintstring, delete_trigger, persistent ) +{ + if ( !isDefined( trig ) ) + { + return; + } + unitrigger_stub = spawnstruct(); + unitrigger_stub.craftablestub = level.zombie_include_craftables[ equipname ]; + angles = trig.script_angles; + if ( !isDefined( angles ) ) + { + angles = ( 0, 0, 0 ); + } + unitrigger_stub.origin = trig.origin + ( anglesToRight( angles ) * -6 ); + unitrigger_stub.angles = trig.angles; + if ( isDefined( trig.script_angles ) ) + { + unitrigger_stub.angles = trig.script_angles; + } + unitrigger_stub.equipname = equipname; + unitrigger_stub.weaponname = weaponname; + unitrigger_stub.trigger_hintstring = trigger_hintstring; + unitrigger_stub.delete_trigger = delete_trigger; + unitrigger_stub.crafted = 0; + unitrigger_stub.persistent = persistent; + unitrigger_stub.usetime = int( 3000 ); + unitrigger_stub.onbeginuse = ::onbeginuseuts; + unitrigger_stub.onenduse = ::onenduseuts; + unitrigger_stub.onuse = ::onuseplantobjectuts; + unitrigger_stub.oncantuse = ::oncantuseuts; + if ( isDefined( trig.script_length ) ) + { + unitrigger_stub.script_length = trig.script_length; + } + else + { + unitrigger_stub.script_length = 32; + } + if ( isDefined( trig.script_width ) ) + { + unitrigger_stub.script_width = trig.script_width; + } + else + { + unitrigger_stub.script_width = 100; + } + if ( isDefined( trig.script_height ) ) + { + unitrigger_stub.script_height = trig.script_height; + } + else + { + unitrigger_stub.script_height = 64; + } + unitrigger_stub.target = trig.target; + unitrigger_stub.targetname = trig.targetname; + unitrigger_stub.script_noteworthy = trig.script_noteworthy; + unitrigger_stub.script_parameters = trig.script_parameters; + unitrigger_stub.cursor_hint = "HINT_NOICON"; + if ( isDefined( level.zombie_craftablestubs[ equipname ].hint ) ) + { + unitrigger_stub.hint_string = level.zombie_craftablestubs[ equipname ].hint; + } + unitrigger_stub.script_unitrigger_type = "unitrigger_box_use"; + unitrigger_stub.require_look_at = 0; + unitrigger_force_per_player_triggers( unitrigger_stub, 1 ); + if ( isDefined( unitrigger_stub.craftablestub.custom_craftablestub_update_prompt ) ) + { + unitrigger_stub.custom_craftablestub_update_prompt = unitrigger_stub.craftablestub.custom_craftablestub_update_prompt; + } + unitrigger_stub.prompt_and_visibility_func = ::craftabletrigger_update_prompt; + maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( unitrigger_stub, ::craftable_place_think ); + unitrigger_stub.piece_trigger = trig; + trig.trigger_stub = unitrigger_stub; + unitrigger_stub.zombie_weapon_upgrade = trig.zombie_weapon_upgrade; + if ( isDefined( unitrigger_stub.target ) ) + { + unitrigger_stub.model = getent( unitrigger_stub.target, "targetname" ); + if ( isDefined( unitrigger_stub.model ) ) + { + if ( isDefined( unitrigger_stub.zombie_weapon_upgrade ) ) + { + unitrigger_stub.model useweaponhidetags( unitrigger_stub.zombie_weapon_upgrade ); + } + unitrigger_stub.model ghost(); + unitrigger_stub.model notsolid(); + } + } + unitrigger_stub.craftablespawn = unitrigger_stub craftable_piece_unitriggers( equipname, unitrigger_stub.origin ); + if ( delete_trigger ) + { + trig delete(); + } + level.a_uts_craftables[ level.a_uts_craftables.size ] = unitrigger_stub; + return unitrigger_stub; +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_distance_tracking.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_distance_tracking.gsc new file mode 100644 index 0000000..a5d6f2e --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_distance_tracking.gsc @@ -0,0 +1,169 @@ +#include maps/mp/zombies/_zm_spawner; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +zombie_tracking_init() +{ + level.zombie_respawned_health = []; + if ( !isDefined( level.zombie_tracking_dist ) ) + { + level.zombie_tracking_dist = 1500; + } + if ( !isDefined( level.zombie_tracking_high ) ) + { + level.zombie_tracking_high = 600; + } + if ( !isDefined( level.zombie_tracking_wait ) ) + { + level.zombie_tracking_wait = 10; + } + for ( ;; ) + { + while ( 1 ) + { + zombies = get_round_enemy_array(); + if ( !isDefined( zombies ) || isDefined( level.ignore_distance_tracking ) && level.ignore_distance_tracking ) + { + wait level.zombie_tracking_wait; + } + } + else i = 0; + while ( i < zombies.size ) + { + if ( isDefined( zombies[ i ] ) && isDefined( zombies[ i ].ignore_distance_tracking ) && !zombies[ i ].ignore_distance_tracking ) + { + zombies[ i ] thread delete_zombie_noone_looking( level.zombie_tracking_dist, level.zombie_tracking_high ); + } + i++; + } + wait level.zombie_tracking_wait; + } +} + +delete_zombie_noone_looking( how_close, how_high ) +{ + self endon( "death" ); + if ( !isDefined( how_close ) ) + { + how_close = 1500; + } + if ( !isDefined( how_high ) ) + { + how_close = 600; + } + distance_squared_check = how_close * how_close; + too_far_dist = distance_squared_check * 3; + if ( isDefined( level.zombie_tracking_too_far_dist ) ) + { + too_far_dist = level.zombie_tracking_too_far_dist * level.zombie_tracking_too_far_dist; + } + self.inview = 0; + self.player_close = 0; + players = get_players(); + i = 0; + while ( i < players.size ) + { + if ( players[ i ].sessionstate == "spectator" ) + { + i++; + continue; + } + else if ( isDefined( level.only_track_targeted_players ) ) + { + if ( !isDefined( self.favoriteenemy ) || self.favoriteenemy != players[ i ] ) + { + i++; + continue; + } + } + else + { + can_be_seen = self player_can_see_me( players[ i ] ); + if ( can_be_seen && distancesquared( self.origin, players[ i ].origin ) < too_far_dist ) + { + self.inview++; + } + if ( distancesquared( self.origin, players[ i ].origin ) < distance_squared_check && abs( self.origin[ 2 ] - players[ i ].origin[ 2 ] ) < how_high ) + { + self.player_close++; + } + } + i++; + } + wait 0,1; + if ( self.inview == 0 && self.player_close == 0 ) + { + if ( !isDefined( self.animname ) || isDefined( self.animname ) && self.animname != "zombie" ) + { + return; + } + if ( isDefined( self.electrified ) && self.electrified == 1 ) + { + return; + } + if ( isDefined( self.in_the_ground ) && self.in_the_ground == 1 ) + { + return; + } + zombies = getaiarray( "axis" ); + if ( isDefined( self.damagemod ) && self.damagemod == "MOD_UNKNOWN" && self.health < self.maxhealth ) + { + if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher ) + { + level.zombie_total++; + level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health; + } + } + else + { + if ( ( zombies.size + level.zombie_total ) > 24 || ( zombies.size + level.zombie_total ) <= 24 && self.health >= self.maxhealth ) + { + if ( isDefined( self.exclude_distance_cleanup_adding_to_total ) && !self.exclude_distance_cleanup_adding_to_total && isDefined( self.isscreecher ) && !self.isscreecher ) + { + level.zombie_total++; + if ( self.health < level.zombie_health ) + { + level.zombie_respawned_health[ level.zombie_respawned_health.size ] = self.health; + } + } + } + } + self maps/mp/zombies/_zm_spawner::reset_attack_spot(); + self notify( "zombie_delete" ); + self delete(); + recalc_zombie_array(); + } +} + +player_can_see_me( player ) +{ + playerangles = player getplayerangles(); + playerforwardvec = anglesToForward( playerangles ); + playerunitforwardvec = vectornormalize( playerforwardvec ); + banzaipos = self.origin; + playerpos = player getorigin(); + playertobanzaivec = banzaipos - playerpos; + playertobanzaiunitvec = vectornormalize( playertobanzaivec ); + forwarddotbanzai = vectordot( playerunitforwardvec, playertobanzaiunitvec ); + if ( forwarddotbanzai >= 1 ) + { + anglefromcenter = 0; + } + else if ( forwarddotbanzai <= -1 ) + { + anglefromcenter = 180; + } + else + { + anglefromcenter = acos( forwarddotbanzai ); + } + playerfov = getDvarFloat( "cg_fov" ); + banzaivsplayerfovbuffer = getDvarFloat( "g_banzai_player_fov_buffer" ); + if ( banzaivsplayerfovbuffer <= 0 ) + { + banzaivsplayerfovbuffer = 0,2; + } + playercanseeme = anglefromcenter <= ( ( playerfov * 0,5 ) * ( 1 - banzaivsplayerfovbuffer ) ); + return playercanseeme; +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_gamemodes.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_gamemodes.gsc new file mode 100644 index 0000000..cb81ebf --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_gamemodes.gsc @@ -0,0 +1,15 @@ +#include maps/mp/zm_prison; +#include maps/mp/gametypes_zm/_zm_gametype; +#include maps/mp/zombies/_zm_game_module; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +init() +{ + level.custom_vending_precaching = ::maps/mp/zm_prison::custom_vending_precaching; + add_map_gamemode( "zclassic", ::maps/mp/zm_prison::zclassic_preinit, undefined, undefined ); + add_map_gamemode( "zgrief", ::maps/mp/zm_alcatraz_grief_cellblock::zgrief_preinit, undefined, undefined ); + add_map_location_gamemode( "zclassic", "prison", ::maps/mp/zm_alcatraz_classic::precache, ::maps/mp/zm_alcatraz_classic::main ); + add_map_location_gamemode( "zgrief", "cellblock", ::maps/mp/zm_alcatraz_grief_cellblock::precache, ::maps/mp/zm_alcatraz_grief_cellblock::main ); +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_grief_cellblock.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_grief_cellblock.gsc new file mode 100644 index 0000000..d22eb28 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_grief_cellblock.gsc @@ -0,0 +1,558 @@ +#include maps/mp/gametypes_zm/zmeat; +#include maps/mp/zm_alcatraz_traps; +#include maps/mp/zombies/_zm_game_module; +#include maps/mp/zombies/_zm_blockers; +#include maps/mp/gametypes_zm/_zm_gametype; +#include maps/mp/zombies/_zm_magicbox; +#include maps/mp/zombies/_zm_weapons; +#include maps/mp/zm_prison; +#include maps/mp/zombies/_zm_race_utility; +#include maps/mp/zombies/_zm_utility; +#include common_scripts/utility; +#include maps/mp/_utility; + +#using_animtree( "fxanim_props" ); + +precache() +{ +} + +zgrief_preinit() +{ + registerclientfield( "toplayer", "meat_stink", 1, 1, "int" ); + level.givecustomloadout = ::maps/mp/zm_prison::givecustomloadout; + zgrief_init(); +} + +zgrief_init() +{ + encounter_init(); + flag_wait( "start_zombie_round_logic" ); + if ( level.round_number < 4 && level.gamedifficulty != 0 ) + { + level.zombie_move_speed = 35; + } +} + +encounter_init() +{ + level._game_module_player_laststand_callback = ::alcatraz_grief_laststand_weapon_save; + level.precachecustomcharacters = ::precache_team_characters; + level.givecustomcharacters = ::give_team_characters; + level.gamemode_post_spawn_logic = ::give_player_shiv; +} + +alcatraz_grief_laststand_weapon_save( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime, deathanimduration ) +{ + if ( self hasperk( "specialty_additionalprimaryweapon" ) ) + { + primary_weapons_that_can_be_taken = []; + primaryweapons = self getweaponslistprimaries(); + i = 0; + while ( i < primaryweapons.size ) + { + if ( maps/mp/zombies/_zm_weapons::is_weapon_included( primaryweapons[ i ] ) || maps/mp/zombies/_zm_weapons::is_weapon_upgraded( primaryweapons[ i ] ) ) + { + primary_weapons_that_can_be_taken[ primary_weapons_that_can_be_taken.size ] = primaryweapons[ i ]; + } + i++; + } + if ( primary_weapons_that_can_be_taken.size >= 3 ) + { + weapon_to_take = primary_weapons_that_can_be_taken[ primary_weapons_that_can_be_taken.size - 1 ]; + self takeweapon( weapon_to_take ); + self.weapon_taken_by_losing_specialty_additionalprimaryweapon = weapon_to_take; + } + } + self.grief_savedweapon_weapons = self getweaponslist(); + self.grief_savedweapon_weaponsammo_stock = []; + self.grief_savedweapon_weaponsammo_clip = []; + self.grief_savedweapon_currentweapon = self getcurrentweapon(); + self.grief_savedweapon_grenades = self get_player_lethal_grenade(); + if ( isDefined( self.grief_savedweapon_grenades ) ) + { + self.grief_savedweapon_grenades_clip = self getweaponammoclip( self.grief_savedweapon_grenades ); + } + self.grief_savedweapon_tactical = self get_player_tactical_grenade(); + if ( isDefined( self.grief_savedweapon_tactical ) ) + { + self.grief_savedweapon_tactical_clip = self getweaponammoclip( self.grief_savedweapon_tactical ); + } + i = 0; + while ( i < self.grief_savedweapon_weapons.size ) + { + self.grief_savedweapon_weaponsammo_clip[ i ] = self getweaponammoclip( self.grief_savedweapon_weapons[ i ] ); + self.grief_savedweapon_weaponsammo_stock[ i ] = self getweaponammostock( self.grief_savedweapon_weapons[ i ] ); + i++; + } + if ( isDefined( self.hasriotshield ) && self.hasriotshield ) + { + self.grief_hasriotshield = 1; + } + if ( self hasweapon( "claymore_zm" ) ) + { + self.grief_savedweapon_claymore = 1; + self.grief_savedweapon_claymore_clip = self getweaponammoclip( "claymore_zm" ); + } +} + +precache_team_characters() +{ + precachemodel( "c_zom_player_grief_guard_fb" ); + precachemodel( "c_zom_oleary_shortsleeve_viewhands" ); + precachemodel( "c_zom_player_grief_inmate_fb" ); + precachemodel( "c_zom_grief_guard_viewhands" ); +} + +give_team_characters() +{ + self detachall(); + self set_player_is_female( 0 ); + if ( !isDefined( self.characterindex ) ) + { + self.characterindex = 1; + if ( self.team == "axis" ) + { + self.characterindex = 0; + } + } + switch( self.characterindex ) + { + case 0: + case 2: + self setmodel( "c_zom_player_grief_inmate_fb" ); + self.voice = "american"; + self.skeleton = "base"; + self setviewmodel( "c_zom_oleary_shortsleeve_viewhands" ); + self.characterindex = 0; + break; + case 1: + case 3: + self setmodel( "c_zom_player_grief_guard_fb" ); + self.voice = "american"; + self.skeleton = "base"; + self setviewmodel( "c_zom_grief_guard_viewhands" ); + self.characterindex = 1; + break; + } + self setmovespeedscale( 1 ); + self setsprintduration( 4 ); + self setsprintcooldown( 0 ); +} + +give_player_shiv() +{ + self takeweapon( "knife_zm" ); + self giveweapon( "knife_zm_alcatraz" ); +} + +grief_treasure_chest_init() +{ + chest1 = getstruct( "start_chest", "script_noteworthy" ); + chest2 = getstruct( "cafe_chest", "script_noteworthy" ); + setdvar( "disableLookAtEntityLogic", 1 ); + level.chests = []; + level.chests[ level.chests.size ] = chest1; + level.chests[ level.chests.size ] = chest2; + maps/mp/zombies/_zm_magicbox::treasure_chest_init( "start_chest" ); +} + +main() +{ + maps/mp/gametypes_zm/_zm_gametype::setup_standard_objects( "cellblock" ); + grief_treasure_chest_init(); + precacheshader( "zm_al_wth_zombie" ); + array_thread( level.zombie_spawners, ::add_spawn_function, ::remove_zombie_hats_for_grief ); + maps/mp/zombies/_zm_ai_brutus::precache(); + maps/mp/zombies/_zm_ai_brutus::init(); + level.enemy_location_override_func = ::enemy_location_override; + level._effect[ "butterflies" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_skull_elec" ); + a_t_door_triggers = getentarray( "zombie_door", "targetname" ); + _a207 = a_t_door_triggers; + _k207 = getFirstArrayKey( _a207 ); + while ( isDefined( _k207 ) ) + { + trigger = _a207[ _k207 ]; + if ( isDefined( trigger.script_flag ) ) + { + if ( trigger.script_flag != "activate_cellblock_citadel" && trigger.script_flag != "activate_shower_room" || trigger.script_flag == "activate_cellblock_infirmary" && trigger.script_flag == "activate_infirmary" ) + { + trigger delete(); + break; + } + else + { + if ( trigger.script_flag != "activate_cafeteria" && trigger.script_flag != "activate_cellblock_east" && trigger.script_flag != "activate_cellblock_west" && trigger.script_flag != "activate_cellblock_barber" && trigger.script_flag != "activate_cellblock_gondola" || trigger.script_flag == "activate_cellblock_east_west" && trigger.script_flag == "activate_warden_office" ) + { + break; + } + else while ( isDefined( trigger.target ) ) + { + str_target = trigger.target; + a_door_and_clip = getentarray( str_target, "targetname" ); + _a229 = a_door_and_clip; + _k229 = getFirstArrayKey( _a229 ); + while ( isDefined( _k229 ) ) + { + ent = _a229[ _k229 ]; + ent delete(); + _k229 = getNextArrayKey( _a229, _k229 ); + } + } + trigger delete(); + } + } + _k207 = getNextArrayKey( _a207, _k207 ); + } + a_t_doors = getentarray( "zombie_door", "targetname" ); + _a244 = a_t_doors; + _k244 = getFirstArrayKey( _a244 ); + while ( isDefined( _k244 ) ) + { + t_door = _a244[ _k244 ]; + if ( isDefined( t_door.script_flag ) ) + { + if ( t_door.script_flag == "activate_cellblock_east_west" || t_door.script_flag == "activate_cellblock_barber" ) + { + t_door maps/mp/zombies/_zm_blockers::door_opened( self.zombie_cost ); + } + } + _k244 = getNextArrayKey( _a244, _k244 ); + } + zbarriers = getzbarrierarray(); + a_str_zones = []; + a_str_zones[ 0 ] = "zone_start"; + a_str_zones[ 1 ] = "zone_library"; + a_str_zones[ 2 ] = "zone_cafeteria"; + a_str_zones[ 3 ] = "zone_cafeteria_end"; + a_str_zones[ 4 ] = "zone_warden_office"; + a_str_zones[ 5 ] = "zone_cellblock_east"; + a_str_zones[ 6 ] = "zone_cellblock_west_warden"; + a_str_zones[ 7 ] = "zone_cellblock_west_barber"; + a_str_zones[ 8 ] = "zone_cellblock_west"; + a_str_zones[ 9 ] = "zone_cellblock_west_gondola"; + _a269 = zbarriers; + _k269 = getFirstArrayKey( _a269 ); + while ( isDefined( _k269 ) ) + { + barrier = _a269[ _k269 ]; + if ( isDefined( barrier.script_noteworthy ) ) + { + if ( barrier.script_noteworthy == "cafe_chest_zbarrier" || barrier.script_noteworthy == "start_chest_zbarrier" ) + { + } + } + else + { + str_model = barrier.model; + b_delete_barrier = 1; + i = 0; + while ( i < a_str_zones.size ) + { + if ( str_model == a_str_zones[ i ] ) + { + b_delete_barrier = 0; + break; + } + else + { + i++; + } + } + if ( b_delete_barrier == 1 ) + { + barrier delete(); + } + } + _k269 = getNextArrayKey( _a269, _k269 ); + } + t_temp = getent( "tower_trap_activate_trigger", "targetname" ); + t_temp delete(); + t_temp = getent( "tower_trap_range_trigger", "targetname" ); + t_temp delete(); + e_model = getent( "trap_control_docks", "targetname" ); + e_model delete(); + e_brush = getent( "tower_shockbox_door", "targetname" ); + e_brush delete(); + a_t_travel_triggers = getentarray( "travel_trigger", "script_noteworthy" ); + _a312 = a_t_travel_triggers; + _k312 = getFirstArrayKey( _a312 ); + while ( isDefined( _k312 ) ) + { + trigger = _a312[ _k312 ]; + trigger delete(); + _k312 = getNextArrayKey( _a312, _k312 ); + } + a_e_gondola_lights = getentarray( "gondola_state_light", "targetname" ); + _a318 = a_e_gondola_lights; + _k318 = getFirstArrayKey( _a318 ); + while ( isDefined( _k318 ) ) + { + light = _a318[ _k318 ]; + light delete(); + _k318 = getNextArrayKey( _a318, _k318 ); + } + a_e_gondola_landing_gates = getentarray( "gondola_landing_gates", "targetname" ); + _a324 = a_e_gondola_landing_gates; + _k324 = getFirstArrayKey( _a324 ); + while ( isDefined( _k324 ) ) + { + model = _a324[ _k324 ]; + model delete(); + _k324 = getNextArrayKey( _a324, _k324 ); + } + a_e_gondola_landing_doors = getentarray( "gondola_landing_doors", "targetname" ); + _a330 = a_e_gondola_landing_doors; + _k330 = getFirstArrayKey( _a330 ); + while ( isDefined( _k330 ) ) + { + model = _a330[ _k330 ]; + model delete(); + _k330 = getNextArrayKey( _a330, _k330 ); + } + a_e_gondola_gates = getentarray( "gondola_gates", "targetname" ); + _a336 = a_e_gondola_gates; + _k336 = getFirstArrayKey( _a336 ); + while ( isDefined( _k336 ) ) + { + model = _a336[ _k336 ]; + model delete(); + _k336 = getNextArrayKey( _a336, _k336 ); + } + a_e_gondola_doors = getentarray( "gondola_doors", "targetname" ); + _a342 = a_e_gondola_doors; + _k342 = getFirstArrayKey( _a342 ); + while ( isDefined( _k342 ) ) + { + model = _a342[ _k342 ]; + model delete(); + _k342 = getNextArrayKey( _a342, _k342 ); + } + m_gondola = getent( "zipline_gondola", "targetname" ); + m_gondola delete(); + t_ride_trigger = getent( "gondola_ride_trigger", "targetname" ); + t_ride_trigger delete(); + a_classic_clips = getentarray( "classic_clips", "targetname" ); + _a355 = a_classic_clips; + _k355 = getFirstArrayKey( _a355 ); + while ( isDefined( _k355 ) ) + { + clip = _a355[ _k355 ]; + clip connectpaths(); + clip delete(); + _k355 = getNextArrayKey( _a355, _k355 ); + } + a_afterlife_props = getentarray( "afterlife_show", "targetname" ); + _a363 = a_afterlife_props; + _k363 = getFirstArrayKey( _a363 ); + while ( isDefined( _k363 ) ) + { + m_prop = _a363[ _k363 ]; + m_prop delete(); + _k363 = getNextArrayKey( _a363, _k363 ); + } + spork_portal = getent( "afterlife_show_spork", "targetname" ); + spork_portal delete(); + a_audio = getentarray( "at_headphones", "script_noteworthy" ); + _a373 = a_audio; + _k373 = getFirstArrayKey( _a373 ); + while ( isDefined( _k373 ) ) + { + model = _a373[ _k373 ]; + model delete(); + _k373 = getNextArrayKey( _a373, _k373 ); + } + m_spoon_pickup = getent( "pickup_spoon", "targetname" ); + m_spoon_pickup delete(); + t_sq_bg = getent( "sq_bg_reward_pickup", "targetname" ); + t_sq_bg delete(); + t_crafting_table = getentarray( "open_craftable_trigger", "targetname" ); + _a386 = t_crafting_table; + _k386 = getFirstArrayKey( _a386 ); + while ( isDefined( _k386 ) ) + { + trigger = _a386[ _k386 ]; + trigger delete(); + _k386 = getNextArrayKey( _a386, _k386 ); + } + t_warden_fence = getent( "warden_fence_damage", "targetname" ); + t_warden_fence delete(); + m_plane_about_to_crash = getent( "plane_about_to_crash", "targetname" ); + m_plane_about_to_crash delete(); + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_craftable delete(); + i = 1; + while ( i <= 5 ) + { + m_key_lock = getent( "masterkey_lock_" + i, "targetname" ); + m_key_lock delete(); + i++; + } + m_shower_door = getent( "shower_key_door", "targetname" ); + m_shower_door delete(); + m_nixie_door = getent( "nixie_door_left", "targetname" ); + m_nixie_door delete(); + m_nixie_door = getent( "nixie_door_right", "targetname" ); + m_nixie_door delete(); + m_nixie_brush = getent( "nixie_tube_weaponclip", "targetname" ); + m_nixie_brush delete(); + i = 1; + while ( i <= 3 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + m_nixie_tube delete(); + i++; + } + t_elevator_door = getent( "nixie_elevator_door", "targetname" ); + t_elevator_door delete(); + e_elevator_clip = getent( "elevator_door_playerclip", "targetname" ); + e_elevator_clip delete(); + e_elevator_bottom_gate = getent( "elevator_bottom_gate_l", "targetname" ); + e_elevator_bottom_gate delete(); + e_elevator_bottom_gate = getent( "elevator_bottom_gate_r", "targetname" ); + e_elevator_bottom_gate delete(); + m_docks_puzzle = getent( "cable_puzzle_gate_01", "targetname" ); + m_docks_puzzle delete(); + m_docks_puzzle = getent( "cable_puzzle_gate_02", "targetname" ); + m_docks_puzzle delete(); + m_infirmary_case = getent( "infirmary_case_door_left", "targetname" ); + m_infirmary_case delete(); + m_infirmary_case = getent( "infirmary_case_door_right", "targetname" ); + m_infirmary_case delete(); + fake_plane_part = getent( "fake_veh_t6_dlc_zombie_part_control", "targetname" ); + fake_plane_part delete(); + i = 1; + while ( i <= 3 ) + { + m_generator = getent( "generator_panel_" + i, "targetname" ); + m_generator delete(); + i++; + } + a_m_generator_core = getentarray( "generator_core", "targetname" ); + _a462 = a_m_generator_core; + _k462 = getFirstArrayKey( _a462 ); + while ( isDefined( _k462 ) ) + { + generator = _a462[ _k462 ]; + generator delete(); + _k462 = getNextArrayKey( _a462, _k462 ); + } + e_playerclip = getent( "electric_chair_playerclip", "targetname" ); + e_playerclip delete(); + i = 1; + while ( i <= 4 ) + { + t_use = getent( "trigger_electric_chair_" + i, "targetname" ); + t_use delete(); + m_chair = getent( "electric_chair_" + i, "targetname" ); + m_chair delete(); + i++; + } + a_afterlife_interact = getentarray( "afterlife_interact", "targetname" ); + _a482 = a_afterlife_interact; + _k482 = getFirstArrayKey( _a482 ); + while ( isDefined( _k482 ) ) + { + model = _a482[ _k482 ]; + model turn_afterlife_interact_on(); + wait 0,1; + _k482 = getNextArrayKey( _a482, _k482 ); + } + flag_wait( "initial_blackscreen_passed" ); + maps/mp/zombies/_zm_game_module::turn_power_on_and_open_doors(); + flag_wait( "start_zombie_round_logic" ); + level thread maps/mp/zm_alcatraz_traps::init_fan_trap_trigs(); + level thread maps/mp/zm_alcatraz_traps::init_acid_trap_trigs(); + wait 1; + level notify( "sleight_on" ); + wait_network_frame(); + level notify( "doubletap_on" ); + wait_network_frame(); + level notify( "juggernog_on" ); + wait_network_frame(); + level notify( "electric_cherry_on" ); + wait_network_frame(); + level notify( "deadshot_on" ); + wait_network_frame(); + level notify( "divetonuke_on" ); + wait_network_frame(); + level notify( "additionalprimaryweapon_on" ); + wait_network_frame(); + level notify( "Pack_A_Punch_on" ); + wait_network_frame(); +/# + level thread maps/mp/gametypes_zm/zmeat::spawn_level_meat_manager(); +#/ +} + +remove_zombie_hats_for_grief() +{ + self detach( "c_zom_guard_hat" ); +} + +enemy_location_override( zombie, enemy ) +{ + location = enemy.origin; + if ( is_true( self.reroute ) ) + { + if ( isDefined( self.reroute_origin ) ) + { + location = self.reroute_origin; + } + } + return location; +} + +magicbox_face_spawn() +{ + self endon( "disconnect" ); + if ( !is_gametype_active( "zgrief" ) ) + { + return; + } + while ( 1 ) + { + self waittill( "user_grabbed_weapon" ); + if ( randomint( 50000 ) == 115 ) + { + self playsoundtoplayer( "zmb_easteregg_face", self ); + self.wth_elem = newclienthudelem( self ); + self.wth_elem.horzalign = "fullscreen"; + self.wth_elem.vertalign = "fullscreen"; + self.wth_elem.sort = 1000; + self.wth_elem.foreground = 0; + self.wth_elem.alpha = 1; + self.wth_elem setshader( "zm_al_wth_zombie", 640, 480 ); + self.wth_elem.hidewheninmenu = 1; + wait 0,25; + self.wth_elem destroy(); + } + wait 0,05; + } +} + +turn_afterlife_interact_on() +{ + if ( self.script_string != "cell_1_powerup_activate" && self.script_string != "intro_powerup_activate" || self.script_string == "cell_2_powerup_activate" && self.script_string == "wires_shower_door" ) + { + return; + } + if ( self.script_string != "electric_cherry_on" || self.script_string == "sleight_on" && self.script_string == "wires_admin_door" ) + { + if ( !isDefined( level.shockbox_anim ) ) + { + level.shockbox_anim[ "on" ] = %fxanim_zom_al_shock_box_on_anim; + level.shockbox_anim[ "off" ] = %fxanim_zom_al_shock_box_off_anim; + } + if ( issubstr( self.model, "p6_zm_al_shock_box" ) ) + { + self useanimtree( -1 ); + self setmodel( "p6_zm_al_shock_box_on" ); + self setanim( level.shockbox_anim[ "on" ] ); + } + } + else + { + self delete(); + } +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_sq.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_sq.gsc new file mode 100644 index 0000000..9d948bd --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_sq.gsc @@ -0,0 +1,2286 @@ +#include maps/mp/zombies/_zm_clone; +#include maps/mp/zombies/_zm_laststand; +#include maps/mp/zombies/_zm_ai_basic; +#include maps/mp/animscripts/shared; +#include maps/mp/zombies/_zm_ai_brutus; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zm_alcatraz_sq_nixie; +#include maps/mp/zombies/_zm_unitrigger; +#include maps/mp/zombies/_zm_equipment; +#include maps/mp/zm_alcatraz_sq_vo; +#include maps/mp/zm_prison_sq_final; +#include maps/mp/gametypes_zm/_hud; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_sidequests; +#include maps/mp/zombies/_zm_craftables; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/zombies/_zm_afterlife; +#include maps/_vehicle; +#include maps/_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +init() +{ + precachemodel( "accessories_gas_canister_1" ); + precachemodel( "p6_zm_al_power_station_panels_03" ); + precacheitem( "falling_hands_zm" ); + precacheitem( "electrocuted_hands_zm" ); + precachestring( &"ZM_PRISON_ELECTRIC_CHAIR_ACTIVATE" ); + precachestring( &"ZM_PRISON_LAUNDRY_MACHINE_ACTIVATE" ); + precachestring( &"ZM_PRISON_PLANE_BEGIN_TAKEOFF" ); + precachestring( &"ZM_PRISON_PLANE_BOARD" ); + precachestring( &"ZM_PRISON_KEY_DOOR_LOCKED" ); + precacherumble( "damage_heavy" ); + precacherumble( "explosion_generic" ); + registerclientfield( "world", "fake_master_key", 9000, 2, "int" ); + flag_init( "map_revealed" ); + flag_init( "key_found" ); + flag_init( "cloth_found" ); + flag_init( "fueltanks_found" ); + flag_init( "engine_found" ); + flag_init( "steering_found" ); + flag_init( "rigging_found" ); + flag_init( "plane_ready" ); + flag_init( "plane_built" ); + flag_init( "plane_boarded" ); + flag_init( "plane_departed" ); + flag_init( "plane_approach_bridge" ); + flag_init( "plane_zapped" ); + flag_init( "plane_crashed" ); + flag_init( "portal_open" ); + flag_init( "spawn_fuel_tanks" ); + flag_init( "plane_is_away" ); + flag_init( "plane_trip_to_nml_successful" ); + flag_init( "story_vo_playing" ); + flag_init( "docks_inner_gate_unlocked" ); + flag_init( "docks_inner_gate_open" ); + flag_init( "docks_outer_gate_open" ); + flag_init( "docks_gates_remain_open" ); + flag_init( "nixie_puzzle_solved" ); + flag_init( "nixie_countdown_started" ); + flag_init( "nixie_countdown_expired" ); + flag_init( "nixie_puzzle_completed" ); + flag_init( "generator_challenge_completed" ); + flag_init( "dryer_cycle_active" ); + flag_init( "quest_completed_thrice" ); + flag_init( "final_quest_ready" ); + flag_init( "final_quest_audio_tour_started" ); + flag_init( "final_quest_audio_tour_finished" ); + flag_init( "final_quest_plane_built" ); + flag_init( "final_quest_plane_boarded" ); + flag_init( "final_quest_plane_departed" ); + flag_init( "final_quest_plane_zapped" ); + flag_init( "final_quest_plane_crashed" ); + flag_init( "final_quest_final_battle_started" ); + flag_init( "final_quest_good_wins" ); + flag_init( "final_quest_evil_wins" ); + flag_init( "nixie_ee_flashing" ); +} + +start_alcatraz_sidequest() +{ + init(); + onplayerconnect_callback( ::player_disconnect_watcher ); + onplayerconnect_callback( ::player_death_watcher ); + flag_wait( "start_zombie_round_logic" ); +/# + setup_devgui(); +#/ + level.n_quest_iteration_count = 1; + level.n_plane_fuel_count = 5; + level.n_plane_pieces_found = 0; + level.final_flight_players = []; + level.final_flight_activated = 0; + level.characters_in_nml = []; + level.someone_has_visited_nml = 0; + level.custom_game_over_hud_elem = ::maps/mp/zm_prison_sq_final::custom_game_over_hud_elem; + prevent_theater_mode_spoilers(); + setup_key_doors(); + setup_puzzle_piece_glint(); + setup_puzzles(); + setup_quest_triggers(); + if ( isDefined( level.gamedifficulty ) && level.gamedifficulty != 0 ) + { + maps/mp/zm_prison_sq_final::final_flight_setup(); + } + level thread warden_fence_hotjoin_handler(); + if ( isDefined( level.host_migration_listener_custom_func ) ) + { + level thread [[ level.host_migration_listener_custom_func ]](); + } + else + { + level thread host_migration_listener(); + } + if ( isDefined( level.manage_electric_chairs_custom_func ) ) + { + level thread [[ level.manage_electric_chairs_custom_func ]](); + } + else + { + level thread manage_electric_chairs(); + } + if ( isDefined( level.plane_flight_thread_custom_func ) ) + { + level thread [[ level.plane_flight_thread_custom_func ]](); + } + else + { + level thread plane_flight_thread(); + } + if ( isDefined( level.track_quest_status_thread_custom_func ) ) + { + level thread [[ level.track_quest_status_thread_custom_func ]](); + } + else + { + level thread track_quest_status_thread(); + } + maps/mp/zm_alcatraz_sq_vo::opening_vo(); +} + +host_migration_listener() +{ + level endon( "end_game" ); + level notify( "afterlife_hostmigration" ); + level endon( "afterlife_hostmigration" ); + while ( 1 ) + { + level waittill( "host_migration_end" ); + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_about_to_crash = getent( "plane_about_to_crash", "targetname" ); + veh_plane_flyable = getent( "plane_flyable", "targetname" ); + a_players = getplayers(); + if ( flag( "plane_boarded" ) && !flag( "plane_departed" ) ) + { + _a215 = a_players; + _k215 = getFirstArrayKey( _a215 ); + while ( isDefined( _k215 ) ) + { + player = _a215[ _k215 ]; + if ( isDefined( player ) && isDefined( player.character_name ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player playerlinktodelta( m_plane_craftable, "tag_player_crouched_" + ( player.n_passenger_index + 1 ) ); + } + _k215 = getNextArrayKey( _a215, _k215 ); + } + } + else if ( flag( "plane_departed" ) && !flag( "plane_approach_bridge" ) ) + { + _a225 = a_players; + _k225 = getFirstArrayKey( _a225 ); + while ( isDefined( _k225 ) ) + { + player = _a225[ _k225 ]; + if ( isDefined( player ) && isDefined( player.character_name ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player playerlinktodelta( veh_plane_flyable, "tag_player_crouched_" + ( player.n_passenger_index + 1 ) ); + } + _k225 = getNextArrayKey( _a225, _k225 ); + } + } + else if ( flag( "plane_approach_bridge" ) && !flag( "plane_zapped" ) ) + { + _a235 = a_players; + _k235 = getFirstArrayKey( _a235 ); + while ( isDefined( _k235 ) ) + { + player = _a235[ _k235 ]; + if ( isDefined( player ) && isDefined( player.character_name ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player playerlinktoabsolute( veh_plane_flyable, "tag_player_crouched_" + ( player.n_passenger_index + 1 ) ); + } + _k235 = getNextArrayKey( _a235, _k235 ); + } + } + else while ( flag( "plane_zapped" ) && !flag( "plane_crashed" ) ) + { + _a245 = a_players; + _k245 = getFirstArrayKey( _a245 ); + while ( isDefined( _k245 ) ) + { + player = _a245[ _k245 ]; + if ( isDefined( player ) && isDefined( player.character_name ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player playerlinktodelta( m_plane_about_to_crash, "tag_player_crouched_" + ( player.n_passenger_index + 1 ), 1, 0, 0, 0, 0, 1 ); + } + _k245 = getNextArrayKey( _a245, _k245 ); + } + } + setup_puzzle_piece_glint(); + setclientfield( "fake_master_key", level.is_master_key_west + 1 ); + if ( !flag( "key_found" ) ) + { + if ( level.is_master_key_west ) + { + exploder( 101 ); + break; + } + else + { + exploder( 100 ); + } + } + } +} + +prevent_theater_mode_spoilers() +{ + flag_wait( "initial_blackscreen_passed" ); + m_plane_flyable = getent( "plane_flyable", "targetname" ); + m_plane_flyable setinvisibletoall(); + m_plane_hideable_engine = getent( "plane_hideable_engine", "targetname" ); + m_plane_hideable_engine ghost(); + m_plane_hideable_clothes_pile = getent( "plane_hideable_clothes_pile", "targetname" ); + m_plane_hideable_clothes_pile ghost(); + a_str_partnames = []; + a_str_partnames[ 0 ] = "cloth"; + a_str_partnames[ 1 ] = "steering"; + i = 0; + while ( i < a_str_partnames.size ) + { + m_plane_piece = get_craftable_piece_model( "plane", a_str_partnames[ i ] ); + if ( isDefined( m_plane_piece ) ) + { + m_plane_piece setinvisibletoall(); + } + i++; + } + m_master_key = get_craftable_piece_model( "quest_key1", "p6_zm_al_key" ); + if ( isDefined( m_master_key ) ) + { + m_master_key setinvisibletoall(); + } +} + +setup_puzzle_piece_glint() +{ + wait 1; + a_str_partnames = []; + a_str_partnames[ 0 ] = "cloth"; + a_str_partnames[ 1 ] = "fueltanks"; + a_str_partnames[ 2 ] = "engine"; + a_str_partnames[ 3 ] = "steering"; + a_str_partnames[ 4 ] = "rigging"; + i = 0; + while ( i < a_str_partnames.size ) + { + m_plane_piece = get_craftable_piece_model( "plane", a_str_partnames[ i ] ); + if ( isDefined( m_plane_piece ) ) + { + playfxontag( level._effect[ "quest_item_glow" ], m_plane_piece, "tag_origin" ); + } + m_fuel_can = get_craftable_piece_model( "refuelable_plane", "fuel" + ( i + 1 ) ); + if ( isDefined( m_fuel_can ) ) + { + playfxontag( level._effect[ "quest_item_glow" ], m_fuel_can, "tag_origin" ); + } + i++; + } + m_master_key = get_craftable_piece_model( "quest_key1", "p6_zm_al_key" ); + if ( isDefined( m_master_key ) ) + { + playfxontag( level._effect[ "key_glint" ], m_master_key, "tag_origin" ); + } + m_fake_plane_steering = getent( "fake_veh_t6_dlc_zombie_part_control", "targetname" ); + if ( isDefined( m_fake_plane_steering ) ) + { + playfxontag( level._effect[ "quest_item_glow" ], m_fake_plane_steering, "tag_origin" ); + } +} + +setup_devgui() +{ + setdvar( "add_afterlife", "off" ); + setdvar( "build_plane", "off" ); + setdvar( "get_master_key", "off" ); + setdvar( "alcatraz_final_battle", "off" ); + setdvar( "alcatraz_give_shield", "off" ); +/# + adddebugcommand( "devgui_cmd "Zombies/Alcatraz:1/Add Afterlife" "add_afterlife on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Alcatraz:1/Get Master Key" "get_master_key on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Alcatraz:1/Alcatraz Final Battle" "alcatraz_final_battle on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Alcatraz:1/Build Plane:1" "build_plane on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Alcatraz:1/Give Shield:1" "alcatraz_give_shield on"\n" ); +#/ + level thread watch_devgui_alcatraz_final_battle(); + level thread watch_devgui_afterlife(); + level thread watch_devgui_plane(); + level thread watch_devgui_get_key(); + level thread watch_devgui_give_shield(); +} + +watch_devgui_alcatraz_final_battle() +{ + while ( 1 ) + { + if ( getDvar( "alcatraz_final_battle" ) == "on" ) + { + players = getplayers(); + _a379 = players; + _k379 = getFirstArrayKey( _a379 ); + while ( isDefined( _k379 ) ) + { + player = _a379[ _k379 ]; +/# + iprintlnbold( "LINK PLAYER TO PLANE, START COUNTDOWN IF NOT YET STARTED" ); +#/ + level.final_flight_activated = 1; + player thread final_flight_player_thread(); + _k379 = getNextArrayKey( _a379, _k379 ); + } + setdvar( "alcatraz_final_battle", "off" ); + } + wait 0,1; + } +} + +watch_devgui_get_key() +{ + while ( 1 ) + { + if ( getDvar( "get_master_key" ) == "on" ) + { + a_players = []; + a_players = getplayers(); + m_master_key = get_craftable_piece_model( "quest_key1", "p6_zm_al_key" ); + if ( isDefined( m_master_key ) ) + { + m_master_key.origin = a_players[ 0 ].origin + vectorScale( ( 0, 0, 0 ), 60 ); + m_master_key setvisibletoall(); + } + setdvar( "get_master_key", "off" ); + } + wait 0,1; + } +} + +watch_devgui_afterlife() +{ + while ( 1 ) + { + if ( getDvar( "add_afterlife" ) == "on" ) + { + a_players = []; + a_players = getplayers(); + i = 0; + while ( i < a_players.size ) + { + a_players[ i ] afterlife_add(); + i++; + } + setdvar( "add_afterlife", "off" ); + } + wait 0,1; + } +} + +watch_devgui_give_shield() +{ + while ( 1 ) + { + if ( getDvar( "alcatraz_give_shield" ) == "on" ) + { + _a438 = getplayers(); + _k438 = getFirstArrayKey( _a438 ); + while ( isDefined( _k438 ) ) + { + player = _a438[ _k438 ]; + if ( is_equipment_included( "alcatraz_shield_zm" ) ) + { + player maps/mp/zombies/_zm_equipment::equipment_buy( "alcatraz_shield_zm" ); + } + _k438 = getNextArrayKey( _a438, _k438 ); + } + setdvar( "alcatraz_give_shield", "off" ); + } + wait 0,05; + } +} + +watch_devgui_plane() +{ + is_shortcut_plane_built = 0; + while ( !is_shortcut_plane_built ) + { + if ( getDvar( "build_plane" ) == "on" ) + { +/# + iprintlnbold( "plane built!" ); +#/ + is_shortcut_plane_built = 1; + } + wait 0,1; + } + i = 0; + while ( i < level.a_uts_craftables.size ) + { + if ( level.a_uts_craftables[ i ].equipname == "plane" ) + { + level.a_uts_craftables[ i ].crafted = 1; + } + i++; + } + level thread maps/mp/zm_alcatraz_sq_vo::escape_flight_vo(); + plane_craftable = getent( "plane_craftable", "targetname" ); + plane_craftable showpart( "tag_support_upper" ); + plane_craftable showpart( "tag_wing_skins_up" ); + plane_craftable showpart( "tag_engines_up" ); + plane_craftable showpart( "tag_feul_tanks" ); + plane_craftable showpart( "tag_control_mechanism" ); + plane_craftable showpart( "tag_fuel_hose" ); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + t_plane_fly trigger_on(); + t_plane_fly.require_look_at = 0; + while ( isDefined( t_plane_fly ) ) + { + t_plane_fly waittill( "trigger", e_triggerer ); + if ( isplayer( e_triggerer ) ) + { +/# + iprintlnbold( e_triggerer ); +#/ + while ( isDefined( level.custom_plane_validation ) ) + { + valid = t_plane_fly [[ level.custom_plane_validation ]]( e_triggerer ); + while ( !valid ) + { + continue; + } + } + if ( level.n_plane_fuel_count == 5 ) + { + if ( isDefined( level.plane_boarding_thread_custom_func ) ) + { + e_triggerer thread [[ level.plane_boarding_thread_custom_func ]](); + break; + } + else + { +/# + iprintlnbold( "LINK PLAYER TO PLANE, START COUNTDOWN IF NOT YET STARTED" ); +#/ + e_triggerer thread plane_boarding_thread(); + } + } + } + } +} + +setup_key_doors() +{ + width = 0; + height = 0; + length = 0; + piece_number = 1; + while ( piece_number < 6 ) + { + switch( piece_number ) + { + case 1: + width = 120; + height = 112; + length = 120; + break; + case 2: + width = 120; + height = 112; + length = 124; + break; + case 3: + width = 108; + height = 112; + length = 90; + break; + case 4: + width = 98; + height = 112; + length = 108; + break; + case 5: + width = 60; + height = 112; + length = 90; + break; + } + create_key_door_unitrigger( piece_number, width, height, length ); + piece_number++; + } +} + +create_key_door_unitrigger( piece_num, width, height, length ) +{ + t_key_door = getstruct( "key_door_" + piece_num + "_trigger", "targetname" ); + t_key_door.unitrigger_stub = spawnstruct(); + t_key_door.unitrigger_stub.origin = t_key_door.origin; + t_key_door.unitrigger_stub.angles = t_key_door.angles; + t_key_door.unitrigger_stub.script_unitrigger_type = "unitrigger_box_use"; + t_key_door.unitrigger_stub.hint_string = &"ZM_PRISON_KEY_DOOR_LOCKED"; + t_key_door.unitrigger_stub.cursor_hint = "HINT_NOICON"; + t_key_door.unitrigger_stub.script_width = width; + t_key_door.unitrigger_stub.script_height = height; + t_key_door.unitrigger_stub.script_length = length; + t_key_door.unitrigger_stub.n_door_index = piece_num; + t_key_door.unitrigger_stub.require_look_at = 0; + t_key_door.unitrigger_stub.prompt_and_visibility_func = ::key_door_trigger_visibility; + maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( t_key_door.unitrigger_stub, ::master_key_door_trigger_thread ); +} + +key_door_trigger_visibility( player ) +{ + if ( !player.afterlife && isDefined( self.stub.master_key_door_opened ) && !self.stub.master_key_door_opened ) + { + if ( self.stub.n_door_index == 2 ) + { + b_is_invis = !flag( "generator_challenge_completed" ); + } + } + self setinvisibletoplayer( player, b_is_invis ); + if ( flag( "key_found" ) ) + { + self sethintstring( &"ZM_PRISON_KEY_DOOR" ); + } + else + { + self sethintstring( self.stub.hint_string ); + } + return !b_is_invis; +} + +master_key_door_trigger_thread() +{ + self endon( "death" ); + self endon( "kill_trigger" ); + n_door_index = self.stub.n_door_index; + b_door_open = 0; + while ( !b_door_open ) + { + self waittill( "trigger", e_triggerer ); + if ( e_triggerer is_holding_part( "quest_key1", "p6_zm_al_key" ) ) + { + self.stub.master_key_door_opened = 1; + self.stub maps/mp/zombies/_zm_unitrigger::run_visibility_function_for_all_triggers(); + level thread open_custom_door_master_key( n_door_index, e_triggerer ); + self playsound( "evt_quest_door_open" ); + b_door_open = 1; + continue; + } + else + { + e_triggerer thread do_player_general_vox( "quest", "sidequest_key", undefined, 100 ); +/# + iprintlnbold( "missing key!" ); +#/ + } + } + level thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub ); +} + +open_custom_door_master_key( n_door_index, e_triggerer ) +{ + m_lock = getent( "masterkey_lock_" + n_door_index, "targetname" ); + m_lock playsound( "zmb_quest_key_unlock" ); + playfxontag( level._effect[ "fx_alcatraz_unlock_door" ], m_lock, "tag_origin" ); + wait 0,5; + m_lock delete(); + switch( n_door_index ) + { + case 1: + shower_key_door = getent( "shower_key_door", "targetname" ); + shower_key_door moveto( shower_key_door.origin + vectorScale( ( 0, 0, 0 ), 80 ), 0,25 ); + shower_key_door connectpaths(); + if ( isDefined( e_triggerer ) ) + { + e_triggerer door_rumble_on_open(); + } + shower_key_door playsound( "zmb_chainlink_open" ); + break; + case 2: + admin_powerhouse_puzzle_door_clip = getent( "admin_powerhouse_puzzle_door_clip", "targetname" ); + admin_powerhouse_puzzle_door_clip delete(); + admin_powerhouse_puzzle_door = getent( "admin_powerhouse_puzzle_door", "targetname" ); + admin_powerhouse_puzzle_door rotateyaw( 90, 0,5 ); + admin_powerhouse_puzzle_door playsound( "zmb_chainlink_open" ); + break; + case 3: + m_nixie_door_left = getent( "nixie_door_left", "targetname" ); + m_nixie_door_right = getent( "nixie_door_right", "targetname" ); + m_nixie_door_left rotateyaw( -165, 0,5 ); + m_nixie_door_right rotateyaw( 165, 0,5 ); + m_nixie_tube_weaponclip = getent( "nixie_tube_weaponclip", "targetname" ); + m_nixie_tube_weaponclip delete(); + if ( isDefined( e_triggerer ) ) + { + e_triggerer door_rumble_on_open(); + } + break; + case 4: + m_gate_01 = getent( "cable_puzzle_gate_01", "targetname" ); + m_gate_01 moveto( m_gate_01.origin + ( -16, 80, 0 ), 0,5 ); + m_gate_01 connectpaths(); + gate_1_monsterclip = getent( "docks_gate_1_monsterclip", "targetname" ); + gate_1_monsterclip.origin += vectorScale( ( 0, 0, 0 ), 256 ); + gate_1_monsterclip disconnectpaths(); + gate_1_monsterclip.origin -= vectorScale( ( 0, 0, 0 ), 256 ); + if ( isDefined( e_triggerer ) ) + { + e_triggerer door_rumble_on_open(); + } + m_gate_01 playsound( "zmb_chainlink_open" ); + flag_set( "docks_inner_gate_unlocked" ); + flag_set( "docks_inner_gate_open" ); + break; + case 5: + m_infirmary_case_door_left = getent( "infirmary_case_door_left", "targetname" ); + m_infirmary_case_door_right = getent( "infirmary_case_door_right", "targetname" ); + m_infirmary_case_door_left rotateyaw( -165, 0,5 ); + m_infirmary_case_door_right rotateyaw( 165, 0,5 ); + m_fake_plane_steering = getent( "fake_veh_t6_dlc_zombie_part_control", "targetname" ); + m_plane_steering = get_craftable_piece_model( "plane", "steering" ); + m_plane_steering moveto( m_plane_steering.origin + vectorScale( ( 0, 0, 0 ), 512 ), 0,05 ); + m_plane_steering setvisibletoall(); + m_fake_plane_steering hide(); + if ( isDefined( e_triggerer ) ) + { + e_triggerer door_rumble_on_open(); + } + m_infirmary_case_door_right playsound( "zmb_cabinet_door" ); + break; + } +} + +door_rumble_on_open() +{ + self endon( "disconnect" ); + level endon( "end_game" ); + self setclientfieldtoplayer( "rumble_door_open", 1 ); + wait_network_frame(); + self setclientfieldtoplayer( "rumble_door_open", 0 ); +} + +setup_puzzles() +{ + level thread setup_master_key(); + level thread setup_dryer_challenge(); + level thread setup_generator_challenge(); + level thread maps/mp/zm_alcatraz_sq_nixie::setup_nixie_tubes_puzzle(); + level thread setup_gate_puzzle(); +} + +setup_quest_triggers() +{ + t_plane_fuelable = getent( "plane_fuelable_trigger", "targetname" ); + t_plane_fuelable trigger_off(); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + t_plane_fly setcursorhint( "HINT_NOICON" ); + t_plane_fly sethintstring( &"ZM_PRISON_PLANE_BOARD" ); + t_plane_fly.require_look_at = 0; + t_plane_fly thread plane_fly_trigger_thread(); +} + +setup_master_key() +{ + level.is_master_key_west = randomintrange( 0, 2 ); + setclientfield( "fake_master_key", level.is_master_key_west + 1 ); + if ( level.is_master_key_west ) + { + level thread key_pulley( "west" ); + exploder( 101 ); + array_delete( getentarray( "wires_pulley_east", "script_noteworthy" ) ); + } + else + { + level thread key_pulley( "east" ); + exploder( 100 ); + array_delete( getentarray( "wires_pulley_west", "script_noteworthy" ) ); + } +} + +key_pulley( str_master_key_location ) +{ + if ( level.is_master_key_west ) + { + t_other_hurt_trigger = getent( "pulley_hurt_trigger_east", "targetname" ); + t_other_panel = getent( "master_key_pulley_east", "targetname" ); + } + else + { + t_other_hurt_trigger = getent( "pulley_hurt_trigger_west", "targetname" ); + t_other_panel = getent( "master_key_pulley_west", "targetname" ); + } + t_other_hurt_trigger delete(); + t_other_panel setmodel( "p6_zm_al_power_station_panels_03" ); + t_pulley_hurt_trigger = getent( "pulley_hurt_trigger_" + str_master_key_location, "targetname" ); + t_pulley_hurt_trigger thread maps/mp/zm_alcatraz_sq_vo::sndhitelectrifiedpulley( str_master_key_location ); + m_master_key_pulley = getent( "master_key_pulley_" + str_master_key_location, "targetname" ); + m_master_key_pulley play_fx( "fx_alcatraz_panel_on_2", m_master_key_pulley.origin, m_master_key_pulley.angles, "power_down", 1, undefined, undefined ); + m_master_key_pulley thread afterlife_interact_object_think(); + level waittill( "master_key_pulley_" + str_master_key_location ); + m_master_key_pulley playsound( "zmb_quest_generator_panel_spark" ); + m_master_key_pulley notify( "power_down" ); + m_master_key_pulley setmodel( "p6_zm_al_power_station_panels_03" ); + playfxontag( level._effect[ "fx_alcatraz_panel_ol" ], m_master_key_pulley, "tag_origin" ); + m_master_key_pulley play_fx( "fx_alcatraz_panel_off_2", m_master_key_pulley.origin, m_master_key_pulley.angles, "power_down", 1, undefined, undefined ); + if ( level.is_master_key_west ) + { + stop_exploder( 101 ); + array_delete( getentarray( "wires_pulley_west", "script_noteworthy" ) ); + } + else + { + stop_exploder( 100 ); + array_delete( getentarray( "wires_pulley_east", "script_noteworthy" ) ); + } + t_hurt_trigger = getent( "pulley_hurt_trigger_" + str_master_key_location, "targetname" ); + t_hurt_trigger delete(); + if ( str_master_key_location == "west" ) + { + level setclientfield( "fxanim_pulley_down_start", 1 ); + } + else + { + if ( str_master_key_location == "east" ) + { + level setclientfield( "fxanim_pulley_down_start", 2 ); + } + } + wait 3; + level setclientfield( "master_key_is_lowered", 1 ); + m_master_key = get_craftable_piece_model( "quest_key1", "p6_zm_al_key" ); + if ( isDefined( m_master_key ) ) + { + e_master_key_target = getstruct( "master_key_" + str_master_key_location + "_origin", "targetname" ); + m_master_key.origin = e_master_key_target.origin; + m_master_key setvisibletoall(); + } +} + +setup_dryer_challenge() +{ + t_dryer = getent( "dryer_trigger", "targetname" ); + t_dryer setcursorhint( "HINT_NOICON" ); + t_dryer sethintstring( &"ZM_PRISON_LAUNDRY_MACHINE_ACTIVATE" ); + t_dryer thread dryer_trigger_thread(); + t_dryer thread dryer_zombies_thread(); + t_dryer trigger_off(); + level waittill( "laundry_power_switch_afterlife" ); + level setclientfield( "dryer_stage", 1 ); +/# + iprintlnbold( "dryer can now be activated" ); +#/ + t_dryer trigger_on(); + t_dryer playsound( "evt_dryer_rdy_bell" ); + wait 1; + players = getplayers(); + _a900 = players; + _k900 = getFirstArrayKey( _a900 ); + while ( isDefined( _k900 ) ) + { + player = _a900[ _k900 ]; + if ( !player.afterlife && distance( player.origin, t_dryer.origin ) < 1500 ) + { + player thread do_player_general_vox( "general", "power_on", undefined, 100 ); + return; + } + _k900 = getNextArrayKey( _a900, _k900 ); + } +} + +dryer_trigger_thread() +{ + self endon( "death" ); + n_dryer_cycle_duration = 30; + a_dryer_spawns = []; + sndent = spawn( "script_origin", ( 1613, 10599, 1203 ) ); + self waittill( "trigger" ); + self trigger_off(); + level setclientfield( "dryer_stage", 2 ); + dryer_playerclip = getent( "dryer_playerclip", "targetname" ); + dryer_playerclip moveto( dryer_playerclip.origin + vectorScale( ( 0, 0, 0 ), 104 ), 0,05 ); + level clientnotify( "sndFF" ); + if ( isDefined( level.music_override ) && !level.music_override ) + { + level notify( "sndStopBrutusLoop" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "laundry_defend" ); + } + exploder( 1000 ); + sndent thread snddryercountdown( n_dryer_cycle_duration ); + sndent playsound( "evt_dryer_start" ); + sndent playloopsound( "evt_dryer_lp" ); + level clientnotify( "fxanim_dryer_start" ); + flag_set( "dryer_cycle_active" ); + wait 1; + sndset = sndmusicvariable(); + level clientnotify( "fxanim_dryer_idle_start" ); + i = 3; + while ( i > 0 ) + { +/# + iprintlnbold( ( ( i / 3 ) * n_dryer_cycle_duration ) + " seconds left!" ); +#/ + wait ( n_dryer_cycle_duration / 3 ); + i--; + + } + level clientnotify( "fxanim_dryer_end_start" ); + wait 2; + flag_clear( "dryer_cycle_active" ); + dryer_playerclip = getent( "dryer_playerclip", "targetname" ); + dryer_playerclip delete(); + sndent stoploopsound(); + sndent playsound( "evt_dryer_stop" ); + if ( isDefined( sndset ) && sndset ) + { + level.music_override = 0; + } + level clientnotify( "sndFF" ); + level setclientfield( "dryer_stage", 3 ); + stop_exploder( 900 ); + stop_exploder( 1000 ); + m_sheets = get_craftable_piece_model( "plane", "cloth" ); + m_sheets.origin = ( 1586,16, 10598,3, 1192 ); + m_sheets setvisibletoall(); + m_sheets ghost(); + self delete(); + sndent thread delaysndenddelete(); +} + +sndmusicvariable() +{ + if ( isDefined( level.music_override ) && !level.music_override ) + { + level.music_override = 1; + return 1; + } + return 0; +} + +dryer_zombies_thread() +{ + n_zombie_count_min = 20; + e_shower_zone = getent( "cellblock_shower", "targetname" ); + flag_wait( "dryer_cycle_active" ); + if ( level.round_number > 4 || isDefined( level.is_forever_solo_game ) && level.is_forever_solo_game ) + { + if ( level.zombie_total < n_zombie_count_min ) + { + level.zombie_total = n_zombie_count_min; + } + while ( flag( "dryer_cycle_active" ) ) + { + a_zombies_in_shower = []; + a_zombies_in_shower = get_zombies_touching_volume( "axis", "cellblock_shower", undefined ); + if ( a_zombies_in_shower.size < n_zombie_count_min ) + { + e_zombie = get_farthest_available_zombie( e_shower_zone ); + if ( isDefined( e_zombie ) && !isinarray( a_zombies_in_shower, e_zombie ) ) + { + e_zombie notify( "zapped" ); + e_zombie thread dryer_teleports_zombie(); + } + } + wait 1; + } + } + else maps/mp/zombies/_zm_ai_brutus::brutus_spawn_in_zone( "cellblock_shower" ); +} + +get_farthest_available_zombie( e_landmark ) +{ + if ( !isDefined( e_landmark ) ) + { + return undefined; + } + while ( 1 ) + { + a_zombies = getaiarray( level.zombie_team ); + if ( isDefined( a_zombies ) ) + { + zombies = get_array_of_closest( e_landmark.origin, a_zombies ); + x = 0; + while ( x < zombies.size ) + { + zombie = zombies[ x ]; + if ( isDefined( zombie ) && isalive( zombie ) && isDefined( zombie.in_the_ground ) && !zombie.in_the_ground && isDefined( zombie.gibbed ) && !zombie.gibbed && isDefined( zombie.head_gibbed ) && !zombie.head_gibbed && isDefined( zombie.is_being_used_as_spawnpoint ) && !zombie.is_being_used_as_spawnpoint && zombie in_playable_area() ) + { + zombie.is_being_used_as_spawnpoint = 1; + return zombie; + } + x++; + } + } + else return undefined; + wait 0,05; + } +} + +get_zombies_touching_volume( team, volume_name, volume ) +{ + if ( !isDefined( volume ) ) + { + volume = getent( volume_name, "targetname" ); +/# + assert( isDefined( volume ), volume_name + " does not exist" ); +#/ + } + guys = getaiarray( team ); + guys_touching_volume = []; + i = 0; + while ( i < guys.size ) + { + if ( guys[ i ] istouching( volume ) ) + { + guys_touching_volume[ guys_touching_volume.size ] = guys[ i ]; + } + i++; + } + return guys_touching_volume; +} + +dryer_teleports_zombie() +{ + self endon( "death" ); + self endon( "zapped" ); + if ( self.ai_state == "find_flesh" ) + { + self.zapped = 1; + a_nodes = getstructarray( "dryer_zombie_teleports", "targetname" ); + nd_target = random( a_nodes ); + playfx( level._effect[ "afterlife_teleport" ], self.origin ); + self hide(); + linker = spawn( "script_origin", ( 0, 0, 0 ) ); + linker thread linker_delete_watch( self ); + linker.origin = self.origin; + linker.angles = self.angles; + self linkto( linker ); + linker moveto( nd_target.origin, 0,05 ); + linker waittill( "movedone" ); + playfx( level._effect[ "afterlife_teleport" ], self.origin ); + linker delete(); + self show(); + self.zapped = undefined; + self.ignoreall = 1; + self notify( "stop_find_flesh" ); + self thread afterlife_zapped_fx(); + self animscripted( self.origin, self.angles, "zm_afterlife_stun" ); + self maps/mp/animscripts/shared::donotetracks( "stunned" ); + self.ignoreall = 0; + self thread maps/mp/zombies/_zm_ai_basic::find_flesh(); + } +} + +delaysndenddelete() +{ + wait 5; + self delete(); +} + +snddryercountdown( num ) +{ + ent = spawn( "script_origin", self.origin ); + i = num; + while ( i > 0 ) + { + if ( i <= 10 ) + { + ent playsound( "zmb_quest_nixie_count_final" ); + } + else + { + ent playsound( "zmb_quest_nixie_count" ); + } + wait 1; + i--; + + } + ent delete(); +} + +setup_generator_challenge() +{ + level.n_generator_panels_active = 0; + generator_soundent = spawn( "script_origin", ( -467, 6388, 132 ) ); + i = 1; + while ( i < 4 ) + { + level thread generator_panel_trigger_thread( i, generator_soundent ); + i++; + } + level thread generator_challenge_main_thread(); +} + +generator_challenge_main_thread() +{ + exploder( 2000 ); + while ( !flag( "generator_challenge_completed" ) ) + { + if ( level.n_generator_panels_active == 3 ) + { +/# + iprintlnbold( "generator overloaded!" ); +#/ + flag_set( "generator_challenge_completed" ); + } + wait 0,1; + } + level clientnotify( "sndWard" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "piece_mid" ); + t_warden_fence_damage = getent( "warden_fence_damage", "targetname" ); + t_warden_fence_damage delete(); + level setclientfield( "warden_fence_down", 1 ); + array_delete( getentarray( "generator_wires", "script_noteworthy" ) ); + wait 3; + stop_exploder( 2000 ); + wait 1; + players = getplayers(); + player = players[ randomintrange( 0, players.size ) ]; + player do_player_general_vox( "general", "power_off", undefined, 100 ); +} + +generator_panel_trigger_thread( n_panel_index, generator_soundent ) +{ + self endon( "death" ); + m_generator_panel = getent( "generator_panel_" + n_panel_index, "targetname" ); + m_generator_panel thread afterlife_interact_object_think(); + m_generator_panel play_fx( "fx_alcatraz_panel_on_2", m_generator_panel.origin, m_generator_panel.angles, "generator_panel_" + n_panel_index + "_afterlife", 1, undefined, undefined ); + level waittill( "generator_panel_" + n_panel_index + "_afterlife" ); + m_generator_panel notify( "generator_panel_" + n_panel_index + "_afterlife" ); +/# + iprintlnbold( "generator panel " + n_panel_index + " overloaded!" ); +#/ + level.n_generator_panels_active += 1; + m_generator_panel setmodel( "p6_zm_al_power_station_panels_03" ); + playfxontag( level._effect[ "fx_alcatraz_panel_ol" ], m_generator_panel, "tag_origin" ); + m_generator_panel play_fx( "fx_alcatraz_panel_off_2", m_generator_panel.origin, m_generator_panel.angles, undefined, 1, undefined, undefined ); + set_generator_vfx_amount( level.n_generator_panels_active, generator_soundent ); + playsoundatposition( "zmb_quest_generator_panel_spark", m_generator_panel.origin ); +} + +set_generator_vfx_amount( n_vfx_amount, generator_soundent ) +{ + if ( n_vfx_amount == 1 ) + { + generator_soundent playloopsound( "zmb_quest_generator_loop1" ); + } + if ( n_vfx_amount == 2 ) + { + generator_soundent stoploopsound(); + wait 0,05; + generator_soundent playloopsound( "zmb_quest_generator_loop2" ); + } + if ( n_vfx_amount == 3 ) + { + exploder( 3100 ); + exploder( 3200 ); + exploder( 3300 ); + generator_soundent stoploopsound(); + wait 0,05; + generator_soundent playloopsound( "zmb_quest_generator_loop3" ); + } +} + +setup_gate_puzzle() +{ + self endon( "death" ); + is_gate_toggled = 0; + is_inner_gate_toggleable = 0; + m_gate_02 = getent( "cable_puzzle_gate_02", "targetname" ); + n_gate_move_duration = 0,5; + m_docks_shockbox = getent( "docks_panel", "targetname" ); + array_set_visible_to_all( getentarray( "wires_docks_gate_toggle", "script_noteworthy" ), 0 ); + a_players = []; + a_players = getplayers(); + if ( a_players.size > 1 ) + { + is_inner_gate_toggleable = 1; + } + while ( 1 ) + { + m_docks_shockbox thread afterlife_interact_object_think(); + level waittill( "cable_puzzle_gate_afterlife" ); + array_set_visible_to_all( getentarray( "wires_docks_gate_toggle", "script_noteworthy" ), 1 ); + if ( is_inner_gate_toggleable && flag( "docks_inner_gate_unlocked" ) ) + { + level thread toggle_inner_gate( n_gate_move_duration ); + } + if ( !flag( "docks_outer_gate_open" ) ) + { + m_gate_02 moveto( m_gate_02.origin + ( -16, 80, 0 ), n_gate_move_duration ); + wait ( n_gate_move_duration + 0,25 ); + m_gate_02 connectpaths(); + gate_2_monsterclip = getent( "docks_gate_2_monsterclip", "targetname" ); + gate_2_monsterclip.origin += vectorScale( ( 0, 0, 0 ), 256 ); + gate_2_monsterclip disconnectpaths(); + gate_2_monsterclip.origin -= vectorScale( ( 0, 0, 0 ), 256 ); + m_gate_02 playsound( "zmb_chainlink_close" ); + } + else + { + if ( !flag( "docks_gates_remain_open" ) ) + { + m_gate_02 moveto( m_gate_02.origin - ( -16, 80, 0 ), n_gate_move_duration ); + wait ( n_gate_move_duration + 0,25 ); + m_gate_02 disconnectpaths(); + gate_2_monsterclip = getent( "docks_gate_2_monsterclip", "targetname" ); + gate_2_monsterclip connectpaths(); + m_gate_02 playsound( "zmb_chainlink_open" ); + } + } + flag_toggle( "docks_outer_gate_open" ); +/# + iprintlnbold( "gate toggled!" ); +#/ + wait n_gate_move_duration; +/# + iprintlnbold( "gate ready to be re-toggled" ); +#/ + m_docks_shockbox notify( "afterlife_interact_reset" ); + array_set_visible_to_all( getentarray( "wires_docks_gate_toggle", "script_noteworthy" ), 0 ); + } +} + +toggle_inner_gate( n_gate_move_duration ) +{ + a_m_gate_01 = getentarray( "cable_puzzle_gate_01", "targetname" ); + if ( flag( "docks_inner_gate_open" ) && !flag( "docks_gates_remain_open" ) ) + { + i = 0; + while ( i < a_m_gate_01.size ) + { + a_m_gate_01[ i ] moveto( a_m_gate_01[ i ].origin - ( -16, 80, 0 ), n_gate_move_duration ); + i++; + } + wait ( n_gate_move_duration + 0,25 ); + i = 0; + while ( i < a_m_gate_01.size ) + { + a_m_gate_01[ i ] disconnectpaths(); + i++; + } + gate_1_monsterclip = getent( "docks_gate_1_monsterclip", "targetname" ); + gate_1_monsterclip connectpaths(); + a_m_gate_01[ 0 ] playsound( "zmb_chainlink_close" ); + } + else + { + i = 0; + while ( i < a_m_gate_01.size ) + { + a_m_gate_01[ i ] moveto( a_m_gate_01[ i ].origin + ( -16, 80, 0 ), n_gate_move_duration ); + i++; + } + wait ( n_gate_move_duration + 0,25 ); + i = 0; + while ( i < a_m_gate_01.size ) + { + a_m_gate_01[ i ] connectpaths(); + i++; + } + gate_1_monsterclip = getent( "docks_gate_1_monsterclip", "targetname" ); + gate_1_monsterclip.origin += vectorScale( ( 0, 0, 0 ), 256 ); + gate_1_monsterclip disconnectpaths(); + gate_1_monsterclip.origin -= vectorScale( ( 0, 0, 0 ), 256 ); + a_m_gate_01[ 0 ] playsound( "zmb_chainlink_open" ); + } + flag_toggle( "docks_inner_gate_open" ); +} + +plane_fly_trigger_thread() +{ + self setcursorhint( "HINT_NOICON" ); + self sethintstring( &"ZM_PRISON_PLANE_BEGIN_TAKEOFF" ); + flag_wait( "initial_players_connected" ); + flag_wait( "brutus_setup_complete" ); + self trigger_off(); + wait 1; + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_craftable show(); + m_plane_craftable hidepart( "tag_support_upper" ); + m_plane_craftable hidepart( "tag_wing_skins_up" ); + m_plane_craftable hidepart( "tag_engines_up" ); + m_plane_craftable hidepart( "tag_feul_tanks" ); + m_plane_craftable hidepart( "tag_control_mechanism" ); + m_plane_craftable hidepart( "tag_engine_ground" ); + m_plane_craftable hidepart( "tag_clothes_ground" ); + m_plane_craftable hidepart( "tag_fuel_hose" ); + waittill_crafted( "plane" ); + maps/mp/zombies/_zm_ai_brutus::transfer_plane_trigger( "build", "fly" ); + self trigger_on(); + while ( isDefined( self ) ) + { + self waittill( "trigger", e_triggerer ); + if ( isplayer( e_triggerer ) ) + { + if ( level.n_plane_fuel_count == 5 ) + { + while ( isDefined( level.custom_plane_validation ) ) + { + valid = self [[ level.custom_plane_validation ]]( e_triggerer ); + while ( !valid ) + { + continue; + } + } + self setinvisibletoplayer( e_triggerer ); + if ( isDefined( level.plane_boarding_thread_custom_func ) ) + { + e_triggerer thread [[ level.plane_boarding_thread_custom_func ]](); + break; + } + else + { + e_triggerer thread plane_boarding_thread(); + } + } + } + } +} + +plane_boarding_thread() +{ + self endon( "death_or_disconnect" ); + flag_set( "plane_is_away" ); + self thread player_disconnect_watcher(); + self thread player_death_watcher(); +/# + iprintlnbold( "plane boarding thread started" ); +#/ + flag_set( "plane_boarded" ); + self setclientfieldtoplayer( "effects_escape_flight", 1 ); + level.brutus_respawn_after_despawn = 0; + a_nml_teleport_targets = []; + i = 1; + while ( i < 6 ) + { + a_nml_teleport_targets[ i - 1 ] = getstruct( "nml_telepoint_" + i, "targetname" ); + i++; + } + level.characters_in_nml[ level.characters_in_nml.size ] = self.character_name; + self.on_a_plane = 1; + level.someone_has_visited_nml = 1; + self.n_passenger_index = level.characters_in_nml.size; + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_about_to_crash = getent( "plane_about_to_crash", "targetname" ); + veh_plane_flyable = getent( "plane_flyable", "targetname" ); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + t_plane_fly sethintstring( &"ZM_PRISON_PLANE_BOARD" ); + self enableinvulnerability(); + self playerlinktodelta( m_plane_craftable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + self allowstand( 0 ); + flag_wait( "plane_departed" ); + level notify( "sndStopBrutusLoop" ); + self clientnotify( "sndPS" ); + self playsoundtoplayer( "zmb_plane_takeoff", self ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "plane_takeoff", self ); + self playerlinktodelta( veh_plane_flyable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + self setclientfieldtoplayer( "effects_escape_flight", 2 ); + flag_wait( "plane_approach_bridge" ); + self thread snddelayedimp(); + self setclientfieldtoplayer( "effects_escape_flight", 3 ); + self unlink(); + self playerlinktoabsolute( veh_plane_flyable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + flag_wait( "plane_zapped" ); + flag_set( "activate_player_zone_bridge" ); + self playsoundtoplayer( "zmb_plane_fall", self ); + self setclientfieldtoplayer( "effects_escape_flight", 4 ); + self.dontspeak = 1; + self setclientfieldtoplayer( "isspeaking", 1 ); + self playerlinktodelta( m_plane_about_to_crash, "tag_player_crouched_" + ( self.n_passenger_index + 1 ), 1, 0, 0, 0, 0, 1 ); + self forcegrenadethrow(); + str_current_weapon = self getcurrentweapon(); + self giveweapon( "falling_hands_zm" ); + self switchtoweaponimmediate( "falling_hands_zm" ); + self setweaponammoclip( "falling_hands_zm", 0 ); + players = getplayers(); + _a1548 = players; + _k1548 = getFirstArrayKey( _a1548 ); + while ( isDefined( _k1548 ) ) + { + player = _a1548[ _k1548 ]; + if ( player != self ) + { + player setinvisibletoplayer( self ); + } + _k1548 = getNextArrayKey( _a1548, _k1548 ); + } + flag_wait( "plane_crashed" ); + self setclientfieldtoplayer( "effects_escape_flight", 5 ); + self takeweapon( "falling_hands_zm" ); + if ( isDefined( str_current_weapon ) && str_current_weapon != "none" ) + { + self switchtoweaponimmediate( str_current_weapon ); + } + self thread fadetoblackforxsec( 0, 2, 0, 0,5, "black" ); + self thread snddelayedmusic(); + self unlink(); + self allowstand( 1 ); + self setstance( "stand" ); + players = getplayers(); + _a1571 = players; + _k1571 = getFirstArrayKey( _a1571 ); + while ( isDefined( _k1571 ) ) + { + player = _a1571[ _k1571 ]; + if ( player != self ) + { + player setvisibletoplayer( self ); + } + _k1571 = getNextArrayKey( _a1571, _k1571 ); + } + flag_clear( "spawn_zombies" ); + self setorigin( a_nml_teleport_targets[ self.n_passenger_index ].origin ); + e_poi = getstruct( "plane_crash_poi", "targetname" ); + vec_to_target = e_poi.origin - self.origin; + vec_to_target = vectorToAngle( vec_to_target ); + vec_to_target = ( 0, vec_to_target[ 1 ], 0 ); + self setplayerangles( vec_to_target ); + n_shellshock_duration = 5; + self shellshock( "explosion", n_shellshock_duration ); + self.dontspeak = 0; + self setclientfieldtoplayer( "isspeaking", 0 ); + self notify( "player_at_bridge" ); + wait n_shellshock_duration; + self disableinvulnerability(); + self.on_a_plane = 0; + if ( level.characters_in_nml.size == 1 ) + { + self vo_bridge_soliloquy(); + } + else + { + if ( level.characters_in_nml.size == 4 ) + { + vo_bridge_four_part_convo(); + } + } + wait 10; + self playsoundtoplayer( "zmb_ggb_swarm_start", self ); + flag_set( "spawn_zombies" ); + level.brutus_respawn_after_despawn = 1; + wait 5; + character_name = level.characters_in_nml[ randomintrange( 0, level.characters_in_nml.size ) ]; + players = getplayers(); + _a1625 = players; + _k1625 = getFirstArrayKey( _a1625 ); + while ( isDefined( _k1625 ) ) + { + player = _a1625[ _k1625 ]; + if ( isDefined( player ) && player.character_name == character_name ) + { + player thread do_player_general_vox( "quest", "zombie_arrive_gg", undefined, 100 ); + } + _k1625 = getNextArrayKey( _a1625, _k1625 ); + } +} + +snddelayedimp() +{ + self endon( "disconnect" ); + wait 6; + self playsoundtoplayer( "zmb_plane_explode", self ); +} + +snddelayedmusic() +{ + self endon( "disconnect" ); + wait 1; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "at_golden_gate", self ); + self clientnotify( "sndPE" ); +} + +track_quest_status_thread() +{ + while ( 1 ) + { + while ( level.characters_in_nml.size == 0 ) + { + wait 1; + } + while ( level.characters_in_nml.size > 0 ) + { + wait 1; + } + if ( flag( "plane_trip_to_nml_successful" ) ) + { + bestow_quest_rewards(); + flag_clear( "plane_trip_to_nml_successful" ); + } + level notify( "bridge_empty" ); + level waittill( "start_of_round" ); + if ( level.n_quest_iteration_count == 2 ) + { + vo_play_four_part_conversation( level.four_part_convos[ "alcatraz_return_alt" + randomintrange( 0, 2 ) ] ); + } + prep_for_new_quest(); + waittill_crafted( "refuelable_plane" ); + maps/mp/zombies/_zm_ai_brutus::transfer_plane_trigger( "fuel", "fly" ); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + t_plane_fly trigger_on(); + } +} + +bestow_quest_rewards() +{ + level.n_quest_iteration_count += 1; + if ( level.n_quest_iteration_count == 2 ) + { + level notify( "unlock_all_perk_machines" ); + level notify( "intro_powerup_restored" ); + } + else + { + if ( level.n_quest_iteration_count == 4 ) + { + flag_set( "quest_completed_thrice" ); + } + } +} + +prep_for_new_quest() +{ + i = 1; + while ( i < 4 ) + { + str_trigger_targetname = "trigger_electric_chair_" + i; + t_electric_chair = getent( str_trigger_targetname, "targetname" ); + t_electric_chair sethintstring( &"ZM_PRISON_ELECTRIC_CHAIR_ACTIVATE" ); + t_electric_chair trigger_on(); + i++; + } + flag_set( "spawn_fuel_tanks" ); + wait 0,05; + flag_clear( "spawn_fuel_tanks" ); + i = 0; + while ( i < level.a_uts_craftables.size ) + { + if ( level.a_uts_craftables[ i ].equipname == "refuelable_plane" ) + { + t_plane_fuelable = level.a_uts_craftables[ i ]; + level.zones[ "zone_roof" ].plane_triggers[ level.zones[ "zone_roof" ].plane_triggers.size ] = t_plane_fuelable; + break; + } + else + { + i++; + } + } + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + t_plane_fly trigger_off(); + players = get_players(); + t_plane_fly setvisibletoall(); + maps/mp/zombies/_zm_ai_brutus::transfer_plane_trigger( "fly", "fuel" ); + i = 1; + while ( i < 5 ) + { + m_electric_chair = getent( "electric_chair_" + i, "targetname" ); + m_electric_chair notify( "bridge_empty" ); + i++; + } + setup_puzzle_piece_glint(); +/# + iprintlnbold( "plane location reset" ); +#/ + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_craftable show(); + playfxontag( level._effect[ "fx_alcatraz_plane_apear" ], m_plane_craftable, "tag_origin" ); + veh_plane_flyable = getent( "plane_flyable", "targetname" ); + veh_plane_flyable attachpath( getvehiclenode( "zombie_plane_underground", "targetname" ) ); + vo_play_four_part_conversation( level.four_part_convos[ "alcatraz_return_quest_reset" ] ); + flag_clear( "plane_is_away" ); +} + +plane_flight_thread() +{ + while ( 1 ) + { + m_plane_about_to_crash = getent( "plane_about_to_crash", "targetname" ); + m_plane_craftable = getent( "plane_craftable", "targetname" ); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + veh_plane_flyable = getent( "plane_flyable", "targetname" ); + m_plane_about_to_crash ghost(); + flag_wait( "plane_boarded" ); + level clientnotify( "sndPB" ); + if ( isDefined( level.music_override ) && !level.music_override ) + { + t_plane_fly playloopsound( "mus_event_plane_countdown_loop", 0,25 ); + } + i = 10; + while ( i > 0 ) + { +/# + iprintlnbold( "TAKE-OFF IN " + i + "..." ); +#/ + veh_plane_flyable playsound( "zmb_plane_countdown_tick" ); + wait 1; + i--; + + } + t_plane_fly stoploopsound( 2 ); + exploder( 10000 ); + veh_plane_flyable attachpath( getvehiclenode( "zombie_plane_flight_path", "targetname" ) ); + veh_plane_flyable startpath(); + flag_set( "plane_departed" ); + t_plane_fly trigger_off(); + m_plane_craftable ghost(); + veh_plane_flyable setvisibletoall(); + level setclientfield( "fog_stage", 1 ); + playfxontag( level._effect[ "fx_alcatraz_plane_trail" ], veh_plane_flyable, "tag_origin" ); + wait 2; + playfxontag( level._effect[ "fx_alcatraz_plane_trail_fast" ], veh_plane_flyable, "tag_origin" ); + wait 3; + exploder( 10001 ); + wait 4; + playfxontag( level._effect[ "fx_alcatraz_flight_lightning" ], veh_plane_flyable, "tag_origin" ); + level setclientfield( "scripted_lightning_flash", 1 ); + wait 1; + flag_set( "plane_approach_bridge" ); + stop_exploder( 10001 ); + level setclientfield( "fog_stage", 2 ); + veh_plane_flyable attachpath( getvehiclenode( "zombie_plane_bridge_approach", "targetname" ) ); + veh_plane_flyable startpath(); + wait 6; + playfxontag( level._effect[ "fx_alcatraz_flight_lightning" ], veh_plane_flyable, "tag_origin" ); + level setclientfield( "scripted_lightning_flash", 1 ); + veh_plane_flyable waittill( "reached_end_node" ); + flag_set( "plane_zapped" ); + level setclientfield( "fog_stage", 3 ); + veh_plane_flyable setinvisibletoall(); + n_crash_duration = 2,25; + nd_plane_about_to_crash_1 = getstruct( "plane_about_to_crash_point_1", "targetname" ); + m_plane_about_to_crash.origin = nd_plane_about_to_crash_1.origin; + nd_plane_about_to_crash_2 = getstruct( "plane_about_to_crash_point_2", "targetname" ); + m_plane_about_to_crash moveto( nd_plane_about_to_crash_2.origin, n_crash_duration ); + m_plane_about_to_crash thread spin_while_falling(); + stop_exploder( 10000 ); + m_plane_about_to_crash waittill( "movedone" ); + flag_set( "plane_crashed" ); + wait 2; + level setclientfield( "scripted_lightning_flash", 1 ); + m_plane_about_to_crash.origin += vectorScale( ( 0, 0, 0 ), 2048 ); + wait 4; + veh_plane_flyable setvisibletoall(); + veh_plane_flyable play_fx( "fx_alcatraz_plane_fire_trail", veh_plane_flyable.origin, veh_plane_flyable.angles, "reached_end_node", 1, "tag_origin", undefined ); + veh_plane_flyable attachpath( getvehiclenode( "zombie_plane_bridge_flyby", "targetname" ) ); + veh_plane_flyable startpath(); + veh_plane_flyable thread sndpc(); + veh_plane_flyable waittill( "reached_end_node" ); + veh_plane_flyable setinvisibletoall(); + wait 20; + if ( !level.final_flight_activated ) + { + if ( isDefined( level.brutus_on_the_bridge_custom_func ) ) + { + level thread [[ level.brutus_on_the_bridge_custom_func ]](); + break; + } + else + { + level thread brutus_on_the_bridge(); + } + } + flag_clear( "plane_built" ); + flag_clear( "plane_boarded" ); + flag_clear( "plane_departed" ); + flag_clear( "plane_approach_bridge" ); + flag_clear( "plane_zapped" ); + flag_clear( "plane_crashed" ); + level.n_plane_fuel_count = 0; + } +} + +sndpc() +{ + self playloopsound( "zmb_plane_fire", 4 ); + wait 6; + self playsound( "zmb_plane_fire_whoosh" ); + wait 1; + self stoploopsound( 3 ); +} + +brutus_on_the_bridge() +{ + level endon( "bridge_empty" ); + n_round_on_bridge = 1; + n_desired_spawn_count = 0; + n_spawn_cap = 4; + level.n_bridge_brutuses_killed = 0; + if ( isDefined( level.last_brutus_on_bridge_custom_func ) ) + { + level thread [[ level.last_brutus_on_bridge_custom_func ]](); + } + else + { + level thread last_brutus_on_bridge(); + } + if ( isDefined( level.brutus_despawn_manager_custom_func ) ) + { + level thread [[ level.brutus_despawn_manager_custom_func ]](); + } + else + { + level thread brutus_despawn_manager(); + } + while ( 1 ) + { + level.brutus_last_spawn_round = 0; + n_desired_spawn_count = int( min( n_round_on_bridge, n_spawn_cap ) ); + n_brutuses_on_bridge_count = get_bridge_brutus_count(); + n_spawns_needed = n_desired_spawn_count - n_brutuses_on_bridge_count; + i = n_spawns_needed; + while ( i > 0 ) + { + ai = maps/mp/zombies/_zm_ai_brutus::brutus_spawn_in_zone( "zone_golden_gate_bridge", 1 ); + if ( isDefined( ai ) ) + { + ai.is_bridge_brutus = 1; + if ( level.n_bridge_brutuses_killed == 0 ) + { + ai thread suppress_brutus_bridge_powerups(); + } + } + wait randomfloatrange( 1, 4 ); + i--; + + } + level waittill( "start_of_round" ); + n_round_on_bridge++; + } +} + +last_brutus_on_bridge() +{ + level endon( "bridge_empty" ); + e_gg_zone = getent( "zone_golden_gate_bridge", "targetname" ); + a_bridge_brutuses = []; + while ( 1 ) + { + a_bridge_brutuses = get_bridge_brutuses(); + if ( a_bridge_brutuses.size > 1 ) + { + _a2012 = a_bridge_brutuses; + _k2012 = getFirstArrayKey( _a2012 ); + while ( isDefined( _k2012 ) ) + { + brutus = _a2012[ _k2012 ]; + if ( isDefined( brutus ) ) + { + brutus.suppress_teargas_behavior = 1; + } + _k2012 = getNextArrayKey( _a2012, _k2012 ); + } + } + else if ( a_bridge_brutuses.size == 1 ) + { + a_bridge_brutuses[ 0 ].suppress_teargas_behavior = 0; + } + wait 0,05; + } +} + +suppress_brutus_bridge_powerups() +{ + self endon( "brutus_teleporting" ); + level endon( "bridge_empty" ); + level endon( "first_bridge_brutus_killed" ); + self waittill( "death" ); + level.n_bridge_brutuses_killed++; + if ( level.n_bridge_brutuses_killed >= 1 ) + { + level.global_brutus_powerup_prevention = 1; + level thread allow_brutus_powerup_spawning(); + level notify( "first_bridge_brutus_killed" ); + } +} + +allow_brutus_powerup_spawning() +{ + level notify( "only_one_powerup_thread" ); + level endon( "only_one_powerup_thread" ); + level waittill( "bridge_empty" ); + level.global_brutus_powerup_prevention = 0; +} + +get_bridge_brutuses() +{ + e_gg_zone = getent( "zone_golden_gate_bridge", "targetname" ); + a_bridge_brutuses = []; + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + if ( isDefined( zombies[ i ].is_brutus ) && zombies[ i ].is_brutus ) + { + brutus = zombies[ i ]; + if ( brutus istouching( e_gg_zone ) ) + { + brutus.is_bridge_brutus = 1; + a_bridge_brutuses[ a_bridge_brutuses.size ] = brutus; + } + } + i++; + } + return a_bridge_brutuses; +} + +brutus_despawn_manager() +{ + level notify( "brutus_despawn_manager" ); + level endon( "brutus_despawn_manager" ); + level endon( "bridge_empty" ); + e_gg_zone = getent( "zone_golden_gate_bridge", "targetname" ); + while ( 1 ) + { + b_is_time_to_despawn = 0; + while ( !b_is_time_to_despawn ) + { + b_is_time_to_despawn = 1; + players = getplayers(); + _a2098 = players; + _k2098 = getFirstArrayKey( _a2098 ); + while ( isDefined( _k2098 ) ) + { + player = _a2098[ _k2098 ]; + if ( isDefined( player ) && player istouching( e_gg_zone ) && !player.afterlife && !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + b_is_time_to_despawn = 0; + } + _k2098 = getNextArrayKey( _a2098, _k2098 ); + } + wait 0,1; + } + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + if ( isDefined( zombies[ i ].is_brutus ) && zombies[ i ].is_brutus && isDefined( zombies[ i ].is_bridge_brutus ) && zombies[ i ].is_bridge_brutus ) + { + level thread brutus_temp_despawn( zombies[ i ], "bridge_empty", "bring_bridge_brutuses_back" ); + } + i++; + } + b_is_time_to_bring_back = 0; + while ( !b_is_time_to_bring_back ) + { + b_is_time_to_bring_back = 0; + players = getplayers(); + _a2125 = players; + _k2125 = getFirstArrayKey( _a2125 ); + while ( isDefined( _k2125 ) ) + { + player = _a2125[ _k2125 ]; + if ( isDefined( player ) && player istouching( e_gg_zone ) && !player.afterlife && !player maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + b_is_time_to_bring_back = 1; + } + _k2125 = getNextArrayKey( _a2125, _k2125 ); + } + wait 0,1; + } + level notify( "bring_bridge_brutuses_back" ); + } +} + +get_bridge_brutus_count() +{ + n_touching_count = 0; + e_gg_zone = getent( "zone_golden_gate_bridge", "targetname" ); + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + if ( isDefined( zombies[ i ].is_brutus ) && zombies[ i ].is_brutus ) + { + brutus = zombies[ i ]; + if ( brutus istouching( e_gg_zone ) ) + { + n_touching_count++; + } + } + i++; + } + return n_touching_count; +} + +clean_up_bridge_brutuses() +{ + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + if ( isDefined( zombies[ i ].is_brutus ) && zombies[ i ].is_brutus && isDefined( zombies[ i ].is_bridge_brutus ) && zombies[ i ].is_bridge_brutus ) + { + brutus = zombies[ i ]; + brutus dodamage( 10000, brutus.origin ); + } + i++; + } +} + +spin_while_falling() +{ + self endon( "movedone" ); + while ( 1 ) + { + self.angles += vectorScale( ( 0, 0, 0 ), 4 ); + wait 0,05; + } +} + +manage_electric_chairs() +{ + level notify( "manage_electric_chairs" ); + level endon( "manage_electric_chairs" ); + n_chairs_wait = 60; + while ( 1 ) + { + flag_wait( "plane_approach_bridge" ); + i = 1; + while ( i < 5 ) + { + str_trigger_targetname = "trigger_electric_chair_" + i; + t_electric_chair = getent( str_trigger_targetname, "targetname" ); + if ( isDefined( level.electric_chair_trigger_thread_custom_func ) ) + { + t_electric_chair thread [[ level.electric_chair_trigger_thread_custom_func ]]( i ); + } + else + { + t_electric_chair thread electric_chair_trigger_thread( i ); + } + t_electric_chair setcursorhint( "HINT_NOICON" ); + t_electric_chair sethintstring( &"ZM_PRISON_ELECTRIC_CHAIR_ACTIVATE" ); + t_electric_chair usetriggerrequirelookat(); + i++; + } + if ( level.final_flight_activated ) + { + level.revive_trigger_should_ignore_sight_checks = ::maps/mp/zm_prison_sq_final::revive_trigger_should_ignore_sight_checks; + j = 0; + while ( j < level.final_flight_players.size ) + { + m_electric_chair = getent( "electric_chair_" + ( j + 1 ), "targetname" ); + corpse = level.final_flight_players[ j ].e_afterlife_corpse; + corpse linkto( m_electric_chair, "tag_origin", ( 0, 0, 0 ), ( 0, 0, 0 ) ); + corpse maps/mp/zombies/_zm_clone::clone_animate( "chair" ); + wait 1; + corpse.revivetrigger unlink(); + corpse.revivetrigger.origin = m_electric_chair.origin + ( 64, 0, 32 ); +/# + corpse.revivetrigger thread print3d_ent( "revivetrigger" ); +#/ + j++; + } + j = 1; + while ( j < 5 ) + { + str_trigger_targetname = "trigger_electric_chair_" + j; + t_electric_chair = getent( str_trigger_targetname, "targetname" ); + t_electric_chair trigger_off(); + j++; + } + while ( flag( "plane_approach_bridge" ) ) + { + wait 1; + } + } + else i = 1; + while ( i < 5 ) + { + m_electric_chair = getent( "electric_chair_" + i, "targetname" ); + m_electric_chair hide(); + str_trigger_targetname = "trigger_electric_chair_" + i; + t_electric_chair = getent( str_trigger_targetname, "targetname" ); + t_electric_chair trigger_off(); + i++; + } + flag_wait( "plane_crashed" ); + wait n_chairs_wait; + exploder( 666 ); + i = 1; + while ( i < 5 ) + { + m_electric_chair = getent( "electric_chair_" + i, "targetname" ); + m_electric_chair show(); + m_electric_chair thread snddelayedchairaudio( i ); + str_trigger_targetname = "trigger_electric_chair_" + i; + t_electric_chair = getent( str_trigger_targetname, "targetname" ); + t_electric_chair trigger_on(); + i++; + } + wait 3; + electric_chair_vo(); + wait 6; + } +} + +snddelayedchairaudio( i ) +{ + wait ( i / 10 ); + self playsound( "zmb_quest_electricchair_spawn" ); +} + +electric_chair_trigger_thread( chair_number ) +{ + level notify( "electric_chair_trigger_thread_" + chair_number ); + level endon( "electric_chair_trigger_thread_" + chair_number ); + m_electric_chair = getent( "electric_chair_" + chair_number, "targetname" ); + n_effects_wait_1 = 4; + n_effects_wait_2 = 0,15; + n_effects_wait_3 = 2; + n_effects_wait_4 = 2; + n_effects_duration = n_effects_wait_1 + n_effects_wait_2 + n_effects_wait_3 + n_effects_wait_4; + while ( 1 ) + { + self waittill( "trigger", e_triggerer ); + character_name = e_triggerer.character_name; + if ( isplayer( e_triggerer ) && !e_triggerer.afterlife ) + { + e_triggerer enableinvulnerability(); + self sethintstring( "" ); + self trigger_off(); + flag_set( "plane_trip_to_nml_successful" ); + if ( level.characters_in_nml.size == 1 ) + { + clean_up_bridge_brutuses(); + } + v_origin = m_electric_chair gettagorigin( "seated" ) + ( 10, 0, -40 ); + v_seated_angles = m_electric_chair gettagangles( "seated" ); + m_linkpoint = spawn_model( "tag_origin", v_origin, v_seated_angles ); + if ( isDefined( level.electric_chair_player_thread_custom_func ) ) + { + e_triggerer thread [[ level.electric_chair_player_thread_custom_func ]]( m_linkpoint, chair_number, n_effects_duration ); + } + else + { + e_triggerer thread electric_chair_player_thread( m_linkpoint, chair_number, n_effects_duration ); + } + chair_corpse = e_triggerer maps/mp/zombies/_zm_clone::spawn_player_clone( e_triggerer, e_triggerer.origin, undefined ); + chair_corpse linkto( m_electric_chair, "tag_origin", ( 0, 0, 0 ), ( 0, 0, 0 ) ); + chair_corpse.ignoreme = 1; + chair_corpse show(); + chair_corpse detachall(); + chair_corpse setvisibletoall(); + chair_corpse setinvisibletoplayer( e_triggerer ); + chair_corpse maps/mp/zombies/_zm_clone::clone_animate( "chair" ); + if ( isDefined( e_triggerer ) ) + { + e_triggerer setclientfieldtoplayer( "rumble_electric_chair", 1 ); + } + wait n_effects_wait_1; + m_fx_1 = spawn_model( "tag_origin", ( -516,883, -3912,04, -7494,9 ), vectorScale( ( 0, 0, 0 ), 180 ) ); + m_fx_2 = spawn_model( "tag_origin", ( -517,024, -3252,66, -7496,2 ), ( 0, 0, 0 ) ); + level setclientfield( "scripted_lightning_flash", 1 ); + wait n_effects_wait_2; + playfxontag( level._effect[ "fx_alcatraz_lightning_finale" ], m_fx_1, "tag_origin" ); + playfxontag( level._effect[ "fx_alcatraz_lightning_finale" ], m_fx_2, "tag_origin" ); + m_fx_3 = spawn_model( "tag_origin", ( -753,495, -3092,62, -8416,6 ), vectorScale( ( 0, 0, 0 ), 270 ) ); + playfxontag( level._effect[ "fx_alcatraz_lightning_wire" ], m_fx_3, "tag_origin" ); + wait n_effects_wait_3; + m_electric_chair play_fx( "fx_alcatraz_elec_chair", m_electric_chair.origin, m_electric_chair.angles, "bridge_empty" ); + if ( isDefined( e_triggerer ) ) + { + e_triggerer setclientfieldtoplayer( "rumble_electric_chair", 2 ); + } + wait n_effects_wait_4; + playfxontag( level._effect[ "fx_alcatraz_afterlife_zmb_tport" ], m_electric_chair, "tag_origin" ); + if ( isDefined( e_triggerer ) ) + { + e_triggerer playsoundtoplayer( "zmb_afterlife_death", e_triggerer ); + } + chair_corpse delete(); + if ( level.characters_in_nml.size == 1 ) + { + clean_up_bridge_brutuses(); + } + if ( isinarray( level.characters_in_nml, character_name ) ) + { + arrayremovevalue( level.characters_in_nml, character_name ); + } + m_fx_1 delete(); + m_fx_2 delete(); + self sethintstring( &"ZM_PRISON_ELECTRIC_CHAIR_ACTIVATE" ); + self trigger_on(); + } + } +} + +electric_chair_player_thread( m_linkpoint, chair_number, n_effects_duration ) +{ + self endon( "death_or_disconnect" ); + e_home_telepoint = getstruct( "home_telepoint_" + chair_number, "targetname" ); + e_corpse_location = getstruct( "corpse_starting_point_" + chair_number, "targetname" ); + self disableweapons(); + self enableinvulnerability(); + self setstance( "stand" ); + self playerlinktodelta( m_linkpoint, "tag_origin", 1, 20, 20, 20, 20 ); + self setplayerangles( m_linkpoint.angles ); + self playsoundtoplayer( "zmb_electric_chair_2d", self ); + self do_player_general_vox( "quest", "chair_electrocution", undefined, 100 ); + self ghost(); + self.ignoreme = 1; + self.dontspeak = 1; + self setclientfieldtoplayer( "isspeaking", 1 ); + wait ( n_effects_duration - 2 ); + switch( self.character_name ) + { + case "Arlington": + self playsoundontag( "vox_plr_3_arlington_electrocution_0", "J_Head" ); + break; + case "Sal": + self playsoundontag( "vox_plr_1_sal_electrocution_0", "J_Head" ); + break; + case "Billy": + self playsoundontag( "vox_plr_2_billy_electrocution_0", "J_Head" ); + break; + case "Finn": + self playsoundontag( "vox_plr_0_finn_electrocution_0", "J_Head" ); + break; + } + wait 2; + level.zones[ "zone_golden_gate_bridge" ].is_enabled = 1; + level.zones[ "zone_golden_gate_bridge" ].is_spawning_allowed = 1; + self.keep_perks = 1; + self disableinvulnerability(); + self.afterlife = 1; + self thread afterlife_laststand( 1 ); + self unlink(); + self setstance( "stand" ); + self waittill( "player_fake_corpse_created" ); + self thread track_player_completed_cycle(); + trace_start = e_corpse_location.origin + vectorScale( ( 0, 0, 0 ), 100 ); + trace_end = e_corpse_location.origin + vectorScale( ( 0, 0, 0 ), 100 ); + corpse_trace = bullettrace( trace_start, trace_end, 0, self.e_afterlife_corpse ); + self.e_afterlife_corpse.origin = corpse_trace[ "position" ]; + self setorigin( e_home_telepoint.origin ); + self enableweapons(); + self setclientfieldtoplayer( "rumble_electric_chair", 0 ); + if ( level.n_quest_iteration_count == 2 ) + { + self waittill( "player_revived" ); + wait 1; + self do_player_general_vox( "quest", "start_2", undefined, 100 ); + } +} + +track_player_completed_cycle() +{ + self endon( "disconnect" ); + self.e_afterlife_corpse waittill( "death" ); + self notify( "player_completed_cycle" ); + level notify( "someone_completed_quest_cycle" ); +} + +reset_plane_hint_string( player ) +{ + if ( isDefined( self.stub ) ) + { +/# + println( "Error: This should have been handled by the craftables callback" ); +#/ + } + else + { + self.fly_trigger sethintstring( &"ZM_PRISON_PLANE_BEGIN_TAKEOFF" ); + } +} + +play_fx( str_fx, v_origin, v_angles, time_to_delete_or_notify, b_link_to_self, str_tag, b_no_cull ) +{ + if ( isDefined( time_to_delete_or_notify ) && !isstring( time_to_delete_or_notify ) && time_to_delete_or_notify == -1 && isDefined( b_link_to_self ) && b_link_to_self && isDefined( str_tag ) ) + { + playfxontag( getfx( str_fx ), self, str_tag ); + return self; + } + else + { + m_fx = spawn_model( "tag_origin", v_origin, v_angles ); + if ( isDefined( b_link_to_self ) && b_link_to_self ) + { + if ( isDefined( str_tag ) ) + { + m_fx linkto( self, str_tag, ( 0, 0, 0 ), ( 0, 0, 0 ) ); + } + else + { + m_fx linkto( self ); + } + } + if ( isDefined( b_no_cull ) && b_no_cull ) + { + m_fx setforcenocull(); + } + playfxontag( getfx( str_fx ), m_fx, "tag_origin" ); + m_fx thread _play_fx_delete( self, time_to_delete_or_notify ); + return m_fx; + } +} + +spawn_model( model_name, origin, angles, n_spawnflags ) +{ + if ( !isDefined( n_spawnflags ) ) + { + n_spawnflags = 0; + } + if ( !isDefined( origin ) ) + { + origin = ( 0, 0, 0 ); + } + model = spawn( "script_model", origin, n_spawnflags ); + model setmodel( model_name ); + if ( isDefined( angles ) ) + { + model.angles = angles; + } + return model; +} + +getfx( fx ) +{ +/# + assert( isDefined( level._effect[ fx ] ), "Fx " + fx + " is not defined in level._effect." ); +#/ + return level._effect[ fx ]; +} + +_play_fx_delete( ent, time_to_delete_or_notify ) +{ + if ( !isDefined( time_to_delete_or_notify ) ) + { + time_to_delete_or_notify = -1; + } + if ( isstring( time_to_delete_or_notify ) ) + { + ent waittill_either( "death", time_to_delete_or_notify ); + } + else if ( time_to_delete_or_notify > 0 ) + { + ent waittill_notify_or_timeout( "death", time_to_delete_or_notify ); + } + else + { + ent waittill( "death" ); + } + if ( isDefined( self ) ) + { + self delete(); + } +} + +player_disconnect_watcher() +{ + if ( isDefined( level.player_disconnect_watcher_custom_func ) ) + { + self thread [[ level.player_disconnect_watcher_custom_func ]](); + return; + } + self notify( "disconnect_watcher" ); + self endon( "disconnect_watcher" ); + level endon( "bridge_empty" ); +/# + iprintlnbold( "player_disconnect_watcher" ); +#/ + if ( !isDefined( self.character_name ) ) + { + wait 0,1; + } + character_name = self.character_name; + self waittill( "disconnect" ); +/# + iprintlnbold( character_name + " disconnected!" ); +#/ + if ( isinarray( level.characters_in_nml, character_name ) ) + { + arrayremovevalue( level.characters_in_nml, character_name ); + flag_set( "spawn_zombies" ); + level.brutus_respawn_after_despawn = 1; + } +} + +player_death_watcher() +{ + if ( isDefined( level.player_death_watcher_custom_func ) ) + { + self thread [[ level.player_death_watcher_custom_func ]](); + return; + } + self notify( "player_death_watcher" ); + self endon( "player_death_watcher" ); + level endon( "bridge_empty" ); +/# + iprintlnbold( "player_death_watcher" ); +#/ + e_gg_zone = getent( "zone_golden_gate_bridge", "targetname" ); + nml_trip_is_over = 0; + while ( !nml_trip_is_over ) + { + level waittill( "start_of_round" ); + nml_trip_is_over = 1; + players = getplayers(); + _a2671 = players; + _k2671 = getFirstArrayKey( _a2671 ); + while ( isDefined( _k2671 ) ) + { + player = _a2671[ _k2671 ]; + if ( player istouching( e_gg_zone ) || isDefined( player.on_a_plane ) && player.on_a_plane ) + { + nml_trip_is_over = 0; + if ( !isinarray( level.characters_in_nml, player.character_name ) ) + { + level.characters_in_nml[ level.characters_in_nml.size ] = player.character_name; + } + } + _k2671 = getNextArrayKey( _a2671, _k2671 ); + } + } + while ( isDefined( level.characters_in_nml ) ) + { + i = 0; + while ( i < level.characters_in_nml.size ) + { + character_name = level.characters_in_nml[ i ]; + if ( isinarray( level.characters_in_nml, character_name ) ) + { + arrayremovevalue( level.characters_in_nml, character_name ); + } + i++; + } + } + flag_set( "spawn_zombies" ); + level.brutus_respawn_after_despawn = 1; +} + +array_set_visible_to_all( a_ents, is_visible ) +{ + if ( is_visible ) + { + _a2707 = a_ents; + _k2707 = getFirstArrayKey( _a2707 ); + while ( isDefined( _k2707 ) ) + { + ent = _a2707[ _k2707 ]; + ent setvisibletoall(); + _k2707 = getNextArrayKey( _a2707, _k2707 ); + } + } + else _a2714 = a_ents; + _k2714 = getFirstArrayKey( _a2714 ); + while ( isDefined( _k2714 ) ) + { + ent = _a2714[ _k2714 ]; + ent setinvisibletoall(); + _k2714 = getNextArrayKey( _a2714, _k2714 ); + } +} + +warden_fence_hotjoin_handler() +{ + while ( 1 ) + { + level waittill( "warden_fence_up" ); + stop_exploder( 2000 ); + exploder( 2000 ); + wait 0,05; + } +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_sq_nixie.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_sq_nixie.gsc new file mode 100644 index 0000000..9041ab3 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_sq_nixie.gsc @@ -0,0 +1,594 @@ +#include maps/mp/zm_alcatraz_sq; +#include maps/mp/gametypes_zm/_hud; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_sidequests; +#include maps/mp/zombies/_zm_craftables; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/zombies/_zm_afterlife; +#include maps/_vehicle; +#include maps/_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +setup_nixie_tubes_puzzle() +{ + level.a_nixie_tube_code = []; + level.a_nixie_tube_solution = []; + t_elevator_door = getent( "nixie_elevator_door", "targetname" ); + t_elevator_door trigger_off(); + m_rigging = get_craftable_piece_model( "plane", "rigging" ); + m_citadel_elevator = getent( "citadel_elevator", "targetname" ); + m_rigging linkto( m_citadel_elevator ); + level thread nixie_tube_notifier(); + level thread nixie_tube_elevator_door(); + while ( !flag( "nixie_puzzle_completed" ) ) + { + generate_unrestricted_nixie_tube_solution(); + n_code = nixie_tube_add_code( level.a_nixie_tube_solution[ 1 ], level.a_nixie_tube_solution[ 2 ], level.a_nixie_tube_solution[ 3 ] ); + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + m_nixie_tube thread nixie_tube_thread( i ); + m_nixie_clue = getent( "nixie_clue_" + i, "script_noteworthy" ); + j = 0; + while ( j < 10 ) + { + m_nixie_clue hidepart( "J_" + j ); + j++; + } + players = getplayers(); + _a76 = players; + _k76 = getFirstArrayKey( _a76 ); + while ( isDefined( _k76 ) ) + { + player = _a76[ _k76 ]; + if ( isDefined( player ) && isDefined( player.afterlife ) && player.afterlife ) + { + m_nixie_clue setvisibletoplayer( player ); + } + _k76 = getNextArrayKey( _a76, _k76 ); + } + m_nixie_clue showpart( "J_" + level.a_nixie_tube_solution[ i ] ); + i++; + } + level waittill( "nixie_" + n_code ); + flag_set( "nixie_puzzle_solved" ); + nixie_tube_remove_code( n_code ); + i = 1; + while ( i < 4 ) + { + m_nixie_clue = getent( "nixie_clue_" + i, "script_noteworthy" ); + m_nixie_clue setinvisibletoall(); + i++; + } + nixie_tube_2 = getent( "nixie_tube_2", "targetname" ); + nixie_tube_2 playsound( "zmb_quest_nixie_success" ); + level thread nixie_tube_elevator_drops(); + nixie_tube_win_effects_all_tubes( 0, 6, 0 ); + wait 0,5; + n_countdown = 60; + level thread sndnixietubecountdown( n_countdown ); + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + level notify( "nixie_tube_trigger_" + i ); + m_nixie_tube thread nixie_tube_thread_play_countdown( i, n_countdown ); + i++; + } + flag_set( "nixie_countdown_started" ); + flag_wait( "nixie_countdown_expired" ); + if ( !flag( "nixie_puzzle_completed" ) ) + { + t_elevator_door = getent( "nixie_elevator_door", "targetname" ); + t_elevator_door trigger_off(); + flag_clear( "nixie_countdown_started" ); + flag_clear( "nixie_countdown_expired" ); + flag_clear( "nixie_puzzle_solved" ); + nixie_tube_elevator_rises(); + } + } + m_nixie_tube = getent( "nixie_tube_2", "targetname" ); + m_nixie_tube playsound( "zmb_quest_nixie_success" ); +/# + iprintlnbold( "nixie puzzle solved!" ); +#/ + flag_clear( "nixie_puzzle_solved" ); + array_delete( getentarray( "wires_nixie_elevator", "script_noteworthy" ) ); + stop_exploder( 3400 ); + stop_exploder( 3500 ); + stop_exploder( 3600 ); + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + m_nixie_tube thread afterlife_interact_object_think(); + m_nixie_tube thread nixie_tube_thread( i ); + i++; + } +} + +generate_unrestricted_nixie_tube_solution() +{ + a_restricted_solutions = []; + a_restricted_solutions[ 0 ] = 115; + a_restricted_solutions[ 1 ] = 935; + a_restricted_solutions[ 2 ] = 386; + a_restricted_solutions[ 3 ] = 481; + a_restricted_solutions[ 4 ] = 101; + a_restricted_solutions[ 5 ] = 872; + a_numbers = []; + i = 0; + while ( i < 10 ) + { + a_numbers[ i ] = i; + i++; + } + i = 1; + while ( i < 4 ) + { + n_index = randomint( a_numbers.size ); + level.a_nixie_tube_solution[ i ] = a_numbers[ n_index ]; + arrayremoveindex( a_numbers, n_index ); + i++; + } + i = 0; + while ( i < a_restricted_solutions.size ) + { + b_is_restricted_solution = 1; + restricted_solution = []; + j = 1; + while ( j < 4 ) + { + restricted_solution[ j ] = get_split_number( j, a_restricted_solutions[ i ] ); + if ( restricted_solution[ j ] != level.a_nixie_tube_solution[ j ] ) + { + b_is_restricted_solution = 0; + } + j++; + } + if ( b_is_restricted_solution ) + { + n_index = randomint( a_numbers.size ); + level.a_nixie_tube_solution[ 3 ] = a_numbers[ n_index ]; + } + i++; + } +} + +nixie_tube_notifier() +{ + if ( !isDefined( level.a_important_codes ) ) + { + level.a_important_codes = []; + level.a_important_codes[ level.a_important_codes.size ] = 115; + level.a_important_codes[ level.a_important_codes.size ] = 935; + } + level thread nixie_115(); + level thread nixie_935(); + while ( !isDefined( level.a_nixie_tube_code ) || !isDefined( level.a_nixie_tube_code[ 3 ] ) ) + { + wait 1; + } + while ( 1 ) + { + codes_to_check = array_copy( level.a_important_codes ); + non_array_value = ( level.a_nixie_tube_code[ 1 ] * 100 ) + ( level.a_nixie_tube_code[ 2 ] * 10 ) + level.a_nixie_tube_code[ 3 ]; + _a240 = codes_to_check; + _k240 = getFirstArrayKey( _a240 ); + while ( isDefined( _k240 ) ) + { + code = _a240[ _k240 ]; + if ( code == non_array_value ) + { + level notify( "nixie_" + code ); + } + _k240 = getNextArrayKey( _a240, _k240 ); + } + wait 2; + } +} + +nixie_tube_add_code( a, b, c ) +{ + if ( isDefined( b ) ) + { + non_array_value = ( a * 100 ) + ( b * 10 ) + c; + } + else + { + non_array_value = a; + } + level.a_important_codes[ level.a_important_codes.size ] = non_array_value; + return non_array_value; +} + +nixie_tube_remove_code( a, b, c ) +{ + if ( isDefined( b ) ) + { + non_array_value = ( a * 100 ) + ( b * 10 ) + c; + } + else + { + non_array_value = a; + } + arrayremovevalue( level.a_important_codes, non_array_value ); +} + +sndnixietubecountdown( num ) +{ + level endon( "sndEndNixieCount" ); + ent = getent( "nixie_tube_2", "targetname" ); + i = num; + while ( i > 0 ) + { + if ( i <= 10 ) + { + ent playsound( "zmb_quest_nixie_count_final" ); + } + else + { + ent playsound( "zmb_quest_nixie_count" ); + } + wait 1; + i--; + + } + ent playsound( "zmb_quest_nixie_fail" ); +} + +nixie_tube_thread( n_tube_index, b_force_reset ) +{ + if ( !isDefined( b_force_reset ) ) + { + b_force_reset = 1; + } + level endon( "kill_nixie_input" ); + if ( b_force_reset ) + { + level.a_nixie_tube_code[ n_tube_index ] = 0; + } + self thread afterlife_interact_object_think(); + i = 0; + while ( i < 10 ) + { + self hidepart( "J_off" ); + self hidepart( "J_" + i ); + i++; + } + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + while ( !flag( "nixie_puzzle_solved" ) ) + { + level waittill( "nixie_tube_trigger_" + n_tube_index ); + while ( flag( "nixie_puzzle_solved" ) ) + { + continue; + } + i = 0; + while ( i < 10 ) + { + self hidepart( "J_" + i ); + i++; + } + level.a_nixie_tube_code[ n_tube_index ]++; + self playsound( "zmb_quest_nixie_count" ); + if ( level.a_nixie_tube_code[ n_tube_index ] > 9 ) + { + level.a_nixie_tube_code[ n_tube_index ] = 0; + } + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait 0,05; + self notify( "afterlife_interact_reset" ); + } +} + +nixie_tube_win_effects( n_tube_index, n_blink_rate ) +{ + if ( !isDefined( n_blink_rate ) ) + { + n_blink_rate = 0,25; + } + while ( !flag( "nixie_countdown_started" ) ) + { + self hidepart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait n_blink_rate; + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait n_blink_rate; + } + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); +} + +nixie_tube_win_effects_all_tubes( goal_num_1, goal_num_2, goal_num_3 ) +{ + if ( !isDefined( goal_num_1 ) ) + { + goal_num_1 = 0; + } + if ( !isDefined( goal_num_2 ) ) + { + goal_num_2 = 0; + } + if ( !isDefined( goal_num_3 ) ) + { + goal_num_3 = 0; + } + a_nixie_tube = []; + a_nixie_tube[ 1 ] = getent( "nixie_tube_1", "targetname" ); + a_nixie_tube[ 2 ] = getent( "nixie_tube_2", "targetname" ); + a_nixie_tube[ 3 ] = getent( "nixie_tube_3", "targetname" ); + n_off_tube = 1; + start_time = 0; + while ( start_time < 3 ) + { + i = 1; + while ( i < ( 3 + 1 ) ) + { + if ( i == n_off_tube ) + { + a_nixie_tube[ i ] hidepart( "J_" + level.a_nixie_tube_code[ i ] ); + i++; + continue; + } + else + { + a_nixie_tube[ i ] showpart( "J_" + level.a_nixie_tube_code[ i ] ); + if ( i == 1 || n_off_tube == 2 && i == 3 && n_off_tube == 1 ) + { + a_nixie_tube[ i ] playsound( "zmb_quest_nixie_count" ); + } + } + i++; + } + n_off_tube++; + if ( n_off_tube > 3 ) + { + n_off_tube = 1; + } + wait_network_frame(); + start_time += 0,15; + } + a_nixie_tube[ 1 ] showpart( "J_" + level.a_nixie_tube_code[ 1 ] ); + a_nixie_tube[ 2 ] showpart( "J_" + level.a_nixie_tube_code[ 2 ] ); + a_nixie_tube[ 3 ] showpart( "J_" + level.a_nixie_tube_code[ 3 ] ); + while ( level.a_nixie_tube_code[ 1 ] != goal_num_1 || level.a_nixie_tube_code[ 2 ] != goal_num_2 && level.a_nixie_tube_code[ 3 ] != goal_num_3 ) + { + n_current_tube = 1; + n_goal = goal_num_1; + if ( level.a_nixie_tube_code[ n_current_tube ] == goal_num_1 ) + { + n_current_tube = 2; + n_goal = goal_num_2; + if ( level.a_nixie_tube_code[ n_current_tube ] == goal_num_2 ) + { + n_current_tube = 3; + n_goal = goal_num_3; + } + } + j = 0; + while ( j < 10 ) + { + a_nixie_tube[ n_current_tube ] hidepart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + level.a_nixie_tube_code[ n_current_tube ]--; + + if ( level.a_nixie_tube_code[ n_current_tube ] == -1 ) + { + level.a_nixie_tube_code[ n_current_tube ] = 9; + } + a_nixie_tube[ n_current_tube ] showpart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + if ( ( j % 3 ) == 0 ) + { + a_nixie_tube[ n_current_tube ] playsound( "zmb_quest_nixie_count" ); + } + wait 0,05; + j++; + } + wait_network_frame(); + j = 0; + while ( level.a_nixie_tube_code[ n_current_tube ] != n_goal ) + { + a_nixie_tube[ n_current_tube ] hidepart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + level.a_nixie_tube_code[ n_current_tube ]--; + + if ( level.a_nixie_tube_code[ n_current_tube ] == -1 ) + { + level.a_nixie_tube_code[ n_current_tube ] = 9; + } + a_nixie_tube[ n_current_tube ] showpart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + if ( ( j % 3 ) == 0 ) + { + a_nixie_tube[ n_current_tube ] playsound( "zmb_quest_nixie_count" ); + } + j++; + wait 0,05; + } + } + a_nixie_tube[ 2 ] playsound( "zmb_quest_nixie_count_final" ); + wait_network_frame(); +} + +nixie_tube_thread_play_countdown( n_tube_index, n_countdown ) +{ + level endon( "end_nixie_countdown" ); + n_tick_duration = 1; + level.a_nixie_tube_code[ n_tube_index ] = get_split_number( n_tube_index, n_countdown ); +/# + iprintlnbold( "tube " + n_tube_index + " number is " + level.a_nixie_tube_code[ n_tube_index ] ); +#/ + i = 0; + while ( i < 10 ) + { + self hidepart( "J_" + i ); + i++; + } + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + while ( n_countdown ) + { + n_countdown--; + + self hidepart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + level.a_nixie_tube_code[ n_tube_index ] = get_split_number( n_tube_index, n_countdown ); + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait n_tick_duration; + } + flag_set( "nixie_countdown_expired" ); + wait 0,05; + flag_clear( "nixie_countdown_expired" ); +} + +get_split_number( n_tube_index, n_countdown ) +{ + if ( n_tube_index == 1 ) + { + return ( n_countdown - ( n_countdown % 100 ) ) / 100; + } + if ( n_tube_index == 2 ) + { + n_temp = n_countdown % 100; + n_temp -= n_countdown % 10; + n_temp /= 10; + return n_temp; + } + if ( n_tube_index == 3 ) + { + return n_countdown % 10; + } +} + +nixie_tube_elevator_drops() +{ + n_elevator_drop_duration = 3; + maps/mp/zm_alcatraz_sq::array_set_visible_to_all( getentarray( "generator_wires", "script_noteworthy" ), 0 ); + exploder( 3400 ); + exploder( 3500 ); + exploder( 3600 ); + m_citadel_elevator = getent( "citadel_elevator", "targetname" ); + a_m_script_models = []; + a_m_script_models = getentarray( "script_model", "classname" ); + i = 0; + while ( i < a_m_script_models.size ) + { + if ( a_m_script_models[ i ].model == "veh_t6_dlc_zombie_part_rigging" ) + { + playfxontag( level._effect[ "elevator_fall" ], a_m_script_models[ i ], "tag_origin" ); + } + i++; + } + m_citadel_elevator playsound( "zmb_quest_elevator_move" ); + m_citadel_elevator moveto( m_citadel_elevator.origin + vectorScale( ( 0, 0, 0 ), 768 ), n_elevator_drop_duration, 1, 1 ); + wait n_elevator_drop_duration; + t_elevator_door = getent( "nixie_elevator_door", "targetname" ); + t_elevator_door trigger_on(); +} + +nixie_tube_elevator_rises() +{ + elevator_rise_duration = 3; + maps/mp/zm_alcatraz_sq::array_set_visible_to_all( getentarray( "generator_wires", "script_noteworthy" ), 1 ); + stop_exploder( 3400 ); + stop_exploder( 3500 ); + stop_exploder( 3600 ); + m_citadel_elevator = getent( "citadel_elevator", "targetname" ); + m_citadel_elevator moveto( m_citadel_elevator.origin + vectorScale( ( 0, 0, 0 ), 768 ), elevator_rise_duration, 1, 1 ); + m_citadel_elevator playsound( "zmb_quest_elevator_move" ); + wait elevator_rise_duration; +} + +nixie_tube_elevator_door() +{ + t_elevator_door = getent( "nixie_elevator_door", "targetname" ); + t_elevator_door sethintstring( &"ZM_PRISON_KEY_DOOR" ); + t_elevator_door waittill( "trigger", e_triggerer ); + m_elevator_bottom_gate_l = getent( "elevator_bottom_gate_l", "targetname" ); + m_elevator_bottom_gate_r = getent( "elevator_bottom_gate_r", "targetname" ); + m_elevator_bottom_gate_l rotateyaw( -90, 0,5 ); + m_elevator_bottom_gate_r rotateyaw( 90, 0,5 ); + elevator_door_playerclip = getent( "elevator_door_playerclip", "targetname" ); + elevator_door_playerclip delete(); + flag_set( "nixie_puzzle_completed" ); + level notify( "sndEndNixieCount" ); + level notify( "end_nixie_countdown" ); + flag_set( "nixie_countdown_expired" ); + wait 0,05; + flag_clear( "nixie_countdown_expired" ); + t_elevator_door delete(); +} + +nixie_tube_win_effects_ee( n_tube_index ) +{ + n_blink_rate = 0,25; + while ( !flag( "nixie_ee_flashing" ) ) + { + self hidepart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait n_blink_rate; + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); + wait n_blink_rate; + } + self showpart( "J_" + level.a_nixie_tube_code[ n_tube_index ] ); +} + +nixie_115() +{ + level waittill( "nixie_" + 115 ); + level notify( "kill_nixie_input" ); + flag_set( "nixie_puzzle_solved" ); + flag_clear( "nixie_ee_flashing" ); + level thread nixie_115_audio(); + nixie_tube_win_effects_all_tubes( 6, 6, 6 ); + flag_set( "nixie_ee_flashing" ); + flag_clear( "nixie_puzzle_solved" ); + nixie_reset_control(); +} + +nixie_115_audio() +{ + m_nixie_tube = getent( "nixie_tube_1", "targetname" ); + n_random_line = randomint( 3 ); + m_nixie_tube playsoundwithnotify( "vox_brutus_scary_voice_" + n_random_line, "scary_voice" ); + m_nixie_tube waittill( "scary_voice" ); +} + +nixie_935() +{ + level waittill( "nixie_" + 935 ); + level notify( "kill_nixie_input" ); + flag_set( "nixie_puzzle_solved" ); + flag_clear( "nixie_ee_flashing" ); + level thread nixie_935_audio(); + nixie_tube_win_effects_all_tubes( 7, 7, 7 ); + flag_set( "nixie_ee_flashing" ); + flag_clear( "nixie_puzzle_solved" ); + nixie_reset_control(); +} + +nixie_935_audio() +{ + if ( isDefined( level.music_override ) && !level.music_override ) + { + level.music_override = 1; + playsoundatposition( "mus_zmb_secret_song_2", ( 0, 0, 0 ) ); + wait 140; + level.music_override = 0; + } + else + { + m_nixie_tube = getent( "nixie_tube_1", "targetname" ); + n_random_line = randomint( 3 ); + m_nixie_tube playsoundwithnotify( "vox_brutus_scary_voice_" + n_random_line, "scary_voice" ); + m_nixie_tube waittill( "scary_voice" ); + } +} + +nixie_reset_control( b_reset_control ) +{ + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + m_nixie_tube thread afterlife_interact_object_think(); + m_nixie_tube thread nixie_tube_thread( i, b_reset_control ); + i++; + } +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_sq_vo.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_sq_vo.gsc new file mode 100644 index 0000000..2efef5b --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_sq_vo.gsc @@ -0,0 +1,733 @@ +#include maps/mp/gametypes_zm/_hud; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_sidequests; +#include maps/mp/zombies/_zm_craftables; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/zombies/_zm_afterlife; +#include maps/_vehicle; +#include maps/_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +vo_see_map_trigger() +{ + level endon( "someone_completed_quest_cycle" ); + e_triggerer = undefined; + t_map_vo_trigger = getent( "map_vo_trigger", "targetname" ); + b_has_line_played = 0; + while ( !b_has_line_played ) + { + t_map_vo_trigger waittill( "trigger", e_triggerer ); + players = getplayers(); + if ( !e_triggerer.dontspeak && !flag( "story_vo_playing" ) ) + { + flag_set( "story_vo_playing" ); + e_triggerer do_player_general_vox( "quest", "find_map", undefined, 100 ); + wait 5; + arrayremovevalue( players, e_triggerer ); + closest_other_player = getclosest( e_triggerer.origin, players ); + if ( isDefined( closest_other_player ) ) + { + closest_other_player do_player_general_vox( "quest", "response_map", undefined, 100 ); + } + b_has_line_played = 1; + wait 5; + flag_clear( "story_vo_playing" ); + } + } +} + +opening_vo() +{ + load_vo_alias_arrays(); + flag_wait( "afterlife_start_over" ); + wait 1; + players = getplayers(); + vo_play_four_part_conversation( level.four_part_convos[ "start_1_oh_shit_" + randomintrange( 1, 3 ) ] ); + wait 1; + if ( players.size == 1 ) + { + players[ 0 ] vo_play_soliloquy( level.soliloquy_convos[ "solo_intro_" + players[ 0 ].character_name ] ); + } + else + { + if ( is_player_character_present( "Arlington" ) ) + { + vo_play_four_part_conversation( level.four_part_convos[ "intro_plr_3" ] ); + } + } + level thread vo_see_map_trigger(); + wait 10; + vo_play_four_part_conversation( level.four_part_convos[ "during_1_oh_shit" ] ); + level waittill( "end_of_round" ); + wait 5; + vo_play_four_part_conversation( level.four_part_convos[ "start_2_oh_shit_" + randomintrange( 1, 3 ) ] ); + wait 4; + vo_play_four_part_conversation( level.four_part_convos[ "start_3_oh_shit" ] ); + level waittill( "end_of_round" ); + wait 3; + if ( ( get_players_touching( "zone_library" ) + get_players_touching( "zone_start" ) ) == 4 ) + { + vo_play_four_part_conversation( level.four_part_convos[ "start_2_oh_shit" ] ); + } + wait 1; +} + +load_vo_alias_arrays() +{ + level.four_part_convos = []; + level.four_part_convos[ "intro_plr_1" ] = []; + level.four_part_convos[ "intro_plr_1" ][ 0 ] = "vox_plr_1_start_1_oh_shit1_0"; + level.four_part_convos[ "intro_plr_3" ] = []; + level.four_part_convos[ "intro_plr_3" ][ 0 ] = "vox_plr_3_chair2_var6_0"; + level.four_part_convos[ "intro_plr_3" ][ 1 ] = "vox_plr_3_chair2_var7_0"; + level.four_part_convos[ "intro_plr_3" ][ 2 ] = "vox_plr_3_chair2_var8_0"; + level.four_part_convos[ "start_1_oh_shit_1" ] = []; + level.four_part_convos[ "start_1_oh_shit_1" ][ 0 ] = "vox_plr_1_start_1_oh_shit4_0"; + level.four_part_convos[ "start_1_oh_shit_1" ][ 1 ] = "vox_plr_2_start_1_oh_shit5_0"; + level.four_part_convos[ "start_1_oh_shit_1" ][ 2 ] = "vox_plr_0_start_1_oh_shit6_0"; + level.four_part_convos[ "start_1_oh_shit_1" ][ 3 ] = "vox_plr_3_start_1_oh_shit7_0"; + level.four_part_convos[ "start_1_oh_shit_2" ] = []; + level.four_part_convos[ "start_1_oh_shit_2" ][ 0 ] = "vox_plr_3_start_1_oh_shit8_0"; + level.four_part_convos[ "start_1_oh_shit_2" ][ 1 ] = "vox_plr_2_start_1_oh_shit9_0"; + level.four_part_convos[ "start_1_oh_shit_2" ][ 2 ] = "vox_plr_1_start_1_oh_shit10_0"; + level.four_part_convos[ "start_1_oh_shit_2" ][ 3 ] = "vox_plr_0_start_1_oh_shit11_0"; + level.four_part_convos[ "during_1_oh_shit" ] = []; + level.four_part_convos[ "during_1_oh_shit" ][ 0 ] = "vox_plr_0_during_1_oh_shit5_0"; + level.four_part_convos[ "during_1_oh_shit" ][ 1 ] = "vox_plr_3_during_1_oh_shit6_0"; + level.four_part_convos[ "during_1_oh_shit" ][ 2 ] = "vox_plr_1_during_1_oh_shit7_0"; + level.four_part_convos[ "during_1_oh_shit" ][ 3 ] = "vox_plr_2_during_1_oh_shit8_0"; + level.four_part_convos[ "start_2_oh_shit_1" ] = []; + level.four_part_convos[ "start_2_oh_shit_1" ][ 0 ] = "vox_plr_3_start_2_oh_shit12_0"; + level.four_part_convos[ "start_2_oh_shit_1" ][ 1 ] = "vox_plr_0_start_2_oh_shit13_0"; + level.four_part_convos[ "start_2_oh_shit_1" ][ 2 ] = "vox_plr_2_start_2_oh_shit14_0"; + level.four_part_convos[ "start_2_oh_shit_1" ][ 3 ] = "vox_plr_1_start_2_oh_shit15_0"; + level.four_part_convos[ "start_2_oh_shit_2" ] = []; + level.four_part_convos[ "start_2_oh_shit_2" ][ 0 ] = "vox_plr_0_start_2_oh_shit16_0"; + level.four_part_convos[ "start_2_oh_shit_2" ][ 1 ] = "vox_plr_2_start_2_oh_shit17_0"; + level.four_part_convos[ "start_2_oh_shit_2" ][ 2 ] = "vox_plr_3_start_2_oh_shit18_0"; + level.four_part_convos[ "start_2_oh_shit_2" ][ 3 ] = "vox_plr_1_start_2_oh_shit19_0"; + level.four_part_convos[ "start_3_oh_shit" ] = []; + level.four_part_convos[ "start_3_oh_shit" ][ 0 ] = "vox_plr_3_start_3_oh_shit13_0"; + level.four_part_convos[ "start_3_oh_shit" ][ 1 ] = "vox_plr_2_start_3_oh_shit14_0"; + level.four_part_convos[ "start_3_oh_shit" ][ 2 ] = "vox_plr_1_start_3_oh_shit15_0"; + level.four_part_convos[ "start_3_oh_shit" ][ 3 ] = "vox_plr_0_start_3_oh_shit16_0"; + level.four_part_convos[ "start_2_oh_shit" ] = []; + level.four_part_convos[ "start_2_oh_shit" ][ 0 ] = "vox_plr_1_start_2_oh_shit9_0"; + level.four_part_convos[ "start_2_oh_shit" ][ 1 ] = "vox_plr_0_start_2_oh_shit10_0"; + level.four_part_convos[ "start_2_oh_shit" ][ 2 ] = "vox_plr_1_start_2_oh_shit11_0"; + level.four_part_convos[ "start_2_oh_shit" ][ 3 ] = "vox_plr_2_start_2_oh_shit12_0"; + level.four_part_convos[ "chair1" ] = []; + level.four_part_convos[ "chair1" ][ 0 ] = "vox_plr_1_chair1_var1_0"; + level.four_part_convos[ "chair1" ][ 1 ] = "vox_plr_2_chair1_var2_0"; + level.four_part_convos[ "chair1" ][ 2 ] = "vox_plr_3_chair1_var3_0"; + level.four_part_convos[ "chair1" ][ 3 ] = "vox_plr_1_chair1_var4_0"; + level.four_part_convos[ "chair1" ][ 4 ] = "vox_plr_3_chair1_var5_0"; + level.four_part_convos[ "chair2" ] = []; + level.four_part_convos[ "chair2" ][ 0 ] = "vox_plr_2_chair2_var1_0"; + level.four_part_convos[ "chair2" ][ 1 ] = "vox_plr_3_chair2_var2_0"; + level.four_part_convos[ "chair2" ][ 1 ] = "vox_plr_0_chair2_var3_0"; + level.four_part_convos[ "chair2" ][ 2 ] = "vox_plr_3_chair2_var5_0"; + level.four_part_convos[ "chair2" ][ 3 ] = "vox_plr_1_chair2_var4_0"; + level.four_part_convos[ "chair_combat_1" ] = []; + level.four_part_convos[ "chair_combat_1" ][ 0 ] = "vox_plr_3_chair3_var_3_0"; + level.four_part_convos[ "chair_combat_1" ][ 1 ] = "vox_plr_1_chair3_var_3_0"; + level.four_part_convos[ "chair_combat_1" ][ 2 ] = "vox_plr_2_chair3_var_3_0"; + level.four_part_convos[ "chair_combat_1" ][ 3 ] = "vox_plr_0_chair3_var_3_0"; + level.four_part_convos[ "chair_combat_2" ] = []; + level.four_part_convos[ "chair_combat_2" ][ 0 ] = "vox_plr_0_chair4_var_4_0"; + level.four_part_convos[ "chair_combat_2" ][ 1 ] = "vox_plr_3_chair4_var_4_0"; + level.four_part_convos[ "chair_combat_2" ][ 2 ] = "vox_plr_2_chair4_var_4_0"; + level.four_part_convos[ "chair_combat_2" ][ 3 ] = "vox_plr_1_chair4_var_4_0"; + level.four_part_convos[ "chair_combat_2" ][ 4 ] = "vox_plr_3_chair4_var_4_1"; + level.four_part_convos[ "bridge_visit1_alt1" ] = []; + level.four_part_convos[ "bridge_visit1_alt1" ][ 0 ] = "vox_plr_3_bridge_var1_1_0"; + level.four_part_convos[ "bridge_visit1_alt1" ][ 1 ] = "vox_plr_2_bridge_var1_2_0"; + level.four_part_convos[ "bridge_visit1_alt1" ][ 2 ] = "vox_plr_0_bridge_var1_3_0"; + level.four_part_convos[ "bridge_visit1_alt1" ][ 3 ] = "vox_plr_1_bridge_var1_4_0"; + level.four_part_convos[ "bridge_visit1_alt2" ] = []; + level.four_part_convos[ "bridge_visit1_alt2" ][ 0 ] = "vox_plr_1_bridge_var2_1_0"; + level.four_part_convos[ "bridge_visit1_alt2" ][ 1 ] = "vox_plr_0_bridge_var2_2_0"; + level.four_part_convos[ "bridge_visit1_alt2" ][ 2 ] = "vox_plr_1_bridge_var2_3_0"; + level.four_part_convos[ "bridge_visit1_alt2" ][ 3 ] = "vox_plr_2_bridge_var2_4_0"; + level.four_part_convos[ "bridge_visit1_alt2" ][ 4 ] = "vox_plr_3_bridge_var2_5_0"; + level.four_part_convos[ "bridge_visit1_alt3" ] = []; + level.four_part_convos[ "bridge_visit1_alt3" ][ 0 ] = "vox_plr_0_bridge_var2_6_0"; + level.four_part_convos[ "bridge_visit1_alt3" ][ 1 ] = "vox_plr_2_bridge_var2_7_0"; + level.four_part_convos[ "bridge_visit1_alt3" ][ 2 ] = "vox_plr_3_bridge_var2_8_0"; + level.four_part_convos[ "bridge_visit1_alt3" ][ 3 ] = "vox_plr_1_bridge_var2_9_0"; + level.four_part_convos[ "bridge_visit1_alt4" ] = []; + level.four_part_convos[ "bridge_visit1_alt4" ][ 0 ] = "vox_plr_1_bridge_var2_10_0"; + level.four_part_convos[ "bridge_visit1_alt4" ][ 1 ] = "vox_plr_2_bridge_var2_11_0"; + level.four_part_convos[ "bridge_visit1_alt4" ][ 2 ] = "vox_plr_0_bridge_var2_12_0"; + level.four_part_convos[ "bridge_visit1_alt4" ][ 3 ] = "vox_plr_3_bridge_var2_13_0"; + level.four_part_convos[ "bridge_visit2_alt1" ] = []; + level.four_part_convos[ "bridge_visit2_alt1" ][ 0 ] = "vox_plr_0_bridge_var5_1_0"; + level.four_part_convos[ "bridge_visit2_alt1" ][ 1 ] = "vox_plr_3_bridge_var5_2_0"; + level.four_part_convos[ "bridge_visit2_alt1" ][ 2 ] = "vox_plr_0_bridge_var5_3_0"; + level.four_part_convos[ "bridge_visit2_alt1" ][ 3 ] = "vox_plr_3_bridge_var6_1_0"; + level.four_part_convos[ "bridge_visit2_alt1" ][ 4 ] = "vox_plr_2_bridge_var5_5_0"; + level.four_part_convos[ "bridge_visit2_alt1" ][ 5 ] = "vox_plr_3_bridge_var5_4_0"; + level.four_part_convos[ "bridge_visit2_alt2" ] = []; + level.four_part_convos[ "bridge_visit2_alt2" ][ 0 ] = "vox_plr_3_bridge_var6_3_0"; + level.four_part_convos[ "bridge_visit2_alt2" ][ 1 ] = "vox_plr_1_bridge_var6_4_0"; + level.four_part_convos[ "bridge_visit2_alt2" ][ 2 ] = "vox_plr_3_bridge_var6_5_0"; + level.four_part_convos[ "bridge_visit2_alt2" ][ 3 ] = "vox_plr_2_bridge_var6_2_0"; + level.four_part_convos[ "bridge_visit2_alt2" ][ 4 ] = "vox_plr_3_bridge_var6_6_0"; + level.four_part_convos[ "bridge_visit2_alt2" ][ 5 ] = "vox_plr_0_bridge_var6_7_0"; + level.four_part_convos[ "bridge_visit2_alt3" ] = []; + level.four_part_convos[ "bridge_visit2_alt3" ][ 0 ] = "vox_plr_3_bridge_var6_8_0"; + level.four_part_convos[ "bridge_visit2_alt3" ][ 1 ] = "vox_plr_2_bridge_var6_9_0"; + level.four_part_convos[ "bridge_visit2_alt3" ][ 2 ] = "vox_plr_3_bridge_var6_10_0"; + level.four_part_convos[ "bridge_visit2_alt3" ][ 3 ] = "vox_plr_2_bridge_var6_11_0"; + level.four_part_convos[ "bridge_visit2_alt3" ][ 3 ] = "vox_plr_3_bridge_var6_12_0"; + level.four_part_convos[ "bridge_visit2_alt4" ] = []; + level.four_part_convos[ "bridge_visit2_alt4" ][ 0 ] = "vox_plr_0_bridge_var6_13_0"; + level.four_part_convos[ "bridge_visit2_alt4" ][ 1 ] = "vox_plr_2_bridge_var6_14_0"; + level.four_part_convos[ "bridge_visit2_alt4" ][ 2 ] = "vox_plr_1_bridge_var6_15_0"; + level.four_part_convos[ "bridge_visit2_alt4" ][ 3 ] = "vox_plr_3_bridge_var6_16_0"; + level.four_part_convos[ "alcatraz_return_alt1" ] = []; + level.four_part_convos[ "alcatraz_return_alt1" ][ 0 ] = "vox_plr_0_start_2_4_player_0"; + level.four_part_convos[ "alcatraz_return_alt1" ][ 1 ] = "vox_plr_3_start_2_4_player_0"; + level.four_part_convos[ "alcatraz_return_alt1" ][ 2 ] = "vox_plr_2_start_2_4_player_0"; + level.four_part_convos[ "alcatraz_return_alt1" ][ 3 ] = "vox_plr_1_start_2_4_player_0"; + level.four_part_convos[ "alcatraz_return_alt2" ] = []; + level.four_part_convos[ "alcatraz_return_alt2" ][ 0 ] = "vox_plr_2_start_2_4_player_1"; + level.four_part_convos[ "alcatraz_return_alt2" ][ 1 ] = "vox_plr_3_start_2_4_player_1"; + level.four_part_convos[ "alcatraz_return_alt2" ][ 2 ] = "vox_plr_0_start_2_4_player_1"; + level.four_part_convos[ "alcatraz_return_alt2" ][ 3 ] = "vox_plr_1_start_2_4_player_1"; + level.four_part_convos[ "alcatraz_return_quest_reset" ] = []; + level.four_part_convos[ "alcatraz_return_quest_reset" ][ 0 ] = "vox_plr_3_start_2_2_3_players_0"; + level.four_part_convos[ "alcatraz_return_quest_reset" ][ 1 ] = "vox_plr_1_start_2_2_3_players_0"; + level.four_part_convos[ "alcatraz_return_quest_reset" ][ 2 ] = "vox_plr_2_start_2_2_3_players_0"; + level.four_part_convos[ "alcatraz_return_quest_reset" ][ 3 ] = "vox_plr_0_start_2_2_3_players_0"; + level.soliloquy_convos[ "solo_intro_Billy" ] = []; + level.soliloquy_convos[ "solo_intro_Billy" ][ 0 ] = "vox_plr_2_start_1_billy_0"; + level.soliloquy_convos[ "solo_intro_Billy" ][ 1 ] = "vox_plr_2_start_1_billy_1"; + level.soliloquy_convos[ "solo_intro_Billy" ][ 2 ] = "vox_plr_2_start_1_billy_2"; + level.soliloquy_convos[ "solo_intro_Sal" ] = []; + level.soliloquy_convos[ "solo_intro_Sal" ][ 0 ] = "vox_plr_1_start_1_sal_0"; + level.soliloquy_convos[ "solo_intro_Sal" ][ 1 ] = "vox_plr_1_start_1_sal_1"; + level.soliloquy_convos[ "solo_intro_Sal" ][ 2 ] = "vox_plr_1_start_1_sal_2"; + level.soliloquy_convos[ "solo_intro_Finn" ] = []; + level.soliloquy_convos[ "solo_intro_Finn" ][ 0 ] = "vox_plr_0_start_1_finn_0"; + level.soliloquy_convos[ "solo_intro_Finn" ][ 1 ] = "vox_plr_0_start_1_finn_1"; + level.soliloquy_convos[ "solo_intro_Finn" ][ 2 ] = "vox_plr_0_start_1_finn_2"; + level.soliloquy_convos[ "solo_intro_Arlington" ] = []; + level.soliloquy_convos[ "solo_intro_Arlington" ][ 0 ] = "vox_plr_3_start_1_arlington_0"; + level.soliloquy_convos[ "solo_intro_Arlington" ][ 1 ] = "vox_plr_3_start_1_arlington_1"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ][ 0 ] = "vox_plr_1_purgatory_sal_var1_0"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ][ 1 ] = "vox_plr_1_purgatory_sal_var1_1"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ][ 2 ] = "vox_plr_1_purgatory_sal_var1_2"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ][ 3 ] = "vox_plr_1_purgatory_sal_var1_3"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt1" ][ 4 ] = "vox_plr_1_purgatory_sal_var1_4"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt2" ][ 0 ] = "vox_plr_1_purgatory_sal_var2_0"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt2" ][ 1 ] = "vox_plr_1_purgatory_sal_var2_1"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt2" ][ 2 ] = "vox_plr_1_purgatory_sal_var2_2"; + level.soliloquy_convos[ "purgatory_Sal_visit1_alt2" ][ 3 ] = "vox_plr_1_purgatory_sal_var2_3"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ][ 0 ] = "vox_plr_1_purgatory_sal_var3_0"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ][ 1 ] = "vox_plr_1_purgatory_sal_var3_1"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ][ 2 ] = "vox_plr_1_purgatory_sal_var3_2"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ][ 3 ] = "vox_plr_1_purgatory_sal_var3_3"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt1" ][ 4 ] = "vox_plr_1_purgatory_sal_var3_4"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ][ 0 ] = "vox_plr_1_purgatory_sal_var4_0"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ][ 1 ] = "vox_plr_1_purgatory_sal_var4_1"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ][ 2 ] = "vox_plr_1_purgatory_sal_var4_3"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ][ 3 ] = "vox_plr_1_purgatory_sal_var4_4"; + level.soliloquy_convos[ "purgatory_Sal_visit2_alt2" ][ 4 ] = "vox_plr_1_purgatory_sal_var4_5"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt1" ][ 0 ] = "vox_plr_2_purgatory_billy_var1_0"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt1" ][ 1 ] = "vox_plr_2_purgatory_billy_var1_1"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt1" ][ 2 ] = "vox_plr_2_purgatory_billy_var1_2"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt2" ][ 0 ] = "vox_plr_2_purgatory_billy_var2_0"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt2" ][ 1 ] = "vox_plr_2_purgatory_billy_var2_1"; + level.soliloquy_convos[ "purgatory_Billy_visit1_alt2" ][ 2 ] = "vox_plr_2_purgatory_billy_var2_2"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt1" ][ 0 ] = "vox_plr_2_purgatory_billy_var3_0"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt1" ][ 1 ] = "vox_plr_2_purgatory_billy_var3_1"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt1" ][ 2 ] = "vox_plr_2_purgatory_billy_var3_2"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt1" ][ 3 ] = "vox_plr_2_purgatory_billy_var3_3"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt2" ][ 0 ] = "vox_plr_2_purgatory_billy_var4_0"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt2" ][ 1 ] = "vox_plr_2_purgatory_billy_var4_1"; + level.soliloquy_convos[ "purgatory_Billy_visit2_alt2" ][ 2 ] = "vox_plr_2_purgatory_billy_var4_2"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt1" ][ 0 ] = "vox_plr_0_purgatory_finn_var1_0"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt1" ][ 1 ] = "vox_plr_0_purgatory_finn_var1_1"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt1" ][ 2 ] = "vox_plr_0_purgatory_finn_var1_2"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt1" ][ 3 ] = "vox_plr_0_purgatory_finn_var1_3"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt2" ][ 0 ] = "vox_plr_0_purgatory_finn_var2_0"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt2" ][ 1 ] = "vox_plr_0_purgatory_finn_var2_1"; + level.soliloquy_convos[ "purgatory_Finn_visit1_alt2" ][ 2 ] = "vox_plr_0_purgatory_finn_var2_2"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt1" ][ 0 ] = "vox_plr_0_purgatory_finn_var3_0"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt1" ][ 1 ] = "vox_plr_0_purgatory_finn_var3_1"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt1" ][ 2 ] = "vox_plr_0_purgatory_finn_var3_2"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt2" ][ 0 ] = "vox_plr_0_purgatory_finn_var4_0"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt2" ][ 1 ] = "vox_plr_0_purgatory_finn_var4_1"; + level.soliloquy_convos[ "purgatory_Finn_visit2_alt2" ][ 2 ] = "vox_plr_0_purgatory_finn_var4_2"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt1" ][ 0 ] = "vox_plr_3_purgatory_arlington_var1_0"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt1" ][ 1 ] = "vox_plr_3_purgatory_arlington_var1_1"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt1" ][ 2 ] = "vox_plr_3_purgatory_arlington_var1_2"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt2" ][ 0 ] = "vox_plr_3_purgatory_arlington_var2_0"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt2" ][ 1 ] = "vox_plr_3_purgatory_arlington_var2_1"; + level.soliloquy_convos[ "purgatory_Arlington_visit1_alt2" ][ 2 ] = "vox_plr_3_purgatory_arlington_var2_2"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt1" ] = []; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt1" ][ 0 ] = "vox_plr_3_purgatory_arlington_var3_0"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt1" ][ 1 ] = "vox_plr_3_purgatory_arlington_var3_1"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt1" ][ 2 ] = "vox_plr_3_purgatory_arlington_var3_2"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt2" ] = []; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt2" ][ 0 ] = "vox_plr_3_purgatory_arlington_var4_0"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt2" ][ 1 ] = "vox_plr_3_purgatory_arlington_var4_1"; + level.soliloquy_convos[ "purgatory_Arlington_visit2_alt2" ][ 2 ] = "vox_plr_3_purgatory_arlington_var4_2"; + level.soliloquy_convos[ "electric_chair_Finn" ] = []; + level.soliloquy_convos[ "electric_chair_Finn" ][ 0 ] = "vox_plr_0_chair4_var_4_0"; + level.soliloquy_convos[ "electric_chair_Sal" ] = []; + level.soliloquy_convos[ "electric_chair_Sal" ][ 0 ] = "vox_plr_1_chair1_var1_0"; + level.soliloquy_convos[ "electric_chair_Billy" ] = []; + level.soliloquy_convos[ "electric_chair_Billy" ][ 0 ] = "vox_plr_2_chair1_var2_0"; + level.soliloquy_convos[ "electric_chair_Arlington" ] = []; + level.soliloquy_convos[ "electric_chair_Arlington" ][ 0 ] = "vox_plr_3_chair3_var_3_0"; +} + +vo_bridge_soliloquy() +{ + if ( level.n_quest_iteration_count < 3 ) + { + convo = level.soliloquy_convos[ "purgatory_" + self.character_name + "_visit" + level.n_quest_iteration_count + "_alt" + randomintrange( 1, 3 ) ]; + if ( isDefined( convo ) ) + { + self vo_play_soliloquy( convo ); + } + } +} + +vo_bridge_four_part_convo() +{ + if ( level.n_quest_iteration_count < 3 ) + { + convo = level.four_part_convos[ "bridge_visit" + level.n_quest_iteration_count + "_alt" + randomintrange( 1, 5 ) ]; + if ( isDefined( convo ) ) + { + vo_play_four_part_conversation( convo ); + } + } +} + +vo_play_soliloquy( convo ) +{ + self endon( "disconnect" ); + if ( !isDefined( convo ) ) + { + return; + } + if ( !flag( "story_vo_playing" ) ) + { + flag_set( "story_vo_playing" ); + self thread vo_play_soliloquy_disconnect_listener(); + self.dontspeak = 1; + self setclientfieldtoplayer( "isspeaking", 1 ); + i = 0; + while ( i < convo.size ) + { + if ( isDefined( self.afterlife ) && self.afterlife ) + { + self.dontspeak = 0; + self setclientfieldtoplayer( "isspeaking", 0 ); + flag_clear( "story_vo_playing" ); + self notify( "soliloquy_vo_done" ); + return; + } + else + { + self playsoundwithnotify( convo[ i ], "sound_done" + convo[ i ] ); + self waittill( "sound_done" + convo[ i ] ); + } + wait 1; + i++; + } + self.dontspeak = 0; + self setclientfieldtoplayer( "isspeaking", 0 ); + flag_clear( "story_vo_playing" ); + self notify( "soliloquy_vo_done" ); + } +} + +vo_play_soliloquy_disconnect_listener() +{ + self endon( "soliloquy_vo_done" ); + self waittill( "disconnect" ); + flag_clear( "story_vo_playing" ); +} + +vo_play_four_part_conversation( convo ) +{ + if ( !isDefined( convo ) ) + { + return; + } + players = getplayers(); + if ( players.size == 4 && !flag( "story_vo_playing" ) ) + { + flag_set( "story_vo_playing" ); + old_speaking_player = undefined; + speaking_player = undefined; + n_dist = 0; + n_max_reply_dist = 1500; + e_arlington = undefined; + e_sal = undefined; + e_billy = undefined; + e_finn = undefined; + _a513 = players; + _k513 = getFirstArrayKey( _a513 ); + while ( isDefined( _k513 ) ) + { + player = _a513[ _k513 ]; + if ( isDefined( player ) ) + { + switch( player.character_name ) + { + case "Arlington": + e_arlington = player; + break; + break; + case "Sal": + e_sal = player; + break; + break; + case "Billy": + e_billy = player; + break; + break; + case "Finn": + e_finn = player; + break; + break; + } + } + _k513 = getNextArrayKey( _a513, _k513 ); + } + if ( isDefined( e_arlington ) && isDefined( e_sal ) || !isDefined( e_billy ) && !isDefined( e_finn ) ) + { + return; + } + else _a542 = players; + _k542 = getFirstArrayKey( _a542 ); + while ( isDefined( _k542 ) ) + { + player = _a542[ _k542 ]; + if ( isDefined( player ) ) + { + player.dontspeak = 1; + player setclientfieldtoplayer( "isspeaking", 1 ); + } + _k542 = getNextArrayKey( _a542, _k542 ); + } + i = 0; + while ( i < convo.size ) + { + players = getplayers(); + if ( players.size != 4 ) + { + _a557 = players; + _k557 = getFirstArrayKey( _a557 ); + while ( isDefined( _k557 ) ) + { + player = _a557[ _k557 ]; + if ( isDefined( player ) ) + { + player.dontspeak = 0; + player setclientfieldtoplayer( "isspeaking", 0 ); + } + _k557 = getNextArrayKey( _a557, _k557 ); + } + flag_clear( "story_vo_playing" ); + return; + } + if ( issubstr( convo[ i ], "plr_0" ) ) + { + speaking_player = e_finn; + } + else if ( issubstr( convo[ i ], "plr_1" ) ) + { + speaking_player = e_sal; + } + else if ( issubstr( convo[ i ], "plr_2" ) ) + { + speaking_player = e_billy; + } + else + { + if ( issubstr( convo[ i ], "plr_3" ) ) + { + speaking_player = e_arlington; + } + } + if ( isDefined( old_speaking_player ) ) + { + n_dist = distance( old_speaking_player.origin, speaking_player.origin ); + } + if ( speaking_player.afterlife || n_dist > n_max_reply_dist ) + { + _a593 = players; + _k593 = getFirstArrayKey( _a593 ); + while ( isDefined( _k593 ) ) + { + player = _a593[ _k593 ]; + if ( isDefined( player ) ) + { + player.dontspeak = 0; + player setclientfieldtoplayer( "isspeaking", 0 ); + } + _k593 = getNextArrayKey( _a593, _k593 ); + } + flag_clear( "story_vo_playing" ); + return; + } + else + { + speaking_player playsoundwithnotify( convo[ i ], "sound_done" + convo[ i ] ); + speaking_player waittill( "sound_done" + convo[ i ] ); + old_speaking_player = speaking_player; + } + wait 1; + i++; + } + _a613 = players; + _k613 = getFirstArrayKey( _a613 ); + while ( isDefined( _k613 ) ) + { + player = _a613[ _k613 ]; + if ( isDefined( player ) ) + { + player.dontspeak = 0; + player setclientfieldtoplayer( "isspeaking", 0 ); + } + _k613 = getNextArrayKey( _a613, _k613 ); + } + flag_clear( "story_vo_playing" ); + } +} + +electric_chair_vo() +{ + if ( level.n_quest_iteration_count == 1 ) + { + e_nml_zone = getent( "zone_golden_gate_bridge", "targetname" ); + n_players_on_bridge_count = get_players_touching( "zone_golden_gate_bridge" ); + players = getplayers(); + if ( players.size == 4 && n_players_on_bridge_count == 4 ) + { + if ( count_zombies_in_zone( "zone_golden_gate_bridge" ) > 0 ) + { + vo_play_four_part_conversation( level.four_part_convos[ "chair_combat_" + randomintrange( 1, 3 ) ] ); + } + else + { + vo_play_four_part_conversation( level.four_part_convos[ "chair" + randomintrange( 1, 3 ) ] ); + } + return; + } + else + { + if ( isDefined( players[ 0 ] ) && players[ 0 ] istouching( e_nml_zone ) ) + { + character_name = players[ 0 ].character_name; + players[ 0 ] vo_play_soliloquy( level.soliloquy_convos[ "electric_chair_" + character_name ] ); + } + } + } +} + +escape_flight_vo() +{ + e_roof_zone = getent( "zone_roof", "targetname" ); + players = getplayers(); + player = players[ randomintrange( 0, players.size ) ]; + if ( isDefined( player ) && player istouching( e_roof_zone ) ) + { + player thread do_player_general_vox( "quest", "build_plane", undefined, 100 ); + } + flag_wait( "plane_boarded" ); + if ( level.final_flight_activated ) + { + return; + } + while ( level.characters_in_nml.size == 0 ) + { + wait 0,1; + } + wait 1; + while ( level.characters_in_nml.size > 0 ) + { + character_name = level.characters_in_nml[ randomintrange( 0, level.characters_in_nml.size ) ]; + players = getplayers(); + _a687 = players; + _k687 = getFirstArrayKey( _a687 ); + while ( isDefined( _k687 ) ) + { + player = _a687[ _k687 ]; + if ( isDefined( player ) && player.character_name == character_name ) + { + player thread do_player_general_vox( "quest", "plane_takeoff" ); + } + _k687 = getNextArrayKey( _a687, _k687 ); + } + } + flag_wait( "plane_departed" ); + wait 2; + while ( level.characters_in_nml.size > 0 ) + { + character_name = level.characters_in_nml[ randomintrange( 0, level.characters_in_nml.size ) ]; + players = getplayers(); + _a703 = players; + _k703 = getFirstArrayKey( _a703 ); + while ( isDefined( _k703 ) ) + { + player = _a703[ _k703 ]; + if ( isDefined( player ) && player.character_name == character_name ) + { + player playsound( "vox_plr_" + player.characterindex + "_plane_flight_0" ); + } + _k703 = getNextArrayKey( _a703, _k703 ); + } + } + flag_wait( "plane_approach_bridge" ); + wait 3,5; + while ( level.characters_in_nml.size > 0 ) + { + character_name = level.characters_in_nml[ randomintrange( 0, level.characters_in_nml.size ) ]; + players = getplayers(); + _a719 = players; + _k719 = getFirstArrayKey( _a719 ); + while ( isDefined( _k719 ) ) + { + player = _a719[ _k719 ]; + if ( isDefined( player ) && player.character_name == character_name ) + { + player playsound( "vox_plr_" + player.characterindex + "_plane_crash_0" ); + } + _k719 = getNextArrayKey( _a719, _k719 ); + } + } + flag_wait( "plane_zapped" ); + players = getplayers(); + _a732 = players; + _k732 = getFirstArrayKey( _a732 ); + while ( isDefined( _k732 ) ) + { + player = _a732[ _k732 ]; + if ( isDefined( player ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player thread player_scream_thread(); + } + _k732 = getNextArrayKey( _a732, _k732 ); + } +} + +player_scream_thread() +{ + self endon( "death" ); + self endon( "disconnect" ); + players = getplayers(); + _a749 = players; + _k749 = getFirstArrayKey( _a749 ); + while ( isDefined( _k749 ) ) + { + player = _a749[ _k749 ]; + if ( isDefined( player ) && isinarray( level.characters_in_nml, player.character_name ) ) + { + player playsoundtoplayer( "vox_plr_" + player.characterindex + "_free_fall_0", self ); + } + _k749 = getNextArrayKey( _a749, _k749 ); + } + level flag_wait( "plane_crashed" ); + self stopsounds(); + self.dontspeak = 0; + player setclientfieldtoplayer( "isspeaking", 0 ); +} + +sndhitelectrifiedpulley( str_master_key_location ) +{ + self endon( "master_key_pulley_" + str_master_key_location ); + while ( 1 ) + { + self waittill( "trigger", e_triggerer ); + self playsound( "fly_elec_sparks_key" ); + wait 1; + } +} + +is_player_character_present( character_name ) +{ + if ( !isDefined( character_name ) ) + { + return 0; + } + players = getplayers(); + _a785 = players; + _k785 = getFirstArrayKey( _a785 ); + while ( isDefined( _k785 ) ) + { + player = _a785[ _k785 ]; + if ( isDefined( player.character_name ) && player.character_name == character_name ) + { + return 1; + } + _k785 = getNextArrayKey( _a785, _k785 ); + } + return 0; +} + +get_players_touching( scr_touched_name ) +{ + n_touching_count = 0; + e_touched = getent( scr_touched_name, "targetname" ); +/# + assert( isDefined( e_touched ) ); +#/ + a_players = getplayers(); + _a803 = a_players; + _k803 = getFirstArrayKey( _a803 ); + while ( isDefined( _k803 ) ) + { + player = _a803[ _k803 ]; + if ( isDefined( player ) && player istouching( e_touched ) ) + { + n_touching_count++; + } + _k803 = getNextArrayKey( _a803, _k803 ); + } + return n_touching_count; +} + +count_zombies_in_zone( volume ) +{ + e_zone = getent( volume, "targetname" ); + if ( !isDefined( e_zone ) ) + { + return; + } + n_zombie_count = 0; + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + if ( zombies[ i ] istouching( e_zone ) ) + { + n_zombie_count++; + } + i++; + } + return n_zombie_count; +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_standard.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_standard.gsc new file mode 100644 index 0000000..e76b666 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_standard.gsc @@ -0,0 +1,27 @@ +#include maps/mp/zombies/_zm_magicbox; +#include maps/mp/zombies/_zm_game_module; +#include maps/mp/gametypes_zm/_zm_gametype; +#include maps/mp/zombies/_zm_utility; +#include common_scripts/utility; +#include maps/mp/_utility; + +precache() +{ +} + +main() +{ + maps/mp/gametypes_zm/_zm_gametype::setup_standard_objects( "working" ); + maps/mp/zombies/_zm_game_module::set_current_game_module( level.game_module_standard_index ); + flag_wait( "initial_blackscreen_passed" ); + flag_set( "power_on" ); + zm_treasure_chest_init(); +} + +zm_treasure_chest_init() +{ + chest1 = getstruct( "start_chest", "script_noteworthy" ); + level.chests = []; + level.chests[ level.chests.size ] = chest1; + maps/mp/zombies/_zm_magicbox::treasure_chest_init( "start_chest" ); +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_traps.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_traps.gsc new file mode 100644 index 0000000..e85cb7c --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_traps.gsc @@ -0,0 +1,800 @@ +#include maps/mp/zombies/_zm_ai_brutus; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/animscripts/zm_death; +#include maps/mp/zombies/_zm_laststand; +#include maps/mp/zombies/_zm_score; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +#using_animtree( "fxanim_props" ); + +init_fan_trap_trigs() +{ + trap_trigs = getentarray( "fan_trap_use_trigger", "targetname" ); + array_thread( trap_trigs, ::fan_trap_think ); + init_fan_fxanim( "wardens_office" ); +} + +init_fan_trap_animtree() +{ + scriptmodelsuseanimtree( -1 ); +} + +init_fan_fxanim( str_loc ) +{ + e_fan = getent( "fxanim_fan_" + str_loc, "targetname" ); + level.fan_trap_fxanims = []; + level.fan_trap_fxanims[ "fan_trap_start" ] = %fxanim_zom_al_trap_fan_start_anim; + level.fan_trap_fxanims[ "fan_trap_idle" ] = %fxanim_zom_al_trap_fan_idle_anim; + level.fan_trap_fxanims[ "fan_trap_end" ] = %fxanim_zom_al_trap_fan_end_anim; +} + +fan_trap_think() +{ + triggers = getentarray( self.targetname, "targetname" ); + self.cost = 1000; + self.in_use = 0; + self.is_available = 1; + self.has_been_used = 0; + self.zombie_dmg_trig = getent( self.target, "targetname" ); + self.zombie_dmg_trig.script_string = self.script_string; + self.zombie_dmg_trig.in_use = 0; + self.rumble_trig = getent( "fan_trap_rumble", "targetname" ); + light_name = self get_trap_light_name(); + zapper_light_red( light_name ); + self sethintstring( &"ZM_PRISON_FAN_TRAP_UNAVAILABLE" ); + flag_wait( "activate_warden_office" ); + zapper_light_green( light_name ); + self hint_string( &"ZM_PRISON_FAN_TRAP", self.cost ); + while ( 1 ) + { + self waittill( "trigger", who ); + while ( who in_revive_trigger() ) + { + continue; + } + while ( !isDefined( self.is_available ) ) + { + continue; + } + if ( is_player_valid( who ) ) + { + if ( who.score >= self.cost ) + { + if ( !self.zombie_dmg_trig.in_use ) + { + if ( !self.has_been_used ) + { + self.has_been_used = 1; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "trap" ); + who do_player_general_vox( "general", "discover_trap" ); + } + else + { + who do_player_general_vox( "general", "start_trap" ); + } + self.zombie_dmg_trig.in_use = 1; + self.zombie_dmg_trig.active = 1; + self playsound( "zmb_trap_activate" ); + self thread fan_trap_move_switch( self ); + self waittill( "switch_activated" ); + who minus_to_player_score( self.cost ); + level.trapped_track[ "fan" ] = 1; + level notify( "trap_activated" ); + who maps/mp/zombies/_zm_stats::increment_client_stat( "prison_fan_trap_used", 0 ); + array_thread( triggers, ::hint_string, &"ZOMBIE_TRAP_ACTIVE" ); + self.zombie_dmg_trig setvisibletoall(); + self thread activate_fan_trap(); + self.zombie_dmg_trig waittill( "trap_finished_" + self.script_string ); + clientnotify( self.script_string + "off" ); + self.zombie_dmg_trig notify( "fan_trap_finished" ); + self.zombie_dmg_trig.active = 0; + self.zombie_dmg_trig setinvisibletoall(); + array_thread( triggers, ::hint_string, &"ZOMBIE_TRAP_COOLDOWN" ); + wait 25; + self playsound( "zmb_trap_available" ); + self notify( "available" ); + self.zombie_dmg_trig.in_use = 0; + array_thread( triggers, ::hint_string, &"ZM_PRISON_FAN_TRAP", self.cost ); + } + } + } + } +} + +activate_fan_trap() +{ + self.zombie_dmg_trig thread fan_trap_damage( self ); + e_fan = getent( "fxanim_fan_" + self.script_string, "targetname" ); + e_fan useanimtree( -1 ); + e_fan playsound( "zmb_trap_fan_start" ); + e_fan playloopsound( "zmb_trap_fan_loop", 2 ); + n_start_time = getanimlength( level.fan_trap_fxanims[ "fan_trap_start" ] ); + n_idle_time = getanimlength( level.fan_trap_fxanims[ "fan_trap_idle" ] ); + n_end_time = getanimlength( level.fan_trap_fxanims[ "fan_trap_end" ] ); + e_fan setanim( level.fan_trap_fxanims[ "fan_trap_start" ], 1, 0,1, 1 ); + wait n_start_time; + e_fan setanim( level.fan_trap_fxanims[ "fan_trap_idle" ], 1, 0,1, 1 ); + self thread fan_trap_timeout(); + self thread fan_trap_rumble_think(); + self.zombie_dmg_trig waittill( "trap_finished_" + self.script_string ); + e_fan setanim( level.fan_trap_fxanims[ "fan_trap_end" ], 1, 0,1, 1 ); + a_players = getplayers(); + _a177 = a_players; + _k177 = getFirstArrayKey( _a177 ); + while ( isDefined( _k177 ) ) + { + player = _a177[ _k177 ]; + if ( is_true( player.fan_trap_rumble ) ) + { + player setclientfieldtoplayer( "rumble_fan_trap", 0 ); + player.fan_trap_rumble = 0; + } + _k177 = getNextArrayKey( _a177, _k177 ); + } + e_fan stoploopsound( 0,75 ); + e_fan playsound( "zmb_trap_fan_end" ); + wait n_end_time; +} + +fan_trap_timeout() +{ + self.zombie_dmg_trig endon( "trap_finished_" + self.script_string ); + n_duration = 0; + while ( n_duration < 25 ) + { + wait 0,05; + n_duration += 0,05; + } + self.zombie_dmg_trig notify( "trap_finished_" + self.script_string ); +} + +fan_trap_rumble_think() +{ + self.zombie_dmg_trig endon( "trap_finished_" + self.script_string ); + while ( 1 ) + { + self.rumble_trig waittill( "trigger", ent ); + if ( isplayer( ent ) ) + { + if ( !is_true( ent.fan_trap_rumble ) ) + { + self thread fan_trap_rumble( ent ); + } + } + } +} + +fan_trap_rumble( player ) +{ + player endon( "death" ); + player endon( "disconnect" ); + self.zombie_dmg_trig endon( "trap_finished_" + self.script_string ); + while ( 1 ) + { + if ( player istouching( self.rumble_trig ) ) + { + player setclientfieldtoplayer( "rumble_fan_trap", 1 ); + player.fan_trap_rumble = 1; + wait 0,25; + continue; + } + else + { + player setclientfieldtoplayer( "rumble_fan_trap", 0 ); + player.fan_trap_rumble = 0; + return; + } + } +} + +fan_trap_damage( parent ) +{ + if ( isDefined( level.custom_fan_trap_damage_func ) ) + { + self thread [[ level.custom_fan_trap_damage_func ]]( parent ); + return; + } + self endon( "fan_trap_finished" ); + while ( 1 ) + { + self waittill( "trigger", ent ); + if ( isplayer( ent ) ) + { + ent thread player_fan_trap_damage(); + continue; + } + else + { + if ( is_true( ent.is_brutus ) ) + { + ent maps/mp/zombies/_zm_ai_brutus::trap_damage_callback( self ); + return; + } + if ( !isDefined( ent.marked_for_death ) ) + { + ent.marked_for_death = 1; + ent thread zombie_fan_trap_death(); + } + } + } +} + +fan_trap_move_switch( parent ) +{ + light_name = ""; + tswitch = getent( "trap_handle_" + parent.script_linkto, "targetname" ); + light_name = parent get_trap_light_name(); + zapper_light_red( light_name ); + tswitch rotatepitch( -180, 0,5 ); + tswitch playsound( "amb_sparks_l_b" ); + tswitch waittill( "rotatedone" ); + self notify( "switch_activated" ); + self waittill( "available" ); + tswitch rotatepitch( 180, 0,5 ); + zapper_light_green( light_name ); +} + +player_fan_trap_damage() +{ + self endon( "death" ); + self endon( "disconnect" ); + if ( !self hasperk( "specialty_armorvest" ) || ( self.health - 100 ) < 1 ) + { + radiusdamage( self.origin, 10, self.health + 100, self.health + 100 ); + } + else + { + self dodamage( 50, self.origin ); + } +} + +zombie_fan_trap_death() +{ + self endon( "death" ); + if ( !isDefined( self.is_brutus ) ) + { + self.a.gib_ref = random( array( "guts", "right_arm", "left_arm", "head" ) ); + self thread maps/mp/animscripts/zm_death::do_gib(); + } + self setclientfield( "fan_trap_blood_fx", 1 ); + self thread stop_fan_trap_blood_fx(); + self dodamage( self.health + 1000, self.origin ); +} + +stop_fan_trap_blood_fx() +{ + wait 2; + self setclientfield( "fan_trap_blood_fx", 0 ); +} + +init_acid_trap_trigs() +{ + trap_trigs = getentarray( "acid_trap_trigger", "targetname" ); + array_thread( trap_trigs, ::acid_trap_think ); + level thread acid_trap_host_migration_listener(); +} + +acid_trap_think() +{ + triggers = getentarray( self.targetname, "targetname" ); + self.is_available = 1; + self.has_been_used = 0; + self.cost = 1000; + self.in_use = 0; + self.zombie_dmg_trig = getent( self.target, "targetname" ); + self.zombie_dmg_trig.in_use = 0; + light_name = self get_trap_light_name(); + zapper_light_red( light_name ); + self sethintstring( &"ZM_PRISON_ACID_TRAP_UNAVAILABLE" ); + flag_wait_any( "activate_cafeteria", "activate_infirmary" ); + zapper_light_green( light_name ); + self hint_string( &"ZM_PRISON_ACID_TRAP", self.cost ); + while ( 1 ) + { + self waittill( "trigger", who ); + while ( who in_revive_trigger() ) + { + continue; + } + while ( !isDefined( self.is_available ) ) + { + continue; + } + if ( is_player_valid( who ) ) + { + if ( who.score >= self.cost ) + { + if ( !self.zombie_dmg_trig.in_use ) + { + if ( !self.has_been_used ) + { + self.has_been_used = 1; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "trap" ); + who do_player_general_vox( "general", "discover_trap" ); + } + else + { + who do_player_general_vox( "general", "start_trap" ); + } + self.zombie_dmg_trig.in_use = 1; + self.zombie_dmg_trig.active = 1; + self playsound( "zmb_trap_activate" ); + self thread acid_trap_move_switch( self ); + self waittill( "switch_activated" ); + who minus_to_player_score( self.cost ); + level.trapped_track[ "acid" ] = 1; + level notify( "trap_activated" ); + who maps/mp/zombies/_zm_stats::increment_client_stat( "prison_acid_trap_used", 0 ); + array_thread( triggers, ::hint_string, &"ZOMBIE_TRAP_ACTIVE" ); + self thread activate_acid_trap(); + self.zombie_dmg_trig waittill( "acid_trap_fx_done" ); + clientnotify( self.script_string + "off" ); + if ( isDefined( self.fx_org ) ) + { + self.fx_org delete(); + } + if ( isDefined( self.zapper_fx_org ) ) + { + self.zapper_fx_org delete(); + } + if ( isDefined( self.zapper_fx_switch_org ) ) + { + self.zapper_fx_switch_org delete(); + } + self.zombie_dmg_trig notify( "acid_trap_finished" ); + self.zombie_dmg_trig.active = 0; + array_thread( triggers, ::hint_string, &"ZOMBIE_TRAP_COOLDOWN" ); + wait 25; + self playsound( "zmb_trap_available" ); + self notify( "available" ); + self.zombie_dmg_trig.in_use = 0; + array_thread( triggers, ::hint_string, &"ZM_PRISON_ACID_TRAP", self.cost ); + } + } + } + } +} + +acid_trap_move_switch( parent ) +{ + light_name = ""; + tswitch = getent( "trap_handle_" + parent.script_linkto, "targetname" ); + light_name = parent get_trap_light_name(); + zapper_light_red( light_name ); + tswitch rotatepitch( -180, 0,5 ); + tswitch playsound( "amb_sparks_l_b" ); + tswitch waittill( "rotatedone" ); + self notify( "switch_activated" ); + self waittill( "available" ); + tswitch rotatepitch( 180, 0,5 ); + zapper_light_green( light_name ); +} + +activate_acid_trap() +{ + clientnotify( self.target ); + fire_points = getstructarray( self.target, "targetname" ); + i = 0; + while ( i < fire_points.size ) + { + wait_network_frame(); + fire_points[ i ] thread acid_trap_fx( self ); + i++; + } + self.zombie_dmg_trig thread acid_trap_damage(); +} + +acid_trap_damage() +{ + if ( isDefined( level.custom_acid_trap_damage_func ) ) + { + self thread [[ level.custom_acid_trap_damage_func ]](); + return; + } + self endon( "acid_trap_finished" ); + while ( 1 ) + { + self waittill( "trigger", ent ); + if ( isplayer( ent ) ) + { + ent thread player_acid_damage( self ); + continue; + } + else + { + if ( is_true( ent.is_brutus ) ) + { + ent maps/mp/zombies/_zm_ai_brutus::trap_damage_callback( self ); + return; + } + if ( !isDefined( ent.marked_for_death ) ) + { + ent.marked_for_death = 1; + ent thread zombie_acid_damage(); + } + } + } +} + +zombie_acid_damage() +{ + self endon( "death" ); + self setclientfield( "acid_trap_death_fx", 1 ); + wait randomfloatrange( 0,25, 2 ); + if ( !isDefined( self.is_brutus ) ) + { + self.a.gib_ref = random( array( "right_arm", "left_arm", "head", "right_leg", "left_leg", "no_legs" ) ); + self thread maps/mp/animscripts/zm_death::do_gib(); + } + self dodamage( self.health + 1000, self.origin ); +} + +stop_acid_death_fx() +{ + wait 3; + self setclientfield( "acid_trap_death_fx", 0 ); +} + +player_acid_damage( t_damage ) +{ + self endon( "death" ); + self endon( "disconnect" ); + t_damage endon( "acid_trap_finished" ); + while ( !isDefined( self.is_in_acid ) && !self player_is_in_laststand() ) + { + self.is_in_acid = 1; + self thread player_acid_damage_cooldown(); + while ( self istouching( t_damage ) && !self player_is_in_laststand() && !self.afterlife ) + { + self dodamage( self.maxhealth / 2, self.origin ); + wait 1; + } + } +} + +player_acid_damage_cooldown() +{ + self endon( "disconnect" ); + wait 1; + if ( isDefined( self ) ) + { + self.is_in_acid = undefined; + } +} + +acid_trap_fx( notify_ent ) +{ + wait 25; + notify_ent.zombie_dmg_trig notify( "acid_trap_fx_done" ); +} + +acid_trap_host_migration_listener() +{ + level endon( "end_game" ); + level notify( "acid_trap_hostmigration" ); + level endon( "acid_trap_hostmigration" ); + while ( 1 ) + { + level waittill( "host_migration_end" ); + trap_trigs = getentarray( "acid_trap_trigger", "targetname" ); + _a623 = trap_trigs; + _k623 = getFirstArrayKey( _a623 ); + while ( isDefined( _k623 ) ) + { + trigger = _a623[ _k623 ]; + if ( isDefined( trigger.zombie_dmg_trig ) && isDefined( trigger.zombie_dmg_trig.active ) ) + { + if ( trigger.zombie_dmg_trig.active == 1 ) + { + clientnotify( trigger.target ); + break; + } + } + else + { + _k623 = getNextArrayKey( _a623, _k623 ); + } + } + } +} + +init_tower_trap_trigs() +{ + trap_trigs = getentarray( "tower_trap_activate_trigger", "targetname" ); + _a644 = trap_trigs; + _k644 = getFirstArrayKey( _a644 ); + while ( isDefined( _k644 ) ) + { + trigger = _a644[ _k644 ]; + trigger thread tower_trap_trigger_think(); + _k644 = getNextArrayKey( _a644, _k644 ); + } +} + +tower_trap_trigger_think() +{ + self.range_trigger = getent( self.target, "targetname" ); + self.upgrade_trigger = getent( self.script_string, "script_noteworthy" ); + self.cost = 1000; + light_name = self get_trap_light_name(); + zapper_light_green( light_name ); + self.is_available = 1; + self.in_use = 0; + self.has_been_used = 0; + self.sndtowerent = spawn( "script_origin", ( -21, 5584, 356 ) ); + while ( 1 ) + { + self hint_string( &"ZM_PRISON_TOWER_TRAP", self.cost ); + self waittill( "trigger", who ); + while ( who in_revive_trigger() ) + { + continue; + } + while ( !isDefined( self.is_available ) ) + { + continue; + } + if ( is_player_valid( who ) ) + { + if ( who.score >= self.cost ) + { + if ( !self.in_use ) + { + if ( !self.has_been_used ) + { + self.has_been_used = 1; + who do_player_general_vox( "general", "discover_trap" ); + } + else + { + who do_player_general_vox( "general", "start_trap" ); + } + self.in_use = 1; + self.active = 1; + play_sound_at_pos( "purchase", who.origin ); + self thread tower_trap_move_switch( self ); + self playsound( "zmb_trap_activate" ); + self waittill( "switch_activated" ); + who minus_to_player_score( self.cost ); + level.trapped_track[ "tower" ] = 1; + level notify( "trap_activated" ); + who maps/mp/zombies/_zm_stats::increment_client_stat( "prison_sniper_tower_used", 0 ); + self hint_string( &"ZOMBIE_TRAP_ACTIVE" ); + self.sndtowerent playsound( "zmb_trap_tower_start" ); + self.sndtowerent playloopsound( "zmb_trap_tower_loop", 1 ); + self thread activate_tower_trap(); + self thread tower_trap_timer(); + self thread tower_upgrade_trigger_think(); + level thread open_tower_trap_upgrade_panel(); + level thread tower_trap_upgrade_panel_closes_early(); + self waittill( "tower_trap_off" ); + self.sndtowerent stoploopsound( 1 ); + self.sndtowerent playsound( "zmb_trap_tower_end" ); + self.upgrade_trigger notify( "afterlife_interact_reset" ); + self.active = 0; + self sethintstring( &"ZOMBIE_TRAP_COOLDOWN" ); + zapper_light_red( light_name ); + wait 25; + self playsound( "zmb_trap_available" ); + self notify( "available" ); + self.in_use = 0; + self.upgrade_trigger notify( "available" ); + self.upgrade_trigger.in_use = 0; + } + } + } + } +} + +tower_upgrade_trigger_think() +{ + self endon( "tower_trap_off" ); + self.upgrade_trigger.cost = 1000; + self.upgrade_trigger.in_use = 0; + self.upgrade_trigger.is_available = 1; + while ( 1 ) + { + level waittill( self.upgrade_trigger.script_string ); + level.trapped_track[ "tower_upgrade" ] = 1; + level notify( "tower_trap_upgraded" ); + level notify( "close_tower_trap_upgrade_panel" ); + self upgrade_tower_trap_weapon(); + self notify( "tower_trap_reset_timer" ); + self thread tower_trap_timer(); + self waittill( "tower_trap_off" ); + wait 25; + } +} + +open_tower_trap_upgrade_panel() +{ + e_door = getent( "tower_shockbox_door", "targetname" ); + e_door moveto( e_door.origin + vectorScale( ( 0, 1, 0 ), 40 ), 1 ); + level waittill( "close_tower_trap_upgrade_panel" ); + e_door moveto( e_door.origin + vectorScale( ( 0, 1, 0 ), 40 ), 1 ); +} + +tower_trap_upgrade_panel_closes_early() +{ + level endon( "tower_trap_upgraded" ); + n_waittime = 24; + wait n_waittime; + level notify( "close_tower_trap_upgrade_panel" ); +} + +tower_trap_move_switch( parent ) +{ + light_name = ""; + tswitch = getent( "trap_handle_" + parent.script_linkto, "targetname" ); + light_name = parent get_trap_light_name(); + zapper_light_red( light_name ); + tswitch rotatepitch( -180, 0,5 ); + tswitch playsound( "amb_sparks_l_b" ); + tswitch waittill( "rotatedone" ); + self notify( "switch_activated" ); + self waittill( "available" ); + tswitch rotatepitch( 180, 0,5 ); + if ( isDefined( parent.script_noteworthy ) ) + { + zapper_light_green( light_name ); + } +} + +activate_tower_trap() +{ + self endon( "tower_trap_off" ); + self.weapon_name = "tower_trap_zm"; + self.tag_to_target = "J_Head"; + self.trap_reload_time = 0,75; + for ( ;; ) + { + while ( 1 ) + { + zombies = getaiarray( level.zombie_team ); + zombies_sorted = []; + _a850 = zombies; + _k850 = getFirstArrayKey( _a850 ); + while ( isDefined( _k850 ) ) + { + zombie = _a850[ _k850 ]; + if ( zombie istouching( self.range_trigger ) ) + { + zombies_sorted[ zombies_sorted.size ] = zombie; + } + _k850 = getNextArrayKey( _a850, _k850 ); + } + if ( zombies_sorted.size <= 0 ) + { + wait_network_frame(); + } + } + else wait_network_frame(); + self tower_trap_fires( zombies_sorted ); + } +} + +upgrade_tower_trap_weapon() +{ + self.weapon_name = "tower_trap_upgraded_zm"; + self.tag_to_target = "J_SpineLower"; + self.trap_reload_time = 1,5; +} + +tower_trap_timer() +{ + self endon( "tower_trap_reset_timer" ); +/# + self thread debug_tower_trap_timer(); +#/ + wait 25; + self notify( "tower_trap_off" ); +} + +debug_tower_trap_timer() +{ + self endon( "tower_trap_reset_timer" ); + i = 1; + while ( i <= 25 ) + { +/# + iprintln( "Tower Trap Timer = " + i ); +#/ + wait 1; + i++; + } +} + +tower_trap_fires( a_zombies ) +{ + if ( isDefined( level.custom_tower_trap_fires_func ) ) + { + self thread [[ level.custom_tower_trap_fires_func ]]( a_zombies ); + return; + } + self endon( "tower_trap_off" ); + e_org = getstruct( self.range_trigger.target, "targetname" ); + n_index = randomintrange( 0, a_zombies.size ); + while ( isalive( a_zombies[ n_index ] ) ) + { + e_target = a_zombies[ n_index ]; + v_zombietarget = e_target gettagorigin( self.tag_to_target ); + if ( sighttracepassed( e_org.origin, v_zombietarget, 1, undefined ) ) + { + magicbullet( self.weapon_name, e_org.origin, v_zombietarget ); + wait self.trap_reload_time; + continue; + } + else + { + arrayremovevalue( a_zombies, e_target, 0 ); + wait_network_frame(); + if ( a_zombies.size <= 0 ) + { + return; + } + else + { + n_index = randomintrange( 0, a_zombies.size ); + } + } + } +} + +hint_string( string, cost ) +{ + if ( isDefined( cost ) ) + { + self sethintstring( string, cost ); + } + else + { + self sethintstring( string ); + } + self setcursorhint( "HINT_NOICON" ); +} + +zapper_light_red( lightname ) +{ + zapper_lights = getentarray( lightname, "targetname" ); + i = 0; + while ( i < zapper_lights.size ) + { + zapper_lights[ i ] setmodel( "p6_zm_al_wall_trap_control_red" ); + i++; + } +} + +zapper_light_green( lightname ) +{ + zapper_lights = getentarray( lightname, "targetname" ); + i = 0; + while ( i < zapper_lights.size ) + { + zapper_lights[ i ] setmodel( "p6_zm_al_wall_trap_control" ); + i++; + } +} + +get_trap_light_name() +{ + tswitch = getent( "trap_handle_" + self.script_linkto, "targetname" ); + switch( tswitch.script_linkname ) + { + case "1": + case "2": + light_name = "trap_control_wardens_office"; + break; + case "3": + case "4": + case "5": + light_name = "trap_control_cafeteria"; + break; + case "99": + light_name = "trap_control_docks"; + break; + } + return light_name; +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_travel.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_travel.gsc new file mode 100644 index 0000000..ed4e7d2 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_travel.gsc @@ -0,0 +1,1001 @@ +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_laststand; +#include maps/mp/zombies/_zm_score; +#include maps/mp/zombies/_zm_utility; +#include maps/_zombiemode_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +#using_animtree( "fxanim_props" ); + +init_alcatraz_zipline() +{ + level thread gondola_hostmigration(); + level.player_intersection_tracker_override = ::zombie_alcatraz_player_intersection_tracker_override; + flag_init( "gondola_at_roof" ); + flag_init( "gondola_at_docks" ); + flag_init( "gondola_in_motion" ); + flag_init( "gondola_initialized" ); + e_gondola = getent( "zipline_gondola", "targetname" ); + level.e_gondola = e_gondola; + e_gondola.location = "roof"; + e_gondola.destination = undefined; + e_gondola setmovingplatformenabled( 1 ); + playfxontag( level._effect[ "light_gondola" ], e_gondola, "tag_origin" ); + flag_set( "gondola_at_roof" ); + level.e_gondola.t_ride = getent( "gondola_ride_trigger", "targetname" ); + level.e_gondola.t_ride enablelinkto(); + level.e_gondola.t_ride linkto( e_gondola ); + t_move_triggers = getentarray( "gondola_move_trigger", "targetname" ); + t_call_triggers = getentarray( "gondola_call_trigger", "targetname" ); + a_t_gondola_triggers = arraycombine( t_move_triggers, t_call_triggers, 1, 0 ); + _a47 = a_t_gondola_triggers; + _k47 = getFirstArrayKey( _a47 ); + while ( isDefined( _k47 ) ) + { + trigger = _a47[ _k47 ]; + trigger hint_string( &"ZM_PRISON_GONDOLA_REQUIRES_POWER" ); + _k47 = getNextArrayKey( _a47, _k47 ); + } + a_gondola_doors = getentarray( "gondola_doors", "targetname" ); + _a54 = a_gondola_doors; + _k54 = getFirstArrayKey( _a54 ); + while ( isDefined( _k54 ) ) + { + m_door = _a54[ _k54 ]; + m_door linkto( e_gondola ); + e_gondola establish_gondola_door_definition( m_door ); + m_door setmovingplatformenabled( 1 ); + _k54 = getNextArrayKey( _a54, _k54 ); + } + a_gondola_gates = getentarray( "gondola_gates", "targetname" ); + _a63 = a_gondola_gates; + _k63 = getFirstArrayKey( _a63 ); + while ( isDefined( _k63 ) ) + { + m_gate = _a63[ _k63 ]; + m_gate linkto( e_gondola ); + e_gondola establish_gondola_gate_definition( m_gate ); + m_gate setmovingplatformenabled( 1 ); + _k63 = getNextArrayKey( _a63, _k63 ); + } + a_gondola_landing_doors = getentarray( "gondola_landing_doors", "targetname" ); + _a72 = a_gondola_landing_doors; + _k72 = getFirstArrayKey( _a72 ); + while ( isDefined( _k72 ) ) + { + m_door = _a72[ _k72 ]; + e_gondola establish_gondola_landing_door_definition( m_door ); + _k72 = getNextArrayKey( _a72, _k72 ); + } + a_gondola_landing_gates = getentarray( "gondola_landing_gates", "targetname" ); + _a79 = a_gondola_landing_gates; + _k79 = getFirstArrayKey( _a79 ); + while ( isDefined( _k79 ) ) + { + m_gate = _a79[ _k79 ]; + e_gondola establish_gondola_landing_gate_definition( m_gate ); + _k79 = getNextArrayKey( _a79, _k79 ); + } + m_chains = spawn( "script_model", level.e_gondola.origin ); + m_chains.origin = level.e_gondola.origin; + m_chains.angles = level.e_gondola.angles; + m_chains setmodel( "fxanim_zom_al_gondola_chains_mod" ); + m_chains linkto( level.e_gondola ); + level.e_gondola.fxanim_chains = m_chains; + level.gondola_chains_fxanims = []; + level.gondola_chains_fxanims[ "gondola_chains_start" ] = %fxanim_zom_al_gondola_chains_start_anim; + level.gondola_chains_fxanims[ "gondola_chains_idle" ] = %fxanim_zom_al_gondola_chains_idle_anim; + level.gondola_chains_fxanims[ "gondola_chains_end" ] = %fxanim_zom_al_gondola_chains_end_anim; + gondola_lights_red(); +/# + level thread debug_power_gondola_on(); +#/ + str_notify = level waittill_any_array_return( array( "gondola_powered_on_roof", "gondola_powered_on_docks" ) ); + if ( str_notify == "gondola_powered_on_roof" ) + { + level thread turn_off_opposite_side_gondola_shockbox( "gondola_powered_on_docks" ); + e_gondola gondola_doors_move( "roof", 1 ); + } + else + { + if ( str_notify == "gondola_powered_on_docks" ) + { + level thread turn_off_opposite_side_gondola_shockbox( "gondola_powered_on_roof" ); + move_gondola( 1 ); + } + } + flag_set( "gondola_initialized" ); + gondola_lights_green(); + array_thread( t_move_triggers, ::zipline_move_trigger_think ); + array_thread( t_call_triggers, ::zipline_call_trigger_think ); +} + +turn_off_opposite_side_gondola_shockbox( str_notify_opposite ) +{ + a_e_afterlife_interacts = getentarray( "afterlife_interact", "targetname" ); + _a134 = a_e_afterlife_interacts; + _k134 = getFirstArrayKey( _a134 ); + while ( isDefined( _k134 ) ) + { + shockbox = _a134[ _k134 ]; + if ( isDefined( shockbox.script_string ) ) + { + if ( shockbox.script_string == str_notify_opposite ) + { + shockbox notify( "damage" ); + } + } + _k134 = getNextArrayKey( _a134, _k134 ); + } +} + +debug_power_gondola_on() +{ +/# + level waittill( "open_sesame" ); + level notify( "gondola_powered_on_roof" ); +#/ +} + +establish_gondola_door_definition( m_door ) +{ + str_identifier = m_door.script_noteworthy; + switch( str_identifier ) + { + case "roof left": + self.door_roof_left = m_door; + break; + case "roof right": + self.door_roof_right = m_door; + break; + case "docks left": + self.door_docks_left = m_door; + break; + case "docks right": + self.door_docks_right = m_door; + break; + } +} + +establish_gondola_gate_definition( m_gate ) +{ + str_identifier = m_gate.script_noteworthy; + switch( str_identifier ) + { + case "roof left": + self.gate_roof_left = m_gate; + break; + case "roof right": + self.gate_roof_right = m_gate; + break; + case "docks left": + self.gate_docks_left = m_gate; + break; + case "docks right": + self.gate_docks_right = m_gate; + break; + } +} + +establish_gondola_landing_door_definition( m_door ) +{ + str_identifier = m_door.script_noteworthy; + switch( str_identifier ) + { + case "roof left": + self.landing_door_roof_left = m_door; + break; + case "roof right": + self.landing_door_roof_right = m_door; + break; + case "docks left": + self.landing_door_docks_left = m_door; + break; + case "docks right": + self.landing_door_docks_right = m_door; + break; + } +} + +establish_gondola_landing_gate_definition( m_gate ) +{ + str_identifier = m_gate.script_noteworthy; + switch( str_identifier ) + { + case "roof left": + self.landing_gate_roof_left = m_gate; + break; + case "roof right": + self.landing_gate_roof_right = m_gate; + break; + case "docks left": + self.landing_gate_docks_left = m_gate; + break; + case "docks right": + self.landing_gate_docks_right = m_gate; + break; + } +} + +zipline_move_trigger_think() +{ + level endon( "interrupt_gondola_move_trigger_" + self.script_string ); + self.cost = 750; + self.in_use = 0; + self.is_available = 1; + self hint_string( "" ); + while ( 1 ) + { + flag_wait( "gondola_at_" + self.script_string ); + self hint_string( &"ZM_PRISON_MOVE_GONDOLA", self.cost ); + self waittill( "trigger", who ); + while ( who in_revive_trigger() ) + { + continue; + } + while ( !isDefined( self.is_available ) ) + { + continue; + } + if ( is_player_valid( who ) ) + { + if ( who.score >= self.cost ) + { + if ( !self.in_use ) + { + self.in_use = 1; + self.is_available = undefined; + play_sound_at_pos( "purchase", who.origin ); + who minus_to_player_score( self.cost ); + if ( self.script_string == "roof" ) + { + level notify( "interrupt_gondola_call_trigger_docks" ); + str_loc = "docks"; + } + else + { + if ( self.script_string == "docks" ) + { + level notify( "interrupt_gondola_call_trigger_roof" ); + str_loc = "roof"; + } + } + a_t_trig = getentarray( "gondola_call_trigger", "targetname" ); + _a298 = a_t_trig; + _k298 = getFirstArrayKey( _a298 ); + while ( isDefined( _k298 ) ) + { + trigger = _a298[ _k298 ]; + if ( trigger.script_string == str_loc ) + { + t_opposite_call_trigger = trigger; + break; + } + else + { + _k298 = getNextArrayKey( _a298, _k298 ); + } + } + move_gondola(); + t_opposite_call_trigger thread zipline_call_trigger_think(); + t_opposite_call_trigger playsound( "zmb_trap_available" ); + self.in_use = 0; + self.is_available = 1; + } + } + } + } +} + +zipline_call_trigger_think() +{ + level endon( "interrupt_gondola_call_trigger_" + self.script_string ); + self.cost = 0; + self.in_use = 0; + self.is_available = 1; + e_gondola = level.e_gondola; + if ( self.script_string == "roof" ) + { + str_gondola_loc = "docks"; + } + else + { + if ( self.script_string == "docks" ) + { + str_gondola_loc = "roof"; + } + } + while ( 1 ) + { + self sethintstring( "" ); + flag_wait( "gondola_at_" + str_gondola_loc ); + self notify( "available" ); + self hint_string( &"ZM_PRISON_CALL_GONDOLA" ); + self waittill( "trigger", who ); + while ( who in_revive_trigger() ) + { + continue; + } + while ( !isDefined( self.is_available ) ) + { + continue; + } + if ( is_player_valid( who ) ) + { + if ( !self.in_use ) + { + self.in_use = 1; + if ( self.script_string == "roof" ) + { + level notify( "interrupt_gondola_move_trigger_docks" ); + str_loc = "docks"; + } + else + { + if ( self.script_string == "docks" ) + { + level notify( "interrupt_gondola_move_trigger_roof" ); + str_loc = "roof"; + } + } + a_t_trig = getentarray( "gondola_move_trigger", "targetname" ); + _a388 = a_t_trig; + _k388 = getFirstArrayKey( _a388 ); + while ( isDefined( _k388 ) ) + { + trigger = _a388[ _k388 ]; + if ( trigger.script_string == str_loc ) + { + t_opposite_move_trigger = trigger; + break; + } + else + { + _k388 = getNextArrayKey( _a388, _k388 ); + } + } + self playsound( "zmb_trap_activate" ); + move_gondola(); + t_opposite_move_trigger thread zipline_move_trigger_think(); + self.in_use = 0; + self playsound( "zmb_trap_available" ); + self.is_available = 1; + } + } + } +} + +move_gondola( b_suppress_doors_close ) +{ + if ( !isDefined( b_suppress_doors_close ) ) + { + b_suppress_doors_close = 0; + } + level clientnotify( "sndGS" ); + gondola_lights_red(); + e_gondola = level.e_gondola; + t_ride = level.e_gondola.t_ride; + e_gondola.is_moving = 1; + if ( e_gondola.location == "roof" ) + { + s_moveloc = getstruct( "gondola_struct_docks", "targetname" ); + e_gondola.destination = "docks"; + } + else + { + if ( e_gondola.location == "docks" ) + { + s_moveloc = getstruct( "gondola_struct_roof", "targetname" ); + e_gondola.destination = "roof"; + } + } + if ( flag( "gondola_initialized" ) ) + { + flag_set( "gondola_roof_to_dock" ); + flag_set( "gondola_dock_to_roof" ); + flag_set( "gondola_ride_zone_enabled" ); + } + flag_clear( "gondola_at_" + e_gondola.location ); + if ( isDefined( b_suppress_doors_close ) && !b_suppress_doors_close ) + { + e_gondola gondola_doors_move( e_gondola.location, -1 ); + } + level notify( "gondola_moving" ); + a_t_move = getentarray( "gondola_move_trigger", "targetname" ); + _a455 = a_t_move; + _k455 = getFirstArrayKey( _a455 ); + while ( isDefined( _k455 ) ) + { + trigger = _a455[ _k455 ]; + trigger sethintstring( "" ); + _k455 = getNextArrayKey( _a455, _k455 ); + } + a_t_call = getentarray( "gondola_call_trigger", "targetname" ); + _a461 = a_t_call; + _k461 = getFirstArrayKey( _a461 ); + while ( isDefined( _k461 ) ) + { + trigger = _a461[ _k461 ]; + trigger sethintstring( &"ZM_PRISON_GONDOLA_ACTIVE" ); + _k461 = getNextArrayKey( _a461, _k461 ); + } + check_when_gondola_moves_if_groundent_is_undefined( e_gondola ); + a_players = getplayers(); + _a472 = a_players; + _k472 = getFirstArrayKey( _a472 ); + while ( isDefined( _k472 ) ) + { + player = _a472[ _k472 ]; + if ( player is_player_on_gondola() ) + { + player setclientfieldtoplayer( "rumble_gondola", 1 ); + player thread check_for_death_on_gondola( e_gondola ); + player.is_on_gondola = 1; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "gondola", player ); + } + if ( isDefined( player.e_afterlife_corpse ) && player.e_afterlife_corpse istouching( t_ride ) ) + { + player.e_afterlife_corpse thread link_corpses_to_gondola( e_gondola ); + } + _k472 = getNextArrayKey( _a472, _k472 ); + } + e_gondola thread create_gondola_poi(); + level thread gondola_moving_vo(); + e_gondola thread gondola_physics_explosion( 10 ); + e_gondola moveto( s_moveloc.origin, 10, 1, 1 ); + flag_set( "gondola_in_motion" ); + e_gondola thread gondola_chain_fx_anim(); + e_gondola playsound( "zmb_gondola_start" ); + e_gondola playloopsound( "zmb_gondola_loop", 1 ); + e_gondola waittill( "movedone" ); + flag_clear( "gondola_in_motion" ); + e_gondola stoploopsound( 0,5 ); + e_gondola thread sndcooldown(); + e_gondola playsound( "zmb_gondola_stop" ); + player_escaped_gondola_failsafe(); + a_players = getplayers(); + _a517 = a_players; + _k517 = getFirstArrayKey( _a517 ); + while ( isDefined( _k517 ) ) + { + player = _a517[ _k517 ]; + if ( isDefined( player.is_on_gondola ) && player.is_on_gondola ) + { + player setclientfieldtoplayer( "rumble_gondola", 0 ); + player.is_on_gondola = 0; + } + _k517 = getNextArrayKey( _a517, _k517 ); + } + e_gondola gondola_doors_move( e_gondola.destination, 1 ); + e_gondola.is_moving = 0; + e_gondola thread tear_down_gondola_poi(); + wait 1; + level clientnotify( "sndGE" ); + if ( e_gondola.location == "roof" ) + { + e_gondola.location = "docks"; + str_zone = "zone_dock_gondola"; + } + else + { + if ( e_gondola.location == "docks" ) + { + e_gondola.location = "roof"; + str_zone = "zone_cellblock_west_gondola_dock"; + } + } + level notify( "gondola_arrived" ); + gondola_cooldown(); + flag_set( "gondola_at_" + e_gondola.location ); +} + +sndcooldown() +{ + self playsound( "zmb_gond_pwr_dn" ); + self playloopsound( "zmb_gondola_cooldown_lp", 1 ); + wait 10; + wait 3,5; + self stoploopsound( 0,5 ); + self playsound( "zmb_gond_pwr_on" ); +} + +gondola_doors_move( str_side, n_state ) +{ + if ( str_side == "roof" ) + { + m_door_left = self.door_roof_left; + m_gate_left = self.gate_roof_left; + m_door_right = self.door_roof_right; + m_gate_right = self.gate_roof_right; + m_landing_door_left = self.landing_door_roof_left; + m_landing_gate_left = self.landing_gate_roof_left; + m_landing_door_right = self.landing_door_roof_right; + m_landing_gate_right = self.landing_gate_roof_right; + n_side_modifier = 1; + } + else + { + if ( str_side == "docks" ) + { + m_door_left = self.door_docks_left; + m_gate_left = self.gate_docks_left; + m_door_right = self.door_docks_right; + m_gate_right = self.gate_docks_right; + m_landing_door_left = self.landing_door_docks_left; + m_landing_gate_left = self.landing_gate_docks_left; + m_landing_door_right = self.landing_door_docks_right; + m_landing_gate_right = self.landing_gate_docks_right; + n_side_modifier = -1; + } + } + a_doors_and_gates = []; + a_doors_and_gates[ 0 ] = m_door_left; + a_doors_and_gates[ 1 ] = m_gate_left; + a_doors_and_gates[ 2 ] = m_door_right; + a_doors_and_gates[ 3 ] = m_gate_right; + _a611 = a_doors_and_gates; + _k611 = getFirstArrayKey( _a611 ); + while ( isDefined( _k611 ) ) + { + m_model = _a611[ _k611 ]; + m_model unlink(); + _k611 = getNextArrayKey( _a611, _k611 ); + } + m_door_left playsound( "zmb_gondola_door" ); + if ( n_state == 1 ) + { + gondola_gate_moves( n_state, n_side_modifier, m_gate_left, m_gate_right, m_landing_gate_left, m_landing_gate_right ); + gondola_gate_and_door_moves( n_state, n_side_modifier, m_gate_left, m_door_left, m_gate_right, m_door_right, m_landing_gate_left, m_landing_door_left, m_landing_gate_right, m_landing_door_right ); + if ( n_side_modifier == 1 ) + { + top_node_r = getnode( "nd_gond_top_r", "targetname" ); + top_node_r node_add_connection( getnode( "nd_on_top_r", "targetname" ) ); + } + else + { + bottom_node_r = getnode( "nd_gond_bottom_r", "targetname" ); + bottom_node_r node_add_connection( getnode( "nd_on_bottom_r", "targetname" ) ); + } + } + else + { + if ( n_side_modifier == 1 ) + { + top_node_r = getnode( "nd_gond_top_r", "targetname" ); + top_node_r node_disconnect_from_path(); + } + else + { + bottom_node_r = getnode( "nd_gond_bottom_r", "targetname" ); + bottom_node_r node_disconnect_from_path(); + } + gondola_gate_and_door_moves( n_state, n_side_modifier, m_gate_left, m_door_left, m_gate_right, m_door_right, m_landing_gate_left, m_landing_door_left, m_landing_gate_right, m_landing_door_right ); + gondola_gate_moves( n_state, n_side_modifier, m_gate_left, m_gate_right, m_landing_gate_left, m_landing_gate_right ); + } + _a657 = a_doors_and_gates; + _k657 = getFirstArrayKey( _a657 ); + while ( isDefined( _k657 ) ) + { + m_model = _a657[ _k657 ]; + m_model linkto( self ); + _k657 = getNextArrayKey( _a657, _k657 ); + } +} + +gondola_gate_moves( n_state, n_side_modifier, m_gate_left, m_gate_right, m_landing_gate_left, m_landing_gate_right ) +{ + m_gate_left moveto( m_gate_left.origin + ( 22,5 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_gate_right moveto( m_gate_right.origin + ( 22,5 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_gate_left moveto( m_landing_gate_left.origin + ( 22,5 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_gate_right moveto( m_landing_gate_right.origin + ( 22,5 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_gate_right waittill( "movedone" ); +} + +gondola_gate_and_door_moves( n_state, n_side_modifier, m_gate_left, m_door_left, m_gate_right, m_door_right, m_landing_gate_left, m_landing_door_left, m_landing_gate_right, m_landing_door_right ) +{ + m_door_left moveto( m_door_left.origin + ( 24 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_gate_left moveto( m_gate_left.origin + ( 24 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_door_right moveto( m_door_right.origin + ( 24 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_gate_right moveto( m_gate_right.origin + ( 24 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_door_left moveto( m_landing_door_left.origin + ( 24 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_gate_left moveto( m_landing_gate_left.origin + ( 24 * n_side_modifier * n_state, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_door_right moveto( m_landing_door_right.origin + ( 24 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_landing_gate_right moveto( m_landing_gate_right.origin + ( 24 * n_side_modifier * n_state * -1, 0, 0 ), 0,5, 0,05, 0,05 ); + m_gate_right waittill( "movedone" ); +} + +check_for_death_on_gondola( e_gondola ) +{ + self endon( "disconnect" ); + self endon( "afterlife_bleedout" ); + e_gondola endon( "movedone" ); + self waittill( "player_fake_corpse_created" ); + self.e_afterlife_corpse endon( "player_revived" ); + self.e_afterlife_corpse linkto( e_gondola ); +} + +link_corpses_to_gondola( e_gondola ) +{ + e_gondola endon( "movedone" ); + if ( isDefined( self ) ) + { + self linkto( e_gondola ); + } +} + +create_gondola_poi() +{ + a_players = getplayers(); + _a717 = a_players; + _k717 = getFirstArrayKey( _a717 ); + while ( isDefined( _k717 ) ) + { + player = _a717[ _k717 ]; + if ( isDefined( player.is_on_gondola ) && !player.is_on_gondola ) + { + return; + } + _k717 = getNextArrayKey( _a717, _k717 ); + } + s_poi = getstruct( "gondola_poi_" + self.destination, "targetname" ); + e_poi = spawn( "script_origin", s_poi.origin ); + e_poi create_zombie_point_of_interest( 10000, 30, 5000, 1 ); + e_poi thread create_zombie_point_of_interest_attractor_positions(); + self.poi = e_poi; +} + +tear_down_gondola_poi() +{ + if ( isDefined( self.poi ) ) + { + remove_poi_attractor( self.poi ); + self.poi delete(); + } +} + +gondola_chain_fx_anim() +{ + m_chains = self.fxanim_chains; + m_chains useanimtree( -1 ); + n_start_time = getanimlength( level.gondola_chains_fxanims[ "gondola_chains_start" ] ); + n_idle_time = getanimlength( level.gondola_chains_fxanims[ "gondola_chains_idle" ] ); + m_chains setanim( level.gondola_chains_fxanims[ "gondola_chains_start" ], 1, 0,1, 1 ); + wait n_start_time; + m_chains setanim( level.gondola_chains_fxanims[ "gondola_chains_idle" ], 1, 0,1, 1 ); + while ( flag( "gondola_in_motion" ) ) + { + wait n_idle_time; + } + m_chains setanim( level.gondola_chains_fxanims[ "gondola_chains_end" ], 1, 0,1, 1 ); +} + +gondola_physics_explosion( n_move_time ) +{ + self endon( "movedone" ); + i = 0; + while ( i < 2 ) + { + physicsexplosionsphere( self.origin, 1000, 0,1, 0,1 ); + wait ( n_move_time / 2 ); + i++; + } +} + +gondola_cooldown() +{ + a_t_call = getentarray( "gondola_call_trigger", "targetname" ); + _a785 = a_t_call; + _k785 = getFirstArrayKey( _a785 ); + while ( isDefined( _k785 ) ) + { + trigger = _a785[ _k785 ]; + trigger sethintstring( &"ZM_PRISON_GONDOLA_COOLDOWN" ); + _k785 = getNextArrayKey( _a785, _k785 ); + } + a_t_move = getentarray( "gondola_move_trigger", "targetname" ); + _a792 = a_t_move; + _k792 = getFirstArrayKey( _a792 ); + while ( isDefined( _k792 ) ) + { + trigger = _a792[ _k792 ]; + trigger sethintstring( &"ZM_PRISON_GONDOLA_COOLDOWN" ); + _k792 = getNextArrayKey( _a792, _k792 ); + } + wait 10; + gondola_lights_green(); +} + +gondola_moving_vo() +{ + if ( isDefined( level.custom_gondola_moving_vo_func ) ) + { + self thread [[ level.custom_gondola_moving_vo_func ]](); + return; + } + a_players = array_players_on_gondola(); + if ( a_players.size > 0 ) + { + a_players = array_randomize( a_players ); + a_players[ 0 ] thread do_player_general_vox( "general", "use_gondola" ); + } +} + +hint_string( string, cost ) +{ + if ( isDefined( cost ) ) + { + self sethintstring( string, cost ); + } + else + { + self sethintstring( string ); + } + self setcursorhint( "HINT_NOICON" ); +} + +gondola_lights_red() +{ + a_m_gondola_lights = getentarray( "gondola_state_light", "targetname" ); + _a845 = a_m_gondola_lights; + _k845 = getFirstArrayKey( _a845 ); + while ( isDefined( _k845 ) ) + { + model = _a845[ _k845 ]; + model setmodel( "p6_zm_al_gondola_frame_light_red" ); + wait_network_frame(); + _k845 = getNextArrayKey( _a845, _k845 ); + } +} + +gondola_lights_green() +{ + a_m_gondola_lights = getentarray( "gondola_state_light", "targetname" ); + _a857 = a_m_gondola_lights; + _k857 = getFirstArrayKey( _a857 ); + while ( isDefined( _k857 ) ) + { + model = _a857[ _k857 ]; + model setmodel( "p6_zm_al_gondola_frame_light_green" ); + wait_network_frame(); + _k857 = getNextArrayKey( _a857, _k857 ); + } +} + +is_player_on_gondola() +{ + if ( isplayer( self ) ) + { + if ( self istouching( level.e_gondola.t_ride ) ) + { + return 1; + } + else + { + return 0; + } + } +} + +array_players_on_gondola() +{ + a_players_on_gondola = []; + a_players = getplayers(); + _a885 = a_players; + _k885 = getFirstArrayKey( _a885 ); + while ( isDefined( _k885 ) ) + { + player = _a885[ _k885 ]; + if ( player is_player_on_gondola() ) + { + a_players_on_gondola[ a_players_on_gondola.size ] = player; + } + _k885 = getNextArrayKey( _a885, _k885 ); + } + return a_players_on_gondola; +} + +init_gondola_chains_animtree() +{ + scriptmodelsuseanimtree( -1 ); +} + +gondola_hostmigration() +{ + level endon( "end_game" ); + level notify( "gondola_hostmigration" ); + level endon( "gondola_hostmigration" ); + while ( 1 ) + { + level waittill( "host_migration_begin" ); + level.hm_link_origins = []; + a_players = getplayers(); + _a915 = a_players; + _k915 = getFirstArrayKey( _a915 ); + while ( isDefined( _k915 ) ) + { + player = _a915[ _k915 ]; + player thread link_player_to_gondola(); + _k915 = getNextArrayKey( _a915, _k915 ); + } + level waittill( "host_migration_end" ); + a_players = getplayers(); + _a923 = a_players; + _k923 = getFirstArrayKey( _a923 ); + while ( isDefined( _k923 ) ) + { + player = _a923[ _k923 ]; + player unlink(); + _k923 = getNextArrayKey( _a923, _k923 ); + } + _a928 = level.hm_link_origins; + _k928 = getFirstArrayKey( _a928 ); + while ( isDefined( _k928 ) ) + { + e_origin = _a928[ _k928 ]; + e_origin delete(); + _k928 = getNextArrayKey( _a928, _k928 ); + } + if ( isDefined( level.e_gondola.is_moving ) && !level.e_gondola.is_moving ) + { + if ( level.e_gondola.location == "roof" ) + { + top_node_r = getnode( "nd_gond_top_r", "targetname" ); + top_node_r node_add_connection( getnode( "nd_on_top_r", "targetname" ) ); + break; + } + else + { + bottom_node_r = getnode( "nd_gond_bottom_r", "targetname" ); + bottom_node_r node_add_connection( getnode( "nd_on_bottom_r", "targetname" ) ); + } + } + } +} + +link_player_to_gondola() +{ + self endon( "death" ); + self endon( "disconnect" ); + if ( !isDefined( self ) ) + { + return; + } + if ( self is_player_on_gondola() ) + { + e_origin = spawn( "script_origin", self.origin ); + e_origin.angles = self.angles; + level.hm_link_origins[ level.hm_link_origins.size ] = e_origin; + e_origin linkto( level.e_gondola ); + self playerlinkto( e_origin ); + } +} + +node_add_connection( nd_node ) +{ + if ( !nodesarelinked( self, nd_node ) ) + { + if ( !isDefined( self.a_node_path_connections ) ) + { + self.a_node_path_connections = []; + } + link_nodes( self, nd_node ); + link_nodes( nd_node, self ); + self.a_node_path_connections[ self.a_node_path_connections.size ] = nd_node; + } +} + +node_disconnect_from_path() +{ + while ( isDefined( self.a_node_path_connections ) ) + { + i = 0; + while ( i < self.a_node_path_connections.size ) + { + nd_node = self.a_node_path_connections[ i ]; + unlink_nodes( self, nd_node ); + unlink_nodes( nd_node, self ); + i++; + } + } + self.a_node_path_connections = undefined; +} + +check_when_gondola_moves_if_groundent_is_undefined( e_gondola ) +{ + wait 1; + a_zombies = getaiarray( level.zombie_team ); + a_zombies = get_array_of_closest( e_gondola.origin, a_zombies ); + i = 0; + while ( i < a_zombies.size ) + { + if ( distancesquared( e_gondola.origin, a_zombies[ i ].origin ) < 90000 ) + { + ground_ent = a_zombies[ i ] getgroundent(); + if ( !isDefined( ground_ent ) ) + { + a_zombies[ i ] dodamage( a_zombies[ i ].health + 1000, a_zombies[ i ].origin ); + } + } + i++; + } +} + +get_gondola_doors_and_gates() +{ + if ( isDefined( level.e_gondola ) ) + { + a_doors_gates = []; + a_doors_gates[ 0 ] = level.e_gondola.door_roof_left; + a_doors_gates[ 1 ] = level.e_gondola.door_roof_right; + a_doors_gates[ 2 ] = level.e_gondola.door_docks_left; + a_doors_gates[ 3 ] = level.e_gondola.door_docks_right; + a_doors_gates[ 4 ] = level.e_gondola.gate_roof_left; + a_doors_gates[ 5 ] = level.e_gondola.gate_roof_right; + a_doors_gates[ 6 ] = level.e_gondola.gate_docks_left; + a_doors_gates[ 7 ] = level.e_gondola.gate_docks_right; + a_doors_gates[ 8 ] = level.e_gondola.landing_door_roof_left; + a_doors_gates[ 9 ] = level.e_gondola.landing_door_roof_right; + a_doors_gates[ 10 ] = level.e_gondola.landing_door_docks_left; + a_doors_gates[ 11 ] = level.e_gondola.landing_door_docks_right; + a_doors_gates[ 12 ] = level.e_gondola.landing_gate_roof_left; + a_doors_gates[ 13 ] = level.e_gondola.landing_gate_roof_right; + a_doors_gates[ 14 ] = level.e_gondola.landing_gate_docks_left; + a_doors_gates[ 15 ] = level.e_gondola.landing_gate_docks_right; + return a_doors_gates; + } +} + +zombie_alcatraz_player_intersection_tracker_override( other_player ) +{ + if ( isDefined( self.afterlife_revived ) || self.afterlife_revived && isDefined( other_player.afterlife_revived ) && other_player.afterlife_revived ) + { + return 1; + } + if ( isDefined( self.is_on_gondola ) && self.is_on_gondola && isDefined( level.e_gondola.is_moving ) && level.e_gondola.is_moving ) + { + return 1; + } + if ( isDefined( other_player.is_on_gondola ) && other_player.is_on_gondola && isDefined( level.e_gondola.is_moving ) && level.e_gondola.is_moving ) + { + return 1; + } + return 0; +} + +player_escaped_gondola_failsafe() +{ + a_players = getplayers(); + _a1074 = a_players; + _k1074 = getFirstArrayKey( _a1074 ); + while ( isDefined( _k1074 ) ) + { + player = _a1074[ _k1074 ]; + while ( isDefined( player.is_on_gondola ) && player.is_on_gondola ) + { + while ( !player is_player_on_gondola() ) + { + if ( isDefined( player.afterlife ) && !player.afterlife && isalive( player ) ) + { + a_s_orgs = getstructarray( "gondola_dropped_parts_" + level.e_gondola.destination, "targetname" ); + _a1084 = a_s_orgs; + _k1084 = getFirstArrayKey( _a1084 ); + while ( isDefined( _k1084 ) ) + { + struct = _a1084[ _k1084 ]; + if ( !positionwouldtelefrag( struct.origin ) ) + { + player setorigin( struct.origin ); + break; + } + else + { + _k1084 = getNextArrayKey( _a1084, _k1084 ); + } + } + } + } + } + _k1074 = getNextArrayKey( _a1074, _k1074 ); + } +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_utility.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_utility.gsc new file mode 100644 index 0000000..7bf5550 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_utility.gsc @@ -0,0 +1,1346 @@ +#include maps/mp/zm_alcatraz_weap_quest; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +#using_animtree( "fxanim_props" ); + +include_craftable( craftable_struct ) +{ +/# + println( "ZM >> include_craftable = " + craftable_struct.name ); +#/ + maps/mp/zombies/_zm_craftables::include_zombie_craftable( craftable_struct ); +} + +is_craftable() +{ + return self maps/mp/zombies/_zm_craftables::is_craftable(); +} + +is_part_crafted( craftable_name, part_modelname ) +{ + return maps/mp/zombies/_zm_craftables::is_part_crafted( craftable_name, part_modelname ); +} + +wait_for_craftable( craftable_name ) +{ + level waittill( craftable_name + "_crafted", player ); + return player; +} + +is_team_on_golden_gate_bridge() +{ + players = getplayers(); + e_zone = getent( "zone_golden_gate_bridge", "targetname" ); + _a57 = players; + _k57 = getFirstArrayKey( _a57 ); + while ( isDefined( _k57 ) ) + { + player = _a57[ _k57 ]; + if ( player istouching( e_zone ) ) + { + } + else return 0; + _k57 = getNextArrayKey( _a57, _k57 ); + } + return 1; +} + +create_tutorial_message( str_msg ) +{ + if ( !isDefined( self.client_hint ) ) + { + self.client_hint = newclienthudelem( self ); + self.client_hint.alignx = "center"; + self.client_hint.aligny = "middle"; + self.client_hint.horzalign = "center"; + self.client_hint.vertalign = "bottom"; + if ( self issplitscreen() ) + { + self.client_hint.y = -140; + } + else + { + self.client_hint.y = -250; + } + self.client_hint.foreground = 1; + self.client_hint.font = "default"; + self.client_hint.fontscale = 1,5; + self.client_hint.alpha = 1; + self.client_hint.foreground = 1; + self.client_hint.hidewheninmenu = 1; + self.client_hint.color = ( 1, 1, 1 ); + } + self.client_hint settext( str_msg ); +} + +destroy_tutorial_message() +{ + if ( isDefined( self.client_hint ) ) + { + self.client_hint fadeovertime( 0,5 ); + self.client_hint.alpha = 0; + wait 0,5; + if ( isDefined( self.client_hint ) ) + { + self.client_hint destroy(); + self.client_hint = undefined; + } + } +} + +get_array_of_farthest( org, array, excluders, max ) +{ + sorted_array = get_array_of_closest( org, array, excluders ); + if ( isDefined( max ) ) + { + temp_array = []; + i = 0; + while ( i < sorted_array.size ) + { + temp_array[ temp_array.size ] = sorted_array[ sorted_array.size - i ]; + i++; + } + sorted_array = temp_array; + } + sorted_array = array_reverse( sorted_array ); + return sorted_array; +} + +drop_all_barriers() +{ + zkeys = getarraykeys( level.zones ); + z = 0; + while ( z < level.zones.size ) + { + while ( zkeys[ z ] != "zone_start" && zkeys[ z ] != "zone_library" ) + { + zbarriers = get_all_zone_zbarriers( zkeys[ z ] ); + if ( !isDefined( zbarriers ) ) + { + z++; + continue; + } + else + { + _a155 = zbarriers; + _k155 = getFirstArrayKey( _a155 ); + while ( isDefined( _k155 ) ) + { + zbarrier = _a155[ _k155 ]; + zbarrier_pieces = zbarrier getnumzbarrierpieces(); + i = 0; + while ( i < zbarrier_pieces ) + { + zbarrier hidezbarrierpiece( i ); + zbarrier setzbarrierpiecestate( i, "open" ); + i++; + } + wait 0,05; + _k155 = getNextArrayKey( _a155, _k155 ); + } + } + } + z++; + } +} + +get_all_zone_zbarriers( zone_name ) +{ + if ( !isDefined( zone_name ) ) + { + return undefined; + } + zone = level.zones[ zone_name ]; + return zone.zbarriers; +} + +blundergat_change_hintstring( hint_string ) +{ + self notify( "new_change_hint_string" ); + self endon( "new_change_hint_string" ); + while ( isDefined( self.is_locked ) && self.is_locked ) + { + wait 0,05; + } + self sethintstring( hint_string ); + wait 0,05; + self sethintstring( hint_string ); +} + +blundergat_upgrade_station() +{ + t_upgrade = getent( "blundergat_upgrade", "targetname" ); + t_upgrade sethintstring( &"ZM_PRISON_CONVERT_START" ); + waittill_crafted( "packasplat" ); + m_converter = t_upgrade.m_upgrade_machine; + v_angles = m_converter gettagangles( "tag_origin" ); + v_weapon_origin_offset = ( ( anglesToForward( v_angles ) * 1 ) + ( anglesToRight( v_angles ) * 10 ) ) + ( anglesToUp( v_angles ) * 1,75 ); + v_weapon_angles_offset = ( 0, 90, -90 ); + m_converter.v_weapon_origin = m_converter gettagorigin( "tag_origin" ) + v_weapon_origin_offset; + m_converter.v_weapon_angles = v_angles + v_weapon_angles_offset; + m_converter useanimtree( -1 ); + m_converter.fxanims[ "close" ] = %fxanim_zom_al_packasplat_start_anim; + m_converter.fxanims[ "inject" ] = %fxanim_zom_al_packasplat_idle_anim; + m_converter.fxanims[ "open" ] = %fxanim_zom_al_packasplat_end_anim; + m_converter.n_start_time = getanimlength( m_converter.fxanims[ "close" ] ); + m_converter.n_idle_time = getanimlength( m_converter.fxanims[ "inject" ] ); + m_converter.n_end_time = getanimlength( m_converter.fxanims[ "open" ] ); + while ( 1 ) + { + t_upgrade thread blundergat_change_hintstring( &"ZM_PRISON_CONVERT_START" ); + t_upgrade waittill( "trigger", player ); + while ( isDefined( level.custom_craftable_validation ) ) + { + valid = t_upgrade [[ level.custom_craftable_validation ]]( player ); + while ( !valid ) + { + continue; + } + } + str_valid_weapon = undefined; + if ( player hasweapon( "blundergat_zm" ) ) + { + str_valid_weapon = "blundergat_zm"; + } + else + { + if ( player hasweapon( "blundergat_upgraded_zm" ) ) + { + str_valid_weapon = "blundergat_upgraded_zm"; + } + } + if ( isDefined( str_valid_weapon ) ) + { + player takeweapon( str_valid_weapon ); + player.is_pack_splatting = 1; + t_upgrade setinvisibletoall(); + m_converter.worldgun = spawn_weapon_model( str_valid_weapon, undefined, m_converter.v_weapon_origin, m_converter.v_weapon_angles ); + m_converter blundergat_upgrade_station_inject( str_valid_weapon ); + t_upgrade thread blundergat_change_hintstring( &"ZM_PRISON_CONVERT_PICKUP" ); + if ( isDefined( player ) ) + { + t_upgrade setvisibletoplayer( player ); + t_upgrade thread wait_for_player_to_take( player, str_valid_weapon ); + } + t_upgrade thread wait_for_timeout(); + t_upgrade waittill_any( "acid_timeout", "acid_taken" ); + if ( isDefined( player ) ) + { + player.is_pack_splatting = undefined; + } + m_converter.worldgun delete(); + wait 0,5; + t_upgrade setvisibletoall(); + continue; + } + else + { + t_upgrade thread blundergat_change_hintstring( &"ZM_PRISON_MISSING_BLUNDERGAT" ); + wait 2; + } + } +} + +wait_for_player_to_take( player, str_valid_weapon ) +{ + self endon( "acid_timeout" ); + player endon( "disconnect" ); + while ( 1 ) + { + self waittill( "trigger", trigger_player ); + while ( isDefined( level.custom_craftable_validation ) ) + { + valid = self [[ level.custom_craftable_validation ]]( player ); + while ( !valid ) + { + continue; + } + } + if ( trigger_player == player ) + { + current_weapon = player getcurrentweapon(); + if ( is_player_valid( player ) && player.is_drinking > 0 && !is_placeable_mine( current_weapon ) && !is_equipment( current_weapon ) && level.revive_tool != current_weapon && current_weapon != "none" && !player hacker_active() ) + { + self notify( "acid_taken" ); + player notify( "acid_taken" ); + weapon_limit = 2; + primaries = player getweaponslistprimaries(); + if ( isDefined( primaries ) && primaries.size >= weapon_limit ) + { + player takeweapon( current_weapon ); + } + str_new_weapon = undefined; + if ( str_valid_weapon == "blundergat_zm" ) + { + str_new_weapon = "blundersplat_zm"; + } + else + { + str_new_weapon = "blundersplat_upgraded_zm"; + } + if ( player hasweapon( "blundersplat_zm" ) ) + { + player givemaxammo( "blundersplat_zm" ); + } + else if ( player hasweapon( "blundersplat_upgraded_zm" ) ) + { + player givemaxammo( "blundersplat_upgraded_zm" ); + } + else + { + player giveweapon( str_new_weapon ); + player switchtoweapon( str_new_weapon ); + } + player thread do_player_general_vox( "general", "player_recieves_blundersplat" ); + player notify( "player_obtained_acidgat" ); + player thread player_lost_blundersplat_watcher(); + return; + } + } + } +} + +wait_for_timeout() +{ + self endon( "acid_taken" ); + wait 15; + self notify( "acid_timeout" ); +} + +blundergat_upgrade_station_inject( str_weapon_model ) +{ + wait 0,5; + self playsound( "zmb_acidgat_upgrade_machine" ); + self setanim( self.fxanims[ "close" ], 1, 0, 1 ); + wait self.n_start_time; + i = 0; + while ( i < 3 ) + { + self setanim( self.fxanims[ "inject" ], 1, 0, 1 ); + wait self.n_idle_time; + i++; + } + self.worldgun delete(); + if ( str_weapon_model == "blundergat_zm" ) + { + self.worldgun = spawn_weapon_model( "blundersplat_zm", undefined, self.v_weapon_origin, self.v_weapon_angles ); + } + else + { + self.worldgun = spawn_weapon_model( "blundersplat_upgraded_zm", undefined, self.v_weapon_origin, self.v_weapon_angles ); + } + self setanim( self.fxanims[ "open" ], 1, 0, 1 ); + wait self.n_end_time; + wait 0,5; +} + +player_lost_blundersplat_watcher() +{ + while ( isDefined( self ) ) + { + if ( isalive( self ) ) + { + primaries = self getweaponslistprimaries(); + if ( !isinarray( primaries, "blundersplat_zm" ) && !isinarray( primaries, "blundersplat_upgraded_zm" ) ) + { + if ( isDefined( self.afterlife ) && !self.afterlife ) + { + return; + } + } + } + else + { + wait 1; + } + } +} + +player_lightning_manager() +{ + self endon( "disconnect" ); + self.b_lightning = 0; + a_bad_zones[ 0 ] = "zone_dryer"; + a_bad_zones[ 1 ] = "zone_studio"; + a_bad_zones[ 2 ] = "zone_citadel_stairs"; + a_bad_zones[ 3 ] = "cellblock_shower"; + a_bad_zones[ 4 ] = "zone_citadel"; + a_bad_zones[ 5 ] = "zone_infirmary"; + a_bad_zones[ 6 ] = "zone_infirmary_roof"; + a_bad_zones[ 7 ] = "zone_citadel_shower"; + while ( 1 ) + { + str_player_zone = self get_player_zone(); + while ( !isDefined( str_player_zone ) ) + { + wait 1; + } + if ( isDefined( level.hostmigrationtimer ) ) + { + level waittill( "host_migration_end" ); + self.b_lightning = 0; + self setclientfieldtoplayer( "toggle_lightning", 0 ); + wait 1; + } + while ( isDefined( self.afterlife ) || self.afterlife && isDefined( self.scary_lightning ) && self.scary_lightning ) + { + self.b_lightning = 0; + self setclientfieldtoplayer( "toggle_lightning", 0 ); + while ( isDefined( self.afterlife ) || self.afterlife && isDefined( self.scary_lightning ) && self.scary_lightning ) + { + wait 0,05; + } + } + if ( isDefined( self.b_lightning ) && self.b_lightning ) + { + _a496 = a_bad_zones; + _k496 = getFirstArrayKey( _a496 ); + while ( isDefined( _k496 ) ) + { + str_bad_zone = _a496[ _k496 ]; + if ( str_player_zone == str_bad_zone ) + { + self.b_lightning = 0; + self setclientfieldtoplayer( "toggle_lightning", 0 ); + break; + } + else + { + _k496 = getNextArrayKey( _a496, _k496 ); + } + } + } + else self.b_lightning = 1; + _a512 = a_bad_zones; + _k512 = getFirstArrayKey( _a512 ); + while ( isDefined( _k512 ) ) + { + str_bad_zone = _a512[ _k512 ]; + if ( str_player_zone == str_bad_zone ) + { + self.b_lightning = 0; + } + _k512 = getNextArrayKey( _a512, _k512 ); + } + if ( isDefined( self.b_lightning ) && self.b_lightning ) + { + self setclientfieldtoplayer( "toggle_lightning", 1 ); + } + wait 1; + } +} + +setting_tutorial_hud() +{ + client_hint = newclienthudelem( self ); + client_hint.x = 320; + client_hint.y = 220; + client_hint.alignx = "center"; + client_hint.aligny = "bottom"; + client_hint.fontscale = 1,6; + client_hint.alpha = 1; + client_hint.sort = 20; + return client_hint; +} + +riotshield_tutorial_hint() +{ + self waittill( "alcatraz_shield_zm_given" ); + wait 4; + hud = setting_tutorial_hud(); + hud settext( &"ZM_PRISON_RIOTSHIELD_ATTACK" ); + self waittill_notify_or_timeout( "shield_attack", 3 ); + hud settext( &"ZM_PRISON_RIOTSHIELD_DEPLOY" ); + self waittill_notify_or_timeout( "shield_attack", 3 ); + hud destroy(); +} + +check_solo_status() +{ + if ( getnumexpectedplayers() == 1 || !sessionmodeisonlinegame() && !sessionmodeisprivate() ) + { + level.is_forever_solo_game = 1; + } + else + { + level.is_forever_solo_game = 0; + } +} + +disable_powerup_if_player_on_bridge() +{ + self endon( "disconnect" ); + flag_wait( "afterlife_start_over" ); + while ( 1 ) + { + if ( self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) ) + { + if ( flag( "zombie_drop_powerups" ) ) + { + flag_clear( "zombie_drop_powerups" ); + } + } + wait 1; + } +} + +enable_powerup_if_no_player_on_bridge() +{ + flag_wait( "afterlife_start_over" ); + while ( 1 ) + { + n_player_total = 0; + n_player_total += get_players_in_zone( "zone_golden_gate_bridge" ); + if ( n_player_total == 0 && !flag( "zombie_drop_powerups" ) ) + { + flag_set( "zombie_drop_powerups" ); + } + wait 1; + } +} + +init_level_specific_audio() +{ + level.oh_shit_vo_cooldown = 0; + level.wolf_kill_vo_cooldown = 0; + level.wallbuys_purchased = 0; + setdvar( "zombie_kills", "5" ); + setdvar( "zombie_kill_timer", "5" ); + if ( is_classic() ) + { + level._audio_custom_response_line = ::alcatraz_audio_custom_response_line; + level.audio_get_mod_type = ::alcatraz_audio_get_mod_type_override; + level.custom_kill_damaged_vo = ::maps/mp/zombies/_zm_audio::custom_kill_damaged_vo; + level._custom_zombie_oh_shit_vox_func = ::alcatraz_custom_zombie_oh_shit_vox; + level.gib_on_damage = ::alcatraz_custom_crawler_spawned_vo; + level thread alcatraz_first_magic_box_seen_vo(); + level._audio_custom_weapon_check = ::alcatraz_audio_custom_weapon_check; + level thread brutus_spawn_vo_watcher(); + level thread brutus_killed_vo_watcher(); + } + level thread setup_conversation_vo(); + alcatraz_add_player_dialogue( "player", "general", "no_money_weapon", "nomoney_generic", undefined ); + alcatraz_add_player_dialogue( "player", "general", "no_money_box", "nomoney_generic", undefined ); + alcatraz_add_player_dialogue( "player", "general", "perk_deny", "nomoney_generic", undefined ); + alcatraz_add_player_dialogue( "player", "perk", "specialty_armorvest", "perk_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "perk", "specialty_fastreload", "perk_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "perk", "specialty_rof", "perk_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "perk", "specialty_deadshot", "perk_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "perk", "specialty_grenadepulldeath", "perk_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "closekill", "kill_close", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "damage", "kill_damaged", undefined, 50 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot", "kill_headshot", "resp_kill_headshot", 25 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_0", "headshot_respond_to_plr_0", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_1", "headshot_respond_to_plr_1", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_2", "headshot_respond_to_plr_2", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_to_plr_3", "headshot_respond_to_plr_3", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "headshot_respond_generic", "headshot_respond_generic", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "kill", "retriever", "kill_retriever", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "redeemer", "kill_redeemer", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "blundergat", "kill_blundergat", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "acidgat", "kill_acidgat", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "death_machine", "kill_death_machine", undefined, 15 ); + alcatraz_add_player_dialogue( "player", "kill", "wolf_kill", "wolf_kill", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "achievement", "earn_acheivement", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "revive_up", "heal_revived", "revive_player", 100 ); + alcatraz_add_player_dialogue( "player", "general", "revive_player", "revive_player", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "exert_sigh", "exert_sigh", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "exert_laugh", "exert_laugh", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "pain_high", "pain_high", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_pickup", "build_pickup", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_swap", "build_swap", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_add", "build_add", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_final", "build_final", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_bsm_pickup", "build_bsm_pickup", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_bsm_final", "build_bsm_final", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "player_recieves_blundersplat", "build_bsm_plc", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_zs_pickup", "build_zs_pickup", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_zs_final", "build_zs_final", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "build_zs_plc", "build_zs_plc", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "reboard", "rebuild_boards", undefined, 50 ); + alcatraz_add_player_dialogue( "player", "general", "discover_box", "discover_box", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "discover_wall_buy", "discover_wall_buy", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "generic_wall_buy", "generic_wall_buy", undefined, 25 ); + alcatraz_add_player_dialogue( "player", "general", "wpck_pap", "wpck_pap", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "portal_clue", "portal_clue", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "killswitch_clue", "killswitch_clue", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "power_off", "power_off", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "power_on", "power_on", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "electric_zap", "electric_zap", undefined, 25 ); + alcatraz_add_player_dialogue( "player", "general", "need_electricity", "need_electricity", undefined, 25 ); + alcatraz_add_player_dialogue( "player", "general", "use_gondola", "use_gondola", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "discover_trap", "discover_trap", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "start_trap", "start_trap", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_0", "surrounded_respond_to_plr_0", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_1", "surrounded_respond_to_plr_1", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_2", "surrounded_respond_to_plr_2", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "surrounded_respond_to_plr_3", "surrounded_respond_to_plr_3", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "wolf_complete", "wolf_complete", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "wolf_final", "wolf_final", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "wolf_encounter", "wolf_encounter", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "brutus_encounter", "brutus_encounter", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "brutus_arrival", "brutus_arrival", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "brutus_reaction", "brutus_reaction", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "general", "brutus_defeated", "brutus_defeated", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "find_map", "find_map", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "response_map", "response_map", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_key", "sidequest_key", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_key_response", "sidequest_key_response", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_sheets", "sidequest_sheets", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_valves", "sidequest_valves", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_engine", "sidequest_engine", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_rigging", "sidequest_rigging", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_oxygen", "sidequest_oxygen", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts1_prog", "sidequest_parts1_prog", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts2_prog", "sidequest_parts2_prog", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts3_prog", "sidequest_parts3_prog", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_parts4_prog", "sidequest_parts4_prog", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_all_parts", "sidequest_all_parts", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "sidequest_roof_nag", "sidequest_roof_nag", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "build_plane", "build_plane", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "plane_takeoff", "plane_takeoff", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "plane_flight", "plane_flight", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "plane_crash", "plane_crash", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "free_fall", "free_fall", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "zombie_arrive_gg", "zombie_arrive_gg", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "chair_electrocution", "chair_electrocution", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "fuel_pickup", "fuel_pickup", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "start_2", "start_2", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "pick_up_easter_egg", "pick_up_egg", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "secret_poster", "secret_poster", undefined, 100 ); + alcatraz_add_player_dialogue( "player", "quest", "find_secret", "find_secret", undefined, 100 ); +} + +alcatraz_add_player_dialogue( speaker, category, type, alias, response, chance ) +{ + level.vox zmbvoxadd( speaker, category, type, alias, response ); + if ( isDefined( chance ) ) + { + add_vox_response_chance( type, chance ); + } +} + +alcatraz_audio_get_mod_type_override( impact, mod, weapon, zombie, instakill, dist, player ) +{ + close_dist = 4096; + med_dist = 15376; + far_dist = 75625; + a_str_mod = []; + if ( isDefined( zombie.my_soul_catcher ) ) + { + if ( isDefined( zombie.my_soul_catcher.wolf_kill_cooldown ) && !zombie.my_soul_catcher.wolf_kill_cooldown ) + { + if ( isDefined( player.soul_catcher_cooldown ) && !player.soul_catcher_cooldown ) + { + if ( isDefined( zombie.my_soul_catcher.souls_received ) && zombie.my_soul_catcher.souls_received > 0 ) + { + a_str_mod[ a_str_mod.size ] = "wolf_kill"; + } + else + { + if ( isDefined( zombie.my_soul_catcher.souls_received ) && zombie.my_soul_catcher.souls_received == 0 ) + { + if ( isDefined( level.wolf_encounter_vo_played ) && !level.wolf_encounter_vo_played ) + { + if ( level.soul_catchers_charged == 0 ) + { + zombie.my_soul_catcher thread maps/mp/zm_alcatraz_weap_quest::first_wolf_encounter_vo(); + } + } + } + } + } + } + } + if ( weapon == "blundergat_zm" || weapon == "blundergat_upgraded_zm" ) + { + a_str_mod[ a_str_mod.size ] = "blundergat"; + } + if ( isDefined( zombie.damageweapon ) && zombie.damageweapon == "blundersplat_explosive_dart_zm" ) + { + a_str_mod[ a_str_mod.size ] = "acidgat"; + } + if ( isDefined( zombie.damageweapon ) && zombie.damageweapon == "bouncing_tomahawk_zm" ) + { + a_str_mod[ a_str_mod.size ] = "retriever"; + } + if ( isDefined( zombie.damageweapon ) && zombie.damageweapon == "upgraded_tomahawk_zm" ) + { + a_str_mod[ a_str_mod.size ] = "redeemer"; + } + if ( weapon == "minigun_alcatraz_zm" || weapon == "minigun_alcatraz_upgraded_zm" ) + { + a_str_mod[ a_str_mod.size ] = "death_machine"; + } + if ( is_headshot( weapon, impact, mod ) && dist >= far_dist ) + { + a_str_mod[ a_str_mod.size ] = "headshot"; + } + if ( is_explosive_damage( mod ) && weapon != "ray_gun_zm" && weapon != "ray_gun_upgraded_zm" && isDefined( zombie.is_on_fire ) && !zombie.is_on_fire ) + { + if ( !isinarray( a_str_mod, "retriever" ) && !isinarray( a_str_mod, "redeemer" ) ) + { + if ( !instakill ) + { + a_str_mod[ a_str_mod.size ] = "explosive"; + } + else + { + a_str_mod[ a_str_mod.size ] = "weapon_instakill"; + } + } + } + if ( weapon == "ray_gun_zm" || weapon == "ray_gun_upgraded_zm" ) + { + if ( dist > far_dist ) + { + if ( !instakill ) + { + a_str_mod[ a_str_mod.size ] = "raygun"; + } + else + { + a_str_mod[ a_str_mod.size ] = "weapon_instakill"; + } + } + } + if ( instakill ) + { + if ( mod == "MOD_MELEE" ) + { + a_str_mod[ a_str_mod.size ] = "melee_instakill"; + } + else + { + a_str_mod[ a_str_mod.size ] = "weapon_instakill"; + } + } + if ( mod != "MOD_MELEE" && !zombie.has_legs ) + { + a_str_mod[ a_str_mod.size ] = "crawler"; + } + if ( mod != "MOD_BURNED" && dist < close_dist ) + { + a_str_mod[ a_str_mod.size ] = "closekill"; + } + if ( a_str_mod.size == 0 ) + { + str_mod_final = "default"; + } + else if ( a_str_mod.size == 1 ) + { + str_mod_final = a_str_mod[ 0 ]; + } + else + { + i = 0; + while ( i < a_str_mod.size ) + { + if ( cointoss() ) + { + str_mod_final = a_str_mod[ i ]; + } + i++; + } + str_mod_final = a_str_mod[ randomint( a_str_mod.size ) ]; + } + if ( str_mod_final == "wolf_kill" ) + { + player thread wolf_kill_cooldown_watcher( zombie.my_soul_catcher ); + } + return str_mod_final; +} + +wolf_kill_cooldown_watcher( soul_catcher ) +{ + self endon( "disconnect" ); + self waittill( "speaking", type ); + if ( type == "wolf_kill" ) + { + self.soul_catcher_cooldown = 1; + soul_catcher thread wolf_kill_cooldown(); + } +} + +wolf_kill_cooldown() +{ + self.wolf_kill_cooldown = 1; + wait 60; + self.wolf_kill_cooldown = 0; +} + +setup_conversation_vo() +{ + level.conscience_vo = []; + level.conscience_vo[ "conscience_Finn_convo_1" ] = []; + level.conscience_vo[ "conscience_Finn_convo_1" ][ 0 ] = "vox_plr_0_finn_self_2_0"; + level.conscience_vo[ "conscience_Finn_convo_1" ][ 1 ] = "vox_plr_0_finn_self_2_1"; + level.conscience_vo[ "conscience_Finn_convo_1" ][ 2 ] = "vox_plr_0_finn_self_2_2"; + level.conscience_vo[ "conscience_Finn_convo_1" ][ 3 ] = "vox_plr_0_finn_self_2_3"; + level.conscience_vo[ "conscience_Finn_convo_1" ][ 4 ] = "vox_plr_0_finn_self_2_4"; + level.conscience_vo[ "conscience_Finn_convo_2" ] = []; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 0 ] = "vox_plr_0_finn_self_3_0"; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 1 ] = "vox_plr_0_finn_self_3_1"; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 2 ] = "vox_plr_0_finn_self_3_2"; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 3 ] = "vox_plr_0_finn_self_3_3"; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 4 ] = "vox_plr_0_finn_self_3_4"; + level.conscience_vo[ "conscience_Finn_convo_2" ][ 5 ] = "vox_plr_0_finn_self_3_5"; + level.conscience_vo[ "conscience_Sal_convo_1" ] = []; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 0 ] = "vox_plr_1_sal_self_2_0"; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 1 ] = "vox_plr_1_sal_self_2_1"; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 2 ] = "vox_plr_1_sal_self_2_2"; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 3 ] = "vox_plr_1_sal_self_2_3"; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 4 ] = "vox_plr_1_sal_self_2_4"; + level.conscience_vo[ "conscience_Sal_convo_1" ][ 5 ] = "vox_plr_1_sal_self_2_5"; + level.conscience_vo[ "conscience_Sal_convo_2" ] = []; + level.conscience_vo[ "conscience_Sal_convo_2" ][ 0 ] = "vox_plr_1_sal_self_3_0"; + level.conscience_vo[ "conscience_Sal_convo_2" ][ 1 ] = "vox_plr_1_sal_self_3_1"; + level.conscience_vo[ "conscience_Sal_convo_2" ][ 2 ] = "vox_plr_1_sal_self_3_2"; + level.conscience_vo[ "conscience_Sal_convo_2" ][ 3 ] = "vox_plr_1_sal_self_3_3"; + level.conscience_vo[ "conscience_Sal_convo_2" ][ 4 ] = "vox_plr_1_sal_self_3_4"; + level.conscience_vo[ "conscience_Billy_convo_1" ] = []; + level.conscience_vo[ "conscience_Billy_convo_1" ][ 0 ] = "vox_plr_2_billy_self_2_0"; + level.conscience_vo[ "conscience_Billy_convo_1" ][ 1 ] = "vox_plr_2_billy_self_2_1"; + level.conscience_vo[ "conscience_Billy_convo_1" ][ 2 ] = "vox_plr_2_billy_self_2_2"; + level.conscience_vo[ "conscience_Billy_convo_1" ][ 3 ] = "vox_plr_2_billy_self_2_3"; + level.conscience_vo[ "conscience_Billy_convo_1" ][ 4 ] = "vox_plr_2_billy_self_2_4"; + level.conscience_vo[ "conscience_Billy_convo_2" ] = []; + level.conscience_vo[ "conscience_Billy_convo_2" ][ 0 ] = "vox_plr_2_billy_self_3_0"; + level.conscience_vo[ "conscience_Billy_convo_2" ][ 1 ] = "vox_plr_2_billy_self_3_1"; + level.conscience_vo[ "conscience_Billy_convo_2" ][ 2 ] = "vox_plr_2_billy_self_3_2"; + level.conscience_vo[ "conscience_Billy_convo_2" ][ 3 ] = "vox_plr_2_billy_self_3_3"; + level.conscience_vo[ "conscience_Billy_convo_2" ][ 4 ] = "vox_plr_2_billy_self_3_4"; + level.conscience_vo[ "conscience_Arlington_convo_1" ] = []; + level.conscience_vo[ "conscience_Arlington_convo_1" ][ 0 ] = "vox_plr_3_arlington_self_2_0"; + level.conscience_vo[ "conscience_Arlington_convo_1" ][ 1 ] = "vox_plr_3_arlington_self_2_2"; + level.conscience_vo[ "conscience_Arlington_convo_1" ][ 2 ] = "vox_plr_3_arlington_self_2_3"; + level.conscience_vo[ "conscience_Arlington_convo_1" ][ 3 ] = "vox_plr_3_arlington_self_2_4"; + level.conscience_vo[ "conscience_Arlington_convo_1" ][ 4 ] = "vox_plr_3_arlington_self_2_5"; + level.conscience_vo[ "conscience_Arlington_convo_2" ] = []; + level.conscience_vo[ "conscience_Arlington_convo_2" ][ 0 ] = "vox_plr_3_arlington_self_3_0"; + level.conscience_vo[ "conscience_Arlington_convo_2" ][ 1 ] = "vox_plr_3_arlington_self_3_1"; + level.conscience_vo[ "conscience_Arlington_convo_2" ][ 2 ] = "vox_plr_3_arlington_self_3_2"; + level.conscience_vo[ "conscience_Arlington_convo_2" ][ 3 ] = "vox_plr_3_arlington_self_3_3"; + level.conscience_vo[ "conscience_Arlington_convo_2" ][ 4 ] = "vox_plr_3_arlington_self_3_4"; +} + +alcatraz_custom_zombie_oh_shit_vox() +{ + self endon( "death_or_disconnect" ); + while ( 1 ) + { + wait 1; + if ( isDefined( self.oh_shit_vo_cooldown ) && self.oh_shit_vo_cooldown ) + { + continue; + } + players = get_players(); + zombs = get_round_enemy_array(); + if ( players.size <= 1 ) + { + n_distance = 250; + n_zombies = 5; + n_chance = 30; + n_cooldown_time = 20; + } + else + { + n_distance = 250; + n_zombies = 5; + n_chance = 30; + n_cooldown_time = 15; + } + close_zombs = 0; + i = 0; + while ( i < zombs.size ) + { + if ( isDefined( zombs[ i ].favoriteenemy ) || zombs[ i ].favoriteenemy == self && !isDefined( zombs[ i ].favoriteenemy ) ) + { + if ( distancesquared( zombs[ i ].origin, self.origin ) < ( n_distance * n_distance ) ) + { + close_zombs++; + } + } + i++; + } + if ( close_zombs >= n_zombies ) + { + if ( randomint( 100 ) < n_chance && isDefined( self.isonbus ) && !self.isonbus ) + { + self maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "oh_shit" ); + self thread global_oh_shit_cooldown_timer( n_cooldown_time ); + wait n_cooldown_time; + } + } + } +} + +global_oh_shit_cooldown_timer( n_cooldown_time ) +{ + self endon( "disconnect" ); + self.oh_shit_vo_cooldown = 1; + wait n_cooldown_time; + self.oh_shit_vo_cooldown = 0; +} + +alcatraz_custom_crawler_spawned_vo() +{ + self endon( "death" ); + if ( isDefined( self.a.gib_ref ) && isalive( self ) ) + { + if ( self.a.gib_ref != "no_legs" || self.a.gib_ref == "right_leg" && self.a.gib_ref == "left_leg" ) + { + if ( isDefined( self.attacker ) && isplayer( self.attacker ) ) + { + if ( isDefined( self.attacker.crawler_created_vo_cooldown ) && self.attacker.crawler_created_vo_cooldown ) + { + return; + } + rand = randomintrange( 0, 100 ); + if ( rand < 15 ) + { + self.attacker maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "crawl_spawn" ); + self.attacker thread crawler_created_vo_cooldown(); + } + } + } + } +} + +crawler_created_vo_cooldown() +{ + self endon( "disconnect" ); + self.crawler_created_vo_cooldown = 1; + wait 30; + self.crawler_created_vo_cooldown = 0; +} + +alcatraz_first_magic_box_seen_vo() +{ + flag_wait( "start_zombie_round_logic" ); + magicbox = level.chests[ level.chest_index ]; + a_players = getplayers(); + _a1155 = a_players; + _k1155 = getFirstArrayKey( _a1155 ); + while ( isDefined( _k1155 ) ) + { + player = _a1155[ _k1155 ]; + player thread wait_and_play_first_magic_box_seen_vo( magicbox.unitrigger_stub ); + _k1155 = getNextArrayKey( _a1155, _k1155 ); + } +} + +wait_and_play_first_magic_box_seen_vo( struct ) +{ + self endon( "disconnect" ); + level endon( "first_maigc_box_discovered" ); + while ( 1 ) + { + if ( distancesquared( self.origin, struct.origin ) < 40000 ) + { + if ( self is_player_looking_at( struct.origin, 0,25 ) ) + { + if ( isDefined( self.dontspeak ) && !self.dontspeak ) + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "discover_box" ); + level notify( "first_maigc_box_discovered" ); + return; + } + } + } + else + { + wait 0,1; + } + } +} + +alcatraz_audio_custom_weapon_check( weapon, magic_box ) +{ + self endon( "death" ); + self endon( "disconnect" ); + if ( isDefined( magic_box ) && magic_box ) + { + type = self maps/mp/zombies/_zm_weapons::weapon_type_check( weapon ); + return type; + } + if ( issubstr( weapon, "upgraded" ) ) + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "wpck_pap" ); + } + else if ( level.wallbuys_purchased == 0 ) + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "discover_wall_buy" ); + level.wallbuys_purchased++; + } + else + { + self thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "generic_wall_buy" ); + } + return "crappy"; +} + +brutus_spawn_vo_watcher() +{ + level.total_brutuses_spawned = 0; + while ( 1 ) + { + level waittill( "brutus_spawned", ai_brutus ); + while ( !isDefined( ai_brutus ) ) + { + continue; + } + if ( isDefined( level.brutus_spawn_vo_cooldown ) && level.brutus_spawn_vo_cooldown ) + { + continue; + } + ai_brutus thread brutus_reaction_vo_watcher(); + ai_brutus thread brutus_helmet_pop_vo_watcher(); + if ( level.total_brutuses_spawned == 0 ) + { + str_vo_category = "brutus_encounter"; + } + else + { + str_vo_category = "brutus_arrival"; + } + wait 3; + while ( !isalive( ai_brutus ) ) + { + continue; + } + a_players = getplayers(); + a_closest = get_array_of_closest( ai_brutus.origin, a_players ); + i = 0; + while ( i < a_closest.size ) + { + if ( isDefined( a_closest[ i ].dontspeak ) && !a_closest[ i ].dontspeak ) + { + if ( isalive( a_closest[ i ] ) && isalive( ai_brutus ) ) + { + a_closest[ i ] thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", str_vo_category ); + level thread brutus_spawn_vo_cooldown(); + } + } + i++; + } + } +} + +brutus_spawn_vo_cooldown() +{ + level.brutus_spawn_vo_cooldown = 1; + wait 30; + level.brutus_spawn_vo_cooldown = 0; +} + +brutus_reaction_vo_watcher() +{ + self endon( "death" ); + level endon( "restart_brutus_reaction_vo_watcher" ); + while ( isalive( self ) ) + { + wait randomfloatrange( 20, 40 ); + a_players = getplayers(); + a_closest = get_array_of_closest( self.origin, a_players ); + i = 0; + while ( i < a_closest.size ) + { + if ( isDefined( a_closest[ i ].dontspeak ) && !a_closest[ i ].dontspeak ) + { + if ( distancesquared( a_closest[ i ].origin, self.origin ) < 1000000 ) + { + a_closest[ i ] thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "brutus_reaction" ); + } + } + i++; + } + } +} + +brutus_helmet_pop_vo_watcher() +{ + self endon( "death" ); + level waittill( "brutus_helmet_removed", player ); + wait 3; + if ( isalive( player ) ) + { + player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "brutus_reaction" ); + } + level notify( "restart_brutus_reaction_vo_watcher" ); + self thread brutus_reaction_vo_watcher(); +} + +brutus_killed_vo_watcher() +{ + while ( 1 ) + { + level waittill( "brutus_killed", player ); + wait 5; + if ( isalive( player ) ) + { + player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "brutus_defeated" ); + } + } +} + +easter_egg_song_vo( player ) +{ + wait 3,5; + if ( isalive( player ) ) + { + player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "quest", "find_secret" ); + } + else + { + while ( 1 ) + { + a_players = getplayers(); + _a1346 = a_players; + _k1346 = getFirstArrayKey( _a1346 ); + while ( isDefined( _k1346 ) ) + { + player = _a1346[ _k1346 ]; + if ( isalive( player ) ) + { + if ( isDefined( player.dontspeak ) && !player.dontspeak ) + { + player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "quest", "find_secret" ); + } + } + _k1346 = getNextArrayKey( _a1346, _k1346 ); + } + } + wait 0,1; + } +} + +player_portal_clue_vo() +{ + self endon( "death" ); + self endon( "disconnect" ); + flag_wait( "afterlife_start_over" ); + wait 1; + while ( 1 ) + { + self waittill( "player_fake_corpse_created" ); + self.e_afterlife_corpse waittill( "player_revived", e_reviver ); + if ( self == e_reviver && !level.someone_has_visited_nml ) + { + wait 3; + self do_player_general_vox( "general", "portal_clue", undefined, 100 ); + return; + } + wait 0,1; + } +} + +setup_personality_character_exerts() +{ + level.exert_sounds[ 1 ][ "burp" ][ 0 ] = "vox_plr_0_exert_burp_0"; + level.exert_sounds[ 1 ][ "burp" ][ 1 ] = "vox_plr_0_exert_burp_1"; + level.exert_sounds[ 1 ][ "burp" ][ 2 ] = "vox_plr_0_exert_burp_2"; + level.exert_sounds[ 1 ][ "burp" ][ 3 ] = "vox_plr_0_exert_burp_3"; + level.exert_sounds[ 1 ][ "burp" ][ 4 ] = "vox_plr_0_exert_burp_4"; + level.exert_sounds[ 1 ][ "burp" ][ 5 ] = "vox_plr_0_exert_burp_5"; + level.exert_sounds[ 1 ][ "burp" ][ 6 ] = "vox_plr_0_exert_burp_6"; + level.exert_sounds[ 2 ][ "burp" ][ 0 ] = "vox_plr_1_exert_burp_0"; + level.exert_sounds[ 2 ][ "burp" ][ 1 ] = "vox_plr_1_exert_burp_1"; + level.exert_sounds[ 2 ][ "burp" ][ 2 ] = "vox_plr_1_exert_burp_2"; + level.exert_sounds[ 2 ][ "burp" ][ 3 ] = "vox_plr_1_exert_burp_3"; + level.exert_sounds[ 3 ][ "burp" ][ 0 ] = "vox_plr_2_exert_burp_0"; + level.exert_sounds[ 3 ][ "burp" ][ 1 ] = "vox_plr_2_exert_burp_1"; + level.exert_sounds[ 3 ][ "burp" ][ 2 ] = "vox_plr_2_exert_burp_2"; + level.exert_sounds[ 3 ][ "burp" ][ 3 ] = "vox_plr_2_exert_burp_3"; + level.exert_sounds[ 3 ][ "burp" ][ 4 ] = "vox_plr_2_exert_burp_4"; + level.exert_sounds[ 3 ][ "burp" ][ 5 ] = "vox_plr_2_exert_burp_5"; + level.exert_sounds[ 3 ][ "burp" ][ 6 ] = "vox_plr_2_exert_burp_6"; + level.exert_sounds[ 4 ][ "burp" ][ 0 ] = "vox_plr_3_exert_burp_0"; + level.exert_sounds[ 4 ][ "burp" ][ 1 ] = "vox_plr_3_exert_burp_1"; + level.exert_sounds[ 4 ][ "burp" ][ 2 ] = "vox_plr_3_exert_burp_2"; + level.exert_sounds[ 4 ][ "burp" ][ 3 ] = "vox_plr_3_exert_burp_3"; + level.exert_sounds[ 4 ][ "burp" ][ 4 ] = "vox_plr_3_exert_burp_4"; + level.exert_sounds[ 4 ][ "burp" ][ 5 ] = "vox_plr_3_exert_burp_5"; + level.exert_sounds[ 4 ][ "burp" ][ 6 ] = "vox_plr_3_exert_burp_6"; + level.exert_sounds[ 1 ][ "hitmed" ][ 0 ] = "vox_plr_0_exert_pain_medium_0"; + level.exert_sounds[ 1 ][ "hitmed" ][ 1 ] = "vox_plr_0_exert_pain_medium_1"; + level.exert_sounds[ 1 ][ "hitmed" ][ 2 ] = "vox_plr_0_exert_pain_medium_2"; + level.exert_sounds[ 1 ][ "hitmed" ][ 3 ] = "vox_plr_0_exert_pain_medium_3"; + level.exert_sounds[ 2 ][ "hitmed" ][ 0 ] = "vox_plr_1_exert_pain_medium_0"; + level.exert_sounds[ 2 ][ "hitmed" ][ 1 ] = "vox_plr_1_exert_pain_medium_1"; + level.exert_sounds[ 2 ][ "hitmed" ][ 2 ] = "vox_plr_1_exert_pain_medium_2"; + level.exert_sounds[ 2 ][ "hitmed" ][ 3 ] = "vox_plr_1_exert_pain_medium_3"; + level.exert_sounds[ 3 ][ "hitmed" ][ 0 ] = "vox_plr_2_exert_pain_medium_0"; + level.exert_sounds[ 3 ][ "hitmed" ][ 1 ] = "vox_plr_2_exert_pain_medium_1"; + level.exert_sounds[ 3 ][ "hitmed" ][ 2 ] = "vox_plr_2_exert_pain_medium_2"; + level.exert_sounds[ 3 ][ "hitmed" ][ 3 ] = "vox_plr_2_exert_pain_medium_3"; + level.exert_sounds[ 4 ][ "hitmed" ][ 0 ] = "vox_plr_3_exert_pain_medium_0"; + level.exert_sounds[ 4 ][ "hitmed" ][ 1 ] = "vox_plr_3_exert_pain_medium_1"; + level.exert_sounds[ 4 ][ "hitmed" ][ 2 ] = "vox_plr_3_exert_pain_medium_2"; + level.exert_sounds[ 4 ][ "hitmed" ][ 3 ] = "vox_plr_3_exert_pain_medium_3"; + level.exert_sounds[ 1 ][ "hitlrg" ][ 0 ] = "vox_plr_0_exert_pain_high_0"; + level.exert_sounds[ 1 ][ "hitlrg" ][ 1 ] = "vox_plr_0_exert_pain_high_1"; + level.exert_sounds[ 1 ][ "hitlrg" ][ 2 ] = "vox_plr_0_exert_pain_high_2"; + level.exert_sounds[ 1 ][ "hitlrg" ][ 3 ] = "vox_plr_0_exert_pain_high_3"; + level.exert_sounds[ 2 ][ "hitlrg" ][ 0 ] = "vox_plr_1_exert_pain_high_0"; + level.exert_sounds[ 2 ][ "hitlrg" ][ 1 ] = "vox_plr_1_exert_pain_high_1"; + level.exert_sounds[ 2 ][ "hitlrg" ][ 2 ] = "vox_plr_1_exert_pain_high_2"; + level.exert_sounds[ 2 ][ "hitlrg" ][ 3 ] = "vox_plr_1_exert_pain_high_3"; + level.exert_sounds[ 3 ][ "hitlrg" ][ 0 ] = "vox_plr_2_exert_pain_high_0"; + level.exert_sounds[ 3 ][ "hitlrg" ][ 1 ] = "vox_plr_2_exert_pain_high_1"; + level.exert_sounds[ 3 ][ "hitlrg" ][ 2 ] = "vox_plr_2_exert_pain_high_2"; + level.exert_sounds[ 3 ][ "hitlrg" ][ 3 ] = "vox_plr_2_exert_pain_high_3"; + level.exert_sounds[ 4 ][ "hitlrg" ][ 0 ] = "vox_plr_3_exert_pain_high_0"; + level.exert_sounds[ 4 ][ "hitlrg" ][ 1 ] = "vox_plr_3_exert_pain_high_1"; + level.exert_sounds[ 4 ][ "hitlrg" ][ 2 ] = "vox_plr_3_exert_pain_high_2"; + level.exert_sounds[ 4 ][ "hitlrg" ][ 3 ] = "vox_plr_3_exert_pain_high_3"; +} + +alcatraz_audio_custom_response_line( player, index, category, type ) +{ + if ( type == "revive_up" ) + { + player thread play_vo_category_on_closest_player( "general", "revive_player" ); + } + else if ( type == "headshot" ) + { + if ( cointoss() ) + { + player thread play_vo_category_on_closest_player( "kill", "headshot_respond_to_plr_" + player.characterindex ); + } + else + { + player thread play_vo_category_on_closest_player( "kill", "headshot_respond_generic" ); + } + } + else + { + if ( type == "oh_shit" ) + { + player thread play_vo_category_on_closest_player( "general", "surrounded_respond_to_plr_" + player.characterindex ); + player thread global_oh_shit_cooldown_timer( 15 ); + } + } +} + +play_vo_category_on_closest_player( category, type ) +{ + a_players = getplayers(); + if ( a_players.size <= 1 ) + { + return; + } + arrayremovevalue( a_players, self ); + a_closest = arraysort( a_players, self.origin, 1 ); + if ( distancesquared( self.origin, a_closest[ 0 ].origin ) <= 250000 ) + { + if ( isalive( a_closest[ 0 ] ) ) + { + a_closest[ 0 ] maps/mp/zombies/_zm_audio::create_and_play_dialog( category, type ); + } + } +} + +check_for_special_weapon_limit_exist( weapon ) +{ + if ( weapon != "blundergat_zm" && weapon != "minigun_alcatraz_zm" ) + { + return 1; + } + players = get_players(); + count = 0; + if ( weapon == "blundergat_zm" ) + { + if ( self maps/mp/zombies/_zm_weapons::has_weapon_or_upgrade( "blundersplat_zm" ) ) + { + return 0; + } + if ( self afterlife_weapon_limit_check( "blundergat_zm" ) ) + { + return 0; + } + limit = level.limited_weapons[ "blundergat_zm" ]; + } + else + { + if ( self afterlife_weapon_limit_check( "minigun_alcatraz_zm" ) ) + { + return 0; + } + limit = level.limited_weapons[ "minigun_alcatraz_zm" ]; + } + i = 0; + while ( i < players.size ) + { + if ( weapon == "blundergat_zm" ) + { + if ( players[ i ] has_weapon_or_upgrade( "blundersplat_zm" ) || isDefined( players[ i ].is_pack_splatting ) && players[ i ].is_pack_splatting ) + { + count++; + i++; + continue; + } + } + else + { + if ( players[ i ] afterlife_weapon_limit_check( weapon ) ) + { + count++; + } + } + i++; + } + if ( count >= limit ) + { + return 0; + } + return 1; +} + +afterlife_weapon_limit_check( limited_weapon ) +{ + while ( isDefined( self.afterlife ) && self.afterlife ) + { + if ( limited_weapon == "blundergat_zm" ) + { + _a1577 = self.loadout; + _k1577 = getFirstArrayKey( _a1577 ); + while ( isDefined( _k1577 ) ) + { + weapon = _a1577[ _k1577 ]; + if ( weapon != "blundergat_zm" && weapon != "blundergat_upgraded_zm" || weapon == "blundersplat_zm" && weapon == "blundersplat_upgraded_zm" ) + { + return 1; + } + _k1577 = getNextArrayKey( _a1577, _k1577 ); + } + } + else while ( limited_weapon == "minigun_alcatraz_zm" ) + { + _a1587 = self.loadout; + _k1587 = getFirstArrayKey( _a1587 ); + while ( isDefined( _k1587 ) ) + { + weapon = _a1587[ _k1587 ]; + if ( weapon == "minigun_alcatraz_zm" || weapon == "minigun_alcatraz_upgraded_zm" ) + { + return 1; + } + _k1587 = getNextArrayKey( _a1587, _k1587 ); + } + } + } + return 0; +} + +door_rumble_on_buy() +{ + self setclientfieldtoplayer( "rumble_door_open", 1 ); + wait_network_frame(); + self setclientfieldtoplayer( "rumble_door_open", 0 ); +} diff --git a/zm_prison_patch/maps/mp/zm_alcatraz_weap_quest.gsc b/zm_prison_patch/maps/mp/zm_alcatraz_weap_quest.gsc new file mode 100644 index 0000000..c7e5d50 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_alcatraz_weap_quest.gsc @@ -0,0 +1,687 @@ +#include maps/mp/zombies/_zm_powerups; +#include maps/mp/zombies/_zm_score; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/animscripts/shared; +#include maps/mp/zombies/_zm_spawner; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +#using_animtree( "fxanim_props" ); + +init() +{ + flag_init( "soul_catchers_charged" ); + level.soul_catchers = []; + level.soul_catchers_vol = []; + level.no_gib_in_wolf_area = ::check_for_zombie_in_wolf_area; + level.soul_catcher_clip[ "rune_2" ] = getent( "wolf_clip_docks", "targetname" ); + level.soul_catcher_clip[ "rune_3" ] = getent( "wolf_clip_infirmary", "targetname" ); + _a24 = level.soul_catcher_clip; + _k24 = getFirstArrayKey( _a24 ); + while ( isDefined( _k24 ) ) + { + e_clip = _a24[ _k24 ]; + e_clip setinvisibletoall(); + _k24 = getNextArrayKey( _a24, _k24 ); + } + level thread create_anim_references_on_server(); + registerclientfield( "actor", "make_client_clone", 9000, 4, "int" ); + onplayerconnect_callback( ::toggle_redeemer_trigger ); + onplayerconnect_callback( ::hellhole_projectile_watch ); + onplayerconnect_callback( ::hellhole_tomahawk_watch ); + level.a_wolf_structs = getstructarray( "wolf_position", "targetname" ); + i = 0; + while ( i < level.a_wolf_structs.size ) + { + registerclientfield( "world", level.a_wolf_structs[ i ].script_parameters, 9000, 3, "int" ); + level.soul_catchers[ i ] = level.a_wolf_structs[ i ]; + level.soul_catchers_vol[ i ] = getent( level.a_wolf_structs[ i ].target, "targetname" ); + i++; + } + i = 0; + while ( i < level.soul_catchers.size ) + { + level.soul_catchers[ i ].souls_received = 0; + level.soul_catchers[ i ].is_eating = 0; + level.soul_catchers[ i ] thread soul_catcher_check(); + if ( is_classic() ) + { + level.soul_catchers[ i ] thread soul_catcher_state_manager(); + } + else + { + level.soul_catchers[ i ] thread grief_soul_catcher_state_manager(); + } + level.soul_catchers[ i ] thread wolf_head_removal( "tomahawk_door_sign_" + ( i + 1 ) ); + level.soul_catchers_vol[ i ] = getent( level.soul_catchers[ i ].target, "targetname" ); + i++; + } + level.soul_catchers_charged = 0; + level thread soul_catchers_charged(); + array_thread( level.zombie_spawners, ::add_spawn_function, ::zombie_spawn_func ); +} + +create_anim_references_on_server() +{ + root = %root; + wolfhead_intro_anim = %o_zombie_dreamcatcher_intro; + wolfhead_outtro_anim = %o_zombie_dreamcatcher_outtro; + woflhead_idle_anims = []; + wolfhead_idle_anim[ 0 ] = %o_zombie_dreamcatcher_idle; + wolfhead_idle_anim[ 1 ] = %o_zombie_dreamcatcher_idle_twitch_scan; + wolfhead_idle_anim[ 2 ] = %o_zombie_dreamcatcher_idle_twitch_shake; + wolfhead_idle_anim[ 3 ] = %o_zombie_dreamcatcher_idle_twitch_yawn; + wolfhead_body_death = %ai_zombie_dreamcatch_impact; + wolfhead_body_float = %ai_zombie_dreamcatch_rise; + wolfhead_body_shrink = %ai_zombie_dreamcatch_shrink_a; + wolfhead_pre_eat_anims = []; + wolfhead_pre_eat_anims[ "right" ] = %o_zombie_dreamcatcher_wallconsume_pre_eat_r; + wolfhead_pre_eat_anims[ "left" ] = %o_zombie_dreamcatcher_wallconsume_pre_eat_l; + wolfhead_pre_eat_anims[ "front" ] = %o_zombie_dreamcatcher_wallconsume_pre_eat_f; + wolfhead_eat_anims[ "right" ] = %o_zombie_dreamcatcher_wallconsume_align_r; + wolfhead_eat_anims[ "left" ] = %o_zombie_dreamcatcher_wallconsume_align_l; + wolfhead_eat_anims[ "front" ] = %o_zombie_dreamcatcher_wallconsume_align_f; + wolfhead_body_anims[ "right" ] = %ai_zombie_dreamcatcher_wallconsume_align_r; + wolfhead_body_anims[ "left" ] = %ai_zombie_dreamcatcher_wallconsume_align_l; + wolfhead_body_anims[ "front" ] = %ai_zombie_dreamcatcher_wallconsume_align_f; +} + +soul_catcher_state_manager() +{ + wait 1; + if ( self.script_noteworthy == "rune_3" ) + { + trigger = getent( "wolf_hurt_trigger", "targetname" ); + trigger hide(); + } + else + { + if ( self.script_noteworthy == "rune_2" ) + { + trigger = getent( "wolf_hurt_trigger_docks", "targetname" ); + trigger hide(); + } + } + level setclientfield( self.script_parameters, 0 ); + self waittill( "first_zombie_killed_in_zone" ); + if ( self.script_noteworthy == "rune_3" ) + { + trigger = getent( "wolf_hurt_trigger", "targetname" ); + trigger show(); + } + else + { + if ( self.script_noteworthy == "rune_2" ) + { + trigger = getent( "wolf_hurt_trigger_docks", "targetname" ); + trigger show(); + } + } + if ( isDefined( level.soul_catcher_clip[ self.script_noteworthy ] ) ) + { + level.soul_catcher_clip[ self.script_noteworthy ] setvisibletoall(); + } + level setclientfield( self.script_parameters, 1 ); + anim_length = getanimlength( %o_zombie_dreamcatcher_intro ); + wait anim_length; + while ( !self.is_charged ) + { + level setclientfield( self.script_parameters, 2 ); + self waittill_either( "fully_charged", "finished_eating" ); + } + level setclientfield( self.script_parameters, 6 ); + anim_length = getanimlength( %o_zombie_dreamcatcher_outtro ); + wait anim_length; + if ( isDefined( level.soul_catcher_clip[ self.script_noteworthy ] ) ) + { + level.soul_catcher_clip[ self.script_noteworthy ] delete(); + } + if ( self.script_noteworthy == "rune_3" ) + { + trigger = getent( "wolf_hurt_trigger", "targetname" ); + trigger delete(); + } + else + { + if ( self.script_noteworthy == "rune_2" ) + { + trigger = getent( "wolf_hurt_trigger_docks", "targetname" ); + trigger delete(); + } + } + level setclientfield( self.script_parameters, 7 ); +} + +grief_soul_catcher_state_manager() +{ + wait 1; + while ( 1 ) + { + level setclientfield( self.script_parameters, 0 ); + self waittill( "first_zombie_killed_in_zone" ); + if ( isDefined( level.soul_catcher_clip[ self.script_noteworthy ] ) ) + { + level.soul_catcher_clip[ self.script_noteworthy ] setvisibletoall(); + } + level setclientfield( self.script_parameters, 1 ); + anim_length = getanimlength( %o_zombie_dreamcatcher_intro ); + wait anim_length; + while ( !self.is_charged ) + { + level setclientfield( self.script_parameters, 2 ); + self waittill_either( "fully_charged", "finished_eating" ); + } + level setclientfield( self.script_parameters, 6 ); + anim_length = getanimlength( %o_zombie_dreamcatcher_outtro ); + wait anim_length; + if ( isDefined( level.soul_catcher_clip[ self.script_noteworthy ] ) ) + { + level.soul_catcher_clip[ self.script_noteworthy ] delete(); + } + self.souls_received = 0; + level thread wolf_spit_out_powerup(); + wait 20; + self thread soul_catcher_check(); + } +} + +wolf_spit_out_powerup() +{ + if ( isDefined( level.enable_magic ) && !level.enable_magic ) + { + return; + } + power_origin_struct = getstruct( "wolf_puke_powerup_origin", "targetname" ); + if ( randomint( 100 ) < 20 ) + { + i = 0; + while ( i < level.zombie_powerup_array.size ) + { + if ( level.zombie_powerup_array[ i ] == "meat_stink" ) + { + level.zombie_powerup_index = i; + found = 1; + break; + } + else + { + i++; + } + } + } + else while ( 1 ) + { + level.zombie_powerup_index = randomint( level.zombie_powerup_array.size ); + while ( level.zombie_powerup_array[ level.zombie_powerup_index ] == "nuke" ) + { + wait 0,05; + } + } + spawn_infinite_powerup_drop( power_origin_struct.origin, level.zombie_powerup_array[ level.zombie_powerup_index ] ); + power_ups = get_array_of_closest( power_origin_struct.origin, level.active_powerups, undefined, undefined, 100 ); + if ( isDefined( power_ups[ 0 ] ) ) + { + power_ups[ 0 ] movez( 120, 4 ); + } +} + +zombie_spawn_func() +{ + self.actor_killed_override = ::zombie_killed_override; +} + +zombie_killed_override( einflictor, attacker, idamage, smeansofdeath, sweapon, vdir, shitloc, psoffsettime ) +{ + if ( !is_true( self.has_legs ) ) + { + return; + } + while ( isplayer( attacker ) ) + { + i = 0; + while ( i < level.soul_catchers.size ) + { + if ( self istouching( level.soul_catchers_vol[ i ] ) ) + { + if ( !level.soul_catchers[ i ].is_charged ) + { + self.deathfunction = ::zombie_soul_catcher_death; + self.my_soul_catcher = level.soul_catchers[ i ]; + } + } + i++; + } + } +} + +check_for_zombie_in_wolf_area() +{ + i = 0; + while ( i < level.soul_catchers.size ) + { + if ( self istouching( level.soul_catchers_vol[ i ] ) ) + { + if ( !level.soul_catchers[ i ].is_charged && !level.soul_catchers[ i ].is_eating ) + { + return 1; + } + } + i++; + } + return 0; +} + +zombie_soul_catcher_death() +{ + self thread maps/mp/zombies/_zm_spawner::zombie_death_animscript(); + if ( isDefined( self._race_team ) ) + { + team = self._race_team; + } + level maps/mp/zombies/_zm_spawner::zombie_death_points( self.origin, self.damagemod, self.damagelocation, self.attacker, self, team ); + if ( self.my_soul_catcher.is_eating ) + { + return 0; + } + if ( self.my_soul_catcher.souls_received >= 6 ) + { + return 0; + } + self.my_soul_catcher.is_eating = 1; + if ( self.my_soul_catcher.souls_received == 0 ) + { + self.my_soul_catcher notify( "first_zombie_killed_in_zone" ); + self thread notify_wolf_intro_anim_complete(); + } + client_notify_value = self get_correct_model_array(); + self setclientfield( "make_client_clone", client_notify_value ); + self setanimstatefromasd( "zm_portal_death" ); + self maps/mp/animscripts/shared::donotetracks( "portal_death" ); + if ( self.my_soul_catcher.souls_received == 0 ) + { + self waittill( "wolf_intro_anim_complete" ); + } + n_eating_anim = self which_eating_anim(); + self ghost(); + level setclientfield( self.my_soul_catcher.script_parameters, n_eating_anim ); + if ( n_eating_anim == 3 ) + { + total_wait_time = 3 + getanimlength( %ai_zombie_dreamcatcher_wallconsume_align_f ); + } + else if ( n_eating_anim == 4 ) + { + total_wait_time = 3 + getanimlength( %ai_zombie_dreamcatcher_wallconsume_align_r ); + } + else + { + total_wait_time = 3 + getanimlength( %ai_zombie_dreamcatcher_wallconsume_align_l ); + } + wait ( total_wait_time - 0,5 ); + self.my_soul_catcher.souls_received++; + wait 0,5; + self.my_soul_catcher notify( "finished_eating" ); + self.my_soul_catcher.is_eating = 0; + self delete(); + return 1; +} + +get_correct_model_array() +{ + mod = 0; + if ( self.model == "c_zom_guard_body" && isDefined( self.hatmodel ) && self.hatmodel == "c_zom_guard_hat" ) + { + mod = 4; + } + if ( self.headmodel == "c_zom_zombie_barbwire_head" ) + { + return 1 + mod; + } + if ( self.headmodel == "c_zom_zombie_hellcatraz_head" ) + { + return 2 + mod; + } + if ( self.headmodel == "c_zom_zombie_mask_head" ) + { + return 3 + mod; + } + if ( self.headmodel == "c_zom_zombie_slackjaw_head" ) + { + return 4 + mod; + } + return 5; +} + +notify_wolf_intro_anim_complete() +{ + anim_length = getanimlength( %o_zombie_dreamcatcher_intro ); + wait anim_length; + self notify( "wolf_intro_anim_complete" ); +} + +which_eating_anim() +{ + soul_catcher = self.my_soul_catcher; + forward_dot = vectordot( anglesToForward( soul_catcher.angles ), vectornormalize( self.origin - soul_catcher.origin ) ); + if ( forward_dot > 0,85 ) + { + return 3; + } + else + { + right_dot = vectordot( anglesToRight( soul_catcher.angles ), self.origin - soul_catcher.origin ); + if ( right_dot > 0 ) + { + return 4; + } + else + { + return 5; + } + } +} + +soul_catcher_check() +{ + self.is_charged = 0; + while ( 1 ) + { + if ( self.souls_received >= 6 ) + { + level.soul_catchers_charged++; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "tomahawk_" + level.soul_catchers_charged ); + self.is_charged = 1; + self notify( "fully_charged" ); + break; + } + else + { + wait 0,05; + } + } + if ( level.soul_catchers_charged == 1 ) + { + self thread first_wolf_complete_vo(); + } + else + { + if ( level.soul_catchers_charged >= level.soul_catchers.size ) + { + self thread final_wolf_complete_vo(); + } + } +} + +wolf_head_removal( wolf_head_model_string ) +{ + wolf_head_model = getent( wolf_head_model_string, "targetname" ); + wolf_head_model setmodel( "p6_zm_al_dream_catcher_off" ); + self waittill( "fully_charged" ); + wolf_head_model setmodel( "p6_zm_al_dream_catcher" ); +} + +soul_catchers_charged() +{ + while ( 1 ) + { + if ( level.soul_catchers_charged >= level.soul_catchers.size ) + { + flag_set( "soul_catchers_charged" ); + level notify( "soul_catchers_charged" ); + return; + } + else + { + wait 1; + } + } +} + +first_wolf_encounter_vo() +{ + if ( !is_classic() ) + { + return; + } + wait 2; + a_players = getplayers(); + a_closest = get_array_of_closest( self.origin, a_players ); + i = 0; + while ( i < a_closest.size ) + { + if ( isDefined( a_closest[ i ].dontspeak ) && !a_closest[ i ].dontspeak ) + { + a_closest[ i ] thread do_player_general_vox( "general", "wolf_encounter" ); + level.wolf_encounter_vo_played = 1; + return; + } + else + { + i++; + } + } +} + +first_wolf_complete_vo() +{ + if ( !is_classic() ) + { + return; + } + wait 3,5; + a_players = getplayers(); + a_closest = get_array_of_closest( self.origin, a_players ); + i = 0; + while ( i < a_closest.size ) + { + if ( isDefined( a_closest[ i ].dontspeak ) && !a_closest[ i ].dontspeak ) + { + a_closest[ i ] thread do_player_general_vox( "general", "wolf_complete" ); + return; + } + else + { + i++; + } + } +} + +final_wolf_complete_vo() +{ + if ( !is_classic() ) + { + return; + } + wait 3,5; + a_players = getplayers(); + a_closest = get_array_of_closest( self.origin, a_players ); + i = 0; + while ( i < a_closest.size ) + { + if ( isDefined( a_closest[ i ].dontspeak ) && !a_closest[ i ].dontspeak ) + { + a_closest[ i ] thread do_player_general_vox( "general", "wolf_final" ); + return; + } + else + { + i++; + } + } +} + +tomahawk_upgrade_quest() +{ + if ( isDefined( level.gamedifficulty ) && level.gamedifficulty == 0 ) + { + return; + } + self endon( "disconnect" ); + self.tomahawk_upgrade_kills = 0; + while ( self.tomahawk_upgrade_kills < 15 ) + { + self waittill( "got_a_tomahawk_kill" ); + self.tomahawk_upgrade_kills++; + } + wait 1; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "quest_generic" ); + e_org = spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) ); + e_org playsoundwithnotify( "zmb_easteregg_scream", "easteregg_scream_complete" ); + e_org waittill( "easteregg_scream_complete" ); + e_org delete(); + while ( level.round_number < 10 ) + { + wait 0,5; + } + self ent_flag_init( "gg_round_done" ); + while ( !self ent_flag( "gg_round_done" ) ) + { + level waittill( "between_round_over" ); + self.killed_with_only_tomahawk = 1; + self.killed_something_thq = 0; + while ( !self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) ) + { + continue; + } + level waittill( "end_of_round" ); + if ( !self.killed_with_only_tomahawk || !self.killed_something_thq ) + { + continue; + } + while ( !self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) ) + { + continue; + } + self ent_flag_set( "gg_round_done" ); + } + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "quest_generic" ); + e_org = spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) ); + e_org playsoundwithnotify( "zmb_easteregg_scream", "easteregg_scream_complete" ); + e_org waittill( "easteregg_scream_complete" ); + e_org delete(); + self notify( "hellhole_time" ); + self waittill( "tomahawk_in_hellhole" ); + if ( isDefined( self.retriever_trigger ) ) + { + self.retriever_trigger setinvisibletoplayer( self ); + } + else + { + trigger = getent( "retriever_pickup_trigger", "script_noteworthy" ); + self.retriever_trigger = trigger; + self.retriever_trigger setinvisibletoplayer( self ); + } + self takeweapon( "bouncing_tomahawk_zm" ); + self set_player_tactical_grenade( "none" ); + self notify( "tomahawk_upgraded_swap" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "quest_generic" ); + e_org = spawn( "script_origin", self.origin + vectorScale( ( 0, 0, 1 ), 64 ) ); + e_org playsoundwithnotify( "zmb_easteregg_scream", "easteregg_scream_complete" ); + e_org waittill( "easteregg_scream_complete" ); + e_org delete(); + level waittill( "end_of_round" ); + tomahawk_pick = getent( "spinning_tomahawk_pickup", "targetname" ); + tomahawk_pick setclientfield( "play_tomahawk_fx", 2 ); + self.current_tomahawk_weapon = "upgraded_tomahawk_zm"; +} + +toggle_redeemer_trigger() +{ + self endon( "disconnect" ); + flag_wait( "tomahawk_pickup_complete" ); + upgraded_tomahawk_trigger = getent( "redeemer_pickup_trigger", "script_noteworthy" ); + upgraded_tomahawk_trigger setinvisibletoplayer( self ); + tomahawk_model = getent( "spinning_tomahawk_pickup", "targetname" ); + while ( 1 ) + { + if ( isDefined( self.current_tomahawk_weapon ) && self.current_tomahawk_weapon == "upgraded_tomahawk_zm" ) + { + break; + } + else wait 1; + } + while ( 1 ) + { + if ( isDefined( self.afterlife ) && self.afterlife ) + { + upgraded_tomahawk_trigger setvisibletoplayer( self ); + tomahawk_model setvisibletoplayer( self ); + } + else + { + upgraded_tomahawk_trigger setinvisibletoplayer( self ); + tomahawk_model setinvisibletoplayer( self ); + } + wait 1; + } +} + +hellhole_projectile_watch() +{ + self endon( "disconnect" ); + while ( 1 ) + { + self waittill( "grenade_fire", grenade, weapname ); + if ( weapname == "frag_grenade_zm" ) + { + self thread hellhole_grenades( grenade ); + } + } +} + +hellhole_tomahawk_watch() +{ + self endon( "disconnect" ); + self waittill( "hellhole_time" ); + while ( 1 ) + { + self waittill( "grenade_fire", grenade, weapname ); + if ( weapname == "bouncing_tomahawk_zm" ) + { + self thread hellhole_tomahawk( grenade ); + } + } +} + +hellhole_grenades( grenade ) +{ + grenade endon( "death" ); + trig_hellhole = getent( "trig_cellblock_hellhole", "targetname" ); + while ( !grenade istouching( trig_hellhole ) ) + { + wait 0,05; + } + self maps/mp/zombies/_zm_score::add_to_player_score( 20 ); + playfx( level._effect[ "tomahawk_hellhole" ], grenade.origin ); + playsoundatposition( "wpn_grenade_poof", grenade.origin ); + grenade delete(); +} + +hellhole_tomahawk( grenade ) +{ + grenade endon( "death" ); + trig_hellhole = getent( "trig_cellblock_hellhole", "targetname" ); + while ( !grenade istouching( trig_hellhole ) ) + { + wait 0,05; + } + self notify( "tomahawk_in_hellhole" ); + grenade notify( "in_hellhole" ); + playfx( level._effect[ "tomahawk_hellhole" ], grenade.origin ); + playsoundatposition( "wpn_grenade_poof", grenade.origin ); + grenade delete(); +} + +spawn_infinite_powerup_drop( v_origin, str_type ) +{ + if ( isDefined( str_type ) ) + { + intro_powerup = maps/mp/zombies/_zm_powerups::specific_powerup_drop( str_type, v_origin ); + } + else + { + intro_powerup = maps/mp/zombies/_zm_powerups::powerup_drop( v_origin ); + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_achievement.gsc b/zm_prison_patch/maps/mp/zm_prison_achievement.gsc new file mode 100644 index 0000000..af9233c --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_achievement.gsc @@ -0,0 +1,209 @@ +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/gametypes_zm/_globallogic_score; +#include maps/mp/zombies/_zm_utility; +#include common_scripts/utility; +#include maps/mp/_utility; + +init() +{ + level thread achievement_full_lockdown(); + level thread achievement_pop_goes_the_weasel(); + level thread achievement_trapped_in_time(); + onplayerconnect_callback( ::onplayerconnect ); + level.achievement_sound_func = ::achievement_sound_func; +} + +onplayerconnect() +{ + self thread achievement_no_one_escapes_alive(); + self thread achievement_feed_the_beast(); + self thread achievement_making_the_rounds(); + self thread achievement_acid_drip(); + self thread achievement_a_burst_of_flavor(); + self thread achievement_paranormal_progress(); + self thread achievement_gg_bridge(); +} + +achievement_sound_func( achievement_name_lower ) +{ + self thread do_player_general_vox( "general", "achievement" ); +} + +init_player_achievement_stats() +{ + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_prison_sidequest", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_feed_the_beast", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_making_the_rounds", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_acid_drip", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_full_lockdown", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_a_burst_of_flavor", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_paranormal_progress", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_gg_bridge", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_trapped_in_time", 0 ); + self maps/mp/gametypes_zm/_globallogic_score::initpersstat( "zm_dlc2_pop_goes_the_weasel", 0 ); +} + +achievement_full_lockdown() +{ + level endon( "end_game" ); + level.lockdown_track[ "magic_box" ] = 0; + level.lockdown_track[ "speedcola_perk" ] = 0; + level.lockdown_track[ "electric_cherry_perk" ] = 0; + level.lockdown_track[ "jugg_perk" ] = 0; + level.lockdown_track[ "deadshot_perk" ] = 0; + level.lockdown_track[ "tap_perk" ] = 0; + level.lockdown_track[ "plane_ramp" ] = 0; + level.lockdown_track[ "craft_shield" ] = 0; + level.lockdown_track[ "craft_kit" ] = 0; + b_unlock = 0; + while ( b_unlock == 0 ) + { + level waittill( "brutus_locked_object" ); + b_unlock = 1; + _a92 = level.lockdown_track; + _k92 = getFirstArrayKey( _a92 ); + while ( isDefined( _k92 ) ) + { + b_check = _a92[ _k92 ]; + if ( b_check == 0 ) + { + b_unlock = 0; + break; + } + else + { + _k92 = getNextArrayKey( _a92, _k92 ); + } + } + } + level giveachievement_wrapper( "ZM_DLC2_FULL_LOCKDOWN", 1 ); +} + +achievement_trapped_in_time() +{ + level endon( "end_game" ); + level.trapped_track[ "acid" ] = 0; + level.trapped_track[ "fan" ] = 0; + level.trapped_track[ "tower" ] = 0; + level.trapped_track[ "tower_upgrade" ] = 0; + b_unlock = 0; + while ( b_unlock == 0 ) + { + level waittill_either( "trap_activated", "tower_trap_upgraded" ); + if ( level.round_number >= 10 ) + { + return; + } + b_unlock = 1; + _a131 = level.trapped_track; + _k131 = getFirstArrayKey( _a131 ); + while ( isDefined( _k131 ) ) + { + b_check = _a131[ _k131 ]; + if ( b_check == 0 ) + { + b_unlock = 0; + break; + } + else + { + _k131 = getNextArrayKey( _a131, _k131 ); + } + } + } + level giveachievement_wrapper( "ZM_DLC2_TRAPPED_IN_TIME", 1 ); +} + +achievement_pop_goes_the_weasel() +{ + level endon( "end_game" ); + level waittill( "pop_goes_the_weasel_achieved" ); + level giveachievement_wrapper( "ZM_DLC2_POP_GOES_THE_WEASEL", 1 ); +} + +achievement_no_one_escapes_alive() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + self waittill( "player_at_bridge" ); + self giveachievement_wrapper( "ZM_DLC2_PRISON_SIDEQUEST" ); +} + +achievement_feed_the_beast() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + self waittill( "player_obtained_tomahawk" ); + self giveachievement_wrapper( "ZM_DLC2_FEED_THE_BEAST" ); +} + +achievement_making_the_rounds() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + n_completed_trips = 0; + while ( n_completed_trips < 3 ) + { + self waittill( "player_completed_cycle" ); + n_completed_trips++; + } + self giveachievement_wrapper( "ZM_DLC2_MAKING_THE_ROUNDS" ); +} + +achievement_acid_drip() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + self waittill( "player_obtained_acidgat" ); + self giveachievement_wrapper( "ZM_DLC2_ACID_DRIP" ); +} + +achievement_a_burst_of_flavor() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + while ( 1 ) + { + self waittill( "electric_cherry_start" ); + self.cherry_kills = 0; + self waittill( "electric_cherry_end" ); + if ( self.cherry_kills >= 10 ) + { + break; + } + else + { + } + } + self giveachievement_wrapper( "ZM_DLC2_A_BURST_OF_FLAVOR" ); +} + +achievement_paranormal_progress() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + self waittill( "player_opened_afterlife_door" ); + self giveachievement_wrapper( "ZM_DLC2_PARANORMAL_PROGRESS" ); +} + +achievement_gg_bridge() +{ + level endon( "end_game" ); + self endon( "disconnect" ); + while ( 1 ) + { + level waittill( "end_of_round" ); + if ( self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) && level.round_number >= 15 ) + { + level waittill( "end_of_round" ); + if ( self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) ) + { + break; + } + } + else + { + } + } + self giveachievement_wrapper( "ZM_DLC2_GG_BRIDGE" ); +} diff --git a/zm_prison_patch/maps/mp/zm_prison_ffotd.gsc b/zm_prison_patch/maps/mp/zm_prison_ffotd.gsc new file mode 100644 index 0000000..28d4eeb --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_ffotd.gsc @@ -0,0 +1,148 @@ +#include maps/mp/zombies/_zm_afterlife; +#include maps/mp/zm_prison; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_utility; +#include common_scripts/utility; +#include maps/mp/_utility; + +main_start() +{ + level thread spawned_collision_ffotd(); + t_killbrush_1 = spawn( "trigger_box", ( 142, 9292, 1504 ), 0, 700, 160, 128 ); + t_killbrush_1.script_noteworthy = "kill_brush"; + t_killbrush_2 = spawn( "trigger_box", ( 1822, 9316, 1358 ), 0, 120, 100, 30 ); + t_killbrush_2.script_noteworthy = "kill_brush"; + t_killbrush_3 = spawn( "trigger_box", ( -42, 9348, 1392 ), 0, 200, 100, 128 ); + t_killbrush_3.script_noteworthy = "kill_brush"; +} + +main_end() +{ + level.equipment_dead_zone_pos = []; + level.equipment_dead_zone_rad2 = []; + level.equipment_dead_zone_pos[ 0 ] = ( 408, 10016, 1128 ); + level.equipment_dead_zone_rad2[ 0 ] = 65536; + level.equipment_dead_zone_pos[ 1 ] = ( -280, 7872, 176 ); + level.equipment_dead_zone_rad2[ 1 ] = 10000; + level.equipment_dead_zone_pos[ 2 ] = ( -104, 8056, 280 ); + level.equipment_dead_zone_rad2[ 2 ] = 10000; + level.equipment_dead_zone_pos[ 3 ] = ( -86, 7712, 114 ); + level.equipment_dead_zone_rad2[ 3 ] = 10000; + level.equipment_dead_zone_pos[ 4 ] = ( 447, 5963, 264 ); + level.equipment_dead_zone_rad2[ 4 ] = 10000; + level.equipment_dead_zone_pos[ 5 ] = ( 231, 5913, 200 ); + level.equipment_dead_zone_rad2[ 5 ] = 10000; + level.equipment_dead_zone_pos[ 6 ] = ( 15, 5877, 136 ); + level.equipment_dead_zone_rad2[ 6 ] = 10000; + level.equipment_dead_zone_pos[ 7 ] = ( -335, 5795, 14 ); + level.equipment_dead_zone_rad2[ 7 ] = 22500; + level.equipment_dead_zone_pos[ 8 ] = ( -621, 5737, -48 ); + level.equipment_dead_zone_rad2[ 8 ] = 10000; + level.equipment_dead_zone_pos[ 9 ] = ( 402, 7058, 147 ); + level.equipment_dead_zone_rad2[ 9 ] = 10000; + level.equipment_dead_zone_pos[ 10 ] = ( 2151, 10180, 1204 ); + level.equipment_dead_zone_rad2[ 10 ] = 625; + level.equipment_dead_zone_pos[ 11 ] = ( 2144, 9486, 1364 ); + level.equipment_dead_zone_rad2[ 11 ] = 2500; + level.equipment_safe_to_drop = ::equipment_safe_to_drop_ffotd; + waittillframeend; + level.afterlife_give_loadout = ::afterlife_give_loadout_override; +} + +equipment_safe_to_drop_ffotd( weapon ) +{ + i = 0; + while ( i < level.equipment_dead_zone_pos.size ) + { + if ( distancesquared( level.equipment_dead_zone_pos[ i ], weapon.origin ) < level.equipment_dead_zone_rad2[ i ] ) + { + return 0; + } + i++; + } + return self maps/mp/zm_prison::equipment_safe_to_drop( weapon ); +} + +spawned_collision_ffotd() +{ + precachemodel( "collision_ai_64x64x10" ); + precachemodel( "collision_wall_256x256x10_standard" ); + precachemodel( "collision_wall_128x128x10_standard" ); + precachemodel( "collision_wall_512x512x10_standard" ); + precachemodel( "collision_geo_256x256x256_standard" ); + precachemodel( "collision_geo_64x64x256_standard" ); + precachemodel( "collision_geo_128x128x128_standard" ); + flag_wait( "start_zombie_round_logic" ); + if ( !is_true( level.optimise_for_splitscreen ) ) + { + collision1 = spawn( "script_model", ( 1999, 9643, 1472 ) ); + collision1 setmodel( "collision_ai_64x64x10" ); + collision1.angles = ( 0, 270, -90 ); + collision1 ghost(); + collision2 = spawn( "script_model", ( -437, 6260, 121 ) ); + collision2 setmodel( "collision_wall_256x256x10_standard" ); + collision2.angles = vectorScale( ( 0, 0, 0 ), 11,8 ); + collision2 ghost(); + collision3 = spawn( "script_model", ( 1887,98, 9323, 1489,14 ) ); + collision3 setmodel( "collision_wall_128x128x10_standard" ); + collision3.angles = ( 0, 270, 38,6 ); + collision3 ghost(); + collision4 = spawn( "script_model", ( -261, 8512,02, 1153,14 ) ); + collision4 setmodel( "collision_geo_256x256x256_standard" ); + collision4.angles = vectorScale( ( 0, 0, 0 ), 180 ); + collision4 ghost(); + collision5a = spawn( "script_model", ( 792, 8302, 1620 ) ); + collision5a setmodel( "collision_geo_64x64x256_standard" ); + collision5a.angles = ( 0, 0, 0 ); + collision5a ghost(); + collision5b = spawn( "script_model", ( 1010, 8302, 1620 ) ); + collision5b setmodel( "collision_geo_64x64x256_standard" ); + collision5b.angles = ( 0, 0, 0 ); + collision5b ghost(); + collision6 = spawn( "script_model", ( 554, 8026, 698 ) ); + collision6 setmodel( "collision_wall_128x128x10_standard" ); + collision6.angles = vectorScale( ( 0, 0, 0 ), 22,2 ); + collision6 ghost(); + collision7 = spawn( "script_model", ( 1890, 9911, 1184 ) ); + collision7 setmodel( "collision_geo_64x64x256_standard" ); + collision7.angles = ( 0, 0, 0 ); + collision7 ghost(); + collision8 = spawn( "script_model", ( 258, 9706, 1152 ) ); + collision8 setmodel( "collision_geo_64x64x256_standard" ); + collision8.angles = ( 0, 0, 0 ); + collision8 ghost(); + collision9 = spawn( "script_model", ( 596, 8944, 1160 ) ); + collision9 setmodel( "collision_ai_64x64x10" ); + collision9.angles = ( 270, 180, -180 ); + collision9 ghost(); + collision10 = spawn( "script_model", ( -756,5, 5730, -113,75 ) ); + collision10 setmodel( "collision_geo_128x128x128_standard" ); + collision10.angles = ( 354,9, 11, 0 ); + collision10 ghost(); + collision11 = spawn( "script_model", ( -4, 8314, 808 ) ); + collision11 setmodel( "collision_wall_128x128x10_standard" ); + collision11.angles = vectorScale( ( 0, 0, 0 ), 292 ); + collision11 ghost(); + collision12 = spawn( "script_model", ( 1416, 10708, 1440 ) ); + collision12 setmodel( "collision_wall_512x512x10_standard" ); + collision12.angles = ( 0, 0, 0 ); + collision12 ghost(); + } +} + +afterlife_give_loadout_override() +{ + self thread afterlife_leave_freeze(); + self maps/mp/zombies/_zm_afterlife::afterlife_give_loadout(); +} + +afterlife_leave_freeze() +{ + self endon( "disconnect" ); + self freezecontrols( 1 ); + wait 0,5; + if ( !is_true( self.hostmigrationcontrolsfrozen ) ) + { + self freezecontrols( 0 ); + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_fx.gsc b/zm_prison_patch/maps/mp/zm_prison_fx.gsc new file mode 100644 index 0000000..f6bb61b --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_fx.gsc @@ -0,0 +1,144 @@ +#include maps/mp/_utility; + +#using_animtree( "fxanim_props" ); + +main() +{ + precache_createfx_fx(); + precache_scripted_fx(); + precache_fxanim_props(); + maps/mp/createfx/zm_prison_fx::main(); +} + +precache_scripted_fx() +{ + level._effect[ "elevator_fall" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elevator_fall" ); + level._effect[ "key_glint" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_key_glint" ); + level._effect[ "quest_item_glow" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_quest_item_glow" ); + level._effect[ "eye_glow" ] = loadfx( "maps/zombie_alcatraz/fx_zombie_eye_single_red" ); + level._effect[ "fx_alcatraz_unlock_door" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_unlock_door" ); + level._effect[ "fx_alcatraz_elec_chair" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elec_chair" ); + level._effect[ "fx_alcatraz_lightning_finale" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_lightning_finale" ); + level._effect[ "fx_alcatraz_panel_on_2" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_panel_on_2" ); + level._effect[ "fx_alcatraz_panel_off_2" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_panel_off_2" ); + level._effect[ "fx_alcatraz_lightning_wire" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_lightning_wire" ); + level._effect[ "fx_alcatraz_afterlife_zmb_tport" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_afterlife_zmb_tport" ); + level._effect[ "fx_alcatraz_panel_ol" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_panel_ol" ); + level._effect[ "fx_alcatraz_plane_apear" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_plane_apear" ); + level._effect[ "switch_sparks" ] = loadfx( "env/electrical/fx_elec_wire_spark_burst" ); + level._effect[ "zapper_light_ready" ] = loadfx( "maps/zombie/fx_zombie_zapper_light_green" ); + level._effect[ "zapper_light_notready" ] = loadfx( "maps/zombie/fx_zombie_zapper_light_red" ); + level._effect[ "fx_alcatraz_plane_trail" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_plane_trail" ); + level._effect[ "fx_alcatraz_plane_trail_fast" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_plane_trail_fast" ); + level._effect[ "fx_alcatraz_flight_lightning" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_flight_lightning" ); + level._effect[ "fx_alcatraz_plane_fire_trail" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_plane_fire_trail" ); + level._effect[ "alcatraz_dryer_light_green" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_dryer_light_green" ); + level._effect[ "alcatraz_dryer_light_red" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_dryer_light_red" ); + level._effect[ "alcatraz_dryer_light_yellow" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_dryer_light_yellow" ); + level._effect[ "zomb_gib" ] = loadfx( "maps/zombie/fx_zmb_tranzit_lava_torso_explo" ); + level._effect[ "elec_md" ] = loadfx( "electrical/fx_elec_player_md" ); + level._effect[ "elec_sm" ] = loadfx( "electrical/fx_elec_player_sm" ); + level._effect[ "elec_torso" ] = loadfx( "electrical/fx_elec_player_torso" ); + level._effect[ "acid_spray" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_acid_spray" ); + level._effect[ "acid_death" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_acid_death" ); + level._effect[ "box_activated" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_box_charge" ); + level._effect[ "fan_blood" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fan_blood" ); + level._effect[ "light_gondola" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_light_gondola" ); + level._effect[ "lightning_flash" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_lightning_lg" ); + level._effect[ "tomahawk_trail" ] = loadfx( "weapon/tomahawk/fx_tomahawk_trail" ); + level._effect[ "tomahawk_trail_ug" ] = loadfx( "weapon/tomahawk/fx_tomahawk_trail_ug" ); + level._effect[ "tomahawk_impact" ] = loadfx( "weapon/tomahawk/fx_tomahawk_impact" ); + level._effect[ "tomahawk_impact_ug" ] = loadfx( "weapon/tomahawk/fx_tomahawk_impact_ug" ); + level._effect[ "tomahawk_charge_up" ] = loadfx( "weapon/tomahawk/fx_tomahawk_charge" ); + level._effect[ "tomahawk_charge_up_ug" ] = loadfx( "weapon/tomahawk/fx_tomahawk_charge_ug" ); + level._effect[ "tomahawk_pickup" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_tomahawk_pickup" ); + level._effect[ "tomahawk_pickup_upgrade" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_tomahawk_pickup_ug" ); + level._effect[ "tomahawk_charged_trail" ] = loadfx( "weapon/tomahawk/fx_tomahawk_trail_charged" ); + level._effect[ "tomahawk_fire_dot" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_zmb_fire_torso" ); + level._effect[ "soul_charge_start" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_soul_charge_start" ); + level._effect[ "soul_charge" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_soul_charge" ); + level._effect[ "soul_charge_impact" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_soul_charge_impact" ); + level._effect[ "soul_charged" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_soul_charged" ); + level._effect[ "hell_portal" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_portal_hell" ); + level._effect[ "hell_portal_close" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_portal_hell_close" ); + level._effect[ "tomahawk_hellhole" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_brutus_footstomp" ); + level._effect[ "wolf_bite_blood" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_soul_charge_impact_sm" ); + level._effect[ "uzi_zm_fx" ] = loadfx( "maps/zombie/fx_zmb_wall_buy_uzi" ); + level._effect[ "thompson_zm_fx" ] = loadfx( "maps/zombie/fx_zmb_wall_buy_thompson" ); + level._effect[ "fx_alcatraz_lighthouse" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_light_house" ); + level._effect[ "ee_skull_shot" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_skull_elec_2" ); +} + +precache_createfx_fx() +{ + level._effect[ "fx_alcatraz_storm_start" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_storm_start" ); + level._effect[ "fx_alcatraz_vista_fog" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_vista_fog" ); + level._effect[ "fx_alcatraz_docks_fog" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_docks_fog" ); + level._effect[ "fx_alcatraz_fog_closet" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fog_closet" ); + level._effect[ "fx_alcatraz_fire_works" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fire_works" ); + level._effect[ "fx_alcatraz_tunnel_dust_fall" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_tunnel_dust_fall" ); + level._effect[ "fx_alcatraz_tunnel_ash" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_tunnel_ash" ); + level._effect[ "fx_alcatraz_steam_pipe_2" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_pipe_2" ); + level._effect[ "fx_alcatraz_steam_pipe" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_pipe" ); + level._effect[ "fx_alcatraz_shower_steam" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_shower_steam" ); + level._effect[ "fx_alcatraz_steam_pipe" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_pipe" ); + level._effect[ "fx_alcatraz_panel_on" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_panel_on" ); + level._effect[ "fx_alcatraz_door_blocker" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_door_blocker" ); + level._effect[ "fx_alcatraz_dryer_on" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_dryer_on" ); + level._effect[ "fx_alcatraz_elec_fence" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elec_fence" ); + level._effect[ "fx_alcatraz_generator_smk" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_generator_smk" ); + level._effect[ "fx_alcatraz_generator_sparks" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_generator_sparks" ); + level._effect[ "fx_alcatraz_generator_exp" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_generator_exp" ); + level._effect[ "fx_alcatraz_elevator_spark" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elevator_spark" ); + level._effect[ "fx_alcatraz_elec_key" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elec_key" ); + level._effect[ "fx_alcatraz_sparks_ceiling" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_sparks_ceiling" ); + level._effect[ "fx_alcatraz_sparks_panel" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_sparks_panel" ); + level._effect[ "fx_alcatraz_fire_sm" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fire_sm" ); + level._effect[ "fx_alcatraz_fire_xsm" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fire_xsm" ); + level._effect[ "fx_alcatraz_embers_flat" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_embers_flat" ); + level._effect[ "fx_alcatraz_falling_fire" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_falling_fire" ); + level._effect[ "fx_alcatraz_steam_3floor" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_3floor" ); + level._effect[ "fx_alcatraz_elec_box_amb" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elec_box_amb" ); + level._effect[ "fx_alcatraz_blood_drip" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_blood_drip" ); + level._effect[ "fx_alcatraz_godray_grill" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_godray_grill" ); + level._effect[ "fx_alcatraz_godray_grill_lg" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_godray_grill_lg" ); + level._effect[ "fx_alcatraz_godray_skinny" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_godray_skinny" ); + level._effect[ "fx_alcatraz_ground_fog" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_ground_fog" ); + level._effect[ "fx_alcatraz_flies" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_flies" ); + level._effect[ "fx_alcatraz_candle_fire" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_candle_fire" ); + level._effect[ "fx_alcatraz_portal_amb" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_portal_amb" ); + level._effect[ "fx_alcatraz_fire_md" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_fire_md" ); + level._effect[ "fx_alcatraz_smk_linger" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_smk_linger" ); + level._effect[ "fx_alcatraz_embers_indoor" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_embers_indoor" ); + level._effect[ "fx_alcatraz_papers" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_papers" ); + level._effect[ "fx_alcatraz_ceiling_fire" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_ceiling_fire" ); + level._effect[ "fx_alcatraz_steam_ash" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_ash" ); + level._effect[ "fx_alcatraz_godray_jail" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_godray_jail" ); + level._effect[ "fx_alcatraz_water_drip" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_water_drip" ); + level._effect[ "fx_alcatraz_shower_steam" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_shower_steam" ); + level._effect[ "fx_alcatraz_steam_pipe" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_steam_pipe" ); + level._effect[ "fx_alcatraz_light_tinhat" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_light_tinhat" ); + level._effect[ "fx_alcatraz_light_round_oo" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_light_round_oo" ); + level._effect[ "fx_alcatraz_light_tinhat_oo" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_light_tinhat_oo" ); + level._effect[ "fx_alcatraz_flight_clouds" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_flight_clouds" ); + level._effect[ "fx_alcatraz_lightning_bridge" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_lightning_bridge" ); + level._effect[ "fx_alcatraz_elec_chair" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_elec_chair" ); +} + +precache_fxanim_props() +{ + level.scr_anim[ "fxanim_props" ][ "wirespark_med" ] = %fxanim_gp_wirespark_med_anim; + level.scr_anim[ "fxanim_props" ][ "dryer_start" ] = %fxanim_zom_al_industrial_dryer_start_anim; + level.scr_anim[ "fxanim_props" ][ "dryer_idle" ] = %fxanim_zom_al_industrial_dryer_idle_anim; + level.scr_anim[ "fxanim_props" ][ "dryer_end" ] = %fxanim_zom_al_industrial_dryer_end_anim; + level.scr_anim[ "fxanim_props" ][ "dryer_hide" ] = %fxanim_zom_al_industrial_dryer_hide_anim; + level.scr_anim[ "fxanim_props" ][ "pulley_down" ] = %fxanim_zom_al_key_pulley_down_anim; + level.scr_anim[ "fxanim_props" ][ "pulley_up" ] = %fxanim_zom_al_key_pulley_up_anim; + level.scr_anim[ "fxanim_props" ][ "crane_palette" ] = %fxanim_zom_al_crane_palette_anim; + level.scr_anim[ "fxanim_props" ][ "chain_hook_rotate" ] = %fxanim_zom_al_chain_short_hook_rotate_anim; + level.scr_anim[ "fxanim_props" ][ "bodybag_rotate" ] = %fxanim_zom_al_bodybag_rotate_anim; + level.scr_anim[ "fxanim_props" ][ "chain_hook_swing" ] = %fxanim_zom_al_chain_short_hook_swing_anim; + level.scr_anim[ "fxanim_props" ][ "bodybag_swing" ] = %fxanim_zom_al_bodybag_swing_anim; + level.scr_anim[ "fxanim_props" ][ "chain_hook_crane" ] = %fxanim_zom_al_chain_short_hook_crane_anim; + level.scr_anim[ "fxanim_props" ][ "bodybag_crane" ] = %fxanim_zom_al_bodybag_crane_anim; +} diff --git a/zm_prison_patch/maps/mp/zm_prison_spoon.gsc b/zm_prison_patch/maps/mp/zm_prison_spoon.gsc new file mode 100644 index 0000000..8be3791 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_spoon.gsc @@ -0,0 +1,301 @@ +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/zombies/_zm_weap_tomahawk; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_spawner; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +#using_animtree( "fxanim_props" ); + +init() +{ + if ( isDefined( level.gamedifficulty ) && level.gamedifficulty == 0 ) + { + spoon_easy_cleanup(); + return; + } + precachemodel( "t6_wpn_zmb_spoon_world" ); + precachemodel( "c_zom_inmate_g_rarmspawn" ); + level thread wait_for_initial_conditions(); + array_thread( level.zombie_spawners, ::add_spawn_function, ::zombie_spoon_func ); + level thread bucket_init(); + spork_portal = getent( "afterlife_show_spork", "targetname" ); + spork_portal setinvisibletoall(); + level.b_spoon_in_tub = 0; + level.n_spoon_kill_count = 0; + flag_init( "spoon_obtained" ); + flag_init( "charged_spoon" ); +/# + level thread debug_prison_spoon_quest(); +#/ +} + +spoon_easy_cleanup() +{ + spork_portal = getent( "afterlife_show_spork", "targetname" ); + spork_portal delete(); + m_spoon_pickup = getent( "pickup_spoon", "targetname" ); + m_spoon_pickup delete(); + m_spoon = getent( "zap_spoon", "targetname" ); + m_spoon delete(); +} + +extra_death_func_to_check_for_splat_death() +{ + self thread maps/mp/zombies/_zm_spawner::zombie_death_animscript(); + if ( self.damagemod == "MOD_GRENADE" || self.damagemod == "MOD_GRENADE_SPLASH" ) + { + if ( self.damageweapon == "blundersplat_explosive_dart_zm" ) + { + if ( isplayer( self.attacker ) ) + { + self notify( "killed_by_a_blundersplat" ); + } + } + else + { + if ( self.damageweapon == "bouncing_tomahawk_zm" ) + { + if ( isplayer( self.attacker ) ) + { + self.attacker notify( "got_a_tomahawk_kill" ); + } + } + } + } + if ( isDefined( self.attacker.killed_with_only_tomahawk ) ) + { + if ( self.damageweapon != "bouncing_tomahawk_zm" && self.damageweapon != "none" ) + { + self.attacker.killed_with_only_tomahawk = 0; + } + } + if ( isDefined( self.attacker.killed_something_thq ) ) + { + self.attacker.killed_something_thq = 1; + } + return 0; +} + +zombie_spoon_func() +{ + self.deathfunction = ::extra_death_func_to_check_for_splat_death; + self waittill( "killed_by_a_blundersplat", player ); + if ( flag( "charged_spoon" ) || !level.b_spoon_in_tub ) + { + return; + } + if ( self maps/mp/zombies/_zm_zonemgr::entity_in_zone( "cellblock_shower" ) ) + { + level.n_spoon_kill_count++; + } + else + { + return; + } + if ( level.n_spoon_kill_count >= 50 ) + { +/# + iprintlnbold( "Spoon Charged" ); +#/ + flag_set( "charged_spoon" ); + } +} + +wait_for_initial_conditions() +{ + m_spoon_pickup = getent( "pickup_spoon", "targetname" ); + m_spoon_pickup ghost(); + m_spoon_pickup ghostindemo(); + while ( !isDefined( level.characters_in_nml ) || level.characters_in_nml.size == 0 ) + { + wait 1; + } + flag_wait( "soul_catchers_charged" ); + m_poster = getent( "poster", "targetname" ); + m_poster.health = 5000; + m_poster setcandamage( 1 ); + b_poster_knocked_down = 0; + while ( !b_poster_knocked_down ) + { + m_poster waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname ); + if ( weaponname != "frag_grenade_zm" || weaponname == "bouncing_tomahawk_zm" && weaponname == "upgraded_tomahawk_zm" ) + { + b_poster_knocked_down = 1; + playsoundatposition( "zmb_squest_spoon_poster", m_poster.origin ); + m_poster delete(); + if ( isDefined( attacker ) && isplayer( attacker ) ) + { + attacker do_player_general_vox( "quest", "secret_poster", undefined, 100 ); + } + wait 1; + attacker thread do_player_general_vox( "quest", "pick_up_easter_egg" ); + } + } + spork_door = getent( "spork_door", "targetname" ); + spork_door.targetname = "afterlife_door"; + spork_portal = getent( "afterlife_show_spork", "targetname" ); + spork_portal.targetname = "afterlife_show"; + m_spoon = getent( "zap_spoon", "targetname" ); + m_spoon ghostindemo(); + m_spoon.health = 50000; + m_spoon setcandamage( 1 ); + b_spoon_shocked = 0; + while ( !b_spoon_shocked ) + { + m_spoon waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname ); + m_spoon.health += damage; + if ( weaponname == "lightning_hands_zm" ) + { + b_spoon_shocked = 1; + m_spoon delete(); + attacker playsound( "zmb_easteregg_laugh" ); + } + } + m_spoon_pickup show(); + m_spoon_pickup.health = 10000; + m_spoon_pickup setcandamage( 1 ); + level.a_tomahawk_pickup_funcs[ level.a_tomahawk_pickup_funcs.size ] = ::tomahawk_the_spoon; +} + +tomahawk_the_spoon( grenade, n_grenade_charge_power ) +{ + if ( self hasweapon( "spoon_zm_alcatraz" ) || self hasweapon( "spork_zm_alcatraz" ) ) + { + return 0; + } + m_spoon = getent( "pickup_spoon", "targetname" ); + if ( distancesquared( m_spoon.origin, grenade.origin ) < 40000 ) + { + m_tomahawk = maps/mp/zombies/_zm_weap_tomahawk::tomahawk_spawn( grenade.origin ); + m_tomahawk.n_grenade_charge_power = n_grenade_charge_power; + m_player_spoon = spawn( "script_model", grenade.origin ); + m_player_spoon setmodel( "t6_wpn_zmb_spoon_world" ); + m_player_spoon linkto( m_tomahawk ); + self maps/mp/zombies/_zm_stats::increment_client_stat( "prison_ee_spoon_acquired", 0 ); + self thread maps/mp/zombies/_zm_weap_tomahawk::tomahawk_return_player( m_tomahawk ); + self thread give_player_spoon_upon_receipt( m_tomahawk, m_player_spoon ); + self thread dip_the_spoon(); + flag_set( "spoon_obtained" ); + self playsoundtoplayer( "vox_brutus_easter_egg_101_0", self ); + return 1; + } + return 0; +} + +give_player_spoon_upon_receipt( m_tomahawk, m_player_spoon ) +{ + while ( isDefined( m_tomahawk ) ) + { + wait 0,05; + } + m_player_spoon delete(); + while ( !self hasweapon( "spoon_zm_alcatraz" ) && !self hasweapon( "spork_zm_alcatraz" ) && isDefined( self.spoon_in_tub ) && !self.spoon_in_tub ) + { + self giveweapon( "spoon_zm_alcatraz" ); + self set_player_melee_weapon( "spoon_zm_alcatraz" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "spoon", self ); + weapons = self getweaponslist(); + i = 0; + while ( i < weapons.size ) + { + if ( issubstr( weapons[ i ], "knife" ) ) + { + self takeweapon( weapons[ i ] ); + } + i++; + } + } + weapons = self getweaponslist(); + wait 1; + self thread do_player_general_vox( "quest", "pick_up_easter_egg" ); +} + +bucket_init() +{ + s_bathtub = getstruct( "tub_trigger_struct", "targetname" ); + level.t_bathtub = spawn( "trigger_radius_use", s_bathtub.origin, 0, 40, 150 ); + level.t_bathtub usetriggerrequirelookat(); + level.t_bathtub triggerignoreteam(); + level.t_bathtub sethintstring( "" ); + level.t_bathtub setcursorhint( "HINT_NOICON" ); +} + +wait_for_bucket_activated( player ) +{ + if ( isDefined( player ) ) + { + while ( 1 ) + { + level.t_bathtub waittill( "trigger", who ); + if ( who == player ) + { + return; + } + } + } + else level.t_bathtub waittill( "trigger", who ); +} + +dip_the_spoon() +{ + self endon( "disconnect" ); + wait_for_bucket_activated( self ); + self takeweapon( "spoon_zm_alcatraz" ); + self giveweapon( "knife_zm_alcatraz" ); + self set_player_melee_weapon( "knife_zm_alcatraz" ); + self.spoon_in_tub = 1; + self setclientfieldtoplayer( "spoon_visual_state", 1 ); + wait 5; + level.b_spoon_in_tub = 1; + flag_wait( "charged_spoon" ); + wait 1; + level.t_bathtub playsound( "zmb_easteregg_laugh" ); + self thread thrust_the_spork(); +} + +thrust_the_spork() +{ + self endon( "disconnect" ); + wait_for_bucket_activated( self ); + self setclientfieldtoplayer( "spoon_visual_state", 2 ); + wait 5; + wait_for_bucket_activated( self ); + self takeweapon( "knife_zm_alcatraz" ); + self giveweapon( "spork_zm_alcatraz" ); + self set_player_melee_weapon( "spork_zm_alcatraz" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "spork", self ); + self.spoon_in_tub = undefined; + self setclientfieldtoplayer( "spoon_visual_state", 3 ); + wait 1; + self thread do_player_general_vox( "quest", "pick_up_easter_egg" ); +} + +debug_prison_spoon_quest() +{ +/# + while ( 1 ) + { + a_players = getplayers(); + _a377 = a_players; + _k377 = getFirstArrayKey( _a377 ); + while ( isDefined( _k377 ) ) + { + player = _a377[ _k377 ]; + if ( player hasweapon( "bouncing_tomahawk_zm" ) ) + { + flag_set( "soul_catchers_charged" ); + break; + } + else + { + _k377 = getNextArrayKey( _a377, _k377 ); + } + } + wait 1; +#/ + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_sq_bg.gsc b/zm_prison_patch/maps/mp/zm_prison_sq_bg.gsc new file mode 100644 index 0000000..8ff8515 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_sq_bg.gsc @@ -0,0 +1,287 @@ +#include maps/mp/zombies/_zm_weap_tomahawk; +#include maps/mp/zombies/_zm_afterlife; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +init() +{ + if ( isDefined( level.gamedifficulty ) && level.gamedifficulty == 0 ) + { + sq_bg_easy_cleanup(); + return; + } + precachemodel( "p6_zm_al_skull_afterlife" ); + flag_init( "warden_blundergat_obtained" ); + level thread wait_for_initial_conditions(); +} + +sq_bg_easy_cleanup() +{ + t_reward_pickup = getent( "sq_bg_reward_pickup", "targetname" ); + t_reward_pickup delete(); +} + +wait_for_initial_conditions() +{ + t_reward_pickup = getent( "sq_bg_reward_pickup", "targetname" ); + t_reward_pickup sethintstring( "" ); + t_reward_pickup setcursorhint( "HINT_NOICON" ); +/# + level thread debug_sq_bg_quest_starter(); +#/ + level waittill( "bouncing_tomahawk_zm_aquired" ); + level.sq_bg_macguffins = []; + a_s_mcguffin = getstructarray( "struct_sq_bg_macguffin", "targetname" ); + _a46 = a_s_mcguffin; + _k46 = getFirstArrayKey( _a46 ); + while ( isDefined( _k46 ) ) + { + struct = _a46[ _k46 ]; + m_temp = spawn( "script_model", struct.origin, 0 ); + m_temp.targetname = "sq_bg_macguffin"; + m_temp setmodel( struct.model ); + m_temp.angles = struct.angles; + m_temp ghost(); + m_temp ghostindemo(); + level.sq_bg_macguffins[ level.sq_bg_macguffins.size ] = m_temp; + wait_network_frame(); + _k46 = getNextArrayKey( _a46, _k46 ); + } + array_thread( level.sq_bg_macguffins, ::sq_bg_macguffin_think ); + level.a_tomahawk_pickup_funcs[ level.a_tomahawk_pickup_funcs.size ] = ::tomahawk_the_macguffin; + level thread check_sq_bg_progress(); + level waittill( "all_macguffins_acquired" ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "quest_generic" ); + t_reward_pickup thread give_sq_bg_reward(); +} + +sq_bg_macguffin_think() +{ + self endon( "sq_bg_macguffin_received_by_player" ); + self thread maps/mp/zombies/_zm_afterlife::enable_afterlife_prop(); + self.health = 10000; + self setcandamage( 1 ); + self setforcenocull(); + while ( 1 ) + { + self waittill( "damage", amount, attacker ); + if ( attacker == level || isplayer( attacker ) && attacker getcurrentweapon() == "lightning_hands_zm" ) + { + playfx( level._effect[ "ee_skull_shot" ], self.origin ); + self playsound( "zmb_powerpanel_activate" ); + self thread maps/mp/zombies/_zm_afterlife::disable_afterlife_prop(); + self thread wait_and_hide_sq_bg_macguffin(); + } + } +} + +wait_and_hide_sq_bg_macguffin() +{ + self notify( "restart_show_timer" ); + self endon( "restart_show_timer" ); + self endon( "caught_by_tomahawk" ); + wait 1,6; + self thread maps/mp/zombies/_zm_afterlife::enable_afterlife_prop(); +} + +tomahawk_the_macguffin( grenade, n_grenade_charge_power ) +{ + if ( !isDefined( level.sq_bg_macguffins ) || level.sq_bg_macguffins.size <= 0 ) + { + return 0; + } + _a119 = level.sq_bg_macguffins; + _k119 = getFirstArrayKey( _a119 ); + while ( isDefined( _k119 ) ) + { + macguffin = _a119[ _k119 ]; + if ( distancesquared( macguffin.origin, grenade.origin ) < 10000 ) + { + m_tomahawk = maps/mp/zombies/_zm_weap_tomahawk::tomahawk_spawn( grenade.origin ); + m_tomahawk.n_grenade_charge_power = n_grenade_charge_power; + macguffin notify( "caught_by_tomahawk" ); + macguffin.origin = grenade.origin; + macguffin linkto( m_tomahawk ); + macguffin thread maps/mp/zombies/_zm_afterlife::disable_afterlife_prop(); + self thread maps/mp/zombies/_zm_weap_tomahawk::tomahawk_return_player( m_tomahawk ); + self thread give_player_macguffin_upon_receipt( m_tomahawk, macguffin ); + return 1; + } + _k119 = getNextArrayKey( _a119, _k119 ); + } + return 0; +} + +give_player_macguffin_upon_receipt( m_tomahawk, m_macguffin ) +{ + self endon( "disconnect" ); + while ( isDefined( m_tomahawk ) ) + { + wait 0,05; + } + m_macguffin notify( "sq_bg_macguffin_received_by_player" ); + arrayremovevalue( level.sq_bg_macguffins, m_macguffin ); + m_macguffin delete(); + play_sound_at_pos( "purchase", self.origin ); + level notify( "sq_bg_macguffin_collected" ); +} + +check_sq_bg_progress() +{ + n_macguffins_total = level.sq_bg_macguffins.size; + n_macguffins_collected = 0; + while ( 1 ) + { + level waittill( "sq_bg_macguffin_collected", player ); + n_macguffins_collected++; + if ( n_macguffins_collected >= n_macguffins_total ) + { + level notify( "all_macguffins_acquired" ); + break; + } + else play_sq_bg_collected_vo( player ); + } + wait 1; + player playsound( "zmb_easteregg_laugh" ); +} + +play_sq_bg_collected_vo( player ) +{ + player endon( "disconnect" ); + wait 1; + player thread do_player_general_vox( "quest", "pick_up_easter_egg" ); +} + +give_sq_bg_reward() +{ + s_reward_origin = getstruct( "sq_bg_reward", "targetname" ); + t_near = spawn( "trigger_radius", s_reward_origin.origin, 0, 196, 64 ); + while ( 1 ) + { + t_near waittill( "trigger", ent ); + if ( isplayer( ent ) ) + { + t_near thread sq_bg_spawn_rumble(); + break; + } + else + { + wait 0,1; + } + } + a_players = getplayers(); + if ( a_players.size == 1 ) + { + if ( a_players[ 0 ] hasweapon( "blundergat_zm" ) ) + { + str_reward_weapon = "blundersplat_zm"; + str_loc = &"ZM_PRISON_SQ_BS"; + } + else + { + str_reward_weapon = "blundergat_zm"; + str_loc = &"ZM_PRISON_SQ_BG"; + } + } + else + { + str_reward_weapon = "blundergat_zm"; + str_loc = &"ZM_PRISON_SQ_BG"; + } + m_reward_model = spawn_weapon_model( str_reward_weapon, undefined, s_reward_origin.origin, s_reward_origin.angles ); + m_reward_model moveto( m_reward_model.origin + vectorScale( ( 0, 0, 1 ), 14 ), 5 ); + level setclientfield( "sq_bg_reward_portal", 1 ); + self sethintstring( str_loc ); + for ( ;; ) + { + while ( 1 ) + { + self waittill( "trigger", player ); + current_weapon = player getcurrentweapon(); + if ( is_player_valid( player ) && player.is_drinking > 0 && !is_placeable_mine( current_weapon ) && !is_equipment( current_weapon ) && level.revive_tool != current_weapon && current_weapon != "none" && !player hacker_active() ) + { + if ( player hasweapon( str_reward_weapon ) ) + { +/# + iprintln( "Player has" + str_reward_weapon + " , so don't give him another one" ); +#/ + } + } + else self delete(); + level setclientfield( "sq_bg_reward_portal", 0 ); + wait_network_frame(); + m_reward_model delete(); + player take_old_weapon_and_give_reward( current_weapon, str_reward_weapon ); + } + } + t_near delete(); +} + +sq_bg_spawn_rumble() +{ + a_players = getplayers(); + _a285 = a_players; + _k285 = getFirstArrayKey( _a285 ); + while ( isDefined( _k285 ) ) + { + player = _a285[ _k285 ]; + if ( player istouching( self ) ) + { + player setclientfieldtoplayer( "rumble_sq_bg", 1 ); + } + _k285 = getNextArrayKey( _a285, _k285 ); + } +} + +take_old_weapon_and_give_reward( current_weapon, reward_weapon, weapon_limit_override ) +{ + if ( !isDefined( weapon_limit_override ) ) + { + weapon_limit_override = 0; + } + if ( weapon_limit_override == 1 ) + { + self takeweapon( current_weapon ); + } + else + { + primaries = self getweaponslistprimaries(); + if ( isDefined( primaries ) && primaries.size >= 2 ) + { + self takeweapon( current_weapon ); + } + } + self giveweapon( reward_weapon ); + self switchtoweapon( reward_weapon ); + flag_set( "warden_blundergat_obtained" ); + self playsoundtoplayer( "vox_brutus_easter_egg_872_0", self ); +} + +debug_sq_bg_quest_starter() +{ +/# + while ( 1 ) + { + a_players = getplayers(); + _a327 = a_players; + _k327 = getFirstArrayKey( _a327 ); + while ( isDefined( _k327 ) ) + { + player = _a327[ _k327 ]; + if ( player hasweapon( "bouncing_tomahawk_zm" ) ) + { + level notify( "bouncing_tomahawk_zm_aquired" ); + break; + } + else + { + _k327 = getNextArrayKey( _a327, _k327 ); + } + } + wait 1; +#/ + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_sq_fc.gsc b/zm_prison_patch/maps/mp/zm_prison_sq_fc.gsc new file mode 100644 index 0000000..e8ffba8 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_sq_fc.gsc @@ -0,0 +1,162 @@ +#include maps/mp/zombies/_zm; +#include maps/mp/_visionset_mgr; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +onplayerconnect_sq_fc() +{ + if ( !isDefined( level.sq_fc_still_valid ) ) + { + level.sq_fc_still_valid = 1; + } + if ( flag( "afterlife_start_over" ) || !level.sq_fc_still_valid ) + { + return; + } + self thread watch_for_touching_controls(); +} + +watch_for_touching_controls() +{ + self endon( "out_of_mana" ); + self endon( "disconnect" ); + self waittill( "al_all_setup" ); + wait 1; + v_original_origin = ( self.origin[ 0 ], self.origin[ 1 ], 0 ); + v_original_angles = self.angles; + v_forward_point = self.origin + ( anglesToForward( self.angles ) * 10 ); + v_original_forward_vec = vectornormalize( v_forward_point - self.origin ); + while ( !flag( "afterlife_start_over" ) && level.sq_fc_still_valid ) + { + v_new_forward_point = self.origin + ( anglesToForward( self.angles ) * 10 ); + v_new_forward_vec = vectornormalize( v_new_forward_point - self.origin ); + move_length = length( ( self.origin[ 0 ], self.origin[ 1 ], 0 ) - v_original_origin ); + if ( !self actionslotonebuttonpressed() && !self actionslottwobuttonpressed() && !self actionslotthreebuttonpressed() && !self actionslotfourbuttonpressed() && !self adsbuttonpressed() && !self attackbuttonpressed() && !self fragbuttonpressed() && !self inventorybuttonpressed() && !self jumpbuttonpressed() && !self meleebuttonpressed() && !self secondaryoffhandbuttonpressed() && !self sprintbuttonpressed() && !self stancebuttonpressed() && !self throwbuttonpressed() && !self usebuttonpressed() && !self changeseatbuttonpressed() || move_length > 2 && vectordot( v_original_forward_vec, v_new_forward_vec ) < 0,99 ) + { + level.sq_fc_still_valid = 0; + } + wait 0,05; + } + level notify( "someone_touched_controls" ); +} + +watch_for_trigger_condition() +{ + level waittill( "pre_end_game" ); + if ( !level.sq_fc_still_valid ) + { + return; + } + level.sndgameovermusicoverride = "game_over_nomove"; + level.custom_intermission = ::player_intermission_prison; + players = getplayers(); + _a94 = players; + _k94 = getFirstArrayKey( _a94 ); + while ( isDefined( _k94 ) ) + { + player = _a94[ _k94 ]; + maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_audio_log", player ); + _k94 = getNextArrayKey( _a94, _k94 ); + } +} + +player_intermission_prison() +{ + self closemenu(); + self closeingamemenu(); + level endon( "stop_intermission" ); + self endon( "disconnect" ); + self endon( "death" ); + self notify( "_zombie_game_over" ); + self.score = self.score_total; + self.sessionstate = "intermission"; + self.spectatorclient = -1; + self.killcamentity = -1; + self.archivetime = 0; + self.psoffsettime = 0; + self.friendlydamage = undefined; + points = getstructarray( "dblock_cam", "targetname" ); + if ( !isDefined( points ) || points.size == 0 ) + { + points = getentarray( "info_intermission", "classname" ); + if ( points.size < 1 ) + { +/# + println( "NO info_intermission POINTS IN MAP" ); +#/ + return; + } + } + self.game_over_bg = newclienthudelem( self ); + self.game_over_bg.horzalign = "fullscreen"; + self.game_over_bg.vertalign = "fullscreen"; + self.game_over_bg setshader( "black", 640, 480 ); + self.game_over_bg.alpha = 1; + visionsetnaked( "cheat_bw", 0,05 ); + org = undefined; + while ( 1 ) + { + points = array_randomize( points ); + i = 0; + while ( i < points.size ) + { + point = points[ i ]; + if ( !isDefined( org ) ) + { + self spawn( point.origin, point.angles ); + } + if ( isDefined( points[ i ].target ) ) + { + if ( !isDefined( org ) ) + { + org = spawn( "script_model", self.origin + vectorScale( ( 0, 0, -1 ), 60 ) ); + org setmodel( "tag_origin" ); + } + org.origin = points[ i ].origin; + org.angles = points[ i ].angles; + j = 0; + while ( j < get_players().size ) + { + player = get_players()[ j ]; + player camerasetposition( org ); + player camerasetlookat(); + player cameraactivate( 1 ); + j++; + } + speed = 20; + if ( isDefined( points[ i ].speed ) ) + { + speed = points[ i ].speed; + } + target_point = getstruct( points[ i ].target, "targetname" ); + dist = distance( points[ i ].origin, target_point.origin ); + time = dist / speed; + q_time = time * 0,25; + if ( q_time > 1 ) + { + q_time = 1; + } + self.game_over_bg fadeovertime( q_time ); + self.game_over_bg.alpha = 0; + org moveto( target_point.origin, time, q_time, q_time ); + org rotateto( target_point.angles, time, q_time, q_time ); + wait ( time - q_time ); + self.game_over_bg fadeovertime( q_time ); + self.game_over_bg.alpha = 1; + wait q_time; + i++; + continue; + } + else + { + self.game_over_bg fadeovertime( 1 ); + self.game_over_bg.alpha = 0; + wait 5; + self.game_over_bg thread maps/mp/zombies/_zm::fade_up_over_time( 1 ); + } + i++; + } + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_sq_final.gsc b/zm_prison_patch/maps/mp/zm_prison_sq_final.gsc new file mode 100644 index 0000000..8f66cc6 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_sq_final.gsc @@ -0,0 +1,1057 @@ +#include maps/mp/zombies/_zm; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/zombies/_zm_ai_brutus; +#include maps/mp/zm_alcatraz_sq; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_laststand; +#include maps/mp/_visionset_mgr; +#include maps/mp/zm_alcatraz_sq_nixie; +#include maps/mp/zm_alcatraz_utility; +#include maps/mp/gametypes_zm/_hud; +#include maps/mp/gametypes_zm/_hud_util; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +onplayerconnect_sq_final() +{ +} + +stage_one() +{ + if ( isDefined( level.gamedifficulty ) && level.gamedifficulty == 0 ) + { + sq_final_easy_cleanup(); + return; + } + precachemodel( "p6_zm_al_audio_headset_icon" ); + flag_wait( "quest_completed_thrice" ); + flag_wait( "spoon_obtained" ); + flag_wait( "warden_blundergat_obtained" ); +/# + players = getplayers(); + _a51 = players; + _k51 = getFirstArrayKey( _a51 ); + while ( isDefined( _k51 ) ) + { + player = _a51[ _k51 ]; + player.fq_client_hint = newclienthudelem( player ); + player.fq_client_hint.x = 25; + player.fq_client_hint.y = 200; + player.fq_client_hint.alignx = "center"; + player.fq_client_hint.aligny = "bottom"; + player.fq_client_hint.fontscale = 1,6; + player.fq_client_hint.alpha = 1; + player.fq_client_hint.sort = 20; + player.fq_client_hint settext( 386 + " - " + 481 + " - " + 101 + " - " + 872 ); + _k51 = getNextArrayKey( _a51, _k51 ); +#/ + } + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + m_nixie_tube thread nixie_tube_scramble_protected_effects( i ); + i++; + } + level waittill_multiple( "nixie_tube_trigger_1", "nixie_tube_trigger_2", "nixie_tube_trigger_3" ); + level thread nixie_final_codes( 386 ); + level thread nixie_final_codes( 481 ); + level thread nixie_final_codes( 101 ); + level thread nixie_final_codes( 872 ); + level waittill_multiple( "nixie_final_" + 386, "nixie_final_" + 481, "nixie_final_" + 101, "nixie_final_" + 872 ); + nixie_tube_off(); +/# + players = getplayers(); + _a88 = players; + _k88 = getFirstArrayKey( _a88 ); + while ( isDefined( _k88 ) ) + { + player = _a88[ _k88 ]; + player.fq_client_hint destroy(); + _k88 = getNextArrayKey( _a88, _k88 ); +#/ + } + m_nixie_tube = getent( "nixie_tube_1", "targetname" ); + m_nixie_tube playsoundwithnotify( "vox_brutus_nixie_right_0", "scary_voice" ); + m_nixie_tube waittill( "scary_voice" ); + wait 3; + level thread stage_two(); +} + +sq_final_easy_cleanup() +{ + t_plane_fly_afterlife = getent( "plane_fly_afterlife_trigger", "script_noteworthy" ); + t_plane_fly_afterlife delete(); +} + +nixie_tube_off() +{ + level notify( "kill_nixie_input" ); + wait 1; + i = 1; + while ( i < 4 ) + { + m_nixie_tube = getent( "nixie_tube_" + i, "targetname" ); + j = 0; + while ( j < 10 ) + { + m_nixie_tube hidepart( "J_" + j ); + j++; + } + wait 0,3; + i++; + } +} + +nixie_final_codes( nixie_code ) +{ + maps/mp/zm_alcatraz_sq_nixie::nixie_tube_add_code( nixie_code ); + level waittill( "nixie_" + nixie_code ); + level notify( "kill_nixie_input" ); + flag_set( "nixie_puzzle_solved" ); + flag_clear( "nixie_ee_flashing" ); + goal_num_1 = maps/mp/zm_alcatraz_sq_nixie::get_split_number( 1, nixie_code ); + goal_num_2 = maps/mp/zm_alcatraz_sq_nixie::get_split_number( 2, nixie_code ); + goal_num_3 = maps/mp/zm_alcatraz_sq_nixie::get_split_number( 3, nixie_code ); + nixie_tube_win_effects_all_tubes_final( goal_num_2, goal_num_3, goal_num_1 ); + flag_set( "nixie_ee_flashing" ); + flag_clear( "nixie_puzzle_solved" ); + maps/mp/zm_alcatraz_sq_nixie::nixie_reset_control( 0 ); + level notify( "nixie_final_" + nixie_code ); +} + +nixie_tube_scramble_protected_effects( n_tube_index ) +{ + self endon( "nixie_scramble_stop" ); + level endon( "nixie_tube_trigger_" + n_tube_index ); + n_change_rate = 0,1; + unrestricted_scramble_num = []; + unrestricted_scramble_num[ 1 ] = array( 0, 2, 5, 6, 7 ); + unrestricted_scramble_num[ 2 ] = array( 2, 4, 5, 6, 9 ); + unrestricted_scramble_num[ 3 ] = array( 0, 3, 4, 7, 8, 9 ); + n_number_to_display = random( unrestricted_scramble_num[ n_tube_index ] ); + while ( 1 ) + { + self hidepart( "J_" + n_number_to_display ); + n_number_to_display = random( unrestricted_scramble_num[ n_tube_index ] ); + self showpart( "J_" + n_number_to_display ); + self playsound( "zmb_quest_nixie_count" ); + wait n_change_rate; + } +} + +nixie_final_audio_cue_code() +{ + m_nixie_tube = getent( "nixie_tube_1", "targetname" ); + m_nixie_tube playsoundwithnotify( "vox_brutus_nixie_right_0", "scary_voice" ); + m_nixie_tube waittill( "scary_voice" ); +} + +nixie_tube_win_effects_all_tubes_final( goal_num_1, goal_num_2, goal_num_3 ) +{ + if ( !isDefined( goal_num_1 ) ) + { + goal_num_1 = 0; + } + if ( !isDefined( goal_num_2 ) ) + { + goal_num_2 = 0; + } + if ( !isDefined( goal_num_3 ) ) + { + goal_num_3 = 0; + } + a_nixie_tube = []; + a_nixie_tube[ 1 ] = getent( "nixie_tube_1", "targetname" ); + a_nixie_tube[ 2 ] = getent( "nixie_tube_2", "targetname" ); + a_nixie_tube[ 3 ] = getent( "nixie_tube_3", "targetname" ); + n_off_tube = 1; + start_time = 0; + while ( start_time < 2 ) + { + i = 1; + while ( i < ( 3 + 1 ) ) + { + if ( i == n_off_tube ) + { + a_nixie_tube[ i ] hidepart( "J_" + level.a_nixie_tube_code[ i ] ); + i++; + continue; + } + else + { + a_nixie_tube[ i ] showpart( "J_" + level.a_nixie_tube_code[ i ] ); + if ( i == 1 || n_off_tube == 2 && i == 3 && n_off_tube == 1 ) + { + a_nixie_tube[ i ] playsound( "zmb_quest_nixie_count" ); + } + } + i++; + } + n_off_tube++; + if ( n_off_tube > 3 ) + { + n_off_tube = 1; + } + wait_network_frame(); + start_time += 0,15; + } + a_nixie_tube[ 1 ] showpart( "J_" + level.a_nixie_tube_code[ 1 ] ); + a_nixie_tube[ 2 ] showpart( "J_" + level.a_nixie_tube_code[ 2 ] ); + a_nixie_tube[ 3 ] showpart( "J_" + level.a_nixie_tube_code[ 3 ] ); + while ( level.a_nixie_tube_code[ 1 ] != goal_num_1 || level.a_nixie_tube_code[ 2 ] != goal_num_2 && level.a_nixie_tube_code[ 3 ] != goal_num_3 ) + { + n_current_tube = 1; + n_goal = goal_num_1; + if ( level.a_nixie_tube_code[ n_current_tube ] == goal_num_1 ) + { + n_current_tube = 2; + n_goal = goal_num_2; + if ( level.a_nixie_tube_code[ n_current_tube ] == goal_num_2 ) + { + n_current_tube = 3; + n_goal = goal_num_3; + } + } + wait_network_frame(); + j = 0; + while ( level.a_nixie_tube_code[ n_current_tube ] != n_goal ) + { + a_nixie_tube[ n_current_tube ] hidepart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + level.a_nixie_tube_code[ n_current_tube ]--; + + if ( level.a_nixie_tube_code[ n_current_tube ] == -1 ) + { + level.a_nixie_tube_code[ n_current_tube ] = 9; + } + a_nixie_tube[ n_current_tube ] showpart( "J_" + level.a_nixie_tube_code[ n_current_tube ] ); + if ( ( j % 3 ) == 0 ) + { + a_nixie_tube[ n_current_tube ] playsound( "zmb_quest_nixie_count" ); + } + j++; + wait 0,05; + } + } + a_nixie_tube[ 2 ] playsound( "zmb_quest_nixie_count_final" ); + wait_network_frame(); +} + +stage_two() +{ + audio_logs = []; + audio_logs[ 0 ] = []; + audio_logs[ 0 ][ 0 ] = "vox_guar_tour_vo_1_0"; + audio_logs[ 0 ][ 1 ] = "vox_guar_tour_vo_2_0"; + audio_logs[ 0 ][ 2 ] = "vox_guar_tour_vo_3_0"; + audio_logs[ 2 ] = []; + audio_logs[ 2 ][ 0 ] = "vox_guar_tour_vo_4_0"; + audio_logs[ 3 ] = []; + audio_logs[ 3 ][ 0 ] = "vox_guar_tour_vo_5_0"; + audio_logs[ 3 ][ 1 ] = "vox_guar_tour_vo_6_0"; + audio_logs[ 4 ] = []; + audio_logs[ 4 ][ 0 ] = "vox_guar_tour_vo_7_0"; + audio_logs[ 5 ] = []; + audio_logs[ 5 ][ 0 ] = "vox_guar_tour_vo_8_0"; + audio_logs[ 6 ] = []; + audio_logs[ 6 ][ 0 ] = "vox_guar_tour_vo_9_0"; + audio_logs[ 6 ][ 1 ] = "vox_guar_tour_vo_10_0"; + play_sq_audio_log( 0, audio_logs[ 0 ], 0 ); + i = 2; + while ( i <= 6 ) + { + play_sq_audio_log( i, audio_logs[ i ], 1 ); + i++; + } + level.m_headphones delete(); + t_plane_fly_afterlife = getent( "plane_fly_afterlife_trigger", "script_noteworthy" ); + t_plane_fly_afterlife playsound( "zmb_easteregg_laugh" ); + trigger_is_on = 0; + while ( 1 ) + { + players = getplayers(); + if ( players.size > 1 ) + { + arlington_is_present = 0; + _a339 = players; + _k339 = getFirstArrayKey( _a339 ); + while ( isDefined( _k339 ) ) + { + player = _a339[ _k339 ]; + if ( isDefined( player ) && player.character_name == "Arlington" ) + { + arlington_is_present = 1; + } + _k339 = getNextArrayKey( _a339, _k339 ); + } + if ( arlington_is_present && !trigger_is_on ) + { + t_plane_fly_afterlife trigger_on(); + trigger_is_on = 1; + } + else + { + if ( !arlington_is_present && trigger_is_on ) + { + t_plane_fly_afterlife trigger_off(); + trigger_is_on = 0; + } + } + } + else + { + if ( trigger_is_on ) + { + t_plane_fly_afterlife trigger_off(); + trigger_is_on = 0; + } + } + wait 0,1; + } +} + +headphones_rotate() +{ + self endon( "death" ); + while ( 1 ) + { + self rotateyaw( 360, 3 ); + self waittill( "rotatedone" ); + } +} + +play_sq_audio_log( num, a_vo, b_use_trig ) +{ + v_pos = getstruct( "sq_at_" + num, "targetname" ).origin; + if ( !isDefined( level.m_headphones ) ) + { + level.m_headphones = spawn( "script_model", v_pos ); + level.m_headphones ghostindemo(); + level.m_headphones setmodel( "p6_zm_al_audio_headset_icon" ); + playfxontag( level._effect[ "powerup_on" ], level.m_headphones, "tag_origin" ); + level.m_headphones thread headphones_rotate(); + level.m_headphones playloopsound( "zmb_spawn_powerup_loop" ); + level.m_headphones trigger_off(); + } + else + { + level.m_headphones trigger_on(); + level.m_headphones.origin = v_pos; + } + if ( b_use_trig ) + { + trigger = spawn( "trigger_radius", level.m_headphones.origin - vectorScale( ( 1, 1, 1 ), 80 ), 0, 30, 150 ); + trigger waittill( "trigger" ); + trigger delete(); + } + level.m_headphones trigger_off(); + level setclientfield( "toggle_futz", 1 ); + players = getplayers(); + _a411 = players; + _k411 = getFirstArrayKey( _a411 ); + while ( isDefined( _k411 ) ) + { + player = _a411[ _k411 ]; + maps/mp/_visionset_mgr::vsmgr_activate( "visionset", "zm_audio_log", player ); + _k411 = getNextArrayKey( _a411, _k411 ); + } + i = 0; + while ( i < a_vo.size ) + { + level.m_headphones playsoundwithnotify( a_vo[ i ], "at_done" ); + level.m_headphones waittill( "at_done" ); + wait 0,5; + i++; + } + level setclientfield( "toggle_futz", 0 ); + players = getplayers(); + _a426 = players; + _k426 = getFirstArrayKey( _a426 ); + while ( isDefined( _k426 ) ) + { + player = _a426[ _k426 ]; + maps/mp/_visionset_mgr::vsmgr_deactivate( "visionset", "zm_audio_log", player ); + _k426 = getNextArrayKey( _a426, _k426 ); + } +} + +final_flight_setup() +{ + t_plane_fly_afterlife = getent( "plane_fly_afterlife_trigger", "script_noteworthy" ); + t_plane_fly_afterlife thread final_flight_trigger(); + t_plane_fly_afterlife trigger_off(); +} + +final_flight_trigger() +{ + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + self setcursorhint( "HINT_NOICON" ); + self sethintstring( "" ); + while ( isDefined( self ) ) + { + self waittill( "trigger", e_triggerer ); + if ( isplayer( e_triggerer ) ) + { + while ( isDefined( level.custom_plane_validation ) ) + { + valid = self [[ level.custom_plane_validation ]]( e_triggerer ); + while ( !valid ) + { + continue; + } + } + players = getplayers(); + while ( players.size < 2 ) + { + continue; + } + b_everyone_is_ready = 1; + _a480 = players; + _k480 = getFirstArrayKey( _a480 ); + while ( isDefined( _k480 ) ) + { + player = _a480[ _k480 ]; + if ( isDefined( player ) || player.sessionstate == "spectator" && player maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + b_everyone_is_ready = 0; + } + _k480 = getNextArrayKey( _a480, _k480 ); + } + while ( !b_everyone_is_ready ) + { + continue; + } + while ( flag( "plane_is_away" ) ) + { + continue; + } + flag_set( "plane_is_away" ); + t_plane_fly trigger_off(); + _a504 = players; + _k504 = getFirstArrayKey( _a504 ); + while ( isDefined( _k504 ) ) + { + player = _a504[ _k504 ]; + if ( isDefined( player ) ) + { +/# + iprintlnbold( "LINK PLAYER TO PLANE, START COUNTDOWN IF NOT YET STARTED" ); +#/ + player thread final_flight_player_thread(); + } + _k504 = getNextArrayKey( _a504, _k504 ); + } + return; + } + } +} + +final_flight_player_thread() +{ + self endon( "death_or_disconnect" ); + self.on_a_plane = 1; + self.dontspeak = 1; + self setclientfieldtoplayer( "isspeaking", 1 ); +/# + iprintlnbold( "plane boarding thread started" ); +#/ + if ( isDefined( self.afterlife ) && !self.afterlife ) + { + self.keep_perks = 1; + self afterlife_remove(); + self.afterlife = 1; + self thread afterlife_laststand(); + self waittill( "player_fake_corpse_created" ); + } + self afterlife_infinite_mana( 1 ); + level.final_flight_activated = 1; + level.final_flight_players[ level.final_flight_players.size ] = self; + a_nml_teleport_targets = []; + i = 1; + while ( i < 6 ) + { + a_nml_teleport_targets[ i - 1 ] = getstruct( "nml_telepoint_" + i, "targetname" ); + i++; + } + self.n_passenger_index = level.final_flight_players.size; + a_players = []; + a_players = getplayers(); + if ( a_players.size == 1 ) + { + self.n_passenger_index = 1; + } + m_plane_craftable = getent( "plane_craftable", "targetname" ); + m_plane_about_to_crash = getent( "plane_about_to_crash", "targetname" ); + m_plane_about_to_crash ghost(); + veh_plane_flyable = getent( "plane_flyable", "targetname" ); + veh_plane_flyable show(); + flag_set( "plane_boarded" ); + t_plane_fly = getent( "plane_fly_trigger", "targetname" ); + str_hint_string = "BOARD FINAL FLIGHT"; + t_plane_fly sethintstring( str_hint_string ); + self playerlinktodelta( m_plane_craftable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + self allowcrouch( 1 ); + self allowstand( 0 ); + self clientnotify( "sndFFCON" ); + flag_wait( "plane_departed" ); + level notify( "sndStopBrutusLoop" ); + self clientnotify( "sndPS" ); + self playsoundtoplayer( "zmb_plane_takeoff", self ); + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "plane_takeoff", self ); + m_plane_craftable ghost(); + self playerlinktodelta( veh_plane_flyable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + self setclientfieldtoplayer( "effects_escape_flight", 1 ); + flag_wait( "plane_approach_bridge" ); + self thread maps/mp/zm_alcatraz_sq::snddelayedimp(); + self setclientfieldtoplayer( "effects_escape_flight", 2 ); + self unlink(); + self playerlinktoabsolute( veh_plane_flyable, "tag_player_crouched_" + ( self.n_passenger_index + 1 ) ); + flag_wait( "plane_zapped" ); + flag_set( "activate_player_zone_bridge" ); + self playsoundtoplayer( "zmb_plane_fall", self ); + self setclientfieldtoplayer( "effects_escape_flight", 3 ); + self.dontspeak = 1; + self setclientfieldtoplayer( "isspeaking", 1 ); + self playerlinktodelta( m_plane_about_to_crash, "tag_player_crouched_" + ( self.n_passenger_index + 1 ), 1, 0, 0, 0, 0, 1 ); + flag_wait( "plane_crashed" ); + self thread fadetoblackforxsec( 0, 2, 0, 0,5, "black" ); + self unlink(); + self allowstand( 1 ); + self setstance( "stand" ); + self allowcrouch( 0 ); + flag_clear( "spawn_zombies" ); + self setorigin( a_nml_teleport_targets[ self.n_passenger_index ].origin ); + e_poi = getstruct( "plane_crash_poi", "targetname" ); + vec_to_target = e_poi.origin - self.origin; + vec_to_target = vectorToAngle( vec_to_target ); + vec_to_target = ( 0, vec_to_target[ 1 ], 0 ); + self setplayerangles( vec_to_target ); + n_shellshock_duration = 5; + self shellshock( "explosion", n_shellshock_duration ); + self.on_a_plane = 0; + stage_final(); +} + +stage_final() +{ + level notify( "stage_final" ); + level endon( "stage_final" ); + b_everyone_alive = 0; + while ( isDefined( b_everyone_alive ) && !b_everyone_alive ) + { + b_everyone_alive = 1; + a_players = getplayers(); + _a648 = a_players; + _k648 = getFirstArrayKey( _a648 ); + while ( isDefined( _k648 ) ) + { + player = _a648[ _k648 ]; + if ( isDefined( player.afterlife ) && player.afterlife ) + { + b_everyone_alive = 0; + wait 0,05; + break; + } + else + { + _k648 = getNextArrayKey( _a648, _k648 ); + } + } + } + level._should_skip_ignore_player_logic = ::final_showdown_zombie_logic; + flag_set( "spawn_zombies" ); + array_func( getplayers(), ::maps/mp/zombies/_zm_afterlife::afterlife_remove ); + p_weasel = undefined; + a_player_team = []; + a_players = getplayers(); + _a671 = a_players; + _k671 = getFirstArrayKey( _a671 ); + while ( isDefined( _k671 ) ) + { + player = _a671[ _k671 ]; + player.dontspeak = 1; + player setclientfieldtoplayer( "isspeaking", 1 ); + if ( player.character_name == "Arlington" ) + { + p_weasel = player; + } + else a_player_team[ a_player_team.size ] = player; + _k671 = getNextArrayKey( _a671, _k671 ); + } + if ( isDefined( p_weasel ) && a_player_team.size > 0 ) + { + level.longregentime = 1000000; + level.playerhealth_regularregendelay = 1000000; + p_weasel.team = level.zombie_team; + p_weasel.pers[ "team" ] = level.zombie_team; + p_weasel.sessionteam = level.zombie_team; + p_weasel.maxhealth = a_player_team.size * 2000; + p_weasel.health = p_weasel.maxhealth; + _a698 = a_player_team; + _k698 = getFirstArrayKey( _a698 ); + while ( isDefined( _k698 ) ) + { + player = _a698[ _k698 ]; + player.maxhealth = 2000; + player.health = player.maxhealth; + _k698 = getNextArrayKey( _a698, _k698 ); + } + s_start_point = getstruct( "final_fight_starting_point_weasel", "targetname" ); + if ( isDefined( p_weasel ) && isDefined( s_start_point ) ) + { + playfx( level._effect[ "afterlife_teleport" ], p_weasel.origin ); + p_weasel setorigin( s_start_point.origin ); + p_weasel setplayerangles( s_start_point.angles ); + playfx( level._effect[ "afterlife_teleport" ], p_weasel.origin ); + } + i = 0; + while ( i < a_player_team.size ) + { + s_start_point = getstruct( "final_fight_starting_point_hero_" + ( i + 1 ), "targetname" ); + if ( isDefined( a_player_team[ i ] ) && isDefined( s_start_point ) ) + { + playfx( level._effect[ "afterlife_teleport" ], a_player_team[ i ].origin ); + a_player_team[ i ] setorigin( s_start_point.origin ); + a_player_team[ i ] setplayerangles( s_start_point.angles ); + playfx( level._effect[ "afterlife_teleport" ], a_player_team[ i ].origin ); + } + i++; + } + level thread final_showdown_track_weasel( p_weasel ); + level thread final_showdown_track_team( a_player_team ); + n_spawns_needed = 2; + i = n_spawns_needed; + while ( i > 0 ) + { + maps/mp/zombies/_zm_ai_brutus::brutus_spawn_in_zone( "zone_golden_gate_bridge", 1 ); + i--; + + } + level thread final_battle_vo( p_weasel, a_player_team ); + level notify( "pop_goes_the_weasel_achieved" ); + level waittill( "showdown_over" ); + } + else + { + if ( isDefined( p_weasel ) ) + { + level.winner = "weasel"; + } + else + { + level.winner = "team"; + } + } + level clientnotify( "sndSQF" ); + level.brutus_respawn_after_despawn = 0; + level thread clean_up_final_brutuses(); + wait 2; + if ( level.winner == "weasel" ) + { + a_players = getplayers(); + _a764 = a_players; + _k764 = getFirstArrayKey( _a764 ); + while ( isDefined( _k764 ) ) + { + player = _a764[ _k764 ]; + player freezecontrols( 1 ); + player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_ee_good_ending", 0 ); + player thread fadetoblackforxsec( 0, 5, 0,5, 0, "white" ); + player create_ending_message( &"ZM_PRISON_GOOD" ); + player.client_hint.sort = 55; + player.client_hint.color = ( 1, 1, 1 ); + playsoundatposition( "zmb_quest_final_white_good", ( 1, 1, 1 ) ); + level.sndgameovermusicoverride = "game_over_final_good"; + _k764 = getNextArrayKey( _a764, _k764 ); + } + level.custom_intermission = ::player_intermission_bridge; + } + else + { + a_players = getplayers(); + _a783 = a_players; + _k783 = getFirstArrayKey( _a783 ); + while ( isDefined( _k783 ) ) + { + player = _a783[ _k783 ]; + player freezecontrols( 1 ); + player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_ee_bad_ending", 0 ); + player thread fadetoblackforxsec( 0, 5, 0,5, 0, "white" ); + player create_ending_message( &"ZM_PRISON_BAD" ); + player.client_hint.sort = 55; + player.client_hint.color = ( 1, 1, 1 ); + playsoundatposition( "zmb_quest_final_white_bad", ( 1, 1, 1 ) ); + level.sndgameovermusicoverride = "game_over_final_bad"; + _k783 = getNextArrayKey( _a783, _k783 ); + } + } + wait 5; + a_players = getplayers(); + _a799 = a_players; + _k799 = getFirstArrayKey( _a799 ); + while ( isDefined( _k799 ) ) + { + player = _a799[ _k799 ]; + if ( isDefined( player.client_hint ) ) + { + player thread destroy_tutorial_message(); + } + if ( isDefined( player.revivetrigger ) ) + { + player thread revive_success( player, 0 ); + player cleanup_suicide_hud(); + } + if ( isDefined( player ) ) + { + player ghost(); + } + _k799 = getNextArrayKey( _a799, _k799 ); + } + if ( isDefined( p_weasel ) ) + { + p_weasel.team = "allies"; + p_weasel.pers[ "team" ] = "allies"; + p_weasel.sessionteam = "allies"; + p_weasel ghost(); + } + level notify( "end_game" ); +} + +final_showdown_track_weasel( p_weasel ) +{ + level endon( "showdown_over" ); + while ( 1 ) + { + if ( !isDefined( p_weasel ) || p_weasel maps/mp/zombies/_zm_laststand::player_is_in_laststand() ) + { + level.winner = "team"; + level notify( "showdown_over" ); + } + wait 0,05; + } +} + +final_showdown_track_team( a_player_team ) +{ + level endon( "showdown_over" ); + while ( 1 ) + { + weasel_won = 1; + _a855 = a_player_team; + _k855 = getFirstArrayKey( _a855 ); + while ( isDefined( _k855 ) ) + { + player = _a855[ _k855 ]; + if ( is_player_valid( player, 0, 0 ) ) + { + weasel_won = 0; + } + _k855 = getNextArrayKey( _a855, _k855 ); + } + if ( isDefined( weasel_won ) && weasel_won ) + { + level.winner = "weasel"; + level notify( "showdown_over" ); + } + wait 0,05; + } +} + +final_showdown_zombie_logic() +{ + a_players = getplayers(); + _a877 = a_players; + _k877 = getFirstArrayKey( _a877 ); + while ( isDefined( _k877 ) ) + { + player = _a877[ _k877 ]; + if ( player.character_name == "Arlington" ) + { + self.ignore_player[ self.ignore_player.size ] = player; + } + _k877 = getNextArrayKey( _a877, _k877 ); + } + return 1; +} + +final_showdown_create_icon( player, enemy ) +{ + height_offset = 60; + hud_elem = newclienthudelem( player ); + hud_elem.x = enemy.origin[ 0 ]; + hud_elem.y = enemy.origin[ 1 ]; + hud_elem.z = enemy.origin[ 2 ] + height_offset; + hud_elem.alpha = 1; + hud_elem.archived = 1; + hud_elem setshader( "waypoint_kill_red", 8, 8 ); + hud_elem setwaypoint( 1 ); + hud_elem.foreground = 1; + hud_elem.hidewheninmenu = 1; + hud_elem thread final_showdown_update_icon( enemy ); + waittill_any_ents( level, "showdown_over", enemy, "disconnect" ); + hud_elem destroy(); +} + +final_showdown_update_icon( enemy ) +{ + level endon( "showdown_over" ); + enemy endon( "disconnect" ); + height_offset = 60; + while ( isDefined( enemy ) ) + { + self.x = enemy.origin[ 0 ]; + self.y = enemy.origin[ 1 ]; + self.z = enemy.origin[ 2 ] + height_offset; + wait 0,05; + } +} + +revive_trigger_should_ignore_sight_checks( player_down ) +{ + if ( level.final_flight_activated ) + { + return 1; + } + return 0; +} + +final_battle_vo( p_weasel, a_player_team ) +{ + level endon( "showdown_over" ); + wait 10; + a_players = arraycopy( a_player_team ); + player = a_players[ randomintrange( 0, a_players.size ) ]; + arrayremovevalue( a_players, player ); + if ( a_players.size > 0 ) + { + player_2 = a_players[ randomintrange( 0, a_players.size ) ]; + } + if ( isDefined( player ) ) + { + player final_battle_reveal(); + } + wait 3; + if ( isDefined( p_weasel ) ) + { + p_weasel playsoundontag( "vox_plr_3_end_scenario_0", "J_Head" ); + } + wait 1; + _a967 = a_player_team; + _k967 = getFirstArrayKey( _a967 ); + while ( isDefined( _k967 ) ) + { + player = _a967[ _k967 ]; + level thread final_showdown_create_icon( player, p_weasel ); + level thread final_showdown_create_icon( p_weasel, player ); + _k967 = getNextArrayKey( _a967, _k967 ); + } + wait 10; + if ( isDefined( player_2 ) ) + { + player_2 playsoundontag( "vox_plr_" + player_2.characterindex + "_end_scenario_1", "J_Head" ); + } + else + { + if ( isDefined( player ) ) + { + player playsoundontag( "vox_plr_" + player.characterindex + "_end_scenario_1", "J_Head" ); + } + } + wait 4; + if ( isDefined( p_weasel ) ) + { + p_weasel playsoundontag( "vox_plr_3_end_scenario_1", "J_Head" ); + p_weasel.dontspeak = 0; + p_weasel setclientfieldtoplayer( "isspeaking", 0 ); + } + _a996 = a_player_team; + _k996 = getFirstArrayKey( _a996 ); + while ( isDefined( _k996 ) ) + { + player = _a996[ _k996 ]; + player.dontspeak = 0; + player setclientfieldtoplayer( "isspeaking", 0 ); + _k996 = getNextArrayKey( _a996, _k996 ); + } +} + +final_battle_reveal() +{ + self endon( "death_or_disconnect" ); + self playsoundwithnotify( "vox_plr_" + self.characterindex + "_end_scenario_0", "showdown_icon_reveal" ); + self waittill( "showdown_icon_reveal" ); +} + +player_intermission_bridge() +{ + self closemenu(); + self closeingamemenu(); + level endon( "stop_intermission" ); + self endon( "disconnect" ); + self endon( "death" ); + self notify( "_zombie_game_over" ); + self.score = self.score_total; + self.sessionstate = "intermission"; + self.spectatorclient = -1; + self.killcamentity = -1; + self.archivetime = 0; + self.psoffsettime = 0; + self.friendlydamage = undefined; + points = getstructarray( "final_cam", "targetname" ); + if ( !isDefined( points ) || points.size == 0 ) + { + points = getentarray( "info_intermission", "classname" ); + if ( points.size < 1 ) + { +/# + println( "NO info_intermission POINTS IN MAP" ); +#/ + return; + } + } + self.game_over_bg = newclienthudelem( self ); + self.game_over_bg.horzalign = "fullscreen"; + self.game_over_bg.vertalign = "fullscreen"; + self.game_over_bg setshader( "black", 640, 480 ); + self.game_over_bg.alpha = 1; + org = undefined; + while ( 1 ) + { + points = array_randomize( points ); + i = 0; + while ( i < points.size ) + { + point = points[ i ]; + if ( !isDefined( org ) ) + { + self spawn( point.origin, point.angles ); + } + if ( isDefined( points[ i ].target ) ) + { + if ( !isDefined( org ) ) + { + org = spawn( "script_model", self.origin + vectorScale( ( 1, 1, 1 ), 60 ) ); + org setmodel( "tag_origin" ); + } + org.origin = points[ i ].origin; + org.angles = points[ i ].angles; + j = 0; + while ( j < get_players().size ) + { + player = get_players()[ j ]; + player camerasetposition( org ); + player camerasetlookat(); + player cameraactivate( 1 ); + j++; + } + speed = 20; + if ( isDefined( points[ i ].speed ) ) + { + speed = points[ i ].speed; + } + target_point = getstruct( points[ i ].target, "targetname" ); + dist = distance( points[ i ].origin, target_point.origin ); + time = dist / speed; + q_time = time * 0,25; + if ( q_time > 1 ) + { + q_time = 1; + } + self.game_over_bg fadeovertime( q_time ); + self.game_over_bg.alpha = 0; + org moveto( target_point.origin, time, q_time, q_time ); + org rotateto( target_point.angles, time, q_time, q_time ); + wait ( time - q_time ); + self.game_over_bg fadeovertime( q_time ); + self.game_over_bg.alpha = 1; + wait q_time; + i++; + continue; + } + else + { + self.game_over_bg fadeovertime( 1 ); + self.game_over_bg.alpha = 0; + wait 5; + self.game_over_bg thread maps/mp/zombies/_zm::fade_up_over_time( 1 ); + } + i++; + } + } +} + +create_ending_message( str_msg ) +{ + if ( !isDefined( self.client_hint ) ) + { + self.client_hint = newclienthudelem( self ); + self.client_hint.alignx = "center"; + self.client_hint.aligny = "middle"; + self.client_hint.horzalign = "center"; + self.client_hint.vertalign = "bottom"; + if ( self issplitscreen() ) + { + self.client_hint.y = -140; + } + else + { + self.client_hint.y = -250; + } + self.client_hint.foreground = 1; + self.client_hint.font = "default"; + self.client_hint.fontscale = 50; + self.client_hint.alpha = 1; + self.client_hint.foreground = 1; + self.client_hint.hidewheninmenu = 1; + self.client_hint.color = ( 1, 1, 1 ); + } + self.client_hint settext( str_msg ); +} + +custom_game_over_hud_elem( player ) +{ + game_over = newclienthudelem( player ); + game_over.alignx = "center"; + game_over.aligny = "middle"; + game_over.horzalign = "center"; + game_over.vertalign = "middle"; + game_over.y -= 130; + game_over.foreground = 1; + game_over.fontscale = 3; + game_over.alpha = 0; + game_over.color = ( 1, 1, 1 ); + game_over.hidewheninmenu = 1; + if ( isDefined( level.winner ) ) + { + game_over settext( &"ZM_PRISON_LIFE_OVER" ); + } + else + { + game_over settext( &"ZOMBIE_GAME_OVER" ); + } + game_over fadeovertime( 1 ); + game_over.alpha = 1; + if ( player issplitscreen() ) + { + game_over.fontscale = 2; + game_over.y += 40; + } + return game_over; +} + +clean_up_final_brutuses() +{ + while ( 1 ) + { + zombies = getaispeciesarray( "axis", "all" ); + i = 0; + while ( i < zombies.size ) + { + zombies[ i ] dodamage( 10000, zombies[ i ].origin ); + i++; + } + wait 1; + } +} diff --git a/zm_prison_patch/maps/mp/zm_prison_sq_wth.gsc b/zm_prison_patch/maps/mp/zm_prison_sq_wth.gsc new file mode 100644 index 0000000..050b566 --- /dev/null +++ b/zm_prison_patch/maps/mp/zm_prison_sq_wth.gsc @@ -0,0 +1,108 @@ +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_net; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +onplayerconnect_sq_wth() +{ + if ( !isDefined( level.wth_lookat_point ) ) + { + level.wth_lookat_point = getstruct( "struct_gg_look", "targetname" ); + } + self thread track_player_eyes(); + self thread play_scary_lightning(); +} + +track_player_eyes() +{ + self endon( "disconnect" ); + b_saw_the_wth = 0; + while ( !b_saw_the_wth ) + { + n_time = 0; + while ( self adsbuttonpressed() && n_time < 25 ) + { + n_time++; + wait 0,05; + } + if ( n_time >= 25 && self adsbuttonpressed() && self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_roof" ) && sq_is_weapon_sniper( self getcurrentweapon() ) && is_player_looking_at( level.wth_lookat_point.origin, 0,9, 0, undefined ) ) + { + self do_player_general_vox( "general", "scare_react", undefined, 100 ); + self playsoundtoplayer( "zmb_easteregg_face", self ); + self.wth_elem = newclienthudelem( self ); + self.wth_elem.horzalign = "fullscreen"; + self.wth_elem.vertalign = "fullscreen"; + self.wth_elem.sort = 1000; + self.wth_elem.foreground = 0; + self.wth_elem setshader( "zm_al_wth_zombie", 640, 480 ); + self.wth_elem.hidewheninmenu = 1; + j_time = 0; + while ( self adsbuttonpressed() && j_time < 5 ) + { + j_time++; + wait 0,05; + } + self.wth_elem destroy(); + b_saw_the_wth = 1; + } + wait 0,05; + } +} + +sq_is_weapon_sniper( str_weapon ) +{ + a_snipers = array( "dsr50", "barretm82" ); + _a77 = a_snipers; + _k77 = getFirstArrayKey( _a77 ); + while ( isDefined( _k77 ) ) + { + str_sniper = _a77[ _k77 ]; + if ( issubstr( str_weapon, str_sniper ) && !issubstr( str_weapon, "+is" ) ) + { + return 1; + } + _k77 = getNextArrayKey( _a77, _k77 ); + } + return 0; +} + +play_scary_lightning() +{ + self endon( "disconnect" ); + while ( 1 ) + { + while ( self maps/mp/zombies/_zm_zonemgr::is_player_in_zone( "zone_golden_gate_bridge" ) && isDefined( self.b_lightning ) || !self.b_lightning && flag( "plane_zapped" ) ) + { + wait 0,25; + } + if ( randomint( 100000 ) == 1337 ) + { + self.scary_lighting = 1; + level setclientfield( "scripted_lightning_flash", 1 ); + wait_network_frame(); + self.sl_elem = newclienthudelem( self ); + self.sl_elem.horzalign = "fullscreen"; + self.sl_elem.vertalign = "fullscreen"; + self.sl_elem.sort = 1000; + self.sl_elem.foreground = 0; + self.sl_elem.alpha = 0,6; + self.sl_elem setshader( "zm_al_wth_zombie", 640, 480 ); + self.sl_elem.hidewheninmenu = 1; + self.sl_elem.alpha = 0; + self.sl_elem fadeovertime( 0,1 ); + wait_network_frame(); + self.sl_elem.alpha = 0,6; + self.sl_elem fadeovertime( 0,1 ); + wait_network_frame(); + self.sl_elem.alpha = 0; + self.sl_elem fadeovertime( 0,1 ); + wait_network_frame(); + self.sl_elem destroy(); + self.scary_lightning = 0; + wait 10; + level setclientfield( "scripted_lightning_flash", 0 ); + } + wait 1; + } +}