From f741460f7a59353434ad3e5290afd9bc70107739 Mon Sep 17 00:00:00 2001 From: JezuzLizard Date: Sat, 4 Jul 2020 09:05:54 -0700 Subject: [PATCH] reorganized pluto specific fixes Also added 8 player origins fix. --- .../8 Player Origins Fix/zm_tomb_amb.gsc | 677 ++++++++ .../zm_tomb_craftables.gsc | 1458 +++++++++++++++++ .../8 Player Origins Fix/zm_tomb_dig.gsc | 1023 ++++++++++++ .../_zm_audio_announcer.gsc | 0 .../{ => MP Bots fix}/_bot.gsc | 0 .../zm_transit_utility.gsc | 0 .../readme.md | 18 +- 7 files changed, 3172 insertions(+), 4 deletions(-) create mode 100644 Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_amb.gsc create mode 100644 Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_craftables.gsc create mode 100644 Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_dig.gsc rename Plutonium specific gsc-related fixes/{ => Audio Announcer Fix}/_zm_audio_announcer.gsc (100%) rename Plutonium specific gsc-related fixes/{ => MP Bots fix}/_bot.gsc (100%) rename Plutonium specific gsc-related fixes/{ => Tombstone Fix}/zm_transit_utility.gsc (100%) diff --git a/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_amb.gsc b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_amb.gsc new file mode 100644 index 0000000..9a502cd --- /dev/null +++ b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_amb.gsc @@ -0,0 +1,677 @@ +//checked includes match cerberus output +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_sidequests; +#include maps/mp/_ambientpackage; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +main() //checked matches cerberus output +{ + level thread sndsetupendgamemusicstates(); + if ( is_classic() ) + { + thread sndmusicegg(); + thread snd115egg(); + thread sndstingersetup(); + onplayerconnect_callback( ::sndtrackers ); + level thread sndmaelstrom(); + } +} + +sndsetupendgamemusicstates() //checked matches cerberus output +{ + flag_wait( "start_zombie_round_logic" ); + level thread maps/mp/zombies/_zm_audio::setupmusicstate( "game_over_ee", "mus_zombie_game_over_ee", 1, 0, undefined, "SILENCE" ); +} + +sndtrackers() //checked matches cerberus output +{ +} + +sndstingersetup() //checked matches cerberus output +{ + 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; + flag_wait( "start_zombie_round_logic" ); + level sndstingersetupstates(); + level thread sndstingerroundwait(); + level thread sndboardmonitor(); + level thread locationstingerwait(); + level thread snddoormusictrigs(); +} + +sndstingersetupstates() //checked matches cerberus output +{ + createstingerstate( "door_open", "mus_event_group_03", 2.5, "ignore" ); + createstingerstate( "boards_gone", "mus_event_group_02", 0.5, "ignore" ); + createstingerstate( "zone_nml_18", "mus_event_location_hilltop", 0.75, "queue" ); + createstingerstate( "zone_village_2", "mus_event_location_church", 0.75, "queue" ); + createstingerstate( "ug_bottom_zone", "mus_event_location_crypt", 0.75, "queue" ); + createstingerstate( "zone_robot_head", "mus_event_location_robot", 0.75, "queue" ); + createstingerstate( "zone_air_stairs", "mus_event_cave_air", 0.75, "queue" ); + createstingerstate( "zone_fire_stairs", "mus_event_cave_fire", 0.75, "queue" ); + createstingerstate( "zone_bolt_stairs", "mus_event_cave_bolt", 0.75, "queue" ); + createstingerstate( "zone_ice_stairs", "mus_event_cave_ice", 0.75, "queue" ); + createstingerstate( "poweron", "mus_event_poweron", 0, "reject" ); + createstingerstate( "tank_ride", "mus_event_tank_ride", 0, "queue" ); + createstingerstate( "generator_1", "mus_event_generator_1", 1, "reject" ); + createstingerstate( "generator_2", "mus_event_generator_2", 1, "reject" ); + createstingerstate( "generator_3", "mus_event_generator_3", 1, "reject" ); + createstingerstate( "generator_4", "mus_event_generator_4", 1, "reject" ); + createstingerstate( "generator_5", "mus_event_generator_5", 1, "reject" ); + createstingerstate( "generator_6", "mus_event_generator_6", 1, "reject" ); + createstingerstate( "staff_fire", "mus_event_staff_fire", 0.1, "reject" ); + createstingerstate( "staff_ice", "mus_event_staff_ice", 0.1, "reject" ); + createstingerstate( "staff_lightning", "mus_event_staff_lightning", 0.1, "reject" ); + createstingerstate( "staff_wind", "mus_event_staff_wind", 0.1, "reject" ); + createstingerstate( "staff_fire_upgraded", "mus_event_staff_fire_upgraded", 0.1, "reject" ); + createstingerstate( "staff_ice_upgraded", "mus_event_staff_ice_upgraded", 0.1, "reject" ); + createstingerstate( "staff_lightning_upgraded", "mus_event_staff_lightning_upgraded", 0.1, "reject" ); + createstingerstate( "staff_wind_upgraded", "mus_event_staff_wind_upgraded", 0.1, "reject" ); + createstingerstate( "staff_all_upgraded", "mus_event_staff_all_upgraded", 0.1, "reject" ); + createstingerstate( "side_sting_1", "mus_side_stinger_1", 0.1, "reject" ); + createstingerstate( "side_sting_2", "mus_side_stinger_2", 0.1, "reject" ); + createstingerstate( "side_sting_3", "mus_side_stinger_3", 0.1, "reject" ); + createstingerstate( "side_sting_4", "mus_side_stinger_4", 0.1, "reject" ); + createstingerstate( "side_sting_5", "mus_side_stinger_5", 0.1, "reject" ); + createstingerstate( "side_sting_6", "mus_side_stinger_6", 0.1, "reject" ); +} + +createstingerstate( state, alias, prewait, interrupt ) //checked matches cerberus output +{ + 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; + } +} + +sndboardmonitor() //checked changed to match cerberus output +{ + while ( 1 ) + { + level waittill( "last_board_torn", barrier_origin ); + players = getplayers(); + foreach ( player in players ) + { + if ( distancesquared( player.origin, barrier_origin ) <= 22500 ) + { + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "boards_gone" ); + break; + } + } + } +} + +locationstingerwait( zone_name, type ) //checked changed to match cerberus output +{ + array = sndlocationsarray(); + sndnorepeats = 3; + numcut = 0; + level.sndlastzone = undefined; + level.sndlocationplayed = 0; + level thread sndlocationbetweenroundswait(); + while ( 1 ) + { + level waittill( "newzoneActive", activezone ); + wait 0.1; + if ( !sndlocationshouldplay( array, activezone ) ) + { + continue; + } + if ( is_true( level.sndroundwait ) ) + { + continue; + } + else if ( is_true( level.sndstinger.isplaying ) ) + { + level thread sndlocationqueue( activezone ); + continue; + } + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( activezone ); + level.sndlocationplayed = 1; + 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; + } + level.sndlocationplayed = 0; + } +} + +sndlocationsarray() //checked matches cerberus output +{ + array = []; + array[ 0 ] = "zone_nml_18"; + array[ 1 ] = "zone_village_2"; + array[ 2 ] = "ug_bottom_zone"; + array[ 3 ] = "zone_air_stairs"; + array[ 4 ] = "zone_fire_stairs"; + array[ 5 ] = "zone_bolt_stairs"; + array[ 6 ] = "zone_ice_stairs"; + return array; +} + +sndlocationshouldplay( array, activezone ) //checked changed to match cerberus output +{ + shouldplay = 0; + if ( activezone == "zone_start_lower" && !flag( "fountain_transport_active" ) ) + { + return shouldplay; + } + if ( is_true( level.music_override ) ) + { + return shouldplay; + } + foreach ( place in array ) + { + if ( place == activezone ) + { + shouldplay = 1; + } + } + if ( shouldplay == 0 ) + { + return shouldplay; + } + playersinlocal = 0; + players = getplayers(); + foreach ( player in players ) + { + if ( player maps/mp/zombies/_zm_zonemgr::is_player_in_zone( activezone ) ) + { + if ( !is_true( player.afterlife ) ) + { + playersinlocal++; + } + } + } + if ( playersinlocal >= 1 ) + { + shouldplay = 1; + } + else + { + shouldplay = 0; + } + return shouldplay; +} + +sndcurrentlocationarray( current_array, activezone, numcut, max_num_removed ) //checked changed to match cerberus output +{ + if ( numcut >= max_num_removed ) + { + current_array = sndlocationsarray(); + } + foreach ( place in current_array ) + { + if ( place == activezone ) + { + arrayremovevalue( current_array, place ); + break; + } + } + return current_array; +} + +sndlocationbetweenrounds() //checked partially changed to match cerberus output see info.md +{ + level endon( "newzoneActive" ); + activezones = maps/mp/zombies/_zm_zonemgr::get_active_zone_names(); + foreach ( zone in activezones ) + { + if ( isDefined( level.sndlastzone ) && zone == level.sndlastzone ) + { + } + else + { + players = getplayers(); + for ( i = 0; i < players.size; i++ ) + { + if ( is_true( players[ i ].afterlife ) ) + { + } + else + { + if ( players[ i ] maps/mp/zombies/_zm_zonemgr::is_player_in_zone( zone ) ) + { + wait 0.1; + level notify( "newzoneActive" ); + return; + } + } + } + } + } +} + +sndlocationbetweenroundswait() //checked matches cerberus output +{ + 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 ) //checked matches cerberus output +{ + level endon( "newzoneActive" ); + while ( is_true( level.sndstinger.isplaying ) ) + { + wait 0.5; + } + level notify( "newzoneActive" ); +} + +sndplaystinger( state, player ) //checked changed to match cerberus output +{ + 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 ) //checked matches cerberus output +{ + 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 ); + s.ent thread playstingerstop(); + } + } + else if ( isDefined( player ) ) + { + player playsoundtoplayer( s.states[ state ].alias, player ); + wait 8; + } + else + { + s.ent playsoundwithnotify( s.states[ state ].alias, "sndStingerDone" ); + s.ent thread playstingerstop(); + s.ent waittill( "sndStingerDone" ); + } +} + +sndqueuestinger( state, player ) //checked changed to match cerberus output +{ + s = level.sndstinger; + count = 0; + if ( is_true( s.queue ) ) + { + return; + } + else + { + s.queue = 1; + while ( 1 ) + { + if ( is_true( level.sndroundwait ) || is_true( s.isplaying ) ) + { + wait 0.5; + count++; + if ( count >= 120 ) + { + return; + } + } + else + { + break; + } + } + level thread sndplaystinger( state, player ); + s.queue = 0; + } +} + +sndstingerroundwait() //checked matches cerberus output +{ + wait 25; + level.sndroundwait = 0; + while ( 1 ) + { + level waittill( "end_of_round" ); + level thread sndstingerroundwait_start(); + } +} + +sndstingerroundwait_start() //checked matches cerberus output +{ + level.sndroundwait = 1; + wait 0.05; + level thread sndstingerroundwait_end(); +} + +sndstingerroundwait_end() //checked matches cerberus output +{ + level endon( "end_of_round" ); + level waittill( "between_round_over" ); + wait 28; + level.sndroundwait = 0; +} + +playstingerstop() //checked matches cerberus output +{ + self endon( "sndStingerDone" ); + level endon( "sndStingerDone" ); + level waittill_any( "end_of_round", "sndStingerForceStop" ); + wait 2; + self stopsounds(); +} + +sndmusicegg() //checked changed to match cerberus output +{ + origins = []; + origins[ 0 ] = ( 2682.23, 4456.15, -302.352 ); + origins[ 1 ] = ( 721.043, -87.7068, 285.986 ); + origins[ 2 ] = ( -674.048, 2536.67, -112.483 ); + level.meteor_counter = 0; + level.music_override = 0; + for ( i = 0; i < origins.size; i++ ) + { + level thread sndmusicegg_wait( origins[ i ] ); + } +} + +sndmusicegg_wait( bottle_origin ) //checked matches cerberus output +{ + 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", 310 ); + } + else + { + wait 1.5; + temp_ent delete(); + } +} + +sndmusicegg_override() //checked matches cerberus output +{ + if ( is_true( level.music_override ) ) + { + return 0; + } + return 1; +} + +sndmuseggplay( ent, alias, time ) //checked matches cerberus output +{ + level.music_override = 1; + wait 1; + ent playsound( alias ); + level setclientfield( "mus_zmb_egg_snapshot_loop", 1 ); + level notify( "sndStingerForceStop" ); + level thread sndeggmusicwait( time ); + level waittill_either( "end_game", "sndSongDone" ); + ent stopsounds(); + level setclientfield( "mus_zmb_egg_snapshot_loop", 0 ); + wait 0.05; + ent delete(); + level.music_override = 0; +} + +sndeggmusicwait( time ) //checked matches cerberus output +{ + level endon( "end_game" ); + wait time; + level notify( "sndSongDone" ); +} + +sndplaystingerwithoverride( alias, length ) //checked matches cerberus output +{ + shouldplay = sndwait(); + if ( !shouldplay ) + { + return; + } + level.music_override = 1; + level setclientfield( "mus_zmb_egg_snapshot_loop", 1 ); + level notify( "sndStingerForceStop" ); + ent = spawn( "script_origin", ( 0, 0, 0 ) ); + ent playsound( alias ); + wait length; + level setclientfield( "mus_zmb_egg_snapshot_loop", 0 ); + level.music_override = 0; + wait 0.05; + ent delete(); +} + +sndwait() //checked matches cerberus output +{ + counter = 0; + while ( is_true( level.music_override ) ) + { + wait 1; + counter++; + if ( counter >= 60 ) + { + return 0; + } + } + return 1; +} + +snddoormusictrigs() //checked changed to match cerberus output +{ + trigs = getentarray( "sndMusicDoor", "script_noteworthy" ); + foreach ( trig in trigs ) + { + trig thread snddoormusic(); + } +} + +snddoormusic() //checked changed to match cerberus output +{ + self endon( "sndDoorMusic_Triggered" ); + while ( 1 ) + { + self waittill( "trigger" ); + if ( is_true( level.music_override ) ) + { + wait 0.1; + } + else + { + break; + } + } + if ( isDefined( self.target ) ) + { + ent = getent( self.target, "targetname" ); + ent notify( "sndDoorMusic_Triggered" ); + } + level thread sndplaystingerwithoverride( self.script_sound, self.script_int ); +} + +sndmaelstrom() //checked matches cerberus output +{ + trig = getent( "sndMaelstrom", "targetname" ); + if ( !isDefined( trig ) ) + { + return; + } + while ( 1 ) + { + trig waittill( "trigger", who ); + if ( isplayer( who ) && !is_true( who.sndmaelstrom ) ) + { + who.sndmaelstrom = 1; + triggerPlayer = who getentitynumber(); + if ( triggerPlayer <= 3 ) + { + level setclientfield( "sndMaelstromPlr" + triggerplayer, 1 ); + } + } + who thread sndmaelstrom_timeout(); + wait 0.1; + } +} + +sndmaelstrom_timeout() //checked matches cerberus output +{ + self notify( "sndMaelstrom_Timeout" ); + self endon( "sndMaelstrom_Timeout" ); + wait 2; + self.sndmaelstrom = 0; + triggerPlayer = who getentitynumber(); + if ( triggerPlayer <= 3 ) + { + level setclientfield( "sndMaelstromPlr" + triggerplayer, 1 ); + } +} + +snd115egg() //checked changed to match cerberus output +{ + level.snd115count = 0; + oneorigin = []; + oneorigin[ 0 ] = ( 2168, 4617, -289 ); + oneorigin[ 1 ] = ( 2170, 4953, -289 ); + fiveorigin = []; + fiveorigin[ 0 ] = ( -2459, 176, 243 ); + fiveorigin[ 1 ] = ( -2792, 175, 243 ); + foreach ( origin in oneorigin ) + { + level thread snd115egg_wait( origin, 0 ); + } + foreach ( origin in fiveorigin ) + { + level thread snd115egg_wait( origin, 1 ); + } +} + +snd115egg_wait( origin, shouldwait ) //checked matches cerberus output +{ + level endon( "sndEnd115" ); + temp_ent = spawn( "script_origin", origin ); + temp_ent thread snddelete115ent(); + if ( shouldwait ) + { + temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::snd115egg_5_override ); + } + else + { + temp_ent thread maps/mp/zombies/_zm_sidequests::fake_use( "main_music_egg_hit", ::snd115egg_1_override ); + } + temp_ent waittill( "main_music_egg_hit", player ); + player playsound( "zmb_meteor_activate" ); + level.snd115count++; + if ( level.snd115count == 3 ) + { + temp_ent notify( "sndDeleting" ); + level thread sndmuseggplay( temp_ent, "mus_zmb_secret_song_aether", 135 ); + level notify( "sndEnd115" ); + } + else + { + temp_ent notify( "sndDeleting" ); + temp_ent delete(); + } +} + +snd115egg_1_override() //checked matches cerberus output +{ + stance = self getstance(); + if ( is_true( level.music_override ) || stance != "prone" ) + { + return 0; + } + return 1; +} + +snd115egg_5_override() //checked matches cerberus output +{ + stance = self getstance(); + if ( !is_true( level.music_override ) || stance != "prone" || level.snd115count < 2 ) + { + return 0; + } + return 1; +} + +snddelete115ent() //checked matches cerberus output +{ + self endon( "sndDeleting" ); + level waittill( "sndEnd115" ); + self delete(); +} + + diff --git a/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_craftables.gsc b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_craftables.gsc new file mode 100644 index 0000000..c69daaf --- /dev/null +++ b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_craftables.gsc @@ -0,0 +1,1458 @@ +#include maps/mp/zombies/_zm_equipment; +#include maps/mp/zombies/_zm_ai_quadrotor; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zombies/_zm_unitrigger; +#include maps/mp/zm_tomb_vo; +#include maps/mp/zm_tomb_main_quest; +#include maps/mp/zm_tomb_utility; +#include maps/mp/zombies/_zm_weapons; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/zombies/_zm_craftables; +#include maps/mp/_utility; +#include common_scripts/utility; + +randomize_craftable_spawns() //checked partially changed to match cerberus output see info.md +{ + a_randomized_craftables = array( "gramophone_vinyl_ice", "gramophone_vinyl_air", "gramophone_vinyl_elec", "gramophone_vinyl_fire", "gramophone_vinyl_master", "gramophone_vinyl_player" ); + foreach ( str_craftable in a_randomized_craftables ) + { + s_original_pos = getstruct( str_craftable, "targetname" ); + a_alt_locations = getstructarray( str_craftable + "_alt", "targetname" ); + n_loc_index = randomintrange( 0, a_alt_locations.size + 1 ); + if ( n_loc_index == a_alt_locations.size ) + { + } + else + { + s_original_pos.origin = a_alt_locations[ n_loc_index ].origin; + s_original_pos.angles = a_alt_locations[ n_loc_index ].angles; + } + } +} + +init_craftables() //checked changed to match cerberus output +{ + precachemodel( "p6_zm_tm_quadrotor_stand" ); + flag_init( "quadrotor_cooling_down" ); + level.craftable_piece_count = 4; + flag_init( "any_crystal_picked_up" ); + flag_init( "staff_air_zm_enabled" ); + flag_init( "staff_fire_zm_enabled" ); + flag_init( "staff_lightning_zm_enabled" ); + flag_init( "staff_water_zm_enabled" ); + register_clientfields(); + add_zombie_craftable( "equip_dieseldrone_zm", &"ZM_TOMB_CRQ", &"ZM_TOMB_CRQ", &"ZM_TOMB_TQ", ::onfullycrafted_quadrotor, 1 ); + add_zombie_craftable_vox_category( "equip_dieseldrone_zm", "build_dd" ); + make_zombie_craftable_open( "equip_dieseldrone_zm", "veh_t6_dlc_zm_quadrotor", ( 0, 0, 0 ), ( 0, -4, 10 ) ); + add_zombie_craftable( "tomb_shield_zm", &"ZM_TOMB_CRRI", undefined, &"ZOMBIE_BOUGHT_RIOT", undefined, 1 ); + add_zombie_craftable_vox_category( "tomb_shield_zm", "build_zs" ); + make_zombie_craftable_open( "tomb_shield_zm", "t6_wpn_zmb_shield_dlc4_dmg0_world", vectorScale( ( 0, -1, 0 ), 90 ), ( 0, 0, level.riotshield_placement_zoffset ) ); + add_zombie_craftable( "elemental_staff_fire", &"ZM_TOMB_CRF", &"ZM_TOMB_INS", &"ZM_TOMB_BOF", ::staff_fire_fullycrafted, 1 ); + add_zombie_craftable_vox_category( "elemental_staff_fire", "fire_staff" ); + add_zombie_craftable( "elemental_staff_air", &"ZM_TOMB_CRA", &"ZM_TOMB_INS", &"ZM_TOMB_BOA", ::staff_air_fullycrafted, 1 ); + add_zombie_craftable_vox_category( "elemental_staff_air", "air_staff" ); + add_zombie_craftable( "elemental_staff_lightning", &"ZM_TOMB_CRL", &"ZM_TOMB_INS", &"ZM_TOMB_BOL", ::staff_lightning_fullycrafted, 1 ); + add_zombie_craftable_vox_category( "elemental_staff_lightning", "light_staff" ); + add_zombie_craftable( "elemental_staff_water", &"ZM_TOMB_CRW", &"ZM_TOMB_INS", &"ZM_TOMB_BOW", ::staff_water_fullycrafted, 1 ); + add_zombie_craftable_vox_category( "elemental_staff_water", "ice_staff" ); + add_zombie_craftable( "gramophone", &"ZM_TOMB_CRAFT_GRAMOPHONE", &"ZM_TOMB_CRAFT_GRAMOPHONE", &"ZM_TOMB_BOUGHT_GRAMOPHONE", undefined, 0 ); + add_zombie_craftable_vox_category( "gramophone", "gramophone" ); + level.zombie_craftable_persistent_weapon = ::tomb_check_crafted_weapon_persistence; + level.custom_craftable_validation = ::tomb_custom_craftable_validation; + level.zombie_custom_equipment_setup = ::setup_quadrotor_purchase; + level thread hide_staff_model(); + level.quadrotor_status = spawnstruct(); + level.quadrotor_status.crafted = 0; + level.quadrotor_status.picked_up = 0; + level.num_staffpieces_picked_up = []; + level.n_staffs_crafted = 0; +} + +add_craftable_cheat( craftable ) //dev call skipped +{ + /* +/# + if ( !isDefined( level.cheat_craftables ) ) + { + level.cheat_craftables = []; + } + _a112 = craftable.a_piecestubs; + _k112 = getFirstArrayKey( _a112 ); + while ( isDefined( _k112 ) ) + { + s_piece = _a112[ _k112 ]; + id_string = undefined; + client_field_val = undefined; + if ( isDefined( s_piece.client_field_id ) ) + { + id_string = s_piece.client_field_id; + client_field_val = id_string; + } + else if ( isDefined( s_piece.client_field_state ) ) + { + id_string = "gem"; + client_field_val = s_piece.client_field_state; + } + else + { + } + tokens = strtok( id_string, "_" ); + display_string = "piece"; + _a134 = tokens; + _k134 = getFirstArrayKey( _a134 ); + while ( isDefined( _k134 ) ) + { + token = _a134[ _k134 ]; + if ( token != "piece" && token != "staff" && token != "zm" ) + { + display_string = ( display_string + "_" ) + token; + } + _k134 = getNextArrayKey( _a134, _k134 ); + } + level.cheat_craftables[ "" + client_field_val ] = s_piece; + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Craftables:1/" + craftable.name + "/" + display_string + "" "give_craftable " + client_field_val + ""\n" ); + s_piece.waste = "waste"; + _k112 = getNextArrayKey( _a112, _k112 ); + } + flag_wait( "start_zombie_round_logic" ); + _a149 = craftable.a_piecestubs; + _k149 = getFirstArrayKey( _a149 ); + while ( isDefined( _k149 ) ) + { + s_piece = _a149[ _k149 ]; + s_piece craftable_waittill_spawned(); + s_piece.piecespawn.model thread puzzle_debug_position( "C", vectorScale( ( 0, 0, 1 ), 255 ), undefined, "show_craftable_locations" ); + _k149 = getNextArrayKey( _a149, _k149 ); +#/ + } + */ +} + +autocraft_staffs() //checked changed to match cerberus output +{ + setdvar( "autocraft_staffs", "off" ); + /* +/# + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Craftables:1/Give All Staff Pieces:0" "autocraft_staffs on"\n" ); +#/ + */ + while ( getDvar( "autocraft_staffs" ) != "on" ) + { + wait_network_frame(); + } + flag_wait( "start_zombie_round_logic" ); + keys = getarraykeys( level.cheat_craftables ); + a_players = getplayers(); + foreach ( key in keys ) + { + if ( issubstr( key, "staff" ) || issubstr( key, "record" ) ) + { + s_piece = level.cheat_craftables[ key ]; + if ( isDefined( s_piece.piecespawn ) ) + { + a_players[ 0 ] maps/mp/zombies/_zm_craftables::player_take_piece( s_piece.piecespawn ); + } + } + } + for ( i = 1; i <= 4; i++ ) + { + level notify( "player_teleported", a_players[0], i ); + wait_network_frame(); + piece_spawn = level.cheat_craftables[ "" + i ].piecespawn; + if ( isDefined( piece_spawn ) ) + { + if ( isDefined( a_players[ i - 1 ] ) ) + { + a_players[ i - 1 ] maps/mp/zombies/_zm_craftables::player_take_piece( piece_spawn ); + wait_network_frame(); + } + } + wait_network_frame(); + } +} + +run_craftables_devgui() //dev call skipped +{ + /* +/# + level thread autocraft_staffs(); + setdvar( "give_craftable", "" ); + while ( 1 ) + { + craftable_id = getDvar( "give_craftable" ); + if ( craftable_id != "" ) + { + piece_spawn = level.cheat_craftables[ craftable_id ].piecespawn; + if ( isDefined( piece_spawn ) ) + { + players = getplayers(); + players[ 0 ] maps/mp/zombies/_zm_craftables::player_take_piece( piece_spawn ); + } + setdvar( "give_craftable", "" ); + } + wait 0,05; +#/ + } + */ +} + +include_craftables() //checked matches cerberus output +{ + level thread run_craftables_devgui(); + craftable_name = "equip_dieseldrone_zm"; + quadrotor_body = generate_zombie_craftable_piece( craftable_name, "body", "veh_t6_dlc_zm_quad_piece_body", 32, 64, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_quadrotor_zm_body", 1, "build_dd" ); + quadrotor_brain = generate_zombie_craftable_piece( craftable_name, "brain", "veh_t6_dlc_zm_quad_piece_brain", 32, 64, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_quadrotor_zm_brain", 1, "build_dd_brain" ); + quadrotor_engine = generate_zombie_craftable_piece( craftable_name, "engine", "veh_t6_dlc_zm_quad_piece_engine", 32, 64, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_quadrotor_zm_engine", 1, "build_dd" ); + quadrotor = spawnstruct(); + quadrotor.name = craftable_name; + quadrotor add_craftable_piece( quadrotor_body ); + quadrotor add_craftable_piece( quadrotor_brain ); + quadrotor add_craftable_piece( quadrotor_engine ); + quadrotor.triggerthink = ::quadrotorcraftable; + include_zombie_craftable( quadrotor ); + level thread add_craftable_cheat( quadrotor ); + craftable_name = "tomb_shield_zm"; + riotshield_top = generate_zombie_craftable_piece( craftable_name, "top", "t6_wpn_zmb_shield_dlc4_top", 48, 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_dlc4_door", 48, 15, 25, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_riotshield_door", 1, "build_zs" ); + riotshield_bracket = generate_zombie_craftable_piece( craftable_name, "bracket", "t6_wpn_zmb_shield_dlc4_bracket", 48, 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_top ); + riotshield add_craftable_piece( riotshield_door ); + riotshield add_craftable_piece( riotshield_bracket ); + riotshield.onbuyweapon = ::onbuyweapon_riotshield; + riotshield.triggerthink = ::riotshieldcraftable; + include_craftable( riotshield ); + level thread add_craftable_cheat( riotshield ); + craftable_name = "elemental_staff_air"; + staff_air_gem = generate_zombie_craftable_piece( craftable_name, "gem", "t6_wpn_zmb_staff_crystal_air_part", 48, 64, 0, undefined, ::onpickup_aircrystal, ::ondrop_aircrystal, undefined, undefined, undefined, undefined, 2, 0, "crystal", 1 ); + staff_air_upper_staff = generate_zombie_craftable_piece( craftable_name, "upper_staff", "t6_wpn_zmb_staff_tip_air_world", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_ustaff_air", 1, "staff_part" ); + staff_air_middle_staff = generate_zombie_craftable_piece( craftable_name, "middle_staff", "t6_wpn_zmb_staff_stem_air_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_mstaff_air", 1, "staff_part" ); + staff_air_lower_staff = generate_zombie_craftable_piece( craftable_name, "lower_staff", "t6_wpn_zmb_staff_revive_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_lstaff_air", 1, "staff_part" ); + staff = spawnstruct(); + staff.name = craftable_name; + staff add_craftable_piece( staff_air_gem ); + staff add_craftable_piece( staff_air_upper_staff ); + staff add_craftable_piece( staff_air_middle_staff ); + staff add_craftable_piece( staff_air_lower_staff ); + staff.triggerthink = ::staffcraftable_air; + staff.custom_craftablestub_update_prompt = ::tomb_staff_update_prompt; + include_zombie_craftable( staff ); + level thread add_craftable_cheat( staff ); + count_staff_piece_pickup( array( staff_air_upper_staff, staff_air_middle_staff, staff_air_lower_staff ) ); + craftable_name = "elemental_staff_fire"; + staff_fire_gem = generate_zombie_craftable_piece( craftable_name, "gem", "t6_wpn_zmb_staff_crystal_fire_part", 48, 64, 0, undefined, ::onpickup_firecrystal, ::ondrop_firecrystal, undefined, undefined, undefined, undefined, 1, 0, "crystal", 1 ); + staff_fire_upper_staff = generate_zombie_craftable_piece( craftable_name, "upper_staff", "t6_wpn_zmb_staff_tip_fire_world", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_ustaff_fire", 1, "staff_part" ); + staff_fire_middle_staff = generate_zombie_craftable_piece( craftable_name, "middle_staff", "t6_wpn_zmb_staff_stem_fire_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_mstaff_fire", 1, "staff_part" ); + staff_fire_lower_staff = generate_zombie_craftable_piece( craftable_name, "lower_staff", "t6_wpn_zmb_staff_revive_part", 64, 128, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_lstaff_fire", 1, "staff_part" ); + level thread maps/mp/zm_tomb_main_quest::staff_mechz_drop_pieces( staff_fire_lower_staff ); + level thread maps/mp/zm_tomb_main_quest::staff_biplane_drop_pieces( array( staff_fire_middle_staff ) ); + level thread maps/mp/zm_tomb_main_quest::staff_unlock_with_zone_capture( staff_fire_upper_staff ); + staff = spawnstruct(); + staff.name = craftable_name; + staff add_craftable_piece( staff_fire_gem ); + staff add_craftable_piece( staff_fire_upper_staff ); + staff add_craftable_piece( staff_fire_middle_staff ); + staff add_craftable_piece( staff_fire_lower_staff ); + staff.triggerthink = ::staffcraftable_fire; + staff.custom_craftablestub_update_prompt = ::tomb_staff_update_prompt; + include_zombie_craftable( staff ); + level thread add_craftable_cheat( staff ); + count_staff_piece_pickup( array( staff_fire_upper_staff, staff_fire_middle_staff, staff_fire_lower_staff ) ); + craftable_name = "elemental_staff_lightning"; + staff_lightning_gem = generate_zombie_craftable_piece( craftable_name, "gem", "t6_wpn_zmb_staff_crystal_bolt_part", 48, 64, 0, undefined, ::onpickup_lightningcrystal, ::ondrop_lightningcrystal, undefined, undefined, undefined, undefined, 3, 0, "crystal", 1 ); + staff_lightning_upper_staff = generate_zombie_craftable_piece( craftable_name, "upper_staff", "t6_wpn_zmb_staff_tip_lightning_world", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_ustaff_lightning", 1, "staff_part" ); + staff_lightning_middle_staff = generate_zombie_craftable_piece( craftable_name, "middle_staff", "t6_wpn_zmb_staff_stem_bolt_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_mstaff_lightning", 1, "staff_part" ); + staff_lightning_lower_staff = generate_zombie_craftable_piece( craftable_name, "lower_staff", "t6_wpn_zmb_staff_revive_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_lstaff_lightning", 1, "staff_part" ); + staff = spawnstruct(); + staff.name = craftable_name; + staff add_craftable_piece( staff_lightning_gem ); + staff add_craftable_piece( staff_lightning_upper_staff ); + staff add_craftable_piece( staff_lightning_middle_staff ); + staff add_craftable_piece( staff_lightning_lower_staff ); + staff.triggerthink = ::staffcraftable_lightning; + staff.custom_craftablestub_update_prompt = ::tomb_staff_update_prompt; + include_zombie_craftable( staff ); + level thread add_craftable_cheat( staff ); + count_staff_piece_pickup( array( staff_lightning_upper_staff, staff_lightning_middle_staff, staff_lightning_lower_staff ) ); + craftable_name = "elemental_staff_water"; + staff_water_gem = generate_zombie_craftable_piece( craftable_name, "gem", "t6_wpn_zmb_staff_crystal_water_part", 48, 64, 0, undefined, ::onpickup_watercrystal, ::ondrop_watercrystal, undefined, undefined, undefined, undefined, 4, 0, "crystal", 1 ); + staff_water_upper_staff = generate_zombie_craftable_piece( craftable_name, "upper_staff", "t6_wpn_zmb_staff_tip_water_world", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_ustaff_water", 1, "staff_part" ); + staff_water_middle_staff = generate_zombie_craftable_piece( craftable_name, "middle_staff", "t6_wpn_zmb_staff_stem_water_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_mstaff_water", 1, "staff_part" ); + staff_water_lower_staff = generate_zombie_craftable_piece( craftable_name, "lower_staff", "t6_wpn_zmb_staff_revive_part", 32, 64, 0, undefined, ::onpickup_staffpiece, ::ondrop_common, undefined, undefined, undefined, undefined, "piece_staff_zm_lstaff_water", 1, "staff_part" ); + a_ice_staff_parts = array( staff_water_lower_staff, staff_water_middle_staff, staff_water_upper_staff ); + level thread maps/mp/zm_tomb_main_quest::staff_ice_dig_pieces( a_ice_staff_parts ); + staff = spawnstruct(); + staff.name = craftable_name; + staff add_craftable_piece( staff_water_gem ); + staff add_craftable_piece( staff_water_upper_staff ); + staff add_craftable_piece( staff_water_middle_staff ); + staff add_craftable_piece( staff_water_lower_staff ); + staff.triggerthink = ::staffcraftable_water; + staff.custom_craftablestub_update_prompt = ::tomb_staff_update_prompt; + include_zombie_craftable( staff ); + level thread add_craftable_cheat( staff ); + count_staff_piece_pickup( array( staff_water_upper_staff, staff_water_middle_staff, staff_water_lower_staff ) ); + craftable_name = "gramophone"; + vinyl_pickup_player = vinyl_add_pickup( craftable_name, "vinyl_player", "p6_zm_tm_gramophone", "piece_record_zm_player", undefined, "gramophone" ); + vinyl_pickup_master = vinyl_add_pickup( craftable_name, "vinyl_master", "p6_zm_tm_record_master", "piece_record_zm_vinyl_master", undefined, "record" ); + vinyl_pickup_air = vinyl_add_pickup( craftable_name, "vinyl_air", "p6_zm_tm_record_wind", "piece_record_zm_vinyl_air", "quest_state2", "record" ); + vinyl_pickup_ice = vinyl_add_pickup( craftable_name, "vinyl_ice", "p6_zm_tm_record_ice", "piece_record_zm_vinyl_water", "quest_state4", "record" ); + vinyl_pickup_fire = vinyl_add_pickup( craftable_name, "vinyl_fire", "p6_zm_tm_record_fire", "piece_record_zm_vinyl_fire", "quest_state1", "record" ); + vinyl_pickup_elec = vinyl_add_pickup( craftable_name, "vinyl_elec", "p6_zm_tm_record_lightning", "piece_record_zm_vinyl_lightning", "quest_state3", "record" ); + vinyl_pickup_player.sam_line = "gramophone_found"; + vinyl_pickup_master.sam_line = "master_found"; + vinyl_pickup_air.sam_line = "first_record_found"; + vinyl_pickup_ice.sam_line = "first_record_found"; + vinyl_pickup_fire.sam_line = "first_record_found"; + vinyl_pickup_elec.sam_line = "first_record_found"; + level thread maps/mp/zm_tomb_vo::watch_one_shot_samantha_line( "vox_sam_1st_record_found_0", "first_record_found" ); + level thread maps/mp/zm_tomb_vo::watch_one_shot_samantha_line( "vox_sam_gramophone_found_0", "gramophone_found" ); + level thread maps/mp/zm_tomb_vo::watch_one_shot_samantha_line( "vox_sam_master_found_0", "master_found" ); + gramophone = spawnstruct(); + gramophone.name = craftable_name; + gramophone add_craftable_piece( vinyl_pickup_player ); + gramophone add_craftable_piece( vinyl_pickup_master ); + gramophone add_craftable_piece( vinyl_pickup_air ); + gramophone add_craftable_piece( vinyl_pickup_ice ); + gramophone add_craftable_piece( vinyl_pickup_fire ); + gramophone add_craftable_piece( vinyl_pickup_elec ); + gramophone.triggerthink = ::gramophonecraftable; + include_zombie_craftable( gramophone ); + level thread add_craftable_cheat( gramophone ); + staff_fire_gem thread watch_part_pickup( "quest_state1", 2 ); + staff_air_gem thread watch_part_pickup( "quest_state2", 2 ); + staff_lightning_gem thread watch_part_pickup( "quest_state3", 2 ); + staff_water_gem thread watch_part_pickup( "quest_state4", 2 ); + staff_fire_gem thread staff_crystal_wait_for_teleport( 1 ); + staff_air_gem thread staff_crystal_wait_for_teleport( 2 ); + staff_lightning_gem thread staff_crystal_wait_for_teleport( 3 ); + staff_water_gem thread staff_crystal_wait_for_teleport( 4 ); + level thread maps/mp/zm_tomb_vo::staff_craft_vo(); + level thread maps/mp/zm_tomb_vo::samantha_discourage_think(); + level thread maps/mp/zm_tomb_vo::samantha_encourage_think(); + level thread craftable_add_glow_fx(); +} + +register_clientfields() //checked matches cerberus output +{ + bits = 1; + registerclientfield( "world", "piece_quadrotor_zm_body", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_quadrotor_zm_brain", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_quadrotor_zm_engine", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_riotshield_dolly", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_riotshield_door", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_riotshield_clamp", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_gem_air", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_ustaff_air", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_mstaff_air", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_lstaff_air", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_gem_fire", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_ustaff_fire", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_mstaff_fire", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_lstaff_fire", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_gem_lightning", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_ustaff_lightning", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_mstaff_lightning", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_lstaff_lightning", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_gem_water", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_ustaff_water", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_mstaff_water", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_staff_zm_lstaff_water", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_player", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_vinyl_master", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_vinyl_air", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_vinyl_water", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_vinyl_fire", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "piece_record_zm_vinyl_lightning", 14000, bits, "int", undefined, 0 ); + registerclientfield( "scriptmover", "element_glow_fx", 14000, 4, "int", undefined, 0 ); + registerclientfield( "scriptmover", "bryce_cake", 14000, 2, "int", undefined, 0 ); + registerclientfield( "scriptmover", "switch_spark", 14000, 1, "int", undefined, 0 ); + bits = getminbitcountfornum( 5 ); + registerclientfield( "world", "staff_player1", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "staff_player2", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "staff_player3", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "staff_player4", 14000, bits, "int", undefined, 0 ); + bits = getminbitcountfornum( 5 ); + registerclientfield( "world", "quest_state1", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state2", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state3", 14000, bits, "int", undefined, 0 ); + registerclientfield( "world", "quest_state4", 14000, bits, "int", undefined, 0 ); + registerclientfield( "toplayer", "sndMudSlow", 14000, 1, "int" ); +} + +craftable_add_glow_fx() //checked partially changed to match cerberus output +{ + flag_wait( "start_zombie_round_logic" ); + foreach ( s_craftable in level.zombie_include_craftables ) + { + if ( !issubstr( s_craftable.name, "elemental_staff" ) ) + { + } + else + { + n_elem = 0; + if ( issubstr( s_craftable.name, "fire" ) ) + { + n_elem = 1; + } + else if ( issubstr( s_craftable.name, "air" ) ) + { + n_elem = 2; + } + else if ( issubstr( s_craftable.name, "lightning" ) ) + { + n_elem = 3; + } + else if ( issubstr( s_craftable.name, "water" ) ) + { + n_elem = 4; + } + else + { + /* +/# + iprintlnbold( "ERROR: Unknown staff element type in craftable_add_glow_fx: " + s_craftable.name ); +#/ + */ + return; + } + for ( i = 0; i < s_craftable.a_piecestubs.size; i++ ) + { + if ( s_piece.piecename == "gem" ) + { + } + else + { + s_piece craftable_waittill_spawned(); + if ( n_elem == 3 || n_elem == 2) + { + do_glow_now = 1; + } + else + { + do_glow_now = 1; + } + s_piece.piecespawn.model thread craftable_model_attach_glow( n_elem, do_glow_now ); + } + } + } + } +} + +craftable_model_attach_glow( n_elem, do_glow_now ) //checked matches cerberus output +{ + self endon( "death" ); + if ( !do_glow_now ) + { + self waittill( "staff_piece_glow" ); + } + self setclientfield( "element_glow_fx", n_elem ); +} + +tomb_staff_update_prompt( player, b_set_hint_string_now, trigger ) //checked matches cerberus output +{ + if ( isDefined( self.crafted ) && self.crafted ) + { + return 1; + } + self.hint_string = &"ZOMBIE_BUILD_PIECE_MORE"; + if ( isDefined( player ) ) + { + if ( !isDefined( player.current_craftable_piece ) ) + { + return 0; + } + if ( !self.craftablespawn craftable_has_piece( player.current_craftable_piece ) ) + { + self.hint_string = &"ZOMBIE_BUILD_PIECE_WRONG"; + return 0; + } + } + if ( level.staff_part_count[ self.craftablespawn.craftable_name ] == 0 ) + { + self.hint_string = level.zombie_craftablestubs[ self.equipname ].str_to_craft; + return 1; + } + else + { + return 0; + } +} + +init_craftable_choke() //checked matches cerberus output +{ + level.craftables_spawned_this_frame = 0; + while ( 1 ) + { + wait_network_frame(); + level.craftables_spawned_this_frame = 0; + } +} + +craftable_wait_your_turn() //checked matches cerberus output +{ + if ( !isDefined( level.craftables_spawned_this_frame ) ) + { + level thread init_craftable_choke(); + } + while ( level.craftables_spawned_this_frame >= 2 ) + { + wait_network_frame(); + } + level.craftables_spawned_this_frame++; +} + +quadrotorcraftable() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "quadrotor_zm_craftable_trigger", "equip_dieseldrone_zm", "equip_dieseldrone_zm", &"ZM_TOMB_TQ", 1, 1 ); +} + +riotshieldcraftable() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "riotshield_zm_craftable_trigger", "tomb_shield_zm", "tomb_shield_zm", &"ZOMBIE_GRAB_RIOTSHIELD", 1, 1 ); +} + +staffcraftable_air() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "staff_air_craftable_trigger", "elemental_staff_air", "staff_air_zm", &"ZM_TOMB_PUAS", 1, 1 ); +} + +staffcraftable_fire() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "staff_fire_craftable_trigger", "elemental_staff_fire", "staff_fire_zm", &"ZM_TOMB_PUFS", 1, 1 ); +} + +staffcraftable_lightning() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "staff_lightning_craftable_trigger", "elemental_staff_lightning", "staff_lightning_zm", &"ZM_TOMB_PULS", 1, 1 ); +} + +staffcraftable_water() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "staff_water_craftable_trigger", "elemental_staff_water", "staff_water_zm", &"ZM_TOMB_PUIS", 1, 1 ); +} + +gramophonecraftable() //checked matches cerberus output +{ + craftable_wait_your_turn(); + maps/mp/zombies/_zm_craftables::craftable_trigger_think( "gramophone_craftable_trigger", "gramophone", "gramophone", &"ZOMBIE_GRAB_GRAMOPHONE", 1, 1 ); +} + +tankcraftableupdateprompt( player, sethintstringnow, buildabletrigger ) //checked matches cerberus output +{ + if ( level.vh_tank getspeedmph() > 0 ) + { + if ( isDefined( self ) ) + { + self.hint_string = ""; + if ( isDefined( sethintstringnow ) && sethintstringnow && isDefined( buildabletrigger ) ) + { + buildabletrigger sethintstring( self.hint_string ); + } + } + return 0; + } + return 1; +} + +ondrop_common( player ) //checked matches cerberus output +{ + self.piece_owner = undefined; +} + +ondrop_crystal( player ) //checked matches cerberus output +{ + ondrop_common( player ); + s_piece = self.piecestub; + s_piece.piecespawn.canmove = 1; + maps/mp/zombies/_zm_unitrigger::reregister_unitrigger_as_dynamic( s_piece.piecespawn.unitrigger ); + s_original_pos = getstruct( ( self.craftablename + "_" ) + self.piecename ); + s_piece.piecespawn.unitrigger trigger_off(); + s_piece.piecespawn.model ghost(); + s_piece.piecespawn.model moveto( s_original_pos.origin, 0.05 ); + s_piece.piecespawn.model waittill( "movedone" ); + s_piece.piecespawn.model show(); + s_piece.piecespawn.unitrigger trigger_on(); +} + +ondrop_firecrystal( player ) //checked matches cerberus output +{ + level setclientfield( "piece_staff_zm_gem_fire", 0 ); + level setclientfield( "quest_state1", 1 ); + level setclientfield( "piece_record_zm_vinyl_fire", 0 ); + player clear_player_crystal( 1 ); + ondrop_crystal( player ); +} + +ondrop_aircrystal( player ) //checked matches cerberus output +{ + level setclientfield( "piece_staff_zm_gem_air", 0 ); + level setclientfield( "quest_state2", 1 ); + level setclientfield( "piece_record_zm_vinyl_air", 0 ); + player clear_player_crystal( 2 ); + ondrop_crystal( player ); +} + +ondrop_lightningcrystal( player ) //checked matches cerberus output +{ + level setclientfield( "piece_staff_zm_gem_lightning", 0 ); + level setclientfield( "quest_state3", 1 ); + level setclientfield( "piece_record_zm_vinyl_lightning", 0 ); + player clear_player_crystal( 3 ); + ondrop_crystal( player ); +} + +ondrop_watercrystal( player ) //checked matches cerberus output +{ + level setclientfield( "piece_staff_zm_gem_water", 0 ); + level setclientfield( "quest_state4", 1 ); + level setclientfield( "piece_record_zm_vinyl_water", 0 ); + player clear_player_crystal( 4 ); + ondrop_crystal( player ); +} + +clear_player_crystal( n_element ) //checked matches cerberus output +{ + if ( n_element == self.crystal_id ) + { + n_player = self getentitynumber() + 1; + if ( n_player <= 4 ) + { + level setclientfield( "staff_player" + n_player, 0 ); + } + self.crystal_id = 0; + } +} + +piece_pickup_conversation( player ) //checked changed to match cerberus output +{ + wait 1; + while ( isDefined( player.isspeaking ) && player.isspeaking ) + { + wait_network_frame(); + } + if ( isDefined( self.piecestub.vo_line_notify ) ) + { + level notify( "quest_progressed", player, 0 ); + level notify( self.piecestub.vo_line_notify, player ); + } + else if ( isDefined( self.piecestub.sam_line ) ) + { + level notify( "quest_progressed", player, 0 ); + level notify( self.piecestub.sam_line, player ); + } + else + { + level notify( "quest_progressed", player, 1 ); + } +} + +onpickup_common( player ) //checked changed to match cerberus output +{ + player playsound( "zmb_craftable_pickup" ); + self.piece_owner = player; + self thread piece_pickup_conversation( player ); + /* +/# + foreach ( spawn in self.spawns ) + { + spawn notify( "stop_debug_position" ); +#/ + } + */ +} + +staff_pickup_vo() //checked matches cerberus output +{ + if ( !flag( "samantha_intro_done" ) ) + { + return; + } + if ( isDefined( level.sam_staff_line_played ) && !level.sam_staff_line_played ) + { + level.sam_staff_line_played = 1; + wait 1; + maps/mp/zm_tomb_vo::set_players_dontspeak( 1 ); + maps/mp/zm_tomb_vo::samanthasay( "vox_sam_1st_staff_found_1_0", self, 1 ); + maps/mp/zm_tomb_vo::samanthasay( "vox_sam_1st_staff_found_2_0", self ); + maps/mp/zm_tomb_vo::set_players_dontspeak( 0 ); + self maps/mp/zombies/_zm_audio::create_and_play_dialog( "staff", "first_piece" ); + } +} + +onpickup_staffpiece( player ) //checked matches cerberus output +{ + onpickup_common( player ); + if ( !isDefined( level.num_staffpieces_picked_up[ self.craftablename ] ) ) + { + level.num_staffpieces_picked_up[ self.craftablename ] = 0; + } + level.num_staffpieces_picked_up[ self.craftablename ]++; + if ( level.num_staffpieces_picked_up[ self.craftablename ] == 3 ) + { + level notify( self.craftablename + "_all_pieces_found" ); + } + player thread staff_pickup_vo(); +} + +onpickup_crystal( player, elementname, elementenum ) //checked matches cerberus output +{ + onpickup_common( player ); + level setclientfield( "piece_staff_zm_gem_" + elementname, 1 ); + n_player = player getentitynumber() + 1; + if ( n_player <= 4 ) + { + level setclientfield( "staff_player" + n_player, elementenum ); + } + if ( flag( "any_crystal_picked_up" ) ) + { + self.piecestub.vox_id = undefined; + } + flag_set( "any_crystal_picked_up" ); +} + +onpickup_firecrystal( player ) //checked matches cerberus output +{ + level setclientfield( "quest_state1", 2 ); + player.crystal_id = 1; + onpickup_crystal( player, "fire", 1 ); +} + +onpickup_aircrystal( player ) //checked matches cerberus output +{ + level setclientfield( "quest_state2", 2 ); + player.crystal_id = 2; + onpickup_crystal( player, "air", 2 ); +} + +onpickup_lightningcrystal( player ) //checked matches cerberus output +{ + level setclientfield( "quest_state3", 2 ); + player.crystal_id = 3; + onpickup_crystal( player, "lightning", 3 ); +} + +onpickup_watercrystal( player ) //checked matches cerberus output +{ + level setclientfield( "quest_state4", 2 ); + player.crystal_id = 4; + onpickup_crystal( player, "water", 4 ); +} + +vinyl_add_pickup( str_craftable_name, str_piece_name, str_model_name, str_bit_clientfield, str_quest_clientfield, str_vox_id ) //checked matches cerberus output +{ + b_one_time_vo = 1; + craftable = generate_zombie_craftable_piece( str_craftable_name, str_piece_name, str_model_name, 32, 62, 0, undefined, ::onpickup_common, ::ondrop_common, undefined, undefined, undefined, undefined, str_bit_clientfield, 1, str_vox_id, b_one_time_vo ); + craftable thread watch_part_pickup( str_quest_clientfield, 1 ); + return craftable; +} + +watch_part_pickup( str_quest_clientfield, n_clientfield_val ) //checked matches cerberus output +{ + self craftable_waittill_spawned(); + self.piecespawn waittill( "pickup" ); + level notify( ( self.craftablename + "_" ) + self.piecename + "_picked_up" ); + if ( isDefined( str_quest_clientfield ) && isDefined( n_clientfield_val ) ) + { + level setclientfield( str_quest_clientfield, n_clientfield_val ); + } +} + +count_staff_piece_pickup( a_staff_pieces ) //checked changed to match cerberus output +{ + if ( !isDefined( level.staff_part_count ) ) + { + level.staff_part_count = []; + } + str_name = a_staff_pieces[ 0 ].craftablename; + level.staff_part_count[ str_name ] = a_staff_pieces.size; + foreach ( piece in a_staff_pieces ) + { + /* +/# + assert( piece.craftablename == str_name ); +#/ + */ + piece thread watch_staff_pickup(); + } +} + +craftable_waittill_spawned() //checked matches cerberus output +{ + while ( !isDefined( self.piecespawn ) ) + { + wait_network_frame(); + } +} + +watch_staff_pickup() //checked matches cerberus output +{ + self craftable_waittill_spawned(); + self.piecespawn waittill( "pickup" ); + level.staff_part_count[ self.craftablename ]--; + +} + +onfullycrafted_quadrotor( player ) //checked changed to match cerberus output +{ + level.quadrotor_status.crafted = 1; + pickup_trig = level.quadrotor_status.pickup_trig; + level.quadrotor_status.str_zone = maps/mp/zombies/_zm_zonemgr::get_zone_from_position( pickup_trig.origin, 1 ); + level.quadrotor_status.pickup_indicator = spawn( "script_model", pickup_trig.model.origin + vectorScale( ( 0, 0, -1 ), 10 ) ); + level.quadrotor_status.pickup_indicator setmodel( "p6_zm_tm_quadrotor_stand" ); + level notify( "quest_progressed", player, 1 ); + return 1; +} + +onbuyweapon_riotshield( player ) //checked matches cerberus output +{ + 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 ]](); + } +} + +staff_fullycrafted( modelname, elementenum ) //checked changed to match cerberus output +{ + player = get_closest_player( self.origin ); + staff_model = getent( modelname, "targetname" ); + staff_info = get_staff_info_from_element_index( elementenum ); + staff_model useweaponmodel( staff_info.weapname ); + staff_model showallparts(); + level notify( "quest_progressed", player, 0 ); + if ( !isDefined( staff_model.inused ) ) + { + staff_model show(); + staff_model.inused = 1; + level.n_staffs_crafted++; + if ( level.n_staffs_crafted == 4 ) + { + flag_set( "ee_all_staffs_crafted" ); + } + } + str_fieldname = "quest_state" + elementenum; + level setclientfield( str_fieldname, 3 ); + return 1; +} + +staff_fire_fullycrafted() //checked matches cerberus output +{ + level thread sndplaystaffstingeronce( "fire" ); + return staff_fullycrafted( "craftable_staff_fire_zm", 1 ); +} + +staff_air_fullycrafted() //checked matches cerberus output +{ + level thread sndplaystaffstingeronce( "wind" ); + return staff_fullycrafted( "craftable_staff_air_zm", 2 ); +} + +staff_lightning_fullycrafted() //checked matches cerberus output +{ + level thread sndplaystaffstingeronce( "lightning" ); + return staff_fullycrafted( "craftable_staff_lightning_zm", 3 ); +} + +staff_water_fullycrafted() //checked matches cerberus output +{ + level thread sndplaystaffstingeronce( "ice" ); + return staff_fullycrafted( "craftable_staff_water_zm", 4 ); +} + +sndplaystaffstingeronce( type ) //checked matches cerberus output +{ + if ( !isDefined( level.sndstaffbuilt ) ) + { + level.sndstaffbuilt = []; + } + if ( !isinarray( level.sndstaffbuilt, type ) ) + { + level.sndstaffbuilt[ level.sndstaffbuilt.size ] = type; + level thread maps/mp/zombies/_zm_audio::sndmusicstingerevent( "staff_" + type ); + } +} + +quadrotor_watcher( player ) //checked matches cerberus output +{ + quadrotor_set_unavailable(); + player thread quadrotor_return_condition_watcher(); + player thread quadrotor_control_thread(); + level waittill( "drone_available" ); + level.maxis_quadrotor = undefined; + if ( flag( "ee_quadrotor_disabled" ) ) + { + flag_waitopen( "ee_quadrotor_disabled" ); + } + quadrotor_set_available(); +} + +quadrotor_return_condition_watcher() //checked matches cerberus output +{ + self waittill_any( "bled_out", "disconnect" ); + if ( isDefined( level.maxis_quadrotor ) ) + { + level notify( "drone_should_return" ); + } + else + { + level notify( "drone_available" ); + } +} + +quadrotor_control_thread() //checked matches cerberus output +{ + self endon( "bled_out" ); + self endon( "disconnect" ); + while ( 1 ) + { + if ( self actionslottwobuttonpressed() && self hasweapon( "equip_dieseldrone_zm" ) ) + { + self waittill( "weapon_change_complete" ); + self playsound( "veh_qrdrone_takeoff" ); + weapons = self getweaponslistprimaries(); + self switchtoweapon( weapons[ 0 ] ); + self waittill( "weapon_change_complete" ); + if ( self hasweapon( "equip_dieseldrone_zm" ) ) + { + self takeweapon( "equip_dieseldrone_zm" ); + self setactionslot( 2, "" ); + } + str_vehicle = "heli_quadrotor_zm"; + if ( flag( "ee_maxis_drone_retrieved" ) ) + { + str_vehicle = "heli_quadrotor_upgraded_zm"; + } + qr = spawnvehicle( "veh_t6_dlc_zm_quadrotor", "quadrotor_ai", str_vehicle, self.origin + vectorScale( ( 0, 0, 1 ), 96 ), self.angles ); + level thread quadrotor_death_watcher( qr ); + qr thread quadrotor_instance_watcher( self ); + return; + } + wait 0.05; + } +} + +quadrotor_debug_send_home( player_owner ) //checked matches cerberus output +{ + self endon( "drone_should_return" ); + level endon( "drone_available" ); + while ( 1 ) + { + if ( player_owner actionslottwobuttonpressed() ) + { + self quadrotor_fly_back_to_table(); + } + wait 0.05; + } +} + +quadrotor_instance_watcher( player_owner ) //checked matches cerberus output +{ + self endon( "death" ); + self.player_owner = player_owner; + self.health = 200; + level.maxis_quadrotor = self; + self makevehicleunusable(); + self thread maps/mp/zombies/_zm_ai_quadrotor::quadrotor_think(); + self thread follow_ent( player_owner ); + self thread quadrotor_timer(); + level waittill( "drone_should_return" ); + self quadrotor_fly_back_to_table(); +} + +quadrotor_death_watcher( quadrotor ) //checked matches cerberus output +{ + level endon( "drone_available" ); + quadrotor waittill( "death" ); + level notify( "drone_available" ); +} + +quadrotor_fly_back_to_table() //checked matches cerberus output +{ + self endon( "death" ); + level endon( "drone_available" ); + if ( isDefined( self ) ) + { + /* +/# + iprintln( "Maxis sez: time to bounce" ); +#/ + */ + self.returning_home = 1; + self thread quadrotor_fly_back_to_table_timeout(); + self waittill_any( "attempting_return", "return_timeout" ); + } + if ( isDefined( self ) ) + { + self waittill_any( "near_goal", "force_goal", "reached_end_node", "return_timeout" ); + } + if ( isDefined( self ) ) + { + playfx( level._effect[ "tesla_elec_kill" ], self.origin ); + self playsound( "zmb_qrdrone_leave" ); + self delete(); + /* +/# + iprintln( "Maxis deleted" ); +#/ + */ + } + level notify( "drone_available" ); +} + +report_notify( str_notify ) //checked matches cerberus output +{ + self waittill( str_notify ); + iprintln( str_notify ); +} + +quadrotor_fly_back_to_table_timeout() //checked matches cerberus output +{ + self endon( "death" ); + level endon( "drone_available" ); + wait 30; + if ( isDefined( self ) ) + { + self delete(); + /* +/# + iprintln( "Maxis deleted" ); +#/ + */ + } + self notify( "return_timeout" ); +} + +quadrotor_timer() //checked matches cerberus output +{ + self endon( "death" ); + level endon( "drone_available" ); + wait 80; + vox_line = "vox_maxi_drone_cool_down_" + randomintrange( 0, 2 ); + self thread maps/mp/zm_tomb_vo::maxissay( vox_line, self ); + wait 10; + vox_line = "vox_maxi_drone_cool_down_2"; + self thread maps/mp/zm_tomb_vo::maxissay( vox_line, self ); + level notify( "drone_should_return" ); +} + +quadrotor_set_available() //checked matches cerberus output +{ + /* +/# + iprintln( "Quad returned to table" ); +#/ + */ + playfx( level._effect[ "tesla_elec_kill" ], level.quadrotor_status.pickup_trig.model.origin ); + level.quadrotor_status.pickup_trig.model playsound( "zmb_qrdrone_leave" ); + level.quadrotor_status.picked_up = 0; + level.quadrotor_status.pickup_trig.model show(); + flag_set( "quadrotor_cooling_down" ); + str_zone = level.quadrotor_status.str_zone; + switch( str_zone ) + { + case "zone_nml_9": + setclientfield( "cooldown_steam", 1 ); + break; + case "zone_bunker_5a": + setclientfield( "cooldown_steam", 2 ); + break; + case "zone_village_1": + setclientfield( "cooldown_steam", 3 ); + break; + } + vox_line = "vox_maxi_drone_cool_down_3"; + thread maxissay( vox_line, level.quadrotor_status.pickup_trig.model ); + wait 60; + flag_clear( "quadrotor_cooling_down" ); + setclientfield( "cooldown_steam", 0 ); + level.quadrotor_status.pickup_trig trigger_on(); + vox_line = "vox_maxi_drone_cool_down_4"; + maxissay( vox_line, level.quadrotor_status.pickup_trig.model ); +} + +quadrotor_set_unavailable() //checked matches cerberus output +{ + level.quadrotor_status.picked_up = 1; + level.quadrotor_status.pickup_trig trigger_off(); + level.quadrotor_status.pickup_trig.model ghost(); +} + +sqcommoncraftable() //checked matches cerberus output +{ + level.sq_craftable = maps/mp/zombies/_zm_craftables::craftable_trigger_think( "sq_common_craftable_trigger", "sq_common", "sq_common", "", 1, 0 ); +} + +droponmover( player ) //checked matches cerberus output +{ +} + +pickupfrommover() //checked matches cerberus output +{ +} + +setup_quadrotor_purchase( player ) //checked matches cerberus output +{ + if ( self.stub.weaponname == "equip_dieseldrone_zm" ) + { + if ( players_has_weapon( "equip_dieseldrone_zm" ) ) + { + return 1; + } + quadrotor = getentarray( "quadrotor_ai", "targetname" ); + if ( quadrotor.size >= 1 ) + { + return 1; + } + quadrotor_set_unavailable(); + player giveweapon( "equip_dieseldrone_zm" ); + player setweaponammoclip( "equip_dieseldrone_zm", 1 ); + player playsoundtoplayer( "zmb_buildable_pickup_complete", player ); + if ( isDefined( self.stub.craftablestub.use_actionslot ) ) + { + player setactionslot( self.stub.craftablestub.use_actionslot, "weapon", "equip_dieseldrone_zm" ); + } + else + { + player setactionslot( 2, "weapon", "equip_dieseldrone_zm" ); + } + player notify( "equip_dieseldrone_zm_given" ); + level thread quadrotor_watcher( player ); + player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "build_dd_plc" ); + return 1; + } + return 0; +} + +players_has_weapon( weaponname ) //checked changed to match cerberus output +{ + players = getplayers(); + for ( i = 0; i < players.size; i++ ) + { + if ( players[ i ] hasweapon( weaponname ) ) + { + return 1; + } + } + return 0; +} + +tomb_custom_craftable_validation( player ) //checked changed to match cerberus output +{ + if ( self.stub.equipname == "equip_dieseldrone_zm" ) + { + level.quadrotor_status.pickup_trig = self.stub; + if ( level.quadrotor_status.crafted ) + { + return !level.quadrotor_status.picked_up && !flag( "quadrotor_cooling_down" ); + } + } + if ( !issubstr( self.stub.weaponname, "staff" ) ) + { + return 1; + } + str_craftable = self.stub.equipname; + if ( isDefined( level.craftables_crafted[ str_craftable ] ) && !level.craftables_crafted[ str_craftable ] ) + { + return 1; + } + if ( !player can_pickup_staff() ) + { + return 0; + } + s_elemental_staff = get_staff_info_from_weapon_name( self.stub.weaponname, 0 ); + str_weapon_check = s_elemental_staff.weapname; + a_weapons = player getweaponslistprimaries(); + foreach ( weapon in a_weapons ) + { + if ( issubstr( weapon, "staff" ) && weapon != str_weapon_check ) + { + player takeweapon( weapon ); + } + } + return 1; +} + +tomb_check_crafted_weapon_persistence( player ) //checked changed to match cerberus output +{ + if ( self.stub.equipname == "equip_dieseldrone_zm" ) + { + if ( level.quadrotor_status.picked_up ) + { + return 1; + } + else if ( level.quadrotor_status.crafted ) + { + return 0; + } + } + else if ( self.stub.weaponname == "staff_air_zm" || self.stub.weaponname == "staff_fire_zm" || self.stub.weaponname == "staff_lightning_zm" || self.stub.weaponname == "staff_water_zm" ) + { + if ( self is_unclaimed_staff_weapon( self.stub.weaponname ) ) + { + s_elemental_staff = get_staff_info_from_weapon_name( self.stub.weaponname, 0 ); + player maps/mp/zombies/_zm_weapons::weapon_give( s_elemental_staff.weapname, 0, 0 ); + if ( isDefined( s_elemental_staff.prev_ammo_stock ) && isDefined( s_elemental_staff.prev_ammo_clip ) ) + { + player setweaponammostock( s_elemental_staff.weapname, s_elemental_staff.prev_ammo_stock ); + player setweaponammoclip( s_elemental_staff.weapname, s_elemental_staff.prev_ammo_clip ); + } + if ( isDefined( level.zombie_craftablestubs[ self.stub.equipname ].str_taken ) ) + { + self.stub.hint_string = level.zombie_craftablestubs[ self.stub.equipname ].str_taken; + } + else + { + self.stub.hint_string = ""; + } + self sethintstring( self.stub.hint_string ); + player track_craftables_pickedup( self.stub.craftablespawn ); + model = getent( "craftable_" + self.stub.weaponname, "targetname" ); + model ghost(); + self.stub thread track_crafted_staff_trigger(); + self.stub thread track_staff_weapon_respawn( player ); + set_player_staff( self.stub.weaponname, player ); + } + else + { + self.stub.hint_string = ""; + self sethintstring( self.stub.hint_string ); + } + return 1; + } + return 0; +} + +is_unclaimed_staff_weapon( str_weapon ) //checked changed to match cerberus output +{ + if ( !maps/mp/zombies/_zm_equipment::is_limited_equipment( str_weapon ) ) + { + return 1; + } + s_elemental_staff = get_staff_info_from_weapon_name( str_weapon, 0 ); + str_weapon_check = s_elemental_staff.weapname; + players = get_players(); + foreach ( player in players ) + { + if ( isDefined( player ) && player has_weapon_or_upgrade( str_weapon_check ) ) + { + return 0; + } + } + return 1; +} + +get_staff_info_from_weapon_name( str_name, b_base_info_only ) //checked partially changed to match cerberus output see info.md +{ + if ( !isDefined( b_base_info_only ) ) + { + b_base_info_only = 1; + } + foreach ( s_staff in level.a_elemental_staffs ) + { + if ( s_staff.weapname == str_name || s_staff.upgrade.weapname == str_name ) + { + if ( s_staff.charger.is_charged && !b_base_info_only ) + { + return s_staff.upgrade; + } + else + { + return s_staff; + } + } + } + return undefined; +} + +get_staff_info_from_element_index( n_index ) //checked changed to match cerberus output +{ + foreach ( s_staff in level.a_elemental_staffs ) + { + if ( s_staff.enum == n_index ) + { + return s_staff; + } + } + return undefined; +} + +track_crafted_staff_trigger() //checked matches cerberus output +{ + s_elemental_staff = get_staff_info_from_weapon_name( self.weaponname, 1 ); + if ( !isDefined( self.base_weaponname ) ) + { + self.base_weaponname = s_elemental_staff.weapname; + } + flag_waitopen( self.base_weaponname + "_enabled" ); + self trigger_off(); + flag_wait( self.base_weaponname + "_enabled" ); + self trigger_on(); +} + +track_staff_weapon_respawn( player ) //checked partially changed to match cerberus output see info.md +{ + self notify( "kill_track_staff_weapon_respawn" ); + self endon( "kill_track_staff_weapon_respawn" ); + s_elemental_staff = get_staff_info_from_weapon_name( self.weaponname, 1 ); + s_upgraded_staff = s_elemental_staff.upgrade; + if ( !isDefined( self.base_weaponname ) ) + { + self.base_weaponname = s_elemental_staff.weapname; + } + flag_clear( self.base_weaponname + "_enabled" ); + has_weapon = 0; + while ( isalive( player ) ) + { + if ( isDefined( s_elemental_staff.charger.is_inserted ) && s_elemental_staff.charger.is_inserted || isDefined( s_upgraded_staff.charger.is_inserted ) || s_upgraded_staff.charger.is_inserted && isDefined( s_upgraded_staff.ee_in_use ) && s_upgraded_staff.ee_in_use ) + { + has_weapon = 1; + break; + } + weapons = player getweaponslistprimaries(); + foreach ( weapon in weapons ) + { + n_melee_element = 0; + if ( weapon == self.base_weaponname ) + { + s_elemental_staff.prev_ammo_stock = player getweaponammostock( weapon ); + s_elemental_staff.prev_ammo_clip = player getweaponammoclip( weapon ); + has_weapon = 1; + } + else if ( weapon == s_upgraded_staff.weapname ) + { + s_upgraded_staff.prev_ammo_stock = player getweaponammostock( weapon ); + s_upgraded_staff.prev_ammo_clip = player getweaponammoclip( weapon ); + has_weapon = 1; + n_melee_element = s_upgraded_staff.enum; + } + if ( player hasweapon( "staff_revive_zm" ) ) + { + s_upgraded_staff.revive_ammo_stock = player getweaponammostock( "staff_revive_zm" ); + s_upgraded_staff.revive_ammo_clip = player getweaponammoclip( "staff_revive_zm" ); + } + if ( has_weapon && isDefined( player.one_inch_punch_flag_has_been_init ) && !player.one_inch_punch_flag_has_been_init && n_melee_element != 0 ) + { + cur_weapon = player getcurrentweapon(); + if ( cur_weapon != weapon && isDefined( player.use_staff_melee ) && player.use_staff_melee ) + { + player update_staff_accessories( 0 ); + } + else + { + if ( cur_weapon == weapon && isDefined( player.use_staff_melee ) && !player.use_staff_melee ) + { + player update_staff_accessories( n_melee_element ); + } + } + } + } + if ( !has_weapon ) + { + break; + } + wait 0.5; + has_weapon = 0; + } + b_staff_in_use = 0; + a_players = getplayers(); + foreach ( check_player in a_players ) + { + weapons = check_player getweaponslistprimaries(); + for ( i = 0; i < weapons.size; i++ ) + { + if ( weapons[ i ] == self.base_weaponname || weapons[ i ] == s_upgraded_staff.weapname ) + { + b_staff_in_use = 1; + } + } + } + if ( !b_staff_in_use ) + { + model = getent( "craftable_" + self.base_weaponname, "targetname" ); + model show(); + flag_set( self.base_weaponname + "_enabled" ); + } + clear_player_staff( self.base_weaponname, player ); +} + +set_player_staff( str_weaponname, e_player ) //checked matches cerberus output +{ + s_staff = get_staff_info_from_weapon_name( str_weaponname ); + s_staff.e_owner = e_player; + n_player = e_player getentitynumber() + 1; + e_player.staff_enum = s_staff.enum; + if ( n_player <= 4 ) + { + level setclientfield( "staff_player" + n_player, s_staff.enum ); + } + e_player update_staff_accessories( s_staff.enum ); + /* +/# + iprintlnbold( "Player " + n_player + " has staff " + s_staff.enum ); +#/ + */ +} + +clear_player_staff_by_player_number( n_player ) //checked matches cerberus output +{ + if ( n_player <= 4 ) + { + level setclientfield( "staff_player" + n_player, 0 ); + } +} + +clear_player_staff( str_weaponname, e_owner ) //checked changed to match cerberus output +{ + s_staff = get_staff_info_from_weapon_name( str_weaponname ); + if ( isDefined( e_owner ) && isDefined( s_staff.e_owner ) && e_owner != s_staff.e_owner ) + { + return; + } + if ( !isDefined( e_owner ) ) + { + e_owner = s_staff.e_owner; + } + if ( isDefined( e_owner ) ) + { + if ( !isDefined( e_owner.staff_enum ) && !isDefined( s_staff.enum ) || isDefined( e_owner.staff_enum ) && isDefined( s_staff.enum ) && e_owner.staff_enum == s_staff.enum ) + { + n_player = e_owner getentitynumber() + 1; + e_owner.staff_enum = 0; + if ( n_player <= 4 ) + { + level setclientfield( "staff_player" + n_player, 0 ); + } + e_owner update_staff_accessories( 0 ); + } + } + /* +/# + iprintlnbold( "Nobody has staff " + s_staff.enum ); +#/ + */ + s_staff.e_owner = undefined; +} + +hide_staff_model() //checked changed to match cerberus output +{ + staffs = getentarray( "craftable_staff_model", "script_noteworthy" ); + foreach ( stave in staffs ) + { + stave ghost(); + } +} + + + diff --git a/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_dig.gsc b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_dig.gsc new file mode 100644 index 0000000..b8bccf8 --- /dev/null +++ b/Plutonium specific gsc-related fixes/8 Player Origins Fix/zm_tomb_dig.gsc @@ -0,0 +1,1023 @@ +//checked includes match cerberus output +#include maps/mp/zombies/_zm_powerup_zombie_blood; +#include maps/mp/zombies/_zm_weap_claymore; +#include maps/mp/zombies/_zm_powerups; +#include maps/mp/zm_tomb_main_quest; +#include maps/mp/zombies/_zm_stats; +#include maps/mp/zombies/_zm_zonemgr; +#include maps/mp/zombies/_zm_audio_announcer; +#include maps/mp/zombies/_zm_audio; +#include maps/mp/zm_tomb_utility; +#include maps/mp/zombies/_zm_unitrigger; +#include maps/mp/zombies/_zm_utility; +#include maps/mp/_utility; +#include common_scripts/utility; + +init_shovel() //checked changed to match cerberus output +{ + precachemodel( "p6_zm_tm_dig_mound" ); + precachemodel( "p6_zm_tm_dig_mound_blood" ); + precachemodel( "p6_zm_tm_shovel" ); + precachemodel( "zombie_pickup_perk_bottle" ); + precachemodel( "t6_wpn_claymore_world" ); + maps/mp/zombies/_zm_audio_announcer::createvox( "blood_money", "powerup_blood_money" ); + onplayerconnect_callback( ::init_shovel_player ); + a_shovel_pos = getstructarray( "shovel_location", "targetname" ); + a_shovel_zone = []; + foreach ( s_shovel_pos in a_shovel_pos ) + { + if ( !isDefined( a_shovel_zone[ s_shovel_pos.script_noteworthy ] ) ) + { + a_shovel_zone[ s_shovel_pos.script_noteworthy ] = []; + } + a_shovel_zone[ s_shovel_pos.script_noteworthy ][ a_shovel_zone[ s_shovel_pos.script_noteworthy ].size ] = s_shovel_pos; + } + foreach ( a_zone in a_shovel_zone ) + { + s_pos = a_zone[ randomint( a_zone.size ) ]; + m_shovel = spawn( "script_model", s_pos.origin ); + m_shovel.angles = s_pos.angles; + m_shovel setmodel( "p6_zm_tm_shovel" ); + generate_shovel_unitrigger( m_shovel ); + } + level.get_player_perk_purchase_limit = ::get_player_perk_purchase_limit; + level.bonus_points_powerup_override = ::bonus_points_powerup_override; + level thread dig_powerups_tracking(); + level thread dig_spots_init(); + registerclientfield( "world", "shovel_player1", 14000, 2, "int", undefined, 0 ); + registerclientfield( "world", "shovel_player2", 14000, 2, "int", undefined, 0 ); + registerclientfield( "world", "shovel_player3", 14000, 2, "int", undefined, 0 ); + registerclientfield( "world", "shovel_player4", 14000, 2, "int", undefined, 0 ); + registerclientfield( "world", "helmet_player1", 14000, 1, "int", undefined, 0 ); + registerclientfield( "world", "helmet_player2", 14000, 1, "int", undefined, 0 ); + registerclientfield( "world", "helmet_player3", 14000, 1, "int", undefined, 0 ); + registerclientfield( "world", "helmet_player4", 14000, 1, "int", undefined, 0 ); + /* +/# + level thread setup_dig_devgui(); +#/ + */ +} + +init_shovel_player() //checked matches cerberus output +{ + self.dig_vars[ "has_shovel" ] = 0; + self.dig_vars[ "has_upgraded_shovel" ] = 0; + self.dig_vars[ "has_helmet" ] = 0; + self.dig_vars[ "n_spots_dug" ] = 0; + self.dig_vars[ "n_losing_streak" ] = 0; +} + +generate_shovel_unitrigger( e_shovel ) //checked changed to match cerberus output +{ + s_unitrigger_stub = spawnstruct(); + s_unitrigger_stub.origin = e_shovel.origin + vectorScale( ( 0, 0, 1 ), 32 ); + s_unitrigger_stub.angles = e_shovel.angles; + s_unitrigger_stub.radius = 32; + s_unitrigger_stub.script_length = 64; + s_unitrigger_stub.script_width = 64; + s_unitrigger_stub.script_height = 64; + s_unitrigger_stub.cursor_hint = "HINT_NOICON"; + s_unitrigger_stub.hint_string = &"ZM_TOMB_SHPU"; + s_unitrigger_stub.script_unitrigger_type = "unitrigger_box_use"; + s_unitrigger_stub.require_look_at = 1; + s_unitrigger_stub.prompt_and_visibility_func = ::shovel_trigger_prompt_and_visiblity; + s_unitrigger_stub.e_shovel = e_shovel; + unitrigger_force_per_player_triggers( s_unitrigger_stub, 1 ); + maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( s_unitrigger_stub, ::shovel_unitrigger_think ); +} + +shovel_trigger_prompt_and_visiblity( e_player ) //checked matches cerberus output +{ + can_use = self.stub shovel_prompt_update( e_player ); + self setinvisibletoplayer( e_player, !can_use ); + self sethintstring( self.stub.hint_string ); + return can_use; +} + +shovel_prompt_update( e_player ) //checked matches cerberus output +{ + if ( !self unitrigger_stub_show_hint_prompt_valid( e_player ) ) + { + return 0; + } + self.hint_string = &"ZM_TOMB_SHPU"; + if ( isDefined( e_player.dig_vars[ "has_shovel" ] ) && e_player.dig_vars[ "has_shovel" ] ) + { + self.hint_string = &"ZM_TOMB_SHAG"; + } + return 1; +} + +shovel_unitrigger_think() //checked changed to match cerberus output +{ + self endon( "kill_trigger" ); + while ( 1 ) + { + self waittill( "trigger", e_player ); + if ( e_player != self.parent_player ) + { + continue; + } + if ( isDefined( e_player.dig_vars[ "has_shovel" ] ) && !e_player.dig_vars[ "has_shovel" ] ) + { + e_player.dig_vars[ "has_shovel" ] = 1; + e_player playsound( "zmb_craftable_pickup" ); + e_player dig_reward_dialog( "pickup_shovel" ); + n_player = e_player getentitynumber() + 1; + if ( n_player <= 4 ) + { + level setclientfield( "shovel_player" + n_player, 1 ); + } + e_player thread dig_disconnect_watch( n_player, self.stub.e_shovel.origin, self.stub.e_shovel.angles ); + self.stub.e_shovel delete(); + maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub ); + } + } +} + +dig_reward_dialog( str_category ) //checked matches cerberus output +{ + if ( isDefined( self.dig_vo_cooldown ) && !self.dig_vo_cooldown ) + { + self do_player_general_vox( "digging", str_category ); + if ( str_category != "pickup_shovel" ) + { + self thread dig_reward_vo_cooldown(); + } + } +} + +dig_reward_vo_cooldown() //checked matches cerberus output +{ + self endon( "disconnect" ); + self.dig_vo_cooldown = 1; + wait 60; + self.dig_vo_cooldown = undefined; +} + +unitrigger_stub_show_hint_prompt_valid( e_player ) //checked matches cerberus output +{ + if ( !is_player_valid( e_player ) ) + { + self.hint_string = ""; + return 0; + } + return 1; +} + +dig_disconnect_watch( n_player, v_origin, v_angles ) //checked matches cerberus output +{ + self waittill( "disconnect" ); + if ( n_player <= 4 ) + { + level setclientfield( "shovel_player" + n_player, 0 ); + level setclientfield( "helmet_player" + n_player, 0 ); + } + m_shovel = spawn( "script_model", v_origin ); + m_shovel.angles = v_angles; + m_shovel setmodel( "p6_zm_tm_shovel" ); + generate_shovel_unitrigger( m_shovel ); +} + +dig_spots_init() //checked changed to match cerberus output +{ + flag_wait( "start_zombie_round_logic" ); + level.n_dig_spots_cur = 0; + level.n_dig_spots_max = 15; + level.a_dig_spots = getstructarray( "dig_spot", "targetname" ); + foreach ( s_dig_spot in level.a_dig_spots ) + { + if ( !isDefined( s_dig_spot.angles ) ) + { + s_dig_spot.angles = ( 0, 0, 0 ); + } + if ( isDefined( s_dig_spot.script_noteworthy ) && s_dig_spot.script_noteworthy == "initial_spot" ) + { + s_dig_spot thread dig_spot_spawn(); + } + else + { + s_dig_spot.dug = 1; + } + s_dig_spot.str_zone = maps/mp/zombies/_zm_zonemgr::get_zone_from_position( s_dig_spot.origin + vectorScale( ( 0, 0, 1 ), 32 ), 1 ); + if ( !isDefined( s_dig_spot.str_zone ) ) + { + s_dig_spot.str_zone = ""; + /* +/# + assertmsg( "Dig spot at ( " + s_dig_spot.origin[ 0 ] + ", " + s_dig_spot.origin[ 1 ] + ", " + s_dig_spot.origin[ 2 ] + ") is not in a zone." ); +#/ + */ + } + wait_network_frame(); + } + level thread dig_spots_respawn(); +} + +dig_spots_respawn( a_dig_spots ) //checked partially changed to match cerberus output see info.md +{ + while ( 1 ) + { + level waittill( "end_of_round" ); + wait 2; + a_dig_spots = array_randomize( level.a_dig_spots ); + n_respawned = 0; + n_respawned_max = 3; + if ( level.weather_snow > 0 ) + { + n_respawned_max = 0; + } + else if ( level.weather_rain > 0 ) + { + n_respawned_max = 5; + } + if ( level.weather_snow == 0 ) + { + n_respawned_max += randomint( get_players().size ); + } + for ( i = 0; i < a_dig_spots.size; i++ ) + { + if ( isDefined( a_dig_spots[ i ].dug ) && a_dig_spots[ i ].dug && n_respawned < n_respawned_max && level.n_dig_spots_cur <= level.n_dig_spots_max ) + { + a_dig_spots[ i ].dug = undefined; + a_dig_spots[ i ] thread dig_spot_spawn(); + wait_network_frame(); + n_respawned++; + } + } + if ( level.weather_snow > 0 && level.ice_staff_pieces.size > 0 ) + { + foreach ( s_staff in level.ice_staff_pieces ) + { + a_staff_spots = []; + n_active_mounds = 0; + for ( i = 0; i < level.a_dig_spots.size; i++ ) + { + if ( isDefined( s_dig_spot.str_zone ) && issubstr( s_dig_spot.str_zone, s_staff.zone_substr ) ) + { + if ( isDefined( s_dig_spot.dug ) && !s_dig_spot.dug ) + { + n_active_mounds++; + } + else + { + a_staff_spots[ a_staff_spots.size ] = s_dig_spot; + } + } + } + if ( n_active_mounds < 2 && a_staff_spots.size > 0 && level.n_dig_spots_cur <= level.n_dig_spots_max ) + { + n_index = randomint( a_staff_spots.size ); + a_staff_spots[ n_index ].dug = undefined; + a_staff_spots[ n_index ] thread dig_spot_spawn(); + arrayremoveindex( a_staff_spots, n_index ); + n_active_mounds++; + wait_network_frame(); + } + } + } + } +} + +dig_spot_spawn() //checked changed to match cerberus output +{ + level.n_dig_spots_cur++; + self.m_dig = spawn( "script_model", self.origin + vectorScale( ( 0, 0, -1 ), 40 ) ); + self.m_dig setmodel( "p6_zm_tm_dig_mound" ); + self.m_dig.angles = self.angles; + self.m_dig moveto( self.origin, 3, 0, 1 ); + self.m_dig waittill( "movedone" ); + t_dig = tomb_spawn_trigger_radius( self.origin + vectorScale( ( 0, 0, 1 ), 20 ), 100, 1 ); + t_dig.prompt_and_visibility_func = ::dig_spot_trigger_visibility; + t_dig.require_look_at = 1; + t_dig waittill_dug( self ); + t_dig tomb_unitrigger_delete(); + t_dig = undefined; + self.m_dig delete(); + self.m_dig = undefined; +} + +dig_spot_trigger_visibility( player ) //checked matches cerberus output +{ + if ( isDefined( player.dig_vars[ "has_shovel" ] ) && player.dig_vars[ "has_shovel" ] ) + { + self sethintstring( &"ZM_TOMB_X2D" ); + } + else + { + self sethintstring( &"ZM_TOMB_NS" ); + } + return 1; +} + +waittill_dug( s_dig_spot ) //checked changed to match cerberus output +{ + while ( 1 ) + { + self waittill( "trigger", player ); + if ( isDefined( player.dig_vars[ "has_shovel" ] ) && player.dig_vars[ "has_shovel" ] ) + { + player playsound( "evt_dig" ); + s_dig_spot.dug = 1; + level.n_dig_spots_cur--; + + playfx( level._effect[ "digging" ], self.origin ); + player setclientfieldtoplayer( "player_rumble_and_shake", 1 ); + player maps/mp/zombies/_zm_stats::increment_client_stat( "tomb_dig", 0 ); + player maps/mp/zombies/_zm_stats::increment_player_stat( "tomb_dig" ); + s_staff_piece = s_dig_spot maps/mp/zm_tomb_main_quest::dig_spot_get_staff_piece( player ); + if ( isDefined( s_staff_piece ) ) + { + s_staff_piece maps/mp/zm_tomb_main_quest::show_ice_staff_piece( self.origin ); + player dig_reward_dialog( "dig_staff_part" ); + } + else + { + n_good_chance = 50; + if ( player.dig_vars[ "n_spots_dug" ] == 0 || player.dig_vars[ "n_losing_streak" ] == 3 ) + { + player.dig_vars[ "n_losing_streak" ] = 0; + n_good_chance = 100; + } + if ( player.dig_vars[ "has_upgraded_shovel" ] ) + { + if ( !player.dig_vars[ "has_helmet" ] ) + { + n_helmet_roll = randomint( 100 ); + if ( n_helmet_roll >= 95 ) + { + player.dig_vars[ "has_helmet" ] = 1; + n_player = player getentitynumber() + 1; + if ( n_player <= 4 ) + { + level setclientfield( "helmet_player" + n_player, 1 ); + } + player playsoundtoplayer( "zmb_squest_golden_anything", player ); + player maps/mp/zombies/_zm_stats::increment_client_stat( "tomb_golden_hard_hat", 0 ); + player maps/mp/zombies/_zm_stats::increment_player_stat( "tomb_golden_hard_hat" ); + return; + } + } + n_good_chance = 70; + } + n_prize_roll = randomint( 100 ); + if ( n_prize_roll > n_good_chance ) + { + if ( cointoss() ) + { + player dig_reward_dialog( "dig_grenade" ); + self thread dig_up_grenade( player ); + } + else + { + player dig_reward_dialog( "dig_zombie" ); + self thread dig_up_zombie( player, s_dig_spot ); + } + player.dig_vars[ "n_losing_streak" ]++; + } + else if ( cointoss() ) + { + self thread dig_up_powerup( player ); + } + else + { + player dig_reward_dialog( "dig_gun" ); + self thread dig_up_weapon( player ); + } + } + if ( !player.dig_vars[ "has_upgraded_shovel" ] ) + { + player.dig_vars[ "n_spots_dug" ]++; + if ( player.dig_vars[ "n_spots_dug" ] >= 30 ) + { + player.dig_vars[ "has_upgraded_shovel" ] = 1; + player thread ee_zombie_blood_dig(); + n_player = player getentitynumber() + 1; + if ( n_player <= 4 ) + { + level setclientfield( "shovel_player" + n_player, 2 ); + } + player playsoundtoplayer( "zmb_squest_golden_anything", player ); + player maps/mp/zombies/_zm_stats::increment_client_stat( "tomb_golden_shovel", 0 ); + player maps/mp/zombies/_zm_stats::increment_player_stat( "tomb_golden_shovel" ); + } + } + return; + } + } +} + +dig_up_zombie( player, s_dig_spot ) //checked changed to match cerberus output +{ + ai_zombie = spawn_zombie( level.dig_spawners[ 0 ] ); + ai_zombie endon( "death" ); + ai_zombie ghost(); + e_linker = spawn( "script_origin", ( 0, 0, 0 ) ); + e_linker.origin = ai_zombie.origin; + e_linker.angles = ai_zombie.angles; + ai_zombie linkto( e_linker ); + e_linker moveto( player.origin + vectorScale( ( 1, 1, 0 ), 100 ), 0,1 ); + e_linker waittill( "movedone" ); + ai_zombie unlink(); + e_linker delete(); + ai_zombie show(); + ai_zombie playsound( "evt_zombie_dig_dirt" ); + ai_zombie dug_zombie_rise( s_dig_spot ); + find_flesh_struct_string = "find_flesh"; + ai_zombie notify( "zombie_custom_think_done", find_flesh_struct_string ); +} + +dig_up_powerup( player ) //checked changed to match cerberus output +{ + powerup = spawn( "script_model", self.origin ); + powerup endon( "powerup_grabbed" ); + powerup endon( "powerup_timedout" ); + a_rare_powerups = dig_get_rare_powerups( player ); + powerup_item = undefined; + if ( ( level.dig_n_powerups_spawned + level.powerup_drop_count ) > 4 || level.dig_last_prize_rare || a_rare_powerups.size == 0 || randomint( 100 ) < 80 ) + { + if ( level.dig_n_zombie_bloods_spawned < 1 && randomint( 100 ) > 70 ) + { + powerup_item = "zombie_blood"; + level.dig_n_zombie_bloods_spawned++; + level.dig_n_powerups_spawned++; + player dig_reward_dialog( "dig_powerup" ); + } + else + { + powerup_item = "bonus_points_player"; + player dig_reward_dialog( "dig_cash" ); + } + level.dig_last_prize_rare = 0; + } + else + { + powerup_item = a_rare_powerups[ randomint( a_rare_powerups.size ) ]; + level.dig_last_prize_rare = 1; + level.dig_n_powerups_spawned++; + player dig_reward_dialog( "dig_powerup" ); + dig_set_powerup_spawned( powerup_item ); + } + powerup maps/mp/zombies/_zm_powerups::powerup_setup( powerup_item ); + powerup movez( 40, 0.6 ); + powerup waittill( "movedone" ); + powerup thread maps/mp/zombies/_zm_powerups::powerup_timeout(); + powerup thread maps/mp/zombies/_zm_powerups::powerup_wobble(); + powerup thread maps/mp/zombies/_zm_powerups::powerup_grab(); +} + +dig_get_rare_powerups( player ) //checked changed to match cerberus output +{ + a_rare_powerups = []; + a_possible_powerups = array( "nuke", "double_points" ); + if ( level.dig_magic_box_moved && !dig_has_powerup_spawned( "fire_sale" ) ) + { + a_possible_powerups[ a_possible_powerups.size ] = "fire_sale"; + } + if ( player.dig_vars[ "has_upgraded_shovel" ] ) + { + a_possible_powerups = combinearrays( a_possible_powerups, array( "insta_kill", "full_ammo" ) ); + } + foreach ( powerup in a_possible_powerups ) + { + if ( !dig_has_powerup_spawned( powerup ) ) + { + a_rare_powerups[ a_rare_powerups.size ] = powerup; + } + } + return a_rare_powerups; +} + +dig_up_grenade( player ) //checked changed to match cerberus output +{ + player endon( "disconnect" ); + v_spawnpt = self.origin; + grenade = "frag_grenade_zm"; + n_rand = randomintrange( 0, 4 ); + player magicgrenadetype( grenade, v_spawnpt, vectorScale( ( 0, 0, 1 ), 300 ), 3 ); + player playsound( "evt_grenade_digup" ); + if ( n_rand ) + { + wait 0.3; + if ( cointoss() ) + { + player magicgrenadetype( grenade, v_spawnpt, ( 50, 50, 300 ), 3 ); + } + } +} + +dig_up_weapon( digger ) //checked changed to match cerberus output +{ + a_common_weapons = array( "ballista_zm", "c96_zm", "870mcs_zm" ); + a_rare_weapons = array( "dsr50_zm", "srm1216_zm" ); + if ( digger.dig_vars[ "has_upgraded_shovel" ] ) + { + a_rare_weapons = combinearrays( a_rare_weapons, array( "claymore_zm", "ak74u_zm", "ksg_zm", "mp40_zm", "mp44_zm" ) ); + } + str_weapon = undefined; + if ( randomint( 100 ) < 90 ) + { + str_weapon = a_common_weapons[ getarraykeys( a_common_weapons )[ randomint( getarraykeys( a_common_weapons ).size ) ] ]; + } + else + { + str_weapon = a_rare_weapons[ getarraykeys( a_rare_weapons )[ randomint( getarraykeys( a_rare_weapons ).size ) ] ]; + } + v_spawnpt = self.origin + ( 0, 0, 40 ); + v_spawnang = ( 0, 0, 0 ); + str_spec_model = undefined; + if ( str_weapon == "claymore_zm" ) + { + str_spec_model = "t6_wpn_claymore_world"; + v_spawnang += vectorScale( ( 0, 1, 0 ), 90 ); + } + v_angles = digger getplayerangles(); + v_angles = ( 0, v_angles[ 1 ], 0 ) + vectorScale( ( 0, 1, 0 ), 90 ) + v_spawnang; + m_weapon = spawn_weapon_model( str_weapon, str_spec_model, v_spawnpt, v_angles ); + if ( str_weapon == "claymore_zm" ) + { + m_weapon setmodel( "t6_wpn_claymore_world" ); + v_spawnang += vectorScale( ( 0, 0, 1 ), 90 ); + } + m_weapon.angles = v_angles; + m_weapon playloopsound( "evt_weapon_digup" ); + m_weapon thread timer_til_despawn( v_spawnpt, 40 * -1 ); + m_weapon endon( "dig_up_weapon_timed_out" ); + playfxontag( level._effect[ "special_glow" ], m_weapon, "tag_origin" ); + m_weapon.trigger = tomb_spawn_trigger_radius( v_spawnpt, 100, 1 ); + m_weapon.trigger.hint_string = &"ZM_TOMB_X2PU"; + m_weapon.trigger.hint_parm1 = getweapondisplayname( str_weapon ); + m_weapon.trigger waittill( "trigger", player ); + m_weapon.trigger notify( "weapon_grabbed" ); + m_weapon.trigger thread swap_weapon( str_weapon, player ); + if ( isDefined( m_weapon.trigger ) ) + { + m_weapon.trigger tomb_unitrigger_delete(); + m_weapon.trigger = undefined; + } + if ( isDefined( m_weapon ) ) + { + m_weapon delete(); + } + if ( player != digger ) + { + digger notify( "dig_up_weapon_shared" ); + } +} + +swap_weapon( str_weapon, e_player ) //checked matches cerberus output +{ + str_current_weapon = e_player getcurrentweapon(); + if ( str_weapon == "claymore_zm" ) + { + if ( !e_player hasweapon( str_weapon ) ) + { + e_player thread maps/mp/zombies/_zm_weap_claymore::show_claymore_hint( "claymore_purchased" ); + e_player thread maps/mp/zombies/_zm_weap_claymore::claymore_setup(); + e_player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", "grenade" ); + } + else + { + e_player givemaxammo( str_weapon ); + } + return; + } + if ( is_player_valid( e_player ) && !e_player.is_drinking && !is_placeable_mine( str_current_weapon ) && !is_equipment( str_current_weapon ) && level.revive_tool != str_current_weapon && str_current_weapon != "none" && !e_player hacker_active() ) + { + if ( !e_player hasweapon( str_weapon ) ) + { + e_player take_old_weapon_and_give_new( str_current_weapon, str_weapon ); + return; + } + else + { + e_player givemaxammo( str_weapon ); + } + } +} + +take_old_weapon_and_give_new( current_weapon, weapon ) //checked matches cerberus output +{ + a_weapons = self getweaponslistprimaries(); + if ( isDefined( a_weapons ) && a_weapons.size >= get_player_weapon_limit( self ) ) + { + self takeweapon( current_weapon ); + } + self giveweapon( weapon ); + self switchtoweapon( weapon ); +} + +timer_til_despawn( v_float, n_dist ) //checked matches cerberus output +{ + self endon( "weapon_grabbed" ); + putbacktime = 12; + self movez( n_dist, putbacktime, putbacktime * 0.5 ); + self waittill( "movedone" ); + self notify( "dig_up_weapon_timed_out" ); + if ( isDefined( self.trigger ) ) + { + self.trigger tomb_unitrigger_delete(); + self.trigger = undefined; + } + if ( isDefined( self ) ) + { + self delete(); + } +} + +get_player_perk_purchase_limit() //checked matches cerberus output +{ + if ( isDefined( self.player_perk_purchase_limit ) ) + { + return self.player_perk_purchase_limit; + } + return level.perk_purchase_limit; +} + +increment_player_perk_purchase_limit() //checked matches cerberus output +{ + if ( !isDefined( self.player_perk_purchase_limit ) ) + { + self.player_perk_purchase_limit = level.perk_purchase_limit; + } + if ( self.player_perk_purchase_limit < 8 ) + { + self.player_perk_purchase_limit++; + } +} + +ee_zombie_blood_dig() //checked changed to match cerberus output +{ + self endon( "disconnect" ); + n_z_spots_found = 0; + a_z_spots = getstructarray( "zombie_blood_dig_spot", "targetname" ); + self.t_zombie_blood_dig = spawn( "trigger_radius_use", ( 0, 0, 0 ), 0, 100, 50 ); + self.t_zombie_blood_dig.e_unique_player = self; + self.t_zombie_blood_dig triggerignoreteam(); + self.t_zombie_blood_dig setcursorhint( "HINT_NOICON" ); + self.t_zombie_blood_dig sethintstring( &"ZM_TOMB_X2D" ); + self.t_zombie_blood_dig maps/mp/zombies/_zm_powerup_zombie_blood::make_zombie_blood_entity(); + while ( n_z_spots_found < 4 ) + { + a_randomized = array_randomize( a_z_spots ); + n_index = undefined; + for ( i = 0; i < a_randomized.size; i++ ) + { + if ( !isDefined( a_randomized[ i ].n_player ) ) + { + n_index = i; + break; + } + } + /* +/# + assert( isDefined( n_index ), "No more zombie blood dig spots. Add more to the map." ); +#/ + */ + s_z_spot = a_randomized[ n_index ]; + s_z_spot.n_player = self getentitynumber(); + s_z_spot create_zombie_blood_dig_spot( self ); + n_z_spots_found++; + level waittill( "end_of_round" ); + } + self.t_zombie_blood_dig delete(); +} + +ee_zombie_blood_dig_disconnect_watch() //checked changed to match cerberus output +{ + self waittill( "disconnect" ); + if ( isDefined( self.t_zombie_blood_dig ) ) + { + self.t_zombie_blood_dig delete(); + } + a_z_spots = getstructarray( "zombie_blood_dig_spot", "targetname" ); + foreach ( s_pos in a_z_spots ) + { + if ( isDefined( s_pos.n_player ) && s_pos.n_player == self getentitynumber() ) + { + s_pos.n_player = undefined; + } + if ( isDefined( s_pos.m_dig ) ) + { + s_pos delete(); + } + } +} + +create_zombie_blood_dig_spot( e_player ) //checked changed to match cerberus output +{ + self.m_dig = spawn( "script_model", self.origin + vectorScale( ( 0, 0, -1 ), 40 ) ); + self.m_dig.angles = self.angles; + self.m_dig setmodel( "p6_zm_tm_dig_mound_blood" ); + self.m_dig maps/mp/zombies/_zm_powerup_zombie_blood::make_zombie_blood_entity(); + self.m_dig moveto( self.origin, 3, 0, 1 ); + self.m_dig waittill( "movedone" ); + self.m_dig.e_unique_player = e_player; + /* +/# + self thread puzzle_debug_position( "+", vectorScale( ( 0, 0, 1 ), 255 ), self.origin ); +#/ + */ + e_player.t_zombie_blood_dig.origin = self.origin + vectorScale( ( 0, 0, 1 ), 20 ); + e_player.t_zombie_blood_dig waittill_zombie_blood_dug( self ); + /* +/# + self notify( "stop_debug_position" ); +#/ + */ +} + +waittill_zombie_blood_dug( s_dig_spot ) //checked changed to match cerberus output +{ + self endon( "death" ); + while ( 1 ) + { + self waittill( "trigger", player ); + if ( isDefined( player.dig_vars[ "has_shovel" ] ) && player.dig_vars[ "has_shovel" ] ) + { + player.t_zombie_blood_dig.origin = ( 0, 0, 0 ); + player playsound( "evt_dig" ); + playfx( level._effect[ "digging" ], self.origin ); + s_dig_spot.m_dig delete(); + spawn_perk_upgrade_bottle( s_dig_spot.origin, player ); + return; + } + } +} + +spawn_perk_upgrade_bottle( v_origin, e_player ) //checked changed to match cerberus output +{ + m_bottle = spawn( "script_model", v_origin + vectorScale( ( 0, 0, 1 ), 40 ) ); + m_bottle setmodel( "zombie_pickup_perk_bottle" ); + m_bottle.angles = vectorScale( ( 1, 0, 0 ), 10 ); + m_bottle setinvisibletoall(); + m_bottle setvisibletoplayer( e_player ); + m_fx = spawn( "script_model", m_bottle.origin ); + m_fx setmodel( "tag_origin" ); + m_fx setinvisibletoall(); + m_fx setvisibletoplayer( e_player ); + playfxontag( level._effect[ "special_glow" ], m_fx, "tag_origin" ); + m_bottle linkto( m_fx ); + m_fx thread rotate_perk_upgrade_bottle(); + while ( isDefined( e_player ) && !e_player istouching( m_bottle ) ) + { + wait 0.05; + } + m_bottle delete(); + m_fx delete(); + if ( isDefined( e_player ) ) + { + e_player increment_player_perk_purchase_limit(); + e_player maps/mp/zombies/_zm_stats::increment_client_stat( "tomb_perk_extension", 0 ); + e_player maps/mp/zombies/_zm_stats::increment_player_stat( "tomb_perk_extension" ); + } +} + +rotate_perk_upgrade_bottle() //checked matches cerberus output +{ + self endon( "death" ); + while ( 1 ) + { + self rotateyaw( 360, 5 ); + self waittill( "rotatedone" ); + } +} + +bonus_points_powerup_override() //checked matches cerberus output +{ + level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "blood_money" ); + points = randomintrange( 1, 6 ) * 50; + return points; +} + +dig_powerups_tracking() //checked changed to match cerberus output +{ + level endon( "end_game" ); + level.dig_powerups_tracking = []; + level.dig_magic_box_moved = 0; + level.dig_last_prize_rare = 0; + level.dig_n_zombie_bloods_spawned = 0; + level.dig_n_powerups_spawned = 0; + while ( 1 ) + { + level waittill( "end_of_round" ); + foreach ( value in level.dig_powerups_tracking ) + { + level.dig_powerups_tracking[ value ] = 0; + } + level.dig_n_zombie_bloods_spawned = 0; + level.dig_n_powerups_spawned = 0; + } +} + +dig_has_powerup_spawned( str_powerup ) //checked matches cerberus output +{ + if ( !isDefined( level.dig_powerups_tracking[ str_powerup ] ) ) + { + level.dig_powerups_tracking[ str_powerup ] = 0; + } + return level.dig_powerups_tracking[ str_powerup ]; +} + +dig_set_powerup_spawned( str_powerup ) //checked matches cerberus output +{ + level.dig_powerups_tracking[ str_powerup ] = 1; +} + +setup_dig_devgui() //dev call skipped +{ + /* +/# + setdvar( "give_shovel", "off" ); + setdvar( "give_golden_shovel", "off" ); + setdvar( "give_helmet", "off" ); + setdvar( "spawn_max_mounds", "off" ); + setdvar( "spawn_all_mounds", "off" ); + setdvar( "test_blood_mounds", "off" ); + setdvar( "force_weather_rain", "off" ); + setdvar( "force_weather_snow", "off" ); + setdvar( "force_weather_none", "off" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Give Shovel:1" "give_shovel on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Give Golden Shovel:2" "give_golden_shovel on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Give Helmet:3" "give_helmet on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Spawn Max Mounds:4" "spawn_max_mounds on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Spawn All Mounds:5" "spawn_all_mounds on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Digging:1/Test Blood Mounds:6" "test_blood_mounds on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Weather:1/Rain:1" "force_weather_rain on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Weather:1/Snow:2" "force_weather_snow on"\n" ); + adddebugcommand( "devgui_cmd "Zombies/Tomb:1/Weather:1/Clear:3" "force_weather_none on"\n" ); + level thread watch_devgui_dig(); +#/ + */ +} + +watch_devgui_dig() //dev call skipped +{ + /* +/# + while ( 1 ) + { + while ( getDvar( "give_shovel" ) == "on" ) + { + setdvar( "give_shovel", "off" ); + _a1131 = getplayers(); + _k1131 = getFirstArrayKey( _a1131 ); + while ( isDefined( _k1131 ) ) + { + player = _a1131[ _k1131 ]; + player.dig_vars[ "has_shovel" ] = 1; + n_player = player getentitynumber() + 1; + level setclientfield( "shovel_player" + n_player, 1 ); + _k1131 = getNextArrayKey( _a1131, _k1131 ); + } + } + while ( getDvar( "give_golden_shovel" ) == "on" ) + { + setdvar( "give_golden_shovel", "off" ); + _a1141 = getplayers(); + _k1141 = getFirstArrayKey( _a1141 ); + while ( isDefined( _k1141 ) ) + { + player = _a1141[ _k1141 ]; + player.dig_vars[ "has_shovel" ] = 1; + player.dig_vars[ "has_upgraded_shovel" ] = 1; + player thread ee_zombie_blood_dig(); + n_player = player getentitynumber() + 1; + level setclientfield( "shovel_player" + n_player, 2 ); + _k1141 = getNextArrayKey( _a1141, _k1141 ); + } + } + while ( getDvar( "give_helmet" ) == "on" ) + { + setdvar( "give_helmet", "off" ); + _a1153 = getplayers(); + _k1153 = getFirstArrayKey( _a1153 ); + while ( isDefined( _k1153 ) ) + { + player = _a1153[ _k1153 ]; + player.dig_vars[ "has_helmet" ] = 1; + n_player = player getentitynumber() + 1; + level setclientfield( "helmet_player" + n_player, 1 ); + _k1153 = getNextArrayKey( _a1153, _k1153 ); + } + } + while ( getDvar( "spawn_max_mounds" ) == "on" ) + { + setdvar( "spawn_max_mounds", "off" ); + a_dig_spots = array_randomize( level.a_dig_spots ); + i = 0; + while ( i < a_dig_spots.size ) + { + if ( isDefined( a_dig_spots[ i ].dug ) && a_dig_spots[ i ].dug && level.n_dig_spots_cur <= level.n_dig_spots_max ) + { + a_dig_spots[ i ].dug = undefined; + a_dig_spots[ i ] thread dig_spot_spawn(); + wait_network_frame(); + } + i++; + } + } + while ( getDvar( "spawn_all_mounds" ) == "on" ) + { + setdvar( "spawn_all_mounds", "off" ); + a_dig_spots = array_randomize( level.a_dig_spots ); + i = 0; + while ( i < a_dig_spots.size ) + { + if ( isDefined( a_dig_spots[ i ].dug ) && a_dig_spots[ i ].dug ) + { + a_dig_spots[ i ].dug = undefined; + a_dig_spots[ i ] thread dig_spot_spawn(); + wait_network_frame(); + } + i++; + } + } + while ( getDvar( "test_blood_mounds" ) == "on" ) + { + setdvar( "test_blood_mounds", "off" ); + a_z_spots = getstructarray( "zombie_blood_dig_spot", "targetname" ); + _a1193 = a_z_spots; + _k1193 = getFirstArrayKey( _a1193 ); + while ( isDefined( _k1193 ) ) + { + s_spot = _a1193[ _k1193 ]; + s_spot.m_dig = spawn( "script_model", s_spot.origin + vectorScale( ( 0, 0, -1 ), 40 ) ); + s_spot.m_dig.angles = s_spot.angles; + s_spot.m_dig setmodel( "p6_zm_tm_dig_mound_blood" ); + s_spot.m_dig moveto( s_spot.origin, 3, 0, 1 ); + wait_network_frame(); + _k1193 = getNextArrayKey( _a1193, _k1193 ); + } + } + while ( getDvar( "force_weather_rain" ) == "on" ) + { + setdvar( "force_weather_rain", "off" ); + level.weather_snow = 0; + level.weather_rain = 5; + level.weather_vision = 1; + level setclientfield( "rain_level", level.weather_rain ); + level setclientfield( "snow_level", level.weather_snow ); + wait 1; + _a1212 = getplayers(); + _k1212 = getFirstArrayKey( _a1212 ); + while ( isDefined( _k1212 ) ) + { + player = _a1212[ _k1212 ]; + if ( is_player_valid( player, 0, 1 ) ) + { + player set_weather_to_player(); + } + _k1212 = getNextArrayKey( _a1212, _k1212 ); + } + } + while ( getDvar( "force_weather_snow" ) == "on" ) + { + setdvar( "force_weather_snow", "off" ); + level.weather_snow = 5; + level.weather_rain = 0; + level.weather_vision = 2; + level setclientfield( "rain_level", level.weather_rain ); + level setclientfield( "snow_level", level.weather_snow ); + wait 1; + _a1229 = getplayers(); + _k1229 = getFirstArrayKey( _a1229 ); + while ( isDefined( _k1229 ) ) + { + player = _a1229[ _k1229 ]; + if ( is_player_valid( player, 0, 1 ) ) + { + player set_weather_to_player(); + } + _k1229 = getNextArrayKey( _a1229, _k1229 ); + } + } + while ( getDvar( "force_weather_none" ) == "on" ) + { + setdvar( "force_weather_none", "off" ); + level.weather_snow = 0; + level.weather_rain = 0; + level.weather_vision = 3; + level setclientfield( "rain_level", level.weather_rain ); + level setclientfield( "snow_level", level.weather_snow ); + wait 1; + _a1246 = getplayers(); + _k1246 = getFirstArrayKey( _a1246 ); + while ( isDefined( _k1246 ) ) + { + player = _a1246[ _k1246 ]; + if ( is_player_valid( player, 0, 1 ) ) + { + player set_weather_to_player(); + } + _k1246 = getNextArrayKey( _a1246, _k1246 ); + } + } + wait 0,05; +#/ + } + */ +} + + diff --git a/Plutonium specific gsc-related fixes/_zm_audio_announcer.gsc b/Plutonium specific gsc-related fixes/Audio Announcer Fix/_zm_audio_announcer.gsc similarity index 100% rename from Plutonium specific gsc-related fixes/_zm_audio_announcer.gsc rename to Plutonium specific gsc-related fixes/Audio Announcer Fix/_zm_audio_announcer.gsc diff --git a/Plutonium specific gsc-related fixes/_bot.gsc b/Plutonium specific gsc-related fixes/MP Bots fix/_bot.gsc similarity index 100% rename from Plutonium specific gsc-related fixes/_bot.gsc rename to Plutonium specific gsc-related fixes/MP Bots fix/_bot.gsc diff --git a/Plutonium specific gsc-related fixes/zm_transit_utility.gsc b/Plutonium specific gsc-related fixes/Tombstone Fix/zm_transit_utility.gsc similarity index 100% rename from Plutonium specific gsc-related fixes/zm_transit_utility.gsc rename to Plutonium specific gsc-related fixes/Tombstone Fix/zm_transit_utility.gsc diff --git a/Plutonium specific gsc-related fixes/readme.md b/Plutonium specific gsc-related fixes/readme.md index 98b3dd8..f54fcc7 100644 --- a/Plutonium specific gsc-related fixes/readme.md +++ b/Plutonium specific gsc-related fixes/readme.md @@ -1,19 +1,29 @@ # Fixed gscs for Plutonium Only: -### Zombies Announcer +### Audio Announcer Fix Compile _zm_audio_announcer.gsc and place it in maps/mp/zombies. This will fix the announcer not having any dialog on all maps and gamemodes. -### Tombstone +### Tombstone Fix Compile zm_transit_utility.gsc and place it in maps/mp. This will allow tombstone to spawn in on dedicated servers. -### Bots +### MP Bots Fix Compile _bot.gsc and place it maps/mp/bots -This should fix the bots difficulty on dedicated servers. \ No newline at end of file +This should fix the bots difficulty on dedicated servers. + +### 8 Player Origins Fix + +Compile zm_tomb_amb.gsc as zm_tomb_amb.gsc and place it maps/mp + +Compile zm_tomb_craftables.gsc as zm_tomb_craftables.gsc and place it maps/mp + +Compile zm_tomb_dig.gsc as zm_tomb_dig.gsc and place it maps/mp + +This fixes the crashes caused by 8 players on origins \ No newline at end of file