summaryrefslogtreecommitdiffstats
path: root/backgammon/common_source
diff options
context:
space:
mode:
Diffstat (limited to 'backgammon/common_source')
-rw-r--r--backgammon/common_source/allow.c109
-rw-r--r--backgammon/common_source/back.h127
-rw-r--r--backgammon/common_source/backgammon.c751
-rw-r--r--backgammon/common_source/board.c176
-rw-r--r--backgammon/common_source/check.c158
-rw-r--r--backgammon/common_source/fancy.c748
-rw-r--r--backgammon/common_source/init.c65
-rw-r--r--backgammon/common_source/odds.c113
-rw-r--r--backgammon/common_source/one.c169
-rw-r--r--backgammon/common_source/save.c180
-rw-r--r--backgammon/common_source/subs.c477
-rw-r--r--backgammon/common_source/table.c308
12 files changed, 3381 insertions, 0 deletions
diff --git a/backgammon/common_source/allow.c b/backgammon/common_source/allow.c
new file mode 100644
index 00000000..2a7c9e0d
--- /dev/null
+++ b/backgammon/common_source/allow.c
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)allow.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+movallow () {
+
+ register int i, m, iold;
+ int r;
+
+ if (d0)
+ swap;
+ m = (D0 == D1? 4: 2);
+ for (i = 0; i < 4; i++)
+ p[i] = bar;
+ i = iold = 0;
+ while (i < m) {
+ if (*offptr == 15)
+ break;
+ h[i] = 0;
+ if (board[bar]) {
+ if (i == 1 || m == 4)
+ g[i] = bar+cturn*D1;
+ else
+ g[i] = bar+cturn*D0;
+ if (r = makmove(i)) {
+ if (d0 || m == 4)
+ break;
+ swap;
+ movback (i);
+ if (i > iold)
+ iold = i;
+ for (i = 0; i < 4; i++)
+ p[i] = bar;
+ i = 0;
+ } else
+ i++;
+ continue;
+ }
+ if ((p[i] += cturn) == home) {
+ if (i > iold)
+ iold = i;
+ if (m == 2 && i) {
+ movback(i);
+ p[i--] = bar;
+ if (p[i] != bar)
+ continue;
+ else
+ break;
+ }
+ if (d0 || m == 4)
+ break;
+ swap;
+ movback (i);
+ for (i = 0; i < 4; i++)
+ p[i] = bar;
+ i = 0;
+ continue;
+ }
+ if (i == 1 || m == 4)
+ g[i] = p[i]+cturn*D1;
+ else
+ g[i] = p[i]+cturn*D0;
+ if (g[i]*cturn > home) {
+ if (*offptr >= 0)
+ g[i] = home;
+ else
+ continue;
+ }
+ if (board[p[i]]*cturn > 0 && (r = makmove(i)) == 0)
+ i++;
+ }
+ movback (i);
+ return (iold > i? iold: i);
+}
diff --git a/backgammon/common_source/back.h b/backgammon/common_source/back.h
new file mode 100644
index 00000000..5bab6e55
--- /dev/null
+++ b/backgammon/common_source/back.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ *
+ * @(#)back.h 5.4 (Berkeley) 6/1/90
+ */
+
+#include <sgtty.h>
+
+#define rnum(r) (random()%r)
+#define D0 dice[0]
+#define D1 dice[1]
+#define swap {D0 ^= D1; D1 ^= D0; D0 ^= D1; d0 = 1-d0;}
+
+/*
+ *
+ * Some numerical conventions:
+ *
+ * Arrays have white's value in [0], red in [1].
+ * Numeric values which are one color or the other use
+ * -1 for white, 1 for red.
+ * Hence, white will be negative values, red positive one.
+ * This makes a lot of sense since white is going in decending
+ * order around the board, and red is ascending.
+ *
+ */
+
+char EXEC[]; /* object for main program */
+char TEACH[]; /* object for tutorial program */
+
+int pnum; /* color of player:
+ -1 = white
+ 1 = red
+ 0 = both
+ 2 = not yet init'ed */
+char args[100]; /* args passed to teachgammon and back */
+int acnt; /* length of args */
+int aflag; /* flag to ask for rules or instructions */
+int bflag; /* flag for automatic board printing */
+int cflag; /* case conversion flag */
+int hflag; /* flag for cleaning screen */
+int mflag; /* backgammon flag */
+int raflag; /* 'roll again' flag for recovered game */
+int rflag; /* recovered game flag */
+int tflag; /* cursor addressing flag */
+int rfl; /* saved value of rflag */
+int iroll; /* special flag for inputting rolls */
+int board[26]; /* board: negative values are white,
+ positive are red */
+int dice[2]; /* value of dice */
+int mvlim; /* 'move limit': max. number of moves */
+int mvl; /* working copy of mvlim */
+int p[5]; /* starting position of moves */
+int g[5]; /* ending position of moves (goals) */
+int h[4]; /* flag for each move if a man was hit */
+int cturn; /* whose turn it currently is:
+ -1 = white
+ 1 = red
+ 0 = just quitted
+ -2 = white just lost
+ 2 = red just lost */
+int d0; /* flag if dice have been reversed from
+ original position */
+int table[6][6]; /* odds table for possible rolls */
+int rscore; /* red's score */
+int wscore; /* white's score */
+int gvalue; /* value of game (64 max.) */
+int dlast; /* who doubled last (0 = neither) */
+int bar; /* position of bar for current player */
+int home; /* position of home for current player */
+int off[2]; /* number of men off board */
+int *offptr; /* pointer to off for current player */
+int *offopp; /* pointer to off for opponent */
+int in[2]; /* number of men in inner table */
+int *inptr; /* pointer to in for current player */
+int *inopp; /* pointer to in for opponent */
+
+int ncin; /* number of characters in cin */
+char cin[100]; /* input line of current move
+ (used for reconstructing input after
+ a backspace) */
+
+char *color[];
+ /* colors as strings */
+char **colorptr; /* color of current player */
+char **Colorptr; /* color of current player, capitalized */
+int colen; /* length of color of current player */
+
+struct sgttyb tty; /* tty information buffer */
+int old; /* original tty status */
+int noech; /* original tty status without echo */
+int raw; /* raw tty status, no echo */
+
+int curr; /* row position of cursor */
+int curc; /* column position of cursor */
+int begscr; /* 'beginning' of screen
+ (not including board) */
+
+int getout(); /* function to exit backgammon cleanly */
diff --git a/backgammon/common_source/backgammon.c b/backgammon/common_source/backgammon.c
new file mode 100644
index 00000000..036301f4
--- /dev/null
+++ b/backgammon/common_source/backgammon.c
@@ -0,0 +1,751 @@
+/*-
+ * Copyright (c) 1991 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)backgammon.c 5.1 (Berkeley) 4/8/91";
+#endif /* not lint */
+
+/*
+** The game of Backgammon
+*/
+
+#include <stdio.h>
+
+#define WHITE 0
+#define BROWN 1
+#define NIL (-1)
+#define MAXGMOV 10
+#define MAXIMOVES 1000
+#define RULES "/usr/games/lib/backrules"
+
+char level; /*'b'=beginner, 'i'=intermediate, 'e'=expert*/
+
+int die1;
+int die2;
+int i;
+int j;
+int l;
+int m;
+int pflg = 1;
+int nobroll = 0;
+int count;
+int imoves;
+int goodmoves[MAXGMOV];
+int probmoves[MAXGMOV];
+
+int brown[] = { /* brown position table */
+ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 0, 0, 0, 0, 3, 0, 5, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0
+};
+
+int white[] = { /* white position table */
+ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
+ 0, 0, 0, 0, 3, 0, 5, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0
+};
+
+int probability[] = {
+ 0, 11, 12, 13, 14, 15, 16,
+ 06, 05, 04, 03, 02, 01
+};
+
+struct {
+ int pos[4];
+ int mov[4];
+} moves[MAXIMOVES];
+
+main()
+{
+ int go[5], tvec[2];
+ int k, n, pid, ret, rpid, t;
+ char s[100];
+
+ srand(time(0));
+ go[5] = NIL;
+ fprintf(stdout, "Instructions? ");
+ gets(s);
+ if(*s == 'y')
+ instructions();
+ putchar('\n');
+ fprintf(stdout, "Opponent's level: b - beginner,\n");
+ fprintf(stdout, "i - intermediate, e - expert? ");
+ level='e';
+ gets(s);
+ if(*s == 'b')
+ level = 'b';
+ else if(*s == 'i')
+ level = 'i';
+ putchar('\n');
+ fprintf(stdout, "You will play brown.\n\n");
+ fprintf(stdout, "Would you like to roll your own dice? ");
+ gets(s);
+ putchar('\n');
+ if(*s == 'y')
+ nobroll = 1;
+ fprintf(stdout, "Would you like to go first? ");
+ gets(s);
+ putchar('\n');
+ if(*s == 'y')
+ goto nowhmove;
+whitesmv:
+ roll(WHITE);
+ fprintf(stdout, "white rolls %d, %d\n", die1, die2);
+ fprintf(stdout, "white's move is:");
+ if(nextmove(white, brown) == NIL)
+ goto nowhmove;
+ if(piececount(white, 0, 24) == 0){
+ fprintf(stdout, "White wins");
+ if(piececount(brown, 0, 6) != 0)
+ fprintf(stdout, " with a Backgammon!\n");
+ else if (piececount(brown, 0, 24) == 24)
+ fprintf(stdout, " with a Gammon.\n");
+ else
+ fprintf(stdout, ".\n");
+ exit(0);
+ }
+nowhmove:
+ if(pflg)
+ prtbrd();
+ roll(BROWN);
+retry:
+ fprintf(stdout, "\nYour roll is %d %d\n", die1, die2);
+ fprintf(stdout, "Move? ");
+ gets(s);
+ switch(*s) {
+ case '\0': /* empty line */
+ fprintf(stdout, "Brown's move skipped.\n");
+ goto whitesmv;
+
+ case 'b': /* how many beared off? */
+ fprintf(stdout, "Brown: %d\n", piececount(brown, 0, 24) - 15);
+ fprintf(stdout, "White: %d\n", piececount(white, 0, 24) - 15);
+ goto retry;
+
+ case 'p': /* print board */
+ prtbrd();
+ goto retry;
+
+ case 's': /* stop auto printing of board */
+ pflg = 0;
+ goto retry;
+
+ case 'r': /* resume auto printing */
+ pflg = 1;
+ goto retry;
+
+ case 'm': /* print possible moves */
+ pmoves();
+ goto retry;
+
+ case 'q': /* i give up */
+ exit(0);
+
+ case '!': /* escape to Shell */
+ if(s[1] != '\0')
+ system(s+1);
+ else if((pid = fork()) == 0) {
+ execl("/bin/sh", "sh", "-", 0);
+ fprintf(stderr, "back: cannot exec /bin/sh!\n");
+ exit(2);
+ }
+ while((rpid = wait(&ret)) != pid && rpid != -1)
+ ;
+ goto retry;
+
+ case '?': /* well, what can i do? */
+ fprintf(stdout, "<newline> skip this move\n");
+ fprintf(stdout, "b number beared off\n");
+ fprintf(stdout, "p print board\n");
+ fprintf(stdout, "q quit\n");
+ fprintf(stdout, "r resume auto print of board\n");
+ fprintf(stdout, "s stop auto print of board\n");
+ fprintf(stdout, "! escape to Shell\n");
+ goto retry;
+ }
+ n = sscanf(s,"%d%d%d%d%d",&go[0],&go[1],&go[2],&go[3],&go[4]);
+ if((die1 != die2 && n > 2) || n > 4){
+ fprintf(stdout, "Too many moves.\n");
+ goto retry;
+ }
+ go[n] = NIL;
+ if(*s=='-'){
+ go[0]= -go[0];
+ t=die1;
+ die1=die2;
+ die2=t;
+ }
+ for(k = 0; k < n; k++){
+ if(0 <= go[k] && go[k] <= 24)
+ continue;
+ else{
+ fprintf(stdout, "Move %d illegal.\n", go[k]);
+ goto retry;
+ }
+ }
+ if(play(brown, white, go))
+ goto retry;
+ if(piececount(brown, 0, 24) == 0){
+ fprintf(stdout, "Brown wins");
+ if(piececount(white, 0, 6) != 0)
+ fprintf(stdout, " with a Backgammon.\n");
+ else if(piececount(white, 0, 24) == 24)
+ fprintf(stdout, " with a gammon.\n");
+ else
+ fprintf(stdout, ".\n");
+ exit(0);
+ }
+ goto whitesmv;
+}
+
+play(player,playee,pos)
+int *player,*playee,pos[];
+{
+ int k, n, die, ipos;
+
+ for(k=0; k < player[0]; k++){ /*blots on player[0] must be moved first*/
+ if(pos[k] == NIL)
+ break;
+ if(pos[k] != 0){
+ fprintf(stdout, "Stone on bar must be moved first.\n");
+ return(NIL);
+ }
+ }
+ for(k = 0; (ipos=pos[k]) != NIL; k++){
+ die = k?die2:die1;
+ n = 25-ipos-die;
+ if(player[ipos] == 0)
+ goto badmove;
+ if(n > 0 && playee[n] >= 2)
+ goto badmove;
+ if(n <= 0){
+ if(piececount(player,0,18) != 0)
+ goto badmove;
+ if((ipos+die) != 25 && piececount(player,19,24-die)!=0)
+ goto badmove;
+ }
+ player[ipos]--;
+ player[ipos+die]++;
+ }
+ for(k = 0; pos[k] != NIL; k++){
+ die = k?die2:die1;
+ n = 25-pos[k]-die;
+ if(n>0 && playee[n]==1){
+ playee[n]=0;
+ playee[0]++;
+ }
+ }
+ return(0);
+
+badmove:
+ fprintf(stdout, "Move %d illegal.\n", ipos);
+ while(k--){
+ die=k?die2:die1;
+ player[pos[k]]++;
+ player[pos[k]+die]--;
+ }
+ return(NIL);
+}
+nextmove(player,playee)
+int *player,*playee;
+{
+ int k;
+
+ imoves=0;
+ movegen(player,playee);
+ if(die1!=die2){
+ k=die1;
+ die1=die2;
+ die2=k;
+ movegen(player,playee);
+ }
+ if(imoves==0){
+ fprintf(stdout, "no move possible.\n");
+ return(NIL);
+ }
+ k=strategy(player,playee); /*select kth possible move*/
+ prtmov(k);
+ update(player,playee,k);
+ return(0);
+}
+prtmov(k)
+int k;
+{
+ int n;
+
+ if(k == NIL)
+ fprintf(stdout, "No move possible\n");
+ else for(n = 0; n < 4; n++){
+ if(moves[k].pos[n] == NIL)
+ break;
+ fprintf(stdout, " %d, %d",25-moves[k].pos[n],moves[k].mov[n]);
+ }
+ fprintf(stdout, "\n");
+}
+update(player,playee,k)
+int *player,*playee,k;
+{
+ int n,t;
+
+ for(n = 0; n < 4; n++){
+ if(moves[k].pos[n] == NIL)
+ break;
+ player[moves[k].pos[n]]--;
+ player[moves[k].pos[n]+moves[k].mov[n]]++;
+ t=25-moves[k].pos[n]-moves[k].mov[n];
+ if(t>0 && playee[t]==1){
+ playee[0]++;
+ playee[t]--;
+ }
+ }
+}
+piececount(player,startrow,endrow)
+int *player,startrow,endrow;
+{
+ int sum;
+
+ sum=0;
+ while(startrow <= endrow)
+ sum += player[startrow++];
+ return(sum);
+}
+pmoves()
+{
+ int i1, i2;
+
+ fprintf(stdout, "Possible moves are:\n");
+ for(i1 = 0; i1 < imoves; i1++){
+ fprintf(stdout, "\n%d",i1);
+ for (i2 = 0; i2<4; i2++){
+ if(moves[i1].pos[i2] == NIL)
+ break;
+ fprintf(stdout, "%d, %d",moves[i1].pos[i2],moves[i1].mov[i2]);
+ }
+ }
+ fprintf(stdout, "\n");
+}
+
+roll(who)
+{
+ register n;
+ char s[10];
+
+ if(who == BROWN && nobroll) {
+ fprintf(stdout, "Roll? ");
+ gets(s);
+ n = sscanf(s, "%d%d", &die1, &die2);
+ if(n != 2 || die1 < 1 || die1 > 6 || die2 < 1 || die2 > 6)
+ fprintf(stdout, "Illegal - I'll do it!\n");
+ else
+ return;
+ }
+ die1 = ((rand()>>8) % 6) + 1;
+ die2 = ((rand()>>8) % 6) + 1;
+}
+
+movegen(mover,movee)
+int *mover,*movee;
+{
+ int k;
+
+ for(i = 0; i <= 24; i++){
+ count = 0;
+ if(mover[i] == 0)
+ continue;
+ if((k=25-i-die1) > 0 && movee[k] >= 2)
+ if(mover[0] > 0)
+ break;
+ else
+ continue;
+ if(k <= 0){
+ if(piececount(mover, 0, 18) != 0)
+ break;
+ if((i+die1) != 25 && piececount(mover,19,i-1) != 0)
+ break;
+ }
+ mover[i]--;
+ mover[i+die1]++;
+ count = 1;
+ for(j = 0; j <= 24; j++){
+ if(mover[j]==0)
+ continue;
+ if((k=25-j-die2) > 0 && movee[k] >= 2)
+ if(mover[0] > 0)
+ break;
+ else
+ continue;
+ if(k <= 0){
+ if(piececount(mover,0,18) != 0)
+ break;
+ if((j+die2) != 25 && piececount(mover,19,j-1) != 0)
+ break;
+ }
+ mover[j]--;
+ mover[j+die2]++;
+ count = 2;
+ if(die1 != die2){
+ moverecord(mover);
+ if(mover[0] > 0)
+ break;
+ else
+ continue;
+ }
+ for(l = 0; l <= 24; l++){
+ if(mover[l] == 0)
+ continue;
+ if((k=25-l-die1) > 0 && movee[k] >= 2)
+ if(mover[0] > 0)
+ break;
+ else
+ continue;
+ if(k <= 0){
+ if(piececount(mover, 0, 18) != 0)
+ break;
+ if((l+die2) != 25 && piececount(mover,19,l-1) != 0)
+ break;
+ }
+ mover[l]--;
+ mover[l+die1]++;
+ count=3;
+ for(m=0;m<=24;m++){
+ if(mover[m]==0)
+ continue;
+ if((k=25-m-die1) >= 0 && movee[k] >= 2)
+ if(mover[0] > 0)
+ break;
+ else
+ continue;
+ if(k <= 0){
+ if(piececount(mover,0,18) != 0)
+ break;
+ if((m+die2) != 25 && piececount(mover,19,m-1) != 0)
+ break;
+ }
+ count=4;
+ moverecord(mover);
+ if(mover[0] > 0)
+ break;
+ }
+ if(count == 3)
+ moverecord(mover);
+ else{
+ mover[l]++;
+ mover[l+die1]--;
+ }
+ if(mover[0] > 0)
+ break;
+ }
+ if(count == 2)
+ moverecord(mover);
+ else{
+ mover[j]++;
+ mover[j+die1]--;
+ }
+ if(mover[0] > 0)
+ break;
+ }
+ if(count == 1)
+ moverecord(mover);
+ else{
+ mover[i]++;
+ mover[i+die1]--;
+ }
+ if(mover[0] > 0)
+ break;
+ }
+}
+moverecord(mover)
+int *mover;
+{
+ int t;
+
+ if(imoves < MAXIMOVES) {
+ for(t = 0; t <= 3; t++)
+ moves[imoves].pos[t] = NIL;
+ switch(count) {
+ case 4:
+ moves[imoves].pos[3]=m;
+ moves[imoves].mov[3]=die1;
+
+ case 3:
+ moves[imoves].pos[2]=l;
+ moves[imoves].mov[2]=die1;
+
+ case 2:
+ moves[imoves].pos[1]=j;
+ moves[imoves].mov[1]=die2;
+
+ case 1:
+ moves[imoves].pos[0]=i;
+ moves[imoves].mov[0]=die1;
+ imoves++;
+ }
+ }
+ switch(count) {
+ case 4:
+ break;
+
+ case 3:
+ mover[l]++;
+ mover[l+die1]--;
+ break;
+
+ case 2:
+ mover[j]++;
+ mover[j+die2]--;
+ break;
+
+ case 1:
+ mover[i]++;
+ mover[i+die1]--;
+ }
+}
+
+strategy(player,playee)
+int *player,*playee;
+{
+ int k, n, nn, bestval, moveval, prob;
+
+ n = 0;
+ if(imoves == 0)
+ return(NIL);
+ goodmoves[0] = NIL;
+ bestval = -32000;
+ for(k = 0; k < imoves; k++){
+ if((moveval=eval(player,playee,k,&prob)) < bestval)
+ continue;
+ if(moveval > bestval){
+ bestval = moveval;
+ n = 0;
+ }
+ if(n<MAXGMOV){
+ goodmoves[n]=k;
+ probmoves[n++]=prob;
+ }
+ }
+ if(level=='e' && n>1){
+ nn=n;
+ n=0;
+ prob=32000;
+ for(k = 0; k < nn; k++){
+ if((moveval=probmoves[k]) > prob)
+ continue;
+ if(moveval<prob){
+ prob=moveval;
+ n=0;
+ }
+ goodmoves[n]=goodmoves[k];
+ probmoves[n++]=probmoves[k];
+ }
+ }
+ return(goodmoves[(rand()>>4)%n]);
+}
+
+eval(player,playee,k,prob)
+int *player,*playee,k,*prob;
+{
+ int newtry[31], newother[31], *r, *q, *p, n, sum, first;
+ int ii, lastwhite, lastbrown;
+
+ *prob = sum = 0;
+ r = player+25;
+ p = newtry;
+ q = newother;
+ while(player<r){
+ *p++= *player++;
+ *q++= *playee++;
+ }
+ q=newtry+31;
+ for(p = newtry+25; p < q; p++) /* zero out spaces for hit pieces */
+ *p = 0;
+ for(n = 0; n < 4; n++){
+ if(moves[k].pos[n] == NIL)
+ break;
+ newtry[moves[k].pos[n]]--;
+ newtry[ii=moves[k].pos[n]+moves[k].mov[n]]++;
+ if(ii<25 && newother[25-ii]==1){
+ newother[25-ii]=0;
+ newother[0]++;
+ if(ii<=15 && level=='e') /* hit if near other's home */
+ sum++;
+ }
+ }
+ for(lastbrown = 0; newother[lastbrown] == 0; lastbrown++);
+ ;
+ for(lastwhite = 0; newtry[lastwhite] == 0; lastwhite++)
+ ;
+ lastwhite = 25-lastwhite;
+ if(lastwhite<=6 && lastwhite<lastbrown)
+ sum=1000;
+ /* experts running game. */
+ /* first priority is to */
+ /* get all pieces into */
+ /* white's home */
+ if(lastwhite<lastbrown && level=='e' && lastwhite>6) {
+ for(sum = 1000; lastwhite > 6; lastwhite--)
+ sum = sum-lastwhite*newtry[25-lastwhite];
+ }
+ for(first = 0; first < 25; first++)
+ if(newother[first] != 0) /*find other's first piece*/
+ break;
+ q = newtry+25;
+ for(p = newtry+1; p < q;) /* blocked points are good */
+ if(*p++ > 1)
+ sum++;
+ if(first > 5) { /* only stress removing pieces if */
+ /* homeboard cannot be hit */
+ q = newtry+31;
+ p=newtry+25;
+ for(n = 6; p < q; n--)
+ sum += *p++ * n; /*remove pieces, but just barely*/
+ }
+ if(level != 'b'){
+ r = newtry+25-first; /*singles past this point can't be hit*/
+ for(p = newtry+7; p < r; )
+ if(*p++ == 1) /*singles are bad after 1st 6 points if they can be hit*/
+ sum--;
+ q = newtry+3;
+ for(p = newtry; p < q; ) /*bad to be on 1st three points*/
+ sum -= *p++;
+ }
+
+ for(n = 1; n <= 4; n++)
+ *prob += n*getprob(newtry,newother,6*n-5,6*n);
+ return(sum);
+}
+instructions()
+{
+ register fd, r;
+ char buf[BUFSIZ];
+
+ if((fd = open(RULES, 0)) < 0) {
+ fprintf(stderr, "back: cannot open %s\n", RULES);
+ return;
+ }
+ while(r = read(fd, buf, BUFSIZ))
+ write(1, buf, r);
+}
+
+getprob(player,playee,start,finish)
+int *player,*playee,start,finish;
+{ /*returns the probability (times 102) that any
+ pieces belonging to 'player' and lying between
+ his points 'start' and 'finish' will be hit
+ by a piece belonging to playee
+ */
+ int k, n, sum;
+
+ sum = 0;
+ for(; start <= finish; start++){
+ if(player[start] == 1){
+ for(k = 1; k <= 12; k++){
+ if((n=25-start-k) < 0)
+ break;
+ if(playee[n] != 0)
+ sum += probability[k];
+ }
+ }
+ }
+ return(sum);
+}
+prtbrd()
+{
+ int k;
+ static char undersc[]="______________________________________________________";
+
+ fprintf(stdout, "White's Home\n%s\r",undersc);
+ for(k = 1; k <= 6; k++)
+ fprintf(stdout, "%4d",k);
+ fprintf(stdout, " ");
+ for(k = 7; k <= 12; k++)
+ fprintf(stdout, "%4d",k);
+ putchar('\n');
+ numline(brown, white, 1, 6);
+ fprintf(stdout, " ");
+ numline(brown, white, 7, 12);
+ putchar('\n');
+ colorline(brown, 'B', white, 'W', 1, 6);
+ fprintf(stdout, " ");
+ colorline(brown, 'B', white, 'W', 7, 12);
+ putchar('\n');
+ if(white[0] != 0)
+ fprintf(stdout, "%28dW\n",white[0]);
+ else
+ putchar('\n');
+ if(brown[0] != 0)
+ fprintf(stdout, "%28dB\n", brown[0]);
+ else
+ putchar('\n');
+ colorline(white, 'W', brown, 'B', 1, 6);
+ fprintf(stdout, " ");
+ colorline(white, 'W', brown, 'B', 7, 12);
+ fprintf(stdout, "\n%s\r",undersc);
+ numline(white, brown, 1, 6);
+ fprintf(stdout, " ");
+ numline(white, brown, 7, 12);
+ putchar('\n');
+ for(k = 24; k >= 19; k--)
+ fprintf(stdout, "%4d",k);
+ fprintf(stdout, " ");
+ for(k = 18; k >= 13; k--)
+ fprintf(stdout, "%4d",k);
+ fprintf(stdout, "\nBrown's Home\n\n\n\n\n");
+}
+numline(upcol,downcol,start,fin)
+int *upcol,*downcol,start,fin;
+{
+ int k, n;
+
+ for(k = start; k <= fin; k++){
+ if((n = upcol[k]) != 0 || (n = downcol[25-k]) != 0)
+ fprintf(stdout, "%4d", n);
+ else
+ fprintf(stdout, " ");
+ }
+}
+colorline(upcol,c1,downcol,c2,start,fin)
+int *upcol,*downcol,start,fin;
+char c1,c2;
+{
+ int k;
+ char c;
+
+ for(k = start; k <= fin; k++){
+ c = ' ';
+ if(upcol[k] != 0)
+ c = c1;
+ if(downcol[25-k] != 0)
+ c = c2;
+ fprintf(stdout, " %c",c);
+ }
+}
diff --git a/backgammon/common_source/board.c b/backgammon/common_source/board.c
new file mode 100644
index 00000000..d21d36a9
--- /dev/null
+++ b/backgammon/common_source/board.c
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)board.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+static int i, j, k;
+static char ln[60];
+
+wrboard () {
+ register int l;
+ static char bl[] =
+ "| | | |\n";
+ static char sv[] =
+ "| | | | \n";
+
+ fixtty (noech);
+ clear();
+
+ if (tflag) {
+ fboard();
+ goto lastline;
+ }
+
+ writel ("_____________________________________________________\n");
+ writel (bl);
+ strcpy (ln,bl);
+ for (j = 1; j < 50; j += 4) {
+ k = j/4+(j > 24? 12: 13);
+ ln[j+1] = k%10+'0';
+ ln[j] = k/10+'0';
+ if (j == 21)
+ j += 4;
+ }
+ writel (ln);
+ for (i = 0; i < 5; i++) {
+ strcpy (ln,sv);
+ for (j = 1; j < 50; j += 4) {
+ k = j/4+(j > 24? 12: 13);
+ wrbsub ();
+ if (j == 21)
+ j += 4;
+ }
+ if (-board[25] > i)
+ ln[26] = 'w';
+ if (-board[25] > i+5)
+ ln[25] = 'w';
+ if (-board[25] > i+10)
+ ln[27] = 'w';
+ l = 53;
+ if (off[1] > i || (off[1] < 0 && off[1]+15 > i)) {
+ ln[54] = 'r';
+ l = 55;
+ }
+ if (off[1] > i+5 || (off[1] < 0 && off[1]+15 > i+5)) {
+ ln[55] = 'r';
+ l = 56;
+ }
+ if (off[1] > i+10 || (off[1] < 0 && off[1]+15 > i+10)) {
+ ln[56] = 'r';
+ l = 57;
+ }
+ ln[l++] = '\n';
+ ln[l] = '\0';
+ writel (ln);
+ }
+ strcpy (ln,bl);
+ ln[25] = 'B';
+ ln[26] = 'A';
+ ln[27] = 'R';
+ writel (ln);
+ strcpy (ln,sv);
+ for (i = 4; i > -1; i--) {
+ for (j = 1; j < 50; j += 4) {
+ k = ((j > 24? 53: 49)-j)/4;
+ wrbsub();
+ if (j == 21)
+ j += 4;
+ }
+ if (board[0] > i)
+ ln[26] = 'r';
+ if (board[0] > i+5)
+ ln[25] = 'r';
+ if (board[0] > i+10)
+ ln[27] = 'r';
+ l = 53;
+ if (off[0] > i || (off[0] < 0 && off[0]+15 > i)) {
+ ln[54] = 'w';
+ l = 55;
+ }
+ if (off[0] > i+5 || (off[0] < 0 && off[0]+15 > i+5)) {
+ ln[55] = 'w';
+ l = 56;
+ }
+ if (off[0] > i+10 || (off[0] < 0 && off[0]+15 > i+10)) {
+ ln[56] = 'w';
+ l = 57;
+ }
+ ln[l++] = '\n';
+ ln[l] = '\0';
+ writel (ln);
+ }
+ strcpy (ln,bl);
+ for (j = 1; j < 50; j += 4) {
+ k = ((j > 24? 53: 49)-j)/4;
+ ln[j+1] = k%10+'0';
+ if (k > 9)
+ ln[j] = k/10+'0';
+ if (j == 21)
+ j += 4;
+ }
+ writel (ln);
+ writel ("|_______________________|___|_______________________|\n");
+
+lastline:
+ gwrite ();
+ if (tflag)
+ curmove (18,0);
+ else {
+ writec ('\n');
+ writec ('\n');
+ }
+ fixtty(raw);
+}
+
+wrbsub () {
+ register int m;
+ register char d;
+
+ if (board[k] > 0) {
+ m = board[k];
+ d = 'r';
+ } else {
+ m = -board[k];
+ d = 'w';
+ }
+ if (m>i)
+ ln[j+1] = d;
+ if (m>i+5)
+ ln[j] = d;
+ if (m>i+10)
+ ln[j+2] = d;
+}
diff --git a/backgammon/common_source/check.c b/backgammon/common_source/check.c
new file mode 100644
index 00000000..5ef2eb2b
--- /dev/null
+++ b/backgammon/common_source/check.c
@@ -0,0 +1,158 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)check.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+getmove () {
+ register int i, c;
+
+ c = 0;
+ for (;;) {
+ i = checkmove(c);
+
+ switch (i) {
+ case -1:
+ if (movokay(mvlim)) {
+ if (tflag)
+ curmove (20,0);
+ else
+ writec ('\n');
+ for (i = 0; i < mvlim; i++)
+ if (h[i])
+ wrhit(g[i]);
+ nexturn();
+ if (*offopp == 15)
+ cturn *= -2;
+ if (tflag && pnum)
+ bflag = pnum;
+ return;
+ }
+
+ case -4:
+ case 0:
+ if (tflag)
+ refresh();
+ if (i != 0 && i != -4)
+ break;
+ if (tflag)
+ curmove (20,0);
+ else
+ writec ('\n');
+ writel (*Colorptr);
+ if (i == -4)
+ writel (" must make ");
+ else
+ writel (" can only make ");
+ writec (mvlim+'0');
+ writel (" move");
+ if (mvlim > 1)
+ writec ('s');
+ writec ('.');
+ writec ('\n');
+ break;
+
+ case -3:
+ if (quit())
+ return;
+ }
+
+ if (! tflag)
+ proll ();
+ else {
+ curmove (cturn == -1? 18: 19,39);
+ cline ();
+ c = -1;
+ }
+ }
+}
+
+movokay (mv)
+register int mv;
+
+{
+ register int i, m;
+
+ if (d0)
+ swap;
+
+ for (i = 0; i < mv; i++) {
+
+ if (p[i] == g[i]) {
+ moverr (i);
+ curmove (20,0);
+ writel ("Attempt to move to same location.\n");
+ return (0);
+ }
+
+ if (cturn*(g[i]-p[i]) < 0) {
+ moverr (i);
+ curmove (20,0);
+ writel ("Backwards move.\n");
+ return (0);
+ }
+
+ if (abs(board[bar]) && p[i] != bar) {
+ moverr (i);
+ curmove (20,0);
+ writel ("Men still on bar.\n");
+ return (0);
+ }
+
+ if ( (m = makmove(i)) ) {
+ moverr (i);
+ switch (m) {
+
+ case 1:
+ writel ("Move not rolled.\n");
+ break;
+
+ case 2:
+ writel ("Bad starting position.\n");
+ break;
+
+ case 3:
+ writel ("Destination occupied.\n");
+ break;
+
+ case 4:
+ writel ("Can't remove men yet.\n");
+ }
+ return (0);
+ }
+ }
+ return (1);
+}
diff --git a/backgammon/common_source/fancy.c b/backgammon/common_source/fancy.c
new file mode 100644
index 00000000..6afaa367
--- /dev/null
+++ b/backgammon/common_source/fancy.c
@@ -0,0 +1,748 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)fancy.c 5.5 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+char PC; /* padding character */
+char *BC; /* backspace sequence */
+char *CD; /* clear to end of screen sequence */
+char *CE; /* clear to end of line sequence */
+char *CL; /* clear screen sequence */
+char *CM; /* cursor movement instructions */
+char *HO; /* home cursor sequence */
+char *MC; /* column cursor movement map */
+char *ML; /* row cursor movement map */
+char *ND; /* forward cursor sequence */
+char *UP; /* up cursor sequence */
+
+int lHO; /* length of HO */
+int lBC; /* length of BC */
+int lND; /* length of ND */
+int lUP; /* length of UP */
+int CO; /* number of columns */
+int LI; /* number of lines */
+int *linect; /* array of lengths of lines on screen
+ (the actual screen is not stored) */
+
+ /* two letter codes */
+char tcap[] = "bccdceclcmhomcmlndup";
+ /* corresponding strings */
+char **tstr[] = { &BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP };
+
+int buffnum; /* pointer to output buffer */
+
+char tbuf[1024]; /* buffer for decoded termcap entries */
+
+int oldb[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+int oldr;
+int oldw;
+ /* "real" cursor positions, so
+ * it knows when to reposition.
+ * These are -1 if curr and curc
+ * are accurate */
+int realr;
+int realc;
+
+void addbuf();
+
+fboard () {
+ register int i, j, l;
+
+ curmove (0,0); /* do top line */
+ for (i = 0; i < 53; i++)
+ fancyc ('_');
+
+ curmove (15,0); /* do botttom line */
+ for (i = 0; i < 53; i++)
+ fancyc ('_');
+
+ l = 1; /* do vertical lines */
+ for (i = 52; i > -1; i -= 28) {
+ curmove ( (l == 1? 1: 15) ,i);
+ fancyc ('|');
+ for (j = 0; j < 14; j++) {
+ curmove (curr+l,curc-1);
+ fancyc ('|');
+ }
+ if (i == 24)
+ i += 32;
+ l = -l; /* alternate directions */
+ }
+
+ curmove (2,1); /* label positions 13-18 */
+ for (i = 13; i < 18; i++) {
+ fancyc ('1');
+ fancyc ((i % 10)+'0');
+ curmove (curr,curc+2);
+ }
+ fancyc ('1');
+ fancyc ('8');
+
+ curmove (2,29); /* label positions 19-24 */
+ fancyc ('1');
+ fancyc ('9');
+ for (i = 20; i < 25; i++) {
+ curmove (curr,curc+2);
+ fancyc ('2');
+ fancyc ((i % 10)+'0');
+ }
+
+ curmove (14,1); /* label positions 12-7 */
+ fancyc ('1');
+ fancyc ('2');
+ for (i = 11; i > 6; i--) {
+ curmove (curr,curc+2);
+ fancyc (i > 9? '1': ' ');
+ fancyc ((i % 10)+'0');
+ }
+
+ curmove (14,30); /* label positions 6-1 */
+ fancyc ('6');
+ for (i = 5; i > 0; i--) {
+ curmove (curr,curc+3);
+ fancyc (i+'0');
+ }
+
+ for (i = 12; i > 6; i--) /* print positions 12-7 */
+ if (board[i])
+ bsect (board[i],13,1+4*(12-i),-1);
+
+ if (board[0]) /* print red men on bar */
+ bsect (board[0],13,25,-1);
+
+ for (i = 6; i > 0; i--) /* print positions 6-1 */
+ if (board[i])
+ bsect (board[i],13,29+4*(6-i),-1);
+
+ l = (off[1] < 0? off[1]+15: off[1]); /* print white's home */
+ bsect (l,3,54,1);
+
+ curmove (8,25); /* print the word BAR */
+ fancyc ('B');
+ fancyc ('A');
+ fancyc ('R');
+
+ for (i = 13; i < 19; i++) /* print positions 13-18 */
+ if (board[i])
+ bsect (board[i],3,1+4*(i-13),1);
+
+ if (board[25]) /* print white's men on bar */
+ bsect (board[25],3,25,1);
+
+ for (i = 19; i < 25; i++) /* print positions 19-24 */
+ if (board[i])
+ bsect (board[i],3,29+4*(i-19),1);
+
+ l = (off[0] < 0? off[0]+15: off[0]); /* print red's home */
+ bsect (-l,13,54,-1);
+
+ for (i = 0; i < 26; i++) /* save board position
+ * for refresh later */
+ oldb[i] = board[i];
+ 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
+ * position, "rpos" is the row to start printing, "cpos" is the column to
+ * start printing, and "cnext" is positive if the position starts at the top
+ * and negative if it starts at the bottom. The value of "cpos" is checked
+ * to see if the position is a player's home, since those are printed
+ * differently.
+ */
+
+bsect (b,rpos,cpos,cnext)
+int b; /* contents of position */
+int rpos; /* row of position */
+int cpos; /* column of position */
+int cnext; /* direction of position */
+
+{
+ register int j; /* index */
+ register int n; /* number of men on position */
+ register int bct; /* counter */
+ int k; /* index */
+ char pc; /* color of men on position */
+
+ n = abs(b); /* initialize n and pc */
+ pc = (b > 0? 'r': 'w');
+
+ if (n < 6 && cpos < 54) /* position cursor at start */
+ curmove (rpos,cpos+1);
+ else
+ curmove (rpos,cpos);
+
+ for (j = 0; j < 5; j++) { /* print position row by row */
+
+ for (k = 0; k < 15; k += 5) /* print men */
+ if (n > j+k)
+ fancyc (pc);
+
+ if (j < 4) { /* figure how far to
+ * back up for next
+ * row */
+ if (n < 6) { /* stop if none left */
+ if (j+1 == n)
+ break;
+ bct = 1; /* single column */
+ } else {
+ if (n < 11) { /* two columns */
+ if (cpos == 54) { /* home pos */
+ if (j+5 >= n)
+ bct = 1;
+ else
+ bct = 2;
+ }
+ if (cpos < 54) { /* not home */
+ if (j+6 >= n)
+ bct = 1;
+ else
+ bct = 2;
+ }
+ } else { /* three columns */
+ if (j+10 >= n)
+ bct = 2;
+ else
+ bct = 3;
+ }
+ }
+ curmove (curr+cnext,curc-bct); /* reposition cursor */
+ }
+ }
+}
+
+refresh() {
+ register int i, r, c;
+
+ r = curr; /* save current position */
+ c = curc;
+
+ for (i = 12; i > 6; i--) /* fix positions 12-7 */
+ if (board[i] != oldb[i]) {
+ fixpos (oldb[i],board[i],13,1+(12-i)*4,-1);
+ oldb[i] = board[i];
+ }
+
+ if (board[0] != oldb[0]) { /* fix red men on bar */
+ fixpos (oldb[0],board[0],13,25,-1);
+ oldb[0] = board[0];
+ }
+
+ for (i = 6; i > 0; i--) /* fix positions 6-1 */
+ if (board[i] != oldb[i]) {
+ fixpos (oldb[i],board[i],13,29+(6-i)*4,-1);
+ oldb[i] = board[i];
+ }
+
+ i = -(off[0] < 0? off[0]+15: off[0]); /* fix white's home */
+ if (oldw != i) {
+ fixpos (oldw,i,13,54,-1);
+ oldw = i;
+ }
+
+ for (i = 13; i < 19; i++) /* fix positions 13-18 */
+ if (board[i] != oldb[i]) {
+ fixpos (oldb[i],board[i],3,1+(i-13)*4,1);
+ oldb[i] = board[i];
+ }
+
+ if (board[25] != oldb[25]) { /* fix white men on bar */
+ fixpos (oldb[25],board[25],3,25,1);
+ oldb[25] = board[25];
+ }
+
+ for (i = 19; i < 25; i++) /* fix positions 19-24 */
+ if (board[i] != oldb[i]) {
+ fixpos (oldb[i],board[i],3,29+(i-19)*4,1);
+ oldb[i] = board[i];
+ }
+
+ i = (off[1] < 0? off[1]+15: off[1]); /* fix red's home */
+ if (oldr != i) {
+ fixpos (oldr,i,3,54,1);
+ oldr = i;
+ }
+
+ curmove (r,c); /* return to saved position */
+ newpos();
+ buflush();
+}
+
+fixpos (old,new,r,c,inc)
+int old, new, r, c, inc;
+
+{
+ register int o, n, nv;
+ int ov, nc;
+ char col;
+
+ if (old*new >= 0) {
+ ov = abs(old);
+ nv = abs(new);
+ col = (old+new > 0? 'r': 'w');
+ o = (ov-1)/5;
+ n = (nv-1)/5;
+ if (o == n) {
+ if (o == 2)
+ nc = c+2;
+ if (o == 1)
+ nc = c < 54? c: c+1;
+ if (o == 0)
+ nc = c < 54? c+1: c;
+ if (ov > nv)
+ fixcol (r+inc*(nv-n*5),nc,abs(ov-nv),' ',inc);
+ else
+ fixcol (r+inc*(ov-o*5),nc,abs(ov-nv),col,inc);
+ return;
+ } else {
+ if (c < 54) {
+ if (o+n == 1) {
+ if (n) {
+ fixcol (r,c,abs(nv-5),col,inc);
+ if (ov != 5)
+ fixcol (r+inc*ov,c+1,abs(ov-5),col,inc);
+ } else {
+ fixcol (r,c,abs(ov-5),' ',inc);
+ if (nv != 5)
+ fixcol (r+inc*nv,c+1,abs(nv-5),' ',inc);
+ }
+ return;
+ }
+ if (n == 2) {
+ if (ov != 10)
+ fixcol (r+inc*(ov-5),c,abs(ov-10),col,inc);
+ fixcol (r,c+2,abs(nv-10),col,inc);
+ } else {
+ if (nv != 10)
+ fixcol (r+inc*(nv-5),c,abs(nv-10),' ',inc);
+ fixcol (r,c+2,abs(ov-10),' ',inc);
+ }
+ return;
+ }
+ if (n > o) {
+ fixcol (r+inc*(ov%5),c+o,abs(5*n-ov),col,inc);
+ if (nv != 5*n)
+ fixcol (r,c+n,abs(5*n-nv),col,inc);
+ } else {
+ fixcol (r+inc*(nv%5),c+n,abs(5*n-nv),' ',inc);
+ if (ov != 5*o)
+ fixcol (r,c+o,abs(5*o-ov),' ',inc);
+ }
+ return;
+ }
+ }
+ nv = abs(new);
+ fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
+ if (abs(old) <= abs(new))
+ return;
+ fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
+}
+
+fixcol (r,c,l,ch,inc)
+register int l, ch;
+int r, c, inc;
+
+{
+ register int i;
+
+ curmove (r,c);
+ fancyc (ch);
+ for (i = 1; i < l; i++) {
+ curmove (curr+inc,curc-1);
+ fancyc (ch);
+ }
+}
+
+curmove (r,c)
+register int r, c;
+
+{
+ if (curr == r && curc == c)
+ return;
+ if (realr == -1) {
+ realr = curr;
+ realc = curc;
+ }
+ curr = r;
+ curc = c;
+}
+
+newpos () {
+ register int r; /* destination row */
+ register int c; /* destination column */
+ register int mode = -1; /* mode of movement */
+
+ int count = 1000; /* character count */
+ int i; /* index */
+ int j; /* index */
+ int n; /* temporary variable */
+ char *m; /* string containing CM movement */
+
+
+ if (realr == -1) /* see if already there */
+ return;
+
+ r = curr; /* set current and dest. positions */
+ c = curc;
+ curr = realr;
+ curc = realc;
+
+ /* double check position */
+ if (curr == r && curc == c) {
+ realr = realc = -1;
+ return;
+ }
+
+ if (CM) { /* try CM to get there */
+ mode = 0;
+ m = (char *)tgoto (CM,c,r);
+ count = strlen (m);
+ }
+
+ /* try HO and local movement */
+ if (HO && (n = r+c*lND+lHO) < count) {
+ mode = 1;
+ count = n;
+ }
+
+ /* try various LF combinations */
+ if (r >= curr) {
+ /* CR, LF, and ND */
+ if ((n = (r-curr)+c*lND+1) < count) {
+ mode = 2;
+ count = n;
+ }
+ /* LF, ND */
+ if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count) {
+ mode = 3;
+ count = n;
+ }
+ /* LF, BS */
+ if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count) {
+ mode = 4;
+ count = n;
+ }
+ }
+
+ /* try corresponding UP combinations */
+ if (r < curr) {
+ /* CR, UP, and ND */
+ if ((n = (curr-r)*lUP+c*lND+1) < count) {
+ mode = 5;
+ count = n;
+ }
+ /* UP and ND */
+ if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count) {
+ mode = 6;
+ count = n;
+ }
+ /* UP and BS */
+ if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count) {
+ mode = 7;
+ count = n;
+ }
+ }
+
+ /* space over */
+ if (curr == r && c > curc && linect[r] < curc && c-curc < count)
+ mode = 8;
+
+ switch (mode) {
+
+ case -1: /* error! */
+ write (2,"\r\nInternal cursor error.\r\n",26);
+ getout();
+
+ /* direct cursor motion */
+ case 0:
+ tputs (m,abs(curr-r),addbuf);
+ break;
+
+ /* relative to "home" */
+ case 1:
+ tputs (HO,r,addbuf);
+ for (i = 0; i < r; i++)
+ addbuf ('\012');
+ for (i = 0; i < c; i++)
+ tputs (ND,1,addbuf);
+ break;
+
+ /* CR and down and over */
+ case 2:
+ addbuf ('\015');
+ for (i = 0; i < r-curr; i++)
+ addbuf ('\012');
+ for (i = 0; i < c; i++)
+ tputs (ND,1,addbuf);
+ break;
+
+ /* down and over */
+ case 3:
+ for (i = 0; i < r-curr; i++)
+ addbuf ('\012');
+ for (i = 0; i < c-curc; i++)
+ tputs (ND,1,addbuf);
+ break;
+
+ /* down and back */
+ case 4:
+ for (i = 0; i < r-curr; i++)
+ addbuf ('\012');
+ for (i = 0; i < curc-c; i++)
+ addbuf ('\010');
+ break;
+
+ /* CR and up and over */
+ case 5:
+ addbuf ('\015');
+ for (i = 0; i < curr-r; i++)
+ tputs (UP,1,addbuf);
+ for (i = 0; i < c; i++)
+ tputs (ND,1,addbuf);
+ break;
+
+ /* up and over */
+ case 6:
+ for (i = 0; i < curr-r; i++)
+ tputs (UP,1,addbuf);
+ for (i = 0; i < c-curc; i++)
+ tputs (ND,1,addbuf);
+ break;
+
+ /* up and back */
+ case 7:
+ for (i = 0; i < curr-r; i++)
+ tputs (UP,1,addbuf);
+ for (i = 0; i < curc-c; i++) {
+ if (BC)
+ tputs (BC,1,addbuf);
+ else
+ addbuf ('\010');
+ }
+ break;
+
+ /* safe space */
+ case 8:
+ for (i = 0; i < c-curc; i++)
+ addbuf (' ');
+ }
+
+ /* fix positions */
+ curr = r;
+ curc = c;
+ realr = -1;
+ realc = -1;
+}
+
+clear () {
+ register int i;
+
+ /* double space if can't clear */
+ if (CL == 0) {
+ writel ("\n\n");
+ return;
+ }
+
+ curr = curc = 0; /* fix position markers */
+ realr = realc = -1;
+ for (i = 0; i < 24; i++) /* clear line counts */
+ linect[i] = -1;
+ buffnum = -1; /* ignore leftover buffer contents */
+ tputs (CL,CO,addbuf); /* put CL in buffer */
+}
+
+tos () { /* home cursor */
+ curmove (0,0);
+}
+
+fancyc (c)
+register char c; /* character to output */
+{
+ register int sp; /* counts spaces in a tab */
+
+ if (c == '\007') { /* bells go in blindly */
+ addbuf (c);
+ return;
+ }
+
+ /* process tabs, use spaces if the
+ * the tab should be erasing things,
+ * otherwise use cursor movement
+ * routines. Note this does not use
+ * hardware tabs at all. */
+ if (c == '\t') {
+ sp = (curc+8) & (~ 7); /* compute spaces */
+ /* check line length */
+ if (linect[curr] >= curc || sp < 4) {
+ for (; sp > curc; sp--)
+ addbuf (' ');
+ curc = sp; /* fix curc */
+ } else
+ curmove (curr,sp);
+ return;
+ }
+
+ /* do newline be calling newline */
+ if (c == '\n') {
+ newline();
+ return;
+ }
+
+ /* ignore any other control chars */
+ if (c < ' ')
+ return;
+
+ /* if an erasing space or non-space,
+ * just add it to buffer. Otherwise
+ * use cursor movement routine, so that
+ * multiple spaces will be grouped
+ * together */
+ if (c > ' ' || linect[curr] >= curc) {
+ newpos (); /* make sure position correct */
+ addbuf (c); /* add character to buffer */
+ /* fix line length */
+ if (c == ' ' && linect[curr] == curc)
+ linect[curr]--;
+ else if (linect[curr] < curc)
+ linect[curr] = curc;
+ curc++; /* fix curc */
+ } else
+ /* use cursor movement routine */
+ curmove (curr,curc+1);
+}
+
+clend() {
+ register int i;
+ register char *s;
+
+
+ if (CD) {
+ tputs (CD,CO-curr,addbuf);
+ for (i = curr; i < LI; i++)
+ linect[i] = -1;
+ return;
+ }
+
+ curmove (i = curr,0);
+ cline();
+ while (curr < LI-1) {
+ curmove (curr+1,0);
+ if (linect[curr] > -1)
+ cline ();
+ }
+ curmove (i,0);
+}
+
+cline () {
+ register int i;
+ register int c;
+ register char *s;
+
+ if (curc > linect[curr])
+ return;
+ newpos ();
+ if (CE) {
+ tputs (CE,1,addbuf);
+ linect[curr] = curc-1;
+ } else {
+ c = curc-1;
+ while (linect[curr] > c) {
+ addbuf (' ');
+ curc++;
+ linect[curr]--;
+ }
+ curmove (curr,c+1);
+ }
+}
+
+newline () {
+ cline();
+ if (curr == LI-1)
+ curmove (begscr,0);
+ else
+ curmove (curr+1,0);
+}
+
+getcaps (s)
+register char *s;
+
+{
+ register char *code; /* two letter code */
+ register char ***cap; /* pointer to cap string */
+ char *bufp; /* pointer to cap buffer */
+ char tentry[1024]; /* temporary uncoded caps buffer */
+
+ tgetent (tentry,s); /* get uncoded termcap entry */
+
+ LI = tgetnum ("li"); /* get number of lines */
+ if (LI == -1)
+ LI = 12;
+ CO = tgetnum ("co"); /* get number of columns */
+ if (CO == -1)
+ CO = 65;
+
+ bufp = tbuf; /* get padding character */
+ tgetstr ("pc",&bufp);
+ if (bufp != tbuf)
+ PC = *tbuf;
+ else
+ PC = 0;
+
+ bufp = tbuf; /* get string entries */
+ cap = tstr;
+ for (code = tcap; *code; code += 2)
+ **cap++ = (char *)tgetstr (code,&bufp);
+
+ /* get pertinent lengths */
+ if (HO)
+ lHO = strlen (HO);
+ if (BC)
+ lBC = strlen (BC);
+ else
+ lBC = 1;
+ if (UP)
+ lUP = strlen (UP);
+ if (ND)
+ lND = strlen (ND);
+ if (LI < 24 || CO < 72 || !(CL && UP && ND))
+ return (0);
+ linect = (int *)calloc (LI+1,sizeof(int));
+ return (1);
+}
diff --git a/backgammon/common_source/init.c b/backgammon/common_source/init.c
new file mode 100644
index 00000000..9d3fce3b
--- /dev/null
+++ b/backgammon/common_source/init.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)init.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include <sgtty.h>
+
+/*
+ * variable initialization.
+ */
+
+ /* name of executable object programs */
+char EXEC[] = "/usr/games/backgammon";
+char TEACH[] = "/usr/games/teachgammon";
+
+int pnum = 2; /* color of player:
+ -1 = white
+ 1 = red
+ 0 = both
+ 2 = not yet init'ed */
+int acnt = 0; /* length of args */
+int aflag = 1; /* flag to ask for rules or instructions */
+int bflag = 0; /* flag for automatic board printing */
+int cflag = 0; /* case conversion flag */
+int hflag = 1; /* flag for cleaning screen */
+int mflag = 0; /* backgammon flag */
+int raflag = 0; /* 'roll again' flag for recovered game */
+int rflag = 0; /* recovered game flag */
+int tflag = 0; /* cursor addressing flag */
+int iroll = 0; /* special flag for inputting rolls */
+int rfl = 0;
+
+char *color[] = {"White","Red","white","red"};
diff --git a/backgammon/common_source/odds.c b/backgammon/common_source/odds.c
new file mode 100644
index 00000000..dc780497
--- /dev/null
+++ b/backgammon/common_source/odds.c
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)odds.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+odds (r1,r2,val)
+register int r1;
+int r2, val;
+{
+ register int i, j;
+
+ if (r1 == 0) {
+ for (i = 0; i < 6; i++)
+ for (j = 0; j < 6; j++)
+ table[i][j] = 0;
+ return;
+ } else {
+ r1--;
+ if (r2-- == 0)
+ for (i = 0; i < 6; i++) {
+ table[i][r1] += val;
+ table[r1][i] += val;
+ }
+ else {
+ table[r2][r1] += val;
+ table[r1][r2] += val;
+ }
+ }
+}
+
+count () {
+ register int i;
+ register int j;
+ register int total;
+
+ total = 0;
+ for (i = 0; i < 6; i++)
+ for (j = 0; j < 6; j++)
+ total += table[i][j];
+ return (total);
+}
+
+canhit (i,c)
+int i, c;
+
+{
+ register int j, k, b;
+ int a, d, diff, place, addon, menstuck;
+
+ if (c == 0)
+ odds (0,0,0);
+ if (board[i] > 0) {
+ a = -1;
+ b = 25;
+ } else {
+ a = 1;
+ b = 0;
+ }
+ place = abs (25-b-i);
+ menstuck = abs (board[b]);
+ for (j = b; j != i; j += a) {
+ if (board[j]*a > 0) {
+ diff = abs(j-i);
+ addon = place+((board[j]*a > 2 || j == b)? 5: 0);
+ if ((j == b && menstuck == 1) &&
+ (j != b && menstuck == 0))
+ for (k = 1; k < diff; k++)
+ if (k < 7 && diff-k < 7 &&
+ (board[i+a*k]*a >= 0 ||
+ board[i+a*(diff-k)] >= 0))
+ odds (k,diff-k,addon);
+ if ((j == b || menstuck < 2) && diff < 7)
+ odds (diff,0,addon);
+ }
+ if (j == b && menstuck > 1)
+ break;
+ }
+ return (count());
+}
diff --git a/backgammon/common_source/one.c b/backgammon/common_source/one.c
new file mode 100644
index 00000000..c00f4ca1
--- /dev/null
+++ b/backgammon/common_source/one.c
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)one.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+makmove (i)
+register int i;
+
+{
+ register int n, d;
+ int max;
+
+ d = d0;
+ n = abs(g[i]-p[i]);
+ max = (*offptr < 0? 7: last());
+ if (board[p[i]]*cturn <= 0)
+ return (checkd(d)+2);
+ if (g[i] != home && board[g[i]]*cturn < -1)
+ return (checkd(d)+3);
+ if (i || D0 == D1) {
+ if (n == max? D1 < n: D1 != n)
+ return (checkd(d)+1);
+ } else {
+ if (n == max? D0 < n && D1 < n: D0 != n && D1 != n)
+ return (checkd(d)+1);
+ if (n == max? D0 < n: D0 != n) {
+ if (d0)
+ return (checkd(d)+1);
+ swap;
+ }
+ }
+ if (g[i] == home && *offptr < 0)
+ return (checkd(d)+4);
+ h[i] = 0;
+ board[p[i]] -= cturn;
+ if (g[i] != home) {
+ if (board[g[i]] == -cturn) {
+ board[home] -= cturn;
+ board[g[i]] = 0;
+ h[i] = 1;
+ if (abs(bar-g[i]) < 7) {
+ (*inopp)--;
+ if (*offopp >= 0)
+ *offopp -= 15;
+ }
+ }
+ board[g[i]] += cturn;
+ if (abs(home-g[i]) < 7 && abs(home-p[i]) > 6) {
+ (*inptr)++;
+ if (*inptr+*offptr == 0)
+ *offptr += 15;
+ }
+ } else {
+ (*offptr)++;
+ (*inptr)--;
+ }
+ return (0);
+}
+
+moverr (i)
+register int i;
+
+{
+ register int j;
+
+ if (tflag)
+ curmove (20,0);
+ else
+ writec ('\n');
+ writel ("Error: ");
+ for (j = 0; j <= i; j++) {
+ wrint (p[j]);
+ writec ('-');
+ wrint (g[j]);
+ if (j < i)
+ writec (',');
+ }
+ writel ("... ");
+ movback (i);
+}
+
+
+checkd (d)
+register int d;
+
+{
+ if (d0 != d)
+ swap;
+ return (0);
+}
+
+last () {
+ register int i;
+
+ for (i = home-6*cturn; i != home; i += cturn)
+ if (board[i]*cturn > 0)
+ return (abs(home-i));
+}
+
+movback (i)
+register int i;
+
+{
+ register int j;
+
+ for (j = i-1; j >= 0; j--)
+ backone(j);
+}
+
+backone (i)
+register int i;
+
+{
+ board[p[i]] += cturn;
+ if (g[i] != home) {
+ board[g[i]] -= cturn;
+ if (abs(g[i]-home) < 7 && abs(p[i]-home) > 6) {
+ (*inptr)--;
+ if (*inptr+*offptr < 15 && *offptr >= 0)
+ *offptr -= 15;
+ }
+ } else {
+ (*offptr)--;
+ (*inptr)++;
+ }
+ if (h[i]) {
+ board[home] += cturn;
+ board[g[i]] = -cturn;
+ if (abs(bar-g[i]) < 7) {
+ (*inopp)++;
+ if (*inopp+*offopp == 0)
+ *offopp += 15;
+ }
+ }
+}
diff --git a/backgammon/common_source/save.c b/backgammon/common_source/save.c
new file mode 100644
index 00000000..b91d3ec3
--- /dev/null
+++ b/backgammon/common_source/save.c
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)save.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+extern int errno;
+
+static char confirm[] = "Are you sure you want to leave now?";
+static char prompt[] = "Enter a file name: ";
+static char exist1[] = "The file '";
+static char exist2[] =
+ "' already exists.\nAre you sure you want to use this file?";
+static char cantuse[] = "\nCan't use ";
+static char saved[] = "This game has been saved on the file '";
+static char type[] = "'.\nType \"backgammon ";
+static char rec[] = "\" to recover your game.\n\n";
+static char cantrec[] = "Can't recover file: ";
+
+save (n)
+register int n;
+
+{
+ register int fdesc;
+ register char *fs;
+ char fname[50];
+
+ if (n) {
+ if (tflag) {
+ curmove (20,0);
+ clend();
+ } else
+ writec ('\n');
+ writel (confirm);
+ if (! yorn(0))
+ return;
+ }
+ cflag = 1;
+ for (;;) {
+ writel (prompt);
+ fs = fname;
+ while ((*fs = readc()) != '\n') {
+ if (*fs == tty.sg_erase) {
+ if (fs > fname) {
+ fs--;
+ if (tflag)
+ curmove (curr,curc-1);
+ else
+ writec (*fs);
+ } else
+ writec ('\007');
+ continue;
+ }
+ writec (*fs++);
+ }
+ *fs = '\0';
+ if ((fdesc = open(fname,2)) == -1 && errno == 2) {
+ if ((fdesc = creat (fname,0700)) != -1)
+ break;
+ }
+ if (fdesc != -1) {
+ if (tflag) {
+ curmove (18,0);
+ clend();
+ } else
+ writec ('\n');
+ writel (exist1);
+ writel (fname);
+ writel (exist2);
+ cflag = 0;
+ close (fdesc);
+ if (yorn (0)) {
+ unlink (fname);
+ fdesc = creat (fname,0700);
+ break;
+ } else {
+ cflag = 1;
+ continue;
+ }
+ }
+ writel (cantuse);
+ writel (fname);
+ writel (".\n");
+ close (fdesc);
+ cflag = 1;
+ }
+ write (fdesc,board,sizeof board);
+ write (fdesc,off,sizeof off);
+ write (fdesc,in,sizeof in);
+ write (fdesc,dice,sizeof dice);
+ write (fdesc,&cturn,sizeof cturn);
+ write (fdesc,&dlast,sizeof dlast);
+ write (fdesc,&pnum,sizeof pnum);
+ write (fdesc,&rscore,sizeof rscore);
+ write (fdesc,&wscore,sizeof wscore);
+ write (fdesc,&gvalue,sizeof gvalue);
+ write (fdesc,&raflag,sizeof raflag);
+ close (fdesc);
+ if (tflag)
+ curmove (18,0);
+ writel (saved);
+ writel (fname);
+ writel (type);
+ writel (fname);
+ writel (rec);
+ if (tflag)
+ clend();
+ getout ();
+}
+
+recover (s)
+char *s;
+
+{
+ register int i;
+ int fdesc;
+
+ if ((fdesc = open (s,0)) == -1)
+ norec (s);
+ read (fdesc,board,sizeof board);
+ read (fdesc,off,sizeof off);
+ read (fdesc,in,sizeof in);
+ read (fdesc,dice,sizeof dice);
+ read (fdesc,&cturn,sizeof cturn);
+ read (fdesc,&dlast,sizeof dlast);
+ read (fdesc,&pnum,sizeof pnum);
+ read (fdesc,&rscore,sizeof rscore);
+ read (fdesc,&wscore,sizeof wscore);
+ read (fdesc,&gvalue,sizeof gvalue);
+ read (fdesc,&raflag,sizeof raflag);
+ close (fdesc);
+ rflag = 1;
+}
+
+norec (s)
+register char *s;
+
+{
+ register char *c;
+
+ tflag = 0;
+ writel (cantrec);
+ c = s;
+ while (*c != '\0')
+ writec (*c++);
+ getout ();
+}
diff --git a/backgammon/common_source/subs.c b/backgammon/common_source/subs.c
new file mode 100644
index 00000000..7917124f
--- /dev/null
+++ b/backgammon/common_source/subs.c
@@ -0,0 +1,477 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)subs.c 5.5 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include <stdio.h>
+#include "back.h"
+
+int buffnum;
+char outbuff[BUFSIZ];
+
+static char plred[] = "Player is red, computer is white.";
+static char plwhite[] = "Player is white, computer is red.";
+static char nocomp[] = "(No computer play.)";
+
+char *descr[] = {
+ "Usage: backgammon [-] [n r w b pr pw pb t3a]\n",
+ "\t-\tgets this list\n\tn\tdon't ask for rules or instructions",
+ "\tr\tplayer is red (implies n)\n\tw\tplayer is white (implies n)",
+ "\tb\ttwo players, red and white (implies n)",
+ "\tpr\tprint the board before red's turn",
+ "\tpw\tprint the board before white's turn",
+ "\tpb\tprint the board before both player's turn",
+ "\tterm\tterminal is a term",
+ "\tsfile\trecover saved game from file",
+ 0
+};
+
+errexit (s)
+register char *s;
+{
+ write (2,"\n",1);
+ perror (s);
+ getout();
+}
+
+strset (s1,s2)
+register char *s1, *s2;
+{
+ while ( (*s1++ = *s2++) != '\0');
+}
+
+addbuf (c)
+register char c;
+
+{
+ buffnum++;
+ if (buffnum == BUFSIZ) {
+ if (write(1,outbuff,BUFSIZ) != BUFSIZ)
+ errexit ("addbuf (write):");
+ buffnum = 0;
+ }
+ outbuff[buffnum] = c;
+}
+
+buflush () {
+ if (buffnum < 0)
+ return;
+ buffnum++;
+ if (write (1,outbuff,buffnum) != buffnum)
+ errexit ("buflush (write):");
+ buffnum = -1;
+}
+
+readc () {
+ char c;
+
+ if (tflag) {
+ cline();
+ newpos();
+ }
+ buflush();
+ if (read(0,&c,1) != 1)
+ errexit ("readc");
+#ifdef WHY_IS_THIS_HARDWIRED_IN_HERE
+ if (c == '\177')
+ getout();
+#endif
+ if (c == '\033' || c == '\015')
+ return ('\n');
+ if (cflag)
+ return (c);
+ if (c == '\014')
+ return ('R');
+ if (c >= 'a' && c <= 'z')
+ return (c & 0137);
+ return (c);
+}
+
+writec (c)
+char c;
+{
+ if (tflag)
+ fancyc (c);
+ else
+ addbuf (c);
+}
+
+writel (l)
+register char *l;
+{
+#ifdef DEBUG
+ register char *s;
+
+ if (trace == NULL)
+ trace = fopen ("bgtrace","w");
+
+ fprintf (trace,"writel: \"");
+ for (s = l; *s; s++) {
+ if (*s < ' ' || *s == '\177')
+ fprintf (trace,"^%c",(*s)^0100);
+ else
+ putc (*s,trace);
+ }
+ fprintf (trace,"\"\n");
+ fflush (trace);
+#endif
+
+ while (*l)
+ writec (*l++);
+}
+
+proll () {
+ if (d0)
+ swap;
+ if (cturn == 1)
+ writel ("Red's roll: ");
+ else
+ writel ("White's roll: ");
+ writec (D0+'0');
+ writec ('\040');
+ writec (D1+'0');
+ if (tflag)
+ cline();
+}
+
+wrint (n)
+int n;
+{
+ register int i, j, t;
+
+ for (i = 4; i > 0; i--) {
+ t = 1;
+ for (j = 0; j<i; j++)
+ t *= 10;
+ if (n > t-1)
+ writec ((n/t)%10+'0');
+ }
+ writec (n%10+'0');
+}
+
+gwrite() {
+ register int r, c;
+
+ if (tflag) {
+ r = curr;
+ c = curc;
+ curmove (16,0);
+ }
+
+ if (gvalue > 1) {
+ writel ("Game value: ");
+ wrint (gvalue);
+ writel (". ");
+ if (dlast == -1)
+ writel (color[0]);
+ else
+ writel (color[1]);
+ writel (" doubled last.");
+ } else {
+ switch (pnum) {
+ case -1: /* player is red */
+ writel (plred);
+ break;
+ case 0: /* player is both colors */
+ writel (nocomp);
+ break;
+ case 1: /* player is white */
+ writel (plwhite);
+ }
+ }
+
+ if (rscore || wscore) {
+ writel (" ");
+ wrscore();
+ }
+
+ if (tflag) {
+ cline();
+ curmove (r,c);
+ }
+}
+
+quit () {
+ register int i;
+
+ if (tflag) {
+ curmove (20,0);
+ clend();
+ } else
+ writec ('\n');
+ writel ("Are you sure you want to quit?");
+ if (yorn (0)) {
+ if (rfl) {
+ writel ("Would you like to save this game?");
+ if (yorn(0))
+ save(0);
+ }
+ cturn = 0;
+ return (1);
+ }
+ return (0);
+}
+
+yorn (special)
+register char special; /* special response */
+{
+ register char c;
+ register int i;
+
+ i = 1;
+ while ( (c = readc()) != 'Y' && c != 'N') {
+ if (special && c == special)
+ return (2);
+ if (i) {
+ if (special) {
+ writel (" (Y, N, or ");
+ writec (special);
+ writec (')');
+ } else
+ writel (" (Y or N)");
+ i = 0;
+ } else
+ writec ('\007');
+ }
+ if (c == 'Y')
+ writel (" Yes.\n");
+ else
+ writel (" No.\n");
+ if (tflag)
+ buflush();
+ return (c == 'Y');
+}
+
+wrhit (i)
+register int i;
+{
+ writel ("Blot hit on ");
+ wrint (i);
+ writec ('.');
+ writec ('\n');
+}
+
+nexturn () {
+ register int c;
+
+ cturn = -cturn;
+ c = cturn/abs(cturn);
+ home = bar;
+ bar = 25-bar;
+ offptr += c;
+ offopp -= c;
+ inptr += c;
+ inopp -= c;
+ Colorptr += c;
+ colorptr += c;
+}
+
+getarg (arg)
+register char ***arg;
+
+{
+ register char **s;
+
+ /* process arguments here. dashes are ignored, nbrw are ignored
+ if the game is being recovered */
+
+ s = *arg;
+ while (s[0][0] == '-') {
+ switch (s[0][1]) {
+
+ /* don't ask if rules or instructions needed */
+ case 'n':
+ if (rflag)
+ break;
+ aflag = 0;
+ args[acnt++] = 'n';
+ break;
+
+ /* player is both read and white */
+ case 'b':
+ if (rflag)
+ break;
+ pnum = 0;
+ aflag = 0;
+ args[acnt++] = 'b';
+ break;
+
+ /* player is red */
+ case 'r':
+ if (rflag)
+ break;
+ pnum = -1;
+ aflag = 0;
+ args[acnt++] = 'r';
+ break;
+
+ /* player is white */
+ case 'w':
+ if (rflag)
+ break;
+ pnum = 1;
+ aflag = 0;
+ args[acnt++] = 'w';
+ break;
+
+ /* print board after move according to following character */
+ case 'p':
+ if (s[0][2] != 'r' && s[0][2] != 'w' && s[0][2] != 'b')
+ break;
+ args[acnt++] = 'p';
+ args[acnt++] = s[0][2];
+ if (s[0][2] == 'r')
+ bflag = 1;
+ if (s[0][2] == 'w')
+ bflag = -1;
+ if (s[0][2] == 'b')
+ bflag = 0;
+ break;
+
+ case 't':
+ if (s[0][2] == '\0') { /* get terminal caps */
+ s++;
+ tflag = getcaps (*s);
+ } else
+ tflag = getcaps (&s[0][2]);
+ break;
+
+ case 's':
+ s++;
+ /* recover file */
+ recover (s[0]);
+ break;
+ }
+ s++;
+ }
+ if (s[0] != 0)
+ recover(s[0]);
+}
+
+init () {
+ register int i;
+ for (i = 0; i < 26;)
+ board[i++] = 0;
+ board[1] = 2;
+ board[6] = board[13] = -5;
+ board[8] = -3;
+ board[12] = board[19] = 5;
+ board[17] = 3;
+ board[24] = -2;
+ off[0] = off[1] = -15;
+ in[0] = in[1] = 5;
+ gvalue = 1;
+ dlast = 0;
+}
+
+wrscore () {
+ writel ("Score: ");
+ writel (color[1]);
+ writec (' ');
+ wrint (rscore);
+ writel (", ");
+ writel (color[0]);
+ writec (' ');
+ wrint (wscore);
+}
+
+fixtty (mode)
+int mode;
+{
+ if (tflag)
+ newpos();
+ buflush();
+ tty.sg_flags = mode;
+ if (stty (0,&tty) < 0)
+ errexit("fixtty");
+}
+
+getout () {
+ /* go to bottom of screen */
+ if (tflag) {
+ curmove (23,0);
+ cline();
+ } else
+ writec ('\n');
+
+ /* fix terminal status */
+ fixtty (old);
+ exit();
+}
+roll () {
+ register char c;
+ register int row;
+ register int col;
+
+ if (iroll) {
+ if (tflag) {
+ row = curr;
+ col = curc;
+ curmove (17,0);
+ } else
+ writec ('\n');
+ writel ("ROLL: ");
+ c = readc();
+ if (c != '\n') {
+ while (c < '1' || c > '6')
+ c = readc();
+ D0 = c-'0';
+ writec (' ');
+ writec (c);
+ c = readc();
+ while (c < '1' || c > '6')
+ c = readc();
+ D1 = c-'0';
+ writec (' ');
+ writec (c);
+ if (tflag) {
+ curmove (17,0);
+ cline();
+ curmove (row,col);
+ } else
+ writec ('\n');
+ return;
+ }
+ if (tflag) {
+ curmove (17,0);
+ cline();
+ curmove (row,col);
+ } else
+ writec ('\n');
+ }
+ D0 = rnum(6)+1;
+ D1 = rnum(6)+1;
+ d0 = 0;
+}
diff --git a/backgammon/common_source/table.c b/backgammon/common_source/table.c
new file mode 100644
index 00000000..9555e8dd
--- /dev/null
+++ b/backgammon/common_source/table.c
@@ -0,0 +1,308 @@
+/*
+ * Copyright (c) 1980 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. All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ * This product includes software developed by the University of
+ * California, Berkeley and its contributors.
+ * 4. 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.
+ */
+
+#ifndef lint
+static char sccsid[] = "@(#)table.c 5.4 (Berkeley) 6/1/90";
+#endif /* not lint */
+
+#include "back.h"
+
+char *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;
+};
+
+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
+};
+
+checkmove (ist)
+
+int ist;
+
+{
+ register int j, n;
+ register char c;
+ char a;
+
+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++)
+ p[j] = g[j] = -1;
+
+dochar:
+ c = readc();
+
+ if (c == 'S') {
+ raflag = 0;
+ save (1);
+ if (tflag) {
+ curmove (cturn == -1? 18: 19,39);
+ ist = -1;
+ goto domove;
+ } else {
+ proll ();
+ ist = 0;
+ goto domove;
+ }
+ }
+
+ if (c == tty.sg_erase && ncin > 0) {
+ if (tflag)
+ curmove (curr,curc-1);
+ else {
+ if (tty.sg_erase == '\010')
+ writel ("\010 \010");
+ else
+ writec (cin[ncin-1]);
+ }
+ ncin--;
+ n = rsetbrd();
+ if (n == 0) {
+ n = -1;
+ if (tflag)
+ refresh();
+ }
+ if ((ist = n) > 0)
+ goto dochar;
+ goto domove;
+ }
+
+ if (c == tty.sg_kill && ncin > 0) {
+ if (tflag) {
+ refresh();
+ curmove (curr,39);
+ ist = -1;
+ goto domove;
+ } else if (tty.sg_erase == '\010') {
+ for (j = 0; j < ncin; j++)
+ writel ("\010 \010");
+ ist = -1;
+ goto domove;
+ } else {
+ writec ('\\');
+ writec ('\n');
+ proll ();
+ ist = 0;
+ goto domove;
+ }
+ }
+
+ n = dotable(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 >= mvlim)
+ return(0);
+ if (n == -1 && mvl < mvlim-1)
+ return(-4);
+
+ if (n == -6) {
+ if (! tflag) {
+ if (movokay(mvl+1)) {
+ wrboard();
+ movback (mvl+1);
+ }
+ proll ();
+ writel ("\t\tMove: ");
+ for (j = 0; j < ncin;)
+ writec (cin[j++]);
+ } else {
+ if (movokay(mvl+1)) {
+ refresh();
+ movback (mvl+1);
+ } else
+ curmove (cturn == -1? 18:19,ncin+39);
+ }
+ ist = n = rsetbrd();
+ goto dochar;
+ }
+
+ if (n != -5)
+ return(n);
+ writec ('\007');
+ goto dochar;
+}
+
+dotable (c,i)
+char c;
+register int i;
+
+{
+ register int a, j;
+ 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 ();
+ writel ("\t\t");
+ } else
+ proll ();
+ break;
+
+ case 2:
+ if (p[mvl] == -1)
+ p[mvl] = c-'0';
+ else
+ p[mvl] = p[mvl]*10+c-'0';
+ break;
+
+ case 3:
+ if (g[mvl] != -1) {
+ if (mvl < mvlim)
+ mvl++;
+ p[mvl] = p[mvl-1];
+ }
+ g[mvl] = p[mvl]+cturn*(c-'0');
+ if (g[mvl] < 0)
+ g[mvl] = 0;
+ if (g[mvl] > 25)
+ g[mvl] = 25;
+ break;
+
+ case 4:
+ if (g[mvl] == -1)
+ g[mvl] = c-'0';
+ else
+ g[mvl] = g[mvl]*10+c-'0';
+ break;
+
+ case 5:
+ if (mvl < mvlim)
+ mvl++;
+ p[mvl] = g[mvl-1];
+ break;
+
+ case 6:
+ if (mvl < mvlim)
+ mvl++;
+ break;
+
+ case 7:
+ if (tflag)
+ curmove (20,0);
+ else
+ writec ('\n');
+ text (help2);
+ if (tflag) {
+ curmove (cturn == -1? 18: 19,39);
+ } else {
+ writec ('\n');
+ proll();
+ writel ("\t\tMove: ");
+ }
+ break;
+
+ case 8:
+ p[mvl] = bar;
+ break;
+
+ case 9:
+ g[mvl] = home;
+ }
+
+ if (! test || a != '\n')
+ return (atmata[i].newst);
+ else
+ return (-6);
+ }
+
+ i++;
+ }
+
+ return (-5);
+}
+
+rsetbrd () {
+ register int i, j, n;
+
+ n = 0;
+ mvl = 0;
+ for (i = 0; i < 4; i++)
+ p[i] = g[i] = -1;
+ for (j = 0; j < ncin; j++)
+ n = dotable (cin[j],n);
+ return (n);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-06 15:34:19 +0000