DragonFlyBSD

SRCS=	allow.c board.c check.c extra.c fancy.c init.c main.c move.c \

	odds.c one.c save.c subs.c table.c text.c version.c

MAN=	backgammon.6

.PATH:	${.CURDIR}/../common_source

HIDEGAME=hidegame

.include "../../Makefile.inc"

.include <bsd.prog.mk>

FILE	*trace;

#endif

/*

 * dble()

 *	Have the current player double and ask opponent to accept.

 */

	int	resp;			/* response to y/n */

	for (;;)  {

		return;

	}

}

/*

 * dblgood ()

 *	Returns 1 if the computer would double in this position.  This

 * behind.

 */

	int	n;			/* accumulated judgment */

	int	OFFC = *offptr;		/* no. of computer's men off */

	int	OFFO = *offopp;		/* no. of player's men off */

		return(1);

	return (0);

}

{

	int		i, inc, lim;

		return ((36-count())/5);

	return (count()/5);

}

{

	int		i, j, k;

	int		c, l, ct;

	}

	return (ct/5);

}

	int		i, j;

	for (j = i = 0; i < 26; i++)

 */

#include <stdio.h>

#include <string.h>

#include <signal.h>

#include "back.h"

extern const char	*const instr[];		/* text of instructions */

extern const char	*const message[];	/* update message */

const char	*helpm[] = {			/* help message */

	"Enter a space or newline to roll, or",

static const char	password[] = "losfurng";

static char	pbuf[10];

{

	int	i;		/* non-descript index */

	int	l;		/* non-descript index */

	/* initialization */

	bflag = 2;					/* default no board */

	acnt = 1;                                       /* Nuber of args */

		errexit ("backgammon(gtty)");

	old = tty.sg_flags;

#ifdef V7

#else

	raw = ((noech = old & ~ECHO) | RAW);		/* set up modes */

#endif

							/* get terminal

							 * capabilities, and

							/* check if restored

							 * game and save flag

							 * for later */

		text (message);				/* print message */

		text (contin);

		wrboard();				/* print board */

					else

						writec ('\n');

					writel ("Password:");

					cflag = 1;

					alarm (10);

					for (i = 0; i < 10; i++)  {

							/* leave peacefully */

	getout ();

}

 * $DragonFly: src/games/backgammon/backgammon/move.c,v 1.2 2003/06/17 04:25:22 dillon Exp $

 */

#include "back.h"

#ifdef DEBUG

static char	tests[20];

#endif

struct BOARD  {				/* structure of game position */

	int	b_board[26];			/* board position */

	int	b_in[2];			/* men in */

struct BOARD *freeq = 0;

struct BOARD *checkq = 0;

					/* these variables are values for the

					 * candidate move */

static int	cg[5];				/* candidate finish position */

static int	race;				/* game reduced to a race */

{

	int	i;		/* index */

	if (okay)  {

						/* see if comp should double */

		if (gvalue < 64 && dlast != cturn && dblgood())  {

	}

	fixtty (raw);				/* no more tty interrupt */

}

{

	int	pos;			/* position on board */

	int	rval;			/* value of roll */

	if ((!swapped) && D0 != D1)

		trymove (0,1);

}

	int		i;		/* index */

	struct BOARD	*now;		/* current position */

	}

	return (now);

}

{

	int		result;			/* comparison result */

		return;

	}

	if (result < 0)  {				/* insert in front */

		checkq = new;

		return;

	}

	if (result == 0)  {				/* duplicate entry */

		makefree (new);

		return;

	}

		if (result < 0)  {			/* found place */

			return;

		}

		if (result == 0)  {			/* duplicate entry */

			makefree (new);

			return;

		}

	}

						/* place at end of queue */

	new->b_next = 0;

}

{

	int	*aloc = a->b_board;	/* pointer to board a */

	int	*bloc = b->b_board;	/* pointer to board b */

	}

	return (0);				/* same position */

}

{

	int		i;

	int		result;

		incumbent->b_fn[i] = candidate->b_fn[i];

	}

}

