mirror of
https://github.com/reaaLx/nx1-gsc-dump.git
synced 2025-04-22 09:05:45 +00:00
771 lines
23 KiB
Plaintext
771 lines
23 KiB
Plaintext
#include maps\mp\_utility;
|
|
#include common_scripts\utility;
|
|
|
|
DOG_TIMEOUT_SEC = 45;
|
|
DOG_HUD_TIMER_POS_X = 0;
|
|
DOG_HUD_TIMER_POS_Y = -35;
|
|
DOG_TURRET_MAX_TARGETING_RANGE = 600; // 45 feet
|
|
DOG_TURRET_SPAWN_GRACE_TIME = 3; // dog wont shoot any anyone who hasn't been spawned for 3 seconds
|
|
DOG_TURRET_MIN_SHOTS = 10; // minimum shots to fire at a player
|
|
DOG_TURRET_MAX_SHOTS = 20; // maximum shots to fire at a player
|
|
DOG_TURRET_FIRE_DELAY = .1; // how long to wait between shots at a target
|
|
DOG_TURRET_MIN_BARRAGE_DELAY = 0; // how long to wait between firing bursts of shots at a target
|
|
DOG_TURRET_MAX_BARRAGE_DELAY = .1; // how long between burts of shots
|
|
DOG_TURRET_MAX_YAW = 60; // how far the turret can turn from the dogs centerline
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
init()
|
|
{
|
|
level._killstreakFuncs["remote_dog"] = ::tryRemoteDog;
|
|
level._remoteDogVehicleInfo = "PROTO_nx_remote_dog_play_mp";
|
|
level._remoteDogVehicleModel = "prototype_vehicle_remotedog_vehicle"; // "defaultvehicle"
|
|
level._remoteDogScriptModel = "prototype_vehicle_remotedog";
|
|
level._remoteDogMoveAnim = "german_shepherd_run";
|
|
level._remoteDogIdleAnim = "german_shepherd_idle";
|
|
level._remoteDogTranProp = "miniuav_transition_prop";
|
|
level._remoteDogTurretInfo = "proto_robot_dog_turret_mp";
|
|
level._remoteDogTurretModel = "proto_remotedog_turret";
|
|
level._remoteDogFOV = 120;
|
|
level._remoteDogHealth = 200;
|
|
level._remoteDogAmmo = 100;
|
|
level._remoteDogFireRate = 1; // in tenths of a second, so 10 is fires once a second
|
|
level._remoteDogCrossHair = "ac130_overlay_25mm";
|
|
|
|
PreCacheItem( level._remoteDogTranProp );
|
|
precacheString( &"NX_MINIUAV_USE_DRONE" );
|
|
PreCacheShader( "ac130_overlay_grain" );
|
|
PreCacheShader( level._remoteDogCrossHair );
|
|
|
|
precacheVehicle( level._remoteDogVehicleInfo );
|
|
precacheModel( level._remoteDogVehicleModel );
|
|
precacheMpAnim( level._remoteDogMoveAnim );
|
|
precacheMpAnim( level._remoteDogIdleAnim );
|
|
precacheModel( level._remoteDogScriptModel );
|
|
precacheTurret( level._remoteDogTurretInfo );
|
|
precacheModel( level._remoteDogTurretModel );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogDebugPrint( msg )
|
|
{
|
|
IPrintLnBold( msg );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
tryRemoteDog( lifeId )
|
|
{
|
|
self thread remoteDogStartup(); // Kick of main UAV loop.
|
|
msg = self waittill_any_return( "death", "cleanup_remote_dog" ); // Wait for death or timeout.
|
|
|
|
if( msg == "cleanup_remote_dog" )
|
|
{
|
|
// Wait for weapon transition to happen.
|
|
wait 2.0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogPlayerEventListenerThread()
|
|
{
|
|
self waittill( "exit_remote_dog" );
|
|
self.remotedog notify( "exit_remote_dog" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogStartup()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "remote_dog_time_is_up" );
|
|
self endon( "remote_dog_out_of_ammo" );
|
|
|
|
// self NotifyOnPlayerCommand( "switch_to_remote_dog", "+actionslot 4" );
|
|
|
|
self DisableOffhandWeapons();
|
|
self._dogPlayerOrigin = self GetOrigin();
|
|
self._dogPlayerAngles = self GetPlayerAngles();
|
|
|
|
// Wait for transition anim to finish.
|
|
wait 1.75;
|
|
|
|
// Enter the Dawg.
|
|
pos = self._dogPlayerOrigin + ( 0, 0, 50 );
|
|
|
|
// setup vehicle
|
|
self.remotedog = spawnVehicle( level._remoteDogVehicleModel, "test_dog", level._remoteDogVehicleInfo, pos, self._dogPlayerAngles );
|
|
self.remotedog.health = level._remoteDogHealth;
|
|
self.remotedog.maxhealth = self.remotedog.health;
|
|
self.remotedog setCanDamage( true );
|
|
self.remotedog.owner = self;
|
|
self.remotedog.team = self.team;
|
|
self.remotedog.ammo = level._remoteDogAmmo;
|
|
self.remotedog.fireRate = level._remoteDogFireRate;
|
|
self.remotedog.damageCallback = ::Callback_DogDamage;
|
|
// hide the remote dog, we're going to attach another model to it
|
|
self.remotedog Hide();
|
|
|
|
// setup dog model
|
|
self.remotedog.remoteDogModel = spawn( "script_model", pos );
|
|
self.remotedog.remoteDogModel.owner = self;
|
|
self.remotedog.remoteDogModel setModel( level._remoteDogScriptModel );
|
|
self.remotedog.remoteDogModel ScriptModelPlayAnim( level._remoteDogIdleAnim );
|
|
self.remotedog.remoteDogModel.angles = self._dogPlayerAngles;
|
|
self.remotedog.currAnim = level._remoteDogIdleAnim;
|
|
self.remotedog.remoteDogModel linkto( self.remotedog );
|
|
|
|
// setup hud and stuff
|
|
self.remotedog notify( "stop_turret_shoot" );
|
|
self.in_dog = true;
|
|
self thread remotedogHud();
|
|
self CameraLinkTo( self.remotedog, "tag_player" );
|
|
self.remote_dog_orig_fov = GetDvarFloat( "cg_fov" );
|
|
self setClientDvar( "cg_fov", level._remoteDogFOV );
|
|
self ThermalVisionFOFOverlayOn();
|
|
self visionSetNakedForPlayer( "cheat_bw", 0 );
|
|
|
|
// create the turret for the dawg
|
|
turretPoint = self.remotedog getTagOrigin( "TAG_TURRET" );
|
|
self.remotedog.turret = spawnTurret( "misc_turret", turretPoint, level._remoteDogTurretInfo );
|
|
self.remotedog.turret linkTo( self.remotedog, "TAG_TURRET", (0,0,0), (0,0,0) );
|
|
self.remotedog.turret setModel( level._remoteDogTurretModel );
|
|
self.remotedog.turret.angles = self.remotedog.angles;
|
|
self.remotedog.turret.owner = self.remotedog.owner;
|
|
self.remotedog.turret makeTurretInoperable();
|
|
self.remotedog.turret SetDefaultDropPitch( 0 );
|
|
//self.remotedog.turret.owner = self;
|
|
|
|
// find a point to for the turret to look at when it isn't trying to fire
|
|
offset = turretPoint - self.remotedog.origin;
|
|
neutralTargetEnt = spawn("script_origin", self.remotedog.turret getTagOrigin("tag_flash") );
|
|
neutralTargetEnt linkTo( self, "tag_origin", offset, (0,0,0) );
|
|
neutralTargetEnt hide();
|
|
self.remotedog.neutralTarget = neutralTargetEnt;
|
|
|
|
// spawn a thread to control the turret
|
|
self.remotedog thread remoteDogFindTargets();
|
|
|
|
// get them controls hooked up!
|
|
// self ControlsLinkTo( self.remotedog );
|
|
self MiniUAVOn( self.remotedog );
|
|
|
|
// Kick off timer.
|
|
self hudRemoteDogTimer( DOG_TIMEOUT_SEC );
|
|
self.remotedog thread RemoteDogWaitForTimeout( DOG_TIMEOUT_SEC );
|
|
|
|
|
|
// loop for the dog
|
|
self thread remoteDogLoop( self.remotedog );
|
|
|
|
// setup a thread to listen for the exit
|
|
self thread remoteDogPlayerEventListenerThread();
|
|
|
|
self.remotedog thread remoteDogExitCleanup();
|
|
|
|
return true;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogExitCleanup()
|
|
{
|
|
remoteDogDebugPrint( "remoteDogExitCleanup()" );
|
|
msg = self waittill_any_return( "death", "exit_remote_dog", "remote_dog_time_is_up", "remote_dog_out_of_ammo" ); // Wait for either way of exiting a uav.
|
|
remoteDogDebugPrint( "Running cleanup after msg " + msg );
|
|
self.owner thread remoteDogExitPlayer();
|
|
self notify( "cleanup_remote_dog" );
|
|
self.owner notify( "cleanup_remote_dog" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogFindTargets()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "cleanup_remote_dog" );
|
|
|
|
println( "Geting Targets" );
|
|
|
|
for ( ;; )
|
|
{
|
|
targets = [];
|
|
players = level._players;
|
|
|
|
for (i = 0; i <= players.size; i++)
|
|
{
|
|
if ( isDogTarget( players[i] ) && isdefined( players[i] ) )
|
|
{
|
|
targets[targets.size] = players[i];
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
|
|
wait( .05 );
|
|
}
|
|
if ( targets.size > 0 )
|
|
{
|
|
self acquireTarget( targets );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
wait( .05 );
|
|
}
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
isDogTarget( potentialTarget )
|
|
{
|
|
self endon( "death" );
|
|
|
|
if ( !isalive( potentialTarget ) || potentialTarget.sessionstate != "playing" )
|
|
return false;
|
|
|
|
if ( !isdefined( potentialTarget.pers["team"] ) )
|
|
return false;
|
|
|
|
if ( potentialTarget == self.owner )
|
|
return false;
|
|
|
|
if ( distanceSquared( potentialTarget.origin , self.origin ) > DOG_TURRET_MAX_TARGETING_RANGE*DOG_TURRET_MAX_TARGETING_RANGE )
|
|
return false;
|
|
|
|
if ( level._teamBased && potentialTarget.pers["team"] == self.team )
|
|
return false;
|
|
|
|
if ( potentialTarget.pers["team"] == "spectator" )
|
|
return false;
|
|
|
|
if ( isdefined( potentialTarget.spawntime ) && ( gettime() - potentialTarget.spawntime )/1000 <= DOG_TURRET_SPAWN_GRACE_TIME )
|
|
return false;
|
|
|
|
// check to see if they are in our yaw range
|
|
vecToTarget = potentialTarget.origin - self.origin;
|
|
targetYaw = AngleClamp( VectorToYaw( vecToTarget ) );
|
|
turretYaw = AngleClamp( self.angles[1] );
|
|
degrees = abs( targetYaw - self.angles[1] );
|
|
degrees = AngleClamp( degrees );
|
|
if( degrees > DOG_TURRET_MAX_YAW && ( 360 - degrees ) > DOG_TURRET_MAX_YAW )
|
|
{
|
|
// println( "bad degrees " + degrees + " angles " + turretYaw + " target yaw " + targetYaw );
|
|
return false;
|
|
}
|
|
// println( "good degrees " + degrees + " angles " + turretYaw + " target yaw " + targetYaw );
|
|
|
|
|
|
if ( isDefined( self ) )
|
|
{
|
|
minTurretEye = self.turret.origin + ( 0, 0, 64 );
|
|
minTurretCanSeeTarget = potentialTarget sightConeTrace( minTurretEye, self );
|
|
|
|
if ( minTurretCanSeeTarget < 1 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
getBestTarget( targets )
|
|
{
|
|
self endon( "death" );
|
|
origin = self.origin;
|
|
|
|
closest = undefined;
|
|
bestTarget = undefined;
|
|
|
|
foreach ( targ in targets )
|
|
{
|
|
curDist = Distance( self.origin, targ.origin );
|
|
|
|
if ( !isDefined( closest ) )
|
|
{
|
|
closest = curDist;
|
|
bestTarget = targ;
|
|
}
|
|
else if ( closest > curDist )
|
|
{
|
|
closest = curDist;
|
|
bestTarget = targ;
|
|
}
|
|
}
|
|
return ( bestTarget );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
acquireTarget( targets )
|
|
{
|
|
self endon( "death" );
|
|
|
|
if ( targets.size == 1 )
|
|
{
|
|
self.bestTarget = targets[0];
|
|
}
|
|
else
|
|
{
|
|
self.bestTarget = self getBestTarget( targets );
|
|
}
|
|
|
|
self notify( "acquiringTarget" );
|
|
self.turret SetTargetEntity( self.bestTarget, ( 0,0,42 ) ); // sets turret to target entity
|
|
wait( .15 );
|
|
self thread fireOnTarget(); // fires on current target.
|
|
self thread watchTargetDeath( targets ); //abandons target when target killed
|
|
self thread watchTargetDistance( targets );
|
|
self thread watchTargetAngle( targets );
|
|
self thread watchTargetThreat( self.bestTarget );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
fireOnTarget()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "abandonedTarget" );
|
|
self endon( "killedTarget" );
|
|
noTargTime = undefined;
|
|
acquiredTime = getTime();
|
|
|
|
if ( !isDefined( self.bestTarget ) )
|
|
{
|
|
println("No Targ to fire on");
|
|
return;
|
|
}
|
|
|
|
println("firing on best target");
|
|
|
|
while( 1 )
|
|
{
|
|
if ( !isDefined ( self.turret getTurretTarget( true ) ) )
|
|
{
|
|
if ( !isDefined( noTargTime ) )
|
|
noTargTime = getTime();
|
|
|
|
curTime = getTime();
|
|
|
|
if ( noTargTime - curTime > 1 )
|
|
{
|
|
noTargTime = undefined;
|
|
self thread explicitAbandonTarget();
|
|
return;
|
|
}
|
|
|
|
println("Waiting because the turret doesnt have a target" );
|
|
|
|
wait ( .5 );
|
|
continue;
|
|
}
|
|
|
|
|
|
numShots = randomIntRange( DOG_TURRET_MIN_SHOTS, DOG_TURRET_MAX_SHOTS );
|
|
for ( i = 0; i < numShots; i++ )
|
|
{
|
|
println( "actually shooting turret" );
|
|
self.turret ShootTurret();
|
|
wait ( DOG_TURRET_FIRE_DELAY );
|
|
}
|
|
wait ( randomFloatRange( DOG_TURRET_MIN_BARRAGE_DELAY, DOG_TURRET_MAX_BARRAGE_DELAY ) );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
watchTargetDeath( targets )
|
|
{
|
|
self endon( "abandonedTarget" );
|
|
self endon( "death" );
|
|
if ( !isDefined( self.bestTarget ) )
|
|
return;
|
|
|
|
self.bestTarget waittill( "death" );
|
|
|
|
self notify( "killedTarget" );
|
|
println( "Killed Target" );
|
|
|
|
self.bestTarget = undefined;
|
|
self.turret ClearTargetEntity();
|
|
self remoteDogFindTargets();
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
watchTargetAngle( targets )
|
|
{
|
|
self endon( "abandonedTarget" );
|
|
self endon( "death" );
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( !isDefined( self.bestTarget ) )
|
|
return;
|
|
|
|
// check to see if they are in our yaw range
|
|
vecToTarget = self.bestTarget.origin - self.origin;
|
|
targetYaw = AngleClamp( VectorToYaw( vecToTarget ) );
|
|
turretYaw = AngleClamp( self.angles[1] );
|
|
degrees = abs( targetYaw - self.angles[1] );
|
|
degrees = AngleClamp( degrees );
|
|
if( degrees > DOG_TURRET_MAX_YAW && ( 360 - degrees ) > DOG_TURRET_MAX_YAW )
|
|
{
|
|
println( "Abandon! degrees " + degrees + " angles " + self.angles[1] + " target yaw " + targetYaw );
|
|
self thread explicitAbandonTarget();
|
|
return;
|
|
}
|
|
wait ( 0.5 );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
watchTargetDistance( targets )
|
|
{
|
|
self endon( "abandonedTarget" );
|
|
self endon( "death" );
|
|
|
|
for ( ;; )
|
|
{
|
|
if ( !isDefined( self.bestTarget ) )
|
|
return;
|
|
|
|
trace = BulletTrace( self.turret.origin, self.bestTarget.origin, false, self );
|
|
traceDistance = Distance(self.origin, trace["position"] );
|
|
|
|
if ( traceDistance > DOG_TURRET_MAX_TARGETING_RANGE )
|
|
{
|
|
println( "TARGET DIST TOO FAR!!!" );
|
|
self thread explicitAbandonTarget();
|
|
return;
|
|
}
|
|
println( traceDistance );
|
|
wait ( 2 );
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
watchTargetThreat( curTarget )
|
|
{
|
|
self endon( "abandonedTarget" );
|
|
self endon( "death" );
|
|
self endon( "killedTarget" );
|
|
|
|
for ( ;; )
|
|
{
|
|
targets = [];
|
|
players = level._players;
|
|
|
|
for (i = 0; i <= players.size; i++)
|
|
{
|
|
if ( isDogTarget( players[i] ) )
|
|
{
|
|
if( !isdefined( players[i] ) )
|
|
continue;
|
|
|
|
if( !isdefined(curTarget) )
|
|
return;
|
|
|
|
traceOldTarg = Distance(self.origin, CurTarget.origin );
|
|
traceNewTarg = Distance(self.origin, players[i].origin );
|
|
|
|
if ( traceNewTarg < traceOldTarg )
|
|
{
|
|
self thread explicitAbandonTarget();
|
|
return;
|
|
}
|
|
}
|
|
|
|
wait( .05 );
|
|
}
|
|
|
|
wait( .25 );
|
|
}
|
|
}
|
|
|
|
explicitAbandonTarget( noNewTarget )
|
|
{
|
|
self notify( "abandonedTarget" );
|
|
|
|
println( "ABANDONED TARGET" );
|
|
|
|
self.bestTarget = undefined;
|
|
self.turret ClearTargetEntity();
|
|
|
|
if ( isDefined(noNewTarget) && noNewTarget )
|
|
return;
|
|
|
|
self thread remoteDogFindTargets();
|
|
return;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogLoop( vehicle )
|
|
{
|
|
self endon( "death" );
|
|
vehicle endon( "cleanup_remote_dog" );
|
|
|
|
self NotifyOnPlayerCommand( "exit_remote_dog", "+usereload" ); // BUTTON_X
|
|
|
|
vehicle._oldOrigin = vehicle.origin;
|
|
vehicle.fireCycle = 0;
|
|
|
|
while ( isalive( self ) )
|
|
{
|
|
if( vehicle.fireCycle > 0 )
|
|
{
|
|
vehicle.fireCycle = vehicle.fireCycle - 1;
|
|
}
|
|
|
|
// steal the player's angles to control turning the dog, for now...
|
|
angles = vehicle.angles;
|
|
player_angles = self GetPlayerAngles();
|
|
angles = ( player_angles[0], angles[1], angles[2] );
|
|
target = vehicle.origin + vector_multiply( AnglesToForward( angles ), 2000.0 );
|
|
|
|
// don't do this anymore, the turret is auto targetting now
|
|
// vehicle SetTurretTargetVec( target );
|
|
|
|
vehicle.remoteDogModel.angels = vehicle.angles;
|
|
|
|
// no more attack buttons to shoot
|
|
/* if( self AttackButtonPressed() )
|
|
{
|
|
if( vehicle.ammo > 0 && vehicle.fireCycle == 0)
|
|
{
|
|
vehicle fireweapon();
|
|
vehicle.fireCycle = vehicle.fireRate;
|
|
vehicle.ammo = vehicle.ammo - 1;
|
|
// out of ammo! lets get out of this thing!
|
|
if( vehicle.ammo == 0 )
|
|
{
|
|
self thread remotedogOutOfAmmoThead( vehicle );
|
|
}
|
|
}
|
|
}*/
|
|
|
|
if( distance( vehicle._oldOrigin, vehicle.origin ) > 0 )
|
|
{
|
|
if( vehicle.currAnim != level._remoteDogMoveAnim )
|
|
{
|
|
vehicle.remoteDogModel ScriptModelPlayAnim( level._remoteDogMoveAnim );
|
|
vehicle.currAnim = level._remoteDogMoveAnim;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( vehicle.currAnim != level._remoteDogIdleAnim )
|
|
{
|
|
vehicle.remoteDogModel ScriptModelPlayAnim( level._remoteDogIdleAnim );
|
|
vehicle.currAnim = level._remoteDogIdleAnim;
|
|
}
|
|
}
|
|
|
|
vehicle._oldOrigin = vehicle.origin;
|
|
wait 0.1;
|
|
}
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remotedogOutOfAmmoThead( vehicle )
|
|
{
|
|
remoteDogDebugPrint( "remotedogOutOfAmmoThead() out of ammo!" );
|
|
vehicle endon( "cleanup_remote_dog" );
|
|
wait 2;
|
|
vehicle notify( "remote_dog_out_of_ammo" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
Callback_DogDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName )
|
|
{
|
|
remoteDogDebugPrint( "damage callback" );
|
|
if ( ( attacker == self || ( isDefined( attacker.pers ) && attacker.pers["team"] == self.team ) ) && attacker != self.owner )
|
|
return;
|
|
|
|
remoteDogDebugPrint( "damaged dog! " + damage );
|
|
self Vehicle_FinishDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remoteDogExitPlayer()
|
|
{
|
|
// cleanup the models
|
|
self.remotedog.remoteDogModel Unlink();
|
|
self.remotedog.remoteDogModel Delete();
|
|
|
|
// cleanup the actual things
|
|
self.remotedog.turret Delete();
|
|
self.remotedog Delete();
|
|
|
|
self ThermalVisionFOFOverlayOff();
|
|
self CameraUnlink();
|
|
self setClientDvar( "cg_fov", self.remote_dog_orig_fov );
|
|
self MiniUAVOff();
|
|
// self ControlsUnlink();
|
|
self visionSetNakedForPlayer( getDvar( "mapname" ), 0 );
|
|
self setVelocity(( 0, 0, 0 ));
|
|
self setOrigin( self._dogPlayerOrigin );
|
|
self setPlayerAngles( self._dogPlayerAngles );
|
|
self switchToWeapon( self._pre_killstreak_weapon_name );
|
|
self destroyRemoteDogTimer();
|
|
wait 2.0;
|
|
self EnableOffhandWeapons();
|
|
self.in_dog = false;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
remotedogHud()
|
|
{
|
|
// crossHair = newClientHudElem( self );
|
|
// crossHair.x = 0;
|
|
// crossHair.y = 0;
|
|
// crossHair.alignX = "center";
|
|
// crossHair.alignY = "middle";
|
|
// crossHair.horzAlign = "center";
|
|
// crossHair.vertAlign = "middle";
|
|
// crossHair setshader( level._remoteDogCrossHair, 640, 480 );
|
|
// static = NewClientHudElem( self );
|
|
// static.horzAlign = "fullscreen";
|
|
// static.vertAlign = "fullscreen";
|
|
// static SetShader( "ac130_overlay_grain", 640, 480 );
|
|
//
|
|
// self waittill( "cleanup_remote_dog" ); // Wait for either way of exiting a uav.
|
|
// crossHair Destroy();
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
hudRemoteDogTimer( duration )
|
|
{
|
|
remoteDogDebugPrint( "hudRemoteDogTimer()" );
|
|
self.remoteDogTimer = newClientHudElem( self );
|
|
self.remoteDogTimer.x = DOG_HUD_TIMER_POS_X;
|
|
self.remoteDogTimer.y = DOG_HUD_TIMER_POS_Y;
|
|
self.remoteDogTimer.alignX = "center";
|
|
self.remoteDogTimer.alignY = "bottom";
|
|
self.remoteDogTimer.horzAlign = "center_adjustable";
|
|
self.remoteDogTimer.vertAlign = "bottom_adjustable";
|
|
self.remoteDogTimer.fontScale = 2.5;
|
|
self.remoteDogTimer setTimer( 1.0 );
|
|
self.remoteDogTimer.alpha = 1.0;
|
|
|
|
self.remoteDogTimer setTimer( duration );
|
|
println( "done setting hud timer" );
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
RemoteDogWaitForTimeout( duration )
|
|
{
|
|
self endon( "cleanup_remote_dog" );
|
|
wait duration;
|
|
remoteDogDebugPrint( "RemoteDogWaitForTimeout() Time's up!" );
|
|
self notify( "remote_dog_time_is_up" );
|
|
self._time_is_up = 1;
|
|
}
|
|
|
|
//*******************************************************************
|
|
// *
|
|
// *
|
|
//*******************************************************************
|
|
|
|
destroyRemoteDogTimer()
|
|
{
|
|
remoteDogDebugPrint( "cleanup timer!" );
|
|
self.remoteDogTimer Destroy();
|
|
}
|
|
|
|
/*
|
|
QUAKED script_vehicle_nx_miniuav_player_mp (1 0 0) (-16 -16 -24) (16 16 32) USABLE SPAWNER
|
|
|
|
put this in your GSC:
|
|
maps\mp\killstreaks\_miniuav::main( "nx_vehicle_miniuav" );
|
|
|
|
and these lines in your CSV:
|
|
include,nx_vehicle_miniuav_player
|
|
|
|
defaultmdl="nx_vehicle_miniuav"
|
|
default:"vehicletype" "nx_miniuav_player"
|
|
default:"script_team" "allies"
|
|
*/
|