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