622 lines
30 KiB
Plaintext
622 lines
30 KiB
Plaintext
#using scripts\codescripts\struct;
|
|
|
|
#using scripts\mp\_util;
|
|
#using scripts\mp\gametypes\_globallogic_audio;
|
|
#using scripts\mp\gametypes\_hostmigration;
|
|
#using scripts\mp\gametypes\_spawning;
|
|
#using scripts\mp\killstreaks\_airsupport;
|
|
#using scripts\mp\killstreaks\_emp;
|
|
#using scripts\mp\killstreaks\_killstreakrules;
|
|
#using scripts\mp\killstreaks\_killstreaks;
|
|
#using scripts\mp\killstreaks\_killstreak_bundles;
|
|
#using scripts\mp\killstreaks\_placeables;
|
|
#using scripts\mp\killstreaks\_remote_weapons;
|
|
#using scripts\mp\killstreaks\_killstreak_hacking;
|
|
#using scripts\mp\teams\_teams;
|
|
|
|
#using scripts\shared\callbacks_shared;
|
|
#using scripts\shared\challenges_shared;
|
|
#using scripts\shared\clientfield_shared;
|
|
#using scripts\shared\hostmigration_shared;
|
|
#using scripts\shared\scoreevents_shared;
|
|
#using scripts\shared\killstreaks_shared;
|
|
#using scripts\shared\popups_shared;
|
|
#using scripts\shared\util_shared;
|
|
#using scripts\shared\weapons\_weaponobjects;
|
|
#using scripts\shared\turret_shared;
|
|
#using scripts\shared\vehicle_shared;
|
|
#using scripts\shared\vehicle_death_shared;
|
|
#using scripts\shared\visionset_mgr_shared;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#precache( "string", "KILLSTREAK_EARNED_AUTO_TURRET" );
|
|
#precache( "string", "KILLSTREAK_AUTO_TURRET_INBOUND" );
|
|
#precache( "string", "KILLSTREAK_AUTO_TURRET_NOT_AVAILABLE" );
|
|
#precache( "string", "KILLSTREAK_AUTO_TURRET_HACKED" );
|
|
#precache( "string", "KILLSTREAK_DESTROYED_AUTO_TURRET" );
|
|
#precache( "triggerstring", "KILLSTREAK_AUTO_TURRET_PLACE_TURRET_HINT" );
|
|
#precache( "triggerstring", "KILLSTREAK_AUTO_TURRET_INVALID_TURRET_LOCATION" );
|
|
#precache( "triggerstring", "KILLSTREAK_SENTRY_TURRET_PICKUP" );
|
|
#precache( "triggerstring", "MP_REMOTE_USE_TURRET" );
|
|
#precache( "string", "mpl_killstreak_auto_turret" );
|
|
|
|
#using_animtree( "mp_autoturret" );
|
|
|
|
|
|
|
|
|
|
// tu1: make sure this matches the same value in placeables.gsc
|
|
|
|
#namespace turret;
|
|
|
|
function init()
|
|
{
|
|
killstreaks::register( "autoturret", "autoturret", "killstreak_auto_turret", "auto_turret_used", &ActivateTurret );
|
|
killstreaks::register_alt_weapon( "autoturret", "auto_gun_turret" );
|
|
killstreaks::register_remote_override_weapon( "autoturret", "killstreak_remote_turret" );
|
|
killstreaks::register_strings( "autoturret", &"KILLSTREAK_EARNED_AUTO_TURRET", &"KILLSTREAK_AUTO_TURRET_NOT_AVAILABLE", &"KILLSTREAK_AUTO_TURRET_INBOUND", undefined, &"KILLSTREAK_AUTO_TURRET_HACKED", false );
|
|
killstreaks::register_dialog( "autoturret", "mpl_killstreak_auto_turret", "turretDialogBundle", undefined, "friendlyTurret", "enemyTurret", "enemyTurretMultiple", "friendlyTurretHacked", "enemyTurretHacked", "requestTurret", "threatTurret" );
|
|
|
|
// TODO: Move to killstreak data
|
|
level.killstreaks["autoturret"].threatOnKill = true;
|
|
|
|
clientfield::register( "vehicle", "auto_turret_open", 1, 1, "int" );
|
|
clientfield::register( "scriptmover", "auto_turret_init", 1, 1, "int" ); // re-export model in close position to save this clientfield
|
|
clientfield::register( "scriptmover", "auto_turret_close", 1, 1, "int" );
|
|
|
|
level.autoturretOpenAnim = %o_turret_sentry_deploy;
|
|
level.autoturretCloseAnim = %o_turret_sentry_close;
|
|
|
|
remote_weapons::RegisterRemoteWeapon( "autoturret", &"MP_REMOTE_USE_TURRET", &StartTurretRemoteControl, &EndTurretRemoteControl, true );
|
|
vehicle::add_main_callback( "sentry_turret", &InitTurret );
|
|
|
|
visionset_mgr::register_info( "visionset", "turret_visionset", 1, 81, 16, true, &visionset_mgr::ramp_in_out_thread_per_player, false );
|
|
}
|
|
|
|
function InitTurret()
|
|
{
|
|
turretVehicle = self;
|
|
//turretVehicle.delete_on_death = undefined; // don't delete on death as we may need to support futz on death
|
|
turretVehicle.dontfreeme = true; // don't allow the shared shutdown sequence until we are ready
|
|
turretVehicle.damage_on_death = false; // never cause damage when auto turret dies
|
|
turretVehicle.delete_on_death = undefined; // disallow the vehicle death's delete
|
|
turretVehicle.watch_remote_weapon_death = true;
|
|
turretVehicle.watch_remote_weapon_death_duration = 1.2;
|
|
|
|
turretVehicle.maxhealth = ( 2000 );
|
|
turretVehicle.damageTaken = 0;
|
|
|
|
tableHealth = killstreak_bundles::get_max_health( "autoturret" );
|
|
|
|
if ( isdefined( tableHealth ) )
|
|
{
|
|
turretVehicle.maxhealth = tableHealth;
|
|
|
|
}
|
|
|
|
turretVehicle.health = turretVehicle.maxhealth;
|
|
|
|
turretVehicle turret::set_max_target_distance( ( 2500 ), 0 );
|
|
// setting min dist squared prevents an exploit of drawing fire and not getting hurt when there is no collision on the turret
|
|
turretVehicle turret::set_min_target_distance_squared( DistanceSquared( turretVehicle GetTagOrigin( "tag_flash" ), turretVehicle GetTagOrigin( "tag_barrel" ) ), 0 );
|
|
turretVehicle turret::set_on_target_angle( ( 15 ), 0 );
|
|
turretVehicle clientfield::set( "enemyvehicle", 1 );
|
|
turretVehicle.soundmod = "drone_land";
|
|
//turretVehicle NotSolid();
|
|
|
|
turretVehicle.overrideVehicleDamage = &OnTurretDamage;
|
|
turretVehicle.overrideVehicleDeath = &OnTurretDeath;
|
|
}
|
|
|
|
function ActivateTurret()
|
|
{
|
|
player = self;
|
|
assert( IsPlayer( player ) );
|
|
|
|
killstreakId = self killstreakrules::killstreakStart( "autoturret", player.team, false, false );
|
|
if( killstreakId == (-1) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bundle = level.killstreakBundle["autoturret"];
|
|
|
|
turret = player placeables::SpawnPlaceable( "autoturret", killstreakId,
|
|
&OnPlaceTurret, &OnCancelPlacement, &OnPickupTurret, &OnShutdown, undefined, undefined,
|
|
"veh_t7_turret_sentry_gun_world_mp", "veh_t7_turret_sentry_gun_world_yellow", "veh_t7_turret_sentry_gun_world_red", true,
|
|
&"KILLSTREAK_SENTRY_TURRET_PICKUP", ( 90 * 1000 ), undefined, 0, bundle.ksPlaceableHint, bundle.ksPlaceableInvalidLocationHint );
|
|
|
|
turret thread WatchTurretShutdown( killstreakId, player.team );
|
|
turret thread util::ghost_wait_show_to_player( player );
|
|
turret.otherModel thread util::ghost_wait_show_to_others( player );
|
|
turret clientfield::set( "auto_turret_init", 1 );
|
|
turret.otherModel clientfield::set( "auto_turret_init", 1 );
|
|
|
|
event = turret util::waittill_any_return( "placed", "cancelled", "death" );
|
|
if( event != "placed" )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
turret playsound ("mpl_turret_startup");
|
|
return true;
|
|
}
|
|
|
|
function OnPlaceTurret( turret )
|
|
{
|
|
player = self;
|
|
assert( IsPlayer( player ) );
|
|
|
|
if( isdefined( turret.vehicle ) )
|
|
{
|
|
turret.vehicle.origin = turret.origin;
|
|
turret.vehicle.angles = turret.angles;
|
|
|
|
turret.vehicle thread util::ghost_wait_show( 0.05 );
|
|
|
|
turret.vehicle playsound ("mpl_turret_startup");
|
|
}
|
|
else
|
|
{
|
|
turret.vehicle = SpawnVehicle( "sentry_turret", turret.origin, turret.angles, "dynamic_spawn_ai" );
|
|
turret.vehicle.owner = player;
|
|
turret.vehicle SetOwner( player );
|
|
turret.vehicle.ownerEntNum = player.entNum;
|
|
turret.vehicle.parentStruct = turret;
|
|
turret.vehicle.controlled = false;
|
|
turret.vehicle.treat_owner_damage_as_friendly_fire = true;
|
|
turret.vehicle.ignore_team_kills = true;
|
|
turret.vehicle.deal_no_crush_damage = true;
|
|
|
|
turret.vehicle.team = player.team;
|
|
turret.vehicle SetTeam( player.team );
|
|
turret.vehicle turret::set_team( player.team, 0 );
|
|
turret.vehicle turret::set_torso_targetting( 0 );
|
|
turret.vehicle turret::set_target_leading( 0 );
|
|
turret.vehicle.use_non_teambased_enemy_selection = true;
|
|
turret.vehicle.waittill_turret_on_target_delay = 0.25;
|
|
//turret.vehicle turret::set_see_from_tag_flash( true, 0 );
|
|
//turret.vehicle turret::
|
|
turret.vehicle.ignore_vehicle_underneath_splash_scalar = true;
|
|
|
|
turret.vehicle killstreaks::configure_team( "autoturret", turret.killstreakId, player, "small_vehicle" );
|
|
turret.vehicle killstreak_hacking::enable_hacking( "autoturret", &HackedCallbackPre, &HackedCallbackPost );
|
|
|
|
turret.vehicle thread turret_watch_owner_events();
|
|
turret.vehicle thread turret_laser_watch();
|
|
turret.vehicle thread setup_death_watch_for_new_targets();
|
|
|
|
turret.vehicle CreateTurretInfluencer( "turret" );
|
|
turret.vehicle CreateTurretInfluencer( "turret_close" );
|
|
|
|
turret.vehicle thread util::ghost_wait_show( 0.05 );
|
|
|
|
if ( IsSentient( turret.vehicle ) == false )
|
|
turret.vehicle MakeSentient(); // so other sentients will consider this as a potential enemy
|
|
|
|
player killstreaks::play_killstreak_start_dialog( "autoturret", player.pers["team"], turret.killstreakId );
|
|
level thread popups::DisplayKillstreakTeamMessageToAll( "autoturret", player );
|
|
player AddWeaponStat( GetWeapon( "autoturret" ), "used", 1 );
|
|
|
|
turret.vehicle.killstreak_end_time = GetTime() + ( 90 * 1000 ) + 5000;
|
|
}
|
|
|
|
turret.vehicle turret::enable( 0, false );
|
|
Target_Set( turret.vehicle, ( 0, 0, 36 ) );
|
|
turret.vehicle Unlink();
|
|
|
|
turret.vehicle vehicle::disconnect_paths( 0, false );
|
|
|
|
turret.vehicle thread TurretScanning();
|
|
|
|
turret play_deploy_anim();
|
|
|
|
player remote_weapons::UseRemoteWeapon( turret.vehicle, "autoturret", false );
|
|
}
|
|
|
|
function HackedCallbackPre( hacker )
|
|
{
|
|
turretVehicle = self;
|
|
turretVehicle clientfield::set( "enemyvehicle", 2 );
|
|
turretVehicle.owner clientfield::set_to_player( "static_postfx", 0 );
|
|
if( turretVehicle.controlled === true )
|
|
visionset_mgr::deactivate( "visionset", "turret_visionset", turretVehicle.owner );
|
|
turretVehicle.owner remote_weapons::RemoveAndAssignNewRemoteControlTrigger( turretVehicle.useTrigger );
|
|
turretVehicle remote_weapons::EndRemoteControlWeaponUse( true );
|
|
turretVehicle.owner unlink();
|
|
turretVehicle clientfield::set( "vehicletransition", 0 );
|
|
}
|
|
|
|
function HackedCallbackPost( hacker )
|
|
{
|
|
turretVehicle = self;
|
|
hacker remote_weapons::UseRemoteWeapon( turretVehicle, "autoturret", false );
|
|
turretVehicle notify( "WatchRemoteControlDeactivate_remoteWeapons" );
|
|
turretVehicle.killstreak_end_time = hacker killstreak_hacking::set_vehicle_drivable_time_starting_now( turretVehicle );
|
|
}
|
|
|
|
function play_deploy_anim_after_wait( wait_time )
|
|
{
|
|
turret = self;
|
|
turret endon( "death" );
|
|
|
|
wait wait_time;
|
|
|
|
turret play_deploy_anim();
|
|
}
|
|
|
|
function play_deploy_anim()
|
|
{
|
|
turret = self;
|
|
|
|
turret clientfield::set( "auto_turret_close", 0 );
|
|
turret.otherModel clientfield::set( "auto_turret_close", 0 );
|
|
|
|
if ( isdefined( turret.vehicle ))
|
|
{
|
|
turret.vehicle clientfield::set( "auto_turret_open", 1 );
|
|
}
|
|
}
|
|
|
|
function OnCancelPlacement( turret )
|
|
{
|
|
turret notify( "sentry_turret_shutdown" );
|
|
}
|
|
|
|
function OnPickupTurret( turret )
|
|
{
|
|
player = self;
|
|
turret.vehicle Ghost();
|
|
turret.vehicle turret::disable( 0 );
|
|
turret.vehicle LinkTo( turret );
|
|
Target_Remove( turret.vehicle );
|
|
|
|
turret clientfield::set( "auto_turret_close", 1 );
|
|
turret.otherModel clientfield::set( "auto_turret_close", 1 );
|
|
|
|
if ( isdefined( turret.vehicle ) )
|
|
{
|
|
turret.vehicle notify( "end_turret_scanning" );
|
|
turret.vehicle SetTurretTargetRelativeAngles( ( 0, 0, 0 ) );
|
|
|
|
turret.vehicle clientfield::set( "auto_turret_open", 0 );
|
|
|
|
if( isdefined( turret.vehicle.useTrigger ) )
|
|
{
|
|
turret.vehicle.useTrigger Delete();
|
|
turret.vehicle playsound ("mpl_turret_down");
|
|
}
|
|
|
|
turret.vehicle vehicle::connect_paths();
|
|
}
|
|
}
|
|
|
|
function OnTurretDamage( eInflictor, eAttacker, iDamage, iDFlags, sMeansOfDeath, weapon, vPoint, vDir, sHitLoc, vDamageOrigin, psOffsetTime, damageFromUnderneath, modelIndex, partName, vSurfaceNormal )
|
|
{
|
|
empDamage = int( iDamage + ( self.healthdefault * ( 1 ) ) + 0.5 );
|
|
|
|
iDamage = self killstreaks::OnDamagePerWeapon( "autoturret", eAttacker, iDamage, iDFlags, sMeansOfDeath, weapon, self.maxhealth, undefined, self.maxhealth*0.4, undefined, empDamage, undefined, true, 1.0 );
|
|
self.damageTaken += iDamage;
|
|
|
|
if ( self.controlled )
|
|
{
|
|
self.owner vehicle::update_damage_as_occupant( self.damageTaken, self.maxHealth );
|
|
}
|
|
|
|
// turret death
|
|
if ( self.damageTaken > self.maxHealth && !isdefined( self.will_die ) )
|
|
{
|
|
self.will_die = true;
|
|
self thread OnDeathAfterFrameEnd( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime );
|
|
}
|
|
|
|
return iDamage;
|
|
}
|
|
|
|
function OnTurretDeath( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime )
|
|
{
|
|
// currently, OnTurretDeath is not getting called, so we call OnDeath directly from OnTurretDamage
|
|
self OnDeath( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime );
|
|
}
|
|
|
|
function OnDeathAfterFrameEnd( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime )
|
|
{
|
|
waittillframeend;
|
|
|
|
if ( isdefined( self ) )
|
|
{
|
|
self OnDeath( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime );
|
|
}
|
|
}
|
|
|
|
function OnDeath( eInflictor, eAttacker, iDamage, sMeansOfDeath, weapon, vDir, sHitLoc, psOffsetTime )
|
|
{
|
|
turretVehicle = self;
|
|
|
|
// only die once
|
|
if ( turretVehicle.dead === true )
|
|
return;
|
|
|
|
turretVehicle.dead = true;
|
|
|
|
turretVehicle DisableDriverFiring( true );
|
|
turretvehicle turret::disable( 0 );
|
|
|
|
turretvehicle vehicle::connect_paths();
|
|
|
|
eAttacker = self [[ level.figure_out_attacker ]]( eAttacker );
|
|
|
|
if( isdefined( turretVehicle.parentStruct ) )
|
|
{
|
|
turretVehicle.parentStruct placeables::ForceShutdown();
|
|
|
|
if ( turretVehicle.parentStruct.killstreakTimedOut === true && isdefined( turretVehicle.owner ) )
|
|
{
|
|
turretVehicle.owner globallogic_audio::play_taacom_dialog( "timeout", turretVehicle.parentStruct.killstreakType );
|
|
}
|
|
else
|
|
{
|
|
if ( isdefined( eAttacker ) && isdefined( turretVehicle.owner ) && ( eAttacker != turretVehicle.owner ) )
|
|
turretVehicle.parentStruct killstreaks::play_destroyed_dialog_on_owner( turretVehicle.parentStruct.killstreakType, turretVehicle.parentStruct.killstreakId );
|
|
}
|
|
}
|
|
|
|
if ( isdefined( eAttacker ) && IsPlayer( eAttacker ) && ( !isdefined( self.owner ) || self.owner util::IsEnemyPlayer( eAttacker ) ) )
|
|
{
|
|
scoreevents::processScoreEvent( "destroyed_sentry_gun", eAttacker, self, weapon );
|
|
eAttacker challenges::destroyScoreStreak( weapon, turretVehicle.controlled, true, false );
|
|
eAttacker challenges::destroyNonAirScoreStreak_PostStatsLock( weapon );
|
|
eAttacker AddPlayerStat( "destroy_turret", 1 );
|
|
eAttacker AddWeaponStat( weapon, "destroy_turret", 1 );
|
|
LUINotifyEvent( &"player_callout", 2, &"KILLSTREAK_DESTROYED_AUTO_TURRET", eAttacker.entnum );
|
|
}
|
|
|
|
turretVehicle vehicle_death::death_fx();
|
|
turretVehicle playsound ("mpl_m_turret_exp");
|
|
|
|
// anticipating futz
|
|
|
|
wait 0.1;
|
|
|
|
turretVehicle Ghost();
|
|
turretVehicle NotSolid();
|
|
|
|
turretVehicle util::waittill_any_timeout( 2.0, "remote_weapon_end" );
|
|
|
|
if ( isdefined( turretVehicle ) )
|
|
{
|
|
// wait until control is released, vehicle gets deleted, or owner disconnects
|
|
while ( isdefined( turretVehicle ) && ( turretVehicle.controlled || !isdefined( turretVehicle.owner ) ) )
|
|
{wait(.05);};
|
|
|
|
turretVehicle.dontfreeme = undefined; // allows vehicle shared shutdown to finish
|
|
|
|
// we decided to be responsible for deleting the vehicle, so we delete here
|
|
wait 0.5;
|
|
if ( isdefined ( turretVehicle ) )
|
|
turretVehicle delete();
|
|
}
|
|
}
|
|
|
|
function OnShutdown( turret )
|
|
{
|
|
turret notify( "sentry_turret_shutdown" );
|
|
}
|
|
|
|
function StartTurretRemoteControl( turretVehicle )
|
|
{
|
|
player = self;
|
|
assert( IsPlayer( player ) );
|
|
|
|
turretVehicle turret::disable( 0 );
|
|
turretVehicle UseVehicle( player, 0 );
|
|
turretVehicle clientfield::set( "vehicletransition", 1 );
|
|
turretVehicle.controlled = true;
|
|
turretVehicle.treat_owner_damage_as_friendly_fire = false;
|
|
turretVehicle.ignore_team_kills = false;
|
|
|
|
player vehicle::set_vehicle_drivable_time( ( 90 * 1000 ) + 5000, turretVehicle.killstreak_end_time );
|
|
player vehicle::update_damage_as_occupant( (isdefined(turretVehicle.damageTaken)?turretVehicle.damageTaken:0), (isdefined(turretVehicle.maxHealth)?turretVehicle.maxHealth:100) );
|
|
|
|
visionset_mgr::activate( "visionset", "turret_visionset", self, 1, 90000, 1 );
|
|
}
|
|
|
|
function EndTurretRemoteControl( turretVehicle, exitRequestedByOwner )
|
|
{
|
|
if( exitRequestedByOwner )
|
|
{
|
|
turretVehicle thread EnableTurretAfterWait( 0.1 ); // currently, this must be called after the player leaves the vehicle
|
|
}
|
|
turretVehicle clientfield::set( "vehicletransition", 0 );
|
|
|
|
if ( isdefined( turretVehicle.owner ) && ( turretVehicle.controlled === true ) )
|
|
visionset_mgr::deactivate( "visionset", "turret_visionset", turretVehicle.owner );
|
|
|
|
turretVehicle.controlled = false;
|
|
turretVehicle.treat_owner_damage_as_friendly_fire = true;
|
|
turretVehicle.ignore_team_kills = true;
|
|
}
|
|
|
|
function EnableTurretAfterWait( wait_time ) // self == turretVehicle
|
|
{
|
|
self endon ( "death" );
|
|
if ( isdefined( self.owner ) )
|
|
{
|
|
self.owner endon( "joined_team" );
|
|
self.owner endon( "disconnect" );
|
|
self.owner endon( "joined_spectators" );
|
|
}
|
|
|
|
wait wait_time;
|
|
self turret::enable( 0, false );
|
|
}
|
|
|
|
function CreateTurretInfluencer( name )
|
|
{
|
|
turret = self;
|
|
|
|
preset = GetInfluencerPreset( name );
|
|
|
|
if ( !IsDefined( preset ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// place the influencer out infront of the turret
|
|
projected_point = turret.origin + VectorScale( AnglesToForward( turret.angles ), preset["radius"] * 0.7 );
|
|
return spawning::create_enemy_influencer( name, turret.origin, turret.team );
|
|
}
|
|
|
|
function turret_watch_owner_events()
|
|
{
|
|
self notify( "turret_watch_owner_events_singleton" );
|
|
self endon ( "tturet_watch_owner_events_singleton" );
|
|
self endon( "death" );
|
|
|
|
self.owner util::waittill_any( "joined_team", "disconnect", "joined_spectators" );
|
|
|
|
self MakeVehicleUsable();
|
|
self.controlled = false;
|
|
|
|
if ( isdefined( self.owner ) )
|
|
{
|
|
self.owner unlink();
|
|
self clientfield::set( "vehicletransition", 0 );
|
|
}
|
|
|
|
self MakeVehicleUnusable();
|
|
|
|
if ( isdefined( self.owner ) )
|
|
{
|
|
self.owner killstreaks::clear_using_remote();
|
|
}
|
|
|
|
self.abandoned = true;
|
|
|
|
OnShutdown( self );
|
|
}
|
|
|
|
function turret_laser_watch()
|
|
{
|
|
turretVehicle = self;
|
|
turretVehicle endon( "death" );
|
|
|
|
while( 1 )
|
|
{
|
|
laser_should_be_on = ( !turretVehicle.controlled && turretVehicle turret::does_have_target( 0 ) );
|
|
|
|
if ( laser_should_be_on )
|
|
{
|
|
if ( IsLaserOn( turretVehicle ) == false )
|
|
{
|
|
turretVehicle turret::enable_laser( true, 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( IsLaserOn( turretVehicle ) )
|
|
{
|
|
turretVehicle turret::enable_laser( false, 0 );
|
|
}
|
|
}
|
|
|
|
wait 0.25;
|
|
}
|
|
}
|
|
|
|
function setup_death_watch_for_new_targets()
|
|
{
|
|
turretVehicle = self;
|
|
|
|
turretVehicle endon( "death" );
|
|
old_target = undefined;
|
|
|
|
while( 1 )
|
|
{
|
|
turretVehicle waittill( "has_new_target", new_target );
|
|
|
|
if ( isdefined( old_target ) )
|
|
old_target notify( "abort_death_watch" );
|
|
|
|
new_target thread target_death_watch( turretVehicle );
|
|
old_target = new_target;
|
|
}
|
|
}
|
|
|
|
function target_death_watch( turretVehicle )
|
|
{
|
|
target = self;
|
|
target endon( "abort_death_watch" );
|
|
|
|
turretVehicle endon( "death" );
|
|
|
|
target util::waittill_any( "death", "disconnect", "joined_team", "joined_spectators" );
|
|
|
|
turretVehicle turret::stop( 0, true );
|
|
}
|
|
|
|
function TurretScanning()
|
|
{
|
|
turretVehicle = self;
|
|
|
|
turretVehicle endon( "death" );
|
|
turretVehicle endon( "end_turret_scanning" );
|
|
|
|
turret_data = turretVehicle _get_turret_data( 0 );
|
|
|
|
turretVehicle.do_not_clear_targets_during_think = true; // don't let shared turret code clear targets; TurretScanning will clear targets
|
|
// note: turret:clear_target() indirectly affects targetType which affects how SetTurretTargetRelativeAngles behaves.
|
|
|
|
wait 0.8;
|
|
|
|
while( 1 )
|
|
{
|
|
if ( turretVehicle.controlled )
|
|
{
|
|
wait 0.5;
|
|
continue;
|
|
}
|
|
|
|
if ( turretVehicle turret::does_have_target( 0 ) )
|
|
{
|
|
wait 0.25;
|
|
continue;
|
|
}
|
|
|
|
/# turret_data = turretVehicle _get_turret_data( 0 ); #/ // for live update
|
|
|
|
turretVehicle turret::clear_target( 0 );
|
|
|
|
if ( turretVehicle.scanPos === "left" )
|
|
{
|
|
turretVehicle SetTurretTargetRelativeAngles( ( 0, ( turret_data.leftArc - 10 ), 0 ), 0 );
|
|
turretVehicle.scanPos = "right";
|
|
}
|
|
else
|
|
{
|
|
turretVehicle SetTurretTargetRelativeAngles( ( 0, -( turret_data.rightArc - 10 ), 0 ), 0 );
|
|
turretVehicle.scanPos = "left";
|
|
}
|
|
|
|
wait 2.5;
|
|
}
|
|
}
|
|
|
|
function WatchTurretShutdown( killstreakId, team )
|
|
{
|
|
turret = self;
|
|
|
|
turret waittill( "sentry_turret_shutdown" );
|
|
|
|
killstreakrules::killstreakStop( "autoturret", team, killstreakId );
|
|
|
|
if( isdefined( turret.vehicle ) )
|
|
{
|
|
turret.vehicle spawning::remove_influencers();
|
|
}
|
|
}
|