games/backgammon/common_source/one.c

   1 /*
   2  * Copyright (c) 1980, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#)one.c    8.1 (Berkeley) 5/31/93
  34  * $FreeBSD: src/games/backgammon/common_source/one.c,v 1.5 1999/11/30 03:48:27 billf Exp $
  35  * $DragonFly: src/games/backgammon/common_source/one.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  36  */
  37
  38 #include "back.h"
  39
  40 static int      checkd(int);
  41 static int      last(void);
  42
  43 int
  44 makmove(int i)
  45 {
  46         int     n, d;
  47         int             max;
  48
  49         d = d0;
  50         n = abs(g[i]-p[i]);
  51         max = (*offptr < 0? 7: last());
  52         if (board[p[i]]*cturn <= 0)
  53                 return (checkd(d)+2);
  54         if (g[i] != home && board[g[i]]*cturn < -1)
  55                 return (checkd(d)+3);
  56         if (i || D0 == D1)  {
  57                 if (n == max? D1 < n: D1 != n)
  58                         return (checkd(d)+1);
  59         } else  {
  60                 if (n == max? D0 < n && D1 < n: D0 != n && D1 != n)
  61                         return (checkd(d)+1);
  62                 if (n == max? D0 < n: D0 != n)  {
  63                         if (d0)
  64                                 return (checkd(d)+1);
  65                         swap;
  66                 }
  67         }
  68         if (g[i] == home && *offptr < 0)
  69                 return (checkd(d)+4);
  70         h[i] = 0;
  71         board[p[i]] -= cturn;
  72         if (g[i] != home)  {
  73                 if (board[g[i]] == -cturn)  {
  74                         board[home] -= cturn;
  75                         board[g[i]] = 0;
  76                         h[i] = 1;
  77                         if (abs(bar-g[i]) < 7)  {
  78                                 (*inopp)--;
  79                                 if (*offopp >= 0)
  80                                         *offopp -= 15;
  81                         }
  82                 }
  83                 board[g[i]] += cturn;
  84                 if (abs(home-g[i]) < 7 && abs(home-p[i]) > 6)  {
  85                         (*inptr)++;
  86                         if (*inptr+*offptr == 0)
  87                                 *offptr += 15;
  88                 }
  89         } else {
  90                 (*offptr)++;
  91                 (*inptr)--;
  92         }
  93         return (0);
  94 }
  95
  96 void
  97 moverr(int i)
  98 {
  99         int     j;
 100
 101         if (tflag)
 102                 curmove (20,0);
 103         else
 104                 writec ('\n');
 105         writel ("Error:  ");
 106         for (j = 0; j <= i; j++)  {
 107                 wrint (p[j]);
 108                 writec ('-');
 109                 wrint (g[j]);
 110                 if (j < i)
 111                         writec (',');
 112         }
 113         writel ("... ");
 114         movback (i);
 115 }
 116
 117 static int
 118 checkd(int d)
 119 {
 120         if (d0 != d)
 121                 swap;
 122         return (0);
 123 }
 124
 125 static int
 126 last(void)
 127 {
 128         int     i;
 129
 130         for (i = home-6*cturn; i != home; i += cturn)
 131                 if (board[i]*cturn > 0)
 132                         return (abs(home-i));
 133         return(-1);
 134 }
 135
 136 void
 137 movback(int i)
 138 {
 139         int     j;
 140
 141         for (j = i-1; j >= 0; j--)
 142                 backone(j);
 143 }
 144
 145 void
 146 backone(int i)
 147 {
 148         board[p[i]] += cturn;
 149         if (g[i] != home)  {
 150                 board[g[i]] -= cturn;
 151                 if (abs(g[i]-home) < 7 && abs(p[i]-home) > 6)  {
 152                         (*inptr)--;
 153                         if (*inptr+*offptr < 15 && *offptr >= 0)
 154                                 *offptr -= 15;
 155                 }
 156         } else  {
 157                 (*offptr)--;
 158                 (*inptr)++;
 159         }
 160         if (h[i])  {
 161                 board[home] += cturn;
 162                 board[g[i]] = -cturn;
 163                 if (abs(bar-g[i]) < 7)  {
 164                         (*inopp)++;
 165                         if (*inopp+*offopp == 0)
 166                                 *offopp += 15;
 167                 }
 168         }
 169 }