2257 lines
48 KiB
Plaintext
2257 lines
48 KiB
Plaintext
#include maps\mp\_utility;
|
|
#include common_scripts\utility;
|
|
//#include _vehicleLogic.gsc;
|
|
|
|
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;
|
|
}
|
|
|
|
//=================================================================
|
|
//
|
|
// Secondary Weapon Targeting Functions
|
|
//
|
|
//=================================================================
|
|
|
|
isMiniTarget( 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 ) > 1024*1024 )
|
|
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 ( isDefined( self ) )
|
|
{
|
|
minTurretEye = self.mgTurret.origin + ( 0, 0, 64 );
|
|
minTurretCanSeeTarget = potentialTarget sightConeTrace( minTurretEye, self );
|
|
|
|
if ( minTurretCanSeeTarget < 1 )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
tankGetMiniTargets()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "leaving" );
|
|
miniTargets = [];
|
|
println( "Geting Mini Targets" );
|
|
|
|
for ( ;; )
|
|
{
|
|
miniTargets = [];
|
|
players = level.players;
|
|
|
|
for (i = 0; i <= players.size; i++)
|
|
{
|
|
if ( isMiniTarget( players[i] ) )
|
|
{
|
|
if( isdefined( players[i] ) )
|
|
miniTargets[miniTargets.size] = players[i];
|
|
}
|
|
else
|
|
continue;
|
|
|
|
wait( .05 );
|
|
}
|
|
if ( miniTargets.size > 0 )
|
|
{
|
|
self acquireMiniTarget( miniTargets );
|
|
return;
|
|
}
|
|
else
|
|
wait( .5 );
|
|
}
|
|
}
|
|
|
|
getBestMiniTarget( targets )
|
|
{
|
|
self endon( "death" );
|
|
tankOrigin = self.origin;
|
|
|
|
closest = undefined;
|
|
bestTarget = undefined;
|
|
|
|
foreach ( targ in targets )
|
|
{
|
|
curDist = Distance( self.origin, targ.origin );
|
|
|
|
// in this calculation having a rocket javelin or c4 increases mini turret priority
|
|
// to prioritize targeting dangerous targets.
|
|
curWeaon = targ GetCurrentWeapon();
|
|
if ( isSubStr( curWeaon, "at4" ) || isSubStr( curWeaon, "jav" ) || isSubStr( curWeaon, "c4" ) || isSubStr( curWeaon, "smart" ) || isSubStr( curWeaon, "grenade" ) )
|
|
curDist -= 200;
|
|
|
|
if ( !isDefined( closest ) )
|
|
{
|
|
closest = curDist;
|
|
bestTarget = targ;
|
|
}
|
|
else if ( closest > curDist )
|
|
{
|
|
closest = curDist;
|
|
bestTarget = targ;
|
|
}
|
|
}
|
|
return ( bestTarget );
|
|
}
|
|
|
|
acquireMiniTarget( targets )
|
|
{
|
|
self endon( "death" );
|
|
|
|
if ( targets.size == 1 )
|
|
self.bestMiniTarget = targets[0];
|
|
else
|
|
self.bestMiniTarget = self getBestMiniTarget( targets );
|
|
|
|
if ( distance2D( self.origin, self.bestMiniTarget.origin) > 768 )
|
|
self thread setMiniEngagementSpeed();
|
|
|
|
self notify( "acquiringMiniTarget" );
|
|
self.mgTurret SetTargetEntity( self.bestMiniTarget, ( 0,0,64 ) ); // sets turret to target entity
|
|
wait( .15 );
|
|
self thread fireMiniOnTarget(); // fires on current target.
|
|
self thread watchMiniTargetDeath( targets ); //abandons target when target killed
|
|
self thread watchMiniTargetDistance( targets );
|
|
self thread watchMiniTargetThreat( self.bestMiniTarget );
|
|
}
|
|
|
|
fireMiniOnTarget()
|
|
{
|
|
self endon( "death" );
|
|
self endon( "abandonedMiniTarget" );
|
|
self endon( "killedMiniTarget" );
|
|
noTargTime = undefined;
|
|
miniAcquiredTime = getTime();
|
|
|
|
if ( !isDefined( self.bestMiniTarget ) )
|
|
{
|
|
println("No Targ to fire on");
|
|
return;
|
|
}
|
|
|
|
println("firing on best target");
|
|
|
|
while( 1 )
|
|
{
|
|
if ( !isDefined ( self.mgTurret getTurretTarget( true ) ) )
|
|
{
|
|
if ( !isDefined( noTargTime ) )
|
|
noTargTime = getTime();
|
|
|
|
curTime = getTime();
|
|
|
|
if ( noTargTime - curTime > 1 )
|
|
{
|
|
noTargTime = undefined;
|
|
self thread explicitAbandonMiniTarget();
|
|
return;
|
|
}
|
|
|
|
//println("Waiting because the turret doesnt have a target" );
|
|
|
|
wait ( .5 );
|
|
continue;
|
|
}
|
|
|
|
if ( getTime() > miniAcquiredTime + 1000 && !isDefined( self.bestTarget ) )
|
|
{
|
|
if ( distance2D(self.origin, self.bestMiniTarget.origin ) > 768 )
|
|
{
|
|
targets[0] = self.bestMiniTarget;
|
|
self acquireTarget( targets );
|
|
}
|
|
}
|
|
|
|
numShots = randomIntRange( 10, 16 );
|
|
for ( i = 0; i < numShots; i++ )
|
|
{
|
|
self.mgTurret ShootTurret();
|
|
wait ( .1 );
|
|
}
|
|
wait ( randomFloatRange( 0.5, 3.0 ) );
|
|
}
|
|
}
|
|
|
|
watchMiniTargetDeath( targets )
|
|
{
|
|
self endon( "abandonedMiniTarget" );
|
|
self endon( "death" );
|
|
if ( ! isDefined( self.bestMiniTarget ) )
|
|
return;
|
|
|
|
self.bestMiniTarget waittill( "death" );
|
|
|
|
self notify( "killedMiniTarget" );
|
|
println( "Killed Mini Target" );
|
|
|
|
self.bestMiniTarget = undefined;
|
|
self.mgTurret ClearTargetEntity();
|
|
self tankGetMiniTargets();
|
|
}
|
|
|
|
watchMiniTargetDistance( targets )
|
|
{
|
|
self endon( "abandonedMiniTarget" );
|
|
self endon( "death" );
|
|
|
|
for ( ;; )
|
|
{
|
|
if (! isDefined( self.bestMiniTarget ) )
|
|
return;
|
|
|
|
trace = BulletTrace( self.mgTurret.origin, self.bestMiniTarget.origin, false, self );
|
|
traceDistance = Distance(self.origin, trace["position"] );
|
|
|
|
if ( traceDistance > 1024 )
|
|
{
|
|
println( "MINI TARGET DIST TOO FAR!!!" );
|
|
self thread explicitAbandonMiniTarget();
|
|
return;
|
|
}
|
|
println( traceDistance );
|
|
wait ( 2 );
|
|
}
|
|
}
|
|
|
|
watchMiniTargetThreat( curTarget )
|
|
{
|
|
self endon( "abandonedMiniTarget" );
|
|
self endon( "death" );
|
|
self endon( "killedMiniTarget" );
|
|
|
|
for ( ;; )
|
|
{
|
|
miniTargets = [];
|
|
players = level.players;
|
|
|
|
for (i = 0; i <= players.size; i++)
|
|
{
|
|
if ( isMiniTarget( 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 explicitAbandonMiniTarget();
|
|
return;
|
|
}
|
|
}
|
|
|
|
wait( .05 );
|
|
}
|
|
|
|
wait( .25 );
|
|
}
|
|
}
|
|
|
|
explicitAbandonMiniTarget( noNewTarget )
|
|
{
|
|
|
|
self notify( "abandonedMiniTarget" );
|
|
|
|
println( "ABANDONED MINI TARGET" );
|
|
|
|
self.bestMiniTarget = undefined;
|
|
self.mgTurret ClearTargetEntity();
|
|
|
|
if ( isDefined(noNewTarget) && noNewTarget )
|
|
return;
|
|
|
|
self thread tankGetMiniTargets();
|
|
return;
|
|
}
|
|
|
|
|
|
addToTankList()
|
|
{
|
|
level.tanks[self getEntityNumber()] = self;
|
|
}
|
|
|
|
removeFromTankList()
|
|
{
|
|
level.tanks[self getEntityNumber()] = undefined;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
*
|
|
* PATHFINDING AND PATH NODE FUNCTIONS
|
|
*
|
|
***************************************************************************/
|
|
|
|
getNodeNearEnemies()
|
|
{
|
|
validEnemies = [];
|
|
|
|
foreach ( player in level.players )
|
|
{
|
|
if ( player.team == "spectator" )
|
|
continue;
|
|
|
|
if ( player.team == self.team )
|
|
continue;
|
|
|
|
if ( !isAlive( player ) )
|
|
continue;
|
|
|
|
player.dist = 0;
|
|
validEnemies[validEnemies.size] = player;
|
|
}
|
|
|
|
if ( !validEnemies.size )
|
|
return undefined;
|
|
|
|
for ( i = 0; i < validEnemies.size; i++ )
|
|
{
|
|
for ( j = i + 1; j < validEnemies.size; j++ )
|
|
{
|
|
dist = distanceSquared( validEnemies[i].origin, validEnemies[j].origin );
|
|
|
|
validEnemies[i].dist += dist;
|
|
validEnemies[j].dist += dist;
|
|
}
|
|
}
|
|
|
|
bestPlayer = validEnemies[0];
|
|
foreach ( player in validEnemies )
|
|
{
|
|
if ( player.dist < bestPlayer.dist )
|
|
bestPlayer = player;
|
|
}
|
|
|
|
bestOrigin = bestPlayer.origin;
|
|
|
|
sortedNodes = sortByDistance( level.graphNodes, bestOrigin );
|
|
|
|
//thread drawLine( bestOrigin, sortedNodes[0].origin, 10.0, (1,0,1) );
|
|
|
|
return ( sortedNodes[0] );
|
|
}
|
|
|
|
|
|
setupPaths()
|
|
{
|
|
tankNodes = [];
|
|
startNodes = [];
|
|
endNodes = [];
|
|
aStarGraphNodes = [];
|
|
|
|
// setup the start node
|
|
tankNode = GetVehicleNode( "startnode", "targetname" );
|
|
tankNodes[tankNodes.size] = tankNode;
|
|
startNodes[startNodes.size] = tankNode;
|
|
|
|
while ( isDefined( tankNode.target ) )
|
|
{
|
|
lastNode = tankNode;
|
|
tankNode = GetVehicleNode( tankNode.target, "targetname" );
|
|
tankNode.prev = lastNode;
|
|
|
|
// case for connected path
|
|
if ( tankNode == tankNodes[0] )
|
|
break;
|
|
|
|
tankNodes[tankNodes.size] = tankNode;
|
|
|
|
// case for disconnected path
|
|
if ( !isDefined( tankNode.target ) )
|
|
return;
|
|
}
|
|
|
|
tankNodes[0].branchNodes = [];
|
|
tankNodes[0] thread handleBranchNode( "forward" );
|
|
aStarGraphNodes[aStarGraphNodes.size] = tankNodes[0];
|
|
|
|
// find the start and end nodes of the branches
|
|
branchNodes = GetVehicleNodeArray( "branchnode", "targetname" );
|
|
foreach ( branchNode in branchNodes )
|
|
{
|
|
tankNode = branchNode;
|
|
tankNodes[tankNodes.size] = tankNode;
|
|
startNodes[startNodes.size] = tankNode;
|
|
|
|
while ( isDefined( tankNode.target ) )
|
|
{
|
|
lastNode = tankNode;
|
|
tankNode = GetVehicleNode( tankNode.target, "targetname" );
|
|
tankNodes[tankNodes.size] = tankNode;
|
|
tankNode.prev = lastNode;
|
|
|
|
if ( !isDefined( tankNode.target ) )
|
|
endNodes[endNodes.size] = tankNode;
|
|
}
|
|
}
|
|
|
|
// detect and initialize the branch nodes. These will be used for the aStar node graph
|
|
foreach ( tankNode in tankNodes )
|
|
{
|
|
isBranchNode = false;
|
|
foreach ( startNode in startNodes )
|
|
{
|
|
if ( startNode == tankNode )
|
|
continue;
|
|
|
|
if ( startNode.target == tankNode.targetname )
|
|
continue;
|
|
|
|
if ( isDefined( tankNode.target ) && tankNode.target == startNode.targetname )
|
|
continue;
|
|
|
|
if ( distance2d( tankNode.origin, startNode.origin ) > 80 )
|
|
continue;
|
|
|
|
startNode thread handleCapNode( tankNode, "reverse" );
|
|
startNode.prev = tankNode;
|
|
|
|
if ( !isDefined( tankNode.branchNodes ) )
|
|
tankNode.branchNodes = [];
|
|
|
|
tankNode.branchNodes[tankNode.branchNodes.size] = startNode;
|
|
|
|
isBranchNode = true;
|
|
}
|
|
|
|
if ( isBranchNode )
|
|
tankNode thread handleBranchNode( "forward" );
|
|
|
|
isJoinNode = false;
|
|
foreach ( endNode in endNodes)
|
|
{
|
|
if ( endNode == tankNode )
|
|
continue;
|
|
|
|
if ( !isDefined( tankNode.target ) )
|
|
continue;
|
|
|
|
if ( tankNode.target == endNode.targetname )
|
|
continue;
|
|
|
|
if ( isDefined( endNode.target ) && endNode.target == tankNode.targetname )
|
|
continue;
|
|
|
|
if ( distance2d( tankNode.origin, endNode.origin ) > 80 )
|
|
continue;
|
|
|
|
endNode thread handleCapNode( tankNode, "forward" );
|
|
endNode.next = getVehicleNode( tankNode.targetname, "targetname" );
|
|
//endNode.target = tankNode.targetname; // READ-ONLY field...
|
|
endNode.length = distance( endNode.origin, tankNode.origin );
|
|
|
|
if ( !isDefined( tankNode.branchNodes ) )
|
|
tankNode.branchNodes = [];
|
|
|
|
tankNode.branchNodes[tankNode.branchNodes.size] = endNode;
|
|
|
|
isJoinNode = true;
|
|
}
|
|
|
|
if ( isJoinNode )
|
|
{
|
|
assert( !isBranchNode );
|
|
tankNode thread handleBranchNode( "reverse" );
|
|
}
|
|
|
|
if ( isJoinNode || isBranchNode )
|
|
aStarGraphNodes[aStarGraphNodes.size] = tankNode;
|
|
}
|
|
|
|
if ( aStarGraphNodes.size < 3 )
|
|
{
|
|
level notify ( "end_tankPathHandling" );
|
|
return;
|
|
}
|
|
|
|
// subdivide the path a bit...
|
|
segmentNodes = [];
|
|
foreach( tankNode in tankNodes )
|
|
{
|
|
if ( !isDefined( tankNode.branchNodes ) )
|
|
continue;
|
|
|
|
segmentNodes[segmentNodes.size] = tankNode;
|
|
}
|
|
|
|
foreach ( segmentNode in segmentNodes )
|
|
{
|
|
tankNode = segmentNode;
|
|
pathLength = 0;
|
|
|
|
while ( isDefined( tankNode.target ) )
|
|
{
|
|
prevNode = tankNode;
|
|
tankNode = GetVehicleNode( tankNode.target, "targetname" );
|
|
pathLength += distance( tankNode.origin, prevNode.origin );
|
|
|
|
if ( tankNode == segmentNode )
|
|
break;
|
|
|
|
if ( isDefined( tankNode.branchNodes ) )
|
|
break;
|
|
}
|
|
|
|
if ( pathLength > 1000 )
|
|
{
|
|
tankNode = segmentNode;
|
|
curLength = 0;
|
|
|
|
while ( isDefined( tankNode.target ) )
|
|
{
|
|
prevNode = tankNode;
|
|
tankNode = GetVehicleNode( tankNode.target, "targetname" );
|
|
|
|
curLength += distance( tankNode.origin, prevNode.origin );
|
|
if ( curLength < pathLength / 2 )
|
|
continue;
|
|
|
|
tankNode.branchNodes = []; // necessary?
|
|
tankNode thread handleBranchNode( "forward" );
|
|
aStarGraphNodes[aStarGraphNodes.size] = tankNode;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
level.graphNodes = initNodeGraph( aStarGraphNodes );
|
|
|
|
foreach ( tankNode in tankNodes )
|
|
{
|
|
if ( !isDefined( tankNode.graphId ) )
|
|
tankNode thread nodeTracker();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
getRandomBranchNode( direction )
|
|
{
|
|
branchNodes = [];
|
|
foreach ( graphId, linkNode in self.links )
|
|
{
|
|
// pick a branch in the direction we're already heading
|
|
if ( self.linkDirs[graphId] != direction )
|
|
continue;
|
|
|
|
branchNodes[branchNodes.size] = linkNode;
|
|
}
|
|
|
|
return ( branchNodes[randomInt( branchNodes.size )] );
|
|
}
|
|
|
|
|
|
getNextNodeForEndNode( endNode, direction )
|
|
{
|
|
graphNode = level.graphNodes[self.graphId];
|
|
|
|
continuePath = generatePath( graphNode, endNode, undefined, direction );
|
|
continueG = continuePath[0].g;
|
|
|
|
changePath = generatePath( graphNode, endNode, undefined, level.otherDir[direction] );
|
|
changeG = changePath[0].g;
|
|
|
|
// temporarily force the tank to only go forward
|
|
if ( !getDvarInt( "tankDebug" ) )
|
|
changeG = 9999999;
|
|
|
|
if ( continueG <= changeG )
|
|
return ( continuePath[1] );
|
|
}
|
|
|
|
|
|
handleBranchNode( direction )
|
|
{
|
|
level endon ( "end_tankPathHandling" );
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger", tank, wasForced );
|
|
|
|
graphNode = level.graphNodes[self.graphId];
|
|
|
|
tank.node = self;
|
|
|
|
nextGraphNode = undefined;
|
|
if ( isDefined( tank.endNode ) && tank.endNode != graphNode )
|
|
{
|
|
nextGraphNode = getNextNodeForEndNode( tank.endNode, tank.veh_pathdir );
|
|
|
|
if ( !isDefined( nextGraphNode ) )
|
|
tank thread setDirection( level.otherDir[tank.veh_pathdir] );
|
|
}
|
|
|
|
if ( !isDefined( nextGraphNode ) || nextGraphNode == graphNode )
|
|
{
|
|
nextGraphNode = graphNode getRandomBranchNode( tank.veh_pathdir );
|
|
}
|
|
|
|
goalNode = graphNode.linkStartNodes[nextGraphNode.graphId];
|
|
|
|
if ( tank.veh_pathdir == "forward" )
|
|
nextLinkNode = self getNextNode();
|
|
else
|
|
nextLinkNode = self getPrevNode();
|
|
|
|
// if we're already on this path, just keep going
|
|
if ( nextLinkNode != goalNode )
|
|
tank startPath( goalNode );
|
|
}
|
|
}
|
|
|
|
|
|
handleCapNode( joinNode, direction )
|
|
{
|
|
for ( ;; )
|
|
{
|
|
self waittill( "trigger", tank );
|
|
|
|
if ( tank.veh_pathdir != direction )
|
|
continue;
|
|
|
|
debugPrintLn2( "tank starting path at join node: " + joinNode.graphId );
|
|
|
|
tank startPath( joinNode );
|
|
}
|
|
}
|
|
|
|
|
|
nodeTracker()
|
|
{
|
|
self.forwardGraphId = getForwardGraphNode().graphId;
|
|
self.reverseGraphId = getReverseGraphNode().graphId;
|
|
|
|
for ( ;; )
|
|
{
|
|
self waittill ( "trigger", tank, wasForced );
|
|
|
|
tank.node = self;
|
|
|
|
/#
|
|
if ( getDvarInt( "tankForceTrigger" ) )
|
|
{
|
|
if ( tank.veh_pathdir == "forward" )
|
|
tank thread forceTrigger( self, self getNextNode(), tank );
|
|
else
|
|
tank thread forceTrigger( self, self getPrevNode(), tank );
|
|
}
|
|
#/
|
|
|
|
tank.forwardGraphId = self.forwardGraphId;
|
|
tank.reverseGraphId = self.reverseGraphId;
|
|
|
|
if ( !isDefined( self.target ) || self.targetname == "branchnode" )
|
|
nodeType = "TRANS";
|
|
else
|
|
nodeType = "NODE";
|
|
|
|
if ( isDefined( wasForced ) )
|
|
debugPrint3D( self.origin, nodeType, (1,0.5,0), 1, 2, 100 );
|
|
else
|
|
debugPrint3D( self.origin, nodeType, (0,1,0), 1, 2, 100 );
|
|
}
|
|
}
|
|
|
|
|
|
forceTrigger( prevNode, nextNode, tank )
|
|
{
|
|
nextNode endon ( "trigger" );
|
|
prevNode endon ( "trigger" );
|
|
tank endon ( "death" );
|
|
|
|
minDist = distanceSquared( tank.origin, nextNode.origin );
|
|
tankDir = tank.veh_pathdir;
|
|
|
|
debugPrint3D( prevNode.origin+(0,0,30), "LAST", (0,0,1), 0.5, 1, 100 );
|
|
debugPrint3D( nextNode.origin+(0,0,60), "NEXT", (0,1,0), 0.5, 1, 100 );
|
|
|
|
timeOutNextFrame = false;
|
|
for ( ;; )
|
|
{
|
|
wait ( 0.05 );
|
|
|
|
// tank changed direction
|
|
if ( tankDir != tank.veh_pathdir )
|
|
{
|
|
debugPrintLn2( "tank missed node: reversing direction" );
|
|
tank thread forceTrigger( nextNode, prevNode, tank );
|
|
return;
|
|
}
|
|
|
|
if ( timeOutNextFrame )
|
|
{
|
|
debugPrintLn2( "... sending notify." );
|
|
nextNode notify ( "trigger", tank, true );
|
|
return;
|
|
}
|
|
|
|
curDist = distanceSquared( tank.origin, nextNode.origin );
|
|
|
|
if ( curDist > minDist )
|
|
{
|
|
timeOutNextFrame = true;
|
|
debugPrintLn2( "tank missed node: forcing notify in one frame..." );
|
|
}
|
|
|
|
minDist = curDist;
|
|
}
|
|
}
|
|
|
|
|
|
getForwardGraphNode()
|
|
{
|
|
assert( !isDefined( self.graphId ) );
|
|
|
|
checkNode = self;
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
checkNode = checkNode getNextNode();
|
|
|
|
return checkNode;
|
|
}
|
|
|
|
|
|
getReverseGraphNode()
|
|
{
|
|
assert( !isDefined( self.graphId ) );
|
|
|
|
checkNode = self;
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
checkNode = checkNode getPrevNode();
|
|
|
|
return checkNode;
|
|
}
|
|
|
|
|
|
getNextNode()
|
|
{
|
|
if ( isDefined( self.target ) )
|
|
return ( GetVehicleNode( self.target, "targetname" ) );
|
|
else
|
|
return ( self.next );
|
|
}
|
|
|
|
|
|
getPrevNode()
|
|
{
|
|
return self.prev;
|
|
}
|
|
|
|
|
|
|
|
// Builds the aStar node graph
|
|
initNodeGraph( astarBaseNodes )
|
|
{
|
|
graphNodes = [];
|
|
foreach ( pathNode in aStarBaseNodes )
|
|
{
|
|
graphNode = spawnStruct();
|
|
graphNode.linkInfos = [];
|
|
graphNode.links = [];
|
|
graphNode.linkLengths = [];
|
|
graphNode.linkDirs = [];
|
|
graphNode.linkStartNodes = [];
|
|
graphNode.node = pathNode;
|
|
graphNode.origin = pathNode.origin;
|
|
graphNode.graphId = graphNodes.size;
|
|
pathNode.graphId = graphNodes.size;
|
|
|
|
debugPrint3D( graphNode.origin + (0,0,80), graphNode.graphId, (1,1,1), 0.65, 2, 100000 );
|
|
|
|
graphNodes[graphNodes.size] = graphNode;
|
|
}
|
|
|
|
foreach ( pathNode in aStarBaseNodes )
|
|
{
|
|
graphId = pathNode.graphId;
|
|
|
|
checkNode = GetVehicleNode( pathNode.target, "targetname" );
|
|
linkLength = distance( pathNode.origin, checkNode.origin );
|
|
linkStartNode = checkNode;
|
|
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
{
|
|
linkLength += distance( checkNode.origin, checkNode.prev.origin );
|
|
|
|
if ( isDefined( checkNode.target ) )
|
|
checkNode = GetVehicleNode( checkNode.target, "targetname" );
|
|
else
|
|
checkNode = checkNode.next;
|
|
}
|
|
|
|
assert( checkNode != pathNode );
|
|
graphNodes[graphId] addLinkNode( graphNodes[checkNode.graphId], linkLength, "forward", linkStartNode );
|
|
|
|
checkNode = pathNode.prev;
|
|
linkLength = distance( pathNode.origin, checkNode.origin );
|
|
linkStartNode = checkNode;
|
|
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
{
|
|
linkLength += distance( checkNode.origin, checkNode.prev.origin );
|
|
checkNode = checkNode.prev;
|
|
}
|
|
|
|
assert( checkNode != pathNode );
|
|
graphNodes[graphId] addLinkNode( graphNodes[checkNode.graphId], linkLength, "reverse", linkStartNode );
|
|
|
|
foreach ( branchNode in pathNode.branchNodes )
|
|
{
|
|
checkNode = branchNode;
|
|
linkLength = distance( pathNode.origin, checkNode.origin );
|
|
linkStartNode = checkNode;
|
|
|
|
if ( checkNode.targetname == "branchnode" )
|
|
{
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
{
|
|
if ( isDefined( checkNode.target ) )
|
|
nextNode = GetVehicleNode( checkNode.target, "targetname" );
|
|
else
|
|
nextNode = checkNode.next;
|
|
|
|
linkLength += distance( checkNode.origin, nextNode.origin );
|
|
checkNode = nextNode;
|
|
}
|
|
|
|
assert( checkNode != pathNode );
|
|
graphNodes[graphId] addLinkNode( graphNodes[checkNode.graphId], linkLength, "forward", linkStartNode );
|
|
}
|
|
else
|
|
{
|
|
while ( !isDefined( checkNode.graphId ) )
|
|
{
|
|
linkLength += distance( checkNode.origin, checkNode.prev.origin );
|
|
checkNode = checkNode.prev;
|
|
}
|
|
|
|
assert( checkNode != pathNode );
|
|
graphNodes[graphId] addLinkNode( graphNodes[checkNode.graphId], linkLength, "reverse", linkStartNode );
|
|
}
|
|
}
|
|
}
|
|
|
|
return graphNodes;
|
|
}
|
|
|
|
|
|
addLinkNode( graphNode, linkLength, linkDir, linkStartNode )
|
|
{
|
|
assert( self.graphId != graphNode.graphId );
|
|
assert( !isDefined( self.links[graphNode.graphId] ) );
|
|
|
|
self.links[graphNode.graphId] = graphNode;
|
|
self.linkLengths[graphNode.graphId] = linkLength;
|
|
self.linkDirs[graphNode.graphId] = linkDir;
|
|
self.linkStartNodes[graphNode.graphId] = linkStartNode;
|
|
|
|
linkInfo = spawnStruct();
|
|
linkInfo.toGraphNode = graphNode;
|
|
linkInfo.toGraphId = graphNode.graphId;
|
|
linkInfo.length = linkLength;
|
|
linkInfo.direction = linkDir;
|
|
linkInfo.startNode = linkStartNode;
|
|
|
|
self.linkInfos[graphNode.graphId] = linkInfo;
|
|
}
|
|
|
|
|
|
// call function as generatePath(startNode, destNode), otherwise paths will be reversed
|
|
generatePath( destNode, startNode, blockedNodes, direction )
|
|
{
|
|
level.openList = [];
|
|
level.closedList = [];
|
|
foundPath = false;
|
|
pathNodes = [];
|
|
|
|
if ( !isDefined( blockedNodes ) )
|
|
blockedNodes = [];
|
|
|
|
startNode.g = 0;
|
|
startNode.h = getHValue( startNode, destNode );
|
|
startNode.f = startNode.g + startNode.h;
|
|
|
|
addToClosedList( startNode );
|
|
|
|
curNode = startNode;
|
|
for ( ;; )
|
|
{
|
|
foreach ( linkId, checkNode in curNode.links )
|
|
{
|
|
if ( is_in_array( blockedNodes, checkNode ) )
|
|
continue;
|
|
|
|
if ( is_in_array( level.closedList, checkNode ) )
|
|
continue;
|
|
|
|
if ( isDefined( direction ) && checkNode.linkDirs[curNode.graphId] != direction )
|
|
continue;
|
|
|
|
if ( !is_in_array( level.openList, checkNode ) )
|
|
{
|
|
addToOpenList( checkNode );
|
|
|
|
checkNode.parentNode = curNode;
|
|
checkNode.g = getGValue( checkNode, curNode );
|
|
checkNode.h = getHValue( checkNode, destNode );
|
|
checkNode.f = checkNode.g + checkNode.h;
|
|
|
|
if ( checkNode == destNode )
|
|
foundPath = true;
|
|
}
|
|
else
|
|
{
|
|
if ( checkNode.g < getGValue( curNode, checkNode ) )
|
|
continue;
|
|
|
|
checkNode.parentNode = curNode;
|
|
checkNode.g = getGValue( checkNode, curNode );
|
|
checkNode.f = checkNode.g + checkNode.h;
|
|
}
|
|
}
|
|
|
|
if ( foundPath )
|
|
break;
|
|
|
|
addToClosedList( curNode );
|
|
|
|
bestNode = level.openList[0];
|
|
|
|
foreach ( testNode in level.openList )
|
|
{
|
|
if ( testNode.f > bestNode.f )
|
|
continue;
|
|
|
|
bestNode = testNode;
|
|
}
|
|
|
|
assert( isDefined( bestNode ) ); // the tank should always have a path
|
|
|
|
addToClosedList( bestNode );
|
|
curNode = bestNode;
|
|
}
|
|
|
|
assert( isDefined( destNode.parentNode ) );
|
|
|
|
curNode = destNode;
|
|
while (curNode != startNode)
|
|
{
|
|
pathNodes[pathNodes.size] = curNode;
|
|
curNode = curNode.parentNode;
|
|
}
|
|
pathNodes[pathNodes.size] = curNode;
|
|
|
|
return pathNodes;
|
|
}
|
|
|
|
|
|
addToOpenList( node )
|
|
{
|
|
node.openListID = level.openList.size;
|
|
level.openList[level.openList.size] = node;
|
|
node.closedListID = undefined;
|
|
}
|
|
|
|
|
|
addToClosedList( node )
|
|
{
|
|
if (isdefined (node.closedListID))
|
|
return;
|
|
|
|
node.closedListID = level.closedList.size;
|
|
level.closedList[level.closedList.size] = node;
|
|
|
|
if (!is_in_array (level.openList, node))
|
|
return;
|
|
|
|
level.openList[node.openListID] = level.openList[level.openList.size - 1];
|
|
level.openList[node.openListID].openListID = node.openListID;
|
|
level.openList[level.openList.size - 1] = undefined;
|
|
node.openListID = undefined;
|
|
}
|
|
|
|
|
|
getHValue (node1, node2)
|
|
{
|
|
return (distance (node1.node.origin, node2.node.origin));
|
|
}
|
|
|
|
|
|
getGValue(node1, node2)
|
|
{
|
|
return ( node1.parentNode.g + node1.linkLengths[node2.graphId] );
|
|
}
|
|
|
|
|
|
is_in_array( aeCollection, eFindee )
|
|
{
|
|
for ( i = 0; i < aeCollection.size; i++ )
|
|
{
|
|
if ( aeCollection[ i ] == eFindee )
|
|
return( true );
|
|
}
|
|
|
|
return( false );
|
|
}
|
|
|
|
|
|
drawPath( pathNodes )
|
|
{
|
|
for ( i = 1; i < pathNodes.size; i++ )
|
|
{
|
|
startNode = pathNodes[i-1];
|
|
endNode = pathNodes[i];
|
|
|
|
if ( startNode.linkDirs[endNode.graphId] == "reverse" )
|
|
level thread drawLink( startNode.node.origin, endNode.node.origin, (1,0,0) );
|
|
else
|
|
level thread drawLink( startNode.node.origin, endNode.node.origin, (0,1,0) );
|
|
|
|
vehNode = startNode.linkStartNodes[endNode.graphId];
|
|
level thread drawLink( startNode.node.origin + (0,0,4), vehNode.origin + (0,0,4), (0,0,1) );
|
|
|
|
if ( startNode.linkDirs[endNode.graphId] == "reverse" )
|
|
{
|
|
while ( !isDefined( vehNode.graphId ) )
|
|
{
|
|
lastVehNode = vehNode;
|
|
vehNode = vehNode.prev;
|
|
level thread drawLink( lastVehNode.origin + (0,0,4), vehNode.origin + (0,0,4), (0,1,1) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while ( !isDefined( vehNode.graphId ) )
|
|
{
|
|
lastVehNode = vehNode;
|
|
|
|
if ( isDefined( vehNode.target ) )
|
|
vehNode = GetVehicleNode( vehNode.target, "targetname" );
|
|
else
|
|
vehNode = vehNode.next;
|
|
|
|
level thread drawLink( lastVehNode.origin + (0,0,4), vehNode.origin + (0,0,4), (0,1,1) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
drawGraph( pathNodes )
|
|
{
|
|
/*
|
|
level.pathZOffset = 0;
|
|
foreach ( node in pathNodes )
|
|
{
|
|
println( node.links.size );
|
|
foreach ( linkId, graphNode in node.links )
|
|
{
|
|
if ( node.linkDirs[linkId] == "reverse" )
|
|
level thread drawLink( node.node.origin, graphNode.node.origin, (0,1,0) );
|
|
else
|
|
level thread drawLink( node.node.origin, graphNode.node.origin, (1,0,0) );
|
|
|
|
//if ( node.linkDirs[linkId] == "reverse" )
|
|
// continue;
|
|
|
|
//level thread drawLink( pathNodes[graphId].node.origin, pathNodes[node.graphId].node.origin, (randomFloat( 2 ), randomFloat( 2 ), randomFloat( 2 )) );
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
drawLink( start, end, color )
|
|
{
|
|
level endon ( "endpath" );
|
|
for ( ;; )
|
|
{
|
|
line(start, end, color, true);
|
|
wait 0.05;
|
|
}
|
|
}
|
|
|
|
debugPrintLn2( printString )
|
|
{
|
|
/#
|
|
if ( getDvarInt( "tankDebug" ) )
|
|
printLn( printString );
|
|
#/
|
|
}
|
|
|
|
debugPrint( printString )
|
|
{
|
|
/#
|
|
if ( getDvarInt( "tankDebug" ) )
|
|
print( printString );
|
|
#/
|
|
}
|
|
|
|
|
|
debugPrint3D( origin, printString, color, alpha, scale, duration )
|
|
{
|
|
/#
|
|
if ( getDvarInt( "tankDebug" ) )
|
|
{
|
|
print3d( origin, printString, color, alpha, scale, duration );
|
|
println( "3D: " + printString );
|
|
}
|
|
#/
|
|
}
|
|
|
|
|
|
drawTankGraphIds()
|
|
{
|
|
/#
|
|
if ( getDvarInt( "tankDebug" ) )
|
|
{
|
|
self notify ( "drawTankGraphIds" );
|
|
self endon ( "drawTankGraphIds" );
|
|
|
|
for ( ;; )
|
|
{
|
|
print3d( self.origin + (0,0,128), "FW: " + self.forwardGraphId + " RV: " + self.reverseGraphId, (0,1,0), 1, 3, 1 );
|
|
wait ( 0.05 );
|
|
}
|
|
}
|
|
#/
|
|
}
|
|
|