INSANEMODE/Recompilable-gscs-for-BO2-zombies-and-multiplayer
1
0
Fork 0
mirror of https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git synced 2025-06-08 01:47:50 -05:00
Code Issues Releases Wiki Activity

uploaded 15 scripts as a baseline for zm_prison_patch

Browse Source
This commit is contained in:
JezuzLizard 2020-05-31 18:16:33 -07:00
parent 32c7128428
commit 88cbdf413c
16 changed files with 13236 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2289
zm_prison_patch/maps/mp/zombies/_zm_afterlife.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

2939
zm_prison_patch/maps/mp/zombies/_zm_ai_brutus.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

3192
zm_prison_patch/maps/mp/zombies/_zm_craftables.gsc Normal file
View File

File diff suppressed because it is too large Load Diff

11
zm_prison_patch/maps/mp/zombies/_zm_game_module_grief.gsc Normal file
View File

@ -0,0 +1,11 @@
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
register_game_module()
{
level.game_module_grief_index = 9;
maps/mp/zombies/_zm_game_module::register_game_module( level.game_module_grief_index, "zgrief", ::onpreinitgametype, ::onpostinitgametype, undefined, ::onspawnzombie, ::onstartgametype );
}

6
zm_prison_patch/maps/mp/zombies/_zm_game_module_meat.gsc Normal file
View File

@ -0,0 +1,6 @@
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_game_module_meat_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;

685
zm_prison_patch/maps/mp/zombies/_zm_game_module_meat_utility.gsc Normal file
View File

@ -0,0 +1,685 @@
#include maps/mp/zombies/_zm_powerups;
#include maps/mp/gametypes_zm/zmeat;
#include maps/mp/zombies/_zm_audio_announcer;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_game_module_utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
award_grenades_for_team( team )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
lethal_grenade = players[ i ] get_player_lethal_grenade();
players[ i ] giveweapon( lethal_grenade );
players[ i ] setweaponammoclip( lethal_grenade, 4 );
}
i++;
}
}
get_players_on_meat_team( team )
{
players = get_players();
players_on_team = [];
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
players_on_team[ players_on_team.size ] = players[ i ];
}
i++;
}
return players_on_team;
}
get_alive_players_on_meat_team( team )
{
players = get_players();
players_on_team = [];
i = 0;
while ( i < players.size )
{
if ( !isDefined( players[ i ]._meat_team ) || players[ i ]._meat_team != team )
{
i++;
continue;
}
else
{
if ( players[ i ].sessionstate == "spectator" || players[ i ] maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
i++;
continue;
}
else
{
players_on_team[ players_on_team.size ] = players[ i ];
}
}
i++;
}
return players_on_team;
}
init_minigun_ring()
{
if ( isDefined( level._minigun_ring ) )
{
return;
}
ring_pos = getstruct( level._meat_location + "_meat_minigun", "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._minigun_ring = spawn( "script_model", ring_pos.origin );
level._minigun_ring.angles = ring_pos.angles;
level._minigun_ring setmodel( ring_pos.script_parameters );
level._minigun_ring_clip = getent( level._meat_location + "_meat_minigun_clip", "script_noteworthy" );
if ( isDefined( level._minigun_ring_clip ) )
{
level._minigun_ring_clip linkto( level._minigun_ring );
}
else
{
iprintlnbold( "BUG: no level._minigun_ring_clip" );
}
level._minigun_ring_trig = getent( level._meat_location + "_meat_minigun_trig", "targetname" );
if ( isDefined( level._minigun_ring_trig ) )
{
level._minigun_ring_trig enablelinkto();
level._minigun_ring_trig linkto( level._minigun_ring );
level._minigun_icon = spawn( "script_model", level._minigun_ring_trig.origin );
level._minigun_icon setmodel( getweaponmodel( "minigun_zm" ) );
level._minigun_icon linkto( level._minigun_ring );
level._minigun_icon setclientfield( "ring_glowfx", 1 );
level thread ring_toss( level._minigun_ring_trig, "minigun" );
}
else
{
iprintlnbold( "BUG: no level._minigun_ring_trig" );
}
level._minigun_ring thread move_ring( ring_pos );
level._minigun_ring thread rotate_ring( 1 );
}
init_ammo_ring()
{
if ( isDefined( level._ammo_ring ) )
{
return;
}
name = level._meat_location + "_meat_ammo";
ring_pos = getstruct( name, "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._ammo_ring = spawn( "script_model", ring_pos.origin );
level._ammo_ring.angles = ring_pos.angles;
level._ammo_ring setmodel( ring_pos.script_parameters );
name = level._meat_location + "_meat_ammo_clip";
level._ammo_ring_clip = getent( name, "script_noteworthy" );
if ( isDefined( level._ammo_ring_clip ) )
{
level._ammo_ring_clip linkto( level._ammo_ring );
}
else
{
iprintlnbold( "BUG: no level._ammo_ring_clip" );
}
name = level._meat_location + "_meat_ammo_trig";
level._ammo_ring_trig = getent( name, "targetname" );
if ( isDefined( level._ammo_ring_clip ) )
{
level._ammo_ring_trig enablelinkto();
level._ammo_ring_trig linkto( level._ammo_ring );
level._ammo_icon = spawn( "script_model", level._ammo_ring_trig.origin );
level._ammo_icon setmodel( "zombie_ammocan" );
level._ammo_icon linkto( level._ammo_ring );
level._ammo_icon setclientfield( "ring_glowfx", 1 );
level thread ring_toss( level._ammo_ring_trig, "ammo" );
}
else
{
iprintlnbold( "BUG: no level._ammo_ring_trig" );
}
level._ammo_ring thread move_ring( ring_pos );
level._ammo_ring thread rotate_ring( 1 );
}
init_splitter_ring()
{
if ( isDefined( level._splitter_ring ) )
{
return;
}
ring_pos = getstruct( level._meat_location + "_meat_splitter", "script_noteworthy" );
if ( !isDefined( ring_pos ) )
{
return;
}
level._splitter_ring = spawn( "script_model", ring_pos.origin );
level._splitter_ring.angles = ring_pos.angles;
level._splitter_ring setmodel( ring_pos.script_parameters );
level._splitter_ring_trig1 = getent( level._meat_location + "_meat_splitter_trig_1", "targetname" );
level._splitter_ring_trig2 = getent( level._meat_location + "_meat_splitter_trig_2", "targetname" );
if ( isDefined( level._splitter_ring_trig1 ) && isDefined( level._splitter_ring_trig2 ) )
{
level._splitter_ring_trig1 enablelinkto();
level._splitter_ring_trig2 enablelinkto();
}
else
{
iprintlnbold( "BUG: missing at least one level._splitter_ring_trig" );
}
level._splitter_ring notsolid();
level._meat_icon = spawn( "script_model", level._splitter_ring.origin );
level._meat_icon setmodel( getweaponmodel( get_gamemode_var( "item_meat_name" ) ) );
level._meat_icon linkto( level._splitter_ring );
level._meat_icon setclientfield( "ring_glow_meatfx", 1 );
if ( isDefined( level._splitter_ring_trig1 ) && isDefined( level._splitter_ring_trig2 ) )
{
level._splitter_ring_trig1 linkto( level._splitter_ring );
level._splitter_ring_trig2 linkto( level._splitter_ring );
level thread ring_toss( level._splitter_ring_trig1, "splitter" );
level thread ring_toss( level._splitter_ring_trig2, "splitter" );
}
level._splitter_ring thread move_ring( ring_pos );
}
ring_toss( trig, type )
{
level endon( "end_game" );
while ( 1 )
{
while ( isDefined( level._ring_triggered ) && level._ring_triggered )
{
wait 0,05;
}
if ( isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_moving ) && level.item_meat.meat_is_moving )
{
if ( level.item_meat istouching( trig ) )
{
level thread ring_toss_prize( type, trig );
level._ring_triggered = 1;
level thread ring_cooldown();
}
}
wait 0,05;
}
}
ring_cooldown()
{
wait 3;
level._ring_triggered = 0;
}
ring_toss_prize( type, trig )
{
switch( type )
{
case "splitter":
level thread meat_splitter( trig );
break;
case "minigun":
level thread minigun_prize( trig );
break;
case "ammo":
level thread ammo_prize( trig );
break;
}
}
meat_splitter( trig )
{
level endon( "meat_grabbed" );
level endon( "meat_kicked" );
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
exit_trig = getent( trig.target, "targetname" );
exit_struct = getstruct( trig.target, "targetname" );
while ( isDefined( level.item_meat ) && !level.item_meat istouching( exit_trig ) )
{
wait 0,05;
}
while ( isDefined( level.item_meat ) && level.item_meat istouching( exit_trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
playfx( level._effect[ "fw_burst" ], exit_trig.origin );
flare_dir = vectornormalize( anglesToForward( exit_struct.angles ) );
velocity = vectorScale( flare_dir, randomintrange( 400, 600 ) );
velocity1 = ( velocity[ 0 ] + 75, velocity[ 1 ] + 75, randomintrange( 75, 125 ) );
velocity2 = ( velocity[ 0 ] - 75, velocity[ 1 ] - 75, randomintrange( 75, 125 ) );
velocity3 = ( velocity[ 0 ], velocity[ 1 ], 100 );
level._fake_meats = [];
level._meat_splitter_activated = 1;
org = exit_trig.origin;
player = get_players()[ 0 ];
player._spawning_meat = 1;
player endon( "disconnect" );
thread split_meat( player, org, velocity1, velocity2, velocity );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_splitter", undefined, undefined, 1 );
wait 0,1;
while ( isDefined( level.splitting_meat ) && level.splitting_meat )
{
wait 0,05;
}
player._spawning_meat = 0;
}
split_meat( player, org, vel1, vel2, vel3 )
{
level.splitting_meat = 1;
level.item_meat cleanup_meat();
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel1 );
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel2 );
wait_network_frame();
level._fake_meats[ level._fake_meats.size ] = player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, vel3 );
real_meat = random( level._fake_meats );
_a330 = level._fake_meats;
_k330 = getFirstArrayKey( _a330 );
while ( isDefined( _k330 ) )
{
meat = _a330[ _k330 ];
if ( real_meat != meat )
{
meat._fake_meat = 1;
meat thread maps/mp/gametypes_zm/zmeat::delete_on_real_meat_pickup();
}
else
{
meat._fake_meat = 0;
level.item_meat = meat;
}
_k330 = getNextArrayKey( _a330, _k330 );
}
level.splitting_meat = 0;
}
minigun_prize( trig )
{
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
if ( isDefined( level._minigun_toss_cooldown ) && level._minigun_toss_cooldown )
{
return;
}
level thread minigun_toss_cooldown();
if ( !is_player_valid( level._last_person_to_throw_meat ) )
{
return;
}
level._last_person_to_throw_meat thread maps/mp/zombies/_zm_powerups::powerup_vo( "minigun" );
level thread maps/mp/zombies/_zm_powerups::minigun_weapon_powerup( level._last_person_to_throw_meat );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_minigun", undefined, undefined, 1 );
}
ammo_prize( trig )
{
while ( isDefined( level.item_meat ) && level.item_meat istouching( trig ) )
{
wait 0,05;
}
if ( !isDefined( level.item_meat ) )
{
return;
}
if ( isDefined( level._ammo_toss_cooldown ) && level._ammo_toss_cooldown )
{
return;
}
playfx( level._effect[ "poltergeist" ], trig.origin );
level thread ammo_toss_cooldown();
level._last_person_to_throw_meat thread maps/mp/zombies/_zm_powerups::powerup_vo( "full_ammo" );
level thread maps/mp/zombies/_zm_powerups::full_ammo_powerup( undefined, level._last_person_to_throw_meat );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_ring_ammo", undefined, undefined, 1 );
}
minigun_toss_cooldown()
{
level._minigun_toss_cooldown = 1;
if ( isDefined( level._minigun_icon ) )
{
level._minigun_icon delete();
}
waittill_any_or_timeout( 120, "meat_end" );
playfx( level._effect[ "poltergeist" ], level._minigun_ring_trig.origin );
level._minigun_icon = spawn( "script_model", level._minigun_ring_trig.origin );
level._minigun_icon setmodel( getweaponmodel( "minigun_zm" ) );
level._minigun_icon linkto( level._minigun_ring );
level._minigun_icon setclientfield( "ring_glowfx", 1 );
level._minigun_toss_cooldown = 0;
}
ammo_toss_cooldown()
{
level._ammo_toss_cooldown = 1;
if ( isDefined( level._ammo_icon ) )
{
level._ammo_icon delete();
}
waittill_any_or_timeout( 60, "meat_end" );
playfx( level._effect[ "poltergeist" ], level._ammo_ring_trig.origin );
level._ammo_icon = spawn( "script_model", level._ammo_ring_trig.origin );
level._ammo_icon setmodel( "zombie_ammocan" );
level._ammo_icon linkto( level._ammo_ring );
level._ammo_icon setclientfield( "ring_glowfx", 1 );
level._ammo_toss_cooldown = 0;
}
wait_for_team_death( team )
{
level endon( "meat_end" );
encounters_team = undefined;
while ( 1 )
{
wait 1;
while ( isDefined( level._checking_for_save ) && level._checking_for_save )
{
wait 0,1;
}
alive_team_players = get_alive_players_on_meat_team( team );
while ( alive_team_players.size > 0 )
{
encounters_team = alive_team_players[ 0 ]._encounters_team;
}
}
if ( !isDefined( encounters_team ) )
{
return;
}
winning_team = "A";
if ( encounters_team == "A" )
{
winning_team = "B";
}
level notify( "meat_end" );
}
check_should_save_player( team )
{
if ( !isDefined( level._meat_on_team ) )
{
return 0;
}
level._checking_for_save = 1;
players = get_players_on_meat_team( team );
i = 0;
while ( i < players.size )
{
player = players[ i ];
if ( isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == player )
{
while ( isDefined( level.item_meat.meat_is_moving ) && !level.item_meat.meat_is_moving && isDefined( level._meat_splitter_activated ) || level._meat_splitter_activated && isDefined( level.item_meat.meat_is_flying ) && level.item_meat.meat_is_flying )
{
if ( level._meat_on_team != player._meat_team )
{
break;
}
else if ( isDefined( level.item_meat.meat_is_rolling ) && level.item_meat.meat_is_rolling && level._meat_on_team == player._meat_team )
{
break;
}
else
{
wait 0,05;
}
}
if ( !isDefined( player ) )
{
level._checking_for_save = 0;
return 0;
}
if ( isDefined( player.last_damage_from_zombie_or_player ) && !player.last_damage_from_zombie_or_player )
{
level._checking_for_save = 0;
return 0;
}
if ( level._meat_on_team != player._meat_team && isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == player )
{
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
level thread revive_saved_player( player );
return 1;
}
}
}
i++;
}
level._checking_for_save = 0;
return 0;
}
watch_save_player()
{
if ( !isDefined( level._meat_on_team ) )
{
return 0;
}
if ( !isDefined( level._last_person_to_throw_meat ) || level._last_person_to_throw_meat != self )
{
return 0;
}
level._checking_for_save = 1;
while ( isDefined( level.splitting_meat ) || level.splitting_meat && isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_moving ) || level.item_meat.meat_is_moving && isDefined( level.item_meat.meat_is_flying ) && level.item_meat.meat_is_flying )
{
if ( level._meat_on_team != self._meat_team )
{
}
else if ( isDefined( level.item_meat ) && isDefined( level.item_meat.meat_is_rolling ) && level.item_meat.meat_is_rolling && level._meat_on_team == self._meat_team )
{
}
else
{
wait 0,05;
}
}
if ( level._meat_on_team != self._meat_team && isDefined( level._last_person_to_throw_meat ) && level._last_person_to_throw_meat == self )
{
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
{
level thread revive_saved_player( self );
return 1;
}
}
level._checking_for_save = 0;
return 0;
}
revive_saved_player( player )
{
player endon( "disconnect" );
player iprintlnbold( &"ZOMBIE_PLAYER_SAVED" );
player playsound( level.zmb_laugh_alias );
wait 0,25;
playfx( level._effect[ "poltergeist" ], player.origin );
playsoundatposition( "zmb_bolt", player.origin );
earthquake( 0,5, 0,75, player.origin, 1000 );
player thread maps/mp/zombies/_zm_laststand::auto_revive( player );
player._saved_by_throw++;
level._checking_for_save = 0;
}
get_game_module_players( player )
{
return get_players_on_meat_team( player._meat_team );
}
item_meat_spawn( origin )
{
org = origin;
player = get_players()[ 0 ];
player._spawning_meat = 1;
player magicgrenadetype( get_gamemode_var( "item_meat_name" ), org, ( 0, 0, 1 ) );
playsoundatposition( "zmb_spawn_powerup", org );
wait 0,1;
player._spawning_meat = undefined;
}
init_item_meat( gametype )
{
if ( gametype == "zgrief" )
{
set_gamemode_var_once( "item_meat_name", "item_meat_zm" );
set_gamemode_var_once( "item_meat_model", "t6_wpn_zmb_meat_world" );
}
else
{
set_gamemode_var_once( "item_meat_name", "item_head_zm" );
set_gamemode_var_once( "item_meat_model", "t6_wpn_zmb_severedhead_world" );
}
precacheitem( get_gamemode_var( "item_meat_name" ) );
set_gamemode_var_once( "start_item_meat_name", get_gamemode_var( "item_meat_name" ) );
level.meat_weaponidx = getweaponindexfromname( get_gamemode_var( "item_meat_name" ) );
level.meat_pickupsound = getweaponpickupsound( level.meat_weaponidx );
level.meat_pickupsoundplayer = getweaponpickupsoundplayer( level.meat_weaponidx );
}
meat_intro( launch_spot )
{
flag_wait( "start_encounters_match_logic" );
wait 3;
level thread multi_launch( launch_spot );
launch_meat( launch_spot );
drop_meat( level._meat_start_point );
level thread maps/mp/zombies/_zm_audio_announcer::leaderdialog( "meat_drop", undefined, undefined, 1 );
}
launch_meat( launch_spot )
{
level waittill( "launch_meat" );
spots = getstructarray( launch_spot, "targetname" );
if ( isDefined( spots ) && spots.size > 0 )
{
spot = random( spots );
meat = spawn( "script_model", spot.origin );
meat setmodel( "tag_origin" );
wait_network_frame();
playfxontag( level._effect[ "fw_trail" ], meat, "tag_origin" );
meat playloopsound( "zmb_souls_loop", 0,75 );
dest = spot;
while ( isDefined( dest ) && isDefined( dest.target ) )
{
new_dest = getstruct( dest.target, "targetname" );
dest = new_dest;
dist = distance( new_dest.origin, meat.origin );
time = dist / 700;
meat moveto( new_dest.origin, time );
meat waittill( "movedone" );
}
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin );
wait randomfloatrange( 0,2, 0,5 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin + ( randomintrange( 50, 150 ), randomintrange( 50, 150 ), randomintrange( -20, 20 ) ) );
wait randomfloatrange( 0,5, 0,75 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin + ( randomintrange( -150, -50 ), randomintrange( -150, 50 ), randomintrange( -20, 20 ) ) );
wait randomfloatrange( 0,5, 0,75 );
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_burst" ], meat.origin );
meat delete();
}
}
multi_launch( launch_spot )
{
spots = getstructarray( launch_spot, "targetname" );
if ( isDefined( spots ) && spots.size > 0 )
{
x = 0;
while ( x < 3 )
{
i = 0;
while ( i < spots.size )
{
delay = randomfloatrange( 0,1, 0,25 );
level thread fake_launch( spots[ i ], delay );
i++;
}
wait randomfloatrange( 0,25, 0,75 );
if ( x > 1 )
{
level notify( "launch_meat" );
}
x++;
}
}
else wait randomfloatrange( 0,25, 0,75 );
level notify( "launch_meat" );
}
fake_launch( launch_spot, delay )
{
wait delay;
wait randomfloatrange( 0,1, 4 );
meat = spawn( "script_model", launch_spot.origin + ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 ) );
meat setmodel( "tag_origin" );
wait_network_frame();
playfxontag( level._effect[ "fw_trail_cheap" ], meat, "tag_origin" );
meat playloopsound( "zmb_souls_loop", 0,75 );
dest = launch_spot;
while ( isDefined( dest ) && isDefined( dest.target ) )
{
random_offset = ( randomintrange( -60, 60 ), randomintrange( -60, 60 ), 0 );
new_dest = getstruct( dest.target, "targetname" );
dest = new_dest;
dist = distance( new_dest.origin + random_offset, meat.origin );
time = dist / 700;
meat moveto( new_dest.origin + random_offset, time );
meat waittill( "movedone" );
}
meat playsound( "zmb_souls_end" );
playfx( level._effect[ "fw_pre_burst" ], meat.origin );
meat delete();
}
drop_meat( drop_spot )
{
meat = spawn( "script_model", drop_spot + vectorScale( ( 0, 0, 1 ), 600 ) );
meat setmodel( "tag_origin" );
dist = distance( meat.origin, drop_spot );
time = dist / 400;
wait 2;
meat moveto( drop_spot, time );
wait_network_frame();
playfxontag( level._effect[ "fw_drop" ], meat, "tag_origin" );
meat waittill( "movedone" );
playfx( level._effect[ "fw_impact" ], drop_spot );
level notify( "reset_meat" );
meat delete();
}

