home *** CD-ROM | disk | FTP | other *** search
/ Aminet 7 / Aminet 7 - August 1995.iso / Aminet / misc / sci / RARS_Amiga_3.lha / RARS / rusty.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-27  |  6.3 KB  |  239 lines
  1. // RUSTY.CPP - "driver" function for RARS
  2. // By Bill Benedict, May 1995
  3. // benediw@rosevc.rose-hulman.edu
  4.  
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <math.h>
  8. #include "car.h"
  9.  
  10.  
  11. #define max(x,y) (((x)<(y))?(y):(x))
  12. #define min(x,y) (((x)<(y))?(x):(y))
  13.  
  14. #define BRAKE 0.27       // mph/ft    .22
  15. #define ACCEL 10       // mph increase each time through this proc
  16. #define NO_RAD 810      // any bigger and its a straightaway, not a turn
  17. #define MAX_SPEED 400.0
  18. #define MIN_SPEED 40.0
  19. #define MID 0.5
  20. #define SRGT 0.60
  21. #define SLFT 0.40
  22. #define TRGT 0.99
  23. #define TLFT 0.01
  24.  
  25.  
  26.  
  27. extern const double CARWID;
  28. extern char* glob_name;
  29.  
  30. con_vec Rusty(situation& s)
  31. {
  32.    const char name[] = "Rusty";
  33.    static int init_flag = 1;
  34.    con_vec result;
  35.    double alpha, vc, rad;
  36.    double width;
  37.    double to_end;
  38.    double cur_len, nex_len;
  39.    double cur_spd, nex_spd, after_spd;
  40.    double cur_rad, nex_rad, after_rad;
  41.    double mod=1.0;
  42.    double EARLY;
  43.    double dlane;
  44.  
  45.    const double steer_gain = .2;
  46.    const double steer_damp = .53;
  47.    const double normalane = 0.5;
  48.    static int lane_time = 0;
  49.    static int lane_time2 = 0;
  50.    static int lane_change = -0.1;
  51.    static double lane = 0.0;
  52.    double cur_lane = 0.0;
  53.         // determines right-left position on straigtaway
  54.    const double corn_con = 5.45;
  55.  
  56.    if(init_flag)  {
  57.       my_name_is(name);
  58.       init_flag = 0;
  59.       result.alpha = result.vc = 0;
  60.       return result;
  61.    }
  62.    width = s.to_lft + s.to_rgt;
  63.    cur_rad=s.cur_rad;
  64.    nex_rad=s.nex_rad;
  65.    after_rad=s.after_rad;
  66.    cur_lane=s.to_lft/width;
  67.    dlane=0.05;
  68.  
  69.  
  70.  
  71.    if(nex_rad==0.0) {
  72.      nex_len = s.nex_len;
  73.    }
  74.    else {                //  make sure that len is always in feet :)
  75.      nex_len= s.nex_len * (s.nex_rad + width/2);
  76.    }
  77.  
  78.    if(cur_rad==0.0) {
  79.      cur_len = s.cur_len;
  80.      to_end = s.to_end;
  81.    }
  82.    else {                //  make sure that to_end is always in feet :)
  83.      cur_len= s.cur_len * (s.cur_rad + width/2);
  84.      to_end = s.to_end * (s.cur_rad + width/2);
  85.    }
  86.    to_end=max(to_end,-to_end);
  87.  
  88.  
  89.    if(stuck(s.backward, s.v,s.vn, s.to_lft,s.to_rgt, &result.alpha,&result.vc))
  90.       return result;
  91.  
  92.  
  93.    if(s.nex_len < 1.63 && abs(s.nex_rad) < width*4)
  94.      mod =1 + (1.63 - s.nex_len)*2.8;
  95.    else mod = 1;
  96.  
  97.    if((s.nex_rad > 0 && s.after_rad > 0) ||
  98.       (s.nex_rad < 0 && s.after_rad < 0))
  99.     mod = 1;
  100.  
  101.  
  102.    if(after_rad != 0.0)
  103.      after_spd = corn_con * sqrt(after_rad > 0.0 ? mod*(after_rad+width/2) :
  104.                            mod*(-after_rad+width/2));
  105.    else
  106.      after_spd = MAX_SPEED;
  107.  
  108.    if(nex_rad != 0.0 && s.nex_len > .53)  //.4
  109.      nex_spd = corn_con * sqrt(nex_rad > 0.0 ? mod*(nex_rad+width/2) :
  110.                            mod*(-nex_rad+width/2));
  111.    else
  112.      nex_spd = MAX_SPEED;
  113.  
  114.    if(s.cur_len < 1.63 && abs(s.cur_rad) < width*4) {
  115.      mod =1 + (1.63 - s.cur_len)*3.9;
  116.      if(s.cur_len < .81) mod*=2.7;
  117.    }
  118.    else mod = 1;
  119.  
  120.    if((s.nex_rad > 0 && s.after_rad > 0) ||
  121.       (s.nex_rad < 0 && s.after_rad < 0))
  122.     mod = 1;
  123.  
  124.   if(cur_rad != 0.0 && s.cur_len > .53)
  125.      cur_spd = corn_con * sqrt(cur_rad > 0.0 ? mod*(cur_rad+width/2) :
  126.                            mod*(-cur_rad+width/2));
  127.    else
  128.      cur_spd = MAX_SPEED;
  129.    if (nex_spd < MIN_SPEED) nex_spd = MIN_SPEED;
  130.    if (cur_spd < MIN_SPEED) cur_spd = MIN_SPEED;
  131.    EARLY = 0.0;
  132.    if((cur_rad == 0.0 || cur_rad > NO_RAD || cur_rad < -NO_RAD) && nex_rad != 0.0)
  133.    { // straight, nearing a turn
  134.      if(s.nex_len > 2.0) EARLY = .8*width; // 115 degrees
  135.      else if(s.nex_len > 1.6) EARLY = 1.2*width; // 91 degrees
  136.      else if(s.nex_len > 1.3) EARLY = 1.8*width; // 75 degrees
  137.      else if(s.nex_len > 1) EARLY = 2.0*width; // 60 degrees
  138.      else if(s.nex_len > .7) EARLY = 2.1*width; // 40 degrees
  139.      else EARLY = 2.0*width;
  140.      if (abs(s.nex_rad) < 151) EARLY*=1.2;
  141.      else if (abs(s.nex_rad) < 181) EARLY*=1.1;
  142.      else if (abs(s.nex_rad) < 311) EARLY*=1.0;
  143.      else if (abs(s.nex_rad) < 451) EARLY*=0.9;     // 221
  144.      else if (abs(s.nex_rad) < 571) EARLY*=0.8;     // 241
  145.      else EARLY*=0.65;                               //.7
  146.  
  147.    }
  148.    else if(cur_rad !=0.0 &&(cur_rad < NO_RAD && cur_rad > -NO_RAD))
  149.    {
  150.      if(s.to_end/s.cur_len < .13) EARLY = to_end +1;
  151.      else EARLY = 0.0;
  152.    }
  153.  
  154.  
  155.    if(cur_rad != 0.0 && cur_rad > -NO_RAD && cur_rad < NO_RAD)
  156.      dlane=1.0;
  157.    else {
  158.      if(cur_len>800) dlane=200/cur_len;
  159.      else dlane=300/cur_lane;
  160.    }
  161.    if(to_end < EARLY)
  162.    {
  163.      dlane = 1.0;
  164.      cur_rad = nex_rad;
  165.      nex_rad = after_rad;
  166. //   sound(20);delay(2);nosound();
  167.    }
  168.  
  169.    if (cur_rad == 0.0 || cur_rad > NO_RAD || cur_rad < -NO_RAD)
  170.    {      // on a 'straight'
  171.      if(nex_rad > 0.0) lane = SRGT;
  172.      else if (nex_rad < 0.0) lane = SLFT;
  173.      else if (after_rad > 0.0) lane = SRGT;
  174.      else if (after_rad < 0.0) lane = SLFT;
  175.      else lane = MID;
  176.    }
  177.    else if (cur_rad > 0.0) lane = TLFT;
  178.    else if (cur_rad < 0.0) lane = TRGT;
  179.    if(s.cur_rad != 0.0 && s.cur_rad > -NO_RAD && s.cur_rad < NO_RAD && EARLY)
  180.    {
  181.      if(s.cur_rad > 0 && s.nex_rad <= 0) lane=MID;
  182.      else if (s.cur_rad < 0 && s.nex_rad >= 0) lane=MID;
  183.      dlane = 0.08;
  184.    }
  185.    if(dlane > 2.0) dlane=2.0;
  186.    if(dlane < 0.1) dlane=0.1;
  187.    // maybe choose a different lane: (to help in passing)
  188. /*
  189.    if(!s.dead_ahead) {
  190.       if (lane_time <= 0) {
  191.     lane_time=-1;
  192.     lane = normalane; //+ random(5)*15;
  193.       }
  194.    }
  195.    else if (lane_time2 <= 0){
  196.       // pick a different lane:
  197.       if(lane >= 0.9)               // pick a new lane somehow:
  198.         lane_change = -0.1;
  199.       else if(lane <= 0.1)
  200.         lane_change = 0.1;
  201.       lane += lane_change;
  202.       if (lane > 0.9) lane = 0.9;
  203.       else if (lane < 0.1) lane = 0.1;
  204.       lane_time2=20;
  205.       lane_time=100;
  206.    }
  207.    if (lane_time >=0 ){
  208.      lane_time--;
  209.      lane_time2--;
  210.    }
  211. */
  212. // Audible buzz when the dead_ahead flag is set for this driver
  213. //if(s.dead_ahead) {sound(20);delay(2);nosound();}
  214.  
  215.    if(lane < cur_lane) lane=max(cur_lane - dlane,lane);
  216.    else if(lane > cur_lane) lane=min(cur_lane + dlane,lane);
  217.  
  218.    alpha = 2.5 * steer_gain * ((s.to_lft/width) - lane);
  219.  
  220.    if(s.dead_ahead)
  221.      alpha *= 1.2;
  222.  
  223.    alpha -= steer_damp * s.vn / s.v;
  224.       // This is damping, to prevent oscillation
  225.  
  226.    if ((s.v - nex_spd) > (to_end * BRAKE))
  227.       vc = max(s.v - (BRAKE*60), nex_spd);
  228.    else if(s.v - after_spd > (to_end + nex_len)*BRAKE)
  229.       vc = max(s.v - (BRAKE*60), after_spd);
  230.    else
  231.       vc = min(cur_spd,s.v+ACCEL);  // keep accellerating to speed we want
  232.  
  233.  
  234.    result.vc = vc;
  235.    result.alpha = alpha;
  236.    return result;
  237. }
  238.  
  239.