{

	dead->b_next = freeq;			/* add to freeq */

	freeq = dead;

}

	struct BOARD	*new;

	if (freeq == 0)  {

	}

	return (new);

}

						/* current game position */

	struct BOARD	*now = bsave();

	struct BOARD	*next;		/* next move */

	boardcopy (now);

}

{

	int	i;			/* index */

		g[i] = s->b_fn[i];

	}

}

	int	i;

#ifdef DEBUG

	if (trace == NULL)

	}

#endif

}

	int	n;

	if (*offptr == 15)

    "    Now you should be ready to begin the game.  Good luck!",

    "",

    0};

{

	int		i;

	const char	*s, *a;

#include "back.h"

	int		i, m, iold;

	int		r;

				g[i] = bar+cturn*D1;

			else

				g[i] = bar+cturn*D0;

				if (d0 || m == 4)

					break;

				swap;

 */

#include <sgtty.h>

#define rnum(r)	(random()%r)

#define D0	dice[0]

extern int	begscr;		/* 'beginning' of screen

				   (not including board) */

#include <string.h>

#include "back.h"

static int	i, j, k;

static char	ln[60];

	int	l;

	static const char	bl[] =

		"|                       |   |                       |\n";

	}

	fixtty(raw);

}

	int		m;

	char		d;

#include "back.h"

	int	i, c;

	c = 0;

		}

	}

}

{

	int	i, m;

 * $DragonFly: src/games/backgammon/common_source/fancy.c,v 1.3 2003/11/12 14:53:52 eirikn Exp $

 */

#include <string.h>

#include <termcap.h>

#include "back.h"

char	PC;			/* padding character */

char	*BC;			/* backspace sequence */

char	*CD;			/* clear to end of screen sequence */

int	realr;

int	realc;

	int	i, j, l;

	curmove (0,0);				/* do top line */

	oldr = (off[1] < 0? off[1]+15: off[1]);

	oldw = -(off[0] < 0? off[0]+15: off[0]);

}

/*

 * bsect (b,rpos,cpos,cnext)

 *	Print the contents of a board position.  "b" has the value of the

 * differently.

 */

{

	int		j;			/* index */

	int		n;			/* number of men on position */

	int		k;			/* index */

	char		pc;			/* color of men on position */

	n = abs(b);				/* initialize n and pc */

	pc = (b > 0? 'r': 'w');

		}

	}

}

	int	i, r, c;

	r = curr;				/* save current position */

	newpos();

	buflush();

}

{

	int		o, n, nv;

	int		ov, nc;

	char		col;

		nv = abs(new);

		o = (ov-1)/5;

		n = (nv-1)/5;

		if (o == n)  {

	}

	nv = abs(new);

	fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);

		return;

}

{

	int	i;

		fancyc (ch);

	}

}

{

	if (curr == r && curc == c)

		return;

	curc = c;

}

	int	r;		/* destination row */

	int	c;		/* destination column */

	int	mode = -1;	/* mode of movement */

	int	i;			/* index */

	int	n;			/* temporary variable */

	char	*m;			/* string containing CM movement */

	if (realr == -1)		/* see if already there */

		return;

	if (CM)  {			/* try CM to get there */

		mode = 0;

		m = (char *)tgoto (CM,c,r);

	}

					/* try HO and local movement */

		mode = 1;

	}

					/* try various LF combinations */

	if (r >= curr)  {

						/* CR, LF, and ND */

			mode = 2;

		}

						/* LF, ND */

			mode = 3;

		}

						/* LF, BS */

			mode = 4;

		}

	}

					/* try corresponding UP combinations */

	if (r < curr)  {

						/* CR, UP, and ND */

			mode = 5;

		}

						/* UP and ND */

			mode = 6;

		}

						/* UP and BS */

			mode = 7;

		}

	}

						/* space over */

		mode = 8;

	switch (mode)  {

	realr = -1;

	realc = -1;

}

	int	i;

					/* double space if can't clear */

	tputs (CL,CO,addbuf);		/* put CL in buffer */

}

