mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-10 10:47:58 -05:00
3760 lines
92 KiB
Plaintext
3760 lines
92 KiB
Plaintext
#include maps/mp/zombies/_zm_audio;
|
|
#include maps/mp/zm_transit_lava;
|
|
#include maps/mp/zombies/_zm_weap_emp_bomb;
|
|
#include maps/mp/zombies/_zm_buildables;
|
|
#include maps/mp/zombies/_zm_powerups;
|
|
#include maps/mp/zombies/_zm_laststand;
|
|
#include maps/mp/zombies/_zm_stats;
|
|
#include maps/mp/zombies/_zm_equipment;
|
|
#include maps/mp/zombies/_zm_ai_basic;
|
|
#include maps/mp/zombies/_zm_spawner;
|
|
#include maps/mp/zombies/_zm;
|
|
#include maps/mp/zm_transit_ambush;
|
|
#include maps/mp/zombies/_zm_zonemgr;
|
|
#include maps/mp/zm_transit_cling;
|
|
#include maps/mp/zm_transit_utility;
|
|
#include maps/mp/zombies/_zm_weapons;
|
|
#include maps/mp/zombies/_zm_utility;
|
|
#include maps/mp/_utility;
|
|
#include common_scripts/utility;
|
|
|
|
#using_animtree( "zombie_bus" );
|
|
#using_animtree( "zombie_bus_props" );
|
|
|
|
bussetup()
|
|
{
|
|
flag_init( "ladder_attached" );
|
|
flag_init( "catcher_attached" );
|
|
flag_init( "hatch_attached" );
|
|
self.immediatespeed = 0;
|
|
self.currentspeed = 0;
|
|
self.targetspeed = 0;
|
|
self.ismoving = 0;
|
|
self.isstopping = 0;
|
|
self.gas = 100;
|
|
self.accel = 10;
|
|
self.decel = 30;
|
|
self.radius = 88;
|
|
self.height = 240;
|
|
self.frontdist = 340;
|
|
self.backdist = 55;
|
|
self.floor = 36;
|
|
self.frontlocal = ( self.frontdist - ( self.radius / 2 ), 0, 0 );
|
|
self.backlocal = ( ( self.backdist * -1 ) + ( self.radius / 2 ), 0, 0 );
|
|
self.drivepath = 0;
|
|
self.zone = "zone_pri";
|
|
self.roadzone = self.zone;
|
|
self.zombiesinside = 0;
|
|
self.zombiesatwindow = 0;
|
|
self.zombiesonroof = 0;
|
|
self.numplayers = 0;
|
|
self.numplayerson = 0;
|
|
self.numplayersonroof = 0;
|
|
self.numplayersinsidebus = 0;
|
|
self.numplayersnear = 0;
|
|
self.numaliveplayersridingbus = 0;
|
|
self.numflattires = 0;
|
|
self.doorsclosed = 1;
|
|
self.doorsdisabledfortime = 0;
|
|
self.stalled = 0;
|
|
self.issafe = 1;
|
|
self.waittimeatdestination = 0;
|
|
self.gracetimeatdestination = 10;
|
|
self.path_blocking = 0;
|
|
self.chase_pos = self.origin;
|
|
self.chase_pos_time = 0;
|
|
self.istouchingignorewindowsvolume = 0;
|
|
level.zm_mantle_over_40_move_speed_override = ::zm_mantle_over_40_move_speed_override;
|
|
self setmovingplatformenabled( 1 );
|
|
self.supportsanimscripted = 1;
|
|
self setvehmaxspeed( 25 );
|
|
self useanimtree( -1 );
|
|
level.callbackactordamage = ::transit_actor_damage_override_wrapper;
|
|
self maps/mp/zm_transit_automaton::main();
|
|
maps/mp/zm_transit_cling::initializecling();
|
|
self maps/mp/zm_transit_openings::main();
|
|
self bus_upgrades();
|
|
self thread busplowsetup();
|
|
self buslightssetup();
|
|
self busdoorssetup();
|
|
self buspathblockersetup();
|
|
self bussetupbounds();
|
|
self bus_roof_watch();
|
|
self bus_set_nodes();
|
|
self bus_set_exit_triggers();
|
|
self thread bus_audio_setup();
|
|
level thread init_bus_door_anims();
|
|
level thread init_bus_props_anims();
|
|
self thread bususeanimtree();
|
|
self thread bususedoor( 0 );
|
|
self thread busidledoor();
|
|
self thread play_lava_audio();
|
|
self thread busthink();
|
|
self thread busopeningscene();
|
|
busschedule();
|
|
self thread busschedulethink();
|
|
self thread bus_bridge_speedcontrol();
|
|
self.door_nodes_linked = 1;
|
|
self thread bussetdoornodes( 0 );
|
|
}
|
|
|
|
bus_upgrades()
|
|
{
|
|
self.upgrades = [];
|
|
self.ladder_local_offset = ( 142, -50, 100 );
|
|
self.upgrades[ "Plow" ] = spawnstruct();
|
|
self.upgrades[ "Plow" ].installed = 0;
|
|
}
|
|
|
|
bus_debug()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
bus_forward = vectornormalize( anglesToForward( level.the_bus.angles ) );
|
|
ret = level.the_bus.origin + vectorScale( bus_forward, -144 );
|
|
groundpos = groundpos_ignore_water_new( ret + vectorScale( ( 0, 0, 1 ), 60 ) );
|
|
/#
|
|
debugstar( groundpos, 1000, ( 0, 0, 1 ) );
|
|
#/
|
|
wait 0,5;
|
|
}
|
|
}
|
|
|
|
bus_set_nodes()
|
|
{
|
|
self.front_door_inside = getnode( "front_door_inside_node", "targetname" );
|
|
self.front_door = getnode( "front_door_node", "targetname" );
|
|
self.back_door_inside1 = getnode( "back_door_inside_node1", "targetname" );
|
|
self.back_door_inside2 = getnode( "back_door_inside_node2", "targetname" );
|
|
self.back_door = getnode( "back_door_node", "targetname" );
|
|
self.exit_back_l = getnode( "exit_back_l_node", "targetname" );
|
|
self.exit_back_r = getnode( "exit_back_r_node", "targetname" );
|
|
}
|
|
|
|
bus_set_exit_triggers()
|
|
{
|
|
spawnflags = 9;
|
|
trigger_exit = [];
|
|
trigger_exit[ trigger_exit.size ] = spawn( "trigger_radius", self.front_door_inside.origin, spawnflags, 32, 72 );
|
|
trigger_exit[ trigger_exit.size ] = spawn( "trigger_radius", self.exit_back_l.origin, spawnflags, 32, 72 );
|
|
trigger_exit[ trigger_exit.size ] = spawn( "trigger_radius", self.exit_back_r.origin, spawnflags, 32, 72 );
|
|
tags = [];
|
|
tags[ 0 ] = "window_right_front_jnt";
|
|
tags[ 1 ] = "window_left_rear_jnt";
|
|
tags[ 2 ] = "window_right_rear_jnt";
|
|
i = 0;
|
|
while ( i < trigger_exit.size )
|
|
{
|
|
trigger = trigger_exit[ i ];
|
|
trigger enablelinkto();
|
|
trigger linkto( self, "", self worldtolocalcoords( trigger.origin ), ( 0, 0, 1 ) );
|
|
trigger setmovingplatformenabled( 1 );
|
|
trigger setteamfortrigger( level.zombie_team );
|
|
trigger.tag = tags[ i ];
|
|
trigger.substate = i;
|
|
self thread maps/mp/zm_transit_openings::busexitthink( trigger );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
onplayerconnect()
|
|
{
|
|
getent( "the_bus", "targetname" ) setclientfield( "the_bus_spawned", 1 );
|
|
}
|
|
|
|
zm_mantle_over_40_move_speed_override()
|
|
{
|
|
traversealias = "barrier_walk";
|
|
switch( self.zombie_move_speed )
|
|
{
|
|
case "chase_bus":
|
|
traversealias = "barrier_sprint";
|
|
break;
|
|
default:
|
|
/#
|
|
assertmsg( "Zombie move speed of '" + self.zombie_move_speed + "' is not supported for mantle_over_40." );
|
|
#/
|
|
}
|
|
return traversealias;
|
|
}
|
|
|
|
follow_path( node )
|
|
{
|
|
self endon( "death" );
|
|
/#
|
|
assert( isDefined( node ), "vehicle_path() called without a path" );
|
|
#/
|
|
self notify( "newpath" );
|
|
if ( isDefined( node ) )
|
|
{
|
|
self.attachedpath = node;
|
|
}
|
|
pathstart = self.attachedpath;
|
|
self.currentnode = self.attachedpath;
|
|
if ( !isDefined( pathstart ) )
|
|
{
|
|
return;
|
|
}
|
|
self attachpath( pathstart );
|
|
self startpath();
|
|
self endon( "newpath" );
|
|
nextpoint = pathstart;
|
|
while ( isDefined( nextpoint ) )
|
|
{
|
|
self waittill( "reached_node", nextpoint );
|
|
self.currentnode = nextpoint;
|
|
nextpoint notify( "trigger" );
|
|
if ( isDefined( nextpoint.script_noteworthy ) )
|
|
{
|
|
self notify( nextpoint.script_noteworthy );
|
|
self notify( "noteworthy" );
|
|
}
|
|
if ( isDefined( nextpoint.script_string ) )
|
|
{
|
|
if ( issubstr( nextpoint.script_string, "map_" ) )
|
|
{
|
|
level thread do_player_bus_location_vox( nextpoint.script_string );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
level thread do_automoton_vox( nextpoint.script_string );
|
|
}
|
|
}
|
|
waittillframeend;
|
|
}
|
|
}
|
|
|
|
busopeningscene()
|
|
{
|
|
startnode = getvehiclenode( "BUS_OPENING", "targetname" );
|
|
self.currentnode = startnode;
|
|
self thread follow_path( startnode );
|
|
self.targetspeed = 0;
|
|
flag_wait( "start_zombie_round_logic" );
|
|
self busstartmoving( 12 );
|
|
self busstartwait();
|
|
self waittill( "opening_end_path" );
|
|
self busstopmoving();
|
|
startnode = getvehiclenode( "BUS_START", "targetname" );
|
|
self.currentnode = startnode;
|
|
self thread follow_path( startnode );
|
|
while ( !flag( "OnPriDoorYar" ) && !flag( "OnPriDoorYar2" ) )
|
|
{
|
|
wait 0,5;
|
|
}
|
|
level.automaton notify( "start_head_think" );
|
|
self notify( "noteworthy" );
|
|
}
|
|
|
|
busschedule()
|
|
{
|
|
level.busschedule = busschedulecreate();
|
|
level.busschedule busscheduleadd( "depot", 0, randomintrange( 40, 180 ), 19, 15 );
|
|
level.busschedule busscheduleadd( "tunnel", 1, 10, 27, 5 );
|
|
level.busschedule busscheduleadd( "diner", 0, randomintrange( 40, 180 ), 18, 20 );
|
|
level.busschedule busscheduleadd( "forest", 1, 10, 18, 5 );
|
|
level.busschedule busscheduleadd( "farm", 0, randomintrange( 40, 180 ), 26, 25 );
|
|
level.busschedule busscheduleadd( "cornfields", 1, 10, 23, 10 );
|
|
level.busschedule busscheduleadd( "power", 0, randomintrange( 40, 180 ), 19, 15 );
|
|
level.busschedule busscheduleadd( "power2town", 1, 10, 26, 5 );
|
|
level.busschedule busscheduleadd( "town", 0, randomintrange( 40, 180 ), 18, 20 );
|
|
level.busschedule busscheduleadd( "bridge", 1, 10, 23, 10 );
|
|
/#
|
|
_a369 = level.busschedule.destinations;
|
|
index = getFirstArrayKey( _a369 );
|
|
while ( isDefined( index ) )
|
|
{
|
|
stop = _a369[ index ];
|
|
adddebugcommand( "devgui_cmd "Zombies:1/Bus:14/Teleport Bus:4/" + stop.name + ":" + index + "" "zombie_devgui teleport_bus " + stop.name + "\n" );
|
|
index = getNextArrayKey( _a369, index );
|
|
#/
|
|
}
|
|
}
|
|
|
|
busschedulethink()
|
|
{
|
|
self endon( "death" );
|
|
for ( ;; )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
self waittill( "noteworthy", noteworthy, noteworthynode );
|
|
zoneisempty = 1;
|
|
shouldremovegas = 0;
|
|
destinationindex = level.busschedule busschedulegetdestinationindex( noteworthy );
|
|
while ( !isDefined( destinationindex ) || !isDefined( noteworthynode ) )
|
|
{
|
|
/#
|
|
if ( isDefined( noteworthy ) )
|
|
{
|
|
println( "^2Bus Debug: Not A Valid Destination (" + noteworthy + ")" );
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
println( "^2Bus Debug: Not A Valid Destination" );
|
|
#/
|
|
}
|
|
}
|
|
self.destinationindex = destinationindex;
|
|
self.waittimeatdestination = level.busschedule busschedulegetmaxwaittimebeforeleaving( self.destinationindex );
|
|
self.currentnode = noteworthynode;
|
|
targetspeed = level.busschedule busschedulegetbusspeedleaving( self.destinationindex );
|
|
_a416 = level.zones;
|
|
_k416 = getFirstArrayKey( _a416 );
|
|
while ( isDefined( _k416 ) )
|
|
{
|
|
zone = _a416[ _k416 ];
|
|
if ( !isDefined( zone.volumes ) || zone.volumes.size == 0 )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
zonename = zone.volumes[ 0 ].targetname;
|
|
if ( self maps/mp/zombies/_zm_zonemgr::entity_in_zone( zonename ) )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Bus Is Touching Zone (" + zonename + ")" );
|
|
#/
|
|
self.zone = zonename;
|
|
zonestocheck = [];
|
|
zonestocheck[ zonestocheck.size ] = zonename;
|
|
switch( zonename )
|
|
{
|
|
case "zone_station_ext":
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_1";
|
|
zonestocheck[ zonestocheck.size ] = "zone_pri";
|
|
zonestocheck[ zonestocheck.size ] = "zone_pri2";
|
|
zonestocheck[ zonestocheck.size ] = "zone_amb_bridge";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_2b";
|
|
break;
|
|
case "zone_gas":
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_2";
|
|
zonestocheck[ zonestocheck.size ] = "zone_amb_tunnel";
|
|
zonestocheck[ zonestocheck.size ] = "zone_gar";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_diner";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_diner2";
|
|
zonestocheck[ zonestocheck.size ] = "zone_diner_roof";
|
|
zonestocheck[ zonestocheck.size ] = "zone_din";
|
|
zonestocheck[ zonestocheck.size ] = "zone_roadside_west";
|
|
zonestocheck[ zonestocheck.size ] = "zone_roadside_east";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_3";
|
|
break;
|
|
case "zone_far":
|
|
zonestocheck[ zonestocheck.size ] = "zone_amb_forest";
|
|
zonestocheck[ zonestocheck.size ] = "zone_far_ext";
|
|
zonestocheck[ zonestocheck.size ] = "zone_farm_house";
|
|
zonestocheck[ zonestocheck.size ] = "zone_brn";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_5";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_6";
|
|
break;
|
|
case "zone_pow":
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_6";
|
|
zonestocheck[ zonestocheck.size ] = "zone_amb_cornfield";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_7";
|
|
zonestocheck[ zonestocheck.size ] = "zone_pow_ext1";
|
|
zonestocheck[ zonestocheck.size ] = "zone_prr";
|
|
zonestocheck[ zonestocheck.size ] = "zone_pcr";
|
|
zonestocheck[ zonestocheck.size ] = "zone_pow_warehouse";
|
|
break;
|
|
case "zone_town_north":
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_8";
|
|
zonestocheck[ zonestocheck.size ] = "zone_amb_power2town";
|
|
zonestocheck[ zonestocheck.size ] = "zone_tbu";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_church";
|
|
zonestocheck[ zonestocheck.size ] = "zone_bar";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_east";
|
|
zonestocheck[ zonestocheck.size ] = "zone_tow";
|
|
zonestocheck[ zonestocheck.size ] = "zone_ban";
|
|
zonestocheck[ zonestocheck.size ] = "zone_ban_vault";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_west";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_west2";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_barber";
|
|
zonestocheck[ zonestocheck.size ] = "zone_town_south";
|
|
zonestocheck[ zonestocheck.size ] = "zone_trans_9";
|
|
break;
|
|
}
|
|
_a500 = zonestocheck;
|
|
_k500 = getFirstArrayKey( _a500 );
|
|
while ( isDefined( _k500 ) )
|
|
{
|
|
zone = _a500[ _k500 ];
|
|
if ( isDefined( zoneisempty ) && !zoneisempty )
|
|
{
|
|
}
|
|
else if ( maps/mp/zombies/_zm_zonemgr::player_in_zone( zone ) )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Player(s) Detected Near Bus In The Zone (" + zone + ")" );
|
|
#/
|
|
zoneisempty = 0;
|
|
}
|
|
_k500 = getNextArrayKey( _a500, _k500 );
|
|
}
|
|
if ( isDefined( zoneisempty ) && zoneisempty )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: No Player(s) Are In The Same Zone As Bus (" + zonename + ")" );
|
|
#/
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Player(s) Are In The Same Zone As Bus (" + zonename + ")" );
|
|
#/
|
|
}
|
|
}
|
|
}
|
|
_k416 = getNextArrayKey( _a416, _k416 );
|
|
}
|
|
if ( isDefined( shouldremovegas ) && shouldremovegas )
|
|
{
|
|
self busgasremove( level.busschedule busschedulegetbusgasusage( self.destinationindex ) );
|
|
}
|
|
while ( isDefined( zoneisempty ) && zoneisempty )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Bus Won't Consider Stopping Since Zone Is Empty." );
|
|
#/
|
|
self busstartmoving( targetspeed );
|
|
}
|
|
if ( isDefined( self.skip_next_destination ) && self.skip_next_destination )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Bus Won't Consider Stopping Since It's Skipping Destination." );
|
|
#/
|
|
self notify( "skipping_destination" );
|
|
self busstartmoving( targetspeed );
|
|
}
|
|
}
|
|
else /#
|
|
println( "^2Bus Debug: Bus Will Consider Stopping, Someone Is Nearby." );
|
|
#/
|
|
if ( level.busschedule busschedulegetisambushstop( self.destinationindex ) )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Arrived At Ambush Point." );
|
|
#/
|
|
if ( maps/mp/zm_transit_ambush::shouldstartambushround() && self.numplayersinsidebus != 0 )
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Ambush Triggering" );
|
|
#/
|
|
self busstopmoving( 1 );
|
|
level.nml_zone_name = "zone_amb_" + noteworthy;
|
|
thread maps/mp/zm_transit_ambush::ambushstartround();
|
|
thread automatonspeak( "inform", "out_of_gas" );
|
|
flag_waitopen( "ambush_round" );
|
|
shouldremovegas = 1;
|
|
thread automatonspeak( "inform", "refueled_gas" );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
/#
|
|
println( "^2Bus Debug: Over Ambush Point But No BreakDown Triggered." );
|
|
#/
|
|
}
|
|
}
|
|
}
|
|
else /#
|
|
println( "^2Bus Debug: Arrived At Destination" );
|
|
#/
|
|
self notify( "reached_destination" );
|
|
shouldremovegas = 1;
|
|
thread do_automaton_arrival_vox( noteworthy );
|
|
if ( noteworthy != "diner" || noteworthy == "town" && noteworthy == "power" )
|
|
{
|
|
self busstopmoving( 1 );
|
|
if ( noteworthy == "diner" )
|
|
{
|
|
self bussetdineropenings( 0 );
|
|
}
|
|
else if ( noteworthy == "power" )
|
|
{
|
|
self bussetpoweropenings( 0 );
|
|
}
|
|
else
|
|
{
|
|
if ( noteworthy == "town" )
|
|
{
|
|
self bussettownopenings( 0 );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self busstopmoving();
|
|
}
|
|
self thread busscheduledepartearly();
|
|
waittimeatdestination = self.waittimeatdestination;
|
|
/#
|
|
if ( getDvarInt( #"1CF9CD76" ) != 0 )
|
|
{
|
|
println( "^2Bus Debug: Using custom wait time of: " + getDvarInt( #"1CF9CD76" ) + " seconds." );
|
|
waittimeatdestination = getDvarInt( #"1CF9CD76" );
|
|
}
|
|
if ( getDvarInt( "zombie_cheat" ) > 0 )
|
|
{
|
|
thread busshowleavinghud( waittimeatdestination );
|
|
#/
|
|
}
|
|
self waittill_any_timeout( waittimeatdestination, "depart_early" );
|
|
/#
|
|
while ( getDvarInt( #"F7C16264" ) )
|
|
{
|
|
wait 0,1;
|
|
#/
|
|
}
|
|
self notify( "ready_to_depart" );
|
|
self thread buslightsflash();
|
|
self thread buslightsignal( "turn_signal_left" );
|
|
thread automatonspeak( "inform", "leaving_warning" );
|
|
self thread play_bus_audio( "grace" );
|
|
wait self.gracetimeatdestination;
|
|
thread automatonspeak( "inform", "leaving" );
|
|
self.accel = 1;
|
|
self busstartmoving( targetspeed );
|
|
self notify( "departing" );
|
|
self setclientfield( "bus_flashing_lights", 0 );
|
|
}
|
|
}
|
|
|
|
busscheduledepartearly()
|
|
{
|
|
self endon( "ready_to_depart" );
|
|
wait 15;
|
|
triggerbuswait = 0;
|
|
while ( 1 )
|
|
{
|
|
while ( isDefined( self.disabled_by_emp ) && self.disabled_by_emp )
|
|
{
|
|
wait 1;
|
|
}
|
|
players = get_players();
|
|
nearbyplayers = 0;
|
|
readytoleaveplayers = 0;
|
|
_a717 = players;
|
|
_k717 = getFirstArrayKey( _a717 );
|
|
while ( isDefined( _k717 ) )
|
|
{
|
|
player = _a717[ _k717 ];
|
|
if ( !is_player_valid( player ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( distancesquared( self.origin, player.origin ) < 262144 )
|
|
{
|
|
nearbyplayers++;
|
|
if ( player.isonbus )
|
|
{
|
|
readytoleaveplayers++;
|
|
}
|
|
}
|
|
}
|
|
_k717 = getNextArrayKey( _a717, _k717 );
|
|
}
|
|
if ( readytoleaveplayers != 0 && readytoleaveplayers == nearbyplayers )
|
|
{
|
|
if ( !triggerbuswait )
|
|
{
|
|
wait 5;
|
|
triggerbuswait = 1;
|
|
}
|
|
else
|
|
{
|
|
self notify( "depart_early" );
|
|
/#
|
|
if ( isDefined( level.bus_leave_hud ) )
|
|
{
|
|
level.bus_leave_hud.alpha = 0;
|
|
#/
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( triggerbuswait )
|
|
{
|
|
triggerbuswait = 0;
|
|
}
|
|
}
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
busschedulecreate()
|
|
{
|
|
schedule = spawnstruct();
|
|
schedule.destinations = [];
|
|
return schedule;
|
|
}
|
|
|
|
busscheduleadd( stopname, isambush, maxwaittimebeforeleaving, busspeedleaving, gasusage )
|
|
{
|
|
/#
|
|
assert( isDefined( stopname ) );
|
|
#/
|
|
/#
|
|
assert( isDefined( isambush ) );
|
|
#/
|
|
/#
|
|
assert( isDefined( maxwaittimebeforeleaving ) );
|
|
#/
|
|
/#
|
|
assert( isDefined( busspeedleaving ) );
|
|
#/
|
|
destinationindex = self.destinations.size;
|
|
self.destinations[ destinationindex ] = spawnstruct();
|
|
self.destinations[ destinationindex ].name = stopname;
|
|
self.destinations[ destinationindex ].isambush = isambush;
|
|
self.destinations[ destinationindex ].maxwaittimebeforeleaving = maxwaittimebeforeleaving;
|
|
self.destinations[ destinationindex ].busspeedleaving = busspeedleaving;
|
|
self.destinations[ destinationindex ].gasusage = gasusage;
|
|
}
|
|
|
|
busschedulegetdestinationindex( stopname )
|
|
{
|
|
_a800 = self.destinations;
|
|
index = getFirstArrayKey( _a800 );
|
|
while ( isDefined( index ) )
|
|
{
|
|
stop = _a800[ index ];
|
|
if ( stop.name != stopname )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
return index;
|
|
}
|
|
index = getNextArrayKey( _a800, index );
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
busschedulegetstopname( destinationindex )
|
|
{
|
|
return self.destinations[ destinationindex ].name;
|
|
}
|
|
|
|
busschedulegetisambushstop( destinationindex )
|
|
{
|
|
return self.destinations[ destinationindex ].isambush;
|
|
}
|
|
|
|
busschedulegetmaxwaittimebeforeleaving( destinationindex )
|
|
{
|
|
return self.destinations[ destinationindex ].maxwaittimebeforeleaving;
|
|
}
|
|
|
|
busschedulegetbusspeedleaving( destinationindex )
|
|
{
|
|
return self.destinations[ destinationindex ].busspeedleaving;
|
|
}
|
|
|
|
busschedulegetbusgasusage( destinationindex )
|
|
{
|
|
return self.destinations[ destinationindex ].gasusage;
|
|
}
|
|
|
|
transit_actor_damage_override_wrapper( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
|
|
{
|
|
if ( damage > self.health && isDefined( self.isonbus ) && self.isonbus )
|
|
{
|
|
ret = self maps/mp/zombies/_zm::actor_damage_override_wrapper( inflictor, attacker, self.health - 1, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
|
|
self zombie_in_bus_death_animscript_callback( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
|
|
return ret;
|
|
}
|
|
return self maps/mp/zombies/_zm::actor_damage_override_wrapper( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex );
|
|
}
|
|
|
|
zombie_in_bus_death_animscript_callback( inflictor, attacker, damage, flags, meansofdeath, weapon, vpoint, vdir, shitloc, psoffsettime, boneindex )
|
|
{
|
|
if ( isDefined( self ) && isDefined( self.opening ) )
|
|
{
|
|
self.opening.zombie = undefined;
|
|
}
|
|
if ( isDefined( self.exploding ) && self.exploding )
|
|
{
|
|
self notify( "killanimscript" );
|
|
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
|
|
return 1;
|
|
}
|
|
if ( isDefined( self ) && isDefined( self.isonbus ) && !self.isonbus && isDefined( self.onbuswindow ) && !self.onbuswindow && isDefined( self.climbing_into_bus ) || self.climbing_into_bus && isDefined( self.climbing_onto_bus ) && self.climbing_onto_bus )
|
|
{
|
|
level maps/mp/zombies/_zm_spawner::zombie_death_points( self.origin, meansofdeath, shitloc, attacker, self );
|
|
launchvector = undefined;
|
|
if ( isDefined( self.onbuswindow ) && self.onbuswindow && isDefined( self.climbing_into_bus ) || !self.climbing_into_bus && isDefined( self.climbing_onto_bus ) && self.climbing_onto_bus )
|
|
{
|
|
fwd = anglesToForward( flat_angle( self.angles * -1 ) );
|
|
my_velocity = vectorScale( fwd, 50 );
|
|
launchvector = ( my_velocity[ 0 ], my_velocity[ 1 ], 20 );
|
|
}
|
|
self thread maps/mp/zombies/_zm_spawner::zombie_ragdoll_then_explode( launchvector, attacker );
|
|
self notify( "killanimscript" );
|
|
self maps/mp/zombies/_zm_spawner::reset_attack_spot();
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
debug_busnear()
|
|
{
|
|
/#
|
|
if ( getDvarInt( #"29B9C39F" ) > 0 )
|
|
{
|
|
zombie_front_dist = 1200;
|
|
zombie_side_dist = self.radius + 50;
|
|
zombie_inside_dist = 240;
|
|
zombie_plow_dist = 340;
|
|
forward_dir = anglesToForward( self.angles );
|
|
forward_proj = vectorScale( forward_dir, zombie_front_dist );
|
|
forward_pos = self.origin + forward_proj;
|
|
backward_proj = vectorScale( forward_dir, zombie_inside_dist * -1 );
|
|
backward_pos = self.origin + backward_proj;
|
|
bus_front_dist = 225;
|
|
bus_back_dist = 235;
|
|
bus_width = 120;
|
|
side_dir = anglesToForward( self.angles + vectorScale( ( 0, 0, 1 ), 90 ) );
|
|
side_proj = vectorScale( side_dir, zombie_side_dist );
|
|
inside_pos = self.origin + vectorScale( forward_dir, zombie_inside_dist );
|
|
plow_pos = self.origin + vectorScale( forward_dir, zombie_plow_dist );
|
|
line( backward_pos, forward_pos, ( 0, 0, 1 ), 1, 0, 2 );
|
|
line( inside_pos - side_proj, inside_pos + side_proj, ( 0, 0, 1 ), 1, 0, 2 );
|
|
line( plow_pos - side_proj, plow_pos + side_proj, ( 0, 0, 1 ), 1, 0, 2 );
|
|
#/
|
|
}
|
|
}
|
|
|
|
debug_zombieonbus( zombie )
|
|
{
|
|
/#
|
|
if ( getDvarInt( #"29B9C39F" ) > 0 )
|
|
{
|
|
zombie_front_dist = 1200;
|
|
zombie_side_dist = self.radius + 50;
|
|
zombie_inside_dist = 240;
|
|
zombie_plow_dist = 340;
|
|
forward_dir = anglesToForward( self.angles );
|
|
forward_proj = vectorScale( forward_dir, zombie_front_dist );
|
|
forward_pos = self.origin + forward_proj;
|
|
backward_proj = vectorScale( forward_dir, zombie_inside_dist * -1 );
|
|
backward_pos = self.origin + backward_proj;
|
|
zombie_origin = zombie.origin;
|
|
zombie_origin_proj = pointonsegmentnearesttopoint( backward_pos, forward_pos, zombie_origin );
|
|
if ( isDefined( zombie.isonbus ) && zombie.isonbus )
|
|
{
|
|
line( zombie_origin_proj, zombie_origin, ( 0, 0, 1 ), 1, 0, 2 );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
line( zombie_origin_proj, zombie_origin, ( 0, 0, 1 ), 1, 0, 2 );
|
|
#/
|
|
}
|
|
}
|
|
}
|
|
|
|
busupdatenearzombies()
|
|
{
|
|
level endon( "end_game" );
|
|
audiozomonbus_old = 0;
|
|
audiozomonbus_new = 0;
|
|
zombiesatwindow_old = 0;
|
|
zombiesatwindow_new = 0;
|
|
zombiesonroof_old = 0;
|
|
zombiesonroof_new = 0;
|
|
zombiesclimbing_new = 0;
|
|
zombiesclimbing_old = 0;
|
|
while ( 1 )
|
|
{
|
|
self.zombiesinside = 0;
|
|
self.zombies_climbing = 0;
|
|
self.zombies_chasing_bus = 0;
|
|
self.zombiesatwindow = 0;
|
|
self.zombiesonroof = 0;
|
|
self.zombies_near_bus = 0;
|
|
/#
|
|
self debug_busnear();
|
|
#/
|
|
zombies = get_round_enemy_array();
|
|
while ( isDefined( zombies ) )
|
|
{
|
|
i = 0;
|
|
while ( i < zombies.size )
|
|
{
|
|
if ( !isDefined( zombies[ i ] ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else zombie = zombies[ i ];
|
|
if ( isDefined( zombie.completed_emerging_into_playable_area ) && !zombie.completed_emerging_into_playable_area )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( zombie.isscreecher ) || zombie.isscreecher && isDefined( zombie.is_avogadro ) && zombie.is_avogadro )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( !isDefined( zombie.isonbus ) )
|
|
{
|
|
zombie.isonbus = 0;
|
|
}
|
|
zombie.ground_ent = zombie getgroundent();
|
|
if ( isDefined( zombie.ground_ent ) )
|
|
{
|
|
if ( isDefined( zombie.ground_ent.isonbus ) && zombie.ground_ent.isonbus )
|
|
{
|
|
zombie.isonbus = 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
groundname = zombie.ground_ent.targetname;
|
|
if ( isDefined( groundname ) )
|
|
{
|
|
if ( level.the_bus.targetname != groundname || groundname == "bus_path_blocker" && groundname == "hatch_clip" )
|
|
{
|
|
zombie.dont_throw_gib = 1;
|
|
zombie.isonbus = 1;
|
|
if ( isDefined( zombie.entering_bus ) && zombie.entering_bus )
|
|
{
|
|
zombie.entering_bus = undefined;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
zombie.isonbus = 0;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
zombie.isonbus = 0;
|
|
}
|
|
}
|
|
}
|
|
if ( isDefined( zombie.entering_bus ) && zombie.entering_bus )
|
|
{
|
|
zombie.isonbus = 1;
|
|
}
|
|
zombie.isonbusroof = zombie _entityisonroof();
|
|
if ( isDefined( zombie.isonbusroof ) && zombie.isonbusroof )
|
|
{
|
|
zombie thread play_zmbonbusroof_sound();
|
|
}
|
|
if ( isDefined( zombie.isonbus ) && zombie.isonbus )
|
|
{
|
|
if ( isDefined( zombie.entering_bus ) && !zombie.entering_bus )
|
|
{
|
|
if ( !isDefined( zombie.onbusfunc ) )
|
|
{
|
|
zombie.onbusfunc = ::maps/mp/zm_transit_openings::zombiemoveonbus;
|
|
zombie thread [[ zombie.onbusfunc ]]();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( zombie.onbusfunc ) )
|
|
{
|
|
zombie.onbusfunc = undefined;
|
|
zombie notify( "endOnBus" );
|
|
zombie animmode( "normal" );
|
|
zombie orientmode( "face enemy" );
|
|
zombie.forcemovementscriptstate = 0;
|
|
zombie thread maps/mp/zombies/_zm_ai_basic::find_flesh();
|
|
}
|
|
}
|
|
if ( isDefined( zombie.isonbus ) && zombie.isonbus )
|
|
{
|
|
self.zombiesinside++;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( zombie.onbuswindow ) && zombie.onbuswindow )
|
|
{
|
|
self.zombiesatwindow++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( zombie.isonbusroof ) && zombie.isonbusroof )
|
|
{
|
|
self.zombiesonroof++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( zombie.climbing_into_bus ) && zombie.climbing_into_bus )
|
|
{
|
|
self.zombies_climbing++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( distancesquared( zombie.origin, self.origin ) < 122500 )
|
|
{
|
|
if ( zombie.zombie_move_speed == "chase_bus" )
|
|
{
|
|
self.zombies_chasing_bus++;
|
|
}
|
|
self.zombies_near_bus++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( self.zombies_near_bus && !self.zombiesinside && !self.zombiesatwindow && !self.zombies_climbing & !self.zombiesonroof )
|
|
{
|
|
level.bus_driver_focused = 1;
|
|
}
|
|
else
|
|
{
|
|
level.bus_driver_focused = 0;
|
|
}
|
|
if ( !self.zombiesinside && !self.zombiesatwindow && !self.zombies_climbing || self.zombiesonroof && self.zombies_near_bus )
|
|
{
|
|
level.bus_zombie_danger = 1;
|
|
}
|
|
else
|
|
{
|
|
level.bus_zombie_danger = 0;
|
|
}
|
|
if ( self.ismoving && self getspeedmph() > 5 )
|
|
{
|
|
if ( isDefined( self.plowtrigger ) )
|
|
{
|
|
if ( zombie istouching( self.plowtrigger ) )
|
|
{
|
|
/#
|
|
println( "^2Transit Debug: Plow killing zombie." );
|
|
#/
|
|
self thread busplowkillzombie( zombie );
|
|
i++;
|
|
continue;
|
|
}
|
|
else }
|
|
else if ( isDefined( self.bussmashtrigger ) )
|
|
{
|
|
if ( !isDefined( zombie.opening ) && isDefined( zombie.isonbus ) && !zombie.isonbus && zombie istouching( self.bussmashtrigger ) )
|
|
{
|
|
/#
|
|
println( "^2Transit Debug: Plow pushing zombie." );
|
|
#/
|
|
self thread buspushzombie( zombie, self.bussmashtrigger );
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self update_zombie_move_speed( zombie );
|
|
/#
|
|
self debug_zombieonbus( zombie );
|
|
#/
|
|
if ( ( i % 4 ) == 3 )
|
|
{
|
|
wait 0,05;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
audiozomonbus_new = self.zombiesinside;
|
|
zombiesatwindow_new = self.zombiesatwindow;
|
|
zombiesonroof_new = self.zombiesonroof;
|
|
zombiesclimbing_new = self.zombies_climbing;
|
|
self zomonbusvox( audiozomonbus_old, audiozomonbus_new );
|
|
self zomatwindowvox( zombiesatwindow_old, zombiesatwindow_new );
|
|
self zomonroofvox( zombiesonroof_old, zombiesonroof_new );
|
|
self zomclimbingvox( zombiesclimbing_old, zombiesclimbing_new );
|
|
self zomchasingvox();
|
|
audiozomonbus_old = audiozomonbus_new;
|
|
zombiesatwindow_old = zombiesatwindow_new;
|
|
zombiesonroof_old = zombiesonroof_new;
|
|
zombiesclimbing_old = zombiesclimbing_new;
|
|
wait 0,05;
|
|
}
|
|
}
|
|
|
|
entity_is_on_bus( use_cache )
|
|
{
|
|
if ( isDefined( self.isonbus ) && isDefined( use_cache ) && use_cache )
|
|
{
|
|
return self.isonbus;
|
|
}
|
|
self.isonbus = 0;
|
|
self.ground_ent = self getgroundent();
|
|
if ( isDefined( self.ground_ent ) )
|
|
{
|
|
groundname = self.ground_ent.targetname;
|
|
if ( isDefined( groundname ) )
|
|
{
|
|
if ( level.the_bus.targetname != groundname || groundname == "bus_path_blocker" && groundname == "hatch_clip" )
|
|
{
|
|
self.isonbus = 1;
|
|
}
|
|
}
|
|
}
|
|
return self.isonbus;
|
|
}
|
|
|
|
busupdatechasers()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
while ( isDefined( self.ismoving ) && self.ismoving && isDefined( self.exceed_chase_speed ) && self.exceed_chase_speed )
|
|
{
|
|
max_speed = 0;
|
|
zombies = getaiarray( level.zombie_team );
|
|
slow_zombies = [];
|
|
_a1238 = zombies;
|
|
_k1238 = getFirstArrayKey( _a1238 );
|
|
while ( isDefined( _k1238 ) )
|
|
{
|
|
zombie = _a1238[ _k1238 ];
|
|
if ( isDefined( zombie.zombie_move_speed ) && zombie.zombie_move_speed == "chase_bus" && isDefined( zombie.close_to_bus ) && !zombie.close_to_bus && !isDefined( zombie.opening ) )
|
|
{
|
|
substate = zombie getanimsubstatefromasd();
|
|
if ( substate == 6 )
|
|
{
|
|
max_speed++;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
slow_zombies[ slow_zombies.size ] = zombie;
|
|
}
|
|
}
|
|
_k1238 = getNextArrayKey( _a1238, _k1238 );
|
|
}
|
|
while ( max_speed < 3 )
|
|
{
|
|
speed_up = 3 - max_speed;
|
|
if ( speed_up > slow_zombies.size )
|
|
{
|
|
speed_up = slow_zombies.size;
|
|
}
|
|
_a1263 = slow_zombies;
|
|
_k1263 = getFirstArrayKey( _a1263 );
|
|
while ( isDefined( _k1263 ) )
|
|
{
|
|
zombie = _a1263[ _k1263 ];
|
|
zombie setanimstatefromasd( "zm_move_chase_bus", 6 );
|
|
speed_up--;
|
|
|
|
if ( speed_up <= 0 )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_k1263 = getNextArrayKey( _a1263, _k1263 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
wait 0,25;
|
|
}
|
|
}
|
|
|
|
play_zmbonbusroof_sound()
|
|
{
|
|
if ( isDefined( self.sndbusroofplayed ) && !self.sndbusroofplayed )
|
|
{
|
|
self playsound( "fly_step_zombie_bus" );
|
|
self.sndbusroofplayed = 1;
|
|
}
|
|
}
|
|
|
|
object_is_on_bus()
|
|
{
|
|
ground_ent = self getgroundent();
|
|
depth = 0;
|
|
while ( isDefined( ground_ent ) && depth < 2 )
|
|
{
|
|
groundname = ground_ent.targetname;
|
|
if ( isDefined( groundname ) )
|
|
{
|
|
if ( level.the_bus.targetname != groundname || groundname == "bus_path_blocker" && groundname == "hatch_clip" )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
new_ground_ent = ground_ent getgroundent();
|
|
if ( !isDefined( new_ground_ent ) || new_ground_ent == ground_ent )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
ground_ent = new_ground_ent;
|
|
depth++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
busupdatenearequipment()
|
|
{
|
|
equipment = maps/mp/zombies/_zm_equipment::get_destructible_equipment_list();
|
|
i = 0;
|
|
while ( i < equipment.size )
|
|
{
|
|
item = equipment[ i ];
|
|
if ( !isDefined( item ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( isDefined( item.isonbus ) && item.isonbus )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( self.bussmashtrigger ) && item istouching( self.bussmashtrigger ) )
|
|
{
|
|
item maps/mp/zombies/_zm_equipment::item_damage( 10000 );
|
|
/#
|
|
println( "^2Bus hit an item." );
|
|
#/
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
update_zombie_move_speed( zombie )
|
|
{
|
|
if ( isDefined( zombie.completed_emerging_into_playable_area ) && !zombie.completed_emerging_into_playable_area )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( zombie.normal_move_speed ) )
|
|
{
|
|
zombie.normal_move_speed = 1;
|
|
}
|
|
if ( !zombie.has_legs )
|
|
{
|
|
return;
|
|
}
|
|
if ( isDefined( zombie.favoriteenemy ) )
|
|
{
|
|
if ( isDefined( zombie.favoriteenemy.isonbus ) )
|
|
{
|
|
enemyonbus = zombie.favoriteenemy.isonbus;
|
|
}
|
|
}
|
|
if ( isDefined( zombie.isonbus ) && zombie.isonbus )
|
|
{
|
|
if ( zombie.normal_move_speed )
|
|
{
|
|
zombie.normal_move_speed = 0;
|
|
}
|
|
walk_state = zombie.zombie_move_speed;
|
|
if ( self.ismoving && isDefined( self.disabled_by_emp ) && !self.disabled_by_emp )
|
|
{
|
|
if ( zombie.zombie_move_speed != "bus_walk" )
|
|
{
|
|
walk_state = "bus_walk";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( zombie.zombie_move_speed != "walk" )
|
|
{
|
|
walk_state = "walk";
|
|
}
|
|
}
|
|
if ( zombie.zombie_move_speed != walk_state )
|
|
{
|
|
zombie set_zombie_run_cycle( walk_state );
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ( enemyonbus && !isDefined( zombie.opening ) )
|
|
{
|
|
if ( self should_chase_bus( zombie ) )
|
|
{
|
|
if ( zombie.zombie_move_speed != "chase_bus" )
|
|
{
|
|
zombie.normal_move_speed = 0;
|
|
zombie set_zombie_run_cycle( "chase_bus" );
|
|
zombie.crawl_anim_override = ::normal_move_speed;
|
|
}
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if ( zombie.zombie_move_speed == "chase_bus" )
|
|
{
|
|
dist_sq = distance2dsquared( self.origin, level.the_bus.origin );
|
|
if ( dist_sq > 90000 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( !zombie.normal_move_speed )
|
|
{
|
|
zombie normal_move_speed();
|
|
}
|
|
}
|
|
|
|
should_chase_bus( zombie )
|
|
{
|
|
if ( !self.ismoving )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( self.exceed_chase_speed ) && !self.exceed_chase_speed )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( self.disabled_by_emp ) && self.disabled_by_emp )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( zombie.is_inert ) && zombie.is_inert )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( zombie.is_traversing ) && zombie.is_traversing )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !flag( "OnPriDoorYar2" ) )
|
|
{
|
|
if ( !flag( "OnPriDoorYar" ) || !flag( "OnPriDoorYar3" ) )
|
|
{
|
|
if ( zombie maps/mp/zombies/_zm_zonemgr::entity_in_zone( "zone_pri" ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
normal_move_speed()
|
|
{
|
|
self.normal_move_speed = 1;
|
|
self set_zombie_run_cycle();
|
|
}
|
|
|
|
plowhudfade( text )
|
|
{
|
|
level endon( "plowHudUpdate" );
|
|
fadein = 0,1;
|
|
fadeout = 3;
|
|
level.hudbuscount fadeovertime( fadein );
|
|
level.hudbuscount.alpha = 1;
|
|
level.hudbuscount settext( text );
|
|
wait fadein;
|
|
level.hudbuscount fadeovertime( 3 );
|
|
level.hudbuscount.alpha = 0;
|
|
}
|
|
|
|
busupdatespeed()
|
|
{
|
|
targetspeed = self.targetspeed;
|
|
if ( is_false( self.ismoving ) )
|
|
{
|
|
targetspeed = 0;
|
|
}
|
|
if ( isDefined( self.forcestop ) && self.forcestop )
|
|
{
|
|
targetspeed = 0;
|
|
}
|
|
if ( isDefined( self.stalled ) && self.stalled )
|
|
{
|
|
targetspeed = 0;
|
|
}
|
|
if ( isDefined( self.disabled_by_emp ) && self.disabled_by_emp )
|
|
{
|
|
targetspeed = 0;
|
|
}
|
|
if ( targetspeed < 0 )
|
|
{
|
|
targetspeed = 0;
|
|
}
|
|
if ( self.currentspeed != targetspeed )
|
|
{
|
|
self.currentspeed = targetspeed;
|
|
if ( isDefined( self.immediatespeed ) && self.immediatespeed )
|
|
{
|
|
self setspeedimmediate( targetspeed, self.accel, self.decel );
|
|
self.immediatespeed = undefined;
|
|
}
|
|
else
|
|
{
|
|
if ( targetspeed == 0 )
|
|
{
|
|
self setspeed( 0, 30, 30 );
|
|
}
|
|
else
|
|
{
|
|
self setspeed( targetspeed, self.accel, self.decel );
|
|
}
|
|
}
|
|
}
|
|
/#
|
|
if ( getDvarInt( #"6152C9EA" ) > 0 )
|
|
{
|
|
msgorigin = self localtoworldcoords( vectorScale( ( 0, 0, 1 ), 100 ) );
|
|
msgtext = "speed " + self getspeedmph();
|
|
print3d( msgorigin, msgtext, ( 0, 0, 1 ), 1, 0,5, 2 );
|
|
#/
|
|
}
|
|
}
|
|
|
|
bus_power_off()
|
|
{
|
|
self endon( "power_on" );
|
|
self.pre_disabled_by_emp = 1;
|
|
self thread play_bus_audio( "emp" );
|
|
self buslightsdisableall();
|
|
self notify( "pre_power_off" );
|
|
while ( isDefined( self.ismoving ) && self.ismoving )
|
|
{
|
|
while ( isDefined( self.istouchingignorewindowsvolume ) && self.istouchingignorewindowsvolume )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
}
|
|
self.disabled_by_emp = 1;
|
|
self thread buspathblockerenable();
|
|
self notify( "power_off" );
|
|
}
|
|
|
|
bus_power_on()
|
|
{
|
|
self buslightsenableall();
|
|
wait 2;
|
|
self.pre_disabled_by_emp = 0;
|
|
self.disabled_by_emp = 0;
|
|
self thread buspathblockerdisable();
|
|
self notify( "power_on" );
|
|
wait 0,25;
|
|
self thread play_bus_audio( "leaving" );
|
|
wait 3;
|
|
level.automaton automatonspeak( "inform", "doors_open" );
|
|
}
|
|
|
|
bus_disabled_by_emp( disable_time )
|
|
{
|
|
self bus_power_off();
|
|
wait ( disable_time - 2 );
|
|
self bus_power_on();
|
|
}
|
|
|
|
busispointinside( entitypos )
|
|
{
|
|
entityposinbus = pointonsegmentnearesttopoint( self.frontworld, self.backworld, entitypos );
|
|
entityposzdelta = entitypos[ 2 ] - entityposinbus[ 2 ];
|
|
entityposdist2 = distance2dsquared( entitypos, entityposinbus );
|
|
if ( entityposdist2 > ( self.radius * self.radius ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
busupdateignorewindows()
|
|
{
|
|
if ( self getspeed() <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( level.bus_ignore_windows ) )
|
|
{
|
|
level.bus_ignore_windows = getentarray( "bus_ignore_windows", "targetname" );
|
|
}
|
|
ignorewindowsvolume = undefined;
|
|
istouchingignorewindowsvolume = 0;
|
|
while ( isDefined( level.bus_ignore_windows ) && level.bus_ignore_windows.size > 0 )
|
|
{
|
|
_a1639 = level.bus_ignore_windows;
|
|
_k1639 = getFirstArrayKey( _a1639 );
|
|
while ( isDefined( _k1639 ) )
|
|
{
|
|
volume = _a1639[ _k1639 ];
|
|
if ( isDefined( istouchingignorewindowsvolume ) && istouchingignorewindowsvolume )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( self istouching( volume ) )
|
|
{
|
|
ignorewindowsvolume = volume;
|
|
istouchingignorewindowsvolume = 1;
|
|
}
|
|
}
|
|
_k1639 = getNextArrayKey( _a1639, _k1639 );
|
|
}
|
|
}
|
|
self.ignorewindowsvolume = ignorewindowsvolume;
|
|
self.istouchingignorewindowsvolume = istouchingignorewindowsvolume;
|
|
}
|
|
|
|
zombie_surf( zombie )
|
|
{
|
|
if ( !isDefined( self.zombie_surf_count ) )
|
|
{
|
|
self.zombie_surf_count = 0;
|
|
}
|
|
damage = int( self.maxhealth / 10 );
|
|
if ( isDefined( zombie.isonbusroof ) && zombie.isonbusroof && ( self.origin[ 2 ] - zombie.origin[ 2 ] ) >= 35 && isDefined( zombie.climbing_onto_bus ) && !zombie.climbing_onto_bus && isDefined( self.hatch_jump ) && !self.hatch_jump )
|
|
{
|
|
damage = int( self.maxhealth / 8 );
|
|
self.zombie_surf_count++;
|
|
if ( isDefined( level.zombie_surfing_kills ) && level.zombie_surfing_kills && self.zombie_surf_count > level.zombie_surfing_kill_count )
|
|
{
|
|
self maps/mp/zombies/_zm_stats::increment_client_stat( "cheat_total", 0 );
|
|
self playlocalsound( level.zmb_laugh_alias );
|
|
self dodamage( self.maxhealth + 1, zombie.origin );
|
|
}
|
|
}
|
|
self applyknockback( damage, ( 0, 0, 1 ) );
|
|
}
|
|
|
|
busupdateplayers()
|
|
{
|
|
level endon( "end_game" );
|
|
while ( 1 )
|
|
{
|
|
self.numplayers = 0;
|
|
self.numplayerson = 0;
|
|
self.numplayersonroof = 0;
|
|
self.numplayersinsidebus = 0;
|
|
self.numplayersnear = 0;
|
|
self.numaliveplayersridingbus = 0;
|
|
self.frontworld = self localtoworldcoords( self.frontlocal );
|
|
self.backworld = self localtoworldcoords( self.backlocal );
|
|
self.bus_riders_alive = [];
|
|
/#
|
|
if ( getDvarInt( #"10AC3C99" ) > 0 )
|
|
{
|
|
line( self.frontworld + ( 0, 0, self.floor ), self.backworld + ( 0, 0, self.floor ), ( 0, 0, 1 ), 1, 0, 4 );
|
|
line( self.frontworld + ( 0, 0, self.floor ), self.frontworld + ( 0, 0, self.height ), ( 0, 0, 1 ), 1, 0, 4 );
|
|
circle( self.backworld + ( 0, 0, self.floor ), self.radius, ( 0, 0, 1 ), 0, 1, 4 );
|
|
circle( self.frontworld + ( 0, 0, self.floor ), self.radius, ( 0, 0, 1 ), 0, 1, 4 );
|
|
#/
|
|
}
|
|
players = get_players();
|
|
_a1717 = players;
|
|
_k1717 = getFirstArrayKey( _a1717 );
|
|
while ( isDefined( _k1717 ) )
|
|
{
|
|
player = _a1717[ _k1717 ];
|
|
if ( !isalive( player ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
self.numplayers++;
|
|
if ( distance2d( player.origin, self.origin ) < 1700 )
|
|
{
|
|
self.numplayersnear++;
|
|
}
|
|
playerisinbus = 0;
|
|
mover = player getmoverent();
|
|
if ( isDefined( mover ) )
|
|
{
|
|
if ( isDefined( mover.targetname ) )
|
|
{
|
|
if ( mover.targetname != "the_bus" && mover.targetname != "bus_path_blocker" || mover.targetname == "hatch_clip" && mover.targetname == "ladder_mantle" )
|
|
{
|
|
playerisinbus = 1;
|
|
}
|
|
}
|
|
if ( isDefined( mover.equipname ) )
|
|
{
|
|
if ( mover.equipname == "riotshield_zm" )
|
|
{
|
|
if ( isDefined( mover.isonbus ) && mover.isonbus )
|
|
{
|
|
playerisinbus = 1;
|
|
}
|
|
}
|
|
}
|
|
if ( isDefined( mover.is_zombie ) && mover.is_zombie && isDefined( mover.isonbus ) && mover.isonbus )
|
|
{
|
|
playerisinbus = 1;
|
|
}
|
|
}
|
|
if ( playerisinbus )
|
|
{
|
|
self.numplayerson++;
|
|
if ( is_player_valid( player ) )
|
|
{
|
|
self.numaliveplayersridingbus++;
|
|
self.bus_riders_alive[ self.bus_riders_alive.size ] = player;
|
|
}
|
|
}
|
|
ground_ent = player getgroundent();
|
|
if ( player isonladder() )
|
|
{
|
|
ground_ent = mover;
|
|
}
|
|
if ( isDefined( ground_ent ) )
|
|
{
|
|
if ( isDefined( ground_ent.is_zombie ) && ground_ent.is_zombie )
|
|
{
|
|
player thread zombie_surf( ground_ent );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( playerisinbus && isDefined( player.isonbus ) && !player.isonbus )
|
|
{
|
|
bbprint( "zombie_events", "category %s type %s round %d playername %s", "BUS", "player_enter", level.round_number, player.name );
|
|
player thread bus_audio_interior_loop( self );
|
|
player clientnotify( "OBS" );
|
|
player setclientplayerpushamount( 0 );
|
|
player allowsprint( 0 );
|
|
player allowprone( 0 );
|
|
player._allow_sprint = 0;
|
|
player._allow_prone = 0;
|
|
isdivingtoprone = player getstance() == "prone";
|
|
if ( isdivingtoprone )
|
|
{
|
|
player thread playerdelayturnoffdivetoprone();
|
|
break;
|
|
}
|
|
if ( randomint( 100 ) > 80 && level.automaton.greeting_timer == 0 )
|
|
{
|
|
thread automatonspeak( "convo", "player_enter" );
|
|
level.automaton thread greeting_timer();
|
|
}
|
|
}
|
|
if ( !playerisinbus && isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
bbprint( "zombie_events", "category %s type %s round %d playername %s", "BUS", "player_exit", level.round_number, player.name );
|
|
self.buyable_weapon setinvisibletoplayer( player );
|
|
player setclientplayerpushamount( 1 );
|
|
player allowsprint( 1 );
|
|
player allowprone( 1 );
|
|
player._allow_sprint = undefined;
|
|
player._allow_prone = undefined;
|
|
player notify( "left bus" );
|
|
player clientnotify( "LBS" );
|
|
if ( randomint( 100 ) > 80 && level.automaton.greeting_timer == 0 )
|
|
{
|
|
thread automatonspeak( "convo", "player_leave" );
|
|
level.automaton thread greeting_timer();
|
|
}
|
|
}
|
|
player.isonbus = playerisinbus;
|
|
player.isonbusroof = player _entityisonroof();
|
|
}
|
|
}
|
|
if ( isDefined( player.isonbusroof ) && player.isonbusroof )
|
|
{
|
|
self.buyable_weapon setinvisibletoplayer( player );
|
|
self.numplayersonroof++;
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
self.buyable_weapon setvisibletoplayer( player );
|
|
self.numplayersinsidebus++;
|
|
}
|
|
}
|
|
wait 0,05;
|
|
}
|
|
_k1717 = getNextArrayKey( _a1717, _k1717 );
|
|
}
|
|
wait 0,05;
|
|
}
|
|
}
|
|
|
|
_entityisonroof()
|
|
{
|
|
if ( !isDefined( level.roof_trig ) )
|
|
{
|
|
level.roof_trig = getent( "bus_roof_watch", "targetname" );
|
|
}
|
|
if ( !self.isonbus )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( self istouching( level.roof_trig ) )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
greeting_timer()
|
|
{
|
|
if ( level.automaton.greeting_timer > 0 )
|
|
{
|
|
return;
|
|
}
|
|
level.automaton.greeting_timer = 1;
|
|
wait 20;
|
|
level.automaton.greeting_timer = 0;
|
|
}
|
|
|
|
_updateplayersinsafearea()
|
|
{
|
|
players = get_players();
|
|
if ( !isDefined( level._safeareacachevalid ) || !level._safeareacachevalid )
|
|
{
|
|
level.playable_areas = getentarray( "player_volume", "script_noteworthy" );
|
|
level.nogas_areas = getentarray( "no_gas", "targetname" );
|
|
level.ambush_areas = getentarray( "ambush_volume", "script_noteworthy" );
|
|
level._safeareacachevaild = 1;
|
|
}
|
|
p = 0;
|
|
while ( p < players.size )
|
|
{
|
|
players[ p ].insafearea = _isplayerinsafearea( players[ p ] );
|
|
players[ p ] _playercheckpoison();
|
|
p++;
|
|
}
|
|
}
|
|
|
|
_isplayerinsafearea( player )
|
|
{
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
return level.the_bus.issafe;
|
|
}
|
|
if ( player _playertouchingsafearea( level.playable_areas ) )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( player _playertouchingsafearea( level.nogas_areas ) )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( flag( "ambush_safe_area_active" ) )
|
|
{
|
|
return player _playertouchingsafearea( level.ambush_areas );
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
_playertouchingsafearea( areas )
|
|
{
|
|
i = 0;
|
|
while ( i < areas.size )
|
|
{
|
|
touching = self istouching( areas[ i ] );
|
|
if ( touching )
|
|
{
|
|
return 1;
|
|
}
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
_playercheckpoison()
|
|
{
|
|
if ( !isalive( self ) || self maps/mp/zombies/_zm_laststand::player_is_in_laststand() )
|
|
{
|
|
return;
|
|
}
|
|
if ( isDefined( self.poisoned ) && self.poisoned )
|
|
{
|
|
return;
|
|
}
|
|
canbepoisoned = self playercanbepoisoned();
|
|
if ( !canbepoisoned )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( self.insafearea ) || self.insafearea )
|
|
{
|
|
return;
|
|
}
|
|
self thread _playerpoison();
|
|
}
|
|
|
|
playercanbepoisoned()
|
|
{
|
|
god_mode = isgodmode( self );
|
|
free_move = self isinmovemode( "ufo", "noclip" );
|
|
zombie_cheat_num = getDvarInt( "zombie_cheat" );
|
|
if ( zombie_cheat_num != 1 && zombie_cheat_num != 2 )
|
|
{
|
|
is_invunerable = zombie_cheat_num == 3;
|
|
}
|
|
if ( !god_mode && !isDefined( free_move ) )
|
|
{
|
|
return !is_invunerable;
|
|
}
|
|
}
|
|
|
|
_playerpoison()
|
|
{
|
|
self.poisoned = 1;
|
|
self startpoisoning();
|
|
self playsound( "evt_gas_cough" );
|
|
wait 1;
|
|
damage = 15;
|
|
while ( 1 )
|
|
{
|
|
if ( self maps/mp/zombies/_zm_laststand::player_is_in_laststand() || !isalive( self ) )
|
|
{
|
|
self stoppoisoning();
|
|
self.poisoned = 0;
|
|
return;
|
|
}
|
|
canbepoisoned = self playercanbepoisoned();
|
|
if ( self.insafearea || !canbepoisoned )
|
|
{
|
|
self stoppoisoning();
|
|
self.poisoned = 0;
|
|
return;
|
|
}
|
|
if ( randomfloat( 100 ) < 60 )
|
|
{
|
|
break;
|
|
}
|
|
self dodamage( damage, self.origin );
|
|
damage += 1;
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
_updateplayersinhubs()
|
|
{
|
|
players = get_players();
|
|
hubs = getentarray( "bus_hub", "script_noteworthy" );
|
|
h = 0;
|
|
while ( h < hubs.size )
|
|
{
|
|
hubs[ h ].active = 0;
|
|
p = 0;
|
|
while ( p < players.size && !hubs[ h ].active )
|
|
{
|
|
hubs[ h ].active = players[ p ] istouching( hubs[ h ] );
|
|
p++;
|
|
}
|
|
h++;
|
|
}
|
|
}
|
|
|
|
playerdelayturnoffdivetoprone()
|
|
{
|
|
self endon( "left bus" );
|
|
wait 1,5;
|
|
}
|
|
|
|
busgivepowerup( location )
|
|
{
|
|
currentzone = level.zones[ self.zone ];
|
|
if ( isDefined( currentzone.target2 ) )
|
|
{
|
|
spawndestent = getent( currentzone.target2, "targetname" );
|
|
if ( isDefined( spawndestent ) )
|
|
{
|
|
level thread maps/mp/zombies/_zm_powerups::specific_powerup_drop( "full_ammo", spawndestent.origin );
|
|
level.powerup_drop_count = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
buslightssetup()
|
|
{
|
|
self setclientfield( "bus_head_lights", 1 );
|
|
}
|
|
|
|
buslightsflash()
|
|
{
|
|
self endon( "departing" );
|
|
while ( 1 )
|
|
{
|
|
self buslightwaitenabled();
|
|
self setclientfield( "bus_flashing_lights", 1 );
|
|
wait 2,5;
|
|
self setclientfield( "bus_flashing_lights", 0 );
|
|
wait 2,5;
|
|
}
|
|
}
|
|
|
|
buslightsbrake()
|
|
{
|
|
self buslightwaitenabled();
|
|
self setclientfield( "bus_brake_lights", 1 );
|
|
wait 5;
|
|
while ( is_false( self.ismoving ) )
|
|
{
|
|
self buslightwaitenabled();
|
|
self setclientfield( "bus_brake_lights", 1 );
|
|
wait 0,8;
|
|
self setclientfield( "bus_brake_lights", 0 );
|
|
wait 0,8;
|
|
}
|
|
self setclientfield( "bus_brake_lights", 0 );
|
|
}
|
|
|
|
buslightwaitenabled()
|
|
{
|
|
while ( isDefined( self.bus_lights_disabled ) && self.bus_lights_disabled )
|
|
{
|
|
wait 0,2;
|
|
}
|
|
}
|
|
|
|
buslightdisable( light_name )
|
|
{
|
|
self.oldlights[ light_name ] = self getclientfield( light_name );
|
|
self setclientfield( light_name, 0 );
|
|
}
|
|
|
|
buslightenable( light_name )
|
|
{
|
|
if ( self.oldlights[ light_name ] )
|
|
{
|
|
self setclientfield( light_name, 1 );
|
|
}
|
|
}
|
|
|
|
buslightsignal( turn_signal_side )
|
|
{
|
|
self endon( "pre_power_off" );
|
|
self endon( "power_off" );
|
|
blink = 4;
|
|
x = 0;
|
|
while ( x < blink )
|
|
{
|
|
wait 1;
|
|
self setclientfield( "bus_" + turn_signal_side, 1 );
|
|
wait 1;
|
|
self setclientfield( "bus_" + turn_signal_side, 0 );
|
|
x++;
|
|
}
|
|
}
|
|
|
|
buslightsdisableall()
|
|
{
|
|
if ( !isDefined( self.oldlights ) )
|
|
{
|
|
self.oldlights = [];
|
|
}
|
|
self buslightdisable( "bus_flashing_lights" );
|
|
self buslightdisable( "bus_head_lights" );
|
|
self buslightdisable( "bus_brake_lights" );
|
|
self buslightdisable( "bus_turn_signal_left" );
|
|
self buslightdisable( "bus_turn_signal_right" );
|
|
self.bus_lights_disabled = 1;
|
|
}
|
|
|
|
buslightsenableall()
|
|
{
|
|
self.bus_lights_disabled = 0;
|
|
self buslightenable( "bus_flashing_lights" );
|
|
self buslightenable( "bus_head_lights" );
|
|
self buslightenable( "bus_brake_lights" );
|
|
self buslightenable( "bus_turn_signal_left" );
|
|
self buslightenable( "bus_turn_signal_right" );
|
|
}
|
|
|
|
busdoorssetup()
|
|
{
|
|
self.doorblockers = [];
|
|
self.doorblockers = getentarray( "bus_door_blocker", "targetname" );
|
|
doorstrigger = getentarray( "bus_door_trigger", "targetname" );
|
|
i = 0;
|
|
while ( i < self.doorblockers.size )
|
|
{
|
|
self.doorblockers[ i ].offset = self worldtolocalcoords( self.doorblockers[ i ].origin );
|
|
self.doorblockers[ i ] linkto( self, "", self.doorblockers[ i ].offset, ( 0, 0, 1 ) );
|
|
self.doorblockers[ i ] setmovingplatformenabled( 1 );
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < doorstrigger.size )
|
|
{
|
|
doorstrigger[ i ] enablelinkto();
|
|
doorstrigger[ i ] linkto( self, "", self worldtolocalcoords( doorstrigger[ i ].origin ), ( 0, 0, 1 ) );
|
|
doorstrigger[ i ] setcursorhint( "HINT_NOICON" );
|
|
doorstrigger[ i ] sethintstring( &"ZOMBIE_TRANSIT_OPEN_BUS_DOOR" );
|
|
doorstrigger[ i ] setmovingplatformenabled( 1 );
|
|
doorstrigger[ i ] sethintlowpriority( 1 );
|
|
self thread busdoorthink( doorstrigger[ i ] );
|
|
i++;
|
|
}
|
|
self maps/mp/zm_transit_openings::busopeningsetenabled( "door", 0 );
|
|
}
|
|
|
|
busdoorsopen()
|
|
{
|
|
if ( !self.doorsclosed || self.doorsdisabledfortime )
|
|
{
|
|
return;
|
|
}
|
|
self.doorsclosed = 0;
|
|
self thread bussetdoornodes( 1 );
|
|
doorstrigger = getentarray( "bus_door_trigger", "targetname" );
|
|
i = 0;
|
|
while ( i < self.doorblockers.size )
|
|
{
|
|
self.doorblockers[ i ] notsolid();
|
|
self.doorblockers[ i ] playsound( "zmb_bus_door_open" );
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < doorstrigger.size )
|
|
{
|
|
doorstrigger[ i ] sethintstring( &"ZOMBIE_TRANSIT_CLOSE_BUS_DOOR" );
|
|
i++;
|
|
}
|
|
self bususeanimtree();
|
|
self bususedoor( 1 );
|
|
self maps/mp/zm_transit_openings::busopeningsetenabled( "door", 1 );
|
|
}
|
|
|
|
busdoorsclose()
|
|
{
|
|
if ( self.doorsclosed || self.doorsdisabledfortime )
|
|
{
|
|
return;
|
|
}
|
|
self.doorsclosed = 1;
|
|
self thread bussetdoornodes( 0 );
|
|
level.the_bus showpart( "doors_front_left_2_jnt" );
|
|
level.the_bus showpart( "doors_front_right_2_jnt" );
|
|
level.the_bus showpart( "doors_rear_left_2_jnt" );
|
|
level.the_bus showpart( "doors_rear_right_2_jnt" );
|
|
doorstrigger = getentarray( "bus_door_trigger", "targetname" );
|
|
i = 0;
|
|
while ( i < self.doorblockers.size )
|
|
{
|
|
self.doorblockers[ i ] solid();
|
|
self.doorblockers[ i ] playsound( "zmb_bus_door_close" );
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < doorstrigger.size )
|
|
{
|
|
doorstrigger[ i ] sethintstring( &"ZOMBIE_TRANSIT_OPEN_BUS_DOOR" );
|
|
i++;
|
|
}
|
|
self bususeanimtree();
|
|
self bususedoor( 0 );
|
|
self maps/mp/zm_transit_openings::busopeningsetenabled( "door", 0 );
|
|
}
|
|
|
|
busdoorsdisablefortime( time )
|
|
{
|
|
doorstrigger = getentarray( "bus_door_trigger", "targetname" );
|
|
i = 0;
|
|
while ( i < doorstrigger.size )
|
|
{
|
|
doorstrigger[ i ] setinvisibletoall();
|
|
i++;
|
|
}
|
|
self.doorsdisabledfortime = 1;
|
|
wait time;
|
|
self.doorsdisabledfortime = 0;
|
|
i = 0;
|
|
while ( i < doorstrigger.size )
|
|
{
|
|
doorstrigger[ i ] setvisibletoall();
|
|
i++;
|
|
}
|
|
}
|
|
|
|
init_animtree()
|
|
{
|
|
scriptmodelsuseanimtree( -1 );
|
|
}
|
|
|
|
init_bus_door_anims()
|
|
{
|
|
level.bus_door_open_state = %v_zombie_bus_all_doors_open;
|
|
level.bus_door_close_state = %v_zombie_bus_all_doors_close;
|
|
level.bus_door_open_idle_state = %v_zombie_bus_all_doors_idle_open;
|
|
level.bus_door_close_idle_state = %v_zombie_bus_all_doors_idle_closed;
|
|
}
|
|
|
|
bususeanimtree()
|
|
{
|
|
self useanimtree( -1 );
|
|
}
|
|
|
|
bususedoor( set )
|
|
{
|
|
self endon( "death" );
|
|
animtime = 1;
|
|
if ( set )
|
|
{
|
|
self.door_state = set;
|
|
self setanim( level.bus_door_open_state, 1, animtime, 1 );
|
|
}
|
|
else
|
|
{
|
|
self.door_state = set;
|
|
self playsound( "zmb_bus_door_close" );
|
|
self setanim( level.bus_door_close_state, 1, animtime, 1 );
|
|
}
|
|
self notify( "BusUseDoor" );
|
|
}
|
|
|
|
busidledoor()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
notifystring = self waittill_any_return( "departing", "BusUseDoor", "stopping" );
|
|
if ( notifystring == "departing" || notifystring == "BusUseDoor" )
|
|
{
|
|
if ( isDefined( self.ismoving ) && self.ismoving && isDefined( self.door_state ) )
|
|
{
|
|
wait 1;
|
|
if ( self.door_state )
|
|
{
|
|
self setanim( level.bus_door_open_idle_state );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
self setanim( level.bus_door_close_idle_state );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( notifystring == "stopping" )
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
init_props_animtree()
|
|
{
|
|
scriptmodelsuseanimtree( -1 );
|
|
}
|
|
|
|
init_bus_props_anims()
|
|
{
|
|
level.bus_props_start_state = %fxanim_zom_bus_interior_start_anim;
|
|
level.bus_props_idle_state = %fxanim_zom_bus_interior_idle_anim;
|
|
level.bus_props_end_state = %fxanim_zom_bus_interior_end_anim;
|
|
}
|
|
|
|
busfxanims()
|
|
{
|
|
self.fxanimmodel = spawn( "script_model", self gettagorigin( "tag_body" ) );
|
|
self.fxanimmodel setmodel( "fxanim_zom_bus_interior_mod" );
|
|
self.fxanimmodel linkto( self, "tag_body" );
|
|
self.fxanimmodel useanimtree( -1 );
|
|
}
|
|
|
|
busfxanims_start()
|
|
{
|
|
if ( !isDefined( self.fxanimmodel ) )
|
|
{
|
|
return;
|
|
}
|
|
self.fxanimmodel setanim( level.bus_props_start_state );
|
|
wait getanimlength( level.bus_props_start_state );
|
|
if ( isDefined( self.ismoving ) && self.ismoving )
|
|
{
|
|
self.fxanimmodel setanim( level.bus_props_idle_state );
|
|
}
|
|
}
|
|
|
|
busfxanims_end()
|
|
{
|
|
if ( !isDefined( self.fxanimmodel ) )
|
|
{
|
|
return;
|
|
}
|
|
self.fxanimmodel setanim( level.bus_props_start_state );
|
|
}
|
|
|
|
busdoorthink( trigger )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
trigger waittill( "trigger", player );
|
|
if ( isDefined( self.force_lock_doors ) && self.force_lock_doors )
|
|
{
|
|
continue;
|
|
}
|
|
if ( self.doorsclosed )
|
|
{
|
|
if ( isDefined( level.bus_intro_done ) && !level.bus_intro_done )
|
|
{
|
|
thread automatonspeak( "scripted", "discover_bus" );
|
|
level.bus_intro_done = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( randomint( 100 ) > 75 && !isDefined( level.automaton.dmgfxorigin ) )
|
|
{
|
|
thread automatonspeak( "inform", "doors_open" );
|
|
}
|
|
}
|
|
self busdoorsopen();
|
|
}
|
|
else
|
|
{
|
|
if ( randomint( 100 ) > 75 && !isDefined( level.automaton.dmgfxorigin ) )
|
|
{
|
|
thread automatonspeak( "inform", "doors_close" );
|
|
}
|
|
self busdoorsclose();
|
|
}
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
busfueltanksetup()
|
|
{
|
|
script_origin = spawn( "script_origin", self.origin + ( -193, 75, 48 ) );
|
|
script_origin.angles = vectorScale( ( 0, 0, 1 ), 180 );
|
|
script_origin linkto( self );
|
|
self.fueltankmodelpoint = script_origin;
|
|
script_origin = spawn( "script_origin", self.origin + ( -193, 128, 48 ) );
|
|
script_origin linkto( self );
|
|
self.fueltanktriggerpoint = script_origin;
|
|
}
|
|
|
|
busdeferredinitplowclip( clip )
|
|
{
|
|
origin = self worldtolocalcoords( clip.origin );
|
|
clip.origin = vectorScale( ( 0, 0, 1 ), 100 );
|
|
wait_for_buildable( "cattlecatcher" );
|
|
trigger = getent( "trigger_plow", "targetname" );
|
|
while ( 1 )
|
|
{
|
|
canbreak = 1;
|
|
players = get_players();
|
|
_a2655 = players;
|
|
_k2655 = getFirstArrayKey( _a2655 );
|
|
while ( isDefined( _k2655 ) )
|
|
{
|
|
player = _a2655[ _k2655 ];
|
|
if ( player istouching( trigger ) )
|
|
{
|
|
canbreak = 0;
|
|
}
|
|
_k2655 = getNextArrayKey( _a2655, _k2655 );
|
|
}
|
|
if ( canbreak )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
wait 0,05;
|
|
}
|
|
}
|
|
self.plow_clip_attached = 1;
|
|
clip linkto( self, "", origin, ( 0, 0, 1 ) );
|
|
clip setmovingplatformenabled( 1 );
|
|
}
|
|
|
|
busplowupdatesolid()
|
|
{
|
|
if ( isDefined( self.cow_catcher_blocker ) )
|
|
{
|
|
if ( isDefined( self.ismoving ) && !self.ismoving && isDefined( self.plow_attached ) && self.plow_attached )
|
|
{
|
|
self.cow_catcher_blocker solid();
|
|
self.cow_catcher_blocker disconnectpaths();
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
self.cow_catcher_blocker notsolid();
|
|
self.cow_catcher_blocker connectpaths();
|
|
}
|
|
}
|
|
}
|
|
|
|
busplowsetup()
|
|
{
|
|
clipbrush = getentarray( "plow_clip", "targetname" );
|
|
while ( isDefined( clipbrush ) && clipbrush.size > 0 )
|
|
{
|
|
i = 0;
|
|
while ( i < clipbrush.size )
|
|
{
|
|
self thread busdeferredinitplowclip( clipbrush[ i ] );
|
|
i++;
|
|
}
|
|
}
|
|
level.the_bus.plow_clip = clipbrush;
|
|
level.the_bus hidepart( "tag_plow_attach" );
|
|
trigger = getent( "trigger_plow", "targetname" );
|
|
trigger linkto( level.the_bus );
|
|
trigger setmovingplatformenabled( 1 );
|
|
self thread busplowmoveplayeronbuilt();
|
|
self thread busplowmoveplayer();
|
|
self.bussmashtrigger = trigger;
|
|
cow_catcher_blocker = getent( "cow_catcher_path_blocker", "targetname" );
|
|
if ( isDefined( cow_catcher_blocker ) )
|
|
{
|
|
self.cow_catcher_blocker = cow_catcher_blocker;
|
|
if ( !isDefined( self.path_blockers ) )
|
|
{
|
|
self.path_blockers = [];
|
|
}
|
|
self.path_blockers[ self.path_blockers.size ] = cow_catcher_blocker;
|
|
self busplowupdatesolid();
|
|
}
|
|
player = wait_for_buildable( "cattlecatcher" );
|
|
flag_set( "catcher_attached" );
|
|
self.plow_attached = 1;
|
|
self busplowupdatesolid();
|
|
self.plowtrigger = trigger;
|
|
level.the_bus showpart( "tag_plow_attach" );
|
|
level.the_bus.upgrades[ "Plow" ].installed = 1;
|
|
level.the_bus maps/mp/zm_transit_openings::busopeningsetenabled( "front", 0 );
|
|
player maps/mp/zombies/_zm_buildables::track_placed_buildables( "cattlecatcher" );
|
|
}
|
|
|
|
busplowmoveplayeronbuilt()
|
|
{
|
|
wait_for_buildable( "cattlecatcher" );
|
|
while ( isDefined( self.plow_clip_attached ) && !self.plow_clip_attached )
|
|
{
|
|
self busplowmoveplayerthink();
|
|
wait 0,05;
|
|
}
|
|
}
|
|
|
|
busplowmoveplayer()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
while ( is_false( self.ismoving ) || isDefined( self.disabled_by_emp ) && self.disabled_by_emp )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
self busplowmoveplayerthink();
|
|
wait 0,05;
|
|
}
|
|
}
|
|
|
|
busplowmoveplayerthink()
|
|
{
|
|
if ( !isDefined( level.triggerplow ) )
|
|
{
|
|
level.triggerplow = getent( "trigger_plow", "targetname" );
|
|
}
|
|
players = get_players();
|
|
_a2797 = players;
|
|
_k2797 = getFirstArrayKey( _a2797 );
|
|
while ( isDefined( _k2797 ) )
|
|
{
|
|
player = _a2797[ _k2797 ];
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( player istouching( level.triggerplow ) )
|
|
{
|
|
rightdistance = distancesquared( player.origin, self gettagorigin( "tag_wheel_front_right" ) );
|
|
leftdistance = distancesquared( player.origin, self gettagorigin( "tag_wheel_front_left" ) );
|
|
bus_dir = undefined;
|
|
if ( isDefined( player.is_burning ) && player getstance() == "stand" )
|
|
{
|
|
player setstance( "crouch" );
|
|
}
|
|
if ( rightdistance < leftdistance )
|
|
{
|
|
bus_dir = vectorScale( anglesToForward( self.angles + ( -60, -60, 30 ) ), 512 );
|
|
}
|
|
else
|
|
{
|
|
bus_dir = vectorScale( anglesToForward( self.angles + ( 60, 60, 30 ) ), 512 );
|
|
}
|
|
bus_vel = self getvelocity();
|
|
boost_velocity = bus_vel + bus_dir;
|
|
player setvelocity( boost_velocity );
|
|
}
|
|
}
|
|
_k2797 = getNextArrayKey( _a2797, _k2797 );
|
|
}
|
|
}
|
|
|
|
buspushzombie( zombie, trigger )
|
|
{
|
|
opening = level.the_bus maps/mp/zm_transit_openings::busopeningbyname( "front" );
|
|
if ( isDefined( opening ) && isDefined( opening.zombie ) || opening.zombie != zombie && isDefined( zombie.is_inert ) && zombie.is_inert )
|
|
{
|
|
busplowkillzombie( zombie );
|
|
}
|
|
else
|
|
{
|
|
zombie thread zombieattachtobus( level.the_bus, opening, 0 );
|
|
}
|
|
}
|
|
|
|
busplowkillzombie( zombie )
|
|
{
|
|
zombie.killedbyplow = 1;
|
|
if ( isDefined( zombie.busplowkillzombie ) )
|
|
{
|
|
zombie thread [[ zombie.busplowkillzombie ]]();
|
|
return;
|
|
}
|
|
if ( is_mature() )
|
|
{
|
|
if ( isDefined( level._effect[ "zomb_gib" ] ) )
|
|
{
|
|
playfxontag( level._effect[ "zomb_gib" ], zombie, "J_SpineLower" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( level._effect[ "spawn_cloud" ] ) )
|
|
{
|
|
playfxontag( level._effect[ "spawn_cloud" ], zombie, "J_SpineLower" );
|
|
}
|
|
}
|
|
zombie thread busplowkillzombieuntildeath();
|
|
wait 1;
|
|
if ( isDefined( zombie ) )
|
|
{
|
|
zombie hide();
|
|
}
|
|
if ( !isDefined( self.upgrades[ "Plow" ].killcount ) )
|
|
{
|
|
self.upgrades[ "Plow" ].killcount = 0;
|
|
}
|
|
self.upgrades[ "Plow" ].killcount++;
|
|
}
|
|
|
|
busplowkillzombieuntildeath()
|
|
{
|
|
self endon( "death" );
|
|
while ( isDefined( self ) && isalive( self ) )
|
|
{
|
|
if ( isDefined( self.health ) )
|
|
{
|
|
self.marked_for_recycle = 1;
|
|
self dodamage( self.health + 666, self.origin, self, self, "none", "MOD_SUICIDE" );
|
|
}
|
|
wait 1;
|
|
}
|
|
}
|
|
|
|
bus_roof_watch()
|
|
{
|
|
roof_trig = getent( "bus_roof_watch", "targetname" );
|
|
roof_trig enablelinkto();
|
|
roof_trig linkto( self, "", self worldtolocalcoords( roof_trig.origin ), roof_trig.angles + self.angles );
|
|
roof_trig setmovingplatformenabled( 1 );
|
|
}
|
|
|
|
busroofjumpoffpositionssetup()
|
|
{
|
|
jump_positions = getentarray( "roof_jump_off_positions", "targetname" );
|
|
/#
|
|
assert( jump_positions.size > 0 );
|
|
#/
|
|
i = 0;
|
|
while ( i < jump_positions.size )
|
|
{
|
|
jump_positions[ i ] linkto( self, "", self worldtolocalcoords( jump_positions[ i ].origin ), jump_positions[ i ].angles + self.angles );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
bussideladderssetup()
|
|
{
|
|
side_ladders = getentarray( "roof_ladder_outside", "targetname" );
|
|
i = 0;
|
|
while ( i < side_ladders.size )
|
|
{
|
|
side_ladders[ i ].trigger = getent( side_ladders[ i ].target, "targetname" );
|
|
if ( !isDefined( side_ladders[ i ].trigger ) )
|
|
{
|
|
side_ladders[ i ] delete();
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
side_ladders[ i ] linkto( self, "", self worldtolocalcoords( side_ladders[ i ].origin ), side_ladders[ i ].angles + self.angles );
|
|
side_ladders[ i ].trigger enablelinkto();
|
|
side_ladders[ i ].trigger linkto( self, "", self worldtolocalcoords( side_ladders[ i ].trigger.origin ), side_ladders[ i ].trigger.angles + self.angles );
|
|
self thread bussideladderthink( side_ladders[ i ], side_ladders[ i ].trigger );
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
bussideladderthink( ladder, trigger )
|
|
{
|
|
if ( 1 )
|
|
{
|
|
trigger delete();
|
|
return;
|
|
}
|
|
trigger setcursorhint( "HINT_NOICON" );
|
|
trigger sethintstring( &"ZOMBIE_TRANSIT_BUS_CLIMB_ROOF" );
|
|
while ( 1 )
|
|
{
|
|
trigger waittill( "trigger", player );
|
|
teleport_location = self localtoworldcoords( ladder.script_vector );
|
|
player setorigin( teleport_location );
|
|
trigger setinvisibletoall();
|
|
wait 1;
|
|
trigger setvisibletoall();
|
|
}
|
|
}
|
|
|
|
buspathblockersetup()
|
|
{
|
|
self.path_blockers = getentarray( "bus_path_blocker", "targetname" );
|
|
i = 0;
|
|
while ( i < self.path_blockers.size )
|
|
{
|
|
self.path_blockers[ i ] linkto( self, "", self worldtolocalcoords( self.path_blockers[ i ].origin ), self.path_blockers[ i ].angles + self.angles );
|
|
i++;
|
|
}
|
|
cow_catcher_blocker = getent( "cow_catcher_path_blocker", "targetname" );
|
|
if ( isDefined( cow_catcher_blocker ) )
|
|
{
|
|
cow_catcher_blocker linkto( self, "", self worldtolocalcoords( cow_catcher_blocker.origin ), cow_catcher_blocker.angles + self.angles );
|
|
}
|
|
trig = getent( "bus_buyable_weapon1", "script_noteworthy" );
|
|
trig enablelinkto();
|
|
trig linkto( self, "", self worldtolocalcoords( trig.origin ), ( 0, 0, 1 ) );
|
|
trig setinvisibletoall();
|
|
self.buyable_weapon = trig;
|
|
level._spawned_wallbuys[ level._spawned_wallbuys.size ] = trig;
|
|
weapon_model = getent( trig.target, "targetname" );
|
|
weapon_model linkto( self, "", self worldtolocalcoords( weapon_model.origin ), weapon_model.angles + self.angles );
|
|
weapon_model setmovingplatformenabled( 1 );
|
|
weapon_model._linked_ent = trig;
|
|
}
|
|
|
|
bussetdoornodes( enable )
|
|
{
|
|
if ( isDefined( self.door_nodes_avoid_linking ) && self.door_nodes_avoid_linking )
|
|
{
|
|
return;
|
|
}
|
|
if ( enable )
|
|
{
|
|
if ( !self.door_nodes_linked )
|
|
{
|
|
link_nodes( self.front_door_inside, self.front_door );
|
|
link_nodes( self.front_door, self.front_door_inside );
|
|
link_nodes( self.back_door_inside1, self.back_door );
|
|
link_nodes( self.back_door, self.back_door_inside1 );
|
|
link_nodes( self.back_door_inside2, self.back_door );
|
|
link_nodes( self.back_door, self.back_door_inside2 );
|
|
self.door_nodes_linked = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( self.door_nodes_linked )
|
|
{
|
|
unlink_nodes( self.front_door_inside, self.front_door );
|
|
unlink_nodes( self.front_door, self.front_door_inside );
|
|
unlink_nodes( self.back_door_inside1, self.back_door );
|
|
unlink_nodes( self.back_door, self.back_door_inside1 );
|
|
unlink_nodes( self.back_door_inside2, self.back_door );
|
|
unlink_nodes( self.back_door, self.back_door_inside2 );
|
|
self.door_nodes_linked = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
buspathblockerenable()
|
|
{
|
|
if ( !isDefined( self.path_blockers ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( self.path_blocking )
|
|
{
|
|
return;
|
|
}
|
|
while ( level.the_bus getspeed() > 0 )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
i = 0;
|
|
while ( i < self.path_blockers.size )
|
|
{
|
|
self.path_blockers[ i ] disconnectpaths();
|
|
i++;
|
|
}
|
|
self.link_start = [];
|
|
self.link_end = [];
|
|
self buslinkdoornodes( "front_door_node" );
|
|
self buslinkdoornodes( "back_door_node" );
|
|
self.path_blocking = 1;
|
|
}
|
|
|
|
buslinkdoornodes( node_name )
|
|
{
|
|
start_node = getnode( node_name, "targetname" );
|
|
start_node.links = [];
|
|
while ( isDefined( start_node ) )
|
|
{
|
|
near_nodes = getnodesinradiussorted( start_node.origin, 128, 0, 64, "pathnodes" );
|
|
links = 0;
|
|
_a3071 = near_nodes;
|
|
_k3071 = getFirstArrayKey( _a3071 );
|
|
while ( isDefined( _k3071 ) )
|
|
{
|
|
node = _a3071[ _k3071 ];
|
|
if ( !isDefined( node.target ) || node.target != "the_bus" )
|
|
{
|
|
self.link_start[ self.link_start.size ] = start_node;
|
|
self.link_end[ self.link_end.size ] = node;
|
|
link_nodes( start_node, node );
|
|
link_nodes( node, start_node );
|
|
start_node.links[ start_node.links.size ] = node;
|
|
links++;
|
|
if ( links == 2 )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_k3071 = getNextArrayKey( _a3071, _k3071 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
busunlinkdoornodes( node_name )
|
|
{
|
|
start_node = getnode( node_name, "targetname" );
|
|
while ( isDefined( start_node ) && isDefined( start_node.links ) )
|
|
{
|
|
linked_nodes = start_node.links;
|
|
_a3098 = linked_nodes;
|
|
_k3098 = getFirstArrayKey( _a3098 );
|
|
while ( isDefined( _k3098 ) )
|
|
{
|
|
node = _a3098[ _k3098 ];
|
|
if ( !isDefined( node.target ) || node.target != "the_bus" )
|
|
{
|
|
unlink_nodes( start_node, node );
|
|
unlink_nodes( node, start_node );
|
|
}
|
|
_k3098 = getNextArrayKey( _a3098, _k3098 );
|
|
}
|
|
}
|
|
}
|
|
|
|
buspathblockerdisable()
|
|
{
|
|
if ( !isDefined( self.path_blockers ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( !self.path_blocking )
|
|
{
|
|
return;
|
|
}
|
|
i = 0;
|
|
while ( i < self.path_blockers.size )
|
|
{
|
|
self.path_blockers[ i ] connectpaths();
|
|
i++;
|
|
}
|
|
self.link_start = [];
|
|
self.link_end = [];
|
|
self busunlinkdoornodes( "front_door_node" );
|
|
self busunlinkdoornodes( "back_door_node" );
|
|
self.path_blocking = 0;
|
|
self bussetdineropenings( 1 );
|
|
self bussetpoweropenings( 1 );
|
|
self bussettownopenings( 1 );
|
|
}
|
|
|
|
bussetupbounds()
|
|
{
|
|
self.bounds_origins = getentarray( "bus_bounds_origin", "targetname" );
|
|
i = 0;
|
|
while ( i < self.bounds_origins.size )
|
|
{
|
|
self.bounds_origins[ i ] linkto( self, "", self worldtolocalcoords( self.bounds_origins[ i ].origin ), self.angles );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
busstartwait()
|
|
{
|
|
while ( self getspeed() == 0 )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
}
|
|
|
|
busshowleavinghud( time )
|
|
{
|
|
if ( !isDefined( level.bus_leave_hud ) )
|
|
{
|
|
level.bus_leave_hud = newhudelem();
|
|
level.bus_leave_hud.color = ( 0, 0, 1 );
|
|
level.bus_leave_hud.fontscale = 4;
|
|
level.bus_leave_hud.x = -300;
|
|
level.bus_leave_hud.y = 100;
|
|
level.bus_leave_hud.alignx = "center";
|
|
level.bus_leave_hud.aligny = "bottom";
|
|
level.bus_leave_hud.horzalign = "center";
|
|
level.bus_leave_hud.vertalign = "middle";
|
|
level.bus_leave_hud.font = "objective";
|
|
level.bus_leave_hud.glowcolor = ( 0,3, 0,6, 0,3 );
|
|
level.bus_leave_hud.glowalpha = 1;
|
|
level.bus_leave_hud.foreground = 1;
|
|
level.bus_leave_hud.hidewheninmenu = 1;
|
|
}
|
|
level.bus_leave_hud.alpha = 0,3;
|
|
level.bus_leave_hud settimer( time );
|
|
wait time;
|
|
level.bus_leave_hud.alpha = 0;
|
|
}
|
|
|
|
busstartmoving( targetspeed )
|
|
{
|
|
if ( !self.ismoving )
|
|
{
|
|
self.ismoving = 1;
|
|
self.isstopping = 0;
|
|
self thread busexceedchasespeed();
|
|
bbprint( "zombie_events", "%s", "bus_start" );
|
|
self setclientfield( "bus_brake_lights", 0 );
|
|
self buspathblockerdisable();
|
|
self thread busfxanims_start();
|
|
self busplowupdatesolid();
|
|
if ( !flag( "ambush_round" ) )
|
|
{
|
|
level.numbusstopssincelastambushround++;
|
|
}
|
|
}
|
|
if ( isDefined( targetspeed ) )
|
|
{
|
|
self.targetspeed = targetspeed;
|
|
}
|
|
self notify( "OnKeysUsed" );
|
|
self thread play_bus_audio( "leaving" );
|
|
}
|
|
|
|
busexceedchasespeed()
|
|
{
|
|
self notify( "exceed_chase_speed" );
|
|
self endon( "exceed_chase_speed" );
|
|
while ( isDefined( self.ismoving ) && self.ismoving )
|
|
{
|
|
if ( self getspeedmph() > 12 )
|
|
{
|
|
self.exceed_chase_speed = 1;
|
|
return;
|
|
}
|
|
wait 0,1;
|
|
}
|
|
}
|
|
|
|
busstopwait()
|
|
{
|
|
while ( self.ismoving && !self.isstopping )
|
|
{
|
|
self.isstopping = 1;
|
|
bbprint( "zombie_events", "%s", "bus_stop" );
|
|
while ( self getspeed() > 0 )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
}
|
|
}
|
|
|
|
busstopmoving( immediatestop )
|
|
{
|
|
if ( self.ismoving )
|
|
{
|
|
if ( isDefined( immediatestop ) && immediatestop )
|
|
{
|
|
self.immediatespeed = 1;
|
|
}
|
|
self notify( "stopping" );
|
|
self thread play_bus_audio( "stopping" );
|
|
self.targetspeed = 0;
|
|
self setspeedimmediate( self.targetspeed, 30, 30 );
|
|
self.ismoving = 0;
|
|
self.isstopping = 0;
|
|
self.exceed_chase_speed = 0;
|
|
self busplowupdatesolid();
|
|
self thread buslightsbrake();
|
|
self thread buspathblockerenable();
|
|
self thread shakeplayersonbus();
|
|
self thread busfxanims_end();
|
|
}
|
|
}
|
|
|
|
shakeplayersonbus()
|
|
{
|
|
players = get_players();
|
|
_a3289 = players;
|
|
_k3289 = getFirstArrayKey( _a3289 );
|
|
while ( isDefined( _k3289 ) )
|
|
{
|
|
player = _a3289[ _k3289 ];
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
earthquake( randomfloatrange( 0,3, 0,4 ), randomfloatrange( 0,2, 0,4 ), player.origin + vectorScale( ( 0, 0, 1 ), 32 ), 150 );
|
|
}
|
|
_k3289 = getNextArrayKey( _a3289, _k3289 );
|
|
}
|
|
}
|
|
|
|
busgasadd( percent )
|
|
{
|
|
newgaslevel = level.the_bus.gas + percent;
|
|
/#
|
|
println( "^2Bus Debug: Old Gas Level is " + newgaslevel );
|
|
#/
|
|
if ( newgaslevel < 0 )
|
|
{
|
|
newgaslevel = 0;
|
|
}
|
|
else
|
|
{
|
|
if ( newgaslevel > 100 )
|
|
{
|
|
newgaslevel = 100;
|
|
}
|
|
}
|
|
level.the_bus.gas = newgaslevel;
|
|
/#
|
|
println( "^2Bus Debug: New Gas Level is " + newgaslevel );
|
|
#/
|
|
}
|
|
|
|
busgasremove( percent )
|
|
{
|
|
busgasadd( percent * -1 );
|
|
}
|
|
|
|
busgasempty()
|
|
{
|
|
if ( level.the_bus.gas <= 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
busrestartzombiespawningaftertime( seconds )
|
|
{
|
|
wait seconds;
|
|
maps/mp/zm_transit_utility::try_resume_zombie_spawning();
|
|
}
|
|
|
|
busthink()
|
|
{
|
|
no_danger = 0;
|
|
self thread busupdatechasers();
|
|
self.buyable_weapon notify( "stop_hint_logic" );
|
|
self thread busupdateplayers();
|
|
self thread busupdatenearzombies();
|
|
while ( 1 )
|
|
{
|
|
waittillframeend;
|
|
self busupdatespeed();
|
|
self busupdateignorewindows();
|
|
if ( self.ismoving )
|
|
{
|
|
self busupdatenearequipment();
|
|
}
|
|
if ( isDefined( level.bus_zombie_danger ) && !level.bus_zombie_danger || self.numplayersonroof && self.numplayersinsidebus )
|
|
{
|
|
no_danger++;
|
|
if ( no_danger > 40 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_none", 40, 60 );
|
|
no_danger = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
no_danger = 0;
|
|
}
|
|
wait 0,1;
|
|
}
|
|
}
|
|
|
|
zomclimbingvox( old, new )
|
|
{
|
|
if ( new <= old )
|
|
{
|
|
return;
|
|
}
|
|
if ( new == 1 || new == 3 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_climb", 30 );
|
|
}
|
|
}
|
|
|
|
zomchasingvox()
|
|
{
|
|
if ( self.zombies_chasing_bus > 2 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_chase", 15 );
|
|
}
|
|
}
|
|
|
|
zomonbusvox( old, new )
|
|
{
|
|
if ( new == old )
|
|
{
|
|
return;
|
|
}
|
|
if ( new != 1 && new != 4 && new == 8 && randomint( 100 ) < 20 )
|
|
{
|
|
level thread automatonspeak( "inform", "zombie_on_board" );
|
|
}
|
|
else
|
|
{
|
|
if ( new >= 1 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_ent", 25 );
|
|
}
|
|
}
|
|
}
|
|
|
|
zomatwindowvox( old, new )
|
|
{
|
|
if ( new <= old )
|
|
{
|
|
return;
|
|
}
|
|
if ( new != 1 && new != 3 && new == 5 && randomint( 100 ) < 35 )
|
|
{
|
|
level thread automatonspeak( "inform", "zombie_at_window" );
|
|
}
|
|
else
|
|
{
|
|
if ( new >= 1 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_atk", 25 );
|
|
}
|
|
}
|
|
}
|
|
|
|
zomonroofvox( old, new )
|
|
{
|
|
if ( new <= old )
|
|
{
|
|
return;
|
|
}
|
|
if ( new != 1 && new != 4 && new == 8 && randomint( 100 ) < 35 )
|
|
{
|
|
level thread automatonspeak( "inform", "zombie_on_roof" );
|
|
}
|
|
else
|
|
{
|
|
if ( new >= 1 )
|
|
{
|
|
level thread do_player_bus_zombie_vox( "bus_zom_roof", 25 );
|
|
}
|
|
}
|
|
}
|
|
|
|
bussetdineropenings( enable )
|
|
{
|
|
_a3464 = self.openings;
|
|
_k3464 = getFirstArrayKey( _a3464 );
|
|
while ( isDefined( _k3464 ) )
|
|
{
|
|
opening = _a3464[ _k3464 ];
|
|
if ( opening.bindtag != "window_right_2_jnt" && opening.bindtag != "window_right_3_jnt" || opening.bindtag == "window_left_2_jnt" && opening.bindtag == "window_left_3_jnt" )
|
|
{
|
|
opening.enabled = enable;
|
|
}
|
|
_k3464 = getNextArrayKey( _a3464, _k3464 );
|
|
}
|
|
}
|
|
|
|
bussetpoweropenings( enable )
|
|
{
|
|
_a3476 = self.openings;
|
|
_k3476 = getFirstArrayKey( _a3476 );
|
|
while ( isDefined( _k3476 ) )
|
|
{
|
|
opening = _a3476[ _k3476 ];
|
|
if ( opening.bindtag == "window_right_4_jnt" )
|
|
{
|
|
opening.enabled = enable;
|
|
}
|
|
_k3476 = getNextArrayKey( _a3476, _k3476 );
|
|
}
|
|
}
|
|
|
|
bussettownopenings( enable )
|
|
{
|
|
_a3487 = self.openings;
|
|
_k3487 = getFirstArrayKey( _a3487 );
|
|
while ( isDefined( _k3487 ) )
|
|
{
|
|
opening = _a3487[ _k3487 ];
|
|
if ( opening.bindtag == "window_right_4_jnt" )
|
|
{
|
|
opening.enabled = enable;
|
|
}
|
|
_k3487 = getNextArrayKey( _a3487, _k3487 );
|
|
}
|
|
}
|
|
|
|
busgetclosestopening()
|
|
{
|
|
enemy = self.favoriteenemy;
|
|
closestorigin = undefined;
|
|
closestopeningtozombie = undefined;
|
|
closestdisttozombie = -1;
|
|
closestorigintozombie = undefined;
|
|
closestopeningtoplayer = undefined;
|
|
closestdisttoplayer = -1;
|
|
closestorigintoplayer = undefined;
|
|
i = 0;
|
|
while ( i < level.the_bus.openings.size )
|
|
{
|
|
opening = level.the_bus.openings[ i ];
|
|
if ( !opening.enabled )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( maps/mp/zm_transit_openings::_isopeningdoor( opening.bindtag ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else jump_origin = maps/mp/zm_transit_openings::_determinejumpfromorigin( opening );
|
|
dist2 = distancesquared( enemy.origin, jump_origin );
|
|
if ( !isDefined( closestopeningtoplayer ) || dist2 < closestdisttoplayer )
|
|
{
|
|
closestopeningtoplayer = opening;
|
|
closestorigintoplayer = jump_origin;
|
|
closestdisttoplayer = dist2;
|
|
}
|
|
if ( isDefined( opening.zombie ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
dist2 = distancesquared( self.origin, jump_origin );
|
|
if ( !isDefined( closestopeningtozombie ) || dist2 < closestdisttozombie )
|
|
{
|
|
closestopeningtozombie = opening;
|
|
closestorigintozombie = jump_origin;
|
|
closestdisttozombie = dist2;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
if ( isDefined( closestopeningtozombie ) )
|
|
{
|
|
closestorigin = closestorigintozombie;
|
|
}
|
|
else
|
|
{
|
|
closestorigin = closestorigintoplayer;
|
|
}
|
|
return closestorigin;
|
|
}
|
|
|
|
busgetclosestexit()
|
|
{
|
|
enemy = self.favoriteenemy;
|
|
goal_node = level.the_bus.front_door_inside;
|
|
if ( isDefined( enemy ) )
|
|
{
|
|
dist_f = distancesquared( enemy.origin, level.the_bus.front_door_inside );
|
|
dist_bl = distancesquared( enemy.origin, level.the_bus.exit_back_l );
|
|
dist_br = distancesquared( enemy.origin, level.the_bus.exit_back_r );
|
|
if ( dist_bl < dist_br )
|
|
{
|
|
if ( dist_bl < dist_f )
|
|
{
|
|
goal_node = dist_bl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( dist_br < dist_f )
|
|
{
|
|
goal_node = dist_br;
|
|
}
|
|
}
|
|
}
|
|
return goal_node.origin;
|
|
}
|
|
|
|
enemy_location_override()
|
|
{
|
|
enemy = self.favoriteenemy;
|
|
location = enemy.origin;
|
|
bus = level.the_bus;
|
|
if ( isDefined( self.isscreecher ) || self.isscreecher && isDefined( self.is_avogadro ) && self.is_avogadro )
|
|
{
|
|
return location;
|
|
}
|
|
if ( isDefined( self.item ) )
|
|
{
|
|
return self.origin;
|
|
}
|
|
if ( is_true( self.reroute ) )
|
|
{
|
|
if ( isDefined( self.reroute_origin ) )
|
|
{
|
|
location = self.reroute_origin;
|
|
}
|
|
}
|
|
if ( isDefined( enemy.isonbus ) && enemy.isonbus && isDefined( self.solo_revive_exit ) && !self.solo_revive_exit )
|
|
{
|
|
if ( isDefined( self.isonbus ) && !self.isonbus )
|
|
{
|
|
if ( isDefined( bus.ismoving ) && bus.ismoving && isDefined( bus.disabled_by_emp ) && !bus.disabled_by_emp )
|
|
{
|
|
self.ignoreall = 1;
|
|
if ( isDefined( self.close_to_bus ) && self.close_to_bus && isDefined( bus.istouchingignorewindowsvolume ) && !bus.istouchingignorewindowsvolume )
|
|
{
|
|
self.goalradius = 2;
|
|
location = self busgetclosestopening();
|
|
location = groundpos_ignore_water_new( location + vectorScale( ( 0, 0, 1 ), 60 ) );
|
|
}
|
|
else
|
|
{
|
|
self.goalradius = 32;
|
|
while ( getTime() != bus.chase_pos_time )
|
|
{
|
|
bus.chase_pos_time = getTime();
|
|
bus.chase_pos_index = 0;
|
|
bus_forward = vectornormalize( anglesToForward( level.the_bus.angles ) );
|
|
bus_right = vectornormalize( anglesToRight( level.the_bus.angles ) );
|
|
bus.chase_pos = [];
|
|
bus.chase_pos[ 0 ] = level.the_bus.origin + vectorScale( bus_forward, -144 );
|
|
bus.chase_pos[ 1 ] = bus.chase_pos[ 0 ] + vectorScale( bus_right, 64 );
|
|
bus.chase_pos[ 2 ] = bus.chase_pos[ 0 ] + vectorScale( bus_right, -64 );
|
|
_a3656 = bus.chase_pos;
|
|
_k3656 = getFirstArrayKey( _a3656 );
|
|
while ( isDefined( _k3656 ) )
|
|
{
|
|
pos = _a3656[ _k3656 ];
|
|
pos = groundpos_ignore_water_new( pos + vectorScale( ( 0, 0, 1 ), 60 ) );
|
|
_k3656 = getNextArrayKey( _a3656, _k3656 );
|
|
}
|
|
}
|
|
location = bus.chase_pos[ bus.chase_pos_index ];
|
|
bus.chase_pos_index++;
|
|
if ( bus.chase_pos_index >= 3 )
|
|
{
|
|
bus.chase_pos_index = 0;
|
|
}
|
|
dist_sq = distancesquared( self.origin, location );
|
|
if ( dist_sq < 2304 )
|
|
{
|
|
self.close_to_bus = 1;
|
|
}
|
|
}
|
|
return location;
|
|
}
|
|
self.close_to_bus = 0;
|
|
if ( isDefined( bus.doorsclosed ) && bus.doorsclosed )
|
|
{
|
|
self.ignoreall = 1;
|
|
self.goalradius = 2;
|
|
location = self busgetclosestopening();
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( enemy.isonbusroof ) && enemy.isonbusroof )
|
|
{
|
|
self.ignoreall = 1;
|
|
self.goalradius = 2;
|
|
location = self busgetclosestopening();
|
|
}
|
|
else
|
|
{
|
|
front_dist = distance2dsquared( enemy.origin, level.the_bus.front_door.origin );
|
|
back_dist = distance2dsquared( enemy.origin, level.the_bus.back_door.origin );
|
|
if ( front_dist < back_dist )
|
|
{
|
|
location = level.the_bus.front_door_inside.origin;
|
|
}
|
|
else
|
|
{
|
|
location = level.the_bus.back_door_inside1.origin;
|
|
}
|
|
self.ignoreall = 0;
|
|
self.goalradius = 32;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return location;
|
|
}
|
|
|
|
adjust_enemyoverride()
|
|
{
|
|
location = self.enemyoverride[ 0 ];
|
|
bus = level.the_bus;
|
|
ent = self.enemyoverride[ 1 ];
|
|
if ( isDefined( ent ) )
|
|
{
|
|
if ( ent entity_is_on_bus( 1 ) )
|
|
{
|
|
if ( isDefined( self.isonbus ) && !self.isonbus )
|
|
{
|
|
if ( isDefined( bus.doorsclosed ) && bus.doorsclosed )
|
|
{
|
|
self.goalradius = 2;
|
|
location = self busgetclosestopening();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self.goalradius = 32;
|
|
}
|
|
}
|
|
}
|
|
return location;
|
|
}
|
|
|
|
attachpoweruptobus( powerup )
|
|
{
|
|
if ( !isDefined( powerup ) || !isDefined( level.the_bus ) )
|
|
{
|
|
return;
|
|
}
|
|
distanceoutsideofbus = 50;
|
|
heightofroofpowerup = 60;
|
|
heightoffloorpowerup = 25;
|
|
originofbus = level.the_bus gettagorigin( "tag_origin" );
|
|
floorofbus = originofbus[ 2 ] + level.the_bus.floor;
|
|
adjustup = 0;
|
|
adjustdown = 0;
|
|
adjustin = 0;
|
|
pos = powerup.origin;
|
|
posinbus = pointonsegmentnearesttopoint( level.the_bus.frontworld, level.the_bus.backworld, pos );
|
|
posdist2 = distance2dsquared( pos, posinbus );
|
|
if ( posdist2 > ( level.the_bus.radius * level.the_bus.radius ) )
|
|
{
|
|
radiusplus = level.the_bus.radius + distanceoutsideofbus;
|
|
if ( posdist2 > ( radiusplus * radiusplus ) )
|
|
{
|
|
return;
|
|
}
|
|
adjustin = 1;
|
|
}
|
|
if ( !adjustin )
|
|
{
|
|
bus_front_local = ( 276, 28, 0 );
|
|
bus_front_local_world = level.the_bus localtoworldcoords( bus_front_local );
|
|
bus_front_radius2 = 10000;
|
|
front_dist2 = distance2dsquared( powerup.origin, bus_front_local_world );
|
|
if ( front_dist2 < bus_front_radius2 )
|
|
{
|
|
adjustin = 1;
|
|
}
|
|
}
|
|
if ( adjustin )
|
|
{
|
|
directiontobus = posinbus - pos;
|
|
directiontobusn = vectornormalize( directiontobus );
|
|
howfarintobus = distanceoutsideofbus + 10;
|
|
powerup.origin += directiontobusn * howfarintobus;
|
|
}
|
|
poszdelta = powerup.origin[ 2 ] - posinbus[ 2 ];
|
|
if ( poszdelta < ( level.the_bus.floor + heightoffloorpowerup ) )
|
|
{
|
|
adjustup = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( poszdelta > ( level.the_bus.height - 20 ) )
|
|
{
|
|
adjustdown = 1;
|
|
}
|
|
}
|
|
if ( adjustup )
|
|
{
|
|
powerup.origin = ( powerup.origin[ 0 ], powerup.origin[ 1 ], floorofbus + heightoffloorpowerup );
|
|
}
|
|
else
|
|
{
|
|
if ( adjustdown )
|
|
{
|
|
powerup.origin = ( powerup.origin[ 0 ], powerup.origin[ 1 ], floorofbus + heightofroofpowerup );
|
|
}
|
|
}
|
|
powerup linkto( level.the_bus, "", level.the_bus worldtolocalcoords( powerup.origin ), powerup.angles - level.the_bus.angles );
|
|
}
|
|
|
|
shouldsuppressgibs( zombie )
|
|
{
|
|
if ( !isDefined( zombie ) || !isDefined( level.the_bus ) )
|
|
{
|
|
return 0;
|
|
}
|
|
pos = zombie.origin;
|
|
posinbus = pointonsegmentnearesttopoint( level.the_bus.frontworld, level.the_bus.backworld, pos );
|
|
poszdelta = pos[ 2 ] - posinbus[ 2 ];
|
|
if ( poszdelta < ( level.the_bus.floor - 10 ) )
|
|
{
|
|
return 0;
|
|
}
|
|
posdist2 = distance2dsquared( pos, posinbus );
|
|
if ( posdist2 > ( level.the_bus.radius * level.the_bus.radius ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
bus_bridge_speedcontrol()
|
|
{
|
|
while ( 1 )
|
|
{
|
|
self waittill( "reached_node", nextpoint );
|
|
/#
|
|
if ( getDvarInt( #"583AF524" ) != 0 )
|
|
{
|
|
if ( isDefined( nextpoint.target ) )
|
|
{
|
|
futurenode = getvehiclenode( nextpoint.target, "targetname" );
|
|
if ( isDefined( futurenode.script_noteworthy ) && futurenode.script_noteworthy == "emp_stop_point" )
|
|
{
|
|
player = get_players()[ 0 ];
|
|
player thread maps/mp/zombies/_zm_weap_emp_bomb::emp_detonate( player magicgrenadetype( "emp_grenade_zm", self.origin + vectorScale( ( 0, 0, 1 ), 10 ), ( 0, 0, 1 ), 0,05 ) );
|
|
#/
|
|
}
|
|
}
|
|
}
|
|
if ( isDefined( nextpoint.script_string ) )
|
|
{
|
|
if ( nextpoint.script_string == "arrival_slowdown" )
|
|
{
|
|
self thread start_stopping_bus();
|
|
}
|
|
if ( nextpoint.script_string == "arrival_slowdown_fast" )
|
|
{
|
|
self thread start_stopping_bus( 1 );
|
|
}
|
|
}
|
|
while ( isDefined( nextpoint.script_noteworthy ) )
|
|
{
|
|
if ( nextpoint.script_noteworthy == "slow_down" )
|
|
{
|
|
self.targetspeed = 10;
|
|
if ( isDefined( nextpoint.script_float ) )
|
|
{
|
|
self.targetspeed = nextpoint.script_float;
|
|
}
|
|
self setspeed( self.targetspeed, 80, 5 );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "turn_signal_left" || nextpoint.script_noteworthy == "turn_signal_right" )
|
|
{
|
|
self thread buslightsignal( nextpoint.script_noteworthy );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( nextpoint.script_noteworthy == "resume_speed" )
|
|
{
|
|
self.targetspeed = 12;
|
|
if ( isDefined( nextpoint.script_float ) )
|
|
{
|
|
self.targetspeed = nextpoint.script_float;
|
|
}
|
|
self setspeed( self.targetspeed, 60, 60 );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "emp_stop_point" )
|
|
{
|
|
self notify( "reached_emp_stop_point" );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "start_lava" )
|
|
{
|
|
playfxontag( level._effect[ "bus_lava_driving" ], self, "tag_origin" );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "stop_lava" )
|
|
{
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "bus_scrape" )
|
|
{
|
|
self playsound( "zmb_bus_car_scrape" );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "arriving" )
|
|
{
|
|
self thread begin_arrival_slowdown();
|
|
self thread play_bus_audio( "arriving" );
|
|
level thread do_player_bus_zombie_vox( "bus_stop", 10 );
|
|
self thread buslightsignal( "turn_signal_right" );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "enter_transition" )
|
|
{
|
|
playfxontag( level._effect[ "fx_zbus_trans_fog" ], self, "tag_headlights" );
|
|
break;
|
|
}
|
|
else if ( nextpoint.script_noteworthy == "bridge" )
|
|
{
|
|
level thread do_automaton_arrival_vox( "bridge" );
|
|
player_near = 0;
|
|
node = getvehiclenode( "bridge_accel_point", "script_noteworthy" );
|
|
while ( isDefined( node ) )
|
|
{
|
|
players = get_players();
|
|
_a3956 = players;
|
|
_k3956 = getFirstArrayKey( _a3956 );
|
|
while ( isDefined( _k3956 ) )
|
|
{
|
|
player = _a3956[ _k3956 ];
|
|
if ( player.isonbus )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( distancesquared( player.origin, node.origin ) < 6760000 )
|
|
{
|
|
player_near = 1;
|
|
}
|
|
}
|
|
_k3956 = getNextArrayKey( _a3956, _k3956 );
|
|
}
|
|
}
|
|
if ( player_near )
|
|
{
|
|
trig = getent( "bridge_trig", "targetname" );
|
|
trig notify( "trigger" );
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
while ( nextpoint.script_noteworthy == "depot" )
|
|
{
|
|
volume = getent( "depot_lava_pit", "targetname" );
|
|
traverse_volume = getent( "depot_pit_traverse", "targetname" );
|
|
while ( isDefined( volume ) )
|
|
{
|
|
zombies = getaiarray( level.zombie_team );
|
|
i = 0;
|
|
while ( i < zombies.size )
|
|
{
|
|
if ( isDefined( zombies[ i ].depot_lava_pit ) )
|
|
{
|
|
if ( zombies[ i ] istouching( volume ) )
|
|
{
|
|
zombies[ i ] thread [[ zombies[ i ].depot_lava_pit ]]();
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( zombies[ i ] istouching( volume ) )
|
|
{
|
|
zombies[ i ] dodamage( zombies[ i ].health + 100, zombies[ i ].origin );
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( zombies[ i ] istouching( traverse_volume ) )
|
|
{
|
|
zombies[ i ] dodamage( zombies[ i ].health + 100, zombies[ i ].origin );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
waittillframeend;
|
|
}
|
|
}
|
|
|
|
bus_audio_setup()
|
|
{
|
|
if ( !isDefined( self ) )
|
|
{
|
|
return;
|
|
}
|
|
self.engine_ent_1 = spawn( "script_origin", self.origin );
|
|
self.engine_ent_1 linkto( self, "tag_wheel_back_left" );
|
|
self.engine_ent_2 = spawn( "script_origin", self.origin );
|
|
self.engine_ent_2 linkto( self, "tag_wheel_back_left" );
|
|
}
|
|
|
|
play_bus_audio( type )
|
|
{
|
|
level notify( "playing_bus_audio" );
|
|
level endon( "playing_bus_audio" );
|
|
if ( isDefined( self.disabled_by_emp ) && self.disabled_by_emp && type != "emp" )
|
|
{
|
|
self notify( "stop_bus_audio" );
|
|
self.engine_ent_1 stoploopsound( 0,5 );
|
|
self.engine_ent_2 stoploopsound( 0,5 );
|
|
return;
|
|
}
|
|
switch( type )
|
|
{
|
|
case "grace":
|
|
self.engine_ent_1 playloopsound( "zmb_bus_start_idle", 0,05 );
|
|
level.automaton playsound( "zmb_bus_horn_warn" );
|
|
break;
|
|
case "leaving":
|
|
level.automaton playsound( "zmb_bus_horn_leave" );
|
|
self.engine_ent_2 playloopsound( "zmb_bus_start_move", 0,05 );
|
|
self.engine_ent_1 stoploopsound( 2 );
|
|
wait 7;
|
|
if ( isDefined( self.disabled_by_emp ) && !self.disabled_by_emp )
|
|
{
|
|
self.engine_ent_1 playloopsound( "zmb_bus_exterior_loop", 2 );
|
|
self.engine_ent_2 stoploopsound( 3 );
|
|
}
|
|
break;
|
|
case "arriving":
|
|
level.automaton playsound( "zmb_bus_horn_leave" );
|
|
break;
|
|
case "stopping":
|
|
self notify( "stop_bus_audio" );
|
|
level.automaton playsound( "zmb_bus_horn_leave" );
|
|
self.engine_ent_1 stoploopsound( 3 );
|
|
self.engine_ent_2 stoploopsound( 3 );
|
|
self.engine_ent_2 playsound( "zmb_bus_stop_move" );
|
|
self playsound( "zmb_bus_car_scrape" );
|
|
break;
|
|
case "emp":
|
|
self notify( "stop_bus_audio" );
|
|
self.engine_ent_1 stoploopsound( 0,5 );
|
|
self.engine_ent_2 stoploopsound( 0,5 );
|
|
self.engine_ent_2 playsound( "zmb_bus_emp_shutdown" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
bus_audio_interior_loop( bus )
|
|
{
|
|
self endon( "left bus" );
|
|
while ( !bus.ismoving || isDefined( bus.disabled_by_emp ) && bus.disabled_by_emp )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
self clientnotify( "buslps" );
|
|
self thread bus_audio_turnoff_interior_player( bus );
|
|
self thread bus_audio_turnoff_interior_bus( bus );
|
|
}
|
|
|
|
bus_audio_turnoff_interior_player( bus )
|
|
{
|
|
bus endon( "stop_bus_audio" );
|
|
self waittill_any( "left bus", "death", "player_suicide", "bled_out" );
|
|
self clientnotify( "buslpe" );
|
|
}
|
|
|
|
bus_audio_turnoff_interior_bus( bus )
|
|
{
|
|
self endon( "left bus" );
|
|
self endon( "death" );
|
|
self endon( "player_suicide" );
|
|
self endon( "bled_out" );
|
|
bus waittill( "stop_bus_audio" );
|
|
self clientnotify( "buslpe" );
|
|
}
|
|
|
|
play_lava_audio()
|
|
{
|
|
ent_back = spawn( "script_origin", self gettagorigin( "tag_wheel_back_left" ) );
|
|
ent_back linkto( self, "tag_wheel_back_left" );
|
|
ent_front = spawn( "script_origin", self gettagorigin( "tag_wheel_front_right" ) );
|
|
ent_front linkto( self, "tag_wheel_front_right" );
|
|
while ( 1 )
|
|
{
|
|
while ( isDefined( self.ismoving ) && !self.ismoving )
|
|
{
|
|
wait 1;
|
|
}
|
|
while ( self maps/mp/zm_transit_lava::object_touching_lava() && self.zone != "zone_station_ext" && self.zone != "zone_pri" )
|
|
{
|
|
ent_front playloopsound( "zmb_bus_lava_wheels_loop", 0,5 );
|
|
ent_back playloopsound( "zmb_bus_lava_wheels_loop", 0,5 );
|
|
wait 2;
|
|
while ( self maps/mp/zm_transit_lava::object_touching_lava() )
|
|
{
|
|
wait 2;
|
|
}
|
|
}
|
|
if ( isDefined( ent_back ) && isDefined( ent_front ) )
|
|
{
|
|
ent_front stoploopsound( 1 );
|
|
ent_back stoploopsound( 1 );
|
|
}
|
|
wait 2;
|
|
}
|
|
}
|
|
|
|
delete_lava_audio_ents( ent1, ent2 )
|
|
{
|
|
self waittill( "stop_bus_audio" );
|
|
ent1 delete();
|
|
ent2 delete();
|
|
}
|
|
|
|
start_stopping_bus( stop_fast )
|
|
{
|
|
if ( isDefined( stop_fast ) && stop_fast )
|
|
{
|
|
self setspeed( 4, 15 );
|
|
}
|
|
else
|
|
{
|
|
self setspeed( 4, 5 );
|
|
}
|
|
}
|
|
|
|
begin_arrival_slowdown()
|
|
{
|
|
self setspeed( 5 );
|
|
}
|
|
|
|
do_automoton_vox( name )
|
|
{
|
|
if ( !issubstr( name, "vox_" ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( level.stops ) )
|
|
{
|
|
level.stops = [];
|
|
}
|
|
if ( !isDefined( level.stops[ name ] ) )
|
|
{
|
|
level.stops[ name ] = 0;
|
|
}
|
|
level.stops[ name ]++;
|
|
if ( level.stops[ name ] > 5 )
|
|
{
|
|
level.stops[ name ] = 4;
|
|
}
|
|
switch( name )
|
|
{
|
|
case "vox_enter_tunnel":
|
|
level thread automatonspeak( "inform", "near_tunnel" + level.stops[ name ] );
|
|
break;
|
|
case "vox_ride_generic":
|
|
if ( isDefined( level.stops ) && isDefined( level.stops[ "depot" ] ) && level.stops[ "depot" ] < 1 )
|
|
{
|
|
return;
|
|
}
|
|
level thread automatonspeak( "inform", "ride_generic" );
|
|
break;
|
|
case "vox_exit_tunnel":
|
|
if ( isDefined( level.tunnel_exit_vox_played ) && !level.tunnel_exit_vox_played )
|
|
{
|
|
level thread automatonspeak( "inform", "leave_tunnel" );
|
|
level.tunnel_exit_vox_played = 1;
|
|
}
|
|
break;
|
|
case "vox_cornfield":
|
|
level thread automatonspeak( "inform", "near_corn" + level.stops[ name ] );
|
|
break;
|
|
case "vox_forest1":
|
|
level thread automatonspeak( "inform", "near_forest1_" + level.stops[ name ] );
|
|
break;
|
|
case "vox_forest2":
|
|
level thread automatonspeak( "inform", "near_forest2_" + level.stops[ name ] );
|
|
break;
|
|
}
|
|
}
|
|
|
|
do_automaton_arrival_vox( destination )
|
|
{
|
|
if ( !isDefined( level.stops ) )
|
|
{
|
|
level.stops = [];
|
|
}
|
|
if ( !isDefined( level.stops[ destination ] ) )
|
|
{
|
|
level.stops[ destination ] = 0;
|
|
}
|
|
if ( destination == "depot" && isDefined( level.bus_intro_done ) && !level.bus_intro_done )
|
|
{
|
|
return;
|
|
}
|
|
level.stops[ destination ]++;
|
|
if ( level.stops[ destination ] > 5 )
|
|
{
|
|
level.stops[ destination ] = 4;
|
|
}
|
|
switch( destination )
|
|
{
|
|
case "depot":
|
|
if ( isDefined( level.bus_intro_done ) && !level.bus_intro_done )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
level thread automatonspeak( "inform", "near_station" + level.stops[ destination ] );
|
|
break;
|
|
return;
|
|
case "diner":
|
|
case "farm":
|
|
case "power":
|
|
case "town":
|
|
level thread automatonspeak( "inform", "near_" + destination + level.stops[ destination ] );
|
|
break;
|
|
return;
|
|
case "bridge":
|
|
if ( isDefined( level.collapse_vox_said ) && level.collapse_vox_said )
|
|
{
|
|
level thread automatonspeak( "inform", "near_" + destination + level.stops[ destination ] );
|
|
}
|
|
break;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
do_player_bus_location_vox( node_info )
|
|
{
|
|
players = get_players();
|
|
players = array_randomize( players );
|
|
valid_player = undefined;
|
|
_a4291 = players;
|
|
_k4291 = getFirstArrayKey( _a4291 );
|
|
while ( isDefined( _k4291 ) )
|
|
{
|
|
player = _a4291[ _k4291 ];
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
valid_player = player;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_k4291 = getNextArrayKey( _a4291, _k4291 );
|
|
}
|
|
}
|
|
if ( !isDefined( valid_player ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( isDefined( level.bus_zombie_danger ) && level.bus_zombie_danger && !valid_player.talks_in_danger )
|
|
{
|
|
return;
|
|
}
|
|
vo_line = undefined;
|
|
if ( issubstr( node_info, "map_in" ) )
|
|
{
|
|
if ( !isDefined( level.arrivals ) )
|
|
{
|
|
level.arrivals = [];
|
|
}
|
|
if ( !isDefined( level.arrivals[ node_info ] ) )
|
|
{
|
|
level.arrivals[ node_info ] = 0;
|
|
}
|
|
level.arrivals[ node_info ]++;
|
|
if ( level.arrivals[ node_info ] > 4 )
|
|
{
|
|
level.arrivals[ node_info ] = 4;
|
|
}
|
|
vo_line = node_info + level.arrivals[ node_info ];
|
|
}
|
|
else
|
|
{
|
|
vo_line = node_info;
|
|
if ( randomint( 100 ) > 75 )
|
|
{
|
|
vo_line = "bus_ride";
|
|
}
|
|
}
|
|
if ( !isDefined( vo_line ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( randomint( 100 ) < 25 )
|
|
{
|
|
valid_player thread maps/mp/zombies/_zm_audio::create_and_play_dialog( "general", vo_line );
|
|
}
|
|
}
|
|
|
|
do_player_bus_zombie_vox( event, chance, timer )
|
|
{
|
|
if ( isDefined( level.doing_bus_zombie_vox ) || level.doing_bus_zombie_vox && !isDefined( event ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( chance ) )
|
|
{
|
|
chance = 100;
|
|
}
|
|
time = 30;
|
|
if ( isDefined( timer ) )
|
|
{
|
|
time = timer;
|
|
}
|
|
players = get_players();
|
|
players = array_randomize( players );
|
|
valid_player = undefined;
|
|
_a4374 = players;
|
|
_k4374 = getFirstArrayKey( _a4374 );
|
|
while ( isDefined( _k4374 ) )
|
|
{
|
|
player = _a4374[ _k4374 ];
|
|
if ( isDefined( player.isonbus ) && player.isonbus )
|
|
{
|
|
valid_player = player;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
_k4374 = getNextArrayKey( _a4374, _k4374 );
|
|
}
|
|
}
|
|
if ( isDefined( valid_player ) )
|
|
{
|
|
valid_player thread do_player_general_vox( "general", event, time, chance );
|
|
level.doing_bus_zombie_vox = 1;
|
|
wait 10;
|
|
level.doing_bus_zombie_vox = 0;
|
|
}
|
|
}
|