(adsbygoogle = window.adsbygoogle || []).push({}); This works for all players for the whole game once you trigger it. This is how it works in my patch, it may be different for you.

Try it online in SnD

As an added bonus, if you just set the actionslot without the doNight, it disables noobtubes

If anyone knows a better "night" VisionsetNaked, let me know as this one is completely black. ( ive tried default night, its not dark enough.)

Init()

    

self.PickedNight=0

onPlayerSpawned()

    if(self.PickedNight==0){self _SetActionSlot(3,"");}else if(self.PickedNight==1){self _SetActionSlot(3,"nightvision");}

Call this function foreach player in level ...

    

doNightVision() {

    self endon("disconnect");

    self.PickedNight = 1;

    self _SetActionSlot(3, "nightvision");

    self thread maps\mp\gametypes\_hud_message::hintMessage("Press [{+actionslot 3}] To Toggle NightVision");

    self thread doNight();

}

doNight() {

    V = 0;

    for (; {

        self VisionSetNakedForPlayer("black_bw", 3);

        wait 0.01;

        V++;

    }

}

Thanks to the unkn0wn for the vision loop... And Thanks to JuddyLovesPizza for the help..

It was in the leaked beta ... :shh:

Could be made theres no proper model though.. or animation

It probably could, Its in the common_mp.ff on alterIW
It uses the abrahams_static model which is in the game.
It would take a lot of work to fill in the gaps though ..

Yes someone was working on it on Se7sins

Heres a bit of it if you fancy it..

init()
{
//tank support cut
return;
//tank support cut
/*
PrecacheVehicle( "bmp_mp" );
PrecacheVehicle( "m1a1_mp" );
PrecacheVehicle( "bradley_mp" );

precacheModel("vehicle_bmp");
precacheModel("vehicle_bradley");

precacheModel("sentry_gun");
precacheModel("vehicle_m1a1_abrams_d_static");
precacheTurret( "abrams_minigun_mp" );

/#
setDevDvar( "tankDir", "" );
setDevDvar( "tankForceTrigger", 0 );
if ( getDvar( "tankDebug" ) == "" )
setDevDvar( "tankDebug", 0 );
#/

level.killstreakFuncs["tank"] = ::useTank;
level.tankFire = loadfx( "explosions/large_vehicle_explosion" );
level.tankCover = loadfx( "props/american_smoke_grenade_mp" );

level.otherDir["forward"] = "reverse";
level.otherDir["reverse"] = "forward";

tankSpawners = Vehicle_GetSpawnerArray();

if ( !tankSpawners.size )
return;

if (!isDefined( getVehicleNode( "startnode", "targetname" ) ) )
{
assertEx ( !isDefined( getVehicleNode( "startnode", "targetname" ) ), "Vehicle spawn is setup but tank path is not setup in this level bug your friendly neighborhood LD." );
return false;
}

level.tankSpawner["allies"] = tankSpawners[0];
level.tankSpawner["axis"] = tankSpawners[0];
level.pathCount = 0;

foreach ( spawner in tankSpawners )
{
if ( isSubStr( spawner.model, "bradley" ) )
level.tankSpawner["allies"] = spawner;

if ( isSubStr( spawner.model, "bmp" ) )
level.tankSpawner["axis"] = spawner;
}

level setupPaths();

*/
}


spawnArmor( owner, vehicletype, model )
{
armor = self Vehicle_DoSpawn( "tank", owner );
//armor setModel( model );

armor.health = 3000;
armor.targeting_delay = 1;
armor.team = owner.team;
armor.pers["team"] = armor.team;
armor.owner = owner;
armor setCanDamage( true );
armor.standardSpeed = 12;

armor thread deleteOnZ();
armor addToTankList();
armor.damageCallback = ::Callback_VehicleDamage;

return armor;
}

deleteOnZ()
{
self endon ( "death" );

originalZ = self.origin[2];

for ( ;; )
{
if ( originalZ - self.origin[2] > 2048 )
{
self.health = 0;
self notify( "death" );
return;
}
wait ( 1.0 );
}
}


useTank( lifeId )
{
return ( self tryUseTank( ) );
}

tryUseTank( )
{
if ( isDefined( level.tankInUse ) && level.tankInUse )
{
self iPrintLnBold( "Armor support unavailable." );
return false;
}

if (!isDefined( getVehicleNode( "startnode", "targetname" ) ) )
{
self iPrintLnBold( "Tank is currently not supported in this level, bug your friendly neighborhood LD." );
return false;
}

if ( !Vehicle_GetSpawnerArray().size )
return false;

if ( self.team == "allies" )
tank = level.tankSpawner["allies"] spawnArmor( self, "vehicle_bradley" );
else
tank = level.tankSpawner["axis"] spawnArmor( self, "vehicle_bmp" );

//level.tank = tank;
tank startTank();
return true;
}


startTank( tankType )
{
startNode = getVehicleNode( "startnode", "targetname" );
waitNode = getVehicleNode( "waitnode", "targetname" );
self.nodes = GetVehicleNodeArray( "info_vehicle_node", "classname" );

level.tankInUse = true;
self thread tankUpdate( startNode, waitNode );
//self thread tankUpdateReverse( startNode, waitNode );

self thread tankDamageMonitor();
level.tank = self;


if ( level.teamBased )
{
objIDAllies = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( objIDAllies, "invisible", (0,0,0) );
objective_team( objIDAllies, "allies" );
level.tank.objID["allies"] = objIDAllies;

objIDAxis = maps\mp\gametypes\_gameobjects::getNextObjID();
objective_add( objIDAxis, "invisible", (0,0,0) );
objective_team( objIDAxis, "axis" );
level.tank.objID["axis"] = objIDAxis;

team = self.team;
level.tank.team = team;
level.tank.pers[ "team" ] = team;
}

mgTurret = spawnTurret( "misc_turret", self.origin, "abrams_minigun_mp" );
mgTurret linkTo( self, "tag_engine_left", (0,0,-20), (0,0,0) );
mgTurret setModel( "sentry_minigun" );
mgTurret.angles = self.angles;
mgTurret.owner = self.owner;
mgTurret makeTurretInoperable();
self.mgTurret = mgTurret;
self.mgTurret SetDefaultDropPitch( 0 );

oldangles = self.angles;
self.angles = (0,0,0);
tankTurretPoint = self getTagOrigin( "tag_flash" );
self.angles = oldangles;
offset = tankTurretPoint - self.origin;

self thread waitForChangeTeams();
self thread waitForDisco();

self.timeLastFired = getTime();

neutralTargetEnt = spawn("script_origin", self getTagOrigin("tag_flash") );
neutralTargetEnt linkTo( self, "tag_origin", offset, (0,0,0) );
neutralTargetEnt hide();
self.neutralTarget = neutralTargetEnt;

self thread tankGetTargets();
self thread destroyTank();
self thread tankGetMiniTargets();
self thread checkDanger();
self thread watchForThreat(); //reacts to players about to fire with rockets

/#
self thread forceDirection();
#/

}

waitForChangeTeams()
{
self endon ( "death" );
self.owner endon ( "disconnect" );

self.owner waittill ( "joined_team" );
self.health = 0;
self notify( "death" );
}

waitForDisco()
{
self endon ( "death" );

self.owner waittill ( "disconnect" );
self.health = 0;
self notify( "death" );
}

/#
forceDirection()
{
for ( ;; )
{
if ( getDvar( "tankDir" ) != "" )
{
forceDir = getDvar( "tankDir" );
if ( self.veh_pathdir != forceDir )
{
if ( forceDir == "forward" )
self stopToForward();
else
self stopToReverse();
}
}

wait ( 0.05 );
}
}
#/

//=================================================================
//
// Movement/Update Functions
//
//=================================================================

setDirection( direction )
{
if ( self.veh_pathdir != direction )
{
if ( direction == "forward" )
self stopToForward();
else
self stopToReverse();
}
}

setEngagementSpeed()
{
self endon( "death" );

self notify ( "path_abandoned" );

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

newSpeed = 2;
self vehicle_SetSpeed( newSpeed, 10, 10 );
self.speedType = "engage";
}

setMiniEngagementSpeed()
{
self endon( "death" );

self notify ( "path_abandoned" );

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

newSpeed = 2;
self vehicle_SetSpeed( newSpeed, 10, 10 );
self.speedType = "engage";
}

setStandardSpeed()
{
self endon( "death" );

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

self vehicle_SetSpeed( self.standardSpeed, 10, 10 );
self.speedType = "standard";
}

setEvadeSpeed()
{
self endon( "death" );

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

self vehicle_setSpeed( 15, 15, 15 );
self.speedType = "evade";
wait(1.5);
self vehicle_setSpeed( self.standardSpeed, 10, 10);
}

setDangerSpeed()
{
self endon( "death" );

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

self vehicle_SetSpeed( 5, 5, 5 );
self.speedType = "danger";
}

stopToReverse()
{
debugPrintLn2( "tank changing direction at " + getTime() );
self vehicle_setSpeed( 0, 5, 6 );

self.changingDirection = true;
while ( self.veh_speed > 0 )
wait ( 0.05 );

wait( 0.25 );
self.changingDirection = undefined;
debugPrintLn2( "tank done changing direction" );

self.veh_transmission = "reverse";
self.veh_pathDir = "reverse";
self vehicle_setSpeed( self.standardSpeed, 5, 6 );
}

stopToForward()
{
debugPrintLn2( "tank changing direction at " + getTime() );
self vehicle_setSpeed( 0, 5, 6 );

self.changingDirection = true;
while ( self.veh_speed > 0 )
wait ( 0.05 );

wait( 0.25 );
self.changingDirection = undefined;
debugPrintLn2( "tank done changing direction" );

self.veh_transmission = "forward";
self.veh_pathDir = "forward";
self vehicle_setSpeed( self.standardSpeed, 5, 6 );
}

checkDanger()
{
self endon( "death" );

targets = [];
players = level.players;
self.numEnemiesClose = 0;

for( ;; )
{
foreach (potentialTarget in players)
{
if ( !isDefined( potentialTarget ) )
continue;

if ( potentialTarget.team == self.team )
{
wait( .05 );
continue;
}

dist = Distance2d( potentialTarget.origin, self.origin );

if ( dist < 2048 )
{
self.numEnemiesClose++;
}
wait( .05 );
}

if ( isDefined( self.speedType ) && ( self.speedType == "evade" || self.speedType == "engage" ) )
{
self.numEnemiesClose = 0;
continue;
}

if ( self.numEnemiesClose > 1 )
self thread setDangerSpeed();
else
self thread setStandardSpeed();

self.numEnemiesClose = 0;
wait( .05 );
}
}

tankUpdate( startNode, waitNode )
{
self endon( "tankDestroyed" );
self endon( "death" );

if ( !isDefined( level.graphNodes ) )
{
self startPath( startNode );
return;
}

self attachPath( startNode );
self startPath( startNode );
startNode notify ( "trigger", self, true );

wait ( 0.05 );

for ( ;; )
{
/#
while ( getDvar( "tankDir" ) != "" )
wait ( 0.05 );
#/

while ( isDefined( self.changingDirection ) )
wait ( 0.05 );

endNode = self getNodeNearEnemies();

if ( isDefined( endNode ) )
self.endNode = endNode;
else
self.endNode = undefined;

wait ( 0.65 );
}
}


Callback_VehicleDamage( inflictor, attacker, damage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName )
{
if ( ( attacker == self || attacker == self.mgTurret || ( isDefined( attacker.pers ) && attacker.pers["team"] == self.team ) ) && ( attacker != self.owner || meansOfDeath == "MOD_MELEE" ) )
return;

tankDamage = modifyDamage( meansOfDeath, damage, attacker );

self Vehicle_FinishDamage( inflictor, attacker, tankDamage, dFlags, meansOfDeath, weapon, point, dir, hitLoc, timeOffset, modelIndex, partName );
}


// accumulate damage and react
tankDamageMonitor()
{
self endon( "death" );
self.damageTaken = 0;
speed = self vehicle_GetSpeed();
maxHealth = self.health;
stage1 = false;
stage2 = false;
stage3 = false;

for( ;; )
{
self waittill( "damage", amount, attacker, direction_vec, point, damageType );

if ( isDefined( attacker.classname ) && attacker.classname == "script_vehicle" )
{
if ( isDefined( self.bestTarget ) && self.bestTarget != attacker )
{
self.forcedTarget = attacker;
println( "Abandoning Target due to vehicle attacker" );
self thread explicitAbandonTarget();
}
}
else
{
if ( isPlayer( attacker ) )
{
attacker maps\mp\gametypes\_damagefeedback::updateDamageFeedback( "hitHelicopter" );

if ( attacker _hasPerk( "specialty_armorpiercing" ) )
{
damageAdd = amount*level.armorPiercingMod;
self.health -= int(damageAdd);
}
}
}

//stages will be used to effect effeciency of the tank
//accuracy, speed, smoke emitters etc....
if ( self.health <= 0 )
{
self notify( "death" );
print("sent death notify via script");
return;
}
else if (self.health < (maxHealth/4) && stage3 == false )
{
//newSpeed = 4;
//self vehicle_SetSpeed( newSpeed, 10, 10 );
//self.standardSpeed = newSpeed;
stage3 = true;


}
else if (self.health < (maxHealth/2) && stage2 == false )
{
//newSpeed = 6;
//self vehicle_SetSpeed( newSpeed, 10, 10 );
//self.standardSpeed = newSpeed;
stage2 = true;


}
else if (self.health < (maxHealth/1.5) && stage1 == false )
{
//newSpeed = 10;
//self vehicle_SetSpeed( newSpeed, 10, 10 );
//self.standardSpeed = newSpeed;
stage1 = true;
}

if ( amount > 1000 )
{
self handleThreat( attacker );
}
}
}

handleThreat( attacker )
{
self endon( "death" );

rand = randomInt(100);

if ( isDefined( self.bestTarget) && self.bestTarget != attacker && rand > 30 )
{
targ = [];
targ[0] = self.bestTarget;
explicitAbandonTarget( true, self.bestTarget );
self thread acquireTarget( targ );
}
else if ( !isDefined( self.bestTarget ) && rand > 30 )
{
targ = [];
targ[0] = attacker;
self thread acquireTarget( targ );
}
else if ( rand < 30 )
{
// all we know here is that it didnt hit the 70%
playFX( level.tankCover, self.origin);
self thread setEvadeSpeed();
}
else
{
self fireWeapon();
self playSound( "bmp_fire" );
}
}

handlePossibleThreat( attacker )
{
self endon( "death" );

position = relativeAngle( attacker );
distance = distance( self.origin, attacker.origin );

if ( RandomInt( 4 ) < 3 )
return;

if( position == "front" && distance < 768 ) //attempts to crush player
{
self thread setEvadeSpeed();
}
else if ( position == "rear_side" || ( position == "rear" && distance >= 768 ) )
{
playFX( level.tankCover, self.origin);
self thread setEvadeSpeed();
}
else if( position == "rear" && distance < 768 ) //attempts to crush player
{

self stopToReverse();
self setEvadeSpeed();
wait( 4 );
self stopToForward();

}
else if( position == "front_side" || position == "front" )
{
playFX( level.tankCover, self.origin);
self stopToReverse();
self setEvadeSpeed();
wait( 8 );
self stopToForward();
}
}

relativeAngle( ent1 )
{
self endon( "death" );
ent1 endon( "death" );
ent1 endon( "disconnect" );

tankForwardVector = anglesToForward( self.angles );
tankToEnt = ent1.origin - self.origin;
tankForwardVector *= (1,1,0);
tankToEnt *= (1,1,0 );

tankToEnt = VectorNormalize( tankToEnt );
TankForwardVector = VectorNormalize( tankForwardVector );

targetCosine = VectorDot( tankToEnt, tankForwardVector );

if ( targetCosine > 0 )
{
if ( targetCosine > .9 )
return "front";
else
return "front_side";
}
else
{
if ( targetCosine < -.9 )
return "rear";
else
return "rear_side";
}

ent1 iPrintLnBold( targetCosine );
}

watchForThreat()
{
self endon( "death" );

for ( ;; )
{
targets = [];
players = level.players;

foreach (player in players)
{
if ( !isDefined( player ) )
{
wait( .05 );
continue;
}

if ( !isTarget( player ) )
{
wait ( .05 );
continue;
}

currentWeapon = player GetCurrentWeapon();

if ( isSubStr( currentWeapon, "at4" ) || isSubStr( currentWeapon, "stinger" ) || isSubStr( currentWeapon, "javelin" ) )
{
self thread handlePossibleThreat( player );
wait( 8 );
}

wait( .15 );
}
}
}

//=================================================================
//
// Accessory Functions
//
//=================================================================

// checks if owner is valid, returns false if not valid
checkOwner()
{
if ( !isdefined( self.owner ) || !isdefined( self.owner.pers["team"] ) || self.owner.pers["team"] != self.team )
{
self notify ( "abandoned" );
return false;
}
return true;
}

drawLine( start, end, timeSlice, color )
{
drawTime = int(timeSlice * 20);
for( time = 0; time < drawTime; time++ )
{
line( start, end, color,false, 1 );
wait ( 0.05 );
}
}

modifyDamage( damageType, amount, attacker )
{
if ( damageType == "MOD_RIFLE_BULLET" )
return ( amount );
else if ( damageType == "MOD_PISTOL_BULLET" )
return ( amount );
else if ( damageType == "MOD_IMPACT" )
return ( amount );
else if (damageType == "MOD_MELEE" )
return ( 0 );
else if (damageType == "MOD_EXPLOSIVE_BULLET" )
return ( amount );
else if (damageType == "MOD_GRENADE" )
return ( amount * 5 );
else if (damageType == "MOD_GRENADE_SPLASH" )
return ( amount * 5 );
else
return amount * 10;
}

destroyTank()
{
self waittill ( "death" );

if ( level.teamBased )
{
team = level.tank.team;
objective_state( level.tank.objID[team], "invisible" );
objective_state( level.tank.objID[level.otherTeam[team]], "invisible" );
}

/* get the current team
if ( isDefined( level.tankSpawner["axis"] ) )
destroyedModel = ;
else
destroyedModel = ;
*/

// award attacker
self notify( "tankDestroyed" );
self Vehicle_SetSpeed( 0,10,10 );
level.tankInUse = false;
playFX( level.spawnFire, self.origin);

playFX( level.tankFire, self.origin);

self removeFromTankList();

destroyedTank = Spawn( "script_model", self.origin );
// set model to current destroyed model.
destroyedTank setModel( "vehicle_m1a1_abrams_d_static" );
destroyedTank.angles = self.angles;
self.mgTurret delete();
self delete();

wait(4);
destroyedTank delete();
}

//=================================================================
//
// Main Weapon Targeting Functions
//
//=================================================================

onHitPitchClamp()
{
self notify( "onTargOrTimeOut" );

self endon( "onTargOrTimeOut" );
self endon( "turret_on_target" );

self waittill( "turret_pitch_clamped" );
println( "Abandoning Target due to turret not being able to reach target" );
self thread explicitAbandonTarget( false, self.bestTarget );
}

fireOnTarget()
{
self endon( "abandonedTarget" );
self endon( "killedTarget" );
self endon( "death" );
self endon( "targetRemoved" );
self endon( "lostLOS" );


for ( ;; )
{
self onHitPitchClamp();

if ( !isDefined( self.bestTarget ) )
continue;

flashOrigin = self GetTagOrigin( "tag_flash" );
trace = BulletTrace( self.origin, flashOrigin, false, self );
if ( trace["position"] != flashOrigin )
{
println( "Abandoning Target due to turret not being able to reach target without clipping" );
self thread explicitAbandonTarget( false, self.bestTarget );
}

trace = BulletTrace( flashOrigin, self.bestTarget.origin, true, self );
distance = Distance(self.origin, trace["position"] );
realDistance = Distance( self.bestTarget.origin, self.origin );

//hitting somthing not even close
if ( distance < 384 || distance + 256 < realDistance )
{
wait( .5 );

if ( distance > 384 )
{
self waitForTurretReady();
self FireWeapon();
self playSound( "bmp_fire" );
self.timeLastFired = getTime();
}
println( "Abandoning due to not hitting intended space" );

// Adjust forward or backward to hit target...
// check angle of target
position = relativeAngle( self.bestTarget );

//if ( position == "rear_side" )
// backup
//if ( position == "front_side" )


self thread explicitAbandonTarget( false, self.bestTarget );
return;
}

self waitForTurretReady();

self FireWeapon();
self playSound( "bmp_fire" );
self.timeLastFired = getTime();
}
}

waitForTurretReady()
{
self endon( "abandonedTarget" );
self endon( "killedTarget" );
self endon( "death" );
self endon( "targetRemoved" );
self endon( "lostLOS" );

timeWaited = getTime() - self.timeLastFired;

if ( timeWaited < 1499 )
wait( 1.5 - timeWaited/1000 );
}

tankGetTargets( badTarget )
{
self endon( "death" );
self endon( "leaving" );
targets = [];

prof_begin( "tankTargets" );

for ( ;; )
{
targets = [];
players = level.players;

if ( isDefined( self.forcedTarget ) )
{
targets = [];
targets[0] = self.ForcedTarget;
self acquireTarget( targets );
self.forcedTarget = undefined;
}

if ( isDefined( level.harrier ) && level.harrier.team != self.team && isAlive( level.harrier ) )
{
if( isVehicleTarget( level.tank ) )
targets[targets.size] = level.tank;
}

if ( isDefined( level.chopper ) && level.chopper.team != self.team && isAlive( level.chopper ) )
{
if( isVehicleTarget( level.chopper ) )
targets[targets.size] = level.chopper;
}

foreach ( potentialTarget in players )
{
if (!isDefined( potentialTarget ) )
{
wait(.05);
continue;
}

if ( isDefined( badTarget ) && potentialTarget == badTarget )
continue;

if ( isTarget( potentialTarget ) )
{
if( isDefined( potentialTarget ) )
targets[targets.size] = potentialTarget;
}
else
continue;
}
if ( targets.size > 0 )
{
self acquireTarget( targets );
}
else
wait( 1 );
}
prof_end( "tankTargets" );
}

acquireTarget( targets )
{
self endon( "death" );

if ( targets.size == 1 )
self.bestTarget = targets[0];
else
self.bestTarget = self getBestTarget( targets );

self thread setEngagementSpeed(); // slows tank down to fire on target

// checks to abandon target
//self thread lostTarget(); // sets lost LOS and time of lost target
//self thread abandonTarget(); // if target is lost for 3+ seconds drops target and gets new one
self thread watchTargetDeath( targets ); //abandons target when target killed


self SetTurretTargetEnt( self.bestTarget ); // sets turret to target entity
self fireOnTarget(); // fires on current target.
self thread setNoTarget();
}

setNoTarget()
{
self endon( "death" );

self setStandardSpeed();
self removeTarget();
self setTurretTargetEnt( self.neutralTarget );
}

getBestTarget( targets )
{
self endon( "death" );
mainGunPointOrigin = self getTagOrigin( "tag_flash" );
tankOrigin = self.origin;

bestYaw = undefined;
bestTarget = undefined;
targetHasRocket = false;

foreach ( targ in targets )
{
angle = abs ( vectorToAngles ( ( targ.origin - self.origin ) )[1] );
cannonAngle = abs( self getTagAngles( "tag_flash" )[1] );
angle = abs ( angle - cannonAngle );

//vehicle priorities
if ( isDefined( level.chopper ) && targ == level.chopper )
return targ;

if ( isDefined( level.harrier ) && targ == level.harrier )
return targ;

// in this calculation having a rocket removes 40d of rotation cost from best target calculation
// to prioritize targeting dangerous targets.
weaponsArray = targ GetWeaponsListItems();
foreach ( weapon in weaponsArray )
{
if ( isSubStr( weapon, "at4" ) || isSubStr( weapon, "jav" ) || isSubStr( weapon, "c4" ) )
angle -= 40;
}

if ( !isDefined( bestYaw ) )
{
bestYaw = angle;
bestTarget = targ;
}
else if ( bestYaw > angle )
{
bestYaw = angle;
bestTarget = targ;
}
}

return ( bestTarget );
}

watchTargetDeath( targets )
{
self endon( "abandonedTarget" );
self endon( "lostLOS" );
self endon( "death" );
self endon( "targetRemoved" );

bestTarg = self.bestTarget;
bestTarg endon ( "disconnect" );

bestTarg waittill( "death" );

self notify( "killedTarget" );
self removeTarget();
self setStandardSpeed();
self thread setNoTarget();
}

explicitAbandonTarget( noNewTarget, targ )
{
self endon( "death" );

self notify( "abandonedTarget" );
println("ABANDON TARGET EXPLICIT");
self setStandardSpeed();
self thread Setnotarget();
self removeTarget();

if ( isDefined(targ) )
{
self.badTarget = targ;
badTargetReset();
}

if ( isDefined(noNewTarget) && noNewTarget )
return;

return;
}

badTargetReset()
{
self endon("death");

wait (1.5);
self.badTarget = undefined;
}

removeTarget()
{
self notify( "targetRemoved" );

self.bestTarget = undefined;
self.lastLostTime = undefined;
}

isVehicleTarget( potentialTarget )
{
if ( distance2D( potentialTarget.origin, self.origin ) > 4096 )
return false;

if ( distance( potentialTarget.origin , self.origin ) < 512 )
return false;

return turretSightTrace( potentialTarget, false );
}

isTarget( potentialTarget )
{
self endon( "death" );

dist = distanceSquared( potentialTarget.origin, self.origin );

if ( !level.teamBased && isDefined( self.owner ) && potentialTarget == self.owner )
return false;

if ( !isalive( potentialTarget ) || potentialTarget.sessionstate != "playing" )
return false;

if ( dist > 4096*4096 )
return false;

if ( dist < 512*512 )
return false;

if ( !isdefined( potentialTarget.pers["team"] ) )
return false;

if ( potentialTarget == self.owner )
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 <= 5 )
return false;

if ( potentialTarget _hasPerk( "specialty_coldblooded" ) )
return false;

return self Vehicle_CanTurretTargetPoint( potentialTarget.origin, 1, self );

//return self turretSightTrace( potentialTarget, false );
}

turretSightTrace( targ, debug )
{
turretCanSeeTarget = targ sightConeTrace( self getTagOrigin( "tag_turret" ), self );

if ( turretCanSeeTarget < .7 )
{
return false;
}

if ( isDefined(debug) && debug )
self thread drawLine( targ.origin, self getTagOrigin( "tag_turret" ), 10, (1,0,0) );

return true;
}

So what is actually missing?

Im not sure, i havent actually tried. It would take a fair bit of time i'd imagine.
Although you could probably rig it with harrier controls instead and just stick it to the floor and then get it to move with you like my pet pavelow, use magic buillets and hey presto... it would look like a tank ...

Bet you can't do it :carling: ha

You must login or register to view this content.

You should put this into AVP or Zombies or something:bro:. I would do it myself but I'm to busy with my own patch.