home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 543a.lha / Nebula / source.LZH / source / enemy.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-10  |  15.7 KB  |  781 lines
  1. /*
  2.  
  3. ------------------------------------------------------------------
  4.  
  5. Black Nebula
  6.  
  7. File :                enemy.c
  8. Programmer:        Colin Adams
  9. Date:                6/5/91
  10. Last Modified :    10/6/91
  11.  
  12. Description:
  13.  
  14. Updates the enemy objects in space (movement and rotations)
  15. Will be fixed a lot for the next version.
  16.  
  17. ------------------------------------------------------------------
  18.  
  19. */
  20.  
  21. #include "3d.h"
  22.  
  23. extern short U_rot;
  24.  
  25. #define DecreaseVelocity(obj) { if(obj->velocity>4)obj->velocity--; }
  26.  
  27. #define IncreaseMissileVelocity(obj) {if(obj->velocity<30)obj->velocity++;}
  28. #define DecreaseMissileVelocity(obj) {if(obj->velocity>20)obj->velocity--;}
  29.  
  30. extern void AddNewObject(short, short, short, short);
  31. extern int player_missiles;
  32.  
  33. int player_scale, player_score;
  34. short num_active[NO_OBJ_TYPES];
  35.  
  36. /*    ------------------------------------------------------------------
  37.         Coding
  38.         ------------------------------------------------------------------
  39. */
  40.  
  41. void IncreaseVelocity(object *obj)
  42. /* some ships move much faster than others.... */
  43. {
  44.     register int max;
  45.     
  46.     switch(obj->type)
  47.     {
  48.         case SHUTTLE: max = 5; break;
  49.         case KRAIT: max = 11; break;
  50.         case GECKO: max = 8; break;
  51.         case THARGOID: max = 11; break;
  52.         case MAMBA: max = 8; break;
  53.     }
  54.     
  55.     if(obj->velocity<max) obj->velocity++;
  56. }
  57.  
  58. int GetTargetAngle(object *obj, short px, short pz)
  59. {
  60.     register int o, angle, tempint;
  61.     register char quad;
  62.     int temp, ex = obj->trans_x+obj->centre_x, ez = obj->trans_z+obj->centre_z;
  63.     float depth, temp2;
  64.     int d;
  65.     
  66.     tempint = px-ex;
  67.     depth = tempint * tempint;
  68.     tempint = pz-ez;
  69.     depth += tempint * tempint;
  70.  
  71.     if(ex>px)
  72.     {
  73.         o = ex - px;
  74.         if(ez>pz)
  75.             quad = 4;
  76.         else
  77.         {
  78.             if(pz==ez) return 0;
  79.             quad = 1;
  80.         }
  81.     }
  82.     else
  83.     {
  84.         if(px==ex)
  85.         {
  86.             if(ez<pz)
  87.                 return 90;
  88.             else
  89.                 return 270;
  90.         }
  91.         
  92.         o = px - ex;
  93.         
  94.         if(ez>pz)
  95.             quad = 3;
  96.         else
  97.         {
  98.             if(pz==ez) return 180;
  99.             quad = 2;
  100.         }
  101.     }
  102.     
  103.     temp = o * 4096;
  104.     temp2 = fsqrt(depth);
  105.     
  106.     d = temp/temp2;
  107.     
  108.     if(d>4096) d = 4096; /* to fix small errors */
  109.     
  110.     angle = anti_sin[d];
  111.     
  112.     switch(quad)
  113.     {
  114.         case 1: angle = 90 - angle; break;
  115.         case 2: angle = 90 + angle; break;
  116.         case 3: angle = 180 + (90-angle); break;
  117.         case 4: angle += 270; break;
  118.     }
  119.     return angle;
  120. }
  121.  
  122. int GetPointAngle(int *de, short px, short pz)
  123. {
  124.     register int o, angle, tempint;
  125.     register char quad;
  126.     int temp;
  127.     float depth, temp2;
  128.     int d;
  129.     
  130.     tempint = px-ex;
  131.     depth = tempint * tempint;
  132.     tempint = pz-ez;
  133.     *de = (depth += tempint * tempint);
  134.  
  135.     if(ex>px)
  136.     {
  137.         o = ex - px;
  138.         if(ez>pz)
  139.             quad = 4;
  140.         else
  141.         {
  142.             if(pz==ez) return 0;
  143.             quad = 1;
  144.         }
  145.     }
  146.     else
  147.     {
  148.         if(px==ex)
  149.         {
  150.             if(ez<pz)
  151.                 return 90;
  152.             else
  153.                 return 270;
  154.         }
  155.         
  156.         o = px - ex;
  157.         
  158.         if(ez>pz)
  159.             quad = 3;
  160.         else
  161.         {
  162.             if(pz==ez) return 180;
  163.             quad = 2;
  164.         }
  165.     }
  166.     
  167.     temp = o * 4096;
  168.     temp2 = fsqrt(depth);
  169.     
  170.     d = temp/temp2;
  171.     
  172.     if(d>4096) d = 4096; /* to fix small errors */
  173.     
  174.     angle = anti_sin[d];
  175.     
  176.     switch(quad)
  177.     {
  178.         case 1: angle = 90 - angle; break;
  179.         case 2: angle = 90 + angle; break;
  180.         case 3: angle = 180 + (90-angle); break;
  181.         case 4: angle += 270; break;
  182.     }
  183.     return angle;
  184. }
  185.  
  186. void LaunchMissile(object *obj)
  187. /* this object would like to launch a missile at the player... */
  188. {
  189.     register int i;
  190.     int tx = obj->centre_x + obj->trans_x + FastCos(200, obj->heading);
  191.     int tz = obj->centre_z + obj->trans_z - FastSin(200, obj->heading);
  192.             
  193.     for(i=0; i<MAX_OBJECTS; i++)
  194.     {
  195.         register object *missile;
  196.             
  197.         if(!obj_free[ENEMYMISSILE][i])
  198.         {
  199.             int difficult = player_score>>12;
  200.             register int rand = getrandom(0, 30-difficult) - (30-difficult)/2;
  201.             int heading = obj->heading + rand;
  202.             
  203.             if(heading<0)
  204.                 heading += 360;
  205.             else if(heading>359)
  206.                 heading -= 360;
  207.             
  208.             missile = &obj_types[ENEMYMISSILE][i];
  209.             Translate_Obj_Abs(missile, tx, obj->trans_y+obj->centre_y, tz);
  210.             missile->i_am_dying = missile->lastdrawme = missile->lastdraw2 = 0;
  211.             missile->velocity = 25 + difficult;
  212.             missile->timeinflight = 0;
  213.             missile->heading = heading;
  214.             Rotate_Obj_Abs(missile, 0, heading, 0);
  215.             missile->explode = 0;
  216.             obj_free[ENEMYMISSILE][i] = 1;
  217.             active_list[no_objects] = missile;
  218.             no_objects++;
  219.             num_active[ENEMYMISSILE]++;
  220.             StartSound(0);
  221.             return;
  222.         }
  223.     }
  224. }
  225.         
  226. void MoveObjects(void)
  227. /* horrible sprawling routine... should be broken up */
  228. {
  229.     register int i;
  230.     register object *obj;
  231.         
  232.     for(i=0; i<no_objects; i++)
  233.     {
  234.         obj = active_list[i];
  235.         
  236.         if(obj->i_am_dying)
  237.             continue;
  238.         else
  239.             obj->drawme = 1;
  240.         
  241.         switch(obj->type)
  242.         {
  243.             case FIXED:
  244.                 Rotate_Obj_Rel(obj, 2, 2, 2);
  245.                 break;
  246.             case PLAYER:
  247.                 break;
  248.             case ENEMYMISSILE:
  249.             {
  250.                 register int i;
  251.                 register object *target;
  252.                 
  253.                 if(obj->timeinflight++>40)
  254.                 {
  255.                     obj->i_am_dying = 1;
  256.                     obj->explode = 1;
  257.                     break;
  258.                 }
  259.                 
  260.                 obj->trans_x += FastCos(obj->velocity, obj->heading);
  261.                 obj->trans_z -= FastSin(obj->velocity, obj->heading);
  262.  
  263.                 if(obj->trans_x<0)
  264.                     obj->trans_x = MAX_WORLD_X;
  265.                 else if(obj->trans_x > MAX_WORLD_X)
  266.                     obj->trans_x = 0;
  267.             
  268.                 if(obj->trans_z<0)
  269.                     obj->trans_z = MAX_WORLD_Z;
  270.                 else if(obj->trans_z>MAX_WORLD_Z)
  271.                     obj->trans_z = 0;
  272.             
  273.                 /* check if missile hit something */
  274.                 
  275.                 for(i=0; i<no_objects; i++)
  276.                 {
  277.                     target = active_list[i];
  278.                     
  279.                     if(target->type==MYMISSILE)
  280.                     {
  281.                         register int temp, distance;
  282.                         temp = (target->trans_x + target->centre_x) -
  283.                                 (obj->trans_x + obj->centre_x);
  284.                         
  285.                         distance = temp * temp;
  286.  
  287.                         temp = (target->trans_y + target->centre_y) -
  288.                                 (obj->trans_y + obj->centre_y);
  289.                         
  290.                         distance += temp * temp;
  291.                         
  292.                         temp = (target->trans_z + target->centre_z) -
  293.                                 (obj->trans_z + obj->centre_z);
  294.                     
  295.                         distance += temp * temp;
  296.                         
  297.                         if(distance<(obj->radius + 2000))
  298.                         {
  299.                             obj->i_am_dying = target->i_am_dying = 1;
  300.                             obj->explode = target->explode = 1;
  301.                             StartSound(2);
  302.                             break;
  303.                         }
  304.                     }
  305.                 }
  306.                 Rotate_Obj_Rel(obj, 5, 0, 0);
  307.                 break;
  308.             }
  309.             case MYMISSILE:
  310.             {
  311.                 register int i;
  312.                 register object *target;
  313.                 
  314.                 if(obj->timeinflight++>50)
  315.                 {
  316.                     obj->i_am_dying = 1;
  317.                     obj->explode = 1;
  318.                     break;
  319.                 }
  320.                 
  321.                 obj->trans_x += FastCos(obj->velocity, obj->heading);
  322.                 obj->trans_z -= FastSin(obj->velocity, obj->heading);
  323.  
  324.                 if(obj->trans_x<0)
  325.                     obj->trans_x = MAX_WORLD_X;
  326.                 else if(obj->trans_x > MAX_WORLD_X)
  327.                     obj->trans_x = 0;
  328.             
  329.                 if(obj->trans_z<0)
  330.                     obj->trans_z = MAX_WORLD_Z;
  331.                 else if(obj->trans_z>MAX_WORLD_Z)
  332.                     obj->trans_z = 0;
  333.             
  334.                 /* check if missile hit something */
  335.                 
  336.                 for(i=0; i<no_objects; i++)
  337.                 {
  338.                     target = active_list[i];
  339.                     
  340.                     if(target->type<=MAMBA)
  341.                     {
  342.                         register int temp, distance;
  343.                         temp = (target->trans_x + target->centre_x) -
  344.                                 (obj->trans_x + obj->centre_x);
  345.                         
  346.                         distance = temp * temp;
  347.  
  348.                         temp = (target->trans_y + target->centre_y) -
  349.                                 (obj->trans_y + obj->centre_y);
  350.                         
  351.                         distance += temp * temp;
  352.                         
  353.                         temp = (target->trans_z + target->centre_z) -
  354.                                 (obj->trans_z + obj->centre_z);
  355.                         
  356.                         distance += temp * temp;
  357.                         
  358.                         if(distance<(obj->radius + 2000))
  359.                         {
  360.                             obj->i_am_dying = target->i_am_dying = 1;
  361.                             obj->explode = target->explode = 1;
  362.                             
  363.                             switch(target->type)
  364.                             {
  365.                                 case FIXED: player_score += 1000; break;
  366.                                 case THARGOID: player_score += 1500; break;
  367.                                 case ENEMYMISSILE: player_score += 10; break;
  368.                                 case KRAIT: player_score += 600; break;
  369.                                 case MAMBA: player_score+= 1000;
  370.                                 default: player_score += 300;
  371.                             }
  372.                             
  373.                             {
  374.                                 register int temp = player_score>>12;
  375.                                 if(temp>player_scale)
  376.                                 {
  377.                                     player_scale = temp;
  378.                                     player_missiles++;
  379.                                 }
  380.                             }
  381.                             
  382.                             StartSound(2);
  383.                             break;
  384.                         }
  385.                     }
  386.                 }
  387.                 Rotate_Obj_Rel(obj, 5, 0, 0);
  388.                 break;
  389.             }
  390.             case GUIDEDMISSILE:
  391.             {
  392.                 register short dest, fdest, theight, height, s1, s2, i;
  393.                 register object *target;
  394.                 
  395.                 Rotate_Obj_Rel(obj, 5, 0, 0);
  396.                 
  397.                 if(obj->timeinflight++>100)
  398.                 {
  399.                     obj->i_am_dying = 1;
  400.                     obj->explode = 1;
  401.                     break;
  402.                 }
  403.                 
  404.                 if(obj->target==NULL) /* no target yet */
  405.                 {
  406.                     register int sh_dist = 0x7fffffff; /* a really big number */
  407.                     
  408.                     for(i=0; i<no_objects; i++)
  409.                     {
  410.                         if(active_list[i]->type<=MAMBA &&
  411.                             active_list[i]->type>ENEMYMISSILE)
  412.                         {
  413.                             register int temp, distance;
  414.                             register object *target = active_list[i];
  415.                             
  416.                             temp = (target->trans_x + target->centre_x) -
  417.                                 (obj->trans_x + obj->centre_x);
  418.                         
  419.                             distance = temp * temp;
  420.  
  421.                             temp = (target->trans_y + target->centre_y) -
  422.                                 (obj->trans_y + obj->centre_y);
  423.                         
  424.                             distance += temp * temp;
  425.                         
  426.                             temp = (target->trans_z + target->centre_z) -
  427.                                 (obj->trans_z + obj->centre_z);
  428.                         
  429.                             distance += temp * temp;
  430.                 
  431.                             if(distance<sh_dist)
  432.                             {
  433.                                 obj->target = active_list[i];
  434.                                 sh_dist = distance;
  435.                             }
  436.                         }
  437.                     }
  438.                 }
  439.                 
  440.                 target = (object *) obj->target;
  441.  
  442.                 {
  443.                     register char flag = 0;
  444.                     for(i=0; i<no_objects; i++)
  445.                     {
  446.                         if(active_list[i]==target)
  447.                         {
  448.                             flag = 1;
  449.                             break;
  450.                         }
  451.                     }
  452.                     if(!flag)
  453.                     {
  454.                         obj->target = NULL; /* get a new target next frame */
  455.                         break;
  456.                     }
  457.                 }
  458.                 
  459.                 /* move missile */
  460.                 
  461.                 height = obj->trans_y + obj->centre_y;
  462.                 
  463.                 theight = target->trans_y + target->centre_y;
  464.                 
  465.                 if(theight>height && height<MAX_WORLD_Y-500)
  466.                     obj->trans_y += 5;
  467.                 else if(height>5)
  468.                     obj->trans_y -= 5;
  469.  
  470.                 dest = GetTargetAngle(target, obj->trans_x+obj->centre_x,
  471.                  obj->trans_z+obj->centre_z);
  472.                 
  473.                 if(dest<0)
  474.                     break;
  475.  
  476.                 s1 = dest - obj->heading; /* get +ve diff. heading */
  477.                 s2 = obj->heading + 360 - dest;
  478.                 
  479.                 fdest = abs(s1)>abs(s2) ? -s2 : s1;
  480.  
  481.                 if(fdest>180)
  482.                 {
  483.                     DecreaseMissileVelocity(obj);
  484.                 }
  485.                 else
  486.                 {
  487.                     IncreaseMissileVelocity(obj);
  488.                 }
  489.                 
  490.                 if(fdest>0)
  491.                 {
  492.                     if(fdest>5)
  493.                         fdest = 5;
  494.                     
  495.                     Rotate_Obj_Rel(obj, 0, fdest, 0);
  496.                     obj->heading += fdest;
  497.                 }
  498.                 else
  499.                 {
  500.                     if(fdest<-5)
  501.                     {
  502.                         obj->heading -= 5;
  503.                         Rotate_Obj_Rel(obj, 0, -5, 0);
  504.                     }
  505.                     else
  506.                     {
  507.                         Rotate_Obj_Rel(obj, 0, fdest, 0);
  508.                         obj->heading += fdest;
  509.                     }
  510.                 }
  511.                 
  512.                 if(obj->heading>359)
  513.                     obj->heading -= 360;
  514.                 else if(obj->heading<0)
  515.                     obj->heading += 360;
  516.                 
  517.                 obj->trans_x += FastCos(obj->velocity, obj->heading);
  518.                 obj->trans_z -= FastSin(obj->velocity, obj->heading);
  519.  
  520.                 if(obj->trans_x<0)
  521.                     obj->trans_x = MAX_WORLD_X;
  522.                 else if(obj->trans_x > MAX_WORLD_X)
  523.                     obj->trans_x = 0;
  524.             
  525.                 if(obj->trans_z<0)
  526.                     obj->trans_z = MAX_WORLD_Z;
  527.                 else if(obj->trans_z>MAX_WORLD_Z)
  528.                     obj->trans_z = 0;
  529.                     
  530.                 /* now check if the target was hit! */
  531.                 
  532.                 {
  533.                     register int temp, distance;
  534.                     
  535.                     temp = (target->trans_x + target->centre_x) -
  536.                             (obj->trans_x + obj->centre_x);
  537.                         
  538.                     distance = temp * temp;
  539.  
  540.                     temp = (target->trans_y + target->centre_y) -
  541.                                 (obj->trans_y + obj->centre_y);
  542.                         
  543.                     distance += temp * temp;
  544.                         
  545.                     temp = (target->trans_z + target->centre_z) -
  546.                             (obj->trans_z + obj->centre_z);
  547.                         
  548.                     distance += temp * temp;
  549.                         
  550.                     if(distance<(obj->radius + 2500))
  551.                     {
  552.                         obj->i_am_dying = target->i_am_dying = 1;
  553.                         obj->explode = target->explode = 1;
  554.                             
  555.                         switch(target->type)
  556.                         {
  557.                             case FIXED: player_score += 1000; break;
  558.                             case THARGOID: player_score += 1500; break;
  559.                             case ENEMYMISSILE: player_score += 10; break;
  560.                             case KRAIT: player_score += 600; break;
  561.                             case MAMBA: player_score+= 1000;
  562.                             default: player_score += 300;
  563.                         }
  564.                         
  565.                         {
  566.                             register int temp = player_score>>12;
  567.                             if(temp>player_scale)
  568.                             {
  569.                                 player_scale = temp;
  570.                                 player_missiles++;
  571.                             }
  572.                         }
  573.                             
  574.                         StartSound(2);
  575.                     }
  576.                 }        
  577.                 break;
  578.             }
  579.             case EXPLOSION: /* floats away */
  580.             {
  581.                 int rad;
  582.                 
  583.                 if((--(obj->timeinflight))==0)
  584.                 {
  585.                     obj->i_am_dying = 1;
  586.                     obj->explode = 0;
  587.                     break;
  588.                 }
  589.                 
  590.                 rad = getrandom(0,10);
  591.                 
  592.                 if(obj->up_or_down)
  593.                 {
  594.                     if(obj->trans_y<MAX_WORLD_Y-100)
  595.                         obj->trans_y += rad;
  596.                 }
  597.                 else
  598.                 {
  599.                     if(obj->trans_y>100)
  600.                         obj->trans_y -= rad;
  601.                 }
  602.                 
  603.                 if(rad>5)
  604.                     rad = getrandom(1, 6);
  605.                 else
  606.                     rad = -getrandom(1, 6);
  607.                 
  608.                 Rotate_Obj_Rel(obj, rad+2, rad-1, rad+1);
  609.                 
  610.                 obj->trans_x += FastCos(obj->velocity, obj->heading);
  611.                 obj->trans_z -= FastSin(obj->velocity, obj->heading);
  612.  
  613.                 if(obj->trans_x<0)
  614.                     obj->trans_x = MAX_WORLD_X;
  615.                 else if(obj->trans_x > MAX_WORLD_X)
  616.                     obj->trans_x = 0;
  617.             
  618.                 if(obj->trans_z<0)
  619.                     obj->trans_z = MAX_WORLD_Z;
  620.                 else if(obj->trans_z>MAX_WORLD_Z)
  621.                     obj->trans_z = 0;
  622.                 break;
  623.             }
  624.             default: /* enemy ship combat algorithm... */
  625.             {
  626.                 register short dest, fdest, height, s1, s2;
  627.                 int distance;
  628.                 
  629.                 if(obj->type==THARGOID)
  630.                     Rotate_Obj_Rel(obj, 0, 5, 0);
  631.                 else if(obj->type==KRAIT)
  632.                     Rotate_Obj_Rel(obj, 5, 0, 0);
  633.                 
  634.                 height = obj->trans_y + obj->centre_y;
  635.                 
  636.                 fdest = ey - height;
  637.                 fdest = abs(fdest);
  638.                 
  639.                 if(ey>height && height<MAX_WORLD_Y-500)
  640.                 {
  641.                     if(fdest>5)
  642.                         obj->trans_y += 5;
  643.                     else
  644.                         obj->trans_y += fdest;
  645.                 }
  646.                 else if(height>5)
  647.                 {
  648.                     if(fdest>5)
  649.                         obj->trans_y -= 5;
  650.                     else
  651.                         obj->trans_y -= fdest;
  652.                 }
  653.  
  654.                 dest = GetPointAngle(&distance,obj->trans_x, obj->trans_z);
  655.                 
  656.                 if(dest<0)
  657.                     break;
  658.  
  659.                 s1 = dest - obj->heading; /* get +ve diff. heading */
  660.                 s2 = obj->heading + 360 - dest;
  661.                 
  662.                 fdest = abs(s1)>abs(s2) ? -s2 : s1;
  663.  
  664.                 if(fdest>180)
  665.                 {
  666.                     DecreaseVelocity(obj);
  667.                 }
  668.                 else
  669.                 {
  670.                     IncreaseVelocity(obj);
  671.                 }
  672.                 
  673.                 if(fdest>0)
  674.                 {
  675.                     if(fdest>5)
  676.                         fdest = 5;
  677.                     
  678.                     Rotate_Obj_Rel(obj, 0, fdest, 0);
  679.                     obj->heading += fdest;
  680.                 }
  681.                 else
  682.                 {
  683.                     if(fdest<-5)
  684.                     {
  685.                         obj->heading -= 5;
  686.                         Rotate_Obj_Rel(obj, 0, -5, 0);
  687.                     }
  688.                     else
  689.                     {
  690.                         Rotate_Obj_Rel(obj, 0, fdest, 0);
  691.                         obj->heading += fdest;
  692.                     }
  693.                 }
  694.                 
  695.                 if(abs(fdest)<10 && distance<(2500*2500))
  696.                 {
  697.                     if(obj->type==THARGOID)
  698.                     {
  699.                         if(getrandom(0, 20)==0)
  700.                             LaunchMissile(obj);
  701.                     }
  702.                     else if(obj->type==MAMBA)
  703.                     {
  704.                         if(getrandom(0,25)==0)
  705.                             LaunchMissile(obj);
  706.                     }
  707.                     else if(obj->type==KRAIT)
  708.                     {
  709.                         if(getrandom(0,35)==0)
  710.                             LaunchMissile(obj);
  711.                     }
  712.                     else 
  713.                     {
  714.                         if(getrandom(0,45)==0)
  715.                             LaunchMissile(obj);
  716.                     }
  717.                 }
  718.                         
  719.                 
  720.                 if(obj->heading>359)
  721.                     obj->heading -= 360;
  722.                 else if(obj->heading<0)
  723.                     obj->heading += 360;
  724.                 
  725.                 obj->trans_x += FastCos(obj->velocity, obj->heading);
  726.                 obj->trans_z -= FastSin(obj->velocity, obj->heading);
  727.  
  728.                 if(obj->trans_x<0)
  729.                     obj->trans_x = MAX_WORLD_X;
  730.                 else if(obj->trans_x > MAX_WORLD_X)
  731.                     obj->trans_x = 0;
  732.             
  733.                 if(obj->trans_z<0)
  734.                     obj->trans_z = MAX_WORLD_Z;
  735.                 else if(obj->trans_z>MAX_WORLD_Z)
  736.                     obj->trans_z = 0;
  737.             
  738.                     break;
  739.             }
  740.         }
  741.     }
  742. }
  743.  
  744. void UpdateObjects(void)
  745. /*
  746. Creates new objects, adding them to the game dynamically
  747. */
  748. {
  749.     if(!num_active[FIXED]) /* space stations */
  750.     {
  751.         /* there are none left, so I'll create 4 new ones ... */
  752.         
  753.         AddNewObject(FIXED, 500, 1000, 500);
  754.         AddNewObject(FIXED, MAX_WORLD_Z-500, 1000, 500);
  755.         AddNewObject(FIXED, 500, 1000, MAX_WORLD_Z-500);
  756.         AddNewObject(FIXED, MAX_WORLD_Z-500, 1000, MAX_WORLD_Z-500);
  757.     }
  758.     
  759.     if(num_active[3]+num_active[4]+num_active[5]+num_active[6]+
  760.     num_active[2]!=3)
  761.     {
  762.         switch(getrandom(0,3))
  763.         {
  764.             case 0:
  765.             AddNewObject(getrandom(SHUTTLE,MAMBA), getrandom(600,7000), 1000, MAX_WORLD_Z-100);
  766.             break;
  767.             case 1:
  768.             AddNewObject(getrandom(SHUTTLE,MAMBA), getrandom(600,7000), 1000, 100);
  769.             break;
  770.             case 2:
  771.             AddNewObject(getrandom(SHUTTLE,MAMBA), MAX_WORLD_X-200, 1000, getrandom(600,7000));
  772.             break;
  773.             case 3:
  774.             AddNewObject(getrandom(SHUTTLE,MAMBA), 100, 1000, getrandom(600,7000));
  775.             break;
  776.         }
  777.     }    
  778. }
  779.  
  780. /* end of module enemy.c */
  781.