46
zm_prison_patch/maps/mp/zombies/_zm_game_module_utility.gsc Normal file
View File

@ -0,0 +1,46 @@
#include maps/mp/zombies/_zm_game_module_meat;
#include maps/mp/zombies/_zm_game_module_meat_utility;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/gametypes_zm/_hud_util;
#include maps/mp/_utility;
init_item_meat()
{
level.item_meat_name = "item_meat_zm";
precacheitem( level.item_meat_name );
}
move_ring( ring )
{
positions = getstructarray( ring.target, "targetname" );
positions = array_randomize( positions );
level endon( "end_game" );
while ( 1 )
{
_a23 = positions;
_k23 = getFirstArrayKey( _a23 );
while ( isDefined( _k23 ) )
{
position = _a23[ _k23 ];
self moveto( position.origin, randomintrange( 30, 45 ) );
self waittill( "movedone" );
_k23 = getNextArrayKey( _a23, _k23 );
}
}
}
rotate_ring( forward )
{
level endon( "end_game" );
dir = -360;
if ( forward )
{
dir = 360;
}
while ( 1 )
{
self rotateyaw( dir, 9 );
wait 9;
}
}

217
zm_prison_patch/maps/mp/zombies/_zm_magicbox_prison.gsc Normal file
View File

@ -0,0 +1,217 @@
#include maps/mp/zombies/_zm_magicbox;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
registerclientfield( "zbarrier", "magicbox_initial_fx", 2000, 1, "int" );
registerclientfield( "zbarrier", "magicbox_amb_fx", 2000, 2, "int" );
registerclientfield( "zbarrier", "magicbox_open_fx", 2000, 1, "int" );
registerclientfield( "zbarrier", "magicbox_leaving_fx", 2000, 1, "int" );
level._effect[ "lght_marker" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_marker" );
level._effect[ "lght_marker_flare" ] = loadfx( "maps/zombie_alcatraz/fx_zmb_tranzit_marker_fl" );
level._effect[ "poltergeist" ] = loadfx( "system_elements/fx_null" );
level._effect[ "box_gone_ambient" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_magicbox_amb" );
level._effect[ "box_here_ambient" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_magicbox_arrive" );
level._effect[ "box_is_open" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_magicbox_open" );
level._effect[ "box_is_locked" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_magicbox_lock" );
level._effect[ "box_is_leaving" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_magicbox_leave" );
level.using_locked_magicbox = 1;
level.chest_joker_model = "p6_anim_zm_al_magic_box_lock_red";
precachemodel( level.chest_joker_model );
level.chest_joker_custom_movement = ::custom_joker_movement;
level.magic_box_zbarrier_state_func = ::set_magic_box_zbarrier_state;
level thread wait_then_create_base_magic_box_fx();
level thread handle_fire_sale();
}
custom_joker_movement()
{
v_origin = self.weapon_model.origin - vectorScale( ( 0, 1, 0 ), 5 );
self.weapon_model delete();
m_lock = spawn( "script_model", v_origin );
m_lock setmodel( level.chest_joker_model );
m_lock.angles = self.angles + vectorScale( ( 0, 1, 0 ), 180 );
wait 0,5;
level notify( "weapon_fly_away_start" );
wait 1;
m_lock rotateyaw( 3000, 4, 4 );
wait 3;
m_lock movez( 20, 0,5, 0,5 );
m_lock waittill( "movedone" );
m_lock movez( -100, 0,5, 0,5 );
m_lock waittill( "movedone" );
m_lock delete();
self notify( "box_moving" );
level notify( "weapon_fly_away_end" );
}
wait_then_create_base_magic_box_fx()
{
while ( !isDefined( level.chests ) )
{
wait 0,5;
}
while ( !isDefined( level.chests[ level.chests.size - 1 ].zbarrier ) )
{
wait 0,5;
}
_a92 = level.chests;
_k92 = getFirstArrayKey( _a92 );
while ( isDefined( _k92 ) )
{
chest = _a92[ _k92 ];
chest.zbarrier setclientfield( "magicbox_initial_fx", 1 );
_k92 = getNextArrayKey( _a92, _k92 );
}
}
set_magic_box_zbarrier_state( state )
{
i = 0;
while ( i < self getnumzbarrierpieces() )
{
self hidezbarrierpiece( i );
i++;
}
self notify( "zbarrier_state_change" );
switch( state )
{
case "away":
self showzbarrierpiece( 0 );
self.state = "away";
self.owner.is_locked = 0;
break;
case "arriving":
self showzbarrierpiece( 1 );
self thread magic_box_arrives();
self.state = "arriving";
break;
case "initial":
self showzbarrierpiece( 1 );
self thread magic_box_initial();
thread maps/mp/zombies/_zm_unitrigger::register_static_unitrigger( self.owner.unitrigger_stub, ::maps/mp/zombies/_zm_magicbox::magicbox_unitrigger_think );
self.state = "close";
break;
case "open":
self showzbarrierpiece( 2 );
self thread magic_box_opens();
self.state = "open";
break;
case "close":
self showzbarrierpiece( 2 );
self thread magic_box_closes();
self.state = "close";
break;
case "leaving":
self showzbarrierpiece( 1 );
self thread magic_box_leaves();
self.state = "leaving";
self.owner.is_locked = 0;
break;
default:
if ( isDefined( level.custom_magicbox_state_handler ) )
{
self [[ level.custom_magicbox_state_handler ]]( state );
}
break;
}
}
magic_box_initial()
{
self setzbarrierpiecestate( 1, "open" );
wait 1;
self setclientfield( "magicbox_amb_fx", 1 );
}
magic_box_arrives()
{
self setclientfield( "magicbox_leaving_fx", 0 );
self setclientfield( "magicbox_amb_fx", 1 );
self setzbarrierpiecestate( 1, "opening" );
while ( self getzbarrierpiecestate( 1 ) == "opening" )
{
wait 0,05;
}
self notify( "arrived" );
self.state = "close";
}
magic_box_leaves()
{
self setclientfield( "magicbox_leaving_fx", 1 );
self setclientfield( "magicbox_open_fx", 0 );
self setzbarrierpiecestate( 1, "closing" );
self playsound( "zmb_hellbox_rise" );
while ( self getzbarrierpiecestate( 1 ) == "closing" )
{
wait 0,1;
}
self notify( "left" );
self setclientfield( "magicbox_amb_fx", 0 );
}
magic_box_opens()
{
self setclientfield( "magicbox_open_fx", 1 );
self setzbarrierpiecestate( 2, "opening" );
self playsound( "zmb_hellbox_open" );
while ( self getzbarrierpiecestate( 2 ) == "opening" )
{
wait 0,1;
}
self notify( "opened" );
}
magic_box_closes()
{
self setzbarrierpiecestate( 2, "closing" );
self playsound( "zmb_hellbox_close" );
while ( self getzbarrierpiecestate( 2 ) == "closing" )
{
wait 0,1;
}
self notify( "closed" );
self setclientfield( "magicbox_open_fx", 0 );
}
magic_box_do_weapon_rise()
{
self endon( "box_hacked_respin" );
self setzbarrierpiecestate( 3, "closed" );
self setzbarrierpiecestate( 4, "closed" );
wait_network_frame();
self zbarrierpieceuseboxriselogic( 3 );
self zbarrierpieceuseboxriselogic( 4 );
self showzbarrierpiece( 3 );
self showzbarrierpiece( 4 );
self setzbarrierpiecestate( 3, "opening" );
self setzbarrierpiecestate( 4, "opening" );
while ( self getzbarrierpiecestate( 3 ) != "open" )
{
wait 0,5;
}
self hidezbarrierpiece( 3 );
self hidezbarrierpiece( 4 );
}
handle_fire_sale()
{
while ( 1 )
{
level waittill( "fire_sale_off" );
i = 0;
while ( i < level.chests.size )
{
if ( level.chest_index != i && isDefined( level.chests[ i ].was_temp ) )
{
level.chests[ i ].zbarrier setclientfield( "magicbox_amb_fx", 0 );
}
i++;
}
}
}

556
zm_prison_patch/maps/mp/zombies/_zm_melee_weapon.gsc Normal file
View File

@ -0,0 +1,556 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn )
{
precacheitem( weapon_name );
precacheitem( flourish_weapon_name );
add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon );
melee_weapon_triggers = getentarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_weapon_triggers.size )
{
knife_model = getent( melee_weapon_triggers[ i ].target, "targetname" );
if ( isDefined( knife_model ) )
{
knife_model hide();
}
melee_weapon_triggers[ i ] thread melee_weapon_think( weapon_name, cost, has_weapon, give_weapon, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
melee_weapon_triggers[ i ] sethintstring( hint_string, cost );
melee_weapon_triggers[ i ] setcursorhint( "HINT_NOICON" );
melee_weapon_triggers[ i ] usetriggerrequirelookat();
i++;
}
melee_weapon_structs = getstructarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_weapon_structs.size )
{
prepare_stub( melee_weapon_structs[ i ].trigger_stub, weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn );
i++;
}
register_melee_weapon_for_level( weapon_name );
if ( !isDefined( level.ballistic_weapon_name ) )
{
level.ballistic_weapon_name = [];
}
level.ballistic_weapon_name[ weapon_name ] = ballistic_weapon_name;
if ( !isDefined( level.ballistic_upgraded_weapon_name ) )
{
level.ballistic_upgraded_weapon_name = [];
}
level.ballistic_upgraded_weapon_name[ weapon_name ] = ballistic_upgraded_weapon_name;
}
prepare_stub( stub, weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn )
{
if ( isDefined( stub ) )
{
stub.hint_string = hint_string;
stub.cost = cost;
stub.weapon_name = weapon_name;
stub.has_weapon = has_weapon;
stub.give_weapon = give_weapon;
stub.take_weapon = take_weapon;
stub.vo_dialog_id = vo_dialog_id;
stub.flourish_weapon_name = flourish_weapon_name;
stub.ballistic_weapon_name = ballistic_weapon_name;
stub.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
stub.trigger_func = ::melee_weapon_think;
stub.flourish_fn = flourish_fn;
}
}
add_stub( stub, weapon_name )
{
melee_weapon = undefined;
i = 0;
while ( i < level._melee_weapons.size )
{
if ( level._melee_weapons[ i ].weapon_name == weapon_name )
{
melee_weapon = level._melee_weapons[ i ];
break;
}
else
{
i++;
}
}
if ( isDefined( stub ) && isDefined( melee_weapon ) )
{
prepare_stub( stub, melee_weapon.weapon_name, melee_weapon.flourish_weapon_name, melee_weapon.ballistic_weapon_name, melee_weapon.ballistic_upgraded_weapon_name, melee_weapon.cost, melee_weapon.wallbuy_targetname, melee_weapon.hint_string, melee_weapon.vo_dialog_id, melee_weapon.has_weapon, melee_weapon.give_weapon, melee_weapon.take_weapon, melee_weapon.flourish_fn );
}
}
give_melee_weapon_by_name( weapon_name )
{
melee_weapon = undefined;
i = 0;
while ( i < level._melee_weapons.size )
{
if ( level._melee_weapons[ i ].weapon_name == weapon_name )
{
melee_weapon = level._melee_weapons[ i ];
break;
}
else
{
i++;
}
}
if ( isDefined( melee_weapon ) )
{
self thread give_melee_weapon( melee_weapon.vo_dialog_id, melee_weapon.flourish_weapon_name, melee_weapon.weapon_name, melee_weapon.ballistic_weapon_name, melee_weapon.ballistic_upgraded_weapon_name, melee_weapon.give_weapon, melee_weapon.flourish_fn, undefined );
}
}
add_melee_weapon( weapon_name, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, cost, wallbuy_targetname, hint_string, vo_dialog_id, has_weapon, give_weapon, take_weapon, flourish_fn )
{
melee_weapon = spawnstruct();
melee_weapon.weapon_name = weapon_name;
melee_weapon.flourish_weapon_name = flourish_weapon_name;
melee_weapon.ballistic_weapon_name = ballistic_weapon_name;
melee_weapon.ballistic_upgraded_weapon_name = ballistic_upgraded_weapon_name;
melee_weapon.cost = cost;
melee_weapon.wallbuy_targetname = wallbuy_targetname;
melee_weapon.hint_string = hint_string;
melee_weapon.vo_dialog_id = vo_dialog_id;
melee_weapon.has_weapon = has_weapon;
melee_weapon.give_weapon = give_weapon;
melee_weapon.take_weapon = take_weapon;
melee_weapon.flourish_fn = flourish_fn;
if ( !isDefined( level._melee_weapons ) )
{
level._melee_weapons = [];
}
level._melee_weapons[ level._melee_weapons.size ] = melee_weapon;
}
spectator_respawn_all()
{
i = 0;
while ( i < level._melee_weapons.size )
{
self [[ level._melee_weapons[ i ].take_weapon ]]();
i++;
}
i = 0;
while ( i < level._melee_weapons.size )
{
self spectator_respawn( level._melee_weapons[ i ].wallbuy_targetname, level._melee_weapons[ i ].take_weapon, level._melee_weapons[ i ].has_weapon );
i++;
}
}
spectator_respawn( wallbuy_targetname, take_weapon, has_weapon )
{
melee_triggers = getentarray( wallbuy_targetname, "targetname" );
players = get_players();
i = 0;
while ( i < melee_triggers.size )
{
melee_triggers[ i ] setvisibletoall();
while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
j = 0;
while ( j < players.size )
{
if ( players[ j ] [[ has_weapon ]]() )
{
melee_triggers[ i ] setinvisibletoplayer( players[ j ] );
}
j++;
}
}
i++;
}
}
trigger_hide_all()
{
i = 0;
while ( i < level._melee_weapons.size )
{
self trigger_hide( level._melee_weapons[ i ].wallbuy_targetname );
i++;
}
}
trigger_hide( wallbuy_targetname )
{
melee_triggers = getentarray( wallbuy_targetname, "targetname" );
i = 0;
while ( i < melee_triggers.size )
{
melee_triggers[ i ] setinvisibletoplayer( self );
i++;
}
}
has_any_ballistic_knife()
{
if ( self hasweapon( "knife_ballistic_zm" ) )
{
return 1;
}
if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
{
return 1;
}
i = 0;
while ( i < level._melee_weapons.size )
{
if ( self hasweapon( level._melee_weapons[ i ].ballistic_weapon_name ) )
{
return 1;
}
if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
{
return 1;
}
i++;
}
return 0;
}
has_upgraded_ballistic_knife()
{
if ( self hasweapon( "knife_ballistic_upgraded_zm" ) )
{
return 1;
}
i = 0;
while ( i < level._melee_weapons.size )
{
if ( self hasweapon( level._melee_weapons[ i ].ballistic_upgraded_weapon_name ) )
{
return 1;
}
i++;
}
return 0;
}
give_ballistic_knife( weapon_string, upgraded )
{
current_melee_weapon = self get_player_melee_weapon();
if ( isDefined( current_melee_weapon ) )
{
if ( upgraded && isDefined( level.ballistic_upgraded_weapon_name ) && isDefined( level.ballistic_upgraded_weapon_name[ current_melee_weapon ] ) )
{
weapon_string = level.ballistic_upgraded_weapon_name[ current_melee_weapon ];
}
if ( !upgraded && isDefined( level.ballistic_weapon_name ) && isDefined( level.ballistic_weapon_name[ current_melee_weapon ] ) )
{
weapon_string = level.ballistic_weapon_name[ current_melee_weapon ];
}
}
return weapon_string;
}
change_melee_weapon( weapon_name, current_weapon )
{
current_melee_weapon = self get_player_melee_weapon();
if ( isDefined( current_melee_weapon ) )
{
self takeweapon( current_melee_weapon );
unacquire_weapon_toggle( current_melee_weapon );
}
self set_player_melee_weapon( weapon_name );
had_ballistic = 0;
had_ballistic_upgraded = 0;
ballistic_was_primary = 0;
primaryweapons = self getweaponslistprimaries();
i = 0;
while ( i < primaryweapons.size )
{
primary_weapon = primaryweapons[ i ];
if ( issubstr( primary_weapon, "knife_ballistic_" ) )
{
had_ballistic = 1;
if ( primary_weapon == current_weapon )
{
ballistic_was_primary = 1;
}
self notify( "zmb_lost_knife" );
self takeweapon( primary_weapon );
unacquire_weapon_toggle( primary_weapon );
if ( issubstr( primary_weapon, "upgraded" ) )
{
had_ballistic_upgraded = 1;
}
}
i++;
}
if ( had_ballistic )
{
if ( had_ballistic_upgraded )
{
new_ballistic = level.ballistic_upgraded_weapon_name[ weapon_name ];
if ( ballistic_was_primary )
{
current_weapon = new_ballistic;
}
self giveweapon( new_ballistic, 0, self maps/mp/zombies/_zm_weapons::get_pack_a_punch_weapon_options( new_ballistic ) );
}
else
{
new_ballistic = level.ballistic_weapon_name[ weapon_name ];
if ( ballistic_was_primary )
{
current_weapon = new_ballistic;
}
self giveweapon( new_ballistic, 0 );
}
}
return current_weapon;
}
melee_weapon_think( weapon_name, cost, has_weapon, give_weapon, flourish_fn, vo_dialog_id, flourish_weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
{
self.first_time_triggered = 0;
while ( isDefined( self.stub ) )
{
self endon( "kill_trigger" );
if ( isDefined( self.stub.first_time_triggered ) )
{
self.first_time_triggered = self.stub.first_time_triggered;
}
weapon_name = self.stub.weapon_name;
cost = self.stub.cost;
has_weapon = self.stub.has_weapon;
give_weapon = self.stub.give_weapon;
flourish_fn = self.stub.flourish_fn;
vo_dialog_id = self.stub.vo_dialog_id;
flourish_weapon_name = self.stub.flourish_weapon_name;
ballistic_weapon_name = self.stub.ballistic_weapon_name;
ballistic_upgraded_weapon_name = self.stub.ballistic_upgraded_weapon_name;
players = getplayers();
while ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
i = 0;
while ( i < players.size )
{
if ( players[ i ] [[ has_weapon ]]() )
{
self setinvisibletoplayer( players[ i ] );
}
i++;
}
}
}
for ( ;; )
{
self waittill( "trigger", player );
if ( !is_player_valid( player ) )
{
player thread ignore_triggers( 0,5 );
continue;
}
else if ( player in_revive_trigger() )
{
wait 0,1;
continue;
}
else if ( player isthrowinggrenade() )
{
wait 0,1;
continue;
}
else if ( player.is_drinking > 0 )
{
wait 0,1;
continue;
}
else if ( player hasweapon( weapon_name ) || player has_powerup_weapon() )
{
wait 0,1;
continue;
}
else
{
if ( player isswitchingweapons() )
{
wait 0,1;
break;
}
else current_weapon = player getcurrentweapon();
if ( !is_placeable_mine( current_weapon ) || is_equipment( current_weapon ) && player has_powerup_weapon() )
{
wait 0,1;
break;
}
else
{
if ( player maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( player.intermission ) && player.intermission )
{
wait 0,1;
break;
}
else
{
player_has_weapon = player [[ has_weapon ]]();
if ( !player_has_weapon )
{
if ( player.score >= cost )
{
if ( self.first_time_triggered == 0 )
{
model = getent( self.target, "targetname" );
if ( isDefined( model ) )
{
model thread melee_weapon_show( player );
}
else
{
if ( isDefined( self.clientfieldname ) )
{
level setclientfield( self.clientfieldname, 1 );
}
}
self.first_time_triggered = 1;
if ( isDefined( self.stub ) )
{
self.stub.first_time_triggered = 1;
}
}
player maps/mp/zombies/_zm_score::minus_to_player_score( cost );
bbprint( "zombie_uses", "playername %s playerscore %d round %d cost %d name %s x %f y %f z %f type %s", player.name, player.score, level.round_number, cost, weapon_name, self.origin, "weapon" );
player thread give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, give_weapon, flourish_fn, self );
}
else
{
play_sound_on_ent( "no_purchase" );
player maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", "no_money_weapon", undefined, 1 );
}
break;
}
else
{
if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
self setinvisibletoplayer( player );
}
}
}
}
}
}
}
melee_weapon_show( player )
{
player_angles = vectorToAngle( player.origin - self.origin );
player_yaw = player_angles[ 1 ];
weapon_yaw = self.angles[ 1 ];
yaw_diff = angleClamp180( player_yaw - weapon_yaw );
if ( yaw_diff > 0 )
{
yaw = weapon_yaw - 90;
}
else
{
yaw = weapon_yaw + 90;
}
self.og_origin = self.origin;
self.origin += anglesToForward( ( 0, yaw, 0 ) ) * 8;
wait 0,05;
self show();
play_sound_at_pos( "weapon_show", self.origin, self );
time = 1;
self moveto( self.og_origin, time );
}
give_melee_weapon( vo_dialog_id, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name, give_weapon, flourish_fn, trigger )
{
if ( isDefined( flourish_fn ) )
{
self thread [[ flourish_fn ]]();
}
gun = self do_melee_weapon_flourish_begin( flourish_weapon_name );
self maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", vo_dialog_id );
self waittill_any( "fake_death", "death", "player_downed", "weapon_change_complete" );
self do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name );
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
{
return;
}
self [[ give_weapon ]]();
if ( isDefined( level._allow_melee_weapon_switching ) && !level._allow_melee_weapon_switching )
{
if ( isDefined( trigger ) )
{
trigger setinvisibletoplayer( self );
}
self trigger_hide_all();
}
}
do_melee_weapon_flourish_begin( flourish_weapon_name )
{
self increment_is_drinking();
self disable_player_move_states( 1 );
gun = self getcurrentweapon();
weapon = flourish_weapon_name;
self giveweapon( weapon );
self switchtoweapon( weapon );
return gun;
}
do_melee_weapon_flourish_end( gun, flourish_weapon_name, weapon_name, ballistic_weapon_name, ballistic_upgraded_weapon_name )
{
/#
assert( !is_zombie_perk_bottle( gun ) );
#/
/#
assert( gun != level.revive_tool );
#/
self enable_player_move_states();
weapon = flourish_weapon_name;
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || isDefined( self.intermission ) && self.intermission )
{
self takeweapon( weapon );
self.lastactiveweapon = "none";
return;
}
self takeweapon( weapon );
self giveweapon( weapon_name );
gun = change_melee_weapon( weapon_name, gun );
if ( self hasweapon( "knife_zm" ) )
{
self takeweapon( "knife_zm" );
}
if ( self is_multiple_drinking() )
{
self decrement_is_drinking();
return;
}
else if ( gun == "knife_zm" )
{
self switchtoweapon( weapon_name );
self decrement_is_drinking();
return;
}
else if ( gun != "none" && !is_placeable_mine( gun ) && !is_equipment( gun ) )
{
self switchtoweapon( gun );
}
else
{
primaryweapons = self getweaponslistprimaries();
if ( isDefined( primaryweapons ) && primaryweapons.size > 0 )
{
self switchtoweapon( primaryweapons[ 0 ] );
}
}
self waittill( "weapon_change_complete" );
if ( !self maps/mp/zombies/_zm_laststand::player_is_in_laststand() && isDefined( self.intermission ) && !self.intermission )
{
self decrement_is_drinking();
}
}

