home *** CD-ROM | disk | FTP | other *** search
/ 17 Bit Software 2: Collection B / 17Bit_Collection_B.iso / files / 1406.dms / in.adf / Backgammon / back.c < prev    next >
Encoding:
C/C++ Source or Header  |  1978-05-28  |  11.4 KB  |  441 lines
  1. /********************************************************************/
  2. /*                                                                  */
  3. /*  Hoser BackGammon version 1.0                                    */
  4. /*                                                                  */
  5. /*      Robert Pfister                                              */
  6. /*                                                                  */
  7. /*      Rfd#3 Box 2340                home:(207)-873-3520           */
  8. /*      Waterville, Maine 04901                                     */
  9. /*                                                                  */
  10. /*      Pfister_rob%dneast@dec.decwrl                               */
  11. /*                                                                  */
  12. /*                                                                  */
  13. /*  Copyright  June,1987                                            */
  14. /*                                                                  */
  15. /*  This program will play a game of backgammon at the novice level */
  16. /*                                                                  */
  17. /*  The code is in 4 parts...                                       */
  18. /*   /                                                              */
  19. /* \/    1) back.c     - main driver                                */
  20. /*       2) eval.c     - evaluation of moves                        */
  21. /*       3) backscn.c  - screen stuff..                             */
  22. /*       4) backmenu.c - menu stuff, help text, and ``decoder''     */
  23. /*                                                                  */
  24. /* this was compiled under Manx 3.20a, using long integers          */
  25. /*                                                                  */
  26. /********************************************************************/
  27. #include <libraries/dos.h>
  28.  
  29. extern int AvgPos;
  30. extern int Moves;
  31.  
  32. int MeInc,YouInc=0;
  33. int MeD,MeM,YouD,YouM=0;
  34. int MeBar,YouBar=0;
  35. int Me2,You2=0;
  36.  
  37. #define StackSize 500
  38.   static int BoardPos[StackSize][26]; /* stack of the previous positions */
  39.   static int DicePos[StackSize][4];   /* stack of the dice rolls */
  40.  
  41.   static int StackPos=0;     /* how many moves back are we at? */
  42.  
  43.   static int MoveList[4];       /* stack of this turns moves */
  44.   static int CurMove=0;        /* place in the list */
  45.   
  46. int Uside;    /* user side */
  47. int Cside;    /* computer side */
  48.  
  49. int Turn;     /* whose turn is it? */
  50.  
  51.  int board[26];    /* describes the board position..0 is the bar */
  52.  int Dice[4];      /* describes the 2->4 dice availible */
  53.  
  54. main() /* main procedure */
  55.   {
  56.  
  57.   int i,j,play;
  58.  
  59.    Gsetup();
  60.    Turn=setup(board,Dice);
  61.  
  62.    for (;;)         /* go until game is over */
  63.      {
  64.       if (Turn==Uside) DoMenuStrip("Your Turn");
  65.                  else  DoMenuStrip("My Turn");
  66.  
  67.       ShowDice(Dice,Turn);
  68.       if (Turn==Uside)
  69.       {
  70.        /* store this board position */
  71.            StoreMove();
  72.        /* user stats */
  73.            if (Dice[2]>0) You2++;
  74.            YouD+=Dice[0]+Dice[1]+Dice[2]+Dice[3];
  75.            YouM++;
  76.            if (board[25]<0) YouBar++;
  77.  
  78.  
  79.        /* do the Move */
  80.           do
  81.             if (UserMove(board,Dice,Turn)==0) GameOver(); /* escape */
  82.             while (  (Turn==Uside)&&
  83.                      (Won(board,Turn)==0)&&
  84.                      (Dice[0]+Dice[1]+Dice[2]+Dice[3]!=0) );
  85.        }
  86.        else /* turn==Cside */
  87.        {  
  88.            /* computer stats */
  89.               if (Dice[2]>0) Me2++;
  90.               MeD+=Dice[0]+Dice[1]+Dice[2]+Dice[3];
  91.               MeM++;
  92.               if (board[0]>0) MeBar++;
  93.  
  94.            /* do move */
  95.               GenerateMoves(board,Dice);
  96.               DoMove(board);
  97.            }
  98.  
  99.       Turn=Turn*-1;
  100.       Roll(Dice);
  101.  
  102.        /* signal to restart the game */
  103.           if (Turn==0) Turn=setup(board,Dice);
  104.           
  105.        /* did user win yet? */
  106.           if (Won(board,Uside))
  107.              {
  108.              stats();
  109.              if (requestor("I lose Play Again?","No","Yes")) GameOver();
  110.                                                 else Turn=setup(board,Dice);
  111.              }
  112.  
  113.        /* did computer win yet? */
  114.           if (Won(board,Cside))
  115.              {
  116.               stats();
  117.               if (requestor("Heehee. I Win. Play Again?","No","Yes")) GameOver();
  118.                                          else Turn=setup(board,Dice);
  119.              }
  120.       ShowDice(Dice,Turn);
  121.  
  122.     } /* end do forever */
  123.  
  124.  } /* end of main */
  125.  
  126. Restart()
  127. {
  128.  Turn=0;
  129. }
  130.  
  131. StoreMove()
  132. { 
  133.  int i;
  134.  
  135.  if (StackPos<StackSize+1) /* can only store that many */
  136.   {
  137.    for (i=0;i<26;i++)
  138.        BoardPos[StackPos][i]=board[i];       
  139.    for (i=0;i<4;i++)
  140.        DicePos[StackPos][i]=Dice[i];
  141.    StackPos++;
  142.    }
  143. /* printf("STORE: stack is at %d \n",StackPos); */
  144. }
  145.  
  146. RecallMove(how)
  147. int how;
  148. {
  149.   int i;
  150.  
  151.   StackPos=StackPos-1+how;
  152.   if (StackPos<0) StackPos=0;
  153.  
  154.   for (i=0;i<26;i++)
  155.       if (board[i]!=BoardPos[StackPos][i])
  156.          { /* only refresh stuff changed */
  157.           board[i]=BoardPos[StackPos][i];       
  158.           PutSpike(i,board[i]);
  159.         }
  160.  
  161.   for (i=0;i<4;i++)
  162.       Dice[i]=DicePos[StackPos][i];
  163.  
  164.   ShowDice(Dice,Uside);
  165.  StackPos++;
  166. /* printf("RECALL: stack is at %d \n",StackPos);  */
  167. }
  168.  
  169. Won(board,side)
  170.   int board[26],side;
  171.       {
  172.        int i;
  173.  
  174.        if (side==1) for(i=0;((board[i]<=0)&&(i<=25));i++);
  175.                else for(i=0;((board[i]>=0)&&(i<=25));i++);
  176.  
  177.        if (i==26) return(1);
  178.              else return(0);
  179.        }
  180.  
  181. UserMove(board,Dice,side)
  182.  int board[26],Dice[4],side;
  183.  {
  184.  char Action;
  185.  int  Pick,Valid;  /* flags */
  186.  int i,x,y;
  187.  
  188.  Valid=0;
  189.  Pick =0;
  190.  while (Valid==0)
  191.  {
  192.    Action=Whats_up(&x);
  193.    UnDoMenuStrip();
  194.    switch (Action)
  195.       {
  196.        /* check for abortion */
  197.        case 'D':Dice[0]=0;
  198.                 Dice[1]=0;
  199.                 Dice[2]=0;
  200.                 Dice[3]=0;
  201.                 Valid=1;
  202.                 YouInc++;
  203.                 break;
  204.  
  205.  
  206.        case 'Q':
  207.                 Valid=-1;
  208.                 break;
  209.  
  210.        case 'P':if (Pick==0)
  211.                    {
  212.                     if (board[x]*side<=0)
  213.                          DoMenuStrip("No peice there!!");
  214.                          else
  215.                              {
  216.                               Pick=1;
  217.                               y=x;
  218.                               }
  219.                           break;
  220.                      }
  221.  
  222.                      else if (Pick==1) /* only if peice marked already */
  223.                        {
  224.                          Pick =0;
  225.                          for (i=0;(Valid==0)&&(i<4);i++)
  226.                            {
  227.                              if ((valid(board,y,x,Dice[i]))&&(Dice[i]!=0))
  228.                                  {
  229.                                   BlinkPeice(board,y);
  230.                                   update(board,y,x,side);
  231.                                   PutSpike(y ,board[ y]);
  232.                                   BlinkPeice(board,x);
  233.                                   PutSpike(0 ,board[ 0]);
  234.                                   PutSpike(25,board[25]);
  235.                                   Valid=1;
  236.                                   Dice[i]=0;
  237.                                   }
  238.                              } /* end for */
  239.  
  240.                         if (Valid==0) DoMenuStrip("Not Valid move");
  241.  
  242.                           break;
  243.                          } /* end if...case 'M' */
  244.  
  245.             case 'C':Valid=DoMenu(x);
  246.                      break;
  247.                     
  248.             default :break;
  249.  
  250.             } /* end of case */
  251.  
  252.       } /* end while Valid==0 */
  253.  
  254.    if (Valid==-1) return(0);
  255.    return(1);
  256.    } /* end UserMove */
  257.  
  258.  
  259. Roll(d)     /* roll the dice  (4 results) */
  260. int  d[4];
  261.   {
  262.   long  i,k,num1,num2;
  263.   struct DateStamp time;
  264.  
  265.   DateStamp(&time);
  266.  
  267.   k=time.ds_Tick;
  268.   
  269.   for (i=1;i<=k;i++)
  270.     {
  271.       num1=RangeRand(6L)+1;
  272.       num2=RangeRand(6L)+1;
  273.      }
  274.   d[0]=num1;
  275.   d[1]=num2;
  276.   if (num1==num2)   /* if rolled doubles */
  277.          {
  278.           d[2]=num1;
  279.           d[3]=num2;
  280.          }
  281.          else
  282.          {
  283.           d[2]=0;
  284.           d[3]=0;
  285.          }
  286.   if (d[3]==0) return(0);
  287.           else return(1);
  288.   }
  289.  
  290. GameOver()
  291. {
  292.  stats();
  293.  finit();
  294.  exit(0);
  295.  }
  296.  
  297. stats()
  298.    {
  299.     if ((YouM!=0)&&(MeM!=0))
  300.        {
  301.         printf("Statistics on the Game \n");
  302.         printf("-------------------------------------------------------\n");
  303.         printf("number of moves %ld  avg positions evaluated %ld \n",MeM,AvgPos/MeM);
  304.         printf("\n");
  305.         printf("avg roll    : User %ld Computer %ld \n",YouD/YouM,MeD/MeM);
  306.         printf("doubles     : User %ld Computer %ld \n",You2,Me2);
  307.         printf("inc. Moves  : User %ld Computer %ld \n",YouInc,MeInc);
  308.         printf("Turns on bar: User %ld Computer %ld \n",YouBar,MeBar);
  309.         printf("-------------------------------------------------------\n");
  310.         }
  311.      MeM=0;     YouD=0; YouM=0;  MeD=0;
  312.      AvgPos=0;  You2=0;  Me2=0;  YouInc=0; MeInc=0;
  313.      YouBar=0; MeBar=0;
  314.    }
  315.  
  316. setup(board,Dice)
  317. int board[26],Dice[4];
  318.  {
  319.  int i;
  320.  
  321.  Uside=-1;
  322.  Cside= 1;
  323.  
  324.  /* set the board to the initial setting */
  325.  
  326.   for (i=0; i<=25; i++)
  327.      {
  328.       board[i]= 0;
  329.       }
  330.  
  331.   board[ 1]= 2;
  332.   board[ 6]=-5;
  333.   board[ 8]=-3;
  334.   board[12]= 5;
  335.   board[13]=-5;
  336.   board[17]= 3;
  337.   board[19]= 5;
  338.   board[24]=-2;
  339.   for (i=0;i<=25;i++)
  340.       {
  341.        PutSpike(i,board[i]);
  342.        }
  343.  
  344.  /* see who goes first */
  345.  
  346.  while (Roll(Dice));  /* until no doubles */
  347.  
  348.  if (Dice[0]>Dice[1])
  349.            return(Uside);
  350.       else return(Cside);
  351.   }
  352.  
  353. /* is the move valid for the board, and one die */
  354. valid(board,m1,m2,p)  /* board, start, stop, dice roll */
  355. int board[26];
  356. int m1,m2,p;
  357.   {
  358.   int sign,i,All_In,bar;
  359.  
  360.      
  361.   All_In=-1;
  362.   
  363.   /* what direction are we going? */
  364.   if (board[m1]>0)
  365.          {
  366.           sign=Cside;
  367.           
  368.           if (Cside==1) bar=0;
  369.                    else bar=25;  
  370.  
  371.           /* is there a man on the bar?? */
  372.           if ((board[bar]!=0)&&(m1!=0)) return(0);
  373.  
  374.           /* see if all peices are in home base */
  375.           for(i=0;(i<=24)&&(All_In==-1);i++)
  376.               if (board[i]>0) All_In=i;
  377.  
  378.           /* check if can take it off */
  379.           if (m2>24)
  380.              {
  381.              if ((All_In>18)&&
  382.                 ( (m1==(25-p)) || ((25-p)<All_In)&&(m1==All_In) )) return(1);
  383.                                                               else return(0);
  384.              }
  385.           }
  386.      else
  387.          {
  388.           sign=-1;
  389.           /* is there a man on the bar? */
  390.           if ((board[25]!=0)&&(m1!=25)) return(0);
  391.  
  392.           /* see if all peices are in home base */
  393.           for(i=25;(i>=1)&&(All_In==-1);i--)
  394.               if (board[i]<0) All_In=i;
  395.  
  396.           /* see if can take off */
  397.          if (m2==m1)
  398.             {
  399.             if ((All_In<7)&&
  400.                ( (m1==p)|| ((p>All_In)&&(m1==All_In) )))  return(1);
  401.                                                     else  return(0);
  402.             }
  403.           }
  404.  
  405.   /* does dice roll make sense for the move picked? */
  406.   if ((m2-m1)!=(p*sign))  return(0);
  407.  
  408.   /* if spike has more than 1 opponent */
  409.   if (board[m2] * sign < -1)  return(0);
  410.  
  411.   /* I suppose that's all there is..*/
  412.   return(1);
  413.   }
  414.  
  415. /* put a given move onto the board */
  416. update(board,m1,m2,sign)
  417. int board[26],m1,m2,sign;
  418.   {
  419.    int bar;
  420.  
  421.    if (sign>0) bar=0;
  422.           else bar=25;
  423.  
  424.    /* remove the peice from the 'source'  spike */
  425.    
  426.    board[m1]=board[m1]-sign;
  427.  
  428.    /* if taking a peice off, dont go any furthur */
  429.    if ((m2==m1)||(m2>=25)) return(1);
  430.  
  431.    /* add a peice to the 'destination' spike, consider if capturing*/
  432.    
  433.    board[m2]=board[m2]+sign;
  434.  
  435.    if (board[m2]==0) {
  436.                       board[m2    ]=sign;
  437.                       board[25-bar]=board[25-bar]-sign;
  438.                       }
  439.    return(0);
  440.    }
  441.