games/backgammon/common_source/table.c

   1 /*
   2  * Copyright (c) 1980, 1993
   3  *      The Regents of the University of California.  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  * @(#)table.c  8.1 (Berkeley) 5/31/93
  34  * $FreeBSD: src/games/backgammon/common_source/table.c,v 1.5 1999/11/30 03:48:28 billf Exp $
  35  * $DragonFly: src/games/backgammon/common_source/table.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
  36  */
  37
  38 #include "back.h"
  39
  40 const char      *const 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 static const 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         int     j, n;
  83         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 \f
 201 dotable (c,i)
 202 char            c;
 203 int     i;
 204
 205 {
 206         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 \f
 298 rsetbrd ()  {
 299         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 }