home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / backgammon / common_source / table.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-08  |  6.3 KB  |  309 lines
  1. /*
  2.  * Copyright (c) 1980 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. #ifndef lint
  35. static char sccsid[] = "@(#)table.c    5.4 (Berkeley) 6/1/90";
  36. #endif /* not lint */
  37.  
  38. #include "back.h"
  39.  
  40. char    *help2[] = {
  41.     "   Enter moves as <s>-<f> or <s>/<r> where <s> is the starting",
  42.     "position, <f> is the finishing position, and <r> is the roll.",
  43.     "Remember, each die roll must be moved separately.",
  44.     0
  45. };
  46.  
  47. struct state    {
  48.     char    ch;
  49.     int    fcode;
  50.     int    newst;
  51. };
  52.  
  53. struct state    atmata[] = {
  54.  
  55.     'R', 1, 0,    '?', 7, 0,    'Q', 0, -3,    'B', 8, 25,
  56.     '9', 2, 25,    '8', 2, 25,    '7', 2, 25,    '6', 2, 25,
  57.     '5', 2, 25,    '4', 2, 25,    '3', 2, 25,    '2', 2, 19,
  58.     '1', 2, 15,    '0', 2, 25,    '.', 0, 0,    '9', 2, 25,
  59.     '8', 2, 25,    '7', 2, 25,    '6', 2, 25,    '5', 2, 25,
  60.  
  61.     '4', 2, 25,    '3', 2, 25,    '2', 2, 25,    '1', 2, 25,
  62.     '0', 2, 25,    '/', 0, 32,    '-', 0, 39,    '.', 0, 0,
  63.     '/', 5, 32,    ' ', 6, 3,    ',', 6, 3,    '\n', 0, -1,
  64.     '6', 3, 28,    '5', 3, 28,    '4', 3, 28,    '3', 3, 28,
  65.     '2', 3, 28,    '1', 3, 28,    '.', 0, 0,    'H', 9, 61,
  66.  
  67.     '9', 4, 61,    '8', 4, 61,    '7', 4, 61,    '6', 4, 61,
  68.     '5', 4, 61,    '4', 4, 61,    '3', 4, 61,    '2', 4, 53,
  69.     '1', 4, 51,    '0', 4, 61,    '.', 0, 0,    '9', 4, 61,
  70.     '8', 4, 61,    '7', 4, 61,    '6', 4, 61,    '5', 4, 61,
  71.     '4', 4, 61,    '3', 4, 61,    '2', 4, 61,    '1', 4, 61,
  72.  
  73.     '0', 4, 61,    ' ', 6, 3,    ',', 6, 3,    '-', 5, 39,
  74.     '\n', 0, -1,    '.', 0, 0
  75. };
  76.  
  77. checkmove (ist)
  78.  
  79. int    ist;
  80.  
  81. {
  82.     register int    j, n;
  83.     register char    c;
  84.     char        a;
  85.  
  86. domove:
  87.     if (ist == 0)  {
  88.         if (tflag)
  89.             curmove (curr,32);
  90.         else
  91.             writel ("\t\t");
  92.         writel ("Move:  ");
  93.     }
  94.     ist = mvl = ncin = 0;
  95.     for (j = 0; j < 5; j++)
  96.         p[j] = g[j] = -1;
  97.  
  98. dochar:
  99.     c = readc();
  100.  
  101.     if (c == 'S')  {
  102.         raflag = 0;
  103.         save (1);
  104.         if (tflag)  {
  105.             curmove (cturn == -1? 18: 19,39);
  106.             ist = -1;
  107.             goto domove;
  108.         } else  {
  109.             proll ();
  110.             ist = 0;
  111.             goto domove;
  112.         }
  113.     }
  114.  
  115.     if (c == tty.sg_erase && ncin > 0)  {
  116.         if (tflag)
  117.             curmove (curr,curc-1);
  118.         else  {
  119.             if (tty.sg_erase == '\010')
  120.                 writel ("\010 \010");
  121.             else
  122.                 writec (cin[ncin-1]);
  123.         }
  124.         ncin--;
  125.         n = rsetbrd();
  126.         if (n == 0)  {
  127.             n = -1;
  128.             if (tflag)
  129.                 refresh();
  130.         }
  131.         if ((ist = n) > 0)
  132.             goto dochar;
  133.         goto domove;
  134.     }
  135.  
  136.     if (c == tty.sg_kill && ncin > 0)  {
  137.         if (tflag)  {
  138.             refresh();
  139.             curmove (curr,39);
  140.             ist = -1;
  141.             goto domove;
  142.         } else  if (tty.sg_erase == '\010')  {
  143.             for (j = 0; j < ncin; j++)
  144.                 writel ("\010 \010");
  145.             ist = -1;
  146.             goto domove;
  147.         } else  {
  148.             writec ('\\');
  149.             writec ('\n');
  150.             proll ();
  151.             ist = 0;
  152.             goto domove;
  153.         }
  154.     }
  155.  
  156.     n = dotable(c,ist);
  157.     if (n >= 0)  {
  158.         cin[ncin++] = c;
  159.         if (n > 2)
  160.         if ((! tflag) || c != '\n')
  161.             writec (c);
  162.         ist = n;
  163.         if (n)
  164.             goto dochar;
  165.         else
  166.             goto domove;
  167.     }
  168.  
  169.     if (n == -1 && mvl >= mvlim)
  170.         return(0);
  171.     if (n == -1 && mvl < mvlim-1)
  172.         return(-4);
  173.  
  174.     if (n == -6)  {
  175.         if (! tflag)  {
  176.             if (movokay(mvl+1))  {
  177.                 wrboard();
  178.                 movback (mvl+1);
  179.             }
  180.             proll ();
  181.             writel ("\t\tMove:  ");
  182.             for (j = 0; j < ncin;)
  183.                 writec (cin[j++]);
  184.         } else  {
  185.             if (movokay(mvl+1))  {
  186.                 refresh();
  187.                 movback (mvl+1);
  188.             } else
  189.                 curmove (cturn == -1? 18:19,ncin+39);
  190.         }
  191.         ist = n = rsetbrd();
  192.         goto dochar;
  193.     }
  194.  
  195.     if (n != -5)
  196.         return(n);
  197.     writec ('\007');
  198.     goto dochar;
  199. }
  200.  
  201. dotable (c,i)
  202. char        c;
  203. register int    i;
  204.  
  205. {
  206.     register int    a, j;
  207.     int        test;
  208.  
  209.     test = (c == 'R');
  210.  
  211.     while ( (a = atmata[i].ch) != '.')  {
  212.         if (a == c || (test && a == '\n'))  {
  213.             switch  (atmata[i].fcode)  {
  214.  
  215.             case 1:
  216.                 wrboard();
  217.                 if (tflag)  {
  218.                     curmove (cturn == -1? 18: 19,0);
  219.                     proll ();
  220.                     writel ("\t\t");
  221.                 } else
  222.                     proll ();
  223.                 break;
  224.  
  225.             case 2:
  226.                 if (p[mvl] == -1)
  227.                     p[mvl] = c-'0';
  228.                 else
  229.                     p[mvl] = p[mvl]*10+c-'0';
  230.                 break;
  231.  
  232.             case 3:
  233.                 if (g[mvl] != -1)  {
  234.                     if (mvl < mvlim)
  235.                         mvl++;
  236.                     p[mvl] = p[mvl-1];
  237.                 }
  238.                 g[mvl] = p[mvl]+cturn*(c-'0');
  239.                 if (g[mvl] < 0)
  240.                     g[mvl] = 0;
  241.                 if (g[mvl] > 25)
  242.                     g[mvl] = 25;
  243.                 break;
  244.  
  245.             case 4:
  246.                 if (g[mvl] == -1)
  247.                     g[mvl] = c-'0';
  248.                 else
  249.                     g[mvl] = g[mvl]*10+c-'0';
  250.                 break;
  251.  
  252.             case 5:
  253.                 if (mvl < mvlim)
  254.                     mvl++;
  255.                 p[mvl] = g[mvl-1];
  256.                 break;
  257.  
  258.             case 6:
  259.                 if (mvl < mvlim)
  260.                     mvl++;
  261.                 break;
  262.  
  263.             case 7:
  264.                 if (tflag)
  265.                     curmove (20,0);
  266.                 else
  267.                     writec ('\n');
  268.                 text (help2);
  269.                 if (tflag)  {
  270.                     curmove (cturn == -1? 18: 19,39);
  271.                 } else  {
  272.                     writec ('\n');
  273.                     proll();
  274.                     writel ("\t\tMove:  ");
  275.                 }
  276.                 break;
  277.  
  278.             case 8:
  279.                 p[mvl] = bar;
  280.                 break;
  281.  
  282.             case 9:
  283.                 g[mvl] = home;
  284.             }
  285.  
  286.             if (! test || a != '\n')
  287.                 return (atmata[i].newst);
  288.             else
  289.                 return (-6);
  290.         }
  291.  
  292.         i++;
  293.     }
  294.  
  295.     return (-5);
  296. }
  297.  
  298. rsetbrd ()  {
  299.     register int    i, j, n;
  300.  
  301.     n = 0;
  302.     mvl = 0;
  303.     for (i = 0; i < 4; i++)
  304.         p[i] = g[i] = -1;
  305.     for (j = 0; j < ncin; j++)
  306.         n = dotable (cin[j],n);
  307.     return (n);
  308. }
  309.