BSD 4_1c_2 release

[unix-history] / usr / src / games / backgammon / table.c

static char sccsid[] = "        table.c 4.1     82/05/11        ";

#include "back.h"

char    *help2[] = {
       "   Enter moves as <s>-<f> or <s>/<r> where <s> is the starting",
       "position, <f> is the finishing position, and <r> is the roll.",
       "Remember, each die roll must be moved separately.",
       0
};

struct state    {
       char    ch;
       int     fcode;
       int     newst;
};

struct state    atmata[] = {

       'R', 1, 0,      '?', 7, 0,      'Q', 0, -3,     'B', 8, 25,
       '9', 2, 25,     '8', 2, 25,     '7', 2, 25,     '6', 2, 25,
       '5', 2, 25,     '4', 2, 25,     '3', 2, 25,     '2', 2, 19,
       '1', 2, 15,     '0', 2, 25,     '.', 0, 0,      '9', 2, 25,
       '8', 2, 25,     '7', 2, 25,     '6', 2, 25,     '5', 2, 25,

       '4', 2, 25,     '3', 2, 25,     '2', 2, 25,     '1', 2, 25,
       '0', 2, 25,     '/', 0, 32,     '-', 0, 39,     '.', 0, 0,
       '/', 5, 32,     ' ', 6, 3,      ',', 6, 3,      '\n', 0, -1,
       '6', 3, 28,     '5', 3, 28,     '4', 3, 28,     '3', 3, 28,
       '2', 3, 28,     '1', 3, 28,     '.', 0, 0,      'H', 9, 61,

       '9', 4, 61,     '8', 4, 61,     '7', 4, 61,     '6', 4, 61,
       '5', 4, 61,     '4', 4, 61,     '3', 4, 61,     '2', 4, 53,
       '1', 4, 51,     '0', 4, 61,     '.', 0, 0,      '9', 4, 61,
       '8', 4, 61,     '7', 4, 61,     '6', 4, 61,     '5', 4, 61,
       '4', 4, 61,     '3', 4, 61,     '2', 4, 61,     '1', 4, 61,

       '0', 4, 61,     ' ', 6, 3,      ',', 6, 3,      '-', 5, 39,
       '\n', 0, -1,    '.', 0, 0
};

checkmove (ist)

int     ist;

{
       register int    j, n;
       register char   c;
       char            a;

domove:
       if (ist == 0)  {
               if (tflag)
                       curmove (curr,32);
               else
                       writel ("\t\t");
               writel ("Move:  ");
       }
       ist = mvl = ncin = 0;
       for (j = 0; j < 5; j++)
               p[j] = g[j] = -1;

dochar:
       c = readc();

       if (c == 'S')  {
               raflag = 0;
               save (1);
               if (tflag)  {
                       curmove (cturn == -1? 18: 19,39);
                       ist = -1;
                       goto domove;
               } else  {
                       proll ();
                       ist = 0;
                       goto domove;
               }
       }

       if (c == tty.sg_erase && ncin > 0)  {
               if (tflag)
                       curmove (curr,curc-1);
               else  {
                       if (tty.sg_erase == '\010')
                               writel ("\010 \010");
                       else
                               writec (cin[ncin-1]);
               }
               ncin--;
               n = rsetbrd();
               if (n == 0)  {
                       n = -1;
                       if (tflag)
                               refresh();
               }
               if ((ist = n) > 0)
                       goto dochar;
               goto domove;
       }

       if (c == tty.sg_kill && ncin > 0)  {
               if (tflag)  {
                       refresh();
                       curmove (curr,39);
                       ist = -1;
                       goto domove;
               } else  if (tty.sg_erase == '\010')  {
                       for (j = 0; j < ncin; j++)
                               writel ("\010 \010");
                       ist = -1;
                       goto domove;
               } else  {
                       writec ('\\');
                       writec ('\n');
                       proll ();
                       ist = 0;
                       goto domove;
               }
       }

       n = dotable(c,ist);
       if (n >= 0)  {
               cin[ncin++] = c;
               if (n > 2)
               if ((! tflag) || c != '\n')
                       writec (c);
               ist = n;
               if (n)
                       goto dochar;
               else
                       goto domove;
       }

       if (n == -1 && mvl >= mvlim)
               return(0);
       if (n == -1 && mvl < mvlim-1)
               return(-4);

       if (n == -6)  {
               if (! tflag)  {
                       if (movokay(mvl+1))  {
                               wrboard();
                               movback (mvl+1);
                       }
                       proll ();
                       writel ("\t\tMove:  ");
                       for (j = 0; j < ncin;)
                               writec (cin[j++]);
               } else  {
                       if (movokay(mvl+1))  {
                               refresh();
                               movback (mvl+1);
                       } else
                               curmove (cturn == -1? 18:19,ncin+39);
               }
               ist = n = rsetbrd();
               goto dochar;
       }

       if (n != -5)
               return(n);
       writec ('\007');
       goto dochar;
}
\f
dotable (c,i)
char            c;
register int    i;

{
       register int    a, j;
       int             test;

       test = (c == 'R');

       while ( (a = atmata[i].ch) != '.')  {
               if (a == c || (test && a == '\n'))  {
                       switch  (atmata[i].fcode)  {

                       case 1:
                               wrboard();
                               if (tflag)  {
                                       curmove (cturn == -1? 18: 19,0);
                                       proll ();
                                       writel ("\t\t");
                               } else
                                       proll ();
                               break;

                       case 2:
                               if (p[mvl] == -1)
                                       p[mvl] = c-'0';
                               else
                                       p[mvl] = p[mvl]*10+c-'0';
                               break;

                       case 3:
                               if (g[mvl] != -1)  {
                                       if (mvl < mvlim)
                                               mvl++;
                                       p[mvl] = p[mvl-1];
                               }
                               g[mvl] = p[mvl]+cturn*(c-'0');
                               if (g[mvl] < 0)
                                       g[mvl] = 0;
                               if (g[mvl] > 25)
                                       g[mvl] = 25;
                               break;

                       case 4:
                               if (g[mvl] == -1)
                                       g[mvl] = c-'0';
                               else
                                       g[mvl] = g[mvl]*10+c-'0';
                               break;

                       case 5:
                               if (mvl < mvlim)
                                       mvl++;
                               p[mvl] = g[mvl-1];
                               break;

                       case 6:
                               if (mvl < mvlim)
                                       mvl++;
                               break;

                       case 7:
                               if (tflag)
                                       curmove (20,0);
                               else
                                       writec ('\n');
                               text (help2);
                               if (tflag)  {
                                       curmove (cturn == -1? 18: 19,39);
                               } else  {
                                       writec ('\n');
                                       proll();
                                       writel ("\t\tMove:  ");
                               }
                               break;

                       case 8:
                               p[mvl] = bar;
                               break;

                       case 9:
                               g[mvl] = home;
                       }

                       if (! test || a != '\n')
                               return (atmata[i].newst);
                       else
                               return (-6);
               }

               i++;
       }

       return (-5);
}
\f
rsetbrd ()  {
       register int    i, j, n;

       n = 0;
       mvl = 0;
       for (i = 0; i < 4; i++)
               p[i] = g[i] = -1;
       for (j = 0; j < ncin; j++)
               n = dotable (cin[j],n);
       return (n);
}