home *** CD-ROM | disk | FTP | other *** search
/ The Games Machine 76 / XENIATGM66.iso / Messiah / data1.cab / Program_Executable_Files / messiahscripts / Enemies / droids.hxx < prev    next >
Encoding:
Text File  |  1999-11-29  |  55.0 KB  |  2,486 lines
  1.  
  2.  
  3. /*
  4. Actors:
  5. MDroid1
  6. MDroid2
  7. ForkLift
  8. AutoCannon
  9. */
  10.  
  11.  
  12.  
  13.  
  14. /////////////////////////////
  15. /////////////////////////////
  16. /////////////////////////////
  17. /////////////////////////////
  18. /////////////////////////////
  19. /////////////////////////////
  20.  
  21. SubRoutine(MoveDroidRoutine)
  22. {
  23.  
  24.         if(vtrigger==_DIRforward)
  25.         {
  26.             move(0,0,-7);
  27.         }
  28.         if(vtrigger==_DIRbackward)
  29.         {
  30.             move(0,0,5);
  31.         }
  32.         if(vtrigger==_DIRleft)
  33.         {
  34.             turn(0,-20,0);
  35.         }
  36.         if(vtrigger==_DIRright)
  37.         {
  38.             turn(0,20,0);
  39.         }
  40.  
  41. }
  42.  
  43.  
  44.  
  45. Actor(PossesionBot)
  46. {
  47.         file(PossesionBotHeader);
  48.         rank(_RankGeneral);
  49.  
  50.         startstate(statenormal);
  51.         startaction(nomove);
  52.  
  53.         float(_declare,Counter,0);
  54.  
  55.         call(AIcheckforplayerone,500);
  56.         if(VTrigger==_DIRTempFlag && Counter>0)
  57.         {
  58.             print("PlayerOneFound    ");
  59.             call(AIchangefriendtoenemy);
  60.             call(AIalert,Sub_AISetAttack);
  61.             sample(SFXViolation,-1);
  62.             float(_set,Counter,-150);
  63.         }
  64.         else
  65.         {
  66.             print("Nothing found     ");
  67.             float(_add,Counter,1);
  68.             if(counter<0)
  69.             {
  70.                 Turn(0,140,0);
  71.             }
  72.             else
  73.             {
  74.                 call(AIPickdest,10);
  75.                 if(vtrigger==_DIRtempflag)
  76.                 {
  77.                     call(PickNewNode);
  78.                 }
  79.  
  80.                 CallSub(Sub_AI1WayAlignToPickDestAngle);
  81.                 if(VTrigger==_DIRleft)
  82.                 {
  83.                     Turn(0,-40,0);
  84.                 }
  85.                 elseif(VTrigger==_DIRright)
  86.                 {
  87.                     Turn(0,40,0);
  88.                 }
  89.                 if(VPickDestAngleCorr<700 && VPickDestAngleCorr>-700)
  90.                 {
  91.                     move(0,0,-3);
  92.                 }
  93.                 if(VPickDestOffsetY>10)
  94.                 {
  95.                     move(0,-2,0);
  96.                 }
  97.                 elseif(VPickDestOffsetY<-10)
  98.                 {
  99.                     move(0,2,0);
  100.                 }
  101.  
  102.             }
  103.         }
  104.  
  105.         CallSub(BackGroundTriggerChecks);
  106.  
  107.         if(vhealth<0)
  108.         {
  109.             killactor();
  110.         }
  111. }
  112.  
  113.  
  114. SubRoutine(Sub_DroidCheckForAttach,float(Attached),float(PreferedDistToGroundLow),float(PreferedDistToGroundHigh))
  115. {
  116.         call(SearchForCloseActor,_AIclassmale|_AIclassfemale,200);
  117.         if(VTrigger==_DIRTempFlag)
  118.         {
  119.             print("Found close actor");
  120.             call(SetLockedOnActorToParent);
  121.             Call(CopyParentFlags);
  122.             float(_set,Attached,1);
  123.             float(_set,PreferedDistToGroundLow,140);
  124.             float(_set,PreferedDistToGroundHigh,220);
  125.         }
  126. }
  127.  
  128. SubRoutine(Sub_CorrectDroidPosition,float(Angle),float(AngleAdd),float(PreferedDistToGroundLow),float(PreferedDistToGroundHigh))
  129. {
  130.         if(VTrigger==_DIRTempFlag)
  131.         {
  132.             if(Angle>0)
  133.             {
  134.                 float(_set,AngleAdd,-5);
  135.             }
  136.             else
  137.             {
  138.                 float(_set,AngleAdd,5);
  139.             }
  140.         }
  141.  
  142.         float(_add,Angle,AngleAdd);
  143.         if(Angle<-90)
  144.         {
  145.             float(_set,Angle,-90);
  146.         }
  147.         elseif(Angle>90)
  148.         {
  149.             float(_set,Angle,90);
  150.         }
  151.  
  152.         if(VDistToGround<PreferedDistToGroundLow)
  153.         {
  154.             print(Move Up");
  155.             move(0,4,0);
  156.         }
  157.         elseif(VDistToGround>PreferedDistToGroundHigh)
  158.         {
  159.             print(Move Down");
  160.             move(0,-4,0);
  161.         }
  162. }
  163.  
  164. SubRoutine(DetachDroidFromParent,float(PreferedDistToGroundLow),float(PreferedDistToGroundHigh),float(Attached))
  165. {
  166.         float(_set,PreferedDistToGroundLow,30);
  167.         float(_set,PreferedDistToGroundHigh,35);
  168.  
  169.         call(ClrParentPtr);
  170.         float(_set,Attached,0);
  171.         Direction(_clr,_DIRshoot|_DIRhavegun);
  172. }
  173.  
  174.  
  175. #define    _DroidStateIdle            1
  176. #define    _DroidStateAttack        2
  177. #define    _DroidStateDefend        4
  178. #define    _DroidStateKamikaze        8
  179.  
  180. Actor(ShellTurret)
  181. {
  182.     file(ShellTurretHeader);
  183.     rank(_RankGeneral);
  184.  
  185.     startstate(statenormal);
  186.     startaction(ShellTurretNoMove);
  187.  
  188.     vector(_declare,VL_LockedOnPos,0,0,0);
  189.     vector(_declare,VL_LockedOnOffset,0,0,0);
  190.     float(_declare,FL_AutoCannonOffset,0);
  191.     float(_declare,anglex,-512);
  192.     float(_declare,angley,2048);
  193.     float(_declare,anglez,0);
  194.  
  195.     float(_declare,ShootDelay,0);
  196.     float(_declare,SideShoot,0);
  197.  
  198.     call(AIupdateAIvars);
  199.  
  200.     call(CheckForVisual,_CLASSModel,1000);
  201.     call(AIcheckfortarget,10);
  202.  
  203.     if(VActiveTime==1)
  204.     {
  205.         ActorFlag(_or,_AFLAGnomove);
  206.     }
  207.  
  208.     if(VAItargetfound!=0)
  209.     {
  210.         printilog("Turret found target !");
  211.         call(AIselecttarget,_AIenemy);
  212.         call(AIPickdest,10);
  213.  
  214.         vector(_settotargetpos,VL_LockedOnPos);
  215.         vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  216.         vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  217.         vector(_settargetpos,VL_LockedOnPos);
  218.  
  219.         CallSub(BackGroundTriggerChecks);
  220.  
  221.         if(VTargetAngle<-51)
  222.         {
  223.             float(_add,angley,-50);
  224.             float(_sub,FL_AutoCannonOffset,1);
  225.         }
  226.         elseif(VTargetAngle>51)
  227.         {
  228.             float(_add,angley,50);
  229.             float(_sub,FL_AutoCannonOffset,1);
  230.         }
  231.         else
  232.         {
  233.             if(FL_AutoCannonOffset<-100)
  234.             {
  235.                 float(_set,FL_AutoCannonOffset,-100);
  236.             }
  237.             //fine tuning angle
  238.             if(VTargetAngle<-11)
  239.             {
  240.                 float(_add,angley,-10);
  241.             }
  242.             elseif(VTargetAngle>11)
  243.             {
  244.                 float(_add,angley,10);
  245.             }
  246.  
  247.             if(VTargetAngleY<-11)
  248.             {
  249.                 float(_add,anglex,10);
  250.             }
  251.             elseif(VTargetAngleY>11)
  252.             {
  253.                 float(_add,anglex,-10);
  254.             }
  255.  
  256.             else
  257.             {
  258.                 print("turret ready to shoot !",0);
  259.                 if(FL_AutoCannonOffset<0)
  260.                 {
  261.                     float(_add,FL_AutoCannonOffset,1);
  262.                 }
  263.                 if(SideShoot==0)
  264.                 {
  265.                     vector(_set,tmpvector,0,0,-200);
  266.                     vector(_set,Gactorpos,20,-50,-98); //left cannon
  267.                     spawnactorbone(BulletShellTurret,tmpvector,Gactorpos,Gactorine,0);
  268.  
  269.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbulhorizac);
  270.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbulvertac);
  271.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbuldiag1ac);
  272.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbuldiag2ac);
  273.  
  274.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashhorizac);
  275.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashvertac);
  276.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag1ac);
  277.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag2ac);
  278.                                                    
  279.                     vector(_set,tmpvector,255,192,192);
  280.                     spawnlight(fire_light,0,Gactorpos,tmpvector,EmptyVector,300);
  281.                     vector(_set,Gactorpos,20,-50,-98);
  282.                     spawnparticle(fx_flare,0,Gactorpos,emptyvector,fx_mturret);
  283.  
  284.                     float(_set,SideShoot,1)
  285.                 }
  286.                 elseif(SideShoot==1)
  287.                 {
  288.                     vector(_set,tmpvector,0,0,-200);
  289.                     vector(_set,Gactorpos,-25,-50,-98); //right cannon
  290.                     spawnactorbone(BulletShellTurret,tmpvector,Gactorpos,Gactorine,0);
  291.  
  292.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbulhorizac);
  293.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbulvertac);
  294.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbuldiag1ac);
  295.                     spawnparticle(fx_gunbulletturretac,0,Gactorpos,tmpvector,fx_gunbuldiag2ac);
  296.  
  297.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashhorizac);
  298.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashvertac);
  299.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag1ac);
  300.                     spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag2ac);
  301.                                                    
  302.                     vector(_set,tmpvector,255,192,192);
  303.                     spawnlight(fire_light,0,Gactorpos,tmpvector,EmptyVector,300);
  304.                     vector(_set,Gactorpos,20,-50,-98);
  305.                     spawnparticle(fx_flare,0,Gactorpos,emptyvector,fx_mturret);
  306.  
  307.                     float(_set,SideShoot,0)
  308.                 }
  309.             }
  310.         }
  311.     }
  312.     else
  313.     {
  314.         float(_set,FL_AutoCannonOffset,-100);
  315.         if(VAInotargettime>160)
  316.         {
  317.             if(angley<-6)
  318.             {
  319.                 float(_add,angley,5);
  320.             }
  321.             else
  322.             {
  323.                 float(_add,angley,-5);
  324.             }
  325.             else
  326.             {
  327.                 float(_set,angley,0);
  328.             }
  329.             if(anglex<-6)
  330.             {
  331.                 float(_add,anglex,5);
  332.             }
  333.             else
  334.             {
  335.                 float(_add,anglex,-5);
  336.             }
  337.             else
  338.             {
  339.                 float(_set,anglex,0);
  340.             }
  341.         }
  342.     }
  343.  
  344.     if(angley>2048)
  345.     {
  346.         float(_set,angley,2048);
  347.     }
  348.     elseif(angley<0)
  349.     {
  350.         float(_set,angley,0);
  351.     }
  352.     if(anglex>512)
  353.     {
  354.         float(_set,anglex,512);
  355.     }
  356.     elseif(anglex<-512)
  357.     {
  358.         float(_set,anglex,-512);
  359.     }
  360.  
  361.     if(anglex!=0 || angley!=0 || anglez!=0)
  362.     {
  363.         call(CalcTransMat,anglex,angley,anglez);
  364.     }
  365. }
  366.  
  367.  
  368. Actor(CompanionBot)
  369. {
  370.         file(CompanionBotHeader);
  371.         rank(_RankGeneral);
  372.  
  373.         startstate(statenormal);
  374.         startaction(nomove);
  375.  
  376.         float(_declare,Attached,0);
  377.         float(_declare,Angle,90);
  378.         float(_declare,AngleAdd,5);
  379.         float(_declare,PreferedDistToGroundLow,30);
  380.         float(_declare,PreferedDistToGroundHigh,35);
  381.         float(_declare,CurrentDirection,0);
  382.  
  383.         float(_declare,CBotsmokeflag,-1);
  384.         float(_declare,CBotsampflag,0);
  385.  
  386.         if(Attached==0)
  387.         {
  388.             //reset FX vars if it becomes de-attached
  389.             float(_set,CBotsmokeflag,-1);
  390.             if(CBotsampflag==1)
  391.             {
  392.                 samplestop(SFXMachineGunFire);
  393.             }
  394.             float(_set,CBotsampflag,0);
  395.  
  396.             CallSub(Sub_DroidCheckForAttach,Attached,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  397.         }
  398.         else
  399.         {
  400.             call(CopyParentFlags);
  401.  
  402.             call(AIcalcdroidposition,80,angle,true,true);
  403.             CallSub(Sub_CorrectDroidPosition,Angle,AngleAdd,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  404.  
  405.             if(VTrigger!=_DIRHaveGun && VTrigger==_DIRCombatMode)
  406.             {
  407.                 vector(_set,WeaponPos,0,0,-20);
  408.                 call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  409.             }
  410.  
  411.             if(VActorFlag==_AFLAGlogon)
  412.             {
  413.                 print("Correcting angle in lock mode");
  414.                 if(VTargetAngle>11)
  415.                 {
  416.                     Turn(0,10,0);
  417.                 }
  418.                 elseif(VTargetAngle<-11)
  419.                 {
  420.                     Turn(0,-10,0);
  421.                 }
  422.             }
  423.         }
  424.  
  425.         if(VTrigger==_DIRshoot)
  426.         {
  427.             //start SFX loop
  428.             if(CBotsampflag==0)
  429.             {
  430.                 sample(SFXMachineGunFire,-1)
  431.             }
  432.             float(_set,CBotsampflag,1);
  433.  
  434.             //if parentptr fired, so do I
  435.             SpawnActor(BulletDroid,0,0,-20);
  436.             if(VTrigger==_DIRBulletFired)
  437.             {
  438.                 move(0,15,30);    //recoil
  439.  
  440.                 //muzzle flash
  441.                 vector(_set,Gactorpos,0,0,-30);
  442.                 spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashhorizsmall);
  443.                 spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashvertsmall);
  444.                 spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag1small);
  445.                 spawnparticle(fx_gunflashturretac,0,Gactorpos,emptyvector,fx_gunflashdiag2small);
  446.                                                
  447.                 vector(_set,tmpvector,255,192,192);
  448.                 spawnlight(fire_light,0,Gactorpos,tmpvector,EmptyVector,300);
  449.                 vector(_set,Gactorpos,0,0,-10);
  450.                 spawnparticle(fx_gunstrobeturret,0,Gactorpos,emptyvector,fx_gunstrobesmall);
  451.                 //muzzle flash
  452.  
  453.                 //reload smoke delayer
  454.                 float(_set,CBotsmokeflag,25);
  455.             }
  456.         }
  457.         else
  458.         {
  459.             //do some smoke
  460.             if(CBotsmokeflag>=0)
  461.             {
  462.                 if(VSniperMode==0)
  463.                 {
  464.                     float(_rnd2,tmpfloat,2);
  465.                     float(_sub,tmpfloat,1);
  466.                     vector(_set,gactorine,0,0,0);
  467.                     vector(_setx,gactorine,tmpfloat);
  468.  
  469.                     if(vrnd<50)
  470.                     {
  471.                         vector(_set,Gactorpos,0,0,-10);
  472.                         spawnparticle(fx_weaponsmoke,0,gactorpos,gactorine,fx_machinegunsmoke);
  473.                     }
  474.                 }
  475.                 float(_sub,CBotsmokeflag,1);
  476.             }
  477.  
  478.             //stop fire, so stop sample loop
  479.             if(CBotsampflag==1)
  480.             {
  481.                 samplestop(SFXMachineGunFire);
  482.             }
  483.             float(_set,CBotsampflag,0);
  484.         }
  485.  
  486.         call(AIupdatemovementvariables);
  487.  
  488. /*        printi("PathDestDist:     ",VPathDestDistance);
  489.         printi("PathDestAngle:    ",VPathDestAngle);
  490.         printi("PickDestAngle:    ",VPickDestAngle);
  491.         printi("TargetDistance:   ",VTargetDistance);
  492.         printi("TargetAngle:      ",VTargetAngle);
  493.         printi("DistToGround:     ",VDistToGround);
  494.         print("PrefDistLow:      ",PreferedDistToGroundLow);
  495.         print("PrefDistHigh:     ",PreferedDistToGroundHigh);
  496.         printi("Health:           ",VHealth);
  497. */
  498.         if(vhealth<100)
  499.         {
  500.             //go into kamikaze mode
  501.             if(vhealth<0)
  502.             {
  503.                 vector(_settoactorpos,tmpvector);
  504.                 CallSub(sub_fxexplosion);
  505.                 killactor();
  506.             }
  507.         }
  508.  
  509.         if(VTrigger!=_DIRalive && VHealth>0)
  510.         {
  511.             //parent died so detach
  512.  
  513.             float(_set,PreferedDistToGroundLow,30);
  514.             float(_set,PreferedDistToGroundHigh,35);
  515.  
  516.             call(ClrParentPtr);
  517.             float(_set,Attached,0);
  518.             Direction(_clr,_DIRshoot|_DIRhavegun);
  519.             Direction(_set,_DIRalive);
  520.         }
  521.  
  522.         CallSub(BackGroundTriggerChecks);
  523.  
  524. }
  525.  
  526. //**********************************************************************************************************
  527. //**********************************************************************************************************
  528. //****************        Defensive Bot                                                     *******************
  529. //**********************************************************************************************************
  530. //**********************************************************************************************************
  531.  
  532. Actor(DefensiveBot)
  533. {
  534.         file(DefensiveBotHeader);
  535.         rank(_RankGeneral);
  536.  
  537.         startstate(statenormal);
  538.         startaction(nomove);
  539.  
  540.         float(_declare,Attached,0);
  541.         float(_declare,KamikazeMode,0);
  542.         float(_declare,Angle,90);
  543.         float(_declare,AngleAdd,5);
  544.         float(_declare,PreferedDistToGroundLow,30);
  545.         float(_declare,PreferedDistToGroundHigh,35);
  546.         float(_declare,CurrentDirection,0);
  547.  
  548.  
  549.  
  550.         printi("Defensive droid start",VAIState);
  551.  
  552.         if(KamikazeMode!=0)
  553.         {
  554.             print("In kamikaze mode");
  555.  
  556.             if(Attached!=0)
  557.             {
  558.                 call(CopyParentFlags);
  559.             }
  560.  
  561.             call(AIupdateAIvars);
  562.             if(aivisiontoggle==0)
  563.             {
  564.                 call(AIcheckfortarget,10);
  565.             }
  566.             if(VAItargetfound==_AIenemy || VAIState==_AIstateAttack)
  567.             {
  568.                 printi("Droid in attackstate:   ",VAItargetfound);
  569.                 //detach from actor
  570.                 //select target and persue
  571.  
  572.                 if(VAItargetfound==_AIenemy)
  573.                 {
  574.                     call(AIselecttarget,_AIenemy);
  575.                     call(AIorder,_set,_AIstateattack);
  576.                 }
  577.                 call(AIpickdest,10);
  578.  
  579.                 CallSub(Sub_CorrectDroidPosition,Angle,AngleAdd,PreferedDistToGroundLow,PreferedDistToGroundHigh);        //for up and down corrections
  580.  
  581.                 Direction(_clr,_DIRaiRemoveFlags);
  582.                 if(VTargetDistance>100)
  583.                 {
  584.                     float(_set,CurrentDirection,0);
  585.                     CallSub(Sub_AI1WayAlignToTarget);
  586.                     CallSub(Sub_AI8WayMoveWalk,CurrentDirection);
  587.                     Direction(_set,CurrentDirection);
  588.                     print("CurrentDirection:  ",CurrentDirection);
  589.                     if(VTrigger==_DIRleft)
  590.                     {
  591.                         Turn(0,-40,0);
  592.                     }
  593.                     elseif(VTrigger==_DIRright)
  594.                     {
  595.                         Turn(0,40,0);
  596.                     }
  597.                     if(VTrigger==_DIRforward)
  598.                     {
  599.                         move(0,0,-15);
  600.                     }
  601.                     elseif(VTrigger==_DIRbackward)
  602.                     {
  603.                         move(0,0,15);
  604.                     }
  605.                     if(VTrigger==_DIRsideleft)
  606.                     {
  607.                         move(15,0,0);
  608.                     }
  609.                     elseif(VTrigger==_DIRsideright)
  610.                     {
  611.                         move(-15,0,0);
  612.                     }
  613.  
  614.                 }
  615.                 else
  616.                 {
  617.                     //blow up
  618.                     vector(_settoactorpos,tmpvector);
  619.                     initactor(BulletExplosion,tmpvector,emptyvector,false);
  620.                     CallSub(sub_fxexplosion);
  621.                     killactor();
  622.                 }
  623.  
  624.                 if(VTargetDistance<600)
  625.                 {
  626.                     if(VTargetAngle<30 && VTargetAngle>-30)
  627.                     {
  628.                         vector(_set,WeaponPos,0,0,-20);
  629.                         call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  630.                         if(VActorFlag==_AFLAGlogon)
  631.                         {
  632.                             print("Trying to fire bullet");
  633.                             SpawnActor(BulletDroid,0,0,-20);
  634.                             if(VTrigger==_DIRBulletFired)
  635.                             {
  636.                                 move(0,15,30);    //recoil
  637.                                 vector(_set,Gactorpos,0,0,-20);
  638.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,-1);
  639.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,fx_gunflashvert);
  640.                             }
  641.                         }
  642.                     }
  643.                 }
  644.             }
  645.         }
  646.         elseif(Attached==0)
  647.         {
  648.             CallSub(Sub_DroidCheckForAttach,Attached,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  649.         }
  650.         else
  651.         {
  652.             call(CopyParentFlags);
  653.  
  654.             call(AIupdateAIvars);
  655.             if(aivisiontoggle==0)
  656.             {
  657.                 call(AIcheckfortarget,0);
  658.             }
  659.             if(VAItargetfound==_AIenemy)
  660.             {
  661.                 printi("Defensebot Found something:   ",VAItargetfound);
  662.                 call(AIselecttarget,_AIenemy);
  663.                 call(AIupdatemovementvariables);
  664.  
  665.                 vector(_set,WeaponPos,0,0,-20);
  666.                 call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  667.  
  668.                 CallSub(Sub_AI1WayAlignToTarget);
  669.                 if(VTrigger==_DIRleft)
  670.                 {
  671.                     Turn(0,-40,0);
  672.                 }
  673.                 elseif(VTrigger==_DIRright)
  674.                 {
  675.                     Turn(0,40,0);
  676.                 }
  677.  
  678.                 if(VActorFlag==_AFLAGlogon)
  679.                 {
  680.                     printi("Correcting angle in lock mode",VTargetAngle);
  681.                     if(VTargetAngle<81 && VTargetAngle>-81)
  682.                     {
  683.                         print("Trying to fire bullet");
  684.                         SpawnActor(BulletDroid,0,0,-20);
  685.                         if(VTrigger==_DIRBulletFired)
  686.                         {
  687.                             move(0,15,30);    //recoil
  688.                             vector(_set,Gactorpos,0,0,-20);
  689.                             spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,-1);
  690.                             spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,fx_gunflashvert);
  691.                         }
  692.                     }
  693.                 }
  694.                 call(AIcalcdroidposition,80,angle,true,false);
  695.             }
  696.             else
  697.             {
  698.                 call(AIcalcdroidposition,80,angle,true,true);
  699.             }
  700.             CallSub(Sub_CorrectDroidPosition,Angle,AngleAdd,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  701.         }
  702.  
  703.         printi("PathDestDist:     ",VPathDestDistance);
  704.         printi("PathDestAngle:    ",VPathDestAngle);
  705.         printi("PickDestAngle:    ",VPickDestAngle);
  706.         printi("TargetDistance:   ",VTargetDistance);
  707.         printi("TargetAngle:      ",VTargetAngle);
  708.         printi("DistToGround:     ",VDistToGround);
  709.         print("PrefDistLow:      ",PreferedDistToGroundLow);
  710.         print("PrefDistHigh:     ",PreferedDistToGroundHigh);
  711.         printi("Health:           ",VHealth);
  712.  
  713.         if(vhealth<1000)
  714.         {
  715.             //go into kamikaze mode
  716.             if(KamikazeMode==0)
  717.             {
  718.                 float(_set,KamikazeMode,1);
  719.                 float(_set,PreferedDistToGroundLow,30);
  720.                 float(_set,PreferedDistToGroundHigh,35);
  721.             }
  722.             if(vhealth<0)
  723.             {
  724.                 vector(_settoactorpos,tmpvector);
  725.                 CallSub(sub_fxexplosion);
  726.                 killactor();
  727.             }
  728.         }
  729.  
  730.         if(VTrigger!=_DIRalive && VHealth>0)
  731.         {
  732.             print("parent died so detach");
  733.             break();
  734.  
  735.             float(_set,PreferedDistToGroundLow,30);
  736.             float(_set,PreferedDistToGroundHigh,35);
  737.  
  738.             call(ClrParentPtr);
  739.             float(_set,Attached,0);
  740.             Direction(_clr,_DIRshoot|_DIRhavegun);
  741.             Direction(_set,_DIRalive);
  742.         }
  743.  
  744.         if(VTrigger==_DIRactorbulletcol)
  745.         {
  746.             printilog("VColAngle:   ",VColAngle);
  747.             //printlog("ColAngleTmp: ",ColAngleTmp);
  748.             if(VColAngle>=3584 && VColAngle<512)
  749.             {
  750.                 move(0,0,60);
  751.             }
  752.             elseif(VColAngle>=512 && VColAngle<1536)
  753.             {
  754.                 move(60,0,0);
  755.             }
  756.             elseif(VColAngle>=1536 && VColAngle<2562)
  757.             {
  758.                 move(0,0,-60);
  759.             }
  760.             else
  761.             {
  762.                 move(-60,0,0);
  763.             }
  764.  
  765.         }
  766.  
  767.         CallSub(BackGroundTriggerChecks);
  768.  
  769.         printi("Defensive droid end");
  770. }
  771.  
  772. //**********************************************************************************************************
  773. //**********************************************************************************************************
  774. //****************        Offensive Bot                                                     *******************
  775. //**********************************************************************************************************
  776. //**********************************************************************************************************
  777.  
  778. Actor(OffensiveBot)
  779. {
  780.         file(OffensiveBotHeader);
  781.         rank(_RankGeneral);
  782.  
  783.         startstate(statenormal);
  784.         startaction(nomove);
  785.  
  786.         float(_declare,Attached,0);
  787.         float(_declare,Angle,90);
  788.         float(_declare,AngleAdd,5);
  789.         float(_declare,PreferedDistToGroundLow,30);
  790.         float(_declare,PreferedDistToGroundHigh,35);
  791.         float(_declare,CurrentDirection,0);
  792.  
  793.         printi("Attackdroid start",VAIState);
  794.  
  795.         if(Attached==0)
  796.         {
  797.             CallSub(Sub_DroidCheckForAttach,Attached,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  798.         }
  799.         else
  800.         {
  801.             call(CopyParentFlags);
  802.  
  803.             call(AIupdateAIvars);
  804.             if(aivisiontoggle==0)
  805.             {
  806.                 print("Checking for target");
  807.                 call(AIcheckfortarget,10);
  808.             }
  809.             if(VAItargetfound==_AIenemy || VAIState==_AIstateAttack || VAIState==_AIstateSearch)
  810.             {
  811.                 printi("Droid in attackstate:  ",VAItargetfound);
  812.                 //detach from actor
  813.                 //select target and persue
  814.  
  815.                 if(VAItargetfound==_AIenemy)
  816.                 {
  817.                     print("in attack");
  818.                     call(AIselecttarget,_AIenemy);
  819.                     call(AIorder,_set,_AIstateattack);
  820.                 }
  821.                 elseif(VAIState==_AIstatesearch)
  822.                 {
  823.                     print("in search");
  824.                     if(VAInotargettime>150)
  825.                     {
  826.                         call(AIorder,_set,_AIstatepatrol);
  827.                         CallSub(DetachDroidFromParent,PreferedDistToGroundLow,PreferedDistToGroundHigh,Attached);
  828.                     }
  829.                 }
  830.                 elseif(VAInotargettime>150)
  831.                 {
  832.                     call(AIorder,_set,_AIstatesearch);
  833.                 }
  834.                 call(AIupdatetargetpos);
  835.                 call(AIpickdest,10);
  836.  
  837.                 Direction(_clr,_DIRaiRemoveFlags);
  838.                 if(VTargetDistance>100)
  839.                 {
  840.                     float(_set,CurrentDirection,0);
  841.                     CallSub(Sub_AI1WayAlignToPickDestAngle);
  842.                     if(VPickDestAngleCorr<700 && VPickDestAngleCorr>-700)
  843.                     {
  844.                         move(0,0,-15);
  845.                     }
  846.                     elseif(VPickDestAngleCorr<-1300 || VPickDestAngleCorr>1300)
  847.                     {
  848.                         move(0,0,15);
  849.                     }
  850.                     if(VPickDestOffsetY>10)
  851.                     {
  852.                         move(0,-2,0);
  853.                     }
  854.                     elseif(VPickDestOffsetY<-10)
  855.                     {
  856.                         move(0,2,0);
  857.                     }
  858.                 }
  859.                 else
  860.                 {
  861.                     CallSub(Sub_AI1WayAlignToTarget);
  862.                 }
  863.                 if(VTrigger==_DIRleft)
  864.                 {
  865.                     Turn(0,-40,0);
  866.                 }
  867.                 elseif(VTrigger==_DIRright)
  868.                 {
  869.                     Turn(0,40,0);
  870.                 }
  871.  
  872.                 if(VTargetDistance<600)
  873.                 {
  874.                     if(VTargetAngle<150 && VTargetAngle>-150)
  875.                     {
  876.                         vector(_set,WeaponPos,0,0,-20);
  877.                         call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  878.                         if(VActorFlag==_AFLAGlogon)
  879.                         {
  880.                             print("Trying to fire bullet");
  881.                             SpawnActor(BulletDroid,0,0,-20);
  882.                             if(VTrigger==_DIRBulletFired)
  883.                             {
  884.                                 move(0,15,30);    //recoil
  885.                                 vector(_set,Gactorpos,0,0,-20);
  886.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,-1);
  887.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,fx_gunflashvert);
  888.                             }
  889.                         }
  890.                     }
  891.                 }
  892.  
  893.                 /*
  894.                 printi("Defensebot Found something:   ",VAItargetfound);
  895.                 call(AIselecttarget,_AIenemy);
  896.                 call(AIupdatemovementvariables);
  897.  
  898.                 vector(_set,WeaponPos,0,0,-20);
  899.                 call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  900.  
  901.                 if(VActorFlag==_AFLAGlogon)
  902.                 {
  903.                     printi("Correcting angle in lock mode",VTargetAngle);
  904.                     if(VTargetAngle>11)
  905.                     {
  906.                         Turn(0,10,0);
  907.                     }
  908.                     elseif(VTargetAngle<-11)
  909.                     {
  910.                         Turn(0,-10,0);
  911.                     }
  912.                     else
  913.                     {
  914.                         print("Trying to fire bullet");
  915.                         SpawnActor(BulletDroid,0,0,-20);
  916.                         if(VTrigger==_DIRBulletFired)
  917.                         {
  918.                             vector(_set,Gactorpos,0,0,-20);
  919.                             spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,-1);
  920.                             spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,fx_gunflashvert);
  921.                         }
  922.                     }
  923.                 }
  924.                 call(AIcalcdroidposition,80,angle,true,false);
  925.                 */
  926.             }
  927.             else
  928.             {
  929.                 print("Not in attack");
  930.                 call(AIcalcdroidposition,80,angle,true,true);
  931.             }
  932.         }
  933.         CallSub(Sub_CorrectDroidPosition,Angle,AngleAdd,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  934.  
  935.         printi("PickDestAngle:    ",VPickDestAngle);
  936.         printi("TargetDistance:   ",VTargetDistance);
  937.         printi("TargetAngle:      ",VTargetAngle);
  938. /*
  939.         printi("PathDestDist:     ",VPathDestDistance);
  940.         printi("PathDestAngle:    ",VPathDestAngle);
  941.         printi("PickDestAngle:    ",VPickDestAngle);
  942.         printi("TargetDistance:   ",VTargetDistance);
  943.         printi("TargetAngle:      ",VTargetAngle);
  944.         printi("DistToGround:     ",VDistToGround);
  945.         print("PrefDistLow:      ",PreferedDistToGroundLow);
  946.         print("PrefDistHigh:     ",PreferedDistToGroundHigh);
  947.         printi("Health:           ",VHealth);
  948. */
  949.         if(vhealth<1000)
  950.         {
  951.             //go into kamikaze mode
  952.             if(vhealth<0)
  953.             {
  954.                 vector(_settoactorpos,tmpvector);
  955.                 CallSub(sub_fxexplosion);
  956.                 killactor();
  957.             }
  958.         }
  959.  
  960.         if(VTrigger!=_DIRalive && VHealth>0)
  961.         {
  962.             //parent died so detach
  963.  
  964.             CallSub(DetachDroidFromParent,PreferedDistToGroundLow,PreferedDistToGroundHigh,Attached);
  965.  
  966.             Direction(_set,_DIRalive);
  967.         }
  968.  
  969.         CallSub(BackGroundTriggerChecks);
  970.         print("Attackdroid end");
  971. }
  972.  
  973. //**********************************************************************************************************
  974. //**********************************************************************************************************
  975. //****************        Transport Bot                                                     *******************
  976. //**********************************************************************************************************
  977. //**********************************************************************************************************
  978.  
  979. Actor(TransportBot)
  980. {
  981.         file(TransportBotHeader);
  982.         rank(_RankGeneral);
  983.  
  984.         startstate(statenormal);
  985.         startaction(nomove);
  986.  
  987.         if(vactivetime==0)
  988.         {
  989.             sample(SFXDroidHover,-1);
  990.         }
  991.         if(vstate==statedead)
  992.         {
  993.             samplestop(SFXDroidHover);
  994.         }
  995.  
  996.         float(_declare,FirstTimeBatteryDrop,0);
  997.  
  998.         printi("Transportdroid start",VAIState);
  999.  
  1000.         ActorFlag(_or,_AFLAGnoai);
  1001.         printih("ActorFlag:   ",VActorFlag);
  1002.  
  1003.         if(vstate==StateFollowPath)
  1004.         {
  1005.             print("Driod in follow path mode:  ",vstate);
  1006.  
  1007.             call(AIPickdest,10);
  1008.             if(VAIstatehigh!=_AIinspecialmode)
  1009.             {
  1010.                 if(vtrigger==_DIRtempflag)
  1011.                 {
  1012.                     call(PickNewNode);
  1013.                 }
  1014.             }
  1015.             else
  1016.             {
  1017.                 print("AAHH! vstate=StateFollowPath & VAIstatehigh=_AIinspecialmode");
  1018.             }
  1019.         }
  1020.         elseif(vstate==StateExecutePathSequence)
  1021.         {
  1022.             print("Droid executing path sequence");
  1023.             call(AIPickdest,10);        //follow path
  1024.             if(vtrigger==_DIRtempflag)
  1025.             {
  1026.                 state(_clr,StateExecutePathSequence);
  1027.                 state(_or,StateFollowPath);
  1028.                 call(PickNewNode);
  1029.             }
  1030.         }
  1031.  
  1032.         printi("PathDestDistance:   ",VPathDestDistance);
  1033.         printi("PickDestAngle:      ",VPickDestAngleCorr);
  1034.         
  1035.         printi("VPickDestOffsetY:   ",VPickDestOffsetY);
  1036.  
  1037.         Direction(_clr,_DIRaiRemoveFlags);
  1038.         if(VPathDestDistance>10)
  1039.         {
  1040.             CallSub(Sub_AI1WayAlignToPickDestAngle);
  1041.             if(VTrigger==_DIRleft)
  1042.             {
  1043.                 Turn(0,-40,0);
  1044.             }
  1045.             elseif(VTrigger==_DIRright)
  1046.             {
  1047.                 Turn(0,40,0);
  1048.             }
  1049.             move(0,0,-5);
  1050.  
  1051.  
  1052.  
  1053. /*            if(VTrigger==_DIRforward)
  1054.             {
  1055.                 move(0,0,-15);
  1056.             }
  1057.             elseif(VTrigger==_DIRbackward)
  1058.             {
  1059.                 move(0,0,15);
  1060.             }
  1061.             if(VTrigger==_DIRsideleft)
  1062.             {
  1063.                 move(15,0,0);
  1064.             }
  1065.             elseif(VTrigger==_DIRsideright)
  1066.             {
  1067.                 move(-15,0,0);
  1068.             }
  1069. */
  1070.         //}
  1071.         //else
  1072.         //{
  1073.         //    CallSub(Sub_AI1WayAlignToTarget);
  1074.         //}
  1075.         }
  1076.         print("FirstTimeBatteryDrop is ",FirstTimeBatteryDrop);
  1077.         if(VPickDestOffsetY>10)
  1078.         {
  1079.             move(0,-2,0);
  1080.         }
  1081.         elseif(VPickDestOffsetY<-10)
  1082.         {
  1083.             move(0,2,0);
  1084.         }
  1085.  
  1086.         if(VAIState==_AIstateSuicide)
  1087.         {
  1088.             KillActor();
  1089.         }
  1090.         if(VAIState==_AIStateDropBattery)
  1091.         {
  1092.             print("aistatedropbattery");
  1093.             if(FirstTimeBatteryDrop==0)
  1094.             {
  1095.                 vector(_settoactorpos,Gactorpos);
  1096.                 vector(_set,Gactorangle,0,0,0);
  1097.                 InitActor(BulletBattery,Gactorpos,Gactorangle,0);
  1098.                 sample(SFXDropBattery,-1);
  1099.                 float(_set,FirstTimeBatteryDrop,1);
  1100.             }
  1101.         }
  1102.         else
  1103.         {
  1104.             print("reset battery");
  1105.             if(FirstTimeBatteryDrop==1)
  1106.             {
  1107.                 float(_set,FirstTimeBatteryDrop,0)
  1108.             }
  1109.         }
  1110.  
  1111. /*        if(Attached==0)
  1112.         {
  1113.             CallSub(Sub_DroidCheckForAttach,Attached,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  1114.         }
  1115.         else
  1116.         {
  1117.             call(CopyParentFlags);
  1118.  
  1119.             call(AIupdateAIvars);
  1120.             if(aivisiontoggle==0)
  1121.             {
  1122.                 call(AIcheckfortarget,10);
  1123.             }
  1124.             if(VAItargetfound==_AIenemy || VAIState==_AIstateAttack)
  1125.             {
  1126.                 print("Droid in attackstate");
  1127.                 //detach from actor
  1128.                 //select target and persue
  1129.  
  1130.                 if(VAItargetfound==_AIenemy)
  1131.                 {
  1132.                     call(AIselecttarget,_AIenemy);
  1133.                     call(AIorder,_set,_AIstateattack);
  1134.                 }
  1135.                 call(AIpickdest,10);
  1136.  
  1137.                 Direction(_clr,_DIRaiRemoveFlags);
  1138.                 if(VTargetDistance>100)
  1139.                 {
  1140.                     float(_set,CurrentDirection,0);
  1141.                     CallSub(Sub_AI1WayAlignToTarget);
  1142.                     CallSub(Sub_AI8WayMoveWalk,CurrentDirection);
  1143.                     Direction(_set,CurrentDirection);
  1144.                     if(VTrigger==_DIRleft)
  1145.                     {
  1146.                         Turn(0,-40,0);
  1147.                     }
  1148.                     elseif(VTrigger==_DIRright)
  1149.                     {
  1150.                         Turn(0,40,0);
  1151.                     }
  1152.                     if(VTrigger==_DIRforward)
  1153.                     {
  1154.                         move(0,0,-15);
  1155.                     }
  1156.                     elseif(VTrigger==_DIRbackward)
  1157.                     {
  1158.                         move(0,0,15);
  1159.                     }
  1160.                     if(VTrigger==_DIRsideleft)
  1161.                     {
  1162.                         move(15,0,0);
  1163.                     }
  1164.                     elseif(VTrigger==_DIRsideright)
  1165.                     {
  1166.                         move(-15,0,0);
  1167.                     }
  1168.  
  1169.                 }
  1170.                 else
  1171.                 {
  1172.                     CallSub(Sub_AI1WayAlignToTarget);
  1173.                 }
  1174.  
  1175.                 if(VTargetDistance<600)
  1176.                 {
  1177.                     if(VTargetAngle<30 && VTargetAngle>-30)
  1178.                     {
  1179.                         vector(_set,WeaponPos,0,0,-20);
  1180.                         call(wCheckWeaponTarget,EmptyVector,32767,WeaponPos);
  1181.                         if(VActorFlag==_AFLAGlogon)
  1182.                         {
  1183.                             print("Trying to fire bullet");
  1184.                             SpawnActor(BulletAutoCannon,0,0,-20);
  1185.                             if(VTrigger==_DIRBulletFired)
  1186.                             {
  1187.                                 move(0,15,30);    //recoil
  1188.                                 vector(_set,Gactorpos,0,0,-20);
  1189.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,-1);
  1190.                                 spawnparticle(fx_gunflashMachineGun,0,Gactorpos,emptyvector,fx_gunflashvert);
  1191.                             }
  1192.                         }
  1193.                     }
  1194.                 }
  1195.  
  1196.  
  1197.             }
  1198.             else
  1199.             {
  1200.                 call(AIcalcdroidposition,80,angle,true,true);
  1201.             }
  1202.             CallSub(Sub_CorrectDroidPosition,Angle,AngleAdd,PreferedDistToGroundLow,PreferedDistToGroundHigh);
  1203.         }
  1204.  
  1205.         printi("PathDestDist:     ",VPathDestDistance);
  1206.         printi("PathDestAngle:    ",VPathDestAngle);
  1207.         printi("PickDestAngle:    ",VPickDestAngle);
  1208.         printi("TargetDistance:   ",VTargetDistance);
  1209.         printi("TargetAngle:      ",VTargetAngle);
  1210.         printi("DistToGround:     ",VDistToGround);
  1211.         print("PrefDistLow:      ",PreferedDistToGroundLow);
  1212.         print("PrefDistHigh:     ",PreferedDistToGroundHigh);
  1213.         printi("Health:           ",VHealth);
  1214.  
  1215.         if(vhealth<100)
  1216.         {
  1217.             //go into kamikaze mode
  1218.             if(vhealth<0)
  1219.             {
  1220.                 vector(_settoactorpos,tmpvector);
  1221.                 CallSub(sub_fxexplosion);
  1222.                 killactor();
  1223.             }
  1224.         }
  1225.  
  1226.         if(VTrigger!=_DIRalive && VHealth>0)
  1227.         {
  1228.             //parent died so detach
  1229.  
  1230.             float(_set,PreferedDistToGroundLow,30);
  1231.             float(_set,PreferedDistToGroundHigh,35);
  1232.  
  1233.             call(ClrParentPtr);
  1234.             float(_set,Attached,0);
  1235.             Direction(_clr,_DIRshoot|_DIRhavegun);
  1236.             Direction(_set,_DIRalive);
  1237.         }
  1238.  
  1239.         CallSub(BackGroundTriggerChecks);
  1240.         print("Attackdroid end");
  1241. */
  1242.         //SpawnActor(BulletBattery,0,0,0);
  1243.         CallSub(BackGroundTriggerChecks);
  1244.  
  1245. }
  1246.  
  1247.  
  1248.  
  1249. Actor(MDroid1)
  1250. {
  1251.         file(MDroid1Header);
  1252.         rank(_RankGeneral);
  1253.  
  1254.         startstate(statenormal);
  1255.         startaction(mdroid1work);
  1256.  
  1257.  
  1258.         CallSub(BackGroundTriggerChecks);
  1259.  
  1260.         if(vaicon==0)
  1261.         {
  1262.             callsub(Sub_SetCameraNormal)
  1263.             callsub(MoveDroidRoutine);
  1264.  
  1265.             if(vtrigger==_DIRdepossesion)
  1266.             {
  1267.                 callsub(Sub_InitDepossesion,0,0,0)
  1268.             }
  1269.         }
  1270.  
  1271.         if(vhealth<0)
  1272.         {
  1273.             vector(_set,Gactorpos,-12540,24441,25123);
  1274.             vector(_set,Gactorangle,0,1604,0);
  1275.             InitActor(mdroid2,Gactorpos,Gactorangle,"stor_01");
  1276.             killactor();
  1277.         }
  1278. }
  1279.  
  1280. Actor(MDroid2)
  1281. {
  1282.         file(MDroid2Header);
  1283.         rank(_RankGeneral);
  1284.  
  1285.         startstate(statenormal);
  1286.         startaction(mdroid2work);
  1287.  
  1288.         if(vaicon==0)
  1289.         {
  1290.             callsub(Sub_SetCameraNormal)
  1291.             callsub(MoveDroidRoutine);
  1292.  
  1293.             if(vtrigger==_DIRdepossesion)
  1294.             {
  1295.                 callsub(Sub_InitDepossesion,0,0,0)
  1296.             }
  1297.  
  1298.         }
  1299.         if(vhealth<0)
  1300.         {
  1301.             vector(_set,Gactorpos,-12540,24441,25123);
  1302.             vector(_set,Gactorangle,0,1604,0);
  1303.             InitActor(mdroid2,Gactorpos,Gactorangle,"stor_01");
  1304.             killactor();
  1305.         }
  1306. }
  1307.  
  1308. Actor(TankMat)
  1309. {
  1310.         file(TankMatHeader);
  1311.         rank(_RankGeneral);
  1312.  
  1313.         startstate(statenormal);
  1314.         startaction(nomove);
  1315.  
  1316.         if(vaicon==0)
  1317.         {
  1318.             callsub(Sub_SetCameraNormal)
  1319.             callsub(MoveDroidRoutine);
  1320.  
  1321.             if(vtrigger==_DIRdepossesion)
  1322.             {
  1323.                 callsub(Sub_InitDepossesion,0,0,0)
  1324.             }
  1325.  
  1326.             if(vtrigger==_DIRaction)
  1327.             {
  1328.                 print("Action pressed");
  1329.  
  1330.                 call(AIcheckfortarget);
  1331.                 if(VAItargetfound!=0)
  1332.                 {
  1333.                     print("Target found 6666666666666666666");
  1334.                 }
  1335.             }
  1336.  
  1337.  
  1338.         }
  1339. /*        if(vhealth<0)        //respawn
  1340.         {
  1341.             vector(_set,Gactorpos,-12540,24441,25123);
  1342.             vector(_set,Gactorangle,0,1604,0);
  1343.             InitActor(mdroid2,Gactorpos,Gactorangle,"stor_01");
  1344.             killactor();
  1345.         }
  1346. */
  1347. }
  1348.  
  1349.  
  1350. Actor(ForkLift)
  1351. {
  1352.         file(ForkLiftHeader);
  1353.  
  1354.         rank(_RankGeneral);
  1355.  
  1356.         startstate(statenormal);
  1357.         startaction(nomove);
  1358.  
  1359.         if(vaicon==0)
  1360.         {
  1361.             callsub(Sub_SetCameraNormal)
  1362.             callsub(MoveDroidRoutine);
  1363.  
  1364.             if(vtrigger==_DIRdepossesion)
  1365.             {
  1366.                 callsub(Sub_InitDepossesion,0,0,0)
  1367.             }
  1368.         }
  1369. }
  1370.  
  1371. Actor(GunTurret)
  1372. {
  1373.         file(GunTurretHeader);
  1374.         startaction(GunTurretIdle);
  1375.  
  1376.         CallSub(BackGroundTriggerChecks);
  1377.  
  1378.         vector(_declare,ShootOffset,0,0,-225);
  1379.         float(_declare,ShootDelay,2);
  1380.         float(_declare,ShootCounter,0);
  1381.         float(_declare,ShootSide,0);            //0 is right cannon, 1 is left cannon
  1382.  
  1383.  
  1384.         if(VAction==GunTurretFire)
  1385.         {
  1386.             if(VFrame==81 || VFrame==121 || VFrame==161)
  1387.             {
  1388.                 float(_set,ShootDelay,0);
  1389.                 float(_set,ShootCounter,9);
  1390.             }
  1391.             elseif(VFrame==38 || VFrame==110 || VFrame==150)
  1392.             {
  1393.                 sample(SFXGunTurretHatch,-1);
  1394.             }
  1395.             elseif(VFrame==232)
  1396.             {
  1397.                 sample(SFXGunTurretSteam,-1);
  1398.             }
  1399.             elseif(VFrame==1 || VFrame==192)
  1400.             {
  1401.                 sample(SFXGunTurretDoor,-1);
  1402.             }
  1403.  
  1404.             if(VFrame>=190 && VFrame<=231)
  1405.             {
  1406.                 if(vrnd<50)
  1407.                 {
  1408.                     float(_rnd2,tmpfloat,2);
  1409.                     float(_sub,tmpfloat,1);
  1410.                     vector(_set,gactorine,0,0,0);
  1411.                     vector(_setx,gactorine,tmpfloat);
  1412.                     vector(_set,Gactorpos,0,0,-225);
  1413.                     spawnparticle(fx_weaponsmoke,4,gactorpos,gactorine,fx_machinegunsmokeac);
  1414.                     spawnparticle(fx_weaponsmoke,7,gactorpos,gactorine,fx_machinegunsmokeac);
  1415.                 }
  1416.             }
  1417.         }
  1418.         elseif(VAction==GunTurretBeserker)
  1419.         {
  1420.             if(Vframe==1)
  1421.             {
  1422.                 sample(SFXGunTurretDoor,-1);
  1423.             }
  1424.             elseif(VFrame==40 || VFrame==204)
  1425.             {
  1426.                 sample(SFXShaftLock,-1);
  1427.             }
  1428.             elseif(VFrame==44 || VFrame==98)
  1429.             {
  1430.                 sample(SFXLightning,-1);
  1431.             }
  1432.             elseif(VFrame==49 || VFrame==53 || VFrame==72 || VFrame==124)
  1433.             {
  1434.                 sample(SFXGunTurretZap,-1);
  1435.             }
  1436.             elseif(VFrame==55 || VFrame==214)
  1437.             {
  1438.                 sample(SFXGunTurretHatch,-1);
  1439.             }
  1440.             elseif(VFrame==81||VFrame==91||VFrame==101||VFrame==111||VFrame==121||VFrame==131||VFrame==141||VFrame==151||VFrame==161||VFrame==171||VFrame==181)    //||VFrame==191
  1441.             {
  1442.                 float(_set,ShootDelay,0);
  1443.                 float(_set,ShootCounter,9);
  1444.             }
  1445.         }
  1446.  
  1447.         if(ShootCounter>0)
  1448.         {
  1449.             if(ShootCounter==9)
  1450.             {
  1451.                 sample(SFXGunTurretFire,-1);
  1452.             }
  1453.             if(ShootDelay==0)
  1454.             {
  1455.                 float(_set,ShootDelay,2);
  1456.                 float(_sub,ShootCounter,1);
  1457.  
  1458.                 if(ShootSide==0)
  1459.                 {
  1460.                     float(_set,ShootSide,1);
  1461.  
  1462.                     //bullet
  1463.                     spawnactorbone(BulletGunTurret,ShootOffset,Gactorpos,Gactorine,4);
  1464.                     vector(_set,tmpvector,0,0,-200);
  1465.                     vector(_set,Gactorpos,0,0,-270);
  1466.                     spawnparticle(fx_gunbulletturretac,4,Gactorpos,tmpvector,fx_gunbulhorizac);
  1467.                     spawnparticle(fx_gunbulletturretac,4,Gactorpos,tmpvector,fx_gunbulvertac);
  1468.                     spawnparticle(fx_gunbulletturretac,4,Gactorpos,tmpvector,fx_gunbuldiag1ac);
  1469.                     spawnparticle(fx_gunbulletturretac,4,Gactorpos,tmpvector,fx_gunbuldiag2ac);
  1470.  
  1471.  
  1472.                     //muzzle flash
  1473.                     spawnparticle(fx_gunflashturretac,4,Gactorpos,emptyvector,fx_gunflashhorizac);
  1474.                     spawnparticle(fx_gunflashturretac,4,Gactorpos,emptyvector,fx_gunflashvertac);
  1475.                     spawnparticle(fx_gunflashturretac,4,Gactorpos,emptyvector,fx_gunflashdiag1ac);
  1476.                     spawnparticle(fx_gunflashturretac,4,Gactorpos,emptyvector,fx_gunflashdiag2ac);
  1477.                                                    
  1478.                     vector(_set,tmpvector,255,192,192);
  1479.                     spawnlight(fire_light,4,Gactorpos,tmpvector,EmptyVector,300);
  1480.                     vector(_set,Gactorpos,0,0,-220);
  1481.                     spawnparticle(fx_gunstrobeturret,4,Gactorpos,emptyvector,fx_gunstrobeac);
  1482.                     //muzzle flash
  1483.                 }
  1484.                 else
  1485.                 {
  1486.                     float(_set,ShootSide,0);
  1487.  
  1488.                     //bullet
  1489.                     spawnactorbone(BulletGunTurret,ShootOffset,Gactorpos,Gactorine,7);
  1490.                     vector(_set,tmpvector,0,0,-200);
  1491.                     vector(_set,Gactorpos,0,0,-270);
  1492.                     spawnparticle(fx_gunbulletturretac,7,Gactorpos,tmpvector,fx_gunbulhorizac);
  1493.                     spawnparticle(fx_gunbulletturretac,7,Gactorpos,tmpvector,fx_gunbulvertac);
  1494.                     spawnparticle(fx_gunbulletturretac,7,Gactorpos,tmpvector,fx_gunbuldiag1ac);
  1495.                     spawnparticle(fx_gunbulletturretac,7,Gactorpos,tmpvector,fx_gunbuldiag2ac);
  1496.                                                    
  1497.  
  1498.                     //muzzle flash
  1499.                     spawnparticle(fx_gunflashturretac,7,Gactorpos,emptyvector,fx_gunflashhorizac);
  1500.                     spawnparticle(fx_gunflashturretac,7,Gactorpos,emptyvector,fx_gunflashvertac);
  1501.                     spawnparticle(fx_gunflashturretac,7,Gactorpos,emptyvector,fx_gunflashdiag1ac);
  1502.                     spawnparticle(fx_gunflashturretac,7,Gactorpos,emptyvector,fx_gunflashdiag2ac);
  1503.  
  1504.                     vector(_set,tmpvector,255,192,192);
  1505.                     spawnlight(fire_light,7,Gactorpos,tmpvector,EmptyVector,300);
  1506.                     vector(_set,Gactorpos,0,0,-220);
  1507.                     spawnparticle(fx_gunstrobeturret,7,Gactorpos,emptyvector,fx_gunstrobeac);
  1508.                     //muzzle flash
  1509.                 }
  1510.             }
  1511.             else
  1512.             {
  1513.                 float(_sub,ShootDelay,1);
  1514.             }
  1515.         }
  1516.         elseif(ShootCounter==0)
  1517.         {
  1518.             samplestop(SFXGunTurretFire);
  1519.             float(_sub,ShootCounter,1);
  1520.         }
  1521. }
  1522.  
  1523.  
  1524.  
  1525.  
  1526.  
  1527.  
  1528.  
  1529. Actor(RocketLauncher)
  1530. {
  1531.         file(RocketLauncherHeader);
  1532.         startaction(Ridle);
  1533.         //startaction(RLaunchPatrol);
  1534.  
  1535.         CallSub(BackGroundTriggerChecks);
  1536.  
  1537.         if(vaicon!=0)
  1538.         {
  1539.             //ack!
  1540.         }
  1541.         else
  1542.         {
  1543.             if(vtrigger==_DIRpossesion)
  1544.             {
  1545.                 Camera(turret_camera_distance,turret_camera_angle);
  1546.                 Target(turret_camera_Tdistance,turret_camera_Tangle);
  1547.                 callsub(Sub_InitPossesion,NoMove,NoMove,NoMove);
  1548.                 FirstPerson(1);
  1549.             }
  1550.             elseif(vtrigger==_DIRdepossesion)
  1551.             {
  1552.                 callsub(Sub_InitDepossesion,0,0,0);
  1553.                 FirstPerson(0);
  1554.             }
  1555.  
  1556.             if(vtrigger==_DIRleft)
  1557.             {
  1558.                 turn(0,-32,0);
  1559.             }
  1560.             if(vtrigger==_DIRright)
  1561.             {
  1562.                 turn(0,32,0);
  1563.             }
  1564.  
  1565.             if(vtrigger==_DIRshoot)
  1566.             {
  1567.                 /*
  1568.                 //bullet
  1569.                 vector(_set,tmpvector,0,110,0);
  1570.                 spawnactorbone(BulletAutoCannon,tmpvector,Gactorpos,Gactorine,4);
  1571.                 vector(_set,tmpvector,0,200,0);
  1572.                 vector(_set,Gactorpos,0,110,0);
  1573.                 spawnparticle(fx_gunflashturret,4,Gactorpos,tmpvector,fx_gunbulhorizac);
  1574.                 spawnparticle(fx_gunflashturret,4,Gactorpos,tmpvector,fx_gunbulvertac);
  1575.                 spawnparticle(fx_gunflashturret,4,Gactorpos,tmpvector,fx_gunbuldiag1ac);
  1576.                 spawnparticle(fx_gunflashturret,4,Gactorpos,tmpvector,fx_gunbuldiag2ac);
  1577.  
  1578.                 //muzzle flash
  1579.                 vector(_set,Gactorpos,0,110,0);
  1580.                 spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,-1);
  1581.                 spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashvert);
  1582.                 spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashdiag1);
  1583.                 spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashdiag2);
  1584.  
  1585.                 vector(_set,tmpvector,255,192,192);
  1586.                 spawnlight(fire_light,4,Gactorpos,tmpvector,EmptyVector,200);
  1587.                 vector(_set,Gactorpos,0,64,0);
  1588.                 spawnparticle(fx_gunstrobeturret,4,Gactorpos,emptyvector,fx_gunstroberot);
  1589.                 */
  1590.             }
  1591.         }
  1592.  
  1593.  
  1594.         //if(vtrigger==_DIRshoot)
  1595.         if(vrnd<15)
  1596.         {
  1597.             //muzzle flash
  1598.             vector(_set,Gactorpos,0,110,0);
  1599.             spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,-1);
  1600.             spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashvert);
  1601.             spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashdiag1);
  1602.             spawnparticle(fx_gunflashturret,4,Gactorpos,emptyvector,fx_gunflashdiag2);
  1603.  
  1604.             vector(_set,tmpvector,255,192,192);
  1605.             spawnlight(fire_light,4,Gactorpos,tmpvector,EmptyVector,200);
  1606.             vector(_set,Gactorpos,0,64,0);
  1607.             spawnparticle(fx_gunstrobeturret,4,Gactorpos,emptyvector,fx_gunstroberot);
  1608.             //muzzle flash
  1609.         }
  1610.  
  1611.  
  1612.         vector(_set,Gactorpos,-28,0,32);
  1613.         vector(_set,Gactorine,0,2048,0);
  1614.         spawnparticle(fx_flare,1,gactorpos,emptyvector,fx_rocklaserflarered);
  1615.         spawnparticle(fx_coplaser,1,gactorpos,gactorine,fx_rocklaser);
  1616.         spawnparticle(fx_coplaser,1,gactorpos,gactorine,fx_gunflashvert);
  1617.         spawnparticle(fx_coplaser,1,gactorpos,gactorine,fx_gunflashdiag1);
  1618.         spawnparticle(fx_coplaser,1,gactorpos,gactorine,fx_gunflashdiag2);
  1619. }
  1620.  
  1621.  
  1622.  
  1623.  
  1624.  
  1625. Actor(AutoCannon)
  1626. {
  1627.         file(AutoCannonHeader);
  1628.         startaction(nomovenocollision);
  1629.  
  1630.         vector(_declare,VL_LockedOnPos,0,0,0);
  1631.         vector(_declare,VL_LockedOnOffset,0,0,0);
  1632.         float(_declare,FL_AutoCannonOffset,0);
  1633.         float(_declare,anglex,0);
  1634.         float(_declare,angley,0);
  1635.         float(_declare,anglez,0);
  1636.  
  1637. /*        printi("AC PathDestDist:     ",VPathDestDistance);
  1638.         printi("AC PathDestAngle:    ",VPathDestAngle);
  1639.         printi("AC PickDestAngle:    ",VPickDestAngle);
  1640.         printi("AC TargetDistance:   ",vtargetdistance);
  1641.         printi("AC TargetAngle:      ",vtargetangle);
  1642.  
  1643.         print("AC anglex:           ",anglex);
  1644.         print("AC angley:           ",angley);
  1645.         print("AC anglez:           ",anglez);
  1646. */
  1647.  
  1648.         callsub(BackGroundTriggerChecks);
  1649.  
  1650.         call(AIupdateAIvars);
  1651.  
  1652.         call(CheckForVisual,_CLASSangel,1000);
  1653.         call(AIcheckfortarget,10);
  1654.  
  1655.         if(VActiveTime==1)
  1656.         {
  1657.             ActorFlag(_or,_AFLAGnomove);
  1658.         }
  1659.  
  1660.         if(VAItargetfound!=0)
  1661.         {
  1662.             call(AIselecttarget,_AIenemy);
  1663.             call(AIPickdest,10);
  1664.  
  1665.             vector(_settotargetpos,VL_LockedOnPos);
  1666.             vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  1667.             vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  1668.             vector(_settargetpos,VL_LockedOnPos);
  1669.  
  1670.             if(VTargetAngle<-51)
  1671.             {
  1672.                 float(_add,angley,-50);
  1673.                 float(_sub,FL_AutoCannonOffset,1);
  1674.             }
  1675.             elseif(VTargetAngle>51)
  1676.             {
  1677.                 float(_add,angley,50);
  1678.                 float(_sub,FL_AutoCannonOffset,1);
  1679.             }
  1680.             else
  1681.             {
  1682.                 if(FL_AutoCannonOffset<-100)
  1683.                 {
  1684.                     float(_set,FL_AutoCannonOffset,-100);
  1685.                 }
  1686.                 //fine tuning angle
  1687.                 if(VTargetAngle<-11)
  1688.                 {
  1689.                     float(_add,angley,-10);
  1690.                 }
  1691.                 elseif(VTargetAngle>11)
  1692.                 {
  1693.                     float(_add,angley,10);
  1694.                 }
  1695.  
  1696.                 print("Correcting YAngle");
  1697.  
  1698.                 if(VTargetAngleY<-11)
  1699.                 {
  1700.                     float(_add,anglex,10);
  1701.                 }
  1702.                 elseif(VTargetAngleY>11)
  1703.                 {
  1704.                     float(_add,anglex,-10);
  1705.                 }
  1706.                 if(VTargetAngleY>-51 && VTargetAngleY<51)
  1707.                 {
  1708.                     if(FL_AutoCannonOffset<0)
  1709.                     {
  1710.                         float(_add,FL_AutoCannonOffset,1);
  1711.                     }
  1712.                     spawnactor(BulletAutoCannon,0,15,-70);
  1713.                 }
  1714.             }
  1715.         }
  1716.         else
  1717.         {
  1718.             float(_set,FL_AutoCannonOffset,-100);
  1719.             if(VAInotargettime>160)
  1720.             {
  1721.                 if(angley<-6)
  1722.                 {
  1723.                     float(_add,angley,5);
  1724.                 }
  1725.                 else
  1726.                 {
  1727.                     float(_add,angley,-5);
  1728.                 }
  1729.                 else
  1730.                 {
  1731.                     float(_set,angley,0);
  1732.                 }
  1733.                 if(anglex<-6)
  1734.                 {
  1735.                     float(_add,anglex,5);
  1736.                 }
  1737.                 else
  1738.                 {
  1739.                     float(_add,anglex,-5);
  1740.                 }
  1741.                 else
  1742.                 {
  1743.                     float(_set,anglex,0);
  1744.                 }
  1745.             }
  1746.         }
  1747.  
  1748.         if(angley>1024)
  1749.         {
  1750.             float(_set,angley,1024);
  1751.         }
  1752.         elseif(angley<-1024)
  1753.         {
  1754.             float(_set,angley,-1024);
  1755.         }
  1756.         if(anglex>512)
  1757.         {
  1758.             float(_set,anglex,512);
  1759.         }
  1760.         elseif(anglex<-512)
  1761.         {
  1762.             float(_set,anglex,-512);
  1763.         }
  1764.  
  1765.         if(anglex!=0 || angley!=0 || anglez!=0)
  1766.         {
  1767.             call(CalcTransMat,anglex,angley,anglez);
  1768.         }
  1769. }
  1770.  
  1771. Actor(AutoCannon2)
  1772. {
  1773.         file(AutoCannonHeader);
  1774.         startaction(nomovenocollision);
  1775.  
  1776.         vector(_declare,VL_LockedOnPos,0,0,0);
  1777.         vector(_declare,VL_LockedOnOffset,0,0,0);
  1778.         float(_declare,FL_AutoCannonOffset,0);
  1779.         float(_declare,anglex,-512);
  1780.         float(_declare,angley,2048);
  1781.         float(_declare,anglez,0);
  1782.  
  1783.         printi("AC PathDestDist:     ",VPathDestDistance);
  1784.         printi("AC PathDestAngle:    ",VPathDestAngle);
  1785.         printi("AC PickDestAngle:    ",VPickDestAngle);
  1786.         printi("AC TargetDistance:   ",vtargetdistance);
  1787.         printi("AC TargetAngle:      ",vtargetangle);
  1788.         printi("AC VTargetAngleY     ",VTargetAngleY);
  1789.         print("AC anglex:           ",anglex);
  1790.         print("AC angley:           ",angley);
  1791.         print("AC anglez:           ",anglez);
  1792.         print("AC offsety:          ",FL_AutoCannonOffset);
  1793.  
  1794.  
  1795.         call(AIupdateAIvars);
  1796.  
  1797.         call(CheckForVisual,_CLASSangel,1000);
  1798.         call(AIcheckfortarget,10);
  1799.  
  1800.         if(VActiveTime==1)
  1801.         {
  1802.             ActorFlag(_or,_AFLAGnomove);
  1803.         }
  1804.  
  1805.         if(VAItargetfound!=0)    // && VAItargetfound==_AIFriend)
  1806.         {
  1807.             call(AIselecttarget,_AIenemy);
  1808.             call(AIPickdest,10);
  1809.  
  1810.             vector(_settotargetpos,VL_LockedOnPos);
  1811.             vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  1812.             vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  1813.             vector(_settargetpos,VL_LockedOnPos);
  1814.  
  1815.             if(VTargetAngle<-51)
  1816.             {
  1817.                 float(_add,angley,-50);
  1818.                 float(_sub,FL_AutoCannonOffset,1);
  1819.             }
  1820.             elseif(VTargetAngle>51)
  1821.             {
  1822.                 float(_add,angley,50);
  1823.                 float(_sub,FL_AutoCannonOffset,1);
  1824.             }
  1825.             else
  1826.             {
  1827.                 if(FL_AutoCannonOffset<-100)
  1828.                 {
  1829.                     float(_set,FL_AutoCannonOffset,-100);
  1830.                 }
  1831.                 //fine tuning angle
  1832.                 if(VTargetAngle<-11)
  1833.                 {
  1834.                     float(_add,angley,-10);
  1835.                 }
  1836.                 elseif(VTargetAngle>11)
  1837.                 {
  1838.                     float(_add,angley,10);
  1839.                 }
  1840.  
  1841.                 print("Correcting YAngle");
  1842.  
  1843.                 if(VTargetAngleY<-11)
  1844.                 {
  1845.                     float(_add,anglex,10);
  1846.                 }
  1847.                 elseif(VTargetAngleY>11)
  1848.                 {
  1849.                     float(_add,anglex,-10);
  1850.                 }
  1851.  
  1852.                 if(VTargetAngleY>-51 && VTargetAngleY<51)
  1853.                 {
  1854.                     if(FL_AutoCannonOffset<0)
  1855.                     {
  1856.                         float(_add,FL_AutoCannonOffset,1);
  1857.                     }
  1858.                     if(LabAlarm!=0)
  1859.                     {
  1860.                         spawnactor(BulletAutoCannon,0,15,-70);
  1861.                     }
  1862.                 }
  1863.             }
  1864.         }
  1865.         else
  1866.         {
  1867.             float(_set,FL_AutoCannonOffset,-100);
  1868.             if(VAInotargettime>160)
  1869.             {
  1870.                 if(angley<-6)
  1871.                 {
  1872.                     float(_add,angley,5);
  1873.                 }
  1874.                 else
  1875.                 {
  1876.                     float(_add,angley,-5);
  1877.                 }
  1878.                 else
  1879.                 {
  1880.                     float(_set,angley,0);
  1881.                 }
  1882.                 if(anglex<-6)
  1883.                 {
  1884.                     float(_add,anglex,5);
  1885.                 }
  1886.                 else
  1887.                 {
  1888.                     float(_add,anglex,-5);
  1889.                 }
  1890.                 else
  1891.                 {
  1892.                     float(_set,anglex,0);
  1893.                 }
  1894.             }
  1895.         }
  1896.  
  1897.  
  1898.         if(angley>2176)
  1899.         {
  1900.             float(_set,angley,2176);
  1901.         }
  1902.         elseif(angley<896)
  1903.         {
  1904.             float(_set,angley,896);
  1905.         }
  1906.         if(anglex>512)
  1907.         {
  1908.             float(_set,anglex,512);
  1909.         }
  1910.         elseif(anglex<-512)
  1911.         {
  1912.             float(_set,anglex,-512);
  1913.         }
  1914.  
  1915.         if(anglex!=0 || angley!=0 || anglez!=0)
  1916.         {
  1917.             call(CalcTransMat,anglex,angley,anglez);
  1918.         }
  1919.  
  1920.         if(VarKey108==0)
  1921.         {
  1922.             vector(_settoactorpos,Gactorpos);
  1923.             vector(_copyy,Gactorpos,tmpfloat);
  1924.             if(tmpfloat<3750)
  1925.             {
  1926.                 float(_add,tmpfloat,1);
  1927.                 vector(_sety,Gactorpos,tmpfloat);
  1928.                 vector(_setactorpos,Gactorpos);
  1929.             }
  1930.         }
  1931.         elseif(VarKey108==1)
  1932.         {
  1933.             vector(_settoactorpos,Gactorpos);
  1934.             vector(_copyy,Gactorpos,tmpfloat);
  1935.             if(tmpfloat>3700)
  1936.             {
  1937.                 print("Y COORDINATE: ",tmpfloat);
  1938.                 float(_sub,tmpfloat,1);
  1939.                 vector(_sety,Gactorpos,tmpfloat);
  1940.                 vector(_setactorpos,Gactorpos);
  1941.             }
  1942.         }
  1943. }
  1944.  
  1945.  
  1946. Actor(AutoCannon3)
  1947. {
  1948.         file(AutoCannonHeader);
  1949.         startaction(nomovenocollision);
  1950.  
  1951.         vector(_declare,VL_LockedOnPos,0,0,0);
  1952.         vector(_declare,VL_LockedOnOffset,0,0,0);
  1953.         float(_declare,FL_AutoCannonOffset,0);
  1954.         float(_declare,anglex,-512);
  1955.         float(_declare,angley,2048);
  1956.         float(_declare,anglez,0);
  1957.  
  1958. /*        printi("AC PathDestDist:     ",VPathDestDistance);
  1959.         printi("AC PathDestAngle:    ",VPathDestAngle);
  1960.         printi("AC PickDestAngle:    ",VPickDestAngle);
  1961.         printi("AC TargetDistance:   ",vtargetdistance);
  1962.         printi("AC TargetAngle:      ",vtargetangle);
  1963.  
  1964.         print("AC anglex:           ",anglex);
  1965.         print("AC angley:           ",angley);
  1966.         print("AC anglez:           ",anglez);
  1967. */
  1968.  
  1969.  
  1970.         call(AIupdateAIvars);
  1971.  
  1972.         call(CheckForVisual,_CLASSangel,1000);
  1973.         call(AIcheckfortarget,10);
  1974.  
  1975.         if(VActiveTime==1)
  1976.         {
  1977.             ActorFlag(_or,_AFLAGnomove);
  1978.         }
  1979.  
  1980.         if(VAItargetfound!=0 && VAItargetfound==_AIFriend)
  1981.         {
  1982.             call(AIselecttarget,_AIenemy);
  1983.             call(AIPickdest,10);
  1984.  
  1985.             vector(_settotargetpos,VL_LockedOnPos);
  1986.             vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  1987.             vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  1988.             vector(_settargetpos,VL_LockedOnPos);
  1989.  
  1990.             if(VTargetAngle<-51)
  1991.             {
  1992.                 float(_add,angley,-50);
  1993.                 float(_sub,FL_AutoCannonOffset,1);
  1994.             }
  1995.             elseif(VTargetAngle>51)
  1996.             {
  1997.                 float(_add,angley,50);
  1998.                 float(_sub,FL_AutoCannonOffset,1);
  1999.             }
  2000.             else
  2001.             {
  2002.                 if(FL_AutoCannonOffset<-100)
  2003.                 {
  2004.                     float(_set,FL_AutoCannonOffset,-100);
  2005.                 }
  2006.                 //fine tuning angle
  2007.                 if(VTargetAngle<-11)
  2008.                 {
  2009.                     float(_add,angley,-10);
  2010.                 }
  2011.                 elseif(VTargetAngle>11)
  2012.                 {
  2013.                     float(_add,angley,10);
  2014.                 }
  2015.  
  2016.                 print("Correcting YAngle");
  2017.  
  2018.                 if(VTargetAngleY<-11)
  2019.                 {
  2020.                     float(_add,anglex,10);
  2021.                 }
  2022.                 elseif(VTargetAngleY>11)
  2023.                 {
  2024.                     float(_add,anglex,-10);
  2025.                 }
  2026.  
  2027.                 if(VTargetAngleY>-51 && VTargetAngleY<51)
  2028.                 {
  2029.                     if(FL_AutoCannonOffset<0)
  2030.                     {
  2031.                         float(_add,FL_AutoCannonOffset,1);
  2032.                     }
  2033.                     if(LabAlarm!=0)
  2034.                     {
  2035.                         spawnactor(BulletAutoCannon,0,15,-70);
  2036.                     }
  2037.                 }
  2038.             }
  2039.         }
  2040.         else
  2041.         {
  2042.             float(_set,FL_AutoCannonOffset,-100);
  2043.             if(VAInotargettime>160)
  2044.             {
  2045.                 if(angley<-6)
  2046.                 {
  2047.                     float(_add,angley,5);
  2048.                 }
  2049.                 else
  2050.                 {
  2051.                     float(_add,angley,-5);
  2052.                 }
  2053.                 else
  2054.                 {
  2055.                     float(_set,angley,0);
  2056.                 }
  2057.                 if(anglex<-6)
  2058.                 {
  2059.                     float(_add,anglex,5);
  2060.                 }
  2061.                 else
  2062.                 {
  2063.                     float(_add,anglex,-5);
  2064.                 }
  2065.                 else
  2066.                 {
  2067.                     float(_set,anglex,0);
  2068.                 }
  2069.             }
  2070.         }
  2071.  
  2072.  
  2073.         if(angley>3204)
  2074.         {
  2075.             float(_set,angley,3204);
  2076.         }
  2077.         elseif(angley<1920)
  2078.         {
  2079.             float(_set,angley,1920);
  2080.         }
  2081.         if(anglex>512)
  2082.         {
  2083.             float(_set,anglex,512);
  2084.         }
  2085.         elseif(anglex<-512)
  2086.         {
  2087.             float(_set,anglex,-512);
  2088.         }
  2089.  
  2090.  
  2091.  
  2092.         if(anglex!=0 || angley!=0 || anglez!=0)
  2093.         {
  2094.             call(CalcTransMat,anglex,angley,anglez);
  2095.         }
  2096.     
  2097.               
  2098.         if(VarKey108==0)
  2099.         {
  2100.             vector(_settoactorpos,Gactorpos);
  2101.             vector(_copyy,Gactorpos,tmpfloat);
  2102.             if(tmpfloat<3750)
  2103.             {
  2104.                 float(_add,tmpfloat,1);
  2105.                 vector(_sety,Gactorpos,tmpfloat);
  2106.                 vector(_setactorpos,Gactorpos);
  2107.             }
  2108.         }
  2109.         elseif(VarKey108==1)
  2110.         {
  2111.             vector(_settoactorpos,Gactorpos);
  2112.             vector(_copyy,Gactorpos,tmpfloat);
  2113.             if(tmpfloat>3700)
  2114.             {
  2115.                 print("Y COORDINATE: ",tmpfloat);
  2116.                 float(_sub,tmpfloat,1);
  2117.                 vector(_sety,Gactorpos,tmpfloat);
  2118.                 vector(_setactorpos,Gactorpos);
  2119.             }
  2120.         }
  2121. }
  2122.  
  2123.  
  2124.  
  2125. Actor(AutoCannon4)
  2126. {
  2127.         file(AutoCannonHeader);
  2128.         startaction(nomovenocollision);
  2129.  
  2130.         vector(_declare,VL_LockedOnPos,0,0,0);
  2131.         vector(_declare,VL_LockedOnOffset,0,0,0);
  2132.         float(_declare,FL_AutoCannonOffset,0);
  2133.         float(_declare,anglex,-512);
  2134.         float(_declare,angley,2048);
  2135.         float(_declare,anglez,0);
  2136.  
  2137. /*        printi("AC PathDestDist:     ",VPathDestDistance);
  2138.         printi("AC PathDestAngle:    ",VPathDestAngle);
  2139.         printi("AC PickDestAngle:    ",VPickDestAngle);
  2140.         printi("AC TargetDistance:   ",vtargetdistance);
  2141.         printi("AC TargetAngle:      ",vtargetangle);
  2142.  
  2143.         print("AC anglex:           ",anglex);
  2144.         print("AC angley:           ",angley);
  2145.         print("AC anglez:           ",anglez);
  2146. */
  2147.  
  2148.  
  2149.         call(AIupdateAIvars);
  2150.  
  2151.         call(CheckForVisual,_CLASSangel,1000);
  2152.         call(AIcheckfortarget,10);
  2153.  
  2154.         if(VActiveTime==1)
  2155.         {
  2156.             ActorFlag(_or,_AFLAGnomove);
  2157.         }
  2158.  
  2159.         if(VAItargetfound!=0 && VAItargetfound==_AIFriend)
  2160.         {
  2161.             call(AIselecttarget,_AIenemy);
  2162.             call(AIPickdest,10);
  2163.  
  2164.             vector(_settotargetpos,VL_LockedOnPos);
  2165.             vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  2166.             vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  2167.             vector(_settargetpos,VL_LockedOnPos);
  2168.  
  2169.             if(VTargetAngle<-51)
  2170.             {
  2171.                 float(_add,angley,-50);
  2172.                 float(_sub,FL_AutoCannonOffset,1);
  2173.             }
  2174.             elseif(VTargetAngle>51)
  2175.             {
  2176.                 float(_add,angley,50);
  2177.                 float(_sub,FL_AutoCannonOffset,1);
  2178.             }
  2179.             else
  2180.             {
  2181.                 if(FL_AutoCannonOffset<-100)
  2182.                 {
  2183.                     float(_set,FL_AutoCannonOffset,-100);
  2184.                 }
  2185.                 //fine tuning angle
  2186.                 if(VTargetAngle<-11)
  2187.                 {
  2188.                     float(_add,angley,-10);
  2189.                 }
  2190.                 elseif(VTargetAngle>11)
  2191.                 {
  2192.                     float(_add,angley,10);
  2193.                 }
  2194.  
  2195.                 print("Correcting YAngle");
  2196.  
  2197.                 if(VTargetAngleY<-11)
  2198.                 {
  2199.                     float(_add,anglex,10);
  2200.                 }
  2201.                 elseif(VTargetAngleY>11)
  2202.                 {
  2203.                     float(_add,anglex,-10);
  2204.                 }
  2205.  
  2206.                 if(VTargetAngleY>-51 && VTargetAngleY<51)
  2207.                 {
  2208.                     if(FL_AutoCannonOffset<0)
  2209.                     {
  2210.                         float(_add,FL_AutoCannonOffset,1);
  2211.                     }
  2212.                     if(LabAlarm!=0)
  2213.                     {
  2214.                         spawnactor(BulletAutoCannon,0,15,-70);
  2215.                     }
  2216.                 }
  2217.             }
  2218.         }
  2219.         else
  2220.         {
  2221.             float(_set,FL_AutoCannonOffset,-100);
  2222.             if(VAInotargettime>160)
  2223.             {
  2224.                 if(angley<-6)
  2225.                 {
  2226.                     float(_add,angley,5);
  2227.                 }
  2228.                 else
  2229.                 {
  2230.                     float(_add,angley,-5);
  2231.                 }
  2232.                 else
  2233.                 {
  2234.                     float(_set,angley,0);
  2235.                 }
  2236.                 if(anglex<-6)
  2237.                 {
  2238.                     float(_add,anglex,5);
  2239.                 }
  2240.                 else
  2241.                 {
  2242.                     float(_add,anglex,-5);
  2243.                 }
  2244.                 else
  2245.                 {
  2246.                     float(_set,anglex,0);
  2247.                 }
  2248.             }
  2249.         }
  2250.  
  2251.  
  2252. /*        if(angley>3204)
  2253.         {
  2254.             float(_set,angley,3204);
  2255.         }*/
  2256.         if(angley>3640)
  2257.         {
  2258.             float(_set,angley,3640);
  2259.         }
  2260.         elseif(angley<1920)
  2261.         {
  2262.             float(_set,angley,1920);
  2263.         }
  2264.         if(anglex>512)
  2265.         {
  2266.             float(_set,anglex,512);
  2267.         }
  2268.         elseif(anglex<-512)
  2269.         {
  2270.             float(_set,anglex,-512);
  2271.         }
  2272.  
  2273.  
  2274.  
  2275.  
  2276.         if(anglex!=0 || angley!=0 || anglez!=0)
  2277.         {
  2278.             call(CalcTransMat,anglex,angley,anglez);
  2279.         }
  2280.     
  2281.               
  2282. /*        if(VarKey108==0)
  2283.         {
  2284.             vector(_settoactorpos,Gactorpos);
  2285.             vector(_copyy,Gactorpos,tmpfloat);
  2286.             if(tmpfloat<3750)
  2287.             {
  2288.                 float(_add,tmpfloat,1);
  2289.                 vector(_sety,Gactorpos,tmpfloat);
  2290.                 vector(_setactorpos,Gactorpos);
  2291.             }
  2292.         }
  2293.         elseif(VarKey108==1)
  2294.         {
  2295.             vector(_settoactorpos,Gactorpos);
  2296.             vector(_copyy,Gactorpos,tmpfloat);
  2297.             if(tmpfloat>3700)
  2298.             {
  2299.                 print("Y COORDINATE: ",tmpfloat);
  2300.                 float(_sub,tmpfloat,1);
  2301.                 vector(_sety,Gactorpos,tmpfloat);
  2302.                 vector(_setactorpos,Gactorpos);
  2303.             }
  2304.         }*/
  2305. }
  2306.  
  2307.  
  2308. Actor(AutoCannon5)
  2309. {
  2310.         file(AutoCannonHeader);
  2311.         startaction(nomovenocollision);
  2312.  
  2313.         vector(_declare,VL_LockedOnPos,0,0,0);
  2314.         vector(_declare,VL_LockedOnOffset,0,0,0);
  2315.         float(_declare,FL_AutoCannonOffset,0);
  2316.         float(_declare,anglex,-512);
  2317.         float(_declare,angley,2048);
  2318.         float(_declare,anglez,0);
  2319.  
  2320.         printi("AC PathDestDist:     ",VPathDestDistance);
  2321.         printi("AC PathDestAngle:    ",VPathDestAngle);
  2322.         printi("AC PickDestAngle:    ",VPickDestAngle);
  2323.         printi("AC TargetDistance:   ",vtargetdistance);
  2324.         printi("AC TargetAngle:      ",vtargetangle);
  2325.         printi("AC VTargetAngleY     ",VTargetAngleY);
  2326.         print("AC anglex:           ",anglex);
  2327.         print("AC angley:           ",angley);
  2328.         print("AC anglez:           ",anglez);
  2329.         print("AC offsety:          ",FL_AutoCannonOffset);
  2330.  
  2331.  
  2332.         call(AIupdateAIvars);
  2333.  
  2334.         call(CheckForVisual,_CLASSangel,1000);
  2335.         call(AIcheckfortarget,10);
  2336.  
  2337.         if(VActiveTime==1)
  2338.         {
  2339.             ActorFlag(_or,_AFLAGnomove);
  2340.         }
  2341.  
  2342.         if(VAItargetfound!=0)    // && VAItargetfound==_AIFriend)
  2343.         {
  2344.             call(AIselecttarget,_AIenemy);
  2345.             call(AIPickdest,10);
  2346.  
  2347.             vector(_settotargetpos,VL_LockedOnPos);
  2348.             vector(_sety,VL_LockedOnOffset,FL_AutoCannonOffset);
  2349.             vector(_add,VL_LockedOnPos,VL_LockedOnOffset);
  2350.             vector(_settargetpos,VL_LockedOnPos);
  2351.  
  2352.             if(VTargetAngle<-51)
  2353.             {
  2354.                 float(_add,angley,-50);
  2355.                 float(_sub,FL_AutoCannonOffset,1);
  2356.             }
  2357.             elseif(VTargetAngle>51)
  2358.             {
  2359.                 float(_add,angley,50);
  2360.                 float(_sub,FL_AutoCannonOffset,1);
  2361.             }
  2362.             else
  2363.             {
  2364.                 if(FL_AutoCannonOffset<-100)
  2365.                 {
  2366.                     float(_set,FL_AutoCannonOffset,-100);
  2367.                 }
  2368.                 //fine tuning angle
  2369.                 if(VTargetAngle<-11)
  2370.                 {
  2371.                     float(_add,angley,-10);
  2372.                 }
  2373.                 elseif(VTargetAngle>11)
  2374.                 {
  2375.                     float(_add,angley,10);
  2376.                 }
  2377.  
  2378.                 print("Correcting YAngle");
  2379.  
  2380.                 if(VTargetAngleY<-11)
  2381.                 {
  2382.                     float(_add,anglex,10);
  2383.                 }
  2384.                 elseif(VTargetAngleY>11)
  2385.                 {
  2386.                     float(_add,anglex,-10);
  2387.                 }
  2388.  
  2389.                 if(VTargetAngleY>-51 && VTargetAngleY<51)
  2390.                 {
  2391.                     if(FL_AutoCannonOffset<0)
  2392.                     {
  2393.                         float(_add,FL_AutoCannonOffset,1);
  2394.                     }
  2395.                     if(LabAlarm!=0)
  2396.                     {
  2397.                         spawnactor(BulletAutoCannon,0,15,-70);
  2398.                     }
  2399.                 }
  2400.             }
  2401.         }
  2402.         else
  2403.         {
  2404.             float(_set,FL_AutoCannonOffset,-100);
  2405.             if(VAInotargettime>160)
  2406.             {
  2407.                 if(angley<-6)
  2408.                 {
  2409.                     float(_add,angley,5);
  2410.                 }
  2411.                 else
  2412.                 {
  2413.                     float(_add,angley,-5);
  2414.                 }
  2415.                 else
  2416.                 {
  2417.                     float(_set,angley,0);
  2418.                 }
  2419.                 if(anglex<-6)
  2420.                 {
  2421.                     float(_add,anglex,5);
  2422.                 }
  2423.                 else
  2424.                 {
  2425.                     float(_add,anglex,-5);
  2426.                 }
  2427.                 else
  2428.                 {
  2429.                     float(_set,anglex,0);
  2430.                 }
  2431.             }
  2432.         }
  2433.  
  2434.  
  2435.         if(angley>2176)
  2436.         {
  2437.             float(_set,angley,2176);
  2438.         }
  2439.         elseif(angley<0)
  2440.         {
  2441.             float(_set,angley,0);
  2442.         }
  2443. /*        elseif(angley<896)
  2444.         {
  2445.             float(_set,angley,896);
  2446.         }*/
  2447.         if(anglex>512)
  2448.         {
  2449.             float(_set,anglex,512);
  2450.         }
  2451.         elseif(anglex<-512)
  2452.         {
  2453.             float(_set,anglex,-512);
  2454.         }
  2455.  
  2456.         if(anglex!=0 || angley!=0 || anglez!=0)
  2457.         {
  2458.             call(CalcTransMat,anglex,angley,anglez);
  2459.         }
  2460.  
  2461. /*        if(VarKey108==0)
  2462.         {
  2463.             vector(_settoactorpos,Gactorpos);
  2464.             vector(_copyy,Gactorpos,tmpfloat);
  2465.             if(tmpfloat<3750)
  2466.             {
  2467.                 float(_add,tmpfloat,1);
  2468.                 vector(_sety,Gactorpos,tmpfloat);
  2469.                 vector(_setactorpos,Gactorpos);
  2470.             }
  2471.         }
  2472.         elseif(VarKey108==1)
  2473.         {
  2474.             vector(_settoactorpos,Gactorpos);
  2475.             vector(_copyy,Gactorpos,tmpfloat);
  2476.             if(tmpfloat>3700)
  2477.             {
  2478.                 print("Y COORDINATE: ",tmpfloat);
  2479.                 float(_sub,tmpfloat,1);
  2480.                 vector(_sety,Gactorpos,tmpfloat);
  2481.                 vector(_setactorpos,Gactorpos);
  2482.             }
  2483.         }*/
  2484. }
  2485.  
  2486.