home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 1: Collection A / 17Bit_Collection_A.iso / files / 1113.dms / 1113.adf / CRobots / tiger.r < prev   
Text File  |  1993-03-02  |  4KB  |  204 lines
  1. Dark Unicorn
  2. Conrad Wong
  3. /* PROWLING TIGER
  4.  
  5.    Tiger, Tiger, Burning Bright,
  6.    Stalking Through the Jungle Night,
  7.    What Mortal Hand or Eye
  8.    Dare Trace Thy Fearful Symmetry?
  9.  
  10.    version 3.0 last revised November 4, 1988
  11.  
  12.    Created July 21, 1988 by Conrad Wong
  13.    Copyrighted (C) 1988 Dark Unicorn Publishing */
  14.  
  15. int angle,
  16.     range,
  17.     look,
  18.     movex,
  19.     movey;
  20.  
  21. main()
  22. {
  23.   int temp;
  24.  
  25.   movex = 100;
  26.   movey = 900;
  27.   while (1) {
  28.     move(movex,movey);
  29.     temp = movex;
  30.     movex = movey;
  31.     movey = 1000 - temp;
  32.   }
  33. }
  34.  
  35. /* Move: Tiger searches for prey by moving in a square inscribed in the
  36.     battlefield.  He looks always in the direction he's heading and in a
  37.     constantly rotating direction. */
  38.  
  39. move (dest_x, dest_y)
  40. int dest_x, dest_y;
  41. {
  42.   int course,range;
  43.  
  44.   course = plot_course(dest_x,dest_y);
  45.   while (distance(loc_x(),loc_y(),dest_x,dest_y) > 50)
  46.   {
  47.     drive (course,100);
  48.     if (range = scan(angle = course,10)) {
  49.       pounce();
  50.       course = plot_course(dest_x,dest_y);
  51.     }
  52.     if (range = scan(angle = (look -= 110),10)) {
  53.       pounce();
  54.       course = plot_course(dest_x,dest_y);
  55.     }
  56.   }
  57.   drive(course,0);
  58. }
  59.  
  60. /* Pounce: when Tiger is charging, he uses the tracking subroutine to make
  61.     sure his gun is on target, then subtracts a bit from range because he's
  62.     moving so fast.  If Tiger is close enough, he stops and uses the killprey
  63.     subroutine; if he loses sight of the prey, he's passed it and does a
  64.     quick scan.  */
  65.  
  66. pounce()
  67. {
  68.   int course;
  69.  
  70.   course = angle;
  71.   while ((range = scan(angle = track(angle,10,0),10)) > 200) {
  72.     cannon(angle,range * 9 / 10);
  73.     drive (course,100);
  74.   }
  75.   if (range)
  76.     killprey();
  77.   spotprey();
  78. }
  79.  
  80. /* Spot Prey: Tiger has lost the prey, but because it was pouncing, Tiger
  81.     thinks the prey is fairly close and uses a tracking subroutine to spot it.
  82.     Depending on the range, it will either pounce or killprey. */
  83.  
  84. spotprey()
  85. {
  86.   int time;
  87.  
  88.   drive (0,0);
  89.   time = 0;
  90.  
  91.   while (!(range = scan(angle += 100,10)) && (time < 36)) {
  92.     time += 1;
  93.   }
  94.   if (range)
  95.     killprey();
  96. }
  97.  
  98. /* Kill Prey: Tiger has spotted the prey in close and doesn't want to waste
  99.     time charging.  Instead Tiger uses a lower resolution on the subroutine
  100.     to keep a good lock on the prey.  Tiger also knows if he's been hit too
  101.     much staying where he is and flees. */
  102.  
  103. killprey()
  104. {
  105.   int hit;
  106.  
  107.   drive (0,0);
  108.   hit = damage() + 30;
  109.  
  110.   cannon (angle,range);
  111.   while (range = scan(angle = track(angle,20,5),10)) {
  112.     cannon (angle,range);
  113.     if (!range) {
  114.       spotprey();
  115.       range = 0;
  116.     }
  117.     if (range > 200) {
  118.       pounce();
  119.       range = 0;
  120.     }
  121.     if (hit < damage()) {
  122.       flee();
  123.       range = 0;
  124.     }
  125.   }
  126. }
  127.  
  128. /* Flee: if Tiger takes too much damage attacking the prey, it will flee by
  129.     running in a random direction. */
  130.  
  131. flee()
  132. {
  133.   int x,y,course;
  134.  
  135.   x = rand(1000);
  136.   y = rand(1000);
  137.   course = plot_course(x,y);
  138.   while (distance(loc_x(),loc_y(),x,y) > 50) {
  139.     drive (course,100);
  140.     range = scan (course,10);
  141.     if (range > 0)
  142.       cannon(course,range);
  143.   }
  144.   drive (0,0);
  145. }
  146.  
  147. /* Track: pinpoints the enemy. */
  148.  
  149. track(d,r,l)
  150. int d,r,l;
  151. {
  152.   if (r > l)
  153.     {
  154.       if (scan(d-r,r) > 0)
  155.         return(track(d-r,r/2,l));
  156.       else
  157.         if (scan(d+r,r) > 0)
  158.           return(track(d+r,r/2,l));
  159.         else
  160.           if (scan(d,r) > 0)
  161.             return(track(d,r/2,l));
  162.           else
  163.             return (d);
  164.     }
  165.   else
  166.     return(d);
  167. }
  168.  
  169. /* Distance: calculates distance between two points. */
  170.  
  171. distance(x1,y1,x2,y2)
  172. int x1,y1,x2,y2;
  173. {
  174.   return(sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2))));
  175. }
  176.  
  177. /* Plot Course: calculates the degree heading of a location. */
  178.  
  179. plot_course(xx,yy)
  180. int xx, yy;
  181. {
  182.   int d,
  183.       x,y;
  184.  
  185.   x = loc_x() - xx;
  186.   y = loc_y() - yy;
  187.  
  188.   if (x == 0) {
  189.     if (y > 0)
  190.       d = 90;
  191.     else
  192.       d = 270;
  193.   }
  194.   else {
  195.     d = atan((100000 * y) / x);
  196.     if (x >= 0)
  197.       d += 180;
  198.     else if ((y > 0) && (x < 0))
  199.       d += 360;
  200.   }
  201.   return (d % 360);
  202. }
  203.  
  204.