home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / cpmug / cpmug048.ark / BUGS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-08  |  7.6 KB  |  340 lines
  1.  
  2. /*
  3.     "Bugs"
  4.     written by Steve Ward for the H19/H89 display terminal
  5.     BD says..."This one is WIERD!!!"
  6. */
  7.  
  8. #define    NBUGS    25
  9. #define BOT    0
  10. #define LEFT    0
  11. #define RADIUS2    21
  12.  
  13. int    Top,        /* Pagesize-1                */
  14.     Right;        /* Linelength-2                */
  15.  
  16. struct bug {
  17.     int X,Y;
  18.     int Dir;    /* 0-down, 1-left, 2-up, 3-right.    */
  19.     int State; } bugs[NBUGS];
  20. char    Wflg, Cflg;
  21. int    CurX, CurY;
  22. int    CBugs;
  23. int    XMotion[20], YMotion[20];
  24.  
  25. rand()
  26. {
  27.     return nrand(2);
  28. }
  29.  
  30. step(bb)
  31.     struct bug *bb;
  32.  {    switch ((*bb).State) {
  33.      case 0:    r(bb,1,0,' ');
  34.             r(bb,1,-1,'\\'); (*bb).State++; break;
  35.      case 1:    r(bb,-1,0,' ');
  36.             r(bb,-1,-1,'/');
  37.             (*bb).State++;    break;
  38.      case 2:    r(bb,1,1,' ');
  39.             r(bb,1,0,'\\');
  40.             (*bb).State++;    break;
  41.      case 3:    r(bb,-1,1,' ');
  42.             r(bb,-1,0,'/');
  43.             (*bb).State++;    break;
  44.      case 4:    r(bb,0,-1,'0');
  45.             r(bb,0,0,'O');
  46.             r(bb,1,-1,'/');
  47.             r(bb,-1,-1,'\\');
  48.             r(bb,1,0,'/');
  49.             r(bb,-1,0,'\\');
  50.             (*bb).State++;    break;
  51.      case 5:    r(bb,1,2,' ');
  52.             r(bb,1,1,'\\');
  53.             (*bb).State++;    break;
  54.      case 6:    r(bb,-1,2,' ');
  55.             r(bb,-1,1,'/');
  56.             (*bb).State++;    break;
  57.      case 7:    r(bb,1,1,'/');
  58.             r(bb,0,1,' ');
  59.             r(bb,-1,1,'\\');
  60.             switch (((*bb).Dir) & 03) {
  61.              case 0: (*bb).Y--; break;
  62.              case 2: (*bb).Y++; break;
  63.              case 1: (*bb).X++; break;
  64.              case 3: (*bb).X--; break; }
  65.             (*bb).State = 0;    break;
  66. /* Diagonal movement:                        */
  67.  
  68.     case 20:    r(bb,1,1,' ');
  69.             r(bb,1,0,'-');
  70.             (*bb).State++;    break;
  71.     case 21:    r(bb,-1,-1,' ');
  72.             r(bb,0,-1,'|');
  73.             (*bb).State++;    break;
  74.     case 22:    r(bb,0,1,' ');
  75.             r(bb,1,1,'/');
  76.             (*bb).State++;    break;
  77.     case 23:    r(bb,-1,0,' ');
  78.             r(bb,-1,-1,'/');
  79.             (*bb).State++;    break;
  80.     case 24:    r(bb,1,-1,'0');
  81.             r(bb,0,0,'O');
  82.             r(bb,1,1,' ');
  83.             r(bb,0,1,'|');
  84.             r(bb,-1,-1,' ');
  85.             r(bb,-1,0,'-');
  86.             r(bb,1,0,'|');
  87.             r(bb,0,-1,'-');
  88.             (*bb).State++;    break;
  89.     case 25:    r(bb,-1,2,' ');
  90.             r(bb,0,2,'/');
  91.             (*bb).State++;    break;
  92.     case 26:    r(bb,-2,1,' ');
  93.             r(bb,-2,0,'/');
  94.             (*bb).State++;    break;
  95.     case 27:    r(bb,-1,1,' ');
  96.             r(bb,0,2,' ');
  97.             r(bb,-2,0,' ');
  98.             r(bb,1,0,'|');
  99.             r(bb,0,-1,'-');
  100.             switch (((*bb).Dir)& 03) {
  101.              case 0: (*bb).X++; (*bb).Y--; break;
  102.              case 1: (*bb).X++; (*bb).Y++; break;
  103.              case 2: (*bb).X--; (*bb).Y++; break;
  104.              case 3: (*bb).X--; (*bb).Y--; break; }
  105.             (*bb).State = 20;    break;
  106.  
  107. /* turn from diag to orthogonal (45 deg CCW)                */
  108.  
  109.     case 40:    r(bb,-1,0,' ');
  110.             r(bb,-2,0,'/');
  111.             (*bb).State++; break;
  112.     case 41:    r(bb,-1,0,'O');
  113.             r(bb,-1,2,' ');
  114.             r(bb,-1,1,'|');
  115.             r(bb,-2,0,'\\');
  116.             r(bb,-2,1,'\\');
  117.             (*bb).State++; break;
  118.     case 42:    r(bb,1,1,' ');
  119.             r(bb,0,1,'\\');
  120.             r(bb,-1,1,'\\');
  121.             r(bb,-2,0,' ');
  122.             r(bb,-2,-1,'/');
  123.             r(bb,0,-1,'/');
  124.             (*bb).Dir = (((*bb).Dir)+1) & 03;
  125.             (*bb).State = 0; break;
  126.  
  127. /* Turn from ortho to diagonal:                    */
  128.  
  129.     case 50:    r(bb,-1,0,' ');
  130.             r(bb,-1,-1,'/');
  131.             (*bb).State++; break;
  132.     case 51:    r(bb,-1,1,' ');
  133.             r(bb,-1,0,'/');
  134.             (*bb).State++; break;
  135.     case 52:    r(bb,1,2,' ');
  136.             r(bb,0,1,'|');
  137.             r(bb,-1,1,'O');
  138.             r(bb,1,0,' ');
  139.             r(bb,-1,2,' ');
  140.             r(bb,0,2,'/');
  141.             r(bb,-1,0,' ');
  142.             r(bb,-2,0,'/');
  143.             r(bb,-2,1,'-');
  144.             (*bb).State++; break;
  145.     case 53:    r(bb,0,2,' ');
  146.             r(bb,-1,2,'|');
  147.             r(bb,-2,0,' ');
  148.             r(bb,-1,0,'-');
  149.             (*bb).Dir = (((*bb).Dir) | 04);
  150.             (*bb).State = 20; break; }
  151.  }
  152.  
  153.  
  154. mkbug(bb,xp,yp,direc)
  155.     struct bug (*bb);
  156.  {    (*bb).X = xp;
  157.     (*bb).Y = yp;
  158.     (*bb).State = 0;
  159.     (*bb).Dir = direc;
  160.  
  161.     if (direc<4) {
  162.      r(bb,0,0,'0');
  163.      r(bb,0,1,'O');
  164.      r(bb,1,0,'/');
  165.      r(bb,1,1,'/');
  166.      r(bb,1,2,'/');
  167.      r(bb,-1,2,'\\');
  168.      r(bb,-1,1,'\\');
  169.      r(bb,-1,0,'\\'); }
  170.     else {
  171.      (*bb).State = 20;
  172.      r(bb,0,0,'0');
  173.      r(bb,1,1,'/');
  174.      r(bb,-1,-1,'/');
  175.      r(bb,0,1,'|');
  176.      r(bb,-1,0,'-');
  177.      r(bb,-1,1,'O');
  178.      r(bb,-1,2,'|');
  179.      r(bb,-2,1,'-'); }
  180.  }
  181.  
  182.  
  183. r(bb,dx,dy,ch)
  184.     struct bug (*bb);
  185.     char ch;
  186.  {    int tx,ty,direc,xdist,ydist;
  187.     char buf[4];
  188.     direc = ((*bb).Dir) & 03;
  189.  
  190.     if ((direc == 1) || (direc == 3))
  191.      { switch (ch) {
  192.         case '/':    ch = '\\'; break;
  193.         case '\\':    ch = '/'; break;
  194.         case '|':    ch = '-'; break;
  195.         case '-':    ch = '|'; break;
  196.         default:    break; }}
  197.  
  198.     switch (direc) {
  199.      case 0: tx = dx+(*bb).X; ty = dy+(*bb).Y; break;
  200.      case 2: tx = (*bb).X-dx; ty = (*bb).Y-dy; break;
  201.      case 1: tx = (*bb).X-dy; ty = (*bb).Y+dx; break;
  202.      case 3: tx = (*bb).X+dy; ty = (*bb).Y-dx; break; }
  203.     placech(ch,tx,ty); }
  204.  
  205.  
  206. placech(ch,tx,ty)
  207.     char ch;
  208.  {    int xdist,ydist;
  209.  
  210.     if ((tx<LEFT) || (tx>Right) || (ty<BOT) || (ty>Top)) return;
  211.  
  212.     xdist = CurX-tx; ydist = CurY-ty;
  213.     if (xdist<0) xdist = -xdist;
  214.     if (ydist<0) ydist = -ydist;
  215.     if ((ydist+xdist)>2)
  216.      { putchar('\033');
  217.        putchar('Y');
  218.        putchar(040 + Top - ty);
  219.        putchar(040 + tx);
  220.        CurX=tx; CurY=ty; }
  221.  
  222.     while (CurX<tx)
  223.      { putchar('\033'); putchar('C'); CurX++; }
  224.     while (tx<CurX)
  225.      { putchar('\033'); putchar('D'); CurX--; }
  226.     while (CurY<ty)
  227.      { putchar('\033'); putchar('A'); CurY++; }
  228.     while (ty<CurY)
  229.      { putchar('\033'); putchar('B'); CurY--; }
  230.     putchar(ch);
  231.     CurX++; }
  232.  
  233.  
  234. randbug(bb)
  235.     struct bug *bb;
  236.  {    int x,y,dir;
  237.      { dir = rand()%8;
  238.        x = rand()%80;
  239.        y = rand()%24;
  240.        if (Cflg)
  241.         { x = (Right-LEFT)/2; y = (Top-BOT)/2; }
  242.        else switch(dir & 03) {
  243.         case 0:    y=24+4; break;
  244.         case 2: y = -4; break;
  245.         case 1: x = -4; break;
  246.         case 3: x=80+4; break; }
  247.        mkbug(bb,x,y,dir); }}
  248.  
  249.  
  250. alive(bb)
  251.     struct bug *bb;
  252.  {    int px,py;
  253.     px = (*bb).X; py = (*bb).Y;
  254.     switch(((*bb).Dir) & 03) {
  255.      case 0: return(py>=BOT-4);
  256.      case 1: return(px<=Right+6);
  257.      case 2: return(py<=Top+4);
  258.      case 3: return(px>=LEFT-4); }}
  259.  
  260. turn(bb)
  261.     struct bug *bb;
  262.  {    switch ((*bb).State) {
  263.      case 0:    (*bb).State = 50; return;
  264.      case 20:    (*bb).State = 40; return;
  265.      default:    return; }}
  266.  
  267.  
  268. main(argc,argv)
  269.     char **argv;
  270.  {    int i,j,xdist,ydist,xmot,ymot;
  271.     char *arg;
  272.  
  273.     initw(XMotion, "0,1,0,-1,1,1,-1,-1");
  274.     initw(YMotion, "-1,0,1,0,-1,1,1,-1");
  275.     CurX = 1000; CurY = 1000;
  276.     Wflg = 0; Cflg = 0;
  277.     CBugs = 5;
  278.     Top = 23; Right = 78;
  279.  
  280.     nrand(0,"Are you ready to be driven buggy? ");
  281.     getchar();
  282.  
  283.     for (i=1; i<argc; i++)
  284.      { arg = argv[i];
  285.        if (arg[0] == '-')
  286.         for (j=1; arg[j]; j++) switch(arg[j]) {
  287.           case 'W':    Wflg++; break;
  288.           case 'C':    Cflg++; break;
  289.           default:    printf("bugs: Illegal option\n",21); exit();}
  290.        else CBugs = atoi(arg); }
  291.     if (CBugs>NBUGS) CBugs=NBUGS;
  292.  
  293.     if (Wflg)
  294.      { for (i=LEFT; i<Right; i++) placech('-',i,Top);
  295.        for (i=Top; i>BOT; i--) placech('|',Right,i);
  296.        for (i=LEFT; i<Right; i++) placech('-',i,BOT);
  297.        for (i=Top; i>BOT; i--) placech('|',LEFT,i);
  298.      }
  299.  
  300.     for (i=0; i<CBugs; i++)
  301.      randbug(&bugs[i]);
  302.  
  303.     while(1)
  304.      { i = rand()%CBugs;
  305.        if (alive(&bugs[i]))
  306.         { step(&bugs[i]);
  307.           j = (bugs[i]).State;
  308.           xmot = XMotion[(bugs[i]).Dir];
  309.           ymot = YMotion[(bugs[i]).Dir];
  310.           if ((j == 0) || (j == 20))
  311.             { if (Wflg) {
  312.               xdist = (bugs[i]).X;
  313.               ydist = xdist-Right;
  314.               if ((xmot>0) && (ydist<0) && (ydist*ydist < RADIUS2))
  315.                 turn(&bugs[i]);
  316.               ydist = xdist-LEFT;
  317.               if ((xmot<0)&&(ydist>0) && (ydist*ydist < RADIUS2))
  318.                 turn(&bugs[i]);
  319.               xdist = (bugs[i]).Y;
  320.               ydist = xdist-Top;
  321.               if ((ymot>0)&&(ydist<0) && (ydist*ydist < RADIUS2))
  322.                 turn(&bugs[i]);
  323.               ydist = xdist-BOT;
  324.               if ((ymot<0)&&(ydist>0) && (ydist*ydist < RADIUS2))
  325.                 turn(&bugs[i]); }}
  326.  
  327.           if ((j == 0) || (j == 20))
  328.            {    for (j=0;j<CBugs;j++)
  329.              { if (j==i) continue;
  330.                xdist = (bugs[j]).X - (bugs[i]).X;
  331.                ydist = (bugs[j]).Y - (bugs[i]).Y;
  332.                if ((xdist*xdist+ydist*ydist) < 21)
  333.                 { if (((xdist*xmot)<=0) && ((ydist*ymot)<=0))
  334.                     continue;
  335.                   turn(&bugs[i]);
  336.                   break; }}
  337.            if (!(rand()%15))
  338.               turn(&bugs[i]);}}
  339.        else randbug(&bugs[i]); }}
  340.