{

	int	sp;		/* counts spaces in a tab */

					/* use cursor movement routine */

		curmove (curr,curc+1);

}

	if (CD)  {

		tputs (CD,CO-curr,addbuf);

	curmove (i,0);

}

	int	c;

	if (curc > linect[curr])

		return;

	}

}

	cline();

	if (curr == LI-1)

		curmove (begscr,0);

	else

		curmove (curr+1,0);

}

{

	char	*code;		/* two letter code */

	char	***cap;		/* pointer to cap string */

	char		*bufp;		/* pointer to cap buffer */

	char		tentry[1024];	/* temporary uncoded caps buffer */

	LI = tgetnum ("li");		/* get number of lines */

	if (LI == -1)

#include "back.h"

{

	int	i, j;

	}

}

	int	i;

	int	j;

	int	total;

			total += table[i][j];

	return (total);

}

{

	int	j, k, b;

	if (c == 0)

		odds (0,0,0);

#include "back.h"

{

	int	n, d;

	int		max;

	}

	return (0);

}

{

	int	j;

	movback (i);

}

{

	if (d0 != d)

		swap;

	return (0);

}

	int	i;

	for (i = home-6*cturn; i != home; i += cturn)

		if (board[i]*cturn > 0)

			return (abs(home-i));

}

{

	int	j;

		backone(j);

}

{

	board[p[i]] += cturn;

	if (g[i] != home)  {

#include <errno.h>

#include "back.h"

static const char	confirm[] = "Are you sure you want to leave now?";

static const char	prompt[] = "Enter a file name:  ";

static const char	exist1[] = "The file '";

static const char	rec[] = "\" to recover your game.\n\n";

static const char	cantrec[] = "Can't recover file:  ";

{

	int	fdesc;

	char	*fs;

		clend();

	getout ();

}

{

	int		fdesc;

	if ((fdesc = open (s,O_RDONLY)) == -1)

	rflag = 1;

}

{

	const char	*c;

 */

#include <stdio.h>

#include <string.h>

#include "back.h"

	0

};

{

	write (2,"\n",1);

	perror (s);

	getout();

}

{

	buffnum++;

	if (buffnum == BUFSIZ)  {

	return (0);

}

	if (buffnum < 0)

		return;

	buffnum++;

	buffnum = -1;

}

	char	c;

	if (tflag)  {

	return (c);

}

{

	if (tflag)

		fancyc (c);

}

void

{

#ifdef DEBUG

	const char	*s;

		writec (*l++);

}

	if (d0)

		swap;

	if (cturn == 1)

		cline();

}

{

	int	i, j, t;

	writec (n%10+'0');

}

	int	r, c;

	if (tflag)  {

		curmove (16,0);

	}

	}

}

	if (tflag)  {

		curmove (20,0);

		clend();

	return (0);

}

{

	char	c;

	int	i;

	return (c == 'Y');

}

{

	writel ("Blot hit on ");

	wrint (i);

	writec ('\n');

}

	int	c;

	cturn = -cturn;

	colorptr += c;

}

{

	char	ch;

	int i;

	/* process arguments here.  dashes are ignored, nbrw are ignored

		recover(argv[0]);

}

	int	i;

	for (i = 0; i < 26;)

		board[i++] = 0;

	dlast = 0;

}

	writel ("Score:  ");

	writel (color[1]);

	writec (' ');

	wrint (wscore);

}

{

	if (tflag)

		newpos();

	buflush();

	tty.sg_flags = mode;

		errexit("fixtty");

}

void

	/* go to bottom of screen */

	if (tflag)  {

		curmove (23,0);

	fixtty (old);

	exit(0);

}

	char	c;

	int	row;

	int	col;

	if (iroll)  {

		if (tflag)  {

			curmove (17,0);

		} else

			writec ('\n');

#include "back.h"

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.",

static const struct state	atmata[] = {

};

{

	int	j, n;

	char	c;

domove:

	if (ist == 0)  {

	writec ('\007');

	goto dochar;

}

{

	int		test;