391
zm_prison_patch/maps/mp/zombies/_zm_perk_electric_cherry.gsc Normal file
View File

@ -0,0 +1,391 @@
#include maps/mp/zombies/_zm_ai_basic;
#include maps/mp/animscripts/shared;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_perks;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
enable_electric_cherry_perk_for_level()
{
maps/mp/zombies/_zm_perks::register_perk_basic_info( "specialty_grenadepulldeath", "electric_cherry", 2000, &"ZM_PRISON_PERK_CHERRY", "zombie_perk_bottle_cherry" );
maps/mp/zombies/_zm_perks::register_perk_precache_func( "specialty_grenadepulldeath", ::electic_cherry_precache );
maps/mp/zombies/_zm_perks::register_perk_clientfields( "specialty_grenadepulldeath", ::electric_cherry_register_clientfield, ::electric_cherry_set_clientfield );
maps/mp/zombies/_zm_perks::register_perk_threads( "specialty_grenadepulldeath", ::electric_cherry_reload_attack, ::electric_cherry_perk_lost );
maps/mp/zombies/_zm_perks::register_perk_machine( "specialty_grenadepulldeath", ::electric_cherry_perk_machine_setup, ::electric_cherry_perk_machine_think );
maps/mp/zombies/_zm_perks::register_perk_host_migration_func( "specialty_grenadepulldeath", ::electric_cherry_host_migration_func );
}
init_electric_cherry()
{
level.custom_laststand_func = ::electric_cherry_laststand;
set_zombie_var( "tesla_head_gib_chance", 50 );
registerclientfield( "allplayers", "electric_cherry_reload_fx", 9000, 2, "int" );
}
electic_cherry_precache()
{
precacheitem( "zombie_perk_bottle_cherry" );
precacheshader( "specialty_fastreload_zombies" );
precachemodel( "p6_zm_vending_electric_cherry_off" );
precachemodel( "p6_zm_vending_electric_cherry_on" );
precachestring( &"ZM_PRISON_PERK_CHERRY" );
level._effect[ "electriccherry" ] = loadfx( "misc/fx_zombie_cola_on" );
level._effect[ "electric_cherry_explode" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_down" );
level._effect[ "electric_cherry_reload_small" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_sm" );
level._effect[ "electric_cherry_reload_medium" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_player" );
level._effect[ "electric_cherry_reload_large" ] = loadfx( "maps/zombie_alcatraz/fx_alcatraz_electric_cherry_lg" );
level._effect[ "tesla_shock" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock" );
level._effect[ "tesla_shock_secondary" ] = loadfx( "maps/zombie/fx_zombie_tesla_shock_secondary" );
}
electric_cherry_register_clientfield()
{
registerclientfield( "toplayer", "perk_electric_cherry", 9000, 1, "int" );
}
electric_cherry_set_clientfield( state )
{
self setclientfieldtoplayer( "perk_electric_cherry", state );
}
electric_cherry_perk_machine_setup( use_trigger, perk_machine, bump_trigger, collision )
{
use_trigger.script_sound = "mus_perks_cherry_jingle";
use_trigger.script_string = "electric_cherry_perk";
use_trigger.script_label = "mus_perks_cherry_sting";
use_trigger.target = "vending_electriccherry";
perk_machine.script_string = "electriccherry_perk";
perk_machine.targetname = "vendingelectric_cherry";
if ( isDefined( bump_trigger ) )
{
bump_trigger.script_string = "electriccherry_perk";
}
}
electric_cherry_perk_machine_think()
{
init_electric_cherry();
while ( 1 )
{
machine = getentarray( "vendingelectric_cherry", "targetname" );
machine_triggers = getentarray( "vending_electriccherry", "target" );
i = 0;
while ( i < machine.size )
{
machine[ i ] setmodel( "p6_zm_vending_electric_cherry_off" );
i++;
}
level thread do_initial_power_off_callback( machine, "electriccherry" );
array_thread( machine_triggers, ::maps/mp/zombies/_zm_perks::set_power_on, 0 );
level waittill( "electric_cherry_on" );
i = 0;
while ( i < machine.size )
{
machine[ i ] setmodel( "p6_zm_vending_electric_cherry_on" );
machine[ i ] vibrate( vectorScale( ( 0, -1, 0 ), 100 ), 0,3, 0,4, 3 );
machine[ i ] playsound( "zmb_perks_power_on" );
machine[ i ] thread perk_fx( "electriccherry" );
machine[ i ] thread play_loop_on_machine();
i++;
}
level notify( "specialty_grenadepulldeath_power_on" );
array_thread( machine_triggers, ::maps/mp/zombies/_zm_perks::set_power_on, 1 );
level waittill( "electric_cherry_off" );
array_thread( machine, ::maps/mp/zombies/_zm_perks::turn_perk_off );
}
}
electric_cherry_host_migration_func()
{
a_electric_cherry_perk_machines = getentarray( "vending_electriccherry", "targetname" );
_a125 = a_electric_cherry_perk_machines;
_k125 = getFirstArrayKey( _a125 );
while ( isDefined( _k125 ) )
{
perk_machine = _a125[ _k125 ];
if ( isDefined( perk_machine.model ) && perk_machine.model == "p6_zm_vending_electric_cherry_on" )
{
perk_machine perk_fx( undefined, 1 );
perk_machine thread perk_fx( "electriccherry" );
}
_k125 = getNextArrayKey( _a125, _k125 );
}
}
electric_cherry_laststand()
{
visionsetlaststand( "zombie_last_stand", 1 );
if ( isDefined( self ) )
{
playfx( level._effect[ "electric_cherry_explode" ], self.origin );
self playsound( "zmb_cherry_explode" );
self notify( "electric_cherry_start" );
wait 0,05;
a_zombies = get_round_enemy_array();
a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, 500 );
i = 0;
while ( i < a_zombies.size )
{
if ( isalive( self ) )
{
if ( a_zombies[ i ].health <= 1000 )
{
a_zombies[ i ] thread electric_cherry_death_fx();
if ( isDefined( self.cherry_kills ) )
{
self.cherry_kills++;
}
self maps/mp/zombies/_zm_score::add_to_player_score( 40 );
}
else
{
a_zombies[ i ] thread electric_cherry_stun();
a_zombies[ i ] thread electric_cherry_shock_fx();
}
wait 0,1;
a_zombies[ i ] dodamage( 1000, self.origin, self, self, "none" );
}
i++;
}
self notify( "electric_cherry_end" );
}
}
electric_cherry_death_fx()
{
self endon( "death" );
tag = "J_SpineUpper";
fx = "tesla_shock";
if ( self.isdog )
{
tag = "J_Spine1";
}
self playsound( "zmb_elec_jib_zombie" );
network_safe_play_fx_on_tag( "tesla_death_fx", 2, level._effect[ fx ], self, tag );
if ( isDefined( self.tesla_head_gib_func ) && !self.head_gibbed )
{
[[ self.tesla_head_gib_func ]]();
}
}
electric_cherry_shock_fx()
{
self endon( "death" );
tag = "J_SpineUpper";
fx = "tesla_shock_secondary";
if ( self.isdog )
{
tag = "J_Spine1";
}
self playsound( "zmb_elec_jib_zombie" );
network_safe_play_fx_on_tag( "tesla_shock_fx", 2, level._effect[ fx ], self, tag );
}
electric_cherry_stun()
{
self endon( "death" );
self notify( "stun_zombie" );
self endon( "stun_zombie" );
if ( self.health <= 0 )
{
/#
iprintln( "trying to stun a dead zombie" );
#/
return;
}
if ( self.ai_state != "find_flesh" )
{
return;
}
self.forcemovementscriptstate = 1;
self.ignoreall = 1;
i = 0;
while ( i < 2 )
{
self animscripted( self.origin, self.angles, "zm_afterlife_stun" );
self maps/mp/animscripts/shared::donotetracks( "stunned" );
i++;
}
self.forcemovementscriptstate = 0;
self.ignoreall = 0;
self setgoalpos( self.origin );
self thread maps/mp/zombies/_zm_ai_basic::find_flesh();
}
electric_cherry_reload_attack()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "stop_electric_cherry_reload_attack" );
self.wait_on_reload = [];
self.consecutive_electric_cherry_attacks = 0;
while ( 1 )
{
self waittill( "reload_start" );
str_current_weapon = self getcurrentweapon();
while ( isinarray( self.wait_on_reload, str_current_weapon ) )
{
continue;
}
self.wait_on_reload[ self.wait_on_reload.size ] = str_current_weapon;
self.consecutive_electric_cherry_attacks++;
n_clip_current = self getweaponammoclip( str_current_weapon );
n_clip_max = weaponclipsize( str_current_weapon );
n_fraction = n_clip_current / n_clip_max;
perk_radius = linear_map( n_fraction, 1, 0, 32, 128 );
perk_dmg = linear_map( n_fraction, 1, 0, 1, 1045 );
self thread check_for_reload_complete( str_current_weapon );
if ( isDefined( self ) )
{
switch( self.consecutive_electric_cherry_attacks )
{
case 0:
case 1:
n_zombie_limit = undefined;
break;
case 2:
n_zombie_limit = 8;
break;
case 3:
n_zombie_limit = 4;
break;
case 4:
n_zombie_limit = 2;
break;
default:
n_zombie_limit = 0;
}
self thread electric_cherry_cooldown_timer( str_current_weapon );
if ( isDefined( n_zombie_limit ) && n_zombie_limit == 0 )
{
continue;
}
self thread electric_cherry_reload_fx( n_fraction );
self notify( "electric_cherry_start" );
self playsound( "zmb_cherry_explode" );
a_zombies = get_round_enemy_array();
a_zombies = get_array_of_closest( self.origin, a_zombies, undefined, undefined, perk_radius );
n_zombies_hit = 0;
i = 0;
while ( i < a_zombies.size )
{
if ( isalive( self ) )
{
if ( isDefined( n_zombie_limit ) )
{
if ( n_zombies_hit < n_zombie_limit )
{
n_zombies_hit++;
break;
}
else }
else if ( a_zombies[ i ].health <= perk_dmg )
{
a_zombies[ i ] thread electric_cherry_death_fx();
if ( isDefined( self.cherry_kills ) )
{
self.cherry_kills++;
}
self maps/mp/zombies/_zm_score::add_to_player_score( 40 );
}
else
{
if ( !isDefined( a_zombies[ i ].is_brutus ) )
{
a_zombies[ i ] thread electric_cherry_stun();
}
a_zombies[ i ] thread electric_cherry_shock_fx();
}
wait 0,1;
a_zombies[ i ] dodamage( perk_dmg, self.origin, self, self, "none" );
}
i++;
}
self notify( "electric_cherry_end" );
}
}
}
electric_cherry_cooldown_timer( str_current_weapon )
{
self notify( "electric_cherry_cooldown_started" );
self endon( "electric_cherry_cooldown_started" );
self endon( "death" );
self endon( "disconnect" );
n_reload_time = weaponreloadtime( str_current_weapon );
if ( self hasperk( "specialty_fastreload" ) )
{
n_reload_time *= getDvarFloat( "perk_weapReloadMultiplier" );
}
n_cooldown_time = n_reload_time + 3;
wait n_cooldown_time;
self.consecutive_electric_cherry_attacks = 0;
}
check_for_reload_complete( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "player_lost_weapon_" + weapon );
self thread weapon_replaced_monitor( weapon );
while ( 1 )
{
self waittill( "reload" );
str_current_weapon = self getcurrentweapon();
if ( str_current_weapon == weapon )
{
arrayremovevalue( self.wait_on_reload, weapon );
self notify( "weapon_reload_complete_" + weapon );
return;
}
else
{
}
}
}
weapon_replaced_monitor( weapon )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "weapon_reload_complete_" + weapon );
while ( 1 )
{
self waittill( "weapon_change" );
primaryweapons = self getweaponslistprimaries();
if ( !isinarray( primaryweapons, weapon ) )
{
self notify( "player_lost_weapon_" + weapon );
arrayremovevalue( self.wait_on_reload, weapon );
return;
}
else
{
}
}
}
electric_cherry_reload_fx( n_fraction )
{
if ( n_fraction >= 0,67 )
{
self setclientfield( "electric_cherry_reload_fx", 1 );
}
else if ( n_fraction >= 0,33 && n_fraction < 0,67 )
{
self setclientfield( "electric_cherry_reload_fx", 2 );
}
else
{
self setclientfield( "electric_cherry_reload_fx", 3 );
}
wait 1;
self setclientfield( "electric_cherry_reload_fx", 0 );
}
electric_cherry_perk_lost()
{
self notify( "stop_electric_cherry_reload_attack" );
}

