(adsbygoogle = window.adsbygoogle || []).push({}); Here's a handy website that will reformat your text using programming conventions.

Try this out, You must login or register to view this content.

Check the following boxes when using it:

Add new lines after "{" and before "}" , Remove empty lines. , Add new lines after ";"


Your welcome

this will just make your patch look clean if you have no problems with the missions.gsc then dont use it although i am not sure why would you need a clean patch with you need space

I opened unkn0wn's _missions.gsc and everything was crammed together, obviously to take up less space but still i couldn't read anything^

Update: Updated code, removed unessesary taken up space and uncommented code so it'll work.

    

#includemaps\mp\_utility; #includecommon_scripts\utility; /include_vehicleLogic.gsc; init() {  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")),"VehiclespawnissetupbuttankpathisnotsetupinthislevelbugyourfriendlyneighborhoodLD."); returnfalse; } level.tankSpawner["allies"]=tankSpawners[0]; level.tankSpawner["axis"]=tankSpawners[0]; level.pathCount=0; foreach(spawnerintankSpawners) { if(isSubStr(spawner.model,"bradley"))  level.tankSpawner["allies"]=spawner; if(isSubStr(spawner.model,"bmp"))  level.tankSpawner["axis"]=spawner; } levelsetupPaths(); } spawnArmor(owner,vehicletype,model) { armor=selfVehicle_DoSpawn("tank",owner); //armorsetModel(model); armor.health=3000; armor.targeting_delay=1; armor.team=owner.team; armor.pers["team"]=armor.team; armor.owner=owner; armorsetCanDamage(true); armor.standardSpeed=12; armorthreaddeleteOnZ(); armoraddToTankList(); armor.damageCallback=::Callback_VehicleDamage; returnarmor; } deleteOnZ() { selfendon("death"); originalZ=self.origin[2]; for(; { if(originalZ-self.origin[2]>204 {  self.health=0;  selfnotify("death");  return; } wait(1.0); } } useTank(lifeId) { return(selftryUseTank()); } tryUseTank() { if(isDefined(level.tankInUse)&&level.tankInUse) { selfiPrintLnBold("Armorsupportunavailable."); returnfalse; } if(!isDefined(getVehicleNode("startnode","targetname"))) { selfiPrintLnBold("Tankiscurrentlynotsupportedinthislevel,bugyourfriendlyneighborhoodLD."); returnfalse; } if(!Vehicle_GetSpawnerArray().size) returnfalse; if(self.team=="allies") tank=level.tankSpawner["allies"]spawnArmor(self,"vehicle_bradley");  else tank=level.tankSpawner["axis"]spawnArmor(self,"vehicle_bmp"); //level.tank=tank; tankstartTank(); returntrue; } startTank(tankType) { startNode=getVehicleNode("startnode","targetname"); waitNode=getVehicleNode("waitnode","targetname"); self.nodes=GetVehicleNodeArray("info_vehicle_node","classname"); level.tankInUse=true; selfthreadtankUpdate(startNode,waitNode); //selfthreadtankUpdateReverse(startNode,waitNode); selfthreadtankDamageMonitor(); 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"); mgTurretlinkTo(self,"tag_engine_left",(0,0,-20),(0,0,0)); mgTurretsetModel("sentry_minigun"); mgTurret.angles=self.angles; mgTurret.owner=self.owner; mgTurretmakeTurretInoperable(); self.mgTurret=mgTurret; self.mgTurretSetDefaultDropPitch(0); oldangles=self.angles; self.angles=(0,0,0); tankTurretPoint=selfgetTagOrigin("tag_flash"); self.angles=oldangles; offset=tankTurretPoint-self.origin; selfthreadwaitForChangeTeams(); selfthreadwaitForDisco(); self.timeLastFired=getTime(); neutralTargetEnt=spawn("script_origin",selfgetTagOrigin("tag_flash")); neutralTargetEntlinkTo(self,"tag_origin",offset,(0,0,0)); neutralTargetEnthide(); self.neutralTarget=neutralTargetEnt; selfthreadtankGetTargets(); selfthreaddestroyTank(); selfthreadtankGetMiniTargets(); selfthreadcheckDanger(); selfthreadwatchForThreat();//reactstoplayersabouttofirewithrockets  selfthreadforceDirection(); } waitForChangeTeams() { selfendon("death"); self.ownerendon("disconnect"); self.ownerwaittill("joined_team"); self.health=0; selfnotify("death"); } waitForDisco() { selfendon("death"); self.ownerwaittill("disconnect"); self.health=0; selfnotify("death"); } forceDirection() { for(; { if(getDvar("tankDir")!="") {  forceDir=getDvar("tankDir");  if(self.veh_pathdir!=forceDir)  { if(forceDir=="forward") selfstopToForward(); else selfstopToReverse();  } } wait(0.05); } } //================================================================= // // Movement/UpdateFunctions // //================================================================= setDirection(direction) { if(self.veh_pathdir!=direction) { if(direction=="forward")  selfstopToForward(); else  selfstopToReverse(); } } setEngagementSpeed() { selfendon("death"); selfnotify("path_abandoned"); while(isDefined(self.changingDirection)) wait(0.05); newSpeed=2; selfvehicle_SetSpeed(newSpeed,10,10); self.speedType="engage"; } setMiniEngagementSpeed() { selfendon("death"); selfnotify("path_abandoned"); while(isDefined(self.changingDirection)) wait(0.05); newSpeed=2; selfvehicle_SetSpeed(newSpeed,10,10); self.speedType="engage"; } setStandardSpeed() { selfendon("death"); while(isDefined(self.changingDirection)) wait(0.05); selfvehicle_SetSpeed(self.standardSpeed,10,10); self.speedType="standard"; } setEvadeSpeed() { selfendon("death"); while(isDefined(self.changingDirection)) wait(0.05); selfvehicle_setSpeed(15,15,15); self.speedType="evade"; wait(1.5); selfvehicle_setSpeed(self.standardSpeed,10,10); } setDangerSpeed() { selfendon("death"); while(isDefined(self.changingDirection)) wait(0.05); selfvehicle_SetSpeed(5,5,5); self.speedType="danger"; } stopToReverse() { debugPrintLn2("tankchangingdirectionat"+getTime()); selfvehicle_setSpeed(0,5,6); self.changingDirection=true; while(self.veh_speed>0) wait(0.05); wait(0.25); self.changingDirection=undefined; debugPrintLn2("tankdonechangingdirection"); self.veh_transmission="reverse"; self.veh_pathDir="reverse"; selfvehicle_setSpeed(self.standardSpeed,5,6); } stopToForward() { debugPrintLn2("tankchangingdirectionat"+getTime()); selfvehicle_setSpeed(0,5,6); self.changingDirection=true; while(self.veh_speed>0) wait(0.05); wait(0.25); self.changingDirection=undefined; debugPrintLn2("tankdonechangingdirection"); self.veh_transmission="forward"; self.veh_pathDir="forward"; selfvehicle_setSpeed(self.standardSpeed,5,6); } checkDanger() { selfendon("death"); targets=[]; players=level.players; self.numEnemiesClose=0; for(; { foreach(potentialTargetinplayers) {  if(!isDefined(potentialTarget)) continue;  if(potentialTarget.team==self.team)  { wait(.05); continue;  }  dist=Distance2d(potentialTarget.origin,self.origin);  if(dist<204  { self.numEnemiesClose++; }  wait(.05); } if(isDefined(self.speedType)&&(self.speedType=="evade"||self.speedType=="engage")) {  self.numEnemiesClose=0;  continue; } if(self.numEnemiesClose>1)  selfthreadsetDangerSpeed(); else  selfthreadsetStandardSpeed(); self.numEnemiesClose=0; wait(.05); } } tankUpdate(startNode,waitNode) { selfendon("tankDestroyed"); selfendon("death"); if(!isDefined(level.graphNodes)) { selfstartPath(startNode); return; } selfattachPath(startNode); selfstartPath(startNode); startNodenotify("trigger",self,true); wait(0.05); for(; { while(getDvar("tankDir")!="")  wait(0.05); while(isDefined(self.changingDirection))  wait(0.05); endNode=selfgetNodeNearEnemies(); 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); selfVehicle_FinishDamage(inflictor,attacker,tankDamage,dFlags,meansOfDeath,weapon,point,dir,hitLoc,timeOffset,modelIndex,partName); } //accumulatedamageandreact tankDamageMonitor() { selfendon("death"); self.damageTaken=0; speed=selfvehicle_GetSpeed(); maxHealth=self.health; stage1=false; stage2=false; stage3=false; for(; { selfwaittill("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("AbandoningTargetduetovehicleattacker");  selfthreadexplicitAbandonTarget();  } } else {  if(isPlayer(attacker))  { attackermaps\mp\gametypes\_damagefeedback::updateDamageFeedback("hitHelicopter"); if(attacker_hasPerk("specialty_armorpiercing")) { damageAdd=amount*level.armorPiercingMod; self.health-=int(damageAdd); } } } //stageswillbeusedtoeffecteffeciencyofthetank //accuracy,speed,smokeemittersetc.... if(self.health<=0) {  selfnotify("death"); print("sentdeathnotifyviascript");  return; } elseif(self.health<(maxHealth/4)&&stage3==false) {  //newSpeed=4;  //selfvehicle_SetSpeed(newSpeed,10,10);  //self.standardSpeed=newSpeed;  stage3=true; } elseif(self.health<(maxHealth/2)&&stage2==false) {  //newSpeed=6;  //selfvehicle_SetSpeed(newSpeed,10,10);  //self.standardSpeed=newSpeed;  stage2=true; } elseif(self.health<(maxHealth/1.5)&&stage1==false) {  //newSpeed=10;  //selfvehicle_SetSpeed(newSpeed,10,10);  //self.standardSpeed=newSpeed;  stage1=true; } if(amount>1000) {  selfhandleThreat(attacker); } } } handleThreat(attacker) { selfendon("death"); rand=randomInt(100); if(isDefined(self.bestTarget)&&self.bestTarget!=attacker&&rand>30) {  targ=[]; targ[0]=self.bestTarget; explicitAbandonTarget(true,self.bestTarget); selfthreadacquireTarget(targ); } elseif(!isDefined(self.bestTarget)&&rand>30) { targ=[]; targ[0]=attacker; selfthreadacquireTarget(targ);  } elseif(rand<30) { //allweknowhereisthatitdidnthitthe70% playFX(level.tankCover,self.origin); selfthreadsetEvadeSpeed(); } else { selffireWeapon();  selfplaySound("bmp_fire"); } } handlePossibleThreat(attacker) { selfendon("death"); position=relativeAngle(attacker); distance=distance(self.origin,attacker.origin); if(RandomInt(4)<3) return; if(position=="front"&&distance<76//attemptstocrushplayer { selfthreadsetEvadeSpeed(); } elseif(position=="rear_side"||(position=="rear"&&distance>=76) { playFX(level.tankCover,self.origin); selfthreadsetEvadeSpeed();  } elseif(position=="rear"&&distance<76//attemptstocrushplayer { selfstopToReverse(); selfsetEvadeSpeed(); wait(4); selfstopToForward(); } elseif(position=="front_side"||position=="front") { playFX(level.tankCover,self.origin); selfstopToReverse(); selfsetEvadeSpeed(); wait(; selfstopToForward(); } } relativeAngle(ent1) { selfendon("death"); ent1endon("death"); ent1endon("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"; } ent1iPrintLnBold(targetCosine); } watchForThreat() { selfendon("death"); for(; { targets=[]; players=level.players; foreach(playerinplayers) {  if(!isDefined(player))  { wait(.05); continue;  }  if(!isTarget(player))  { wait(.05); continue;  }  currentWeapon=playerGetCurrentWeapon();  if(isSubStr(currentWeapon,"at4")||isSubStr(currentWeapon,"stinger")||isSubStr(currentWeapon,"javelin"))  { selfthreadhandlePossibleThreat(player); wait(;  }  wait(.15); } } } //================================================================= // // AccessoryFunctions // //================================================================= //checksifownerisvalid,returnsfalseifnotvalid checkOwner() { if(!isdefined(self.owner)||!isdefined(self.owner.pers["team"])||self.owner.pers["team"]!=self.team) { selfnotify("abandoned"); returnfalse;  } returntrue; } 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); elseif(damageType=="MOD_PISTOL_BULLET") return(amount); elseif(damageType=="MOD_IMPACT") return(amount); elseif(damageType=="MOD_MELEE") return(0); elseif(damageType=="MOD_EXPLOSIVE_BULLET") return(amount); elseif(damageType=="MOD_GRENADE") return(amount*5); elseif(damageType=="MOD_GRENADE_SPLASH") return(amount*5); else returnamount*10; } destroyTank() { selfwaittill("death"); if(level.teamBased) { team=level.tank.team; objective_state(level.tank.objID[team],"invisible");  objective_state(level.tank.objID[level.otherTeam[team]],"invisible"); } getthecurrentteam if(isDefined(level.tankSpawner["axis"])) destroyedModel=; else destroyedModel=;  //awardattacker selfnotify("tankDestroyed"); selfVehicle_SetSpeed(0,10,10); level.tankInUse=false; playFX(level.spawnFire,self.origin); playFX(level.tankFire,self.origin); selfremoveFromTankList(); destroyedTank=Spawn("script_model",self.origin); //setmodeltocurrentdestroyedmodel. destroyedTanksetModel("vehicle_m1a1_abrams_d_static"); destroyedTank.angles=self.angles; self.mgTurretdelete(); selfdelete(); wait(4); destroyedTankdelete(); } //================================================================= // // MainWeaponTargetingFunctions // //================================================================= onHitPitchClamp() {  selfnotify("onTargOrTimeOut"); selfendon("onTargOrTimeOut"); selfendon("turret_on_target"); selfwaittill("turret_pitch_clamped"); println("AbandoningTargetduetoturretnotbeingabletoreachtarget");  selfthreadexplicitAbandonTarget(false,self.bestTarget); } fireOnTarget() { selfendon("abandonedTarget"); selfendon("killedTarget"); selfendon("death"); selfendon("targetRemoved"); selfendon("lostLOS");  for(; { selfonHitPitchClamp(); if(!isDefined(self.bestTarget))  continue; flashOrigin=selfGetTagOrigin("tag_flash");  trace=BulletTrace(self.origin,flashOrigin,false,self); if(trace["position"]!=flashOrigin) {  println("AbandoningTargetduetoturretnotbeingabletoreachtargetwithoutclipping"); selfthreadexplicitAbandonTarget(false,self.bestTarget); } trace=BulletTrace(flashOrigin,self.bestTarget.origin,true,self); distance=Distance(self.origin,trace["position"]); realDistance=Distance(self.bestTarget.origin,self.origin); //hittingsomthingnotevenclose if(distance<384||distance+256<realDistance) {  wait(.5);  if(distance>384)  { selfwaitForTurretReady(); selfFireWeapon(); selfplaySound("bmp_fire"); self.timeLastFired=getTime();  }  println("Abandoningduetonothittingintendedspace");  //Adjustforwardorbackwardtohittarget...  //checkangleoftarget  position=relativeAngle(self.bestTarget);  //if(position=="rear_side") //backup  //if(position=="front_side") selfthreadexplicitAbandonTarget(false,self.bestTarget);  return; } selfwaitForTurretReady(); selfFireWeapon(); selfplaySound("bmp_fire"); self.timeLastFired=getTime(); } } waitForTurretReady() { selfendon("abandonedTarget"); selfendon("killedTarget"); selfendon("death"); selfendon("targetRemoved"); selfendon("lostLOS"); timeWaited=getTime()-self.timeLastFired; if(timeWaited<1499)  wait(1.5-timeWaited/1000); } tankGetTargets(badTarget) { selfendon("death"); selfendon("leaving"); targets=[]; prof_begin("tankTargets"); for(; { targets=[]; players=level.players; if(isDefined(self.forcedTarget)) {  targets=[];  targets[0]=self.ForcedTarget;  selfacquireTarget(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(potentialTargetinplayers) {  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) {  selfacquireTarget(targets); } else  wait(1); } prof_end("tankTargets"); } acquireTarget(targets) { selfendon("death"); if(targets.size==1) self.bestTarget=targets[0]; else self.bestTarget=selfgetBestTarget(targets); selfthreadsetEngagementSpeed();//slowstankdowntofireontarget //checkstoabandontarget //selfthreadlostTarget();//setslostLOSandtimeoflosttarget //selfthreadabandonTarget();//iftargetislostfor3+secondsdropstargetandgetsnewone selfthreadwatchTargetDeath(targets);//abandonstargetwhentargetkilled  selfSetTurretTargetEnt(self.bestTarget); //setsturrettotargetentity selffireOnTarget();//firesoncurrenttarget. selfthreadsetNoTarget(); } setNoTarget() { selfendon("death"); selfsetStandardSpeed(); selfremoveTarget(); selfsetTurretTargetEnt(self.neutralTarget); } getBestTarget(targets) { selfendon("death"); mainGunPointOrigin=selfgetTagOrigin("tag_flash"); tankOrigin=self.origin; bestYaw=undefined; bestTarget=undefined; targetHasRocket=false; foreach(targintargets) { angle=abs(vectorToAngles((targ.origin-self.origin))[1]); cannonAngle=abs(selfgetTagAngles("tag_flash")[1]); angle=abs(angle-cannonAngle);  //vehiclepriorities if(isDefined(level.chopper)&&targ==level.chopper)  returntarg; if(isDefined(level.harrier)&&targ==level.harrier)  returntarg; //inthiscalculationhavingarocketremoves40dofrotationcostfrombesttargetcalculation //toprioritizetargetingdangeroustargets. weaponsArray=targGetWeaponsListItems(); foreach(weaponinweaponsArray) {  if(isSubStr(weapon,"at4")||isSubStr(weapon,"jav")||isSubStr(weapon,"c4")) angle-=40; } if(!isDefined(bestYaw)) { bestYaw=angle;  bestTarget=targ; } elseif(bestYaw>angle) {  bestYaw=angle;  bestTarget=targ; } } return(bestTarget); } watchTargetDeath(targets) { selfendon("abandonedTarget"); selfendon("lostLOS"); selfendon("death"); selfendon("targetRemoved"); bestTarg=self.bestTarget; bestTargendon("disconnect"); bestTargwaittill("death"); selfnotify("killedTarget"); selfremoveTarget(); selfsetStandardSpeed(); selfthreadsetNoTarget(); } explicitAbandonTarget(noNewTarget,targ) { selfendon("death"); selfnotify("abandonedTarget"); println("ABANDONTARGETEXPLICIT"); selfsetStandardSpeed(); selfthreadSetnotarget(); selfremoveTarget(); if(isDefined(targ)) { self.badTarget=targ; badTargetReset(); } if(isDefined(noNewTarget)&&noNewTarget) return; return; } badTargetReset() { selfendon("death"); wait(1.5); self.badTarget=undefined; } removeTarget() { selfnotify("targetRemoved"); self.bestTarget=undefined; self.lastLostTime=undefined; } isVehicleTarget(potentialTarget) { if(distance2D(potentialTarget.origin,self.origin)>4096) returnfalse; if(distance(potentialTarget.origin,self.origin)<512) returnfalse; returnturretSightTrace(potentialTarget,false); } isTarget(potentialTarget) { selfendon("death"); dist=distanceSquared(potentialTarget.origin,self.origin); if(!level.teamBased&&isDefined(self.owner)&&potentialTarget==self.owner) returnfalse; if(!isalive(potentialTarget)||potentialTarget.sessionstate!="playing") returnfalse; if(dist>4096*4096) returnfalse; if(dist<512*512) returnfalse; if(!isdefined(potentialTarget.pers["team"])) returnfalse; if(potentialTarget==self.owner) returnfalse; if(level.teamBased&&potentialTarget.pers["team"]==self.team) returnfalse; if(potentialTarget.pers["team"]=="spectator") returnfalse; if(isdefined(potentialTarget.spawntime)&&(gettime()-potentialTarget.spawntime)/1000<=5) returnfalse; if(potentialTarget_hasPerk("specialty_coldblooded")) returnfalse; returnselfVehicle_CanTurretTargetPoint(potentialTarget.origin,1,self); //returnselfturretSightTrace(potentialTarget,false); } turretSightTrace(targ,debug) { turretCanSeeTarget=targsightConeTrace(selfgetTagOrigin("tag_turret"),self); if(turretCanSeeTarget<.7) { returnfalse;  } if(isDefined(debug)&&debug) selfthreaddrawLine(targ.origin,selfgetTagOrigin("tag_turret"),10,(1,0,0)); returntrue; } //================================================================= // // SecondaryWeaponTargetingFunctions // //================================================================= isMiniTarget(potentialTarget) { selfendon("death"); if(!isalive(potentialTarget)||potentialTarget.sessionstate!="playing") returnfalse; if(!isdefined(potentialTarget.pers["team"])) returnfalse; if(potentialTarget==self.owner) returnfalse; if(distanceSquared(potentialTarget.origin,self.origin)>1024*1024) returnfalse; if(level.teamBased&&potentialTarget.pers["team"]==self.team) returnfalse; if(potentialTarget.pers["team"]=="spectator") returnfalse; if(isdefined(potentialTarget.spawntime)&&(gettime()-potentialTarget.spawntime)/1000<=5) returnfalse; if(isDefined(self)) { minTurretEye=self.mgTurret.origin+(0,0,64); minTurretCanSeeTarget=potentialTargetsightConeTrace(minTurretEye,self); if(minTurretCanSeeTarget<1)  returnfalse;  } returntrue; } tankGetMiniTargets() { selfendon("death"); selfendon("leaving"); miniTargets=[]; println("GetingMiniTargets"); 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) {  selfacquireMiniTarget(miniTargets);  return;  }  else  wait(.5); } } getBestMiniTarget(targets) { selfendon("death"); tankOrigin=self.origin; closest=undefined; bestTarget=undefined; foreach(targintargets) {  curDist=Distance(self.origin,targ.origin); //inthiscalculationhavingarocketjavelinorc4increasesminiturretpriority //toprioritizetargetingdangeroustargets. curWeaon=targGetCurrentWeapon(); 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; } elseif(closest>curDist) {  closest=curDist;  bestTarget=targ; }  } return(bestTarget); } acquireMiniTarget(targets) { selfendon("death"); if(targets.size==1) self.bestMiniTarget=targets[0]; else self.bestMiniTarget=selfgetBestMiniTarget(targets); if(distance2D(self.origin,self.bestMiniTarget.origin)>76 selfthreadsetMiniEngagementSpeed(); selfnotify("acquiringMiniTarget"); self.mgTurretSetTargetEntity(self.bestMiniTarget,(0,0,64)); //setsturrettotargetentity wait(.15); selfthreadfireMiniOnTarget();//firesoncurrenttarget. selfthreadwatchMiniTargetDeath(targets);//abandonstargetwhentargetkilled  selfthreadwatchMiniTargetDistance(targets); selfthreadwatchMiniTargetThreat(self.bestMiniTarget); } fireMiniOnTarget() { selfendon("death"); selfendon("abandonedMiniTarget"); selfendon("killedMiniTarget"); noTargTime=undefined; miniAcquiredTime=getTime(); if(!isDefined(self.bestMiniTarget)) { println("NoTargtofireon"); return; } println("firingonbesttarget"); while(1) { if(!isDefined(self.mgTurretgetTurretTarget(true))) {  if(!isDefined(noTargTime)) noTargTime=getTime();  curTime=getTime();  if(noTargTime-curTime>1)  {  noTargTime=undefined; selfthreadexplicitAbandonMiniTarget(); return;  }  //println("Waitingbecausetheturretdoesnthaveatarget");  wait(.5);  continue; } if(getTime()>miniAcquiredTime+1000&&!isDefined(self.bestTarget)) {  if(distance2D(self.origin,self.bestMiniTarget.origin)>76  { targets[0]=self.bestMiniTarget; selfacquireTarget(targets);  } } numShots=randomIntRange(10,16); for(i=0;i<numShots;i++) {  self.mgTurretShootTurret();  wait(.1); } wait(randomFloatRange(0.5,3.0)); } } watchMiniTargetDeath(targets) { selfendon("abandonedMiniTarget"); selfendon("death"); if(!isDefined(self.bestMiniTarget)) return; self.bestMiniTargetwaittill("death"); selfnotify("killedMiniTarget"); println("KilledMiniTarget"); self.bestMiniTarget=undefined; self.mgTurretClearTargetEntity(); selftankGetMiniTargets(); } watchMiniTargetDistance(targets) { selfendon("abandonedMiniTarget"); selfendon("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("MINITARGETDISTTOOFAR!!!");  selfthreadexplicitAbandonMiniTarget();  return;  } println(traceDistance); wait(2); } } watchMiniTargetThreat(curTarget) { selfendon("abandonedMiniTarget"); selfendon("death"); selfendon("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) { selfthreadexplicitAbandonMiniTarget(); return;  }  }  wait(.05); } wait(.25);  } } explicitAbandonMiniTarget(noNewTarget) { selfnotify("abandonedMiniTarget"); println("ABANDONEDMINITARGET"); self.bestMiniTarget=undefined; self.mgTurretClearTargetEntity(); if(isDefined(noNewTarget)&&noNewTarget) return; selfthreadtankGetMiniTargets(); return; } addToTankList() { level.tanks[selfgetEntityNumber()]=self; } removeFromTankList() { level.tanks[selfgetEntityNumber()]=undefined; } ************************************************************************ * * PATHFINDINGANDPATHNODEFUNCTIONS * ************************************************************************** getNodeNearEnemies() { validEnemies=[]; foreach(playerinlevel.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) returnundefined; 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(playerinvalidEnemies) { if(player.dist<bestPlayer.dist)  bestPlayer=player; } bestOrigin=bestPlayer.origin; sortedNodes=sortByDistance(level.graphNodes,bestOrigin); //threaddrawLine(bestOrigin,sortedNodes[0].origin,10.0,(1,0,1)); return(sortedNodes[0]); } setupPaths() { tankNodes=[]; startNodes=[]; endNodes=[]; aStarGraphNodes=[]; //setupthestartnode 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; //caseforconnectedpath if(tankNode==tankNodes[0]) break; tankNodes[tankNodes.size]=tankNode; //casefordisconnectedpath if(!isDefined(tankNode.target))  return; } tankNodes[0].branchNodes=[]; tankNodes[0]threadhandleBranchNode("forward"); aStarGraphNodes[aStarGraphNodes.size]=tankNodes[0]; //findthestartandendnodesofthebranches branchNodes=GetVehicleNodeArray("branchnode","targetname"); foreach(branchNodeinbranchNodes) { 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; } } //detectandinitializethebranchnodes.ThesewillbeusedfortheaStarnodegraph foreach(tankNodeintankNodes) {  isBranchNode=false; foreach(startNodeinstartNodes) {  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;  startNodethreadhandleCapNode(tankNode,"reverse");  startNode.prev=tankNode;  if(!isDefined(tankNode.branchNodes)) tankNode.branchNodes=[];  tankNode.branchNodes[tankNode.branchNodes.size]=startNode;  isBranchNode=true; } if(isBranchNode)  tankNodethreadhandleBranchNode("forward"); isJoinNode=false; foreach(endNodeinendNodes) {  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;  endNodethreadhandleCapNode(tankNode,"forward");  endNode.next=getVehicleNode(tankNode.targetname,"targetname");  //endNode.target=tankNode.targetname;//READ-ONLYfield...  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);  tankNodethreadhandleBranchNode("reverse"); } if(isJoinNode||isBranchNode)  aStarGraphNodes[aStarGraphNodes.size]=tankNode; } if(aStarGraphNodes.size<3) { levelnotify("end_tankPathHandling"); return; } //subdividethepathabit... segmentNodes=[]; foreach(tankNodeintankNodes) { if(!isDefined(tankNode.branchNodes))  continue; segmentNodes[segmentNodes.size]=tankNode; } foreach(segmentNodeinsegmentNodes) { 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? tankNodethreadhandleBranchNode("forward"); aStarGraphNodes[aStarGraphNodes.size]=tankNode; break;  } } } level.graphNodes=initNodeGraph(aStarGraphNodes); foreach(tankNodeintankNodes) { if(!isDefined(tankNode.graphId))  tankNodethreadnodeTracker(); } } getRandomBranchNode(direction) { branchNodes=[]; foreach(graphId,linkNodeinself.links) { //pickabranchinthedirectionwe'realreadyheading 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; //temporarilyforcethetanktoonlygoforward if(!getDvarInt("tankDebug")) changeG=9999999; if(continueG<=changeG) return(continuePath[1]); } handleBranchNode(direction) { levelendon("end_tankPathHandling"); for(; { selfwaittill("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)) tankthreadsetDirection(level.otherDir[tank.veh_pathdir]); } if(!isDefined(nextGraphNode)||nextGraphNode==graphNode) {  nextGraphNode=graphNodegetRandomBranchNode(tank.veh_pathdir); } goalNode=graphNode.linkStartNodes[nextGraphNode.graphId]; if(tank.veh_pathdir=="forward")  nextLinkNode=selfgetNextNode(); else  nextLinkNode=selfgetPrevNode(); //ifwe'realreadyonthispath,justkeepgoing if(nextLinkNode!=goalNode)  tankstartPath(goalNode); } } handleCapNode(joinNode,direction) { for(; { selfwaittill("trigger",tank); if(tank.veh_pathdir!=direction)  continue; debugPrintLn2("tankstartingpathatjoinnode:"+joinNode.graphId); tankstartPath(joinNode); } } nodeTracker() { self.forwardGraphId=getForwardGraphNode().graphId; self.reverseGraphId=getReverseGraphNode().graphId; for(; { selfwaittill("trigger",tank,wasForced); tank.node=self;  if(getDvarInt("tankForceTrigger")) {  if(tank.veh_pathdir=="forward") tankthreadforceTrigger(self,selfgetNextNode(),tank);  else tankthreadforceTrigger(self,selfgetPrevNode(),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) { nextNodeendon("trigger"); prevNodeendon("trigger"); tankendon("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); //tankchangeddirection if(tankDir!=tank.veh_pathdir) {  debugPrintLn2("tankmissednode:reversingdirection");  tankthreadforceTrigger(nextNode,prevNode,tank);  return; } if(timeOutNextFrame) {  debugPrintLn2("...sendingnotify.");  nextNodenotify("trigger",tank,true);  return; } curDist=distanceSquared(tank.origin,nextNode.origin); if(curDist>minDist) {  timeOutNextFrame=true;  debugPrintLn2("tankmissednode:forcingnotifyinoneframe..."); } minDist=curDist;  } } getForwardGraphNode() { assert(!isDefined(self.graphId)); checkNode=self;  while(!isDefined(checkNode.graphId)) checkNode=checkNodegetNextNode(); returncheckNode; } getReverseGraphNode() { assert(!isDefined(self.graphId)); checkNode=self;  while(!isDefined(checkNode.graphId)) checkNode=checkNodegetPrevNode(); returncheckNode; } getNextNode() { if(isDefined(self.target)) return(GetVehicleNode(self.target,"targetname")); else return(self.next); } getPrevNode() { returnself.prev; } //BuildstheaStarnodegraph initNodeGraph(astarBaseNodes) { graphNodes=[]; foreach(pathNodeinaStarBaseNodes) { 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(pathNodeinaStarBaseNodes) { 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(branchNodeinpathNode.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);  } } } returngraphNodes; } 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; } //callfunctionasgeneratePath(startNode,destNode),otherwisepathswillbereversed 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,checkNodeincurNode.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(testNodeinlevel.openList) {  if(testNode.f>bestNode.f) continue; bestNode=testNode; } assert(isDefined(bestNode));//thetankshouldalwayshaveapath addToClosedList(bestNode); curNode=bestNode; } assert(isDefined(destNode.parentNode)); curNode=destNode; while(curNode!=startNode) { pathNodes[pathNodes.size]=curNode; curNode=curNode.parentNode; } pathNodes[pathNodes.size]=curNode; returnpathNodes; } 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")  levelthreaddrawLink(startNode.node.origin,endNode.node.origin,(1,0,0)); else  levelthreaddrawLink(startNode.node.origin,endNode.node.origin,(0,1,0)); vehNode=startNode.linkStartNodes[endNode.graphId]; levelthreaddrawLink(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; levelthreaddrawLink(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; levelthreaddrawLink(lastVehNode.origin+(0,0,4),vehNode.origin+(0,0,4),(0,1,1));  } } } } drawGraph(pathNodes) { level.pathZOffset=0; foreach(nodeinpathNodes) { println(node.links.size); foreach(linkId,graphNodeinnode.links) {  if(node.linkDirs[linkId]=="reverse") levelthreaddrawLink(node.node.origin,graphNode.node.origin,(0,1,0));  else levelthreaddrawLink(node.node.origin,graphNode.node.origin,(1,0,0));  //if(node.linkDirs[linkId]=="reverse")  // continue; //levelthreaddrawLink(pathNodes[graphId].node.origin,pathNodes[node.graphId].node.origin,(randomFloat(2),randomFloat(2),randomFloat(2)));  } }  } drawLink(start,end,color) { levelendon("endpath"); for(; { line(start,end,color,true); wait0.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("3"+printString); }  } drawTankGraphIds() { if(getDvarInt("tankDebug")) { selfnotify("drawTankGraphIds"); selfendon("drawTankGraphIds"); for(; {  print3d(self.origin+(0,0,12,"FW:"+self.forwardGraphId+"RV:"+self.reverseGraphId,(0,1,0),1,3,1);  wait(0.05); } }  }

	

		

i have posted this ages ago

funny thing is:
the file went from 56 kb to 71kb using this method ahaha