* __P removal from games/
[dragonfly.git] / 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 }