670
zm_prison_patch/maps/mp/zombies/_zm_riotshield_prison.gsc Normal file
View File

@ -0,0 +1,670 @@
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_buildables;
#include maps/mp/zombies/_zm_weap_riotshield_prison;
#include common_scripts/utility;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
init()
{
level.riotshield_name = "alcatraz_shield_zm";
level.deployedshieldmodel = [];
level.stowedshieldmodel = [];
level.carriedshieldmodel = [];
level.deployedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc2_dmg0_world";
level.deployedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc2_dmg1_world";
level.deployedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc2_dmg2_world";
level.stowedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc2_dmg0_stow";
level.stowedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc2_dmg1_stow";
level.stowedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc2_dmg2_stow";
level.carriedshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc2_dmg0_world";
level.carriedshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc2_dmg1_world";
level.carriedshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc2_dmg2_world";
level.viewshieldmodel[ 0 ] = "t6_wpn_zmb_shield_dlc2_dmg0_view";
level.viewshieldmodel[ 2 ] = "t6_wpn_zmb_shield_dlc2_dmg1_view";
level.viewshieldmodel[ 3 ] = "t6_wpn_zmb_shield_dlc2_dmg2_view";
precachemodel( level.stowedshieldmodel[ 0 ] );
precachemodel( level.stowedshieldmodel[ 2 ] );
precachemodel( level.stowedshieldmodel[ 3 ] );
precachemodel( level.carriedshieldmodel[ 0 ] );
precachemodel( level.carriedshieldmodel[ 2 ] );
precachemodel( level.carriedshieldmodel[ 3 ] );
precachemodel( level.viewshieldmodel[ 0 ] );
precachemodel( level.viewshieldmodel[ 2 ] );
precachemodel( level.viewshieldmodel[ 3 ] );
level.riotshield_placement_zoffset = 26;
}
attachriotshield( model, tag )
{
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
self.prev_shield_model = model;
self.prev_shield_tag = tag;
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self attachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
}
removeriotshield()
{
if ( isDefined( self.prev_shield_model ) && isDefined( self.prev_shield_tag ) )
{
self detachshieldmodel( self.prev_shield_model, self.prev_shield_tag );
}
self.prev_shield_model = undefined;
self.prev_shield_tag = undefined;
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
self setheldweaponmodel( 0 );
}
setriotshieldviewmodel( modelnum )
{
self.prev_shield_viewmodel = modelnum;
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
if ( isDefined( self.prev_shield_viewmodel ) )
{
self setheldweaponmodel( self.prev_shield_viewmodel );
}
else
{
self setheldweaponmodel( 0 );
}
}
specialriotshieldviewmodel()
{
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
self setheldweaponmodel( 3 );
}
restoreriotshieldviewmodel()
{
if ( self getcurrentweapon() != level.riotshield_name )
{
return;
}
if ( isDefined( self.prev_shield_viewmodel ) )
{
self setheldweaponmodel( self.prev_shield_viewmodel );
}
else
{
self setheldweaponmodel( 0 );
}
}
updateriotshieldmodel()
{
if ( !isDefined( self.shield_damage_level ) )
{
if ( isDefined( self.player_shield_reset_health ) )
{
self [[ self.player_shield_reset_health ]]();
}
}
update = 0;
if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
{
self.prev_shield_damage_level = self.shield_damage_level;
update = 1;
}
if ( !isDefined( self.prev_shield_placement ) || self.prev_shield_placement != self.shield_placement )
{
self.prev_shield_placement = self.shield_placement;
update = 1;
}
if ( update )
{
if ( self.prev_shield_placement == 0 )
{
self attachriotshield();
return;
}
else if ( self.prev_shield_placement == 1 )
{
self attachriotshield( level.carriedshieldmodel[ self.prev_shield_damage_level ], "tag_weapon_left" );
self setriotshieldviewmodel( self.prev_shield_damage_level );
return;
}
else if ( self.prev_shield_placement == 2 )
{
self attachriotshield( level.stowedshieldmodel[ self.prev_shield_damage_level ], "tag_stowed_back" );
return;
}
else
{
if ( self.prev_shield_placement == 3 )
{
self attachriotshield();
if ( isDefined( self.shield_ent ) )
{
self.shield_ent setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
}
}
}
}
}
updatestandaloneriotshieldmodel()
{
update = 0;
if ( !isDefined( self.prev_shield_damage_level ) || self.prev_shield_damage_level != self.shield_damage_level )
{
self.prev_shield_damage_level = self.shield_damage_level;
update = 1;
}
if ( update )
{
self setmodel( level.deployedshieldmodel[ self.prev_shield_damage_level ] );
}
}
watchshieldlaststand()
{
self endon( "death" );
self endon( "disconnect" );
self notify( "watchShieldLastStand" );
self endon( "watchShieldLastStand" );
while ( 1 )
{
self waittill( "weapons_taken_for_last_stand" );
self.riotshield_hidden = 0;
if ( isDefined( self.hasriotshield ) && self.hasriotshield )
{
if ( self.prev_shield_placement == 1 || self.prev_shield_placement == 2 )
{
self.riotshield_hidden = 2;
self.shield_placement = 0;
self updateriotshieldmodel();
}
}
str_notify = self waittill_any_return( "player_revived", "bled_out" );
if ( str_notify == "player_revived" )
{
if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden > 0 )
{
self.shield_placement = self.riotshield_hidden;
self updateriotshieldmodel();
}
}
else
{
self maps/mp/zombies/_zm_weap_riotshield_prison::player_take_riotshield();
}
self.riotshield_hidden = undefined;
}
}
trackriotshield()
{
self endon( "death" );
self endon( "disconnect" );
self.hasriotshield = self hasweapon( level.riotshield_name );
self.hasriotshieldequipped = self getcurrentweapon() == level.riotshield_name;
self.shield_placement = 0;
if ( self.hasriotshield )
{
if ( self.hasriotshieldequipped )
{
self.shield_placement = 1;
self updateriotshieldmodel();
}
else
{
self.shield_placement = 2;
self updateriotshieldmodel();
}
}
for ( ;; )
{
self waittill( "weapon_change", newweapon );
if ( newweapon == level.riotshield_name )
{
if ( self.hasriotshieldequipped )
{
continue;
}
else if ( isDefined( self.riotshieldentity ) )
{
self notify( "destroy_riotshield" );
}
self.shield_placement = 1;
self updateriotshieldmodel();
if ( self.hasriotshield )
{
break;
}
self.hasriotshield = 1;
self.hasriotshieldequipped = 1;
continue;
}
else if ( self ismantling() && newweapon == "none" )
{
continue;
}
else
{
if ( self.hasriotshieldequipped )
{
/#
assert( self.hasriotshield );
#/
self.hasriotshield = self hasweapon( level.riotshield_name );
if ( isDefined( self.riotshield_hidden ) && self.riotshield_hidden )
{
}
else
{
if ( self.hasriotshield )
{
self.shield_placement = 2;
break;
}
else if ( isDefined( self.shield_ent ) )
{
/#
assert( self.shield_placement == 3 );
#/
break;
}
else
{
self.shield_placement = 0;
}
}
self updateriotshieldmodel();
self.hasriotshieldequipped = 0;
break;
}
else if ( self.hasriotshield )
{
if ( !self hasweapon( level.riotshield_name ) )
{
self.shield_placement = 0;
self updateriotshieldmodel();
self.hasriotshield = 0;
}
break;
}
else
{
if ( self hasweapon( level.riotshield_name ) )
{
self.shield_placement = 2;
self updateriotshieldmodel();
self.hasriotshield = 1;
}
}
}
}
}
trackequipmentchange()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "equipment_dropped", equipname );
self notify( "weapon_change" );
}
}
updateriotshieldplacement()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "deploy_riotshield" );
self endon( "start_riotshield_deploy" );
self endon( "weapon_change" );
while ( 1 )
{
placement = self canplaceriotshield( "raise_riotshield" );
if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) )
{
self restoreriotshieldviewmodel();
self setplacementhint( 1 );
}
else
{
self specialriotshieldviewmodel();
self setplacementhint( 0 );
}
wait 0,05;
}
}
startriotshielddeploy()
{
self notify( "start_riotshield_deploy" );
self thread updateriotshieldplacement();
self thread watchriotshielddeploy();
}
spawnriotshieldcover( origin, angles )
{
shield_ent = spawn( "script_model", origin, 1 );
shield_ent.angles = angles;
shield_ent setowner( self );
shield_ent.owner = self;
shield_ent.owner.shield_ent = shield_ent;
shield_ent.isriotshield = 1;
self.shield_placement = 3;
self updateriotshieldmodel();
shield_ent setscriptmoverflag( 0 );
self thread maps/mp/zombies/_zm_buildables::delete_on_disconnect( shield_ent, "destroy_riotshield", 1 );
maps/mp/zombies/_zm_equipment::destructible_equipment_list_add( shield_ent );
return shield_ent;
}
watchriotshielddeploy()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self waittill( "deploy_riotshield", deploy_attempt );
self restoreriotshieldviewmodel();
self setplacementhint( 1 );
placement_hint = 0;
if ( deploy_attempt )
{
placement = self canplaceriotshield( "deploy_riotshield" );
if ( placement[ "result" ] && riotshielddistancetest( placement[ "origin" ] ) && self check_plant_position( placement[ "origin" ], placement[ "angles" ] ) )
{
self doriotshielddeploy( placement[ "origin" ], placement[ "angles" ] );
}
else
{
placement_hint = 1;
clip_max_ammo = weaponclipsize( level.riotshield_name );
self setweaponammoclip( level.riotshield_name, clip_max_ammo );
}
}
else
{
placement_hint = 1;
}
if ( placement_hint )
{
self setriotshieldfailhint();
}
}
check_plant_position( origin, angles )
{
if ( isDefined( level.equipment_safe_to_drop ) )
{
ret = 1;
test_ent = spawn( "script_model", origin );
test_ent setmodel( level.deployedshieldmodel[ 0 ] );
test_ent.angles = angles;
if ( !( self [[ level.equipment_safe_to_drop ]]( test_ent ) ) )
{
ret = 0;
}
test_ent delete();
return ret;
}
return 1;
}
doriotshielddeploy( origin, angles )
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self notify( "deployed_riotshield" );
self maps/mp/zombies/_zm_buildables::track_placed_buildables( level.riotshield_name );
if ( isDefined( self.current_equipment ) && self.current_equipment == level.riotshield_name )
{
self maps/mp/zombies/_zm_equipment::equipment_to_deployed( level.riotshield_name );
}
zoffset = level.riotshield_placement_zoffset;
shield_ent = self spawnriotshieldcover( origin + ( 0, 0, zoffset ), angles );
item_ent = deployriotshield( self, shield_ent );
primaries = self getweaponslistprimaries();
/#
assert( isDefined( item_ent ) );
assert( !isDefined( self.riotshieldretrievetrigger ) );
assert( !isDefined( self.riotshieldentity ) );
#/
self maps/mp/zombies/_zm_weapons::switch_back_primary_weapon( primaries[ 0 ] );
if ( isDefined( level.equipment_planted ) )
{
self [[ level.equipment_planted ]]( shield_ent, level.riotshield_name, self );
}
if ( isDefined( level.equipment_safe_to_drop ) )
{
if ( !( self [[ level.equipment_safe_to_drop ]]( shield_ent ) ) )
{
self notify( "destroy_riotshield" );
shield_ent delete();
item_ent delete();
return;
}
}
self.riotshieldretrievetrigger = item_ent;
self.riotshieldentity = shield_ent;
self thread watchdeployedriotshieldents();
self thread deleteshieldondamage( self.riotshieldentity );
self thread deleteshieldmodelonweaponpickup( self.riotshieldretrievetrigger );
self thread deleteriotshieldonplayerdeath();
self thread watchshieldtriggervisibility( self.riotshieldretrievetrigger );
self.riotshieldentity thread watchdeployedriotshielddamage();
return shield_ent;
}
riotshielddistancetest( origin )
{
/#
assert( isDefined( origin ) );
#/
min_dist_squared = getDvarFloat( "riotshield_deploy_limit_radius" );
min_dist_squared *= min_dist_squared;
i = 0;
while ( i < level.players.size )
{
if ( isDefined( level.players[ i ].riotshieldentity ) )
{
dist_squared = distancesquared( level.players[ i ].riotshieldentity.origin, origin );
if ( min_dist_squared > dist_squared )
{
/#
println( "Shield placement denied! Failed distance check to other riotshields." );
#/
return 0;
}
}
i++;
}
return 1;
}
watchdeployedriotshieldents()
{
/#
assert( isDefined( self.riotshieldretrievetrigger ) );
assert( isDefined( self.riotshieldentity ) );
#/
riotshieldretrievetrigger = self.riotshieldretrievetrigger;
riotshieldentity = self.riotshieldentity;
self waittill_any( "destroy_riotshield", "disconnect", "alcatraz_shield_zm_taken" );
if ( isDefined( self ) )
{
self.shield_placement = 0;
self updateriotshieldmodel();
}
if ( isDefined( riotshieldretrievetrigger ) )
{
riotshieldretrievetrigger delete();
}
if ( isDefined( riotshieldentity ) )
{
riotshieldentity delete();
}
}
watchdeployedriotshielddamage()
{
self endon( "death" );
damagemax = getDvarInt( "riotshield_deployed_health" );
self.damagetaken = 0;
while ( 1 )
{
self.maxhealth = 100000;
self.health = self.maxhealth;
self waittill( "damage", damage, attacker, direction, point, type, tagname, modelname, partname, weaponname, idflags );
if ( isDefined( level.players_can_damage_riotshields ) && !level.players_can_damage_riotshields )
{
continue;
}
if ( !isDefined( attacker ) || !isplayer( attacker ) )
{
continue;
}
/#
if ( isDefined( self.owner ) )
{
assert( isDefined( self.owner.team ) );
}
#/
while ( is_encounter() && attacker.team == self.owner.team && attacker != self.owner )
{
continue;
}
if ( isDefined( level.riotshield_damage_callback ) )
{
self.owner [[ level.riotshield_damage_callback ]]( damage, 0 );
continue;
}
else
{
if ( type == "MOD_MELEE" )
{
damage *= getDvarFloat( "riotshield_melee_damage_scale" );
}
else if ( type == "MOD_PISTOL_BULLET" || type == "MOD_RIFLE_BULLET" )
{
damage *= getDvarFloat( "riotshield_bullet_damage_scale" );
}
else
{
if ( type != "MOD_GRENADE" && type != "MOD_GRENADE_SPLASH" && type != "MOD_EXPLOSIVE" && type != "MOD_EXPLOSIVE_SPLASH" || type == "MOD_PROJECTILE" && type == "MOD_PROJECTILE_SPLASH" )
{
damage *= getDvarFloat( "riotshield_explosive_damage_scale" );
break;
}
else
{
if ( type == "MOD_IMPACT" )
{
damage *= getDvarFloat( "riotshield_projectile_damage_scale" );
}
}
}
self.damagetaken += damage;
if ( self.damagetaken >= damagemax )
{
self damagethendestroyriotshield();
}
}
}
}
damagethendestroyriotshield()
{
self endon( "death" );
self.owner.riotshieldretrievetrigger delete();
self notsolid();
self setclientflag( 14 );
wait getDvarFloat( "riotshield_destroyed_cleanup_time" );
self.owner notify( "destroy_riotshield" );
}
deleteshieldondamage( shield_ent )
{
shield_ent waittill( "death" );
self notify( "destroy_riotshield" );
}
deleteshieldmodelonweaponpickup( shield_trigger )
{
shield_trigger waittill( "trigger", player );
self maps/mp/zombies/_zm_equipment::equipment_from_deployed( level.riotshield_name );
self notify( "destroy_riotshield" );
if ( self != player )
{
if ( isDefined( level.transferriotshield ) )
{
[[ level.transferriotshield ]]( self, player );
}
}
}
watchshieldtriggervisibility( trigger )
{
self endon( "death" );
trigger endon( "death" );
while ( isDefined( trigger ) )
{
players = get_players();
_a759 = players;
_k759 = getFirstArrayKey( _a759 );
while ( isDefined( _k759 ) )
{
player = _a759[ _k759 ];
pickup = 1;
if ( !isDefined( player ) )
{
}
else if ( is_true( player.afterlife ) )
{
trigger setinvisibletoplayer( player );
wait 0,05;
}
else
{
if ( isDefined( level.cantransferriotshield ) )
{
pickup = [[ level.cantransferriotshield ]]( self, player );
}
if ( !isDefined( trigger ) )
{
return;
}
if ( pickup )
{
trigger setvisibletoplayer( player );
}
else
{
trigger setinvisibletoplayer( player );
}
wait 0,05;
}
_k759 = getNextArrayKey( _a759, _k759 );
}
wait 0,05;
}
}
deleteriotshieldonplayerdeath()
{
self.riotshieldentity endon( "death" );
self waittill( "death" );
self notify( "destroy_riotshield" );
}

