Return to table.c CVS log

Up to [cvs.NetBSD.org] / src / games / backgammon / common_source

Pass the move info around instead of using it as a global.

/*	$NetBSD: table.c,v 1.13 2012/10/13 19:19:39 dholland Exp $	*/

/*
 * Copyright (c) 1980, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)table.c	8.1 (Berkeley) 5/31/93";
#else
__RCSID("$NetBSD: table.c,v 1.13 2012/10/13 19:19:39 dholland Exp $");
#endif
#endif /* not lint */

#include "back.h"

static const char *const 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;
};

static int mvl;			/* working copy of move->mvlim */

static const 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}
};

static int dotable(struct move *, int, int);
static int rsetbrd(struct move *);

int
checkmove(struct move *mm, int ist)
{
	int     j, n;
	char    c;

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++)
		mm->p[j] = mm->g[j] = -1;

dochar:
	c = readc();

	if (c == 'S') {
		raflag = 0;
		save(mm, 1);
		if (tflag) {
			curmove(cturn == -1 ? 18 : 19, 39);
			ist = -1;
			goto domove;
		} else {
			proll(mm);
			ist = 0;
			goto domove;
		}
	}
	if (c == old.c_cc[VERASE] && ncin > 0) {
		if (tflag)
			curmove(curr, curc - 1);
		else {
			if (old.c_cc[VERASE] == '\010')
				writel("\010 \010");
			else
				writec(cin[ncin - 1]);
		}
		ncin--;
		n = rsetbrd(mm);
		if (n == 0) {
			n = -1;
			if (tflag)
				refresh();
		}
		if ((ist = n) > 0)
			goto dochar;
		goto domove;
	}
	if (c == old.c_cc[VKILL] && ncin > 0) {
		if (tflag) {
			refresh();
			curmove(curr, 39);
			ist = -1;
			goto domove;
		} else
			if (old.c_cc[VERASE] == '\010') {
				for (j = 0; j < ncin; j++)
					writel("\010 \010");
				ist = -1;
				goto domove;
			} else {
				writec('\\');
				writec('\n');
				proll(mm);
				ist = 0;
				goto domove;
			}
	}
	n = dotable(mm, 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 >= mm->mvlim)
		return (0);
	if (n == -1 && mvl < mm->mvlim - 1)
		return (-4);

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

static int
dotable(struct move *mm, int c, int i)
{
	int     a;
	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(mm);
					writel("\t\t");
				} else
					proll(mm);
				break;

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

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

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

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

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

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

			case 8:
				mm->p[mvl] = bar;
				break;

			case 9:
				mm->g[mvl] = home;
			}

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

	return (-5);
}

static int
rsetbrd(struct move *mm)
{
	int     i, j, n;

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