mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-22 16:47:53 -05:00
1450 lines
35 KiB
Plaintext
1450 lines
35 KiB
Plaintext
#include maps/mp/gametypes/_dev;
|
|
#include maps/mp/gametypes/_hud;
|
|
#include maps/mp/killstreaks/_radar;
|
|
#include maps/mp/killstreaks/_dogs;
|
|
#include maps/mp/_scoreevents;
|
|
#include maps/mp/_challenges;
|
|
#include maps/mp/killstreaks/_remote_weapons;
|
|
#include maps/mp/gametypes/_spawning;
|
|
#include maps/mp/_entityheadicons;
|
|
#include maps/mp/killstreaks/_emp;
|
|
#include maps/mp/killstreaks/_killstreakrules;
|
|
#include maps/mp/gametypes/_spawnlogic;
|
|
#include maps/mp/killstreaks/_airsupport;
|
|
#include maps/mp/killstreaks/_supplydrop;
|
|
#include maps/mp/killstreaks/_killstreaks;
|
|
#include common_scripts/utility;
|
|
#include maps/mp/gametypes/_weapons;
|
|
#include maps/mp/_utility;
|
|
|
|
#using_animtree( "mp_vehicles" );
|
|
|
|
init()
|
|
{
|
|
precachevehicle( "ai_tank_drone_mp" );
|
|
precachemodel( "veh_t6_drone_tank" );
|
|
precachemodel( "veh_t6_drone_tank_alt" );
|
|
precacheitem( "ai_tank_drone_rocket_mp" );
|
|
precacheitem( "killstreak_ai_tank_mp" );
|
|
precacheshader( "mech_check_line" );
|
|
precacheshader( "mech_check_fill" );
|
|
precacheshader( "mech_flame_bar" );
|
|
precacheshader( "mech_flame_arrow_flipped" );
|
|
loadfx( "vehicle/treadfx/fx_treadfx_talon_dirt" );
|
|
loadfx( "vehicle/treadfx/fx_treadfx_talon_concrete" );
|
|
loadfx( "light/fx_vlight_talon_eye_grn" );
|
|
loadfx( "light/fx_vlight_talon_eye_red" );
|
|
loadfx( "weapon/talon/fx_talon_emp_stun" );
|
|
level.ai_tank_minigun_flash_3p = loadfx( "weapon/talon/fx_muz_talon_rocket_flash_1p" );
|
|
registerkillstreak( "inventory_ai_tank_drop_mp", "inventory_ai_tank_drop_mp", "killstreak_ai_tank_drop", "ai_tank_drop_used", ::usekillstreakaitankdrop );
|
|
registerkillstreakaltweapon( "inventory_ai_tank_drop_mp", "ai_tank_drone_gun_mp" );
|
|
registerkillstreakaltweapon( "inventory_ai_tank_drop_mp", "ai_tank_drone_rocket_mp" );
|
|
registerkillstreakremoteoverrideweapon( "inventory_ai_tank_drop_mp", "killstreak_ai_tank_mp" );
|
|
registerkillstreakstrings( "inventory_ai_tank_drop_mp", &"KILLSTREAK_EARNED_AI_TANK_DROP", &"KILLSTREAK_AI_TANK_NOT_AVAILABLE", &"KILLSTREAK_AI_TANK_INBOUND" );
|
|
registerkillstreakdialog( "inventory_ai_tank_drop_mp", "mpl_killstreak_ai_tank", "kls_aitank_used", "", "kls_aitank_enemy", "", "kls_aitank_ready" );
|
|
registerkillstreakdevdvar( "inventory_ai_tank_drop_mp", "scr_giveaitankdrop" );
|
|
registerkillstreak( "ai_tank_drop_mp", "ai_tank_drop_mp", "killstreak_ai_tank_drop", "ai_tank_drop_used", ::usekillstreakaitankdrop );
|
|
registerkillstreakaltweapon( "ai_tank_drop_mp", "ai_tank_drone_gun_mp" );
|
|
registerkillstreakaltweapon( "ai_tank_drop_mp", "ai_tank_drone_rocket_mp" );
|
|
registerkillstreakremoteoverrideweapon( "ai_tank_drop_mp", "killstreak_ai_tank_mp" );
|
|
registerkillstreakstrings( "ai_tank_drop_mp", &"KILLSTREAK_EARNED_AI_TANK_DROP", &"KILLSTREAK_AI_TANK_NOT_AVAILABLE", &"KILLSTREAK_AI_TANK_INBOUND" );
|
|
registerkillstreakdialog( "ai_tank_drop_mp", "mpl_killstreak_ai_tank", "kls_aitank_used", "", "kls_aitank_enemy", "", "kls_aitank_ready" );
|
|
level.ai_tank_fov = cos( 160 );
|
|
level.ai_tank_turret_fire_rate = weaponfiretime( "ai_tank_drone_gun_mp" );
|
|
level.ai_tank_valid_locations = [];
|
|
spawns = maps/mp/gametypes/_spawnlogic::getspawnpointarray( "mp_tdm_spawn" );
|
|
level.ai_tank_damage_fx = loadfx( "weapon/talon/fx_talon_damage_state" );
|
|
level.ai_tank_explode_fx = loadfx( "weapon/talon/fx_talon_exp" );
|
|
level.ai_tank_crate_explode_fx = loadfx( "weapon/talon/fx_talon_drop_box" );
|
|
_a73 = spawns;
|
|
_k73 = getFirstArrayKey( _a73 );
|
|
while ( isDefined( _k73 ) )
|
|
{
|
|
spawn = _a73[ _k73 ];
|
|
level.ai_tank_valid_locations[ level.ai_tank_valid_locations.size ] = spawn.origin;
|
|
_k73 = getNextArrayKey( _a73, _k73 );
|
|
}
|
|
anims = [];
|
|
anims[ anims.size ] = %o_drone_tank_missile1_fire;
|
|
anims[ anims.size ] = %o_drone_tank_missile2_fire;
|
|
anims[ anims.size ] = %o_drone_tank_missile3_fire;
|
|
anims[ anims.size ] = %o_drone_tank_missile_full_reload;
|
|
setdvar( "scr_ai_tank_no_timeout", 0 );
|
|
/#
|
|
level thread tank_devgui_think();
|
|
#/
|
|
}
|
|
|
|
register()
|
|
{
|
|
registerclientfield( "vehicle", "ai_tank_death", 1, 1, "int" );
|
|
registerclientfield( "vehicle", "ai_tank_hack_spawned", 1, 1, "int" );
|
|
registerclientfield( "vehicle", "ai_tank_hack_rebooting", 1, 1, "int" );
|
|
registerclientfield( "vehicle", "ai_tank_missile_fire", 1, 3, "int" );
|
|
}
|
|
|
|
usekillstreakaitankdrop( hardpointtype )
|
|
{
|
|
team = self.team;
|
|
if ( !self maps/mp/killstreaks/_supplydrop::issupplydropgrenadeallowed( hardpointtype ) )
|
|
{
|
|
return 0;
|
|
}
|
|
killstreak_id = self maps/mp/killstreaks/_killstreakrules::killstreakstart( hardpointtype, team, 0, 0 );
|
|
if ( killstreak_id == -1 )
|
|
{
|
|
return 0;
|
|
}
|
|
result = self maps/mp/killstreaks/_supplydrop::usesupplydropmarker( killstreak_id );
|
|
self notify( "supply_drop_marker_done" );
|
|
if ( !isDefined( result ) || !result )
|
|
{
|
|
maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointtype, team, killstreak_id );
|
|
return 0;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
crateland( crate, weaponname, owner, team )
|
|
{
|
|
if ( crate valid_location() && isDefined( owner ) || team != owner.team && owner maps/mp/killstreaks/_emp::isenemyempkillstreakactive() )
|
|
{
|
|
maps/mp/killstreaks/_killstreakrules::killstreakstop( weaponname, team, crate.package_contents_id );
|
|
wait 10;
|
|
crate delete();
|
|
return;
|
|
}
|
|
origin = crate.origin;
|
|
cratebottom = bullettrace( origin, origin + vectorScale( ( 0, 0, 1 ), 50 ), 0, crate );
|
|
if ( isDefined( cratebottom ) )
|
|
{
|
|
origin = cratebottom[ "position" ] + ( 0, 0, 1 );
|
|
}
|
|
playfx( level.ai_tank_crate_explode_fx, origin, ( 0, 0, 1 ), ( 0, 0, 1 ) );
|
|
playsoundatposition( "veh_talon_crate_exp", crate.origin );
|
|
level thread ai_tank_killstreak_start( owner, origin, crate.package_contents_id, weaponname );
|
|
crate delete();
|
|
}
|
|
|
|
valid_location()
|
|
{
|
|
node = getnearestnode( self.origin );
|
|
if ( !isDefined( node ) )
|
|
{
|
|
return 0;
|
|
}
|
|
start = self getcentroid();
|
|
end = node.origin + vectorScale( ( 0, 0, 1 ), 8 );
|
|
trace = physicstrace( start, end, ( 0, 0, 1 ), ( 0, 0, 1 ), self, level.physicstracecontentsvehicleclip );
|
|
if ( trace[ "fraction" ] < 1 )
|
|
{
|
|
return 0;
|
|
}
|
|
origin = self.origin + vectorScale( ( 0, 0, 1 ), 32 );
|
|
level.ai_tank_valid_locations = array_randomize( level.ai_tank_valid_locations );
|
|
count = min( level.ai_tank_valid_locations.size, 5 );
|
|
i = 0;
|
|
while ( i < count )
|
|
{
|
|
if ( findpath( origin, level.ai_tank_valid_locations[ i ], self, 0, 1 ) )
|
|
{
|
|
return 1;
|
|
}
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ai_tank_killstreak_start( owner, origin, killstreak_id, weaponname )
|
|
{
|
|
waittillframeend;
|
|
drone = spawnvehicle( "veh_t6_drone_tank", "talon", "ai_tank_drone_mp", origin, ( 0, 0, 1 ) );
|
|
drone setenemymodel( "veh_t6_drone_tank_alt" );
|
|
drone playloopsound( "veh_talon_idle_npc", 0,2 );
|
|
drone setvehicleavoidance( 1 );
|
|
drone setclientfield( "ai_tank_missile_fire", 4 );
|
|
drone setowner( owner );
|
|
drone.owner = owner;
|
|
drone.team = owner.team;
|
|
drone.aiteam = owner.team;
|
|
drone.killstreak_id = killstreak_id;
|
|
drone.type = "tank_drone";
|
|
if ( level.teambased )
|
|
{
|
|
drone setteam( owner.team );
|
|
}
|
|
else
|
|
{
|
|
drone setteam( "free" );
|
|
}
|
|
drone maps/mp/_entityheadicons::setentityheadicon( drone.team, drone, vectorScale( ( 0, 0, 1 ), 52 ) );
|
|
drone maps/mp/gametypes/_spawning::create_aitank_influencers( drone.team );
|
|
drone.controlled = 0;
|
|
drone makevehicleunusable();
|
|
drone.numberrockets = 3;
|
|
drone.warningshots = 3;
|
|
drone setdrawinfrared( 1 );
|
|
if ( !isDefined( drone.owner.numtankdrones ) )
|
|
{
|
|
drone.owner.numtankdrones = 1;
|
|
}
|
|
else
|
|
{
|
|
drone.owner.numtankdrones++;
|
|
}
|
|
drone.ownernumber = drone.owner.numtankdrones;
|
|
target_set( drone, vectorScale( ( 0, 0, 1 ), 20 ) );
|
|
target_setturretaquire( drone, 0 );
|
|
drone thread tank_move_think();
|
|
drone thread tank_aim_think();
|
|
drone thread tank_combat_think();
|
|
drone thread tank_death_think( weaponname );
|
|
drone thread tank_damage_think();
|
|
drone thread tank_abort_think();
|
|
drone thread tank_team_kill();
|
|
drone thread tank_ground_abort_think();
|
|
drone thread tank_riotshield_think();
|
|
drone thread tank_rocket_think();
|
|
owner maps/mp/killstreaks/_remote_weapons::initremoteweapon( drone, "killstreak_ai_tank_mp" );
|
|
drone thread deleteonkillbrush( drone.owner );
|
|
level thread tank_game_end_think( drone );
|
|
/#
|
|
#/
|
|
}
|
|
|
|
tank_team_kill()
|
|
{
|
|
self endon( "death" );
|
|
self.owner waittill( "teamKillKicked" );
|
|
self notify( "death" );
|
|
}
|
|
|
|
tank_abort_think()
|
|
{
|
|
self endon( "death" );
|
|
self.owner wait_endon( 120, "disconnect", "joined_team", "joined_spectators", "emp_jammed" );
|
|
shouldtimeout = getDvar( "scr_ai_tank_no_timeout" );
|
|
if ( shouldtimeout == "1" )
|
|
{
|
|
return;
|
|
}
|
|
self notify( "death" );
|
|
}
|
|
|
|
tank_game_end_think( drone )
|
|
{
|
|
drone endon( "death" );
|
|
level waittill( "game_ended" );
|
|
drone notify( "death" );
|
|
}
|
|
|
|
stop_remote()
|
|
{
|
|
if ( !isDefined( self ) )
|
|
{
|
|
return;
|
|
}
|
|
self clearusingremote();
|
|
self.killstreak_waitamount = undefined;
|
|
self destroy_remote_hud();
|
|
self clientnotify( "nofutz" );
|
|
}
|
|
|
|
tank_damage_think()
|
|
{
|
|
self endon( "death" );
|
|
self.maxhealth = 999999;
|
|
self.health = self.maxhealth;
|
|
self.isstunned = 0;
|
|
low_health = 0;
|
|
damage_taken = 0;
|
|
for ( ;; )
|
|
{
|
|
self waittill( "damage", damage, attacker, dir, point, mod, model, tag, part, weapon, flags );
|
|
self.maxhealth = 999999;
|
|
self.health = self.maxhealth;
|
|
/#
|
|
self.damage_debug = ( damage + " (" ) + weapon + ")";
|
|
#/
|
|
if ( weapon == "emp_grenade_mp" && mod == "MOD_GRENADE_SPLASH" )
|
|
{
|
|
damage_taken += 400;
|
|
damage = 0;
|
|
if ( !self.isstunned )
|
|
{
|
|
maps/mp/_challenges::stunnedtankwithempgrenade( attacker );
|
|
self thread tank_stun( 4 );
|
|
self.isstunned = 1;
|
|
}
|
|
}
|
|
if ( !self.isstunned )
|
|
{
|
|
if ( weapon != "proximity_grenade_mp" && weapon == "proximity_grenade_aoe_mp" || mod == "MOD_GRENADE_SPLASH" && mod == "MOD_GAS" )
|
|
{
|
|
self thread tank_stun( 1,5 );
|
|
self.isstunned = 1;
|
|
}
|
|
}
|
|
if ( mod != "MOD_RIFLE_BULLET" && mod != "MOD_PISTOL_BULLET" || weapon == "hatchet_mp" && mod == "MOD_PROJECTILE_SPLASH" && isexplosivebulletweapon( weapon ) )
|
|
{
|
|
if ( isplayer( attacker ) )
|
|
{
|
|
if ( attacker hasperk( "specialty_armorpiercing" ) )
|
|
{
|
|
damage += int( damage * level.cac_armorpiercing_data );
|
|
}
|
|
}
|
|
if ( weaponclass( weapon ) == "spread" )
|
|
{
|
|
damage *= 4,5;
|
|
}
|
|
damage *= 0,3;
|
|
}
|
|
if ( mod != "MOD_PROJECTILE" && mod != "MOD_GRENADE_SPLASH" && mod == "MOD_PROJECTILE_SPLASH" && damage != 0 && weapon != "emp_grenade_mp" && !isexplosivebulletweapon( weapon ) )
|
|
{
|
|
damage *= 1,5;
|
|
}
|
|
if ( self.controlled )
|
|
{
|
|
self.owner sendkillstreakdamageevent( int( damage ) );
|
|
}
|
|
damage_taken += damage;
|
|
if ( damage_taken >= 800 )
|
|
{
|
|
self notify( "death" );
|
|
return;
|
|
}
|
|
if ( !low_health && damage_taken > 444,4445 )
|
|
{
|
|
self thread tank_low_health_fx();
|
|
low_health = 1;
|
|
}
|
|
if ( isDefined( attacker ) && isplayer( attacker ) && self tank_is_idle() && !self.isstunned )
|
|
{
|
|
self.aim_entity.origin = attacker getcentroid();
|
|
self.aim_entity.delay = 8;
|
|
self notify( "aim_updated" );
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_low_health_fx()
|
|
{
|
|
self endon( "death" );
|
|
self.damage_fx = spawn( "script_model", self gettagorigin( "tag_origin" ) + vectorScale( ( 0, 0, 1 ), 14 ) );
|
|
self.damage_fx setmodel( "tag_origin" );
|
|
self.damage_fx linkto( self, "tag_turret", vectorScale( ( 0, 0, 1 ), 14 ), ( 0, 0, 1 ) );
|
|
wait 0,1;
|
|
playfxontag( level.ai_tank_damage_fx, self.damage_fx, "tag_origin" );
|
|
}
|
|
|
|
deleteonkillbrush( player )
|
|
{
|
|
player endon( "disconnect" );
|
|
self endon( "death" );
|
|
killbrushes = getentarray( "trigger_hurt", "classname" );
|
|
while ( 1 )
|
|
{
|
|
i = 0;
|
|
while ( i < killbrushes.size )
|
|
{
|
|
if ( self istouching( killbrushes[ i ] ) )
|
|
{
|
|
if ( isDefined( self ) )
|
|
{
|
|
self notify( "death" );
|
|
}
|
|
return;
|
|
}
|
|
i++;
|
|
}
|
|
wait 0,1;
|
|
}
|
|
}
|
|
|
|
tank_stun( duration )
|
|
{
|
|
self endon( "death" );
|
|
self notify( "stunned" );
|
|
self clearvehgoalpos();
|
|
forward = anglesToForward( self.angles );
|
|
forward = self.origin + ( forward * 128 );
|
|
forward -= vectorScale( ( 0, 0, 1 ), 64 );
|
|
self setturrettargetvec( forward );
|
|
self disablegunnerfiring( 0, 1 );
|
|
self laseroff();
|
|
if ( self.controlled )
|
|
{
|
|
self.owner freezecontrols( 1 );
|
|
self.owner sendkillstreakdamageevent( 400 );
|
|
}
|
|
if ( isDefined( self.owner.fullscreen_static ) )
|
|
{
|
|
self.owner thread maps/mp/killstreaks/_remote_weapons::stunstaticfx( duration );
|
|
}
|
|
self setclientflag( 3 );
|
|
wait duration;
|
|
self clearclientflag( 3 );
|
|
if ( self.controlled )
|
|
{
|
|
self.owner freezecontrols( 0 );
|
|
}
|
|
if ( self.controlled == 0 )
|
|
{
|
|
self thread tank_move_think();
|
|
self thread tank_aim_think();
|
|
self thread tank_combat_think();
|
|
}
|
|
self disablegunnerfiring( 0, 0 );
|
|
self.isstunned = 0;
|
|
}
|
|
|
|
emp_crazy_death()
|
|
{
|
|
self setclientflag( 3 );
|
|
wait 1;
|
|
self notify( "death" );
|
|
time = 0;
|
|
randomangle = randomint( 360 );
|
|
while ( time < 1,45 )
|
|
{
|
|
self setturrettargetvec( self.origin + ( anglesToForward( ( randomintrange( 305, 315 ), int( randomangle + ( time * 180 ) ), 0 ) ) * 100 ) );
|
|
if ( time > 0,2 )
|
|
{
|
|
self fireweapon();
|
|
if ( randomint( 100 ) > 85 )
|
|
{
|
|
rocket = self firegunnerweapon( 0 );
|
|
if ( isDefined( rocket ) )
|
|
{
|
|
rocket.from_ai = 1;
|
|
}
|
|
}
|
|
}
|
|
time += 0,05;
|
|
wait 0,05;
|
|
}
|
|
self setclientfield( "ai_tank_death", 1 );
|
|
playfx( level.ai_tank_explode_fx, self.origin, ( 0, 0, 1 ) );
|
|
playsoundatposition( "wpn_agr_explode", self.origin );
|
|
wait 0,05;
|
|
self hide();
|
|
}
|
|
|
|
tank_death_think( hardpointname )
|
|
{
|
|
team = self.team;
|
|
self waittill( "death", attacker, type, weapon );
|
|
self.dead = 1;
|
|
self laseroff();
|
|
self clearvehgoalpos();
|
|
if ( self.controlled == 1 && isDefined( self.owner ) )
|
|
{
|
|
self.owner sendkillstreakdamageevent( 600 );
|
|
self.owner destroy_remote_hud();
|
|
}
|
|
if ( self.isstunned )
|
|
{
|
|
stunned = 1;
|
|
self thread emp_crazy_death();
|
|
wait 1,55;
|
|
}
|
|
else
|
|
{
|
|
self setclientfield( "ai_tank_death", 1 );
|
|
stunned = 0;
|
|
playfx( level.ai_tank_explode_fx, self.origin, ( 0, 0, 1 ) );
|
|
playsoundatposition( "wpn_agr_explode", self.origin );
|
|
wait 0,05;
|
|
self hide();
|
|
if ( isDefined( self.damage_fx ) )
|
|
{
|
|
self.damage_fx delete();
|
|
}
|
|
}
|
|
if ( isDefined( attacker ) && isplayer( attacker ) && isDefined( self.owner ) && attacker != self.owner )
|
|
{
|
|
if ( self.owner isenemyplayer( attacker ) )
|
|
{
|
|
maps/mp/_scoreevents::processscoreevent( "destroyed_aitank", attacker, self.owner, weapon );
|
|
attacker addweaponstat( weapon, "destroyed_aitank", 1 );
|
|
if ( isDefined( self.wascontrollednowdead ) && self.wascontrollednowdead )
|
|
{
|
|
attacker addweaponstat( weapon, "destroyed_controlled_killstreak", 1 );
|
|
}
|
|
}
|
|
}
|
|
wait 2;
|
|
maps/mp/killstreaks/_killstreakrules::killstreakstop( hardpointname, team, self.killstreak_id );
|
|
self.aim_entity delete();
|
|
self delete();
|
|
}
|
|
|
|
tank_move_think()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stunned" );
|
|
self endon( "remote_start" );
|
|
level endon( "game_ended" );
|
|
/#
|
|
self endon( "debug_patrol" );
|
|
#/
|
|
do_wait = 1;
|
|
for ( ;; )
|
|
{
|
|
if ( do_wait )
|
|
{
|
|
wait randomfloatrange( 1, 4 );
|
|
}
|
|
do_wait = 1;
|
|
if ( !tank_is_idle() )
|
|
{
|
|
enemy = tank_get_target();
|
|
if ( valid_target( enemy, self.team, self.owner ) )
|
|
{
|
|
if ( distancesquared( self.origin, enemy.origin ) < 65536 )
|
|
{
|
|
self clearvehgoalpos();
|
|
wait 1;
|
|
}
|
|
else if ( findpath( self.origin, enemy.origin, self, 0 ) )
|
|
{
|
|
self setvehgoalpos( enemy.origin, 1, 2 );
|
|
self wait_endon( 3, "reached_end_node" );
|
|
}
|
|
else
|
|
{
|
|
self clearvehgoalpos();
|
|
wait 1;
|
|
}
|
|
if ( valid_target( enemy, self.team, self.owner ) )
|
|
{
|
|
do_wait = 0;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
else avg_position = tank_compute_enemy_position();
|
|
if ( isDefined( avg_position ) )
|
|
{
|
|
nodes = getnodesinradiussorted( avg_position, 256, 0 );
|
|
}
|
|
else
|
|
{
|
|
nodes = getnodesinradiussorted( self.owner.origin, 1024, 256, 128 );
|
|
}
|
|
if ( nodes.size > 0 )
|
|
{
|
|
node = nodes[ 0 ];
|
|
}
|
|
else
|
|
{
|
|
}
|
|
if ( self setvehgoalpos( node.origin, 1, 2 ) )
|
|
{
|
|
event = self waittill_any_timeout( 45, "reached_end_node", "force_movement_wake" );
|
|
if ( event != "reached_end_node" )
|
|
{
|
|
do_wait = 0;
|
|
}
|
|
continue;
|
|
}
|
|
else self clearvehgoalpos();
|
|
}
|
|
}
|
|
|
|
tank_riotshield_think()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "remote_start" );
|
|
for ( ;; )
|
|
{
|
|
level waittill( "riotshield_planted", owner );
|
|
if ( owner == self.owner || owner.team == self.team )
|
|
{
|
|
if ( distancesquared( owner.riotshieldentity.origin, self.origin ) < 262144 )
|
|
{
|
|
self clearvehgoalpos();
|
|
}
|
|
self notify( "force_movement_wake" );
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_ground_abort_think()
|
|
{
|
|
self endon( "death" );
|
|
ground_trace_fail = 0;
|
|
for ( ;; )
|
|
{
|
|
wait 1;
|
|
nodes = getnodesinradius( self.origin, 256, 0, 128, "Path" );
|
|
if ( nodes.size <= 0 )
|
|
{
|
|
ground_trace_fail++;
|
|
}
|
|
else
|
|
{
|
|
ground_trace_fail = 0;
|
|
}
|
|
if ( ground_trace_fail >= 4 )
|
|
{
|
|
self notify( "death" );
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_aim_think()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stunned" );
|
|
self endon( "remote_start" );
|
|
if ( !isDefined( self.aim_entity ) )
|
|
{
|
|
self.aim_entity = spawn( "script_model", ( 0, 0, 1 ) );
|
|
}
|
|
self.aim_entity.delay = 0;
|
|
self tank_idle();
|
|
for ( ;; )
|
|
{
|
|
self wait_endon( randomfloatrange( 1, 3 ), "aim_updated" );
|
|
if ( self.aim_entity.delay > 0 )
|
|
{
|
|
wait self.aim_entity.delay;
|
|
self.aim_entity.delay = 0;
|
|
continue;
|
|
}
|
|
else if ( !tank_is_idle() )
|
|
{
|
|
continue;
|
|
}
|
|
else if ( self getspeed() <= 1 )
|
|
{
|
|
enemies = tank_get_player_enemies( 0 );
|
|
if ( enemies.size )
|
|
{
|
|
enemy = enemies[ 0 ];
|
|
node = getvisiblenode( self.origin, enemy.origin, self );
|
|
if ( isDefined( node ) )
|
|
{
|
|
self.aim_entity.origin = node.origin + vectorScale( ( 0, 0, 1 ), 16 );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
yaw = ( 0, self.angles[ 1 ] + randomintrange( -75, 75 ), 0 );
|
|
forward = anglesToForward( yaw );
|
|
origin = self.origin + ( forward * 1024 );
|
|
self.aim_entity.origin = ( origin[ 0 ], origin[ 1 ], origin[ 2 ] + 20 );
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_combat_think()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "stunned" );
|
|
self endon( "remote_start" );
|
|
level endon( "game_ended" );
|
|
for ( ;; )
|
|
{
|
|
wait 0,5;
|
|
self laseroff();
|
|
origin = self.origin + vectorScale( ( 0, 0, 1 ), 32 );
|
|
forward = vectornormalize( self.target_entity.origin - self.origin );
|
|
players = tank_get_player_enemies( 0 );
|
|
self tank_target_evaluate( players, origin, forward );
|
|
if ( level.gametype != "hack" )
|
|
{
|
|
dogs = maps/mp/killstreaks/_dogs::dog_manager_get_dogs();
|
|
self tank_target_evaluate( dogs, origin, forward );
|
|
tanks = getentarray( "talon", "targetname" );
|
|
self tank_target_evaluate( tanks, origin, forward );
|
|
rcbombs = getentarray( "rcbomb", "targetname" );
|
|
self tank_target_evaluate( rcbombs, origin, forward );
|
|
turrets = getentarray( "auto_turret", "classname" );
|
|
self tank_target_evaluate( turrets, origin, forward );
|
|
shields = getentarray( "riotshield_mp", "targetname" );
|
|
self tank_target_evaluate( shields, origin, forward );
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_target_evaluate( targets, origin, forward )
|
|
{
|
|
_a802 = targets;
|
|
_k802 = getFirstArrayKey( _a802 );
|
|
while ( isDefined( _k802 ) )
|
|
{
|
|
target = _a802[ _k802 ];
|
|
if ( !valid_target( target, self.team, self.owner ) )
|
|
{
|
|
}
|
|
else delta = target.origin - origin;
|
|
delta = vectornormalize( delta );
|
|
dot = vectordot( forward, delta );
|
|
if ( dot < level.ai_tank_fov )
|
|
{
|
|
}
|
|
else if ( !bullettracepassed( origin, target getcentroid(), 0, target ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
self tank_engage( target );
|
|
break;
|
|
}
|
|
_k802 = getNextArrayKey( _a802, _k802 );
|
|
}
|
|
self tank_idle();
|
|
}
|
|
|
|
tank_engage( enemy )
|
|
{
|
|
do_fire_delay = 1;
|
|
warning_shots = self.warningshots;
|
|
self laseron();
|
|
for ( ;; )
|
|
{
|
|
if ( !valid_target( enemy, self.team, self.owner ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( warning_shots <= 2 )
|
|
{
|
|
fire_rocket = self tank_should_fire_rocket( enemy );
|
|
}
|
|
self tank_set_target( enemy, fire_rocket );
|
|
if ( fire_rocket )
|
|
{
|
|
self clearvehgoalpos();
|
|
}
|
|
event = self waittill_any_return( "turret_on_vistarget", "turret_no_vis" );
|
|
if ( !valid_target( enemy, self.team, self.owner ) )
|
|
{
|
|
return;
|
|
}
|
|
self.aim_entity.origin = enemy getcentroid();
|
|
distsq = distancesquared( self.origin, enemy.origin );
|
|
if ( distsq > 4096 && event == "turret_no_vis" )
|
|
{
|
|
self tank_target_lost();
|
|
if ( self tank_is_idle() )
|
|
{
|
|
return;
|
|
}
|
|
continue;
|
|
}
|
|
else self notify( "force_movement_wake" );
|
|
if ( event == "turret_no_vis" )
|
|
{
|
|
warning_shots = self.warningshots;
|
|
}
|
|
if ( do_fire_delay )
|
|
{
|
|
self playsound( "wpn_metalstorm_lock_on" );
|
|
wait randomfloatrange( 0,4, 0,8 );
|
|
do_fire_delay = 0;
|
|
if ( !valid_target( enemy, self.team, self.owner ) )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
if ( fire_rocket )
|
|
{
|
|
rocket = self firegunnerweapon( 0, self.owner );
|
|
self notify( "missile_fire" );
|
|
if ( isDefined( rocket ) )
|
|
{
|
|
rocket.from_ai = 1;
|
|
rocket.killcament = self;
|
|
rocket wait_endon( randomfloatrange( 0,5, 1 ), "death" );
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
self fireweapon();
|
|
warning_shots--;
|
|
|
|
wait level.ai_tank_turret_fire_rate;
|
|
while ( isDefined( enemy ) && !isalive( enemy ) )
|
|
{
|
|
bullets = randomintrange( 8, 15 );
|
|
i = 0;
|
|
while ( i < bullets )
|
|
{
|
|
self fireweapon();
|
|
wait level.ai_tank_turret_fire_rate;
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_target_lost()
|
|
{
|
|
self endon( "turret_on_vistarget" );
|
|
wait 5;
|
|
self tank_idle();
|
|
}
|
|
|
|
tank_should_fire_rocket( enemy )
|
|
{
|
|
if ( self.numberrockets <= 0 )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( distancesquared( self.origin, enemy.origin ) < 147456 )
|
|
{
|
|
return 0;
|
|
}
|
|
origin = self gettagorigin( "tag_flash_gunner1" );
|
|
if ( !bullettracepassed( origin, enemy.origin + vectorScale( ( 0, 0, 1 ), 10 ), 0, enemy ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
tank_rocket_think()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "remote_start" );
|
|
if ( self.numberrockets <= 0 )
|
|
{
|
|
self disablegunnerfiring( 0, 1 );
|
|
wait 2;
|
|
self setclientfield( "ai_tank_missile_fire", 4 );
|
|
self.numberrockets = 3;
|
|
wait 0,4;
|
|
if ( !self.isstunned )
|
|
{
|
|
self disablegunnerfiring( 0, 0 );
|
|
}
|
|
}
|
|
while ( 1 )
|
|
{
|
|
self waittill( "missile_fire" );
|
|
self.numberrockets--;
|
|
|
|
self setclientfield( "ai_tank_missile_fire", self.numberrockets );
|
|
angles = self gettagangles( "tag_flash_gunner1" );
|
|
dir = anglesToForward( angles );
|
|
self launchvehicle( dir * -30, self.origin + vectorScale( ( 0, 0, 1 ), 50 ), 0 );
|
|
earthquake( 0,4, 0,5, self.origin, 200 );
|
|
if ( self.numberrockets <= 0 )
|
|
{
|
|
self disablegunnerfiring( 0, 1 );
|
|
wait 2;
|
|
self setclientfield( "ai_tank_missile_fire", 4 );
|
|
self.numberrockets = 3;
|
|
wait 0,4;
|
|
if ( !self.isstunned )
|
|
{
|
|
self disablegunnerfiring( 0, 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_set_target( entity, use_rocket )
|
|
{
|
|
if ( !isDefined( use_rocket ) )
|
|
{
|
|
use_rocket = 0;
|
|
}
|
|
self.target_entity = entity;
|
|
if ( use_rocket )
|
|
{
|
|
angles = self gettagangles( "tag_barrel" );
|
|
right = anglesToRight( angles );
|
|
offset = vectorScale( right, 8 );
|
|
velocity = entity getvelocity();
|
|
speed = length( velocity );
|
|
forward = anglesToForward( entity.angles );
|
|
origin = offset + vectorScale( forward, speed );
|
|
self setturrettargetent( entity, origin );
|
|
}
|
|
else
|
|
{
|
|
self setturrettargetent( entity );
|
|
}
|
|
}
|
|
|
|
tank_get_target()
|
|
{
|
|
return self.target_entity;
|
|
}
|
|
|
|
tank_idle()
|
|
{
|
|
tank_set_target( self.aim_entity );
|
|
}
|
|
|
|
tank_is_idle()
|
|
{
|
|
return tank_get_target() == self.aim_entity;
|
|
}
|
|
|
|
tank_has_radar()
|
|
{
|
|
if ( level.teambased )
|
|
{
|
|
if ( !maps/mp/killstreaks/_radar::teamhasspyplane( self.team ) )
|
|
{
|
|
return maps/mp/killstreaks/_radar::teamhassatellite( self.team );
|
|
}
|
|
}
|
|
if ( isDefined( self.owner.hasspyplane ) && !self.owner.hasspyplane )
|
|
{
|
|
if ( isDefined( self.owner.hassatellite ) )
|
|
{
|
|
return self.owner.hassatellite;
|
|
}
|
|
}
|
|
}
|
|
|
|
tank_get_player_enemies( on_radar )
|
|
{
|
|
enemies = [];
|
|
if ( !isDefined( on_radar ) )
|
|
{
|
|
on_radar = 0;
|
|
}
|
|
if ( on_radar )
|
|
{
|
|
time = getTime();
|
|
}
|
|
_a1077 = level.aliveplayers;
|
|
teamkey = getFirstArrayKey( _a1077 );
|
|
while ( isDefined( teamkey ) )
|
|
{
|
|
team = _a1077[ teamkey ];
|
|
if ( level.teambased && teamkey == self.team )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
_a1084 = team;
|
|
_k1084 = getFirstArrayKey( _a1084 );
|
|
while ( isDefined( _k1084 ) )
|
|
{
|
|
player = _a1084[ _k1084 ];
|
|
if ( !valid_target( player, self.team, self.owner ) )
|
|
{
|
|
}
|
|
else if ( on_radar )
|
|
{
|
|
if ( ( time - player.lastfiretime ) > 3000 && !tank_has_radar() )
|
|
{
|
|
}
|
|
}
|
|
else
|
|
{
|
|
enemies[ enemies.size ] = player;
|
|
}
|
|
_k1084 = getNextArrayKey( _a1084, _k1084 );
|
|
}
|
|
}
|
|
teamkey = getNextArrayKey( _a1077, teamkey );
|
|
}
|
|
return enemies;
|
|
}
|
|
|
|
tank_compute_enemy_position()
|
|
{
|
|
enemies = tank_get_player_enemies( 0 );
|
|
position = undefined;
|
|
if ( enemies.size )
|
|
{
|
|
x = 0;
|
|
y = 0;
|
|
z = 0;
|
|
_a1117 = enemies;
|
|
_k1117 = getFirstArrayKey( _a1117 );
|
|
while ( isDefined( _k1117 ) )
|
|
{
|
|
enemy = _a1117[ _k1117 ];
|
|
x += enemy.origin[ 0 ];
|
|
y += enemy.origin[ 1 ];
|
|
z += enemy.origin[ 2 ];
|
|
_k1117 = getNextArrayKey( _a1117, _k1117 );
|
|
}
|
|
x /= enemies.size;
|
|
y /= enemies.size;
|
|
z /= enemies.size;
|
|
position = ( x, y, z );
|
|
}
|
|
return position;
|
|
}
|
|
|
|
valid_target( target, team, owner )
|
|
{
|
|
if ( !isDefined( target ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( !isalive( target ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( target == owner )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isplayer( target ) )
|
|
{
|
|
if ( target.sessionstate != "playing" )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( target.lastspawntime ) && ( getTime() - target.lastspawntime ) < 3000 )
|
|
{
|
|
return 0;
|
|
}
|
|
/#
|
|
if ( target isinmovemode( "ufo", "noclip" ) )
|
|
{
|
|
return 0;
|
|
#/
|
|
}
|
|
}
|
|
if ( level.teambased )
|
|
{
|
|
if ( isDefined( target.team ) && team == target.team )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( target.aiteam ) && team == target.aiteam )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
if ( isDefined( target.owner ) && target.owner == owner )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( target.script_owner ) && target.script_owner == owner )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( target.dead ) && target.dead )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( isDefined( target.targetname ) && target.targetname == "riotshield_mp" )
|
|
{
|
|
if ( isDefined( target.damagetaken ) && target.damagetaken >= getDvarInt( "riotshield_deployed_health" ) )
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
starttankremotecontrol( drone )
|
|
{
|
|
self.killstreak_waitamount = 120000;
|
|
drone makevehicleusable();
|
|
drone clearvehgoalpos();
|
|
drone clearturrettarget();
|
|
drone laseroff();
|
|
drone usevehicle( self, 0 );
|
|
drone makevehicleunusable();
|
|
drone setbrake( 0 );
|
|
self create_weapon_hud();
|
|
drone update_weapon_hud( self );
|
|
self thread tank_fire_watch( drone );
|
|
drone thread tank_rocket_watch( self );
|
|
}
|
|
|
|
endtankremotecontrol( drone, isdead )
|
|
{
|
|
drone makevehicleunusable();
|
|
if ( !isdead )
|
|
{
|
|
drone thread tank_move_think();
|
|
drone thread tank_riotshield_think();
|
|
drone thread tank_aim_think();
|
|
drone thread tank_combat_think();
|
|
drone thread tank_rocket_think();
|
|
}
|
|
}
|
|
|
|
end_remote_control_ai_tank( drone )
|
|
{
|
|
if ( !isDefined( drone.dead ) || !drone.dead )
|
|
{
|
|
self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,25, 0,1, 0,25 );
|
|
wait 0,3;
|
|
}
|
|
else
|
|
{
|
|
wait 0,75;
|
|
self thread maps/mp/gametypes/_hud::fadetoblackforxsec( 0, 0,25, 0,1, 0,25 );
|
|
wait 0,3;
|
|
}
|
|
drone makevehicleusable();
|
|
drone.controlled = 0;
|
|
drone notify( "remote_stop" );
|
|
self unlink();
|
|
drone makevehicleunusable();
|
|
self stop_remote();
|
|
drone showpart( "tag_pov_hide" );
|
|
if ( isDefined( self.hud_prompt_control ) || !isDefined( drone.dead ) && !drone.dead )
|
|
{
|
|
self.hud_prompt_control settext( "HOLD [{+activate}] TO CONTROL A.G.R." );
|
|
self.hud_prompt_exit settext( "" );
|
|
}
|
|
self switchtolastnonkillstreakweapon();
|
|
wait 0,5;
|
|
self takeweapon( "killstreak_ai_tank_mp" );
|
|
if ( !isDefined( drone.dead ) || !drone.dead )
|
|
{
|
|
drone thread tank_move_think();
|
|
drone thread tank_riotshield_think();
|
|
drone thread tank_aim_think();
|
|
drone thread tank_combat_think();
|
|
}
|
|
}
|
|
|
|
tank_fire_watch( drone )
|
|
{
|
|
self endon( "disconnect" );
|
|
self endon( "stopped_using_remote" );
|
|
drone endon( "death" );
|
|
level endon( "game_ended" );
|
|
while ( 1 )
|
|
{
|
|
drone waittill( "turret_fire" );
|
|
while ( drone.isstunned )
|
|
{
|
|
continue;
|
|
}
|
|
drone fireweapon();
|
|
earthquake( 0,2, 0,2, drone.origin, 200 );
|
|
angles = drone gettagangles( "tag_barrel" );
|
|
dir = anglesToForward( angles );
|
|
drone launchvehicle( dir * -5, drone.origin + vectorScale( ( 0, 0, 1 ), 10 ), 0 );
|
|
wait level.ai_tank_turret_fire_rate;
|
|
}
|
|
}
|
|
|
|
tank_rocket_watch( player )
|
|
{
|
|
self endon( "death" );
|
|
player endon( "stopped_using_remote" );
|
|
if ( self.numberrockets <= 0 )
|
|
{
|
|
self disablegunnerfiring( 0, 1 );
|
|
wait 2;
|
|
self setclientfield( "ai_tank_missile_fire", 4 );
|
|
self.numberrockets = 3;
|
|
wait 0,4;
|
|
if ( !self.isstunned )
|
|
{
|
|
self disablegunnerfiring( 0, 0 );
|
|
}
|
|
self update_weapon_hud( player );
|
|
}
|
|
if ( !self.isstunned )
|
|
{
|
|
self disablegunnerfiring( 0, 0 );
|
|
}
|
|
while ( 1 )
|
|
{
|
|
player waittill( "missile_fire" );
|
|
self.numberrockets--;
|
|
|
|
self setclientfield( "ai_tank_missile_fire", self.numberrockets );
|
|
angles = self gettagangles( "tag_flash_gunner1" );
|
|
dir = anglesToForward( angles );
|
|
if ( !self.controlled )
|
|
{
|
|
self launchvehicle( dir * -30, self.origin + vectorScale( ( 0, 0, 1 ), 50 ), 0 );
|
|
}
|
|
else
|
|
{
|
|
self launchvehicle( dir * -30, self.origin + vectorScale( ( 0, 0, 1 ), 50 ), 0 );
|
|
player playrumbleonentity( "sniper_fire" );
|
|
}
|
|
earthquake( 0,4, 0,5, self.origin, 200 );
|
|
self update_weapon_hud( player );
|
|
if ( self.numberrockets <= 0 )
|
|
{
|
|
self disablegunnerfiring( 0, 1 );
|
|
wait 2;
|
|
self setclientfield( "ai_tank_missile_fire", 4 );
|
|
self.numberrockets = 3;
|
|
wait 0,4;
|
|
if ( !self.isstunned )
|
|
{
|
|
self disablegunnerfiring( 0, 0 );
|
|
}
|
|
self update_weapon_hud( player );
|
|
}
|
|
}
|
|
}
|
|
|
|
create_weapon_hud()
|
|
{
|
|
self.tank_rocket_1 = newclienthudelem( self );
|
|
self.tank_rocket_1.alignx = "right";
|
|
self.tank_rocket_1.aligny = "bottom";
|
|
self.tank_rocket_1.horzalign = "user_center";
|
|
self.tank_rocket_1.vertalign = "user_bottom";
|
|
self.tank_rocket_1.font = "small";
|
|
self.tank_rocket_1 setshader( "mech_check_fill", 32, 16 );
|
|
self.tank_rocket_1.hidewheninmenu = 0;
|
|
self.tank_rocket_1.immunetodemogamehudsettings = 1;
|
|
self.tank_rocket_1.x = -250;
|
|
self.tank_rocket_1.y = -75;
|
|
self.tank_rocket_1.fontscale = 1,25;
|
|
self.tank_rocket_2 = newclienthudelem( self );
|
|
self.tank_rocket_2.alignx = "right";
|
|
self.tank_rocket_2.aligny = "bottom";
|
|
self.tank_rocket_2.horzalign = "user_center";
|
|
self.tank_rocket_2.vertalign = "user_bottom";
|
|
self.tank_rocket_2.font = "small";
|
|
self.tank_rocket_2 setshader( "mech_check_fill", 32, 16 );
|
|
self.tank_rocket_2.hidewheninmenu = 0;
|
|
self.tank_rocket_2.immunetodemogamehudsettings = 1;
|
|
self.tank_rocket_2.x = -250;
|
|
self.tank_rocket_2.y = -65;
|
|
self.tank_rocket_2.fontscale = 1,25;
|
|
self.tank_rocket_3 = newclienthudelem( self );
|
|
self.tank_rocket_3.alignx = "right";
|
|
self.tank_rocket_3.aligny = "bottom";
|
|
self.tank_rocket_3.horzalign = "user_center";
|
|
self.tank_rocket_3.vertalign = "user_bottom";
|
|
self.tank_rocket_3.font = "small";
|
|
self.tank_rocket_3 setshader( "mech_check_fill", 32, 16 );
|
|
self.tank_rocket_3.hidewheninmenu = 0;
|
|
self.tank_rocket_3.immunetodemogamehudsettings = 1;
|
|
self.tank_rocket_3.x = -250;
|
|
self.tank_rocket_3.y = -55;
|
|
self.tank_rocket_3.fontscale = 1,25;
|
|
self thread fade_out_weapon_hud();
|
|
}
|
|
|
|
fade_out_weapon_hud()
|
|
{
|
|
self endon( "death" );
|
|
wait 8;
|
|
time = 0;
|
|
while ( time < 2 )
|
|
{
|
|
if ( !isDefined( self.tank_rocket_hint ) )
|
|
{
|
|
return;
|
|
}
|
|
self.tank_rocket_hint.alpha -= 0,025;
|
|
self.tank_mg_hint.alpha -= 0,025;
|
|
time += 0,05;
|
|
wait 0,05;
|
|
}
|
|
self.tank_rocket_hint.alpha = 0;
|
|
self.tank_mg_hint.alpha = 0;
|
|
}
|
|
|
|
update_weapon_hud( player )
|
|
{
|
|
if ( isDefined( player.tank_rocket_3 ) )
|
|
{
|
|
player.tank_rocket_3 setshader( "mech_check_fill", 32, 16 );
|
|
player.tank_rocket_2 setshader( "mech_check_fill", 32, 16 );
|
|
player.tank_rocket_1 setshader( "mech_check_fill", 32, 16 );
|
|
switch( self.numberrockets )
|
|
{
|
|
case 0:
|
|
player.tank_rocket_3 setshader( "mech_check_line", 32, 16 );
|
|
case 1:
|
|
player.tank_rocket_2 setshader( "mech_check_line", 32, 16 );
|
|
case 2:
|
|
player.tank_rocket_1 setshader( "mech_check_line", 32, 16 );
|
|
break;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
destroy_remote_hud()
|
|
{
|
|
self useservervisionset( 0 );
|
|
self setinfraredvision( 0 );
|
|
if ( isDefined( self.fullscreen_static ) )
|
|
{
|
|
self.fullscreen_static destroy();
|
|
}
|
|
if ( isDefined( self.remote_hud_reticle ) )
|
|
{
|
|
self.remote_hud_reticle destroy();
|
|
}
|
|
if ( isDefined( self.remote_hud_bracket_right ) )
|
|
{
|
|
self.remote_hud_bracket_right destroy();
|
|
}
|
|
if ( isDefined( self.remote_hud_bracket_left ) )
|
|
{
|
|
self.remote_hud_bracket_left destroy();
|
|
}
|
|
if ( isDefined( self.remote_hud_arrow_right ) )
|
|
{
|
|
self.remote_hud_arrow_right destroy();
|
|
}
|
|
if ( isDefined( self.remote_hud_arrow_left ) )
|
|
{
|
|
self.remote_hud_arrow_left destroy();
|
|
}
|
|
if ( isDefined( self.tank_rocket_1 ) )
|
|
{
|
|
self.tank_rocket_1 destroy();
|
|
}
|
|
if ( isDefined( self.tank_rocket_2 ) )
|
|
{
|
|
self.tank_rocket_2 destroy();
|
|
}
|
|
if ( isDefined( self.tank_rocket_3 ) )
|
|
{
|
|
self.tank_rocket_3 destroy();
|
|
}
|
|
if ( isDefined( self.tank_rocket_hint ) )
|
|
{
|
|
self.tank_rocket_hint destroy();
|
|
}
|
|
if ( isDefined( self.tank_mg_bar ) )
|
|
{
|
|
self.tank_mg_bar destroy();
|
|
}
|
|
if ( isDefined( self.tank_mg_arrow ) )
|
|
{
|
|
self.tank_mg_arrow destroy();
|
|
}
|
|
if ( isDefined( self.tank_mg_hint ) )
|
|
{
|
|
self.tank_mg_hint destroy();
|
|
}
|
|
}
|
|
|
|
tank_devgui_think()
|
|
{
|
|
/#
|
|
setdvar( "devgui_tank", "" );
|
|
for ( ;; )
|
|
{
|
|
wait 0,25;
|
|
level.ai_tank_turret_fire_rate = weaponfiretime( "ai_tank_drone_gun_mp" );
|
|
if ( getDvar( "devgui_tank" ) == "routes" )
|
|
{
|
|
devgui_debug_route();
|
|
setdvar( "devgui_tank", "" );
|
|
}
|
|
#/
|
|
}
|
|
}
|
|
|
|
tank_debug_patrol( node1, node2 )
|
|
{
|
|
/#
|
|
self endon( "death" );
|
|
self endon( "debug_patrol" );
|
|
for ( ;; )
|
|
{
|
|
self setvehgoalpos( node1.origin, 1, 2 );
|
|
self waittill( "reached_end_node" );
|
|
wait 1;
|
|
self setvehgoalpos( node2.origin, 1, 2 );
|
|
self waittill( "reached_end_node" );
|
|
wait 1;
|
|
#/
|
|
}
|
|
}
|
|
|
|
devgui_debug_route()
|
|
{
|
|
/#
|
|
iprintln( "Choose nodes with 'A' or press 'B' to cancel" );
|
|
nodes = maps/mp/gametypes/_dev::dev_get_node_pair();
|
|
if ( !isDefined( nodes ) )
|
|
{
|
|
iprintln( "Route Debug Cancelled" );
|
|
return;
|
|
}
|
|
iprintln( "Sending talons to chosen nodes" );
|
|
tanks = getentarray( "talon", "targetname" );
|
|
_a1611 = tanks;
|
|
_k1611 = getFirstArrayKey( _a1611 );
|
|
while ( isDefined( _k1611 ) )
|
|
{
|
|
tank = _a1611[ _k1611 ];
|
|
tank notify( "debug_patrol" );
|
|
tank thread tank_debug_patrol( nodes[ 0 ], nodes[ 1 ] );
|
|
_k1611 = getNextArrayKey( _a1611, _k1611 );
|
|
#/
|
|
}
|
|
}
|
|
|
|
tank_debug_hud_init()
|
|
{
|
|
/#
|
|
host = gethostplayer();
|
|
while ( !isDefined( host ) )
|
|
{
|
|
wait 0,25;
|
|
host = gethostplayer();
|
|
}
|
|
x = 80;
|
|
y = 40;
|
|
level.ai_tank_bar = newclienthudelem( host );
|
|
level.ai_tank_bar.x = x + 80;
|
|
level.ai_tank_bar.y = y + 2;
|
|
level.ai_tank_bar.alignx = "left";
|
|
level.ai_tank_bar.aligny = "top";
|
|
level.ai_tank_bar.horzalign = "fullscreen";
|
|
level.ai_tank_bar.vertalign = "fullscreen";
|
|
level.ai_tank_bar.alpha = 0;
|
|
level.ai_tank_bar.foreground = 0;
|
|
level.ai_tank_bar setshader( "black", 1, 8 );
|
|
level.ai_tank_text = newclienthudelem( host );
|
|
level.ai_tank_text.x = x + 80;
|
|
level.ai_tank_text.y = y;
|
|
level.ai_tank_text.alignx = "left";
|
|
level.ai_tank_text.aligny = "top";
|
|
level.ai_tank_text.horzalign = "fullscreen";
|
|
level.ai_tank_text.vertalign = "fullscreen";
|
|
level.ai_tank_text.alpha = 0;
|
|
level.ai_tank_text.fontscale = 1;
|
|
level.ai_tank_text.foreground = 1;
|
|
#/
|
|
}
|
|
|
|
tank_debug_health()
|
|
{
|
|
/#
|
|
self.damage_debug = "";
|
|
level.ai_tank_bar.alpha = 1;
|
|
level.ai_tank_text.alpha = 1;
|
|
for ( ;; )
|
|
{
|
|
wait 0,05;
|
|
if ( !isDefined( self ) || !isalive( self ) )
|
|
{
|
|
level.ai_tank_bar.alpha = 0;
|
|
level.ai_tank_text.alpha = 0;
|
|
return;
|
|
}
|
|
width = ( self.health / self.maxhealth ) * 300;
|
|
width = int( max( width, 1 ) );
|
|
level.ai_tank_bar setshader( "black", width, 8 );
|
|
str = ( self.health + " Last Damage: " ) + self.damage_debug;
|
|
level.ai_tank_text settext( str );
|
|
#/
|
|
}
|
|
}
|