278
zm_prison_patch/maps/mp/zombies/_zm_weap_ballistic_knife.gsc Normal file
View File

@ -0,0 +1,278 @@
#include maps/mp/zombies/_zm_stats;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
if ( isDefined( level._uses_retrievable_ballisitic_knives ) && level._uses_retrievable_ballisitic_knives == 1 )
{
precachemodel( "t5_weapon_ballistic_knife_projectile" );
precachemodel( "t5_weapon_ballistic_knife_blade_retrieve" );
}
}
on_spawn( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
player endon( "zmb_lost_knife" );
level endon( "game_ended" );
self waittill( "stationary", endpos, normal, angles, attacker, prey, bone );
isfriendly = 0;
if ( isDefined( endpos ) )
{
retrievable_model = spawn( "script_model", endpos );
retrievable_model setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
retrievable_model setowner( player );
retrievable_model.owner = player;
retrievable_model.angles = angles;
retrievable_model.name = watcher.weapon;
if ( isDefined( prey ) )
{
if ( isplayer( prey ) && player.team == prey.team )
{
isfriendly = 1;
}
else
{
if ( isai( prey ) && player.team == prey.team )
{
isfriendly = 1;
}
}
if ( !isfriendly )
{
retrievable_model linkto( prey, bone );
retrievable_model thread force_drop_knives_to_ground_on_death( player, prey );
}
else
{
if ( isfriendly )
{
retrievable_model physicslaunch( normal, ( randomint( 10 ), randomint( 10 ), randomint( 10 ) ) );
normal = ( 0, 0, 1 );
}
}
}
watcher.objectarray[ watcher.objectarray.size ] = retrievable_model;
if ( isfriendly )
{
retrievable_model waittill( "stationary" );
}
retrievable_model thread drop_knives_to_ground( player );
if ( isfriendly )
{
player notify( "ballistic_knife_stationary" );
}
else
{
player notify( "ballistic_knife_stationary" );
}
retrievable_model thread wait_to_show_glowing_model( prey );
}
}
wait_to_show_glowing_model( prey )
{
level endon( "game_ended" );
self endon( "death" );
wait 2;
self setmodel( "t5_weapon_ballistic_knife_blade_retrieve" );
}
on_spawn_retrieve_trigger( watcher, player )
{
player endon( "death" );
player endon( "disconnect" );
player endon( "zmb_lost_knife" );
level endon( "game_ended" );
player waittill( "ballistic_knife_stationary", retrievable_model, normal, prey );
if ( !isDefined( retrievable_model ) )
{
return;
}
trigger_pos = [];
if ( isDefined( prey ) || isplayer( prey ) && isai( prey ) )
{
trigger_pos[ 0 ] = prey.origin[ 0 ];
trigger_pos[ 1 ] = prey.origin[ 1 ];
trigger_pos[ 2 ] = prey.origin[ 2 ] + 10;
}
else
{
trigger_pos[ 0 ] = retrievable_model.origin[ 0 ] + ( 10 * normal[ 0 ] );
trigger_pos[ 1 ] = retrievable_model.origin[ 1 ] + ( 10 * normal[ 1 ] );
trigger_pos[ 2 ] = retrievable_model.origin[ 2 ] + ( 10 * normal[ 2 ] );
}
pickup_trigger = spawn( "trigger_radius_use", ( trigger_pos[ 0 ], trigger_pos[ 1 ], trigger_pos[ 2 ] ) );
pickup_trigger setcursorhint( "HINT_NOICON" );
pickup_trigger.owner = player;
retrievable_model.retrievabletrigger = pickup_trigger;
hint_string = &"WEAPON_BALLISTIC_KNIFE_PICKUP";
if ( isDefined( hint_string ) )
{
pickup_trigger sethintstring( hint_string );
}
else
{
pickup_trigger sethintstring( &"GENERIC_PICKUP" );
}
pickup_trigger setteamfortrigger( player.team );
player clientclaimtrigger( pickup_trigger );
pickup_trigger enablelinkto();
if ( isDefined( prey ) )
{
pickup_trigger linkto( prey );
}
else
{
pickup_trigger linkto( retrievable_model );
}
if ( isDefined( level.knife_planted ) )
{
[[ level.knife_planted ]]( retrievable_model, pickup_trigger, prey );
}
retrievable_model thread watch_use_trigger( pickup_trigger, retrievable_model, ::pick_up, watcher.weapon, watcher.pickupsoundplayer, watcher.pickupsound );
player thread watch_shutdown( pickup_trigger, retrievable_model );
}
debug_print( endpos )
{
/#
self endon( "death" );
while ( 1 )
{
print3d( endpos, "pickup_trigger" );
wait 0,05;
#/
}
}
watch_use_trigger( trigger, model, callback, weapon, playersoundonuse, npcsoundonuse )
{
self endon( "death" );
self endon( "delete" );
level endon( "game_ended" );
while ( 1 )
{
trigger waittill( "trigger", player );
while ( !isalive( player ) )
{
continue;
}
while ( !player isonground() )
{
continue;
}
if ( isDefined( trigger.triggerteam ) && player.team != trigger.triggerteam )
{
continue;
}
if ( isDefined( trigger.claimedby ) && player != trigger.claimedby )
{
continue;
}
if ( player usebuttonpressed() && !player.throwinggrenade && !player meleebuttonpressed() )
{
if ( isDefined( playersoundonuse ) )
{
player playlocalsound( playersoundonuse );
}
if ( isDefined( npcsoundonuse ) )
{
player playsound( npcsoundonuse );
}
player thread [[ callback ]]( weapon, model, trigger );
return;
}
else
{
}
}
}
pick_up( weapon, model, trigger )
{
current_weapon = self getcurrentweapon();
if ( current_weapon != weapon )
{
clip_ammo = self getweaponammoclip( weapon );
if ( !clip_ammo )
{
self setweaponammoclip( weapon, 1 );
}
else
{
new_ammo_stock = self getweaponammostock( weapon ) + 1;
self setweaponammostock( weapon, new_ammo_stock );
}
}
else
{
new_ammo_stock = self getweaponammostock( weapon ) + 1;
self setweaponammostock( weapon, new_ammo_stock );
}
self maps/mp/zombies/_zm_stats::increment_client_stat( "ballistic_knives_pickedup" );
self maps/mp/zombies/_zm_stats::increment_player_stat( "ballistic_knives_pickedup" );
model destroy_ent();
trigger destroy_ent();
}
destroy_ent()
{
if ( isDefined( self ) )
{
if ( isDefined( self.glowing_model ) )
{
self.glowing_model delete();
}
self delete();
}
}
watch_shutdown( trigger, model )
{
self waittill_any( "death", "disconnect", "zmb_lost_knife" );
trigger destroy_ent();
model destroy_ent();
}
drop_knives_to_ground( player )
{
player endon( "death" );
player endon( "zmb_lost_knife" );
for ( ;; )
{
level waittill( "drop_objects_to_ground", origin, radius );
if ( distancesquared( origin, self.origin ) < ( radius * radius ) )
{
self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
self thread update_retrieve_trigger( player );
}
}
}
force_drop_knives_to_ground_on_death( player, prey )
{
self endon( "death" );
player endon( "zmb_lost_knife" );
prey waittill( "death" );
self unlink();
self physicslaunch( ( 0, 0, 1 ), vectorScale( ( 0, 0, 1 ), 5 ) );
self thread update_retrieve_trigger( player );
}
update_retrieve_trigger( player )
{
self endon( "death" );
player endon( "zmb_lost_knife" );
if ( isDefined( level.custom_update_retrieve_trigger ) )
{
self [[ level.custom_update_retrieve_trigger ]]( player );
return;
}
self waittill( "stationary" );
trigger = self.retrievabletrigger;
trigger.origin = ( self.origin[ 0 ], self.origin[ 1 ], self.origin[ 2 ] + 10 );
trigger linkto( self );
}

492
zm_prison_patch/maps/mp/zombies/_zm_weap_claymore.gsc Normal file
View File

@ -0,0 +1,492 @@
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_audio;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
if ( !isDefined( level.claymores_max_per_player ) )
{
level.claymores_max_per_player = 12;
}
trigs = getentarray( "claymore_purchase", "targetname" );
i = 0;
while ( i < trigs.size )
{
model = getent( trigs[ i ].target, "targetname" );
if ( isDefined( model ) )
{
model hide();
}
i++;
}
array_thread( trigs, ::buy_claymores );
level thread give_claymores_after_rounds();
level.claymores_on_damage = ::satchel_damage;
level.pickup_claymores = ::pickup_claymores;
level.pickup_claymores_trigger_listener = ::pickup_claymores_trigger_listener;
level.claymore_detectiondot = cos( 70 );
level.claymore_detectionmindist = 20;
level._effect[ "claymore_laser" ] = loadfx( "weapon/claymore/fx_claymore_laser" );
}
buy_claymores()
{
self.zombie_cost = 1000;
self sethintstring( &"ZOMBIE_CLAYMORE_PURCHASE" );
self setcursorhint( "HINT_NOICON" );
self endon( "kill_trigger" );
if ( !isDefined( self.stub ) )
{
return;
}
if ( isDefined( self.stub ) && !isDefined( self.stub.claymores_triggered ) )
{
self.stub.claymores_triggered = 0;
}
self.claymores_triggered = self.stub.claymores_triggered;
while ( 1 )
{
self waittill( "trigger", who );
while ( who in_revive_trigger() )
{
continue;
}
while ( who has_powerup_weapon() )
{
wait 0,1;
}
if ( is_player_valid( who ) )
{
if ( who.score >= self.zombie_cost )
{
if ( !who is_player_placeable_mine( "claymore_zm" ) )
{
play_sound_at_pos( "purchase", self.origin );
who maps/mp/zombies/_zm_score::minus_to_player_score( self.zombie_cost );
who thread claymore_setup();
who thread show_claymore_hint( "claymore_purchased" );
who thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "weapon_pickup", "grenade" );
if ( isDefined( self.stub ) )
{
self.claymores_triggered = self.stub.claymores_triggered;
}
if ( self.claymores_triggered == 0 )
{
model = getent( self.target, "targetname" );
if ( isDefined( model ) )
{
model thread maps/mp/zombies/_zm_weapons::weapon_show( who );
}
else
{
if ( isDefined( self.clientfieldname ) )
{
level setclientfield( self.clientfieldname, 1 );
}
}
self.claymores_triggered = 1;
if ( isDefined( self.stub ) )
{
self.stub.claymores_triggered = 1;
}
}
trigs = getentarray( "claymore_purchase", "targetname" );
i = 0;
while ( i < trigs.size )
{
trigs[ i ] setinvisibletoplayer( who );
i++;
}
}
else who thread show_claymore_hint( "already_purchased" );
}
}
}
}
claymore_unitrigger_update_prompt( player )
{
if ( player is_player_placeable_mine( "claymore_zm" ) )
{
return 0;
}
return 1;
}
set_claymore_visible()
{
players = get_players();
trigs = getentarray( "claymore_purchase", "targetname" );
while ( 1 )
{
j = 0;
while ( j < players.size )
{
while ( !players[ j ] is_player_placeable_mine( "claymore_zm" ) )
{
i = 0;
while ( i < trigs.size )
{
trigs[ i ] setinvisibletoplayer( players[ j ], 0 );
i++;
}
}
j++;
}
wait 1;
players = get_players();
}
}
claymore_safe_to_plant()
{
if ( self.owner.claymores.size >= level.claymores_max_per_player )
{
return 0;
}
if ( isDefined( level.claymore_safe_to_plant ) )
{
return self [[ level.claymore_safe_to_plant ]]();
}
return 1;
}
claymore_wait_and_detonate()
{
wait 0,1;
self detonate( self.owner );
}
claymore_watch()
{
self endon( "death" );
while ( 1 )
{
self waittill( "grenade_fire", claymore, weapname );
if ( weapname == "claymore_zm" )
{
claymore.owner = self;
claymore.team = self.team;
self notify( "zmb_enable_claymore_prompt" );
if ( claymore claymore_safe_to_plant() )
{
if ( isDefined( level.claymore_planted ) )
{
self thread [[ level.claymore_planted ]]( claymore );
}
claymore thread satchel_damage();
claymore thread claymore_detonation();
claymore thread play_claymore_effects();
self maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_planted" );
self maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_planted" );
break;
}
else
{
claymore thread claymore_wait_and_detonate();
}
}
}
}
claymore_setup()
{
if ( !isDefined( self.claymores ) )
{
self.claymores = [];
}
self thread claymore_watch();
self giveweapon( "claymore_zm" );
self set_player_placeable_mine( "claymore_zm" );
self setactionslot( 4, "weapon", "claymore_zm" );
self setweaponammostock( "claymore_zm", 2 );
}
adjust_trigger_origin( origin )
{
origin += vectorScale( ( 0, 0, 1 ), 20 );
return origin;
}
on_spawn_retrieve_trigger( watcher, player )
{
self maps/mp/gametypes_zm/_weaponobjects::onspawnretrievableweaponobject( watcher, player );
if ( isDefined( self.pickuptrigger ) )
{
self.pickuptrigger sethintlowpriority( 0 );
}
}
pickup_claymores()
{
player = self.owner;
if ( !player hasweapon( "claymore_zm" ) )
{
player thread claymore_watch();
player giveweapon( "claymore_zm" );
player set_player_placeable_mine( "claymore_zm" );
player setactionslot( 4, "weapon", "claymore_zm" );
player setweaponammoclip( "claymore_zm", 0 );
player notify( "zmb_enable_claymore_prompt" );
}
else
{
clip_ammo = player getweaponammoclip( self.name );
clip_max_ammo = weaponclipsize( self.name );
if ( clip_ammo >= clip_max_ammo )
{
self destroy_ent();
player notify( "zmb_disable_claymore_prompt" );
return;
}
}
self pick_up();
clip_ammo = player getweaponammoclip( self.name );
clip_max_ammo = weaponclipsize( self.name );
if ( clip_ammo >= clip_max_ammo )
{
player notify( "zmb_disable_claymore_prompt" );
}
player maps/mp/zombies/_zm_stats::increment_client_stat( "claymores_pickedup" );
player maps/mp/zombies/_zm_stats::increment_player_stat( "claymores_pickedup" );
}
pickup_claymores_trigger_listener( trigger, player )
{
self thread pickup_claymores_trigger_listener_enable( trigger, player );
self thread pickup_claymores_trigger_listener_disable( trigger, player );
}
pickup_claymores_trigger_listener_enable( trigger, player )
{
self endon( "delete" );
while ( 1 )
{
player waittill_any( "zmb_enable_claymore_prompt", "spawned_player" );
if ( !isDefined( trigger ) )
{
return;
}
trigger trigger_on();
trigger linkto( self );
}
}
pickup_claymores_trigger_listener_disable( trigger, player )
{
self endon( "delete" );
while ( 1 )
{
player waittill( "zmb_disable_claymore_prompt" );
if ( !isDefined( trigger ) )
{
return;
}
trigger unlink();
trigger trigger_off();
}
}
shouldaffectweaponobject( object )
{
pos = self.origin + vectorScale( ( 0, 0, 1 ), 32 );
dirtopos = pos - object.origin;
objectforward = anglesToForward( object.angles );
dist = vectordot( dirtopos, objectforward );
if ( dist < level.claymore_detectionmindist )
{
return 0;
}
dirtopos = vectornormalize( dirtopos );
dot = vectordot( dirtopos, objectforward );
return dot > level.claymore_detectiondot;
}
claymore_detonation()
{
self endon( "death" );
self waittill_not_moving();
detonateradius = 96;
damagearea = spawn( "trigger_radius", self.origin + ( 0, 0, 0 - detonateradius ), 4, detonateradius, detonateradius * 2 );
damagearea setexcludeteamfortrigger( self.team );
damagearea enablelinkto();
damagearea linkto( self );
if ( is_true( self.isonbus ) )
{
damagearea setmovingplatformenabled( 1 );
}
self.damagearea = damagearea;
self thread delete_claymores_on_death( self.owner, damagearea );
self.owner.claymores[ self.owner.claymores.size ] = self;
while ( 1 )
{
damagearea waittill( "trigger", ent );
if ( isDefined( self.owner ) && ent == self.owner )
{
continue;
}
while ( isDefined( ent.pers ) && isDefined( ent.pers[ "team" ] ) && ent.pers[ "team" ] == self.team )
{
continue;
}
if ( isDefined( ent.ignore_claymore ) && ent.ignore_claymore )
{
continue;
}
while ( !ent shouldaffectweaponobject( self ) )
{
continue;
}
if ( ent damageconetrace( self.origin, self ) > 0 )
{
self playsound( "wpn_claymore_alert" );
wait 0,4;
if ( isDefined( self.owner ) )
{
self detonate( self.owner );
}
else
{
self detonate( undefined );
}
return;
}
}
}
delete_claymores_on_death( player, ent )
{
self waittill( "death" );
if ( isDefined( player ) )
{
arrayremovevalue( player.claymores, self );
}
wait 0,05;
if ( isDefined( ent ) )
{
ent delete();
}
}
satchel_damage()
{
self setcandamage( 1 );
self.health = 100000;
self.maxhealth = self.health;
attacker = undefined;
while ( 1 )
{
self waittill( "damage", amount, attacker );
if ( !isDefined( self ) )
{
return;
}
self.health = self.maxhealth;
while ( !isplayer( attacker ) )
{
continue;
}
if ( isDefined( self.owner ) && attacker == self.owner )
{
continue;
}
while ( isDefined( attacker.pers ) && isDefined( attacker.pers[ "team" ] ) && attacker.pers[ "team" ] != level.zombie_team )
{
continue;
}
}
if ( level.satchelexplodethisframe )
{
wait ( 0,1 + randomfloat( 0,4 ) );
}
else wait 0,05;
if ( !isDefined( self ) )
{
return;
}
level.satchelexplodethisframe = 1;
thread reset_satchel_explode_this_frame();
self detonate( attacker );
}
reset_satchel_explode_this_frame()
{
wait 0,05;
level.satchelexplodethisframe = 0;
}
play_claymore_effects()
{
self endon( "death" );
self waittill_not_moving();
playfxontag( level._effect[ "claymore_laser" ], self, "tag_fx" );
}
give_claymores_after_rounds()
{
while ( 1 )
{
level waittill( "between_round_over" );
while ( !level flag_exists( "teleporter_used" ) || !flag( "teleporter_used" ) )
{
players = get_players();
i = 0;
while ( i < players.size )
{
if ( players[ i ] is_player_placeable_mine( "claymore_zm" ) )
{
players[ i ] giveweapon( "claymore_zm" );
players[ i ] set_player_placeable_mine( "claymore_zm" );
players[ i ] setactionslot( 4, "weapon", "claymore_zm" );
players[ i ] setweaponammoclip( "claymore_zm", 2 );
}
i++;
}
}
}
}
init_hint_hudelem( x, y, alignx, aligny, fontscale, alpha )
{
self.x = x;
self.y = y;
self.alignx = alignx;
self.aligny = aligny;
self.fontscale = fontscale;
self.alpha = alpha;
self.sort = 20;
}
setup_client_hintelem()
{
self endon( "death" );
self endon( "disconnect" );
if ( !isDefined( self.hintelem ) )
{
self.hintelem = newclienthudelem( self );
}
self.hintelem init_hint_hudelem( 320, 220, "center", "bottom", 1,6, 1 );
}
show_claymore_hint( string )
{
self endon( "death" );
self endon( "disconnect" );
if ( string == "claymore_purchased" )
{
text = &"ZOMBIE_CLAYMORE_HOWTO";
}
else
{
text = &"ZOMBIE_CLAYMORE_ALREADY_PURCHASED";
}
self setup_client_hintelem();
self.hintelem settext( text );
wait 3,5;
self.hintelem settext( "" );
}

778
zm_prison_patch/maps/mp/zombies/_zm_weap_riotshield_prison.gsc Normal file
View File

@ -0,0 +1,778 @@
#include maps/mp/zombies/_zm_audio;
#include maps/mp/animscripts/zm_death;
#include maps/mp/zombies/_zm_unitrigger;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_laststand;
#include maps/mp/zombies/_zm_stats;
#include maps/mp/gametypes_zm/_weaponobjects;
#include maps/mp/zombies/_zm_equipment;
#include maps/mp/zombies/_zm_spawner;
#include maps/mp/zombies/_zm_utility;
#include common_scripts/utility;
#include maps/mp/_utility;
init()
{
maps/mp/zombies/_zm_riotshield_prison::init();
set_zombie_var( "riotshield_cylinder_radius", 360 );
set_zombie_var( "riotshield_fling_range", 90 );
set_zombie_var( "riotshield_gib_range", 90 );
set_zombie_var( "riotshield_gib_damage", 75 );
set_zombie_var( "riotshield_knockdown_range", 90 );
set_zombie_var( "riotshield_knockdown_damage", 15 );
set_zombie_var( "riotshield_hit_points", 1500 );
set_zombie_var( "riotshield_fling_damage_shield", 100 );
set_zombie_var( "riotshield_knockdown_damage_shield", 15 );
level.riotshield_network_choke_count = 0;
level.riotshield_gib_refs = [];
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "guts";
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "right_arm";
level.riotshield_gib_refs[ level.riotshield_gib_refs.size ] = "left_arm";
level.riotshield_damage_callback = ::player_damage_shield;
level.deployed_riotshield_damage_callback = ::deployed_damage_shield;
level.transferriotshield = ::transferriotshield;
level.cantransferriotshield = ::cantransferriotshield;
maps/mp/zombies/_zm_spawner::register_zombie_damage_callback( ::riotshield_zombie_damage_response );
maps/mp/zombies/_zm_equipment::register_equipment( "alcatraz_shield_zm", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING", &"ZOMBIE_EQUIP_RIOTSHIELD_HOWTO", "riotshield_zm_icon", "riotshield", ::riotshield_activation_watcher_thread, undefined, ::dropshield, ::pickupshield );
maps/mp/gametypes_zm/_weaponobjects::createretrievablehint( "riotshield", &"ZOMBIE_EQUIP_RIOTSHIELD_PICKUP_HINT_STRING" );
onplayerconnect_callback( ::onplayerconnect );
}
onplayerconnect()
{
self.player_shield_reset_health = ::player_init_shield_health;
self.player_shield_apply_damage = ::player_damage_shield;
self.player_shield_reset_location = ::player_init_shield_location;
self thread watchriotshielduse();
self thread watchriotshieldmelee();
self thread player_watch_laststand();
}
dropshield()
{
self.shield_placement = 0;
self maps/mp/zombies/_zm_riotshield_prison::updateriotshieldmodel();
item = self maps/mp/zombies/_zm_equipment::placed_equipment_think( "t6_wpn_zmb_shield_dlc2_dmg0_world", "alcatraz_shield_zm", self.origin + vectorScale( ( 0, 0, 1 ), 30 ), self.angles );
if ( isDefined( item ) )
{
item.shielddamagetaken = self.shielddamagetaken;
item.original_owner = self;
item.owner = undefined;
item.name = level.riotshield_name;
item.isriotshield = 1;
item deployed_damage_shield( 0 );
item setscriptmoverflag( 0 );
item.requires_pickup = 1;
item thread watchtoofriendly( self );
}
self takeweapon( level.riotshield_name );
return item;
}
watchtoofriendly( player )
{
wait 1;
if ( isDefined( self ) && isDefined( player ) && distance2dsquared( self.origin, player.origin ) < 36 )
{
if ( isalive( player ) )
{
player playlocalsound( level.zmb_laugh_alias );
}
player maps/mp/zombies/_zm_stats::increment_client_stat( "cheat_total", 0 );
self deployed_damage_shield( 2000 );
}
}
pickupshield( item )
{
item.owner = self;
damage = item.shielddamagetaken;
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
self.shielddamagetaken = damage;
self player_set_shield_health( damage, damagemax );
}
placeshield( origin, angles )
{
if ( self getcurrentweapon() != level.riotshield_name )
{
self switchtoweapon( level.riotshield_name );
self waittill( "weapon_change" );
}
item = self maps/mp/zombies/_zm_riotshield_prison::doriotshielddeploy( origin, angles );
if ( isDefined( item ) )
{
item.origin = self.origin + vectorScale( ( 0, 0, 1 ), 30 );
item.angles = self.angles;
item.owner = self;
}
return item;
}
cantransferriotshield( fromplayer, toplayer )
{
if ( isDefined( toplayer.screecher_weapon ) )
{
return 0;
}
if ( isDefined( toplayer.is_drinking ) && toplayer.is_drinking > 0 )
{
return 0;
}
if ( toplayer maps/mp/zombies/_zm_laststand::player_is_in_laststand() || toplayer in_revive_trigger() )
{
return 0;
}
if ( toplayer isthrowinggrenade() )
{
return 0;
}
if ( fromplayer == toplayer )
{
return 1;
}
if ( toplayer is_player_equipment( level.riotshield_name ) && toplayer.shield_placement != 3 )
{
return 0;
}
if ( fromplayer.session_team != toplayer.session_team )
{
return 0;
}
return 1;
}
transferriotshield( fromplayer, toplayer )
{
damage = fromplayer.shielddamagetaken;
toplayer player_take_riotshield();
fromplayer player_take_riotshield();
toplayer.shielddamagetaken = damage;
toplayer.shield_placement = 3;
toplayer.shield_damage_level = 0;
toplayer maps/mp/zombies/_zm_equipment::equipment_give( "alcatraz_shield_zm" );
toplayer switchtoweapon( "alcatraz_shield_zm" );
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
toplayer player_set_shield_health( damage, damagemax );
}
player_take_riotshield()
{
self notify( "destroy_riotshield" );
if ( self getcurrentweapon() == "alcatraz_shield_zm" )
{
new_primary = "";
if ( isDefined( self.laststand ) && self.laststand )
{
new_primary = self.laststandpistol;
self giveweapon( new_primary );
}
else
{
primaryweapons = self getweaponslistprimaries();
i = 0;
while ( i < primaryweapons.size )
{
if ( primaryweapons[ i ] != "alcatraz_shield_zm" )
{
new_primary = primaryweapons[ i ];
break;
}
else
{
i++;
}
}
if ( new_primary == "" )
{
self maps/mp/zombies/_zm_weapons::give_fallback_weapon();
new_primary = "zombie_fists_zm";
}
}
self switchtoweaponimmediate( new_primary );
self playsound( "wpn_riotshield_zm_destroy" );
self waittill( "weapon_change" );
}
self maps/mp/zombies/_zm_riotshield_prison::removeriotshield();
self maps/mp/zombies/_zm_equipment::equipment_take( "alcatraz_shield_zm" );
self.hasriotshield = 0;
self.hasriotshieldequipped = 0;
}
player_watch_laststand()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "entering_last_stand" );
if ( self getcurrentweapon() == "alcatraz_shield_zm" )
{
new_primary = self.laststandpistol;
self giveweapon( new_primary );
self switchtoweaponimmediate( new_primary );
}
}
}
player_init_shield_health()
{
retval = self.shielddamagetaken > 0;
self.shielddamagetaken = 0;
self.shield_damage_level = 0;
self maps/mp/zombies/_zm_riotshield_prison::updateriotshieldmodel();
return retval;
}
player_init_shield_location()
{
self.hasriotshield = 1;
self.hasriotshieldequipped = 0;
self.shield_placement = 2;
self maps/mp/zombies/_zm_riotshield_prison::updateriotshieldmodel();
}
player_set_shield_health( damage, max_damage )
{
shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
if ( shieldhealth >= 50 )
{
self.shield_damage_level = 0;
}
else if ( shieldhealth >= 25 )
{
self.shield_damage_level = 2;
}
else
{
self.shield_damage_level = 3;
}
self maps/mp/zombies/_zm_riotshield_prison::updateriotshieldmodel();
}
deployed_set_shield_health( damage, max_damage )
{
shieldhealth = int( ( 100 * ( max_damage - damage ) ) / max_damage );
if ( shieldhealth >= 50 )
{
self.shield_damage_level = 0;
}
else if ( shieldhealth >= 25 )
{
self.shield_damage_level = 2;
}
else
{
self.shield_damage_level = 3;
}
self maps/mp/zombies/_zm_riotshield_prison::updatestandaloneriotshieldmodel();
}
player_damage_shield( idamage, bheld )
{
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
if ( !isDefined( self.shielddamagetaken ) )
{
self.shielddamagetaken = 0;
}
self.shielddamagetaken += idamage;
if ( self.shielddamagetaken >= damagemax )
{
if ( bheld || !isDefined( self.shield_ent ) )
{
self playrumbleonentity( "damage_heavy" );
earthquake( 1, 0,75, self.origin, 100 );
}
else
{
if ( isDefined( self.shield_ent ) )
{
if ( is_true( self.shield_ent.destroy_begun ) )
{
return;
}
self.shield_ent.destroy_begun = 1;
shield_origin = self.shield_ent.origin;
level thread maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
wait 1;
playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
}
}
self thread player_take_riotshield();
}
else
{
if ( bheld )
{
self playrumbleonentity( "damage_light" );
earthquake( 0,5, 0,5, self.origin, 100 );
}
self player_set_shield_health( self.shielddamagetaken, damagemax );
self playsound( "fly_riotshield_zm_impact_zombies" );
}
}
deployed_damage_shield( idamage )
{
damagemax = level.zombie_vars[ "riotshield_hit_points" ];
if ( !isDefined( self.shielddamagetaken ) )
{
self.shielddamagetaken = 0;
}
self.shielddamagetaken += idamage;
if ( self.shielddamagetaken >= damagemax )
{
shield_origin = self.origin;
if ( isDefined( self.stub ) )
{
thread maps/mp/zombies/_zm_unitrigger::unregister_unitrigger( self.stub );
}
if ( isDefined( self.original_owner ) )
{
self.original_owner maps/mp/zombies/_zm_equipment::equipment_take( "alcatraz_shield_zm" );
}
maps/mp/zombies/_zm_equipment::equipment_disappear_fx( shield_origin, level._riotshield_dissapear_fx );
playsoundatposition( "wpn_riotshield_zm_destroy", shield_origin );
self_delete();
}
else
{
self deployed_set_shield_health( self.shielddamagetaken, damagemax );
}
}
riotshield_activation_watcher_thread()
{
self endon( "zombified" );
self endon( "disconnect" );
self endon( "alcatraz_shield_zm_taken" );
while ( 1 )
{
self waittill_either( "alcatraz_shield_zm_activate", "alcatraz_shield_zm_deactivate" );
}
}
watchriotshielduse()
{
self endon( "death" );
self endon( "disconnect" );
self.shielddamagetaken = 0;
self thread maps/mp/zombies/_zm_riotshield_prison::trackriotshield();
self thread maps/mp/zombies/_zm_riotshield_prison::trackequipmentchange();
self thread maps/mp/zombies/_zm_riotshield_prison::watchshieldlaststand();
self thread trackstuckzombies();
for ( ;; )
{
self waittill( "raise_riotshield" );
self thread maps/mp/zombies/_zm_riotshield_prison::startriotshielddeploy();
}
}
watchriotshieldmelee()
{
for ( ;; )
{
self waittill( "weapon_melee", weapon );
if ( weapon == level.riotshield_name )
{
self riotshield_melee();
}
}
}
is_riotshield_damage( mod, player, amount )
{
if ( mod == "MOD_MELEE" && player hasweapon( level.riotshield_name ) && amount < 10 )
{
return 1;
}
return 0;
}
riotshield_damage( amount )
{
}
riotshield_fling_zombie( player, fling_vec, index )
{
if ( !isDefined( self ) || !isalive( self ) )
{
return;
}
if ( isDefined( self.ignore_riotshield ) && self.ignore_riotshield )
{
return;
}
if ( isDefined( self.riotshield_fling_func ) )
{
self [[ self.riotshield_fling_func ]]( player );
return;
}
damage = 2500;
self dodamage( damage, player.origin, player, player, "", "MOD_IMPACT" );
if ( self.health < 1 )
{
self.riotshield_death = 1;
self startragdoll();
self launchragdoll( fling_vec );
}
}
zombie_knockdown( player, gib )
{
damage = level.zombie_vars[ "riotshield_knockdown_damage" ];
if ( isDefined( level.override_riotshield_damage_func ) )
{
self [[ level.override_riotshield_damage_func ]]( player, gib );
}
else
{
if ( gib )
{
self.a.gib_ref = random( level.riotshield_gib_refs );
self thread maps/mp/animscripts/zm_death::do_gib();
}
self dodamage( damage, player.origin, player );
}
}
riotshield_knockdown_zombie( player, gib )
{
self endon( "death" );
playsoundatposition( "vox_riotshield_forcehit", self.origin );
playsoundatposition( "wpn_riotshield_proj_impact", self.origin );
if ( !isDefined( self ) || !isalive( self ) )
{
return;
}
if ( isDefined( self.riotshield_knockdown_func ) )
{
self [[ self.riotshield_knockdown_func ]]( player, gib );
}
else
{
self zombie_knockdown( player, gib );
}
self dodamage( level.zombie_vars[ "riotshield_knockdown_damage" ], player.origin, player );
self playsound( "fly_riotshield_forcehit" );
}
riotshield_get_enemies_in_range()
{
view_pos = self geteye();
zombies = get_array_of_closest( view_pos, get_round_enemy_array(), undefined, undefined, 2 * level.zombie_vars[ "riotshield_knockdown_range" ] );
if ( !isDefined( zombies ) )
{
return;
}
knockdown_range_squared = level.zombie_vars[ "riotshield_knockdown_range" ] * level.zombie_vars[ "riotshield_knockdown_range" ];
gib_range_squared = level.zombie_vars[ "riotshield_gib_range" ] * level.zombie_vars[ "riotshield_gib_range" ];
fling_range_squared = level.zombie_vars[ "riotshield_fling_range" ] * level.zombie_vars[ "riotshield_fling_range" ];
cylinder_radius_squared = level.zombie_vars[ "riotshield_cylinder_radius" ] * level.zombie_vars[ "riotshield_cylinder_radius" ];
forward_view_angles = self getweaponforwarddir();
end_pos = view_pos + vectorScale( forward_view_angles, level.zombie_vars[ "riotshield_knockdown_range" ] );
/#
if ( getDvarInt( #"BF480CE9" ) == 2 )
{
near_circle_pos = view_pos + vectorScale( forward_view_angles, 2 );
circle( near_circle_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
line( near_circle_pos, end_pos, ( 0, 0, 1 ), 1, 0, 100 );
circle( end_pos, level.zombie_vars[ "riotshield_cylinder_radius" ], ( 0, 0, 1 ), 0, 0, 100 );
#/
}
i = 0;
while ( i < zombies.size )
{
if ( !isDefined( zombies[ i ] ) || !isalive( zombies[ i ] ) )
{
i++;
continue;
}
else
{
test_origin = zombies[ i ] getcentroid();
test_range_squared = distancesquared( view_pos, test_origin );
if ( test_range_squared > knockdown_range_squared )
{
zombies[ i ] riotshield_debug_print( "range", ( 0, 0, 1 ) );
return;
}
normal = vectornormalize( test_origin - view_pos );
dot = vectordot( forward_view_angles, normal );
if ( dot <= 0 )
{
zombies[ i ] riotshield_debug_print( "dot", ( 0, 0, 1 ) );
i++;
continue;
}
else radial_origin = pointonsegmentnearesttopoint( view_pos, end_pos, test_origin );
if ( distancesquared( test_origin, radial_origin ) > cylinder_radius_squared )
{
zombies[ i ] riotshield_debug_print( "cylinder", ( 0, 0, 1 ) );
i++;
continue;
}
else if ( zombies[ i ] damageconetrace( view_pos, self ) == 0 )
{
zombies[ i ] riotshield_debug_print( "cone", ( 0, 0, 1 ) );
i++;
continue;
}
else if ( test_range_squared < fling_range_squared )
{
level.riotshield_fling_enemies[ level.riotshield_fling_enemies.size ] = zombies[ i ];
dist_mult = ( fling_range_squared - test_range_squared ) / fling_range_squared;
fling_vec = vectornormalize( test_origin - view_pos );
if ( test_range_squared >= 5000 )
{
fling_vec += vectornormalize( test_origin - radial_origin );
}
fling_vec = ( fling_vec[ 0 ], fling_vec[ 1 ], abs( fling_vec[ 2 ] ) );
fling_vec = vectorScale( fling_vec, 100 + ( 100 * dist_mult ) );
level.riotshield_fling_vecs[ level.riotshield_fling_vecs.size ] = fling_vec;
zombies[ i ] riotshield_debug_print( "fling", ( 0, 0, 1 ) );
i++;
continue;
}
else
{
level.riotshield_knockdown_enemies[ level.riotshield_knockdown_enemies.size ] = zombies[ i ];
level.riotshield_knockdown_gib[ level.riotshield_knockdown_gib.size ] = 0;
zombies[ i ] riotshield_debug_print( "knockdown", ( 0, 0, 1 ) );
}
}
i++;
}
}
riotshield_network_choke()
{
level.riotshield_network_choke_count++;
if ( level.riotshield_network_choke_count % 10 )
{
wait_network_frame();
wait_network_frame();
wait_network_frame();
}
}
riotshield_melee()
{
if ( !isDefined( level.riotshield_knockdown_enemies ) )
{
level.riotshield_knockdown_enemies = [];
level.riotshield_knockdown_gib = [];
level.riotshield_fling_enemies = [];
level.riotshield_fling_vecs = [];
}
self riotshield_get_enemies_in_range();
shield_damage = 0;
level.riotshield_network_choke_count = 0;
i = 0;
while ( i < level.riotshield_fling_enemies.size )
{
riotshield_network_choke();
if ( isDefined( level.riotshield_fling_enemies[ i ] ) )
{
level.riotshield_fling_enemies[ i ] thread riotshield_fling_zombie( self, level.riotshield_fling_vecs[ i ], i );
shield_damage += level.zombie_vars[ "riotshield_fling_damage_shield" ];
}
i++;
}
i = 0;
while ( i < level.riotshield_knockdown_enemies.size )
{
riotshield_network_choke();
level.riotshield_knockdown_enemies[ i ] thread riotshield_knockdown_zombie( self, level.riotshield_knockdown_gib[ i ] );
shield_damage += level.zombie_vars[ "riotshield_knockdown_damage_shield" ];
i++;
}
level.riotshield_knockdown_enemies = [];
level.riotshield_knockdown_gib = [];
level.riotshield_fling_enemies = [];
level.riotshield_fling_vecs = [];
if ( shield_damage )
{
self player_damage_shield( shield_damage, 0 );
}
}
trackstuckzombies()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "deployed_riotshield" );
if ( isDefined( self.riotshieldentity ) )
{
self thread watchstuckzombies();
}
}
}
attack_shield( shield )
{
self endon( "death" );
shield.owner endon( "death" );
shield.owner endon( "disconnect" );
shield.owner endon( "start_riotshield_deploy" );
shield.owner endon( "destroy_riotshield" );
if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
{
return 0;
}
self.old_origin = self.origin;
if ( getDvar( "zombie_shield_attack_freq" ) == "" )
{
setdvar( "zombie_shield_attack_freq", "15" );
}
freq = getDvarInt( "zombie_shield_attack_freq" );
self.doing_shield_attack = 1;
self.enemyoverride[ 0 ] = shield.origin;
self.enemyoverride[ 1 ] = shield;
wait ( randomint( 100 ) / 100 );
self thread maps/mp/zombies/_zm_audio::do_zombies_playvocals( "attack", self.animname );
attackanim = "zm_riotshield_melee";
if ( !self.has_legs )
{
attackanim += "_crawl";
}
self orientmode( "face point", shield.origin );
self animscripted( self.origin, flat_angle( vectorToAngle( shield.origin - self.origin ) ), attackanim );
if ( isDefined( shield.owner.player_shield_apply_damage ) )
{
shield.owner [[ shield.owner.player_shield_apply_damage ]]( 100, 0 );
}
else
{
shield.owner player_damage_shield( 100, 0 );
}
self thread attack_shield_stop( shield );
wait ( randomint( 100 ) / 100 );
self.doing_shield_attack = 0;
self orientmode( "face default" );
}
attack_shield_stop( shield )
{
self notify( "attack_shield_stop" );
self endon( "attack_shield_stop" );
self endon( "death" );
shield waittill( "death" );
self stopanimscripted();
if ( isDefined( self.doing_shield_attack ) && self.doing_shield_attack )
{
breachanim = "zm_riotshield_breakthrough";
if ( !self.has_legs )
{
breachanim += "_crawl";
}
self animscripted( self.origin, flat_angle( self.angles ), breachanim );
}
}
window_notetracks( msg, player )
{
self endon( "death" );
while ( 1 )
{
self waittill( msg, notetrack );
if ( notetrack == "end" )
{
return;
}
if ( notetrack == "fire" )
{
player player_damage_shield( 100, 0 );
}
}
}
watchstuckzombies()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self endon( "destroy_riotshield" );
self endon( "deployed_riotshield" );
level endon( "intermission" );
self.riotshieldentity maps/mp/zombies/_zm_equipment::item_attract_zombies();
}
riotshield_active()
{
return self maps/mp/zombies/_zm_equipment::is_equipment_active( "alcatraz_shield_zm" );
}
riotshield_debug_print( msg, color )
{
/#
if ( !getDvarInt( #"BF480CE9" ) )
{
return;
}
if ( !isDefined( color ) )
{
color = ( 0, 0, 1 );
}
print3d( self.origin + vectorScale( ( 0, 0, 1 ), 60 ), msg, color, 1, 1, 40 );
#/
}
shield_zombie_attract_func( poi )
{
}
shield_zombie_arrive_func( poi )
{
self endon( "death" );
self endon( "zombie_acquire_enemy" );
self endon( "path_timer_done" );
self waittill( "goal" );
if ( isDefined( poi.owner ) )
{
poi.owner player_damage_shield( 100, 0 );
if ( isDefined( poi.owner.player_shield_apply_damage ) )
{
poi.owner [[ poi.owner.player_shield_apply_damage ]]( 100, 0 );
}
}
}
createriotshieldattractor()
{
self create_zombie_point_of_interest( 50, 8, 0, 1, ::shield_zombie_attract_func, ::shield_zombie_arrive_func );
self thread create_zombie_point_of_interest_attractor_positions( 4, 15, 15 );
return get_zombie_point_of_interest( self.origin );
}
riotshield_zombie_damage_response( mod, hit_location, hit_origin, player, amount )
{
if ( self is_riotshield_damage( mod, player, amount ) )
{
self riotshield_damage( amount );
return 1;
}
return 0;
}
watchriotshieldattractor()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "start_riotshield_deploy" );
self endon( "destroy_riotshield" );
self endon( "deployed_riotshield" );
poi = self.riotshieldentity createriotshieldattractor();
}
trackriotshieldattractor()
{
self endon( "death" );
self endon( "disconnect" );
for ( ;; )
{
self waittill( "deployed_riotshield" );
self thread watchriotshieldattractor();
}
}

672
zm_prison_patch/maps/mp/zombies/_zm_weap_tomahawk.gsc Normal file
View File

@ -0,0 +1,672 @@
#include maps/mp/zombies/_zm_stats;
#include maps/mp/zombies/_zm_score;
#include maps/mp/zombies/_zm_weapons;
#include maps/mp/zombies/_zm_net;
#include maps/mp/zombies/_zm_utility;
#include maps/mp/_utility;
#include common_scripts/utility;
init()
{
registerclientfield( "toplayer", "tomahawk_in_use", 9000, 2, "int" );
registerclientfield( "toplayer", "upgraded_tomahawk_in_use", 9000, 1, "int" );
registerclientfield( "scriptmover", "play_tomahawk_fx", 9000, 2, "int" );
registerclientfield( "actor", "play_tomahawk_hit_sound", 9000, 1, "int" );
onplayerconnect_callback( ::tomahawk_on_player_connect );
maps/mp/zombies/_zm_weapons::include_zombie_weapon( "bouncing_tomahawk_zm", 0 );
maps/mp/zombies/_zm_weapons::include_zombie_weapon( "upgraded_tomahawk_zm", 0 );
maps/mp/zombies/_zm_weapons::include_zombie_weapon( "zombie_tomahawk_flourish", 0 );
maps/mp/zombies/_zm_weapons::add_zombie_weapon( "bouncing_tomahawk_zm", "zombie_tomahawk_flourish", &"ZOMBIE_WEAPON_SATCHEL_2000", 2000, "wpck_monkey", "", undefined, 1 );
maps/mp/zombies/_zm_weapons::add_zombie_weapon( "upgraded_tomahawk_zm", "zombie_tomahawk_flourish", &"ZOMBIE_WEAPON_SATCHEL_2000", 2000, "wpck_monkey", "", undefined, 1 );
level thread tomahawk_pickup();
level.zombie_weapons_no_max_ammo = [];
level.zombie_weapons_no_max_ammo[ "bouncing_tomahawk_zm" ] = 1;
level.zombie_weapons_no_max_ammo[ "upgraded_tomahawk_zm" ] = 1;
level.a_tomahawk_pickup_funcs = [];
}
tomahawk_on_player_connect()
{
self.current_tomahawk_weapon = "bouncing_tomahawk_zm";
self.current_tactical_grenade = "bouncing_tomahawk_zm";
self thread watch_for_tomahawk_throw();
self thread watch_for_tomahawk_charge();
}
watch_for_tomahawk_throw()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "grenade_fire", grenade, weapname );
while ( !issubstr( weapname, "tomahawk_zm" ) )
{
continue;
}
grenade.use_grenade_special_bookmark = 1;
grenade.grenade_multiattack_bookmark_count = 1;
grenade.low_level_instant_kill_charge = 1;
grenade.owner = self;
self notify( "throwing_tomahawk" );
if ( isDefined( self.n_tomahawk_cooking_time ) )
{
grenade.n_cookedtime = grenade.birthtime - self.n_tomahawk_cooking_time;
}
else
{
grenade.n_cookedtime = 0;
}
self thread check_for_time_out( grenade );
self thread tomahawk_thrown( grenade );
}
}
watch_for_tomahawk_charge()
{
self endon( "disconnect" );
while ( 1 )
{
self waittill( "grenade_pullback", weaponname );
while ( !issubstr( weaponname, "tomahawk_zm" ) )
{
continue;
}
self thread watch_for_grenade_cancel();
self thread play_charge_fx();
self.n_tomahawk_cooking_time = getTime();
self waittill_either( "grenade_fire", "grenade_throw_cancelled" );
wait 0,1;
self.n_tomahawk_cooking_time = undefined;
}
}
watch_for_grenade_cancel()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "grenade_fire" );
waittillframeend;
weapon = "none";
while ( self isthrowinggrenade() && weapon == "none" )
{
self waittill( "weapon_change", weapon );
}
self notify( "grenade_throw_cancelled" );
}
play_charge_fx()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "grenade_fire" );
waittillframeend;
time_to_pulse = 1000;
while ( 1 )
{
time = getTime() - self.n_tomahawk_cooking_time;
self.current_tactical_grenade = self get_player_tactical_grenade();
if ( time >= time_to_pulse )
{
if ( self.current_tactical_grenade == "upgraded_tomahawk_zm" )
{
playfxontag( level._effect[ "tomahawk_charge_up_ug" ], self, "tag_origin" );
}
else
{
playfxontag( level._effect[ "tomahawk_charge_up" ], self, "tag_origin" );
}
time_to_pulse += 1000;
self playrumbleonentity( "reload_small" );
}
if ( time_to_pulse > 2400 && self.current_tactical_grenade != "upgraded_tomahawk_zm" )
{
return;
}
else
{
if ( time_to_pulse >= 3400 )
{
return;
}
else
{
wait 0,05;
}
}
}
}
get_grenade_charge_power( player )
{
player endon( "disconnect" );
if ( self.n_cookedtime > 1000 && self.n_cookedtime < 2000 )
{
if ( player.current_tomahawk_weapon == "upgraded_tomahawk_zm" )
{
return 4,5;
}
return 1,5;
}
else
{
if ( self.n_cookedtime > 2000 && self.n_cookedtime < 3000 )
{
if ( player.current_tomahawk_weapon == "upgraded_tomahawk_zm" )
{
return 6;
}
return 2;
}
else
{
if ( self.n_cookedtime >= 3000 && player.current_tomahawk_weapon != "upgraded_tomahawk_zm" )
{
return 2;
}
else
{
if ( self.n_cookedtime >= 3000 )
{
return 3;
}
}
}
}
return 1;
}
tomahawk_thrown( grenade )
{
self endon( "disconnect" );
grenade endon( "in_hellhole" );
grenade_owner = undefined;
if ( isDefined( grenade.owner ) )
{
grenade_owner = grenade.owner;
}
playfxontag( level._effect[ "tomahawk_charged_trail" ], grenade, "tag_origin" );
self setclientfieldtoplayer( "tomahawk_in_use", 2 );
grenade waittill_either( "death", "time_out" );
grenade_origin = grenade.origin;
a_zombies = getaispeciesarray( "axis", "all" );
n_grenade_charge_power = grenade get_grenade_charge_power( self );
a_zombies = get_array_of_closest( grenade_origin, a_zombies, undefined, undefined, 200 );
a_powerups = get_array_of_closest( grenade_origin, level.active_powerups, undefined, undefined, 200 );
while ( isDefined( level.a_tomahawk_pickup_funcs ) )
{
_a243 = level.a_tomahawk_pickup_funcs;
_k243 = getFirstArrayKey( _a243 );
while ( isDefined( _k243 ) )
{
tomahawk_func = _a243[ _k243 ];
if ( [[ tomahawk_func ]]( grenade, n_grenade_charge_power ) )
{
return;
}
_k243 = getNextArrayKey( _a243, _k243 );
}
}
if ( isDefined( a_powerups ) && a_powerups.size > 0 )
{
m_tomahawk = tomahawk_spawn( grenade_origin, n_grenade_charge_power );
m_tomahawk.n_grenade_charge_power = n_grenade_charge_power;
_a256 = a_powerups;
_k256 = getFirstArrayKey( _a256 );
while ( isDefined( _k256 ) )
{
powerup = _a256[ _k256 ];
powerup.origin = grenade_origin;
powerup linkto( m_tomahawk );
m_tomahawk.a_has_powerup = a_powerups;
_k256 = getNextArrayKey( _a256, _k256 );
}
self thread tomahawk_return_player( m_tomahawk, 0 );
return;
}
if ( !isDefined( a_zombies ) )
{
m_tomahawk = tomahawk_spawn( grenade_origin, n_grenade_charge_power );
m_tomahawk.n_grenade_charge_power = n_grenade_charge_power;
self thread tomahawk_return_player( m_tomahawk, 0 );
return;
}
else
{
_a276 = a_zombies;
_k276 = getFirstArrayKey( _a276 );
while ( isDefined( _k276 ) )
{
ai_zombie = _a276[ _k276 ];
ai_zombie.hit_by_tomahawk = 0;
_k276 = getNextArrayKey( _a276, _k276 );
}
}
if ( isDefined( a_zombies[ 0 ] ) && isalive( a_zombies[ 0 ] ) )
{
v_zombiepos = a_zombies[ 0 ].origin;
if ( distancesquared( grenade_origin, v_zombiepos ) <= 4900 )
{
a_zombies[ 0 ] setclientfield( "play_tomahawk_hit_sound", 1 );
n_tomahawk_damage = calculate_tomahawk_damage( a_zombies[ 0 ], n_grenade_charge_power, grenade );
a_zombies[ 0 ] dodamage( n_tomahawk_damage, grenade_origin, self, grenade, "none", "MOD_GRENADE", 0, "bouncing_tomahawk_zm" );
a_zombies[ 0 ].hit_by_tomahawk = 1;
self maps/mp/zombies/_zm_score::add_to_player_score( 10 );
self thread tomahawk_ricochet_attack( grenade_origin, n_grenade_charge_power );
}
else
{
m_tomahawk = tomahawk_spawn( grenade_origin, n_grenade_charge_power );
m_tomahawk.n_grenade_charge_power = n_grenade_charge_power;
self thread tomahawk_return_player( m_tomahawk, 0 );
}
}
else
{
m_tomahawk = tomahawk_spawn( grenade_origin, n_grenade_charge_power );
m_tomahawk.n_grenade_charge_power = n_grenade_charge_power;
if ( isDefined( grenade ) )
{
grenade delete();
}
self thread tomahawk_return_player( m_tomahawk, 0 );
}
}
check_for_time_out( grenade )
{
self endon( "disconnect" );
grenade endon( "death" );
wait 0,5;
grenade notify( "time_out" );
}
tomahawk_ricochet_attack( grenade_origin, tomahawk_charge_power )
{
self endon( "disconnect" );
a_zombies = getaispeciesarray( "axis", "all" );
a_zombies = get_array_of_closest( grenade_origin, a_zombies, undefined, undefined, 300 );
a_zombies = array_reverse( a_zombies );
if ( !isDefined( a_zombies ) )
{
m_tomahawk = tomahawk_spawn( grenade_origin, tomahawk_charge_power );
m_tomahawk.n_grenade_charge_power = tomahawk_charge_power;
self thread tomahawk_return_player( m_tomahawk, 0 );
return;
}
m_tomahawk = tomahawk_spawn( grenade_origin, tomahawk_charge_power );
m_tomahawk.n_grenade_charge_power = tomahawk_charge_power;
self thread tomahawk_attack_zombies( m_tomahawk, a_zombies );
}
tomahawk_attack_zombies( m_tomahawk, a_zombies )
{
self endon( "disconnect" );
if ( !isDefined( a_zombies ) )
{
self thread tomahawk_return_player( m_tomahawk, 0 );
return;
}
if ( a_zombies.size <= 4 )
{
n_attack_limit = a_zombies.size;
}
else
{
n_attack_limit = 4;
}
i = 0;
while ( i < n_attack_limit )
{
if ( isDefined( a_zombies[ i ] ) && isalive( a_zombies[ i ] ) )
{
tag = "J_Head";
if ( a_zombies[ i ].isdog )
{
tag = "J_Spine1";
}
if ( isDefined( a_zombies[ i ].hit_by_tomahawk ) && !a_zombies[ i ].hit_by_tomahawk )
{
v_target = a_zombies[ i ] gettagorigin( tag );
m_tomahawk moveto( v_target, 0,3 );
m_tomahawk waittill( "movedone" );
if ( isDefined( a_zombies[ i ] ) && isalive( a_zombies[ i ] ) )
{
if ( self.current_tactical_grenade == "upgraded_tomahawk_zm" )
{
playfxontag( level._effect[ "tomahawk_impact_ug" ], a_zombies[ i ], tag );
}
else
{
playfxontag( level._effect[ "tomahawk_impact" ], a_zombies[ i ], tag );
}
playfxontag( level._effect[ "tomahawk_fire_dot" ], a_zombies[ i ], "j_spineupper" );
a_zombies[ i ] setclientfield( "play_tomahawk_hit_sound", 1 );
n_tomahawk_damage = calculate_tomahawk_damage( a_zombies[ i ], m_tomahawk.n_grenade_charge_power, m_tomahawk );
a_zombies[ i ] dodamage( n_tomahawk_damage, m_tomahawk.origin, self, m_tomahawk, "none", "MOD_GRENADE", 0, "bouncing_tomahawk_zm" );
a_zombies[ i ].hit_by_tomahawk = 1;
self maps/mp/zombies/_zm_score::add_to_player_score( 10 );
}
}
}
wait 0,2;
i++;
}
self thread tomahawk_return_player( m_tomahawk, n_attack_limit );
}
tomahawk_return_player( m_tomahawk, num_zombie_hit )
{
self endon( "disconnect" );
n_dist = distance2dsquared( m_tomahawk.origin, self.origin );
if ( !isDefined( num_zombie_hit ) )
{
num_zombie_hit = 5;
}
while ( n_dist > 4096 )
{
m_tomahawk moveto( self geteye(), 0,25 );
if ( num_zombie_hit < 5 )
{
self tomahawk_check_for_zombie( m_tomahawk );
num_zombie_hit++;
}
wait 0,1;
n_dist = distance2dsquared( m_tomahawk.origin, self geteye() );
}
while ( isDefined( m_tomahawk.a_has_powerup ) )
{
_a470 = m_tomahawk.a_has_powerup;
_k470 = getFirstArrayKey( _a470 );
while ( isDefined( _k470 ) )
{
powerup = _a470[ _k470 ];
if ( isDefined( powerup ) )
{
powerup.origin = self.origin;
}
_k470 = getNextArrayKey( _a470, _k470 );
}
}
m_tomahawk delete();
self playsoundtoplayer( "wpn_tomahawk_catch_plr", self );
self playsound( "wpn_tomahawk_catch_npc" );
wait 5;
self playsoundtoplayer( "wpn_tomahawk_cooldown_done", self );
self givemaxammo( self.current_tomahawk_weapon );
a_zombies = getaispeciesarray( "axis", "all" );
_a490 = a_zombies;
_k490 = getFirstArrayKey( _a490 );
while ( isDefined( _k490 ) )
{
ai_zombie = _a490[ _k490 ];
ai_zombie.hit_by_tomahawk = 0;
_k490 = getNextArrayKey( _a490, _k490 );
}
self setclientfieldtoplayer( "tomahawk_in_use", 3 );
}
tomahawk_check_for_zombie( grenade )
{
self endon( "disconnect" );
grenade endon( "death" );
a_zombies = getaispeciesarray( "axis", "all" );
a_zombies = get_array_of_closest( grenade.origin, a_zombies, undefined, undefined, 100 );
if ( isDefined( a_zombies[ 0 ] ) && distance2dsquared( grenade.origin, a_zombies[ 0 ].origin ) <= 10000 )
{
if ( isDefined( a_zombies[ 0 ].hit_by_tomahawk ) && !a_zombies[ 0 ].hit_by_tomahawk )
{
self tomahawk_hit_zombie( a_zombies[ 0 ], grenade );
}
}
}
tomahawk_hit_zombie( ai_zombie, grenade )
{
self endon( "disconnect" );
if ( isDefined( ai_zombie ) && isalive( ai_zombie ) )
{
tag = "J_Head";
if ( ai_zombie.isdog )
{
tag = "J_Spine1";
}
v_target = ai_zombie gettagorigin( tag );
grenade moveto( v_target, 0,3 );
grenade waittill( "movedone" );
if ( isDefined( ai_zombie ) && isalive( ai_zombie ) )
{
if ( self.current_tactical_grenade == "upgraded_tomahawk_zm" )
{
playfxontag( level._effect[ "tomahawk_impact_ug" ], ai_zombie, tag );
}
else
{
playfxontag( level._effect[ "tomahawk_impact" ], ai_zombie, tag );
}
ai_zombie setclientfield( "play_tomahawk_hit_sound", 1 );
n_tomahawk_damage = calculate_tomahawk_damage( ai_zombie, grenade.n_grenade_charge_power, grenade );
ai_zombie dodamage( n_tomahawk_damage, grenade.origin, self, grenade, "none", "MOD_GRENADE", 0, "bouncing_tomahawk_zm" );
ai_zombie.hit_by_tomahawk = 1;
self maps/mp/zombies/_zm_score::add_to_player_score( 10 );
}
}
}
tomahawk_spawn( grenade_origin, charged )
{
m_tomahawk = spawn( "script_model", grenade_origin );
m_tomahawk setmodel( "t6_wpn_zmb_tomahawk_world" );
m_tomahawk thread tomahawk_spin();
m_tomahawk playloopsound( "wpn_tomahawk_flying_loop" );
if ( self.current_tactical_grenade == "upgraded_tomahawk_zm" )
{
playfxontag( level._effect[ "tomahawk_trail_ug" ], m_tomahawk, "tag_origin" );
}
else
{
playfxontag( level._effect[ "tomahawk_trail" ], m_tomahawk, "tag_origin" );
}
if ( isDefined( charged ) && charged > 1 )
{
playfxontag( level._effect[ "tomahawk_charged_trail" ], m_tomahawk, "tag_origin" );
}
m_tomahawk.low_level_instant_kill_charge = 1;
return m_tomahawk;
}
tomahawk_spin()
{
self endon( "death" );
while ( isDefined( self ) )
{
self rotatepitch( 90, 0,2 );
wait 0,15;
}
}
tomahawk_pickup()
{
flag_wait( "soul_catchers_charged" );
flag_init( "tomahawk_pickup_complete" );
door = getent( "tomahawk_room_door", "targetname" );
door trigger_off();
door connectpaths();
s_pos_tomahawk = getstruct( "tomahawk_pickup_pos", "targetname" );
m_tomahawk = spawn( "script_model", s_pos_tomahawk.origin );
m_tomahawk.targetname = "spinning_tomahawk_pickup";
m_tomahawk setmodel( "t6_wpn_zmb_tomahawk_world" );
m_tomahawk setclientfield( "play_tomahawk_fx", 1 );
m_tomahawk thread tomahawk_pickup_spin();
m_tomahawk playloopsound( "amb_tomahawk_swirl" );
s_pos_trigger = getstruct( "tomahawk_trigger_pos", "targetname" );
trigger = spawn( "trigger_radius_use", s_pos_trigger.origin, 0, 100, 150 );
trigger.script_noteworthy = "retriever_pickup_trigger";
trigger usetriggerrequirelookat();
trigger triggerignoreteam();
trigger sethintstring( &"ZM_PRISON_TOMAHAWK_PICKUP" );
trigger setcursorhint( "HINT_NOICON" );
trigger_upgraded = spawn( "trigger_radius_use", s_pos_trigger.origin, 0, 100, 150 );
trigger_upgraded usetriggerrequirelookat();
trigger_upgraded triggerignoreteam();
trigger_upgraded.script_noteworthy = "redeemer_pickup_trigger";
trigger_upgraded sethintstring( &"ZM_PRISON_TOMAHAWK_UPGRADED_PICKUP" );
trigger_upgraded setcursorhint( "HINT_NOICON" );
/#
iprintlnbold( "GO FIND THE TOMAHAWK" );
#/
trigger thread tomahawk_pickup_trigger();
trigger_upgraded thread tomahawk_pickup_trigger();
flag_set( "tomahawk_pickup_complete" );
}
tomahawk_pickup_trigger()
{
for ( ;; )
{
while ( 1 )
{
self waittill( "trigger", player );
if ( isDefined( player.current_tactical_grenade ) && !issubstr( player.current_tactical_grenade, "tomahawk_zm" ) )
{
player takeweapon( player.current_tactical_grenade );
}
while ( player.current_tomahawk_weapon == "upgraded_tomahawk_zm" )
{
if ( !is_true( player.afterlife ) )
{
}
}
else player disable_player_move_states( 1 );
gun = player getcurrentweapon();
level notify( "bouncing_tomahawk_zm_aquired" );
player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_tomahawk_acquired", 0 );
player giveweapon( "zombie_tomahawk_flourish" );
player thread tomahawk_update_hud_on_last_stand();
player switchtoweapon( "zombie_tomahawk_flourish" );
player waittill_any( "player_downed", "weapon_change_complete" );
if ( self.script_noteworthy == "redeemer_pickup_trigger" )
{
player.redeemer_trigger = self;
player setclientfieldtoplayer( "upgraded_tomahawk_in_use", 1 );
}
player switchtoweapon( gun );
player enable_player_move_states();
player.loadout.hastomahawk = 1;
}
if ( !player hasweapon( "bouncing_tomahawk_zm" ) && !player hasweapon( "upgraded_tomahawk_zm" ) )
{
player disable_player_move_states( 1 );
if ( !is_true( player.afterlife ) )
{
player giveweapon( player.current_tomahawk_weapon );
player thread tomahawk_update_hud_on_last_stand();
player thread tomahawk_tutorial_hint();
player set_player_tactical_grenade( player.current_tomahawk_weapon );
if ( self.script_noteworthy == "retriever_pickup_trigger" )
{
player.retriever_trigger = self;
}
player notify( "tomahawk_picked_up" );
player setclientfieldtoplayer( "tomahawk_in_use", 1 );
gun = player getcurrentweapon();
level notify( "bouncing_tomahawk_zm_aquired" );
player notify( "player_obtained_tomahawk" );
player maps/mp/zombies/_zm_stats::increment_client_stat( "prison_tomahawk_acquired", 0 );
player giveweapon( "zombie_tomahawk_flourish" );
player switchtoweapon( "zombie_tomahawk_flourish" );
player waittill_any( "player_downed", "weapon_change_complete" );
if ( self.script_noteworthy == "redeemer_pickup_trigger" )
{
player setclientfieldtoplayer( "upgraded_tomahawk_in_use", 1 );
}
player switchtoweapon( gun );
}
player enable_player_move_states();
wait 0,1;
}
}
}
tomahawk_pickup_spin()
{
self endon( "death" );
while ( 1 )
{
self rotateyaw( 90, 1 );
wait 0,15;
}
}
calculate_tomahawk_damage( n_target_zombie, n_tomahawk_power, tomahawk )
{
if ( n_tomahawk_power > 2 )
{
return n_target_zombie.health + 1;
}
else
{
if ( level.round_number >= 10 && level.round_number < 13 && tomahawk.low_level_instant_kill_charge <= 3 )
{
tomahawk.low_level_instant_kill_charge += 1;
return n_target_zombie.health + 1;
}
else
{
if ( level.round_number >= 13 && level.round_number < 15 && tomahawk.low_level_instant_kill_charge <= 2 )
{
tomahawk.low_level_instant_kill_charge += 1;
return n_target_zombie.health + 1;
}
else
{
return 1000 * n_tomahawk_power;
}
}
}
}
setting_tutorial_hud()
{
client_hint = newclienthudelem( self );
client_hint.alignx = "center";
client_hint.aligny = "middle";
client_hint.horzalign = "center";
client_hint.vertalign = "bottom";
client_hint.y = -120;
client_hint.foreground = 1;
client_hint.font = "default";
client_hint.fontscale = 1,5;
client_hint.alpha = 1;
client_hint.color = ( 1, 1, 1 );
return client_hint;
}
tomahawk_tutorial_hint()
{
hud = setting_tutorial_hud();
hud settext( &"ZM_PRISON_TOMAHAWK_TUTORIAL" );
self waittill_notify_or_timeout( "throwing_tomahawk", 5 );
wait 1;
hud destroy();
}
tomahawk_update_hud_on_last_stand()
{
self endon( "disconnect" );
self endon( "bled_out" );
self endon( "tomahawk_upgraded_swap" );
while ( 1 )
{
self waittill_either( "entering_last_stand", "fake_death" );
self setclientfieldtoplayer( "tomahawk_in_use", 0 );
self waittill( "player_revived" );
if ( isalive( self ) )
{
wait 0,1;
self setclientfieldtoplayer( "tomahawk_in_use", 1 );
self giveweapon( self.current_tomahawk_weapon );
self givemaxammo( self.current_tomahawk_weapon );
self set_player_tactical_grenade( self.current_tomahawk_weapon );
}
}
}

15
zm_prison_patch/readme.md
View File

@ -45,7 +45,20 @@ zm_prison_patch/maps/mp/zm_prison_sq_fc.gsc
zm_prison_patch/maps/mp/zm_prison_sq_final.gsc
zm_prison_patch/maps/mp/zm_prison_sq_wth.gsc
zm_prison_patch/maps/mp/zombies/_zm_afterlife.gsc
zm_prison_patch/maps/mp/zombies/_zm_ai_brutus.gsc
zm_prison_patch/maps/mp/zombies/_zm_craftables.gsc
zm_prison_patch/maps/mp/zombies/_zm_game_module_grief.gsc
zm_prison_patch/maps/mp/zombies/_zm_game_module_meat.gsc
zm_prison_patch/maps/mp/zombies/_zm_game_module_meat_utility.gsc
zm_prison_patch/maps/mp/zombies/_zm_game_module_utility.gsc
zm_prison_patch/maps/mp/zombies/_zm_magicbox_prison.gsc
zm_prison_patch/maps/mp/zombies/_zm_melee_weapon.gsc
zm_prison_patch/maps/mp/zombies/_zm_riotshield_prison.gsc
zm_prison_patch/maps/mp/zombies/_zm_weap_ballistic_knife.gsc
zm_prison_patch/maps/mp/zombies/_zm_weap_claymore.gsc
zm_prison_patch/maps/mp/zombies/_zm_weap_riotshield_prison.gsc
zm_prison_patch/maps/mp/zombies/_zm_weap_tomahawk.gsc
```