home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / othl-111.zip / Othello.c < prev    next >
C/C++ Source or Header  |  1994-07-26  |  32KB  |  1,243 lines
  1. ///////////////////////////////////////////////////////////////////////////
  2. // Othello.c
  3. //
  4. // Copyright (c) 1994 by John Morris    All Rights Reserved
  5. ///////////////////////////////////////////////////////////////////////////
  6. //
  7. // This Othello door source code is meant to be an example of an OS/2
  8. // type door which will run under Adept under menu option 802, or under
  9. // GMon/2 using the OS/2 door redirection flag.
  10. //
  11. // Notice there is no special com routines used here!  This file is the 
  12. // entire program!
  13. //
  14. // Under Adept and GMon/2 redirection, STDIN, STDOUT, and STDERR
  15. // are redirected thru unnamed pipes to the parent program. The parent program
  16. // then routes the information to the proper place (com port, or named pipe)
  17. //
  18. // When running the program from Adept or from GMon/2 you will see the output
  19. // appear on the regular BBS screen.
  20. //
  21. // This program (through no fault of my own.. it appears to be a quirk of the
  22. // Watcom C32 10.0 IO library) operates slightly differently when used from
  23. // the OS/2 command line than from Adept or GMon/2 (IO is controlled more
  24. // precisely from the latter two)
  25. //
  26. // I'll make more notes on the code added to make the program work more
  27. // efficiently thru pipes.
  28. //
  29. // Please keep jokes about the game itself to yourself <grin>
  30. //
  31. // Compiler command:
  32. //
  33. // wcl386 /3r /w3 /l=os2v2 othello.c
  34. //
  35. // Sample Command line: (from an Adept menu)
  36. //
  37. // Othello d:\Adept\System\Line{LN\Session.Info
  38. //
  39. // command line contains 1 parm. The name of the Session.Info file!
  40. //
  41. ///////////////////////////////////////////////////////////////////////////
  42.  
  43. #define INCL_DOS
  44.  
  45. #include <os2.h>
  46.  
  47. #include <ctype.h>
  48. #include <stdio.h>
  49. #include <stdlib.h>
  50. #include <string.h>
  51. #include <fcntl.h>
  52. #include <io.h>
  53. #include <share.h>
  54. #include <sys\types.h>
  55. #include <sys\stat.h>
  56. #include <time.h>
  57. #include <malloc.h>
  58. #include <math.h>
  59.  
  60. #include <myquirks.h>   // my own C programming quirks
  61.  
  62. // Input defs
  63. #define INPUTUCASE      0x00000001
  64. #define TURBO           0x00000002
  65.  
  66. // ANSI colors defs..
  67. #define BLACK   0
  68. #define RED     1
  69. #define GREEN   2
  70. #define YELLOW  3
  71. #define BLUE    4
  72. #define MAGENTA 5
  73. #define CYAN    6
  74. #define WHITE   7
  75.  
  76. ///////////////////////////////////////////////////////////////////////////
  77. // Global variables (begin with 'o')
  78.  
  79. static int      oBlack               = 0;            
  80.  
  81. static int      oBoard[10][10];
  82.  
  83. static int      oWasBoard[10][10];
  84.  
  85. static char    *oColumnLetters       = "ABCDEFGH";
  86.  
  87. static int      oComputer            = 0;
  88.  
  89. static int      oComputerPieces      = 0;
  90.  
  91. static int      oCornersSacrificed   = 0;
  92.  
  93. static int      oHandicap            = 0;
  94.  
  95. static int      oHandicapRecipient   = 0;
  96.  
  97. static int      oHuman               = 0;
  98.  
  99. static int      oHumanPieces         = 0;
  100.  
  101. static int      oMoveRow             = 0;            
  102.  
  103. static int      oNextRow[8]          = { 0, -1, -1, -1, 0, 1, 1, 1 };
  104.  
  105. static int      oMoveCol             = 0;            
  106.  
  107. static int      oNextCol[8]          = { 1, 1, 0, -1, -1, -1, 0, 1 };
  108.  
  109. static int      oSpacesTaken         = 0;
  110.  
  111. static int      oPiecesTaken         = 0;
  112.  
  113. static char     oPieceType[3][5];
  114.  
  115. static int      oRed                 = 0;       
  116.  
  117. static int      oGoodGuy             = 0;
  118.  
  119. static int      oBadGuy             = 0;
  120.  
  121. static int      oZ                   = 0;
  122.  
  123. static int      oANSIRow[8]          = { 4, 6, 8, 10, 12, 14, 16, 18 };
  124.  
  125. static int      oANSICol[8]          = { 15, 21, 27, 33, 39, 45, 51, 57 };
  126.  
  127. static BOOL     oBoardDisplayed      = FALSE;
  128.  
  129. static BOOL     oColor               = FALSE;
  130.  
  131. static BOOL     oBright              = FALSE;
  132.  
  133. static int      oForeColor           = 7;
  134.  
  135. static int      oBackColor           = 0;
  136.  
  137. static char     oTempString[512];
  138.  
  139. static int      oArgLen              = 0;
  140.  
  141. static int      oArgValue            = 0;
  142.  
  143. static char    *Copyright = {"\n\rCopyright (c) 1994 by John Morris   All Rights Reserved\n\r" };
  144.  
  145. ///////////////////////////////////////////////////////////////////////////
  146. // game functions
  147. static int  PlayGame(void);
  148. static int  PlayAgain(void);
  149. static void TellPieces(void);
  150. static int  NextToOpponent(void);
  151. static void TakePieces(BOOL ChangeBoard);
  152. static void DisplayBoard(void);
  153. static void WipeLine(int RowNumber);
  154. static void AskHandicap(void);
  155. static void HumanGetsHandicap(void);
  156. static void AskCorners(void);
  157. static void EndGame(void);
  158.  
  159. ///////////////////////////////////////////////////////////////////////////
  160. // IO procs
  161. int   YorN(char *YorNQuestion);
  162. void  OutPut(char *String, int NumLineFeeds);
  163. int   Input(char *Prompt, int Flags, int MaxLength);
  164. void  WipeLine(int Row);
  165. void  ANSIString(int ForeColor, int BackColor);
  166. void  BuffFile(char *FileToView);
  167. ULONG Random(ULONG Low, ULONG High);
  168. ULONG mult(ULONG p, ULONG q);
  169. void  Randomize(void);
  170. float Zero2OneRand(void);
  171.  
  172. static void ReadSessionInfo(char *SessionInfoName);
  173.  
  174.  
  175. void main(int ArgC, char **ArgV)
  176. {   
  177.     // Session.Info Filename should have been passed as the only
  178.     // command on the command line
  179.     if (ArgC > 1)
  180.         ReadSessionInfo(ArgV[1]);
  181.  
  182.     /////////////////////////////////////////////
  183.     // no buffering on Std IO
  184.     //
  185.     // an important step. eliminate the compilers file IO
  186.     // buffering.. everything should go thru the pipes NOW!
  187.     // let the parent program buffer things.
  188.     //
  189.     setvbuf(stdin,  NULL, _IONBF, 0);
  190.     setvbuf(stdout, NULL, _IONBF, 0);
  191.     setvbuf(stderr, NULL, _IONBF, 0);
  192.  
  193.     /////////////////////////////////////////////
  194.     // set translation mode
  195.     //
  196.     // Also everything should be binary in nature
  197.     // make that is so.
  198.     //
  199.     setmode(fileno(stdin),  O_BINARY);
  200.     setmode(fileno(stdout), O_BINARY);
  201.     setmode(fileno(stderr), O_BINARY);
  202.  
  203.     // Run Othello
  204.     PgmMain();
  205.  
  206.     return;
  207. } 
  208.  
  209. static void PgmMain(void)
  210. {
  211.     int  Neutral = 0;     
  212.  
  213.     Randomize();
  214.  
  215.     // clear screen
  216.  
  217.     fprintf(stderr, "\r\n   " __DATE__ " " __TIME__);
  218.     fprintf(stderr, Copyright);
  219.     fprintf(stderr, "\r\n");
  220.  
  221.     OutPut("\r\nO T H E L L O", 0);
  222.      
  223.     oForeColor = YELLOW;
  224.      
  225.     if (YorN("\r\n\r\nDo you require instructions ([Y]/N)? "))
  226.     {
  227.         oForeColor = CYAN;
  228.         OutPut("\r\nOTHELLO is played on an 8 X 8 checker board,", 1);
  229.         OutPut("rows numbered 1 to 8 and columns A to H.", 1);
  230.         OutPut("The initial configuration is all blank, except", 1);
  231.         OutPut("for the center four squares, which form the pattern", 1);
  232.         OutPut("     0 X", 1);
  233.         OutPut("     X 0", 1);
  234.         OutPut("Place your piece so that it 'outflanks'", 1);
  235.         OutPut("mine, creating a horizontal, vertical, or diagonal", 1);
  236.         OutPut("run of my pieces bounded at each end by at least", 1);
  237.         OutPut("one of yours.  This will 'flip' my pieces ", 1);
  238.         OutPut("converting them to yours.  You must capture a", 1);
  239.         OutPut("piece if possible.   If you have no legal move", 1);
  240.         OutPut("forfeit your turn by entering 0,0.", 2);
  241.         oForeColor = MAGENTA;
  242.         OutPut("Scoring is as follows:", 1);
  243.         OutPut("No handicap       --  (X'S - O'S) * 10", 1);
  244.         OutPut("You take handicap -- ((X'S - O'S) * 10) - (80  * # corners taken)", 1);
  245.         OutPut("You give handicap -- ((X'S - O'S) * 10) + (2.5 * # corners given)", 1);
  246.         OutPut("If you quit before game's end, I'll deduct a 1000 points!", 2);
  247.     }
  248.  
  249.     oBlack  = -1;
  250.     Neutral = 0;                 
  251.     oRed    = 1;
  252.  
  253.     if (NOT oColor)
  254.     {
  255.         strcpy(oPieceType[oBlack + 1]  , "X");
  256.         strcpy(oPieceType[Neutral + 1] , ".");
  257.         strcpy(oPieceType[oRed + 1]    , "O");
  258.     }
  259.      
  260.     do
  261.     {
  262.         if (NOT PlayGame())
  263.             break;
  264.    
  265.     } while (PlayAgain());
  266.  
  267.     EndGame();
  268. }
  269.  
  270. static int PlayGame(void)
  271. {
  272.     int     LastPiecesTaken;
  273.     long    GamePoints;
  274.     int     Lasti;
  275.     int     Lastj; 
  276.     char   *Column;
  277.  
  278.     for (oMoveRow = 0; oMoveRow < 10; oMoveRow++)
  279.     {
  280.         for (oMoveCol = 0; oMoveCol < 10; oMoveCol++)
  281.         {
  282.             oBoard[oMoveRow][oMoveCol] = 0;
  283.             oWasBoard[oMoveRow][oMoveCol] = 0;
  284.         }
  285.     }
  286.  
  287.     oBoard[4][4] = oRed;
  288.     oBoard[5][5] = oRed;
  289.     oBoard[4][5] = oBlack;
  290.     oBoard[5][4] = oBlack;
  291.     oComputerPieces = 2;
  292.     oHumanPieces = 2;
  293.     oSpacesTaken = 4;
  294.     oZ = FALSE;
  295.     oHandicap = 0;
  296.     oBoardDisplayed = FALSE;
  297.     oForeColor = GREEN;
  298.     sprintf(oTempString, "You are %s, and I am %s. Enter X if you want %s: ",
  299.                          oColor ? "Red"   : "O",
  300.                          oColor ? "Black" : "X",
  301.                          oColor ? "Black" : "X");
  302.  
  303.     Input(oTempString, INPUTUCASE, 1);
  304.  
  305.     oComputer = oBlack;
  306.     oHuman    = oRed;
  307.  
  308.     if (*oTempString == 'X')
  309.     {
  310.         oComputer = oRed;
  311.         oHuman    = oBlack;
  312.     } 
  313.  
  314.     AskHandicap();
  315.  
  316.     oForeColor = YELLOW;
  317.     if (YorN("Would you like to move first ([Y]/N)? "))
  318.     {
  319.         DisplayBoard();
  320.  
  321. HumanMove:
  322.  
  323.         oGoodGuy = oHuman;
  324.         oBadGuy = oComputer;
  325.  
  326. AskMove: 
  327.         do
  328.         {
  329.             do
  330.             {
  331.                 oForeColor = WHITE;
  332.  
  333.                 if (oColor)
  334.                     WipeLine(23);
  335.  
  336.                 sprintf(oTempString, "Your move, (row,column), %sF)orfeit, Q)uit? ", oColor ? "R)edraw, " : "");
  337.                 Input(oTempString, INPUTUCASE, 4);
  338.                      
  339.                 if (*oTempString == 'F')
  340.                     goto IsForfeit;
  341.  
  342.                 if (*oTempString == 'Q')
  343.                 {
  344.                     if (oColor)
  345.                         WipeLine(22);
  346.                 
  347.                     OutPut("Chickened out, huh!?.", 1);
  348.                     return (TRUE);
  349.                 }
  350.                      
  351.                 if (oColor AND *oTempString == 'R')
  352.                 {
  353.                     oBoardDisplayed = FALSE;
  354.  
  355.                     for (oMoveRow = 0; oMoveRow < 10; oMoveRow++)
  356.                     {
  357.                         for (oMoveCol = 0; oMoveCol < 10; oMoveCol++)
  358.                         {
  359.                             oWasBoard[oMoveRow][oMoveCol] = 0;
  360.                         }
  361.                     }
  362.  
  363.                     DisplayBoard();
  364.  
  365.                     goto AskMove;
  366.                 }
  367.  
  368.                 if (NOT strchr(oTempString, ','))
  369.                 {
  370.                     oForeColor = RED;
  371.                     if (NOT oColor)
  372.                         OutPut("Row,Column with a comma...", 1);
  373.                     goto  AskMove;
  374.                 } 
  375.                      
  376.                 if (oArgLen != 3 )
  377.                 {
  378.                     oForeColor = RED;
  379.                     if (NOT oColor)
  380.                         OutPut("Try again...", 1);
  381.                     goto  AskMove;
  382.                 } 
  383.                  
  384.             } while (oArgValue < 0 OR oArgValue > 8 );
  385.  
  386.             oMoveRow = (int) oArgValue;
  387.  
  388.             Column = strchr(oTempString, ',') + 1;
  389.              
  390.             if (oMoveRow)
  391.             {
  392.                 if (Column = strchr(oColumnLetters, *Column))
  393.                 {
  394.                     oMoveCol = (int) (Column - oColumnLetters) + 1;
  395.                     // oMoveRow,oMoveCol is human move...
  396.                     goto g540;
  397.                 }
  398.                 else
  399.                     goto AskMove;
  400.             } 
  401.  
  402. IsForfeit:
  403.             oForeColor = MAGENTA;
  404.              
  405.             if (oColor)
  406.                 WipeLine(23);
  407.  
  408.         } while (NOT YorN("Are you forfeiting your turn ([Y]/N)? "));
  409.  
  410.         if (NOT oZ)
  411.         {
  412.             oZ = TRUE;
  413.             goto ComputerMove;
  414.         } 
  415.     } 
  416.     else
  417.     {
  418. ComputerMove:  
  419.  
  420.         LastPiecesTaken = -1;
  421.         Lasti = 0;
  422.         Lastj = 0;
  423.         oGoodGuy = oComputer;
  424.         oBadGuy = oHuman;
  425.         oMoveRow = 0;
  426.  
  427.         if (oColor)
  428.             WipeLine(21);
  429.  
  430.         do 
  431.         {
  432.             oMoveRow++;
  433.             for (oMoveCol = 1; oMoveCol <= 8; oMoveCol++)
  434.             {
  435.                 if (oBoard[oMoveRow][oMoveCol] == 0)
  436.                 {
  437.                     if (NextToOpponent())
  438.                     {
  439.                         TakePieces(FALSE);
  440.                          
  441.                         if (oPiecesTaken != 0)
  442.                         {
  443.                             // computer likes corners....
  444.                             if (((oMoveRow - 1) * (oMoveRow - 8)) == 0)
  445.                                 oPiecesTaken += 4;
  446.                              
  447.                             if (((oMoveCol - 1) * (oMoveCol - 8)) == 0)
  448.                                 oPiecesTaken += 4;
  449.                              
  450.                             // doesn't like corners inside corners
  451.                             if (Zero2OneRand() > 0.32)
  452.                             {
  453.                                 if (((oMoveRow - 2) * (oMoveRow - 7)) == 0)
  454.                                     oPiecesTaken >>= 1;
  455.  
  456.                                 if (((oMoveCol - 2) * (oMoveCol - 7)) == 0)
  457.                                     oPiecesTaken >>= 1;
  458.                             }
  459.                              
  460.                             if (oPiecesTaken >= LastPiecesTaken)
  461.                             {
  462.                                 LastPiecesTaken = oPiecesTaken;
  463.                                 Lasti = oMoveRow;
  464.                                 Lastj = oMoveCol;
  465.                             } 
  466.                         } 
  467.                     }
  468.                 } 
  469.             }
  470.              
  471.         } while  (oMoveRow != 8);
  472.  
  473.         if (LastPiecesTaken > 0)
  474.         {
  475.             oZ = FALSE;
  476.             oForeColor = MAGENTA;
  477.             if (oColor)
  478.                 WipeLine(21);
  479.             sprintf(oTempString , "I will move to %d, %c", Lasti, oColumnLetters[Lastj - 1]);
  480. //            if (NOT oColor)
  481.                 OutPut(oTempString, oColor ? 0 : 1);
  482.             DosSleep(1000);
  483.             oMoveRow = Lasti;
  484.             oMoveCol = Lastj;
  485.             TakePieces(TRUE);
  486.             oComputerPieces = oComputerPieces + oPiecesTaken + 1 ;
  487.             oHumanPieces -= oPiecesTaken;
  488.             oSpacesTaken++;
  489.             sprintf(oTempString , "That gives me %d of your pieces", oPiecesTaken);
  490.             if (NOT oColor)
  491.                 OutPut(oTempString, 1);
  492.             oForeColor = CYAN;
  493.             TellPieces();
  494.             if (NOT oColor)
  495.                 DosSleep(1000);
  496.             DisplayBoard();
  497.             
  498.             if (oHumanPieces) 
  499.             {
  500.                 if (oSpacesTaken != 64)
  501.                     goto HumanMove;
  502.             }
  503.         } 
  504.         else
  505.         {
  506.             oForeColor = RED;
  507.  
  508.             if (oColor)
  509.                 WipeLine(22);
  510.  
  511.             OutPut("I forfeit my move", 1);
  512.              
  513.             if (NOT oZ)
  514.             {
  515.                 oZ = TRUE;
  516.                 goto HumanMove;
  517.             } 
  518.         } 
  519.     } 
  520. EndCheck:
  521.  
  522.     OutPut("", 1);
  523.  
  524.     TellPieces();
  525.  
  526.     if (NOT oColor)
  527.         DosSleep(1000);
  528.      
  529.     if (oColor)
  530.     {
  531.         WipeLine(21);
  532.         OutPut("\x1B[21;1H", 0);
  533.     }
  534.  
  535.     if (oHumanPieces == oComputerPieces)
  536.     {
  537.         OutPut("The game is a draw!!", 1);
  538.         return (TRUE);
  539.     } 
  540.     
  541.     if (oHumanPieces > oComputerPieces)
  542.     {
  543.         OutPut("Great job! You win!!", 1);
  544.     } 
  545.     else
  546.     {
  547.         OutPut("GOTCHA!  I won that one", 1);
  548.     } 
  549.  
  550.     GamePoints = ((oHumanPieces - oComputerPieces + oHandicap) * 100);
  551.     sprintf(oTempString , "You earned %ld points for that game", GamePoints);
  552.     if (NOT oColor)
  553.         OutPut(oTempString, 1);
  554.  
  555.     return (TRUE);
  556.  
  557. g540: 
  558.      
  559.     if (oBoard[oMoveRow][oMoveCol])
  560.     {
  561.         oForeColor = WHITE;
  562.  
  563.         if (oColor)
  564.             WipeLine(22);
  565.  
  566.         OutPut("Sorry that square is occupied. Try again!", 1);
  567.         DosSleep(1000);
  568.         goto AskMove;
  569.     } 
  570.  
  571.     if (NOT NextToOpponent())
  572.     {
  573.         oForeColor = RED;
  574.         if (oColor)
  575.             WipeLine(22);
  576.         OutPut("Sorry you are not next to one of my pieces. Try again!", 1);
  577.         DosSleep(1000);
  578.         goto AskMove;
  579.     } 
  580.  
  581.     TakePieces(FALSE);
  582.     
  583.     if (oPiecesTaken <= 0)
  584.     {
  585.         oForeColor = RED;
  586.         if (oColor)
  587.             WipeLine(22);
  588.         OutPut("Sorry that doesn't flank a row. Try again!", 1);
  589.         DosSleep(1000);
  590.         goto AskMove;
  591.     } 
  592.  
  593.     oZ = FALSE;
  594.     sprintf(oTempString , "That gives you %d of my pieces", oPiecesTaken);
  595.     if (NOT oColor)
  596.         OutPut(oTempString, 1);
  597.     TakePieces(TRUE);
  598.     oHumanPieces = oHumanPieces + oPiecesTaken + 1 ;
  599.     oComputerPieces -= oPiecesTaken;
  600.     oSpacesTaken++;
  601.     oForeColor = CYAN;
  602.     TellPieces();
  603.     DosSleep(1000);
  604.     DisplayBoard();
  605.     
  606.     if (oComputerPieces)
  607.     {
  608.         if (oSpacesTaken != 64)
  609.             goto ComputerMove;
  610.     }
  611.  
  612.     goto EndCheck;
  613. }
  614.  
  615. static void TellPieces(void)
  616. {
  617.     if (oColor)
  618.         OutPut("\x1B[20;17H\x1B[K", 0);
  619.  
  620.     sprintf(oTempString , "You have %d pieces, and I have %d pieces", oHumanPieces, oComputerPieces);
  621.     OutPut(oTempString, 1);
  622. }
  623.  
  624. static int PlayAgain(void)
  625. {
  626.     OutPut("", 1);
  627.  
  628.     oForeColor = YELLOW;
  629.  
  630.     if (oColor)
  631.         WipeLine(23);
  632.  
  633.     if (YorN("Do you want to play another game ([Y]/N)? "))
  634.         return (TRUE);
  635.  
  636.     OutPut("Thanks. Its been fun playing you.", 1);
  637.     OutPut("Exiting Othello, Bye", 1);
  638.  
  639.     return (FALSE);
  640. }
  641.  
  642. static int NextToOpponent(void)
  643. {
  644.     int   Index1;
  645.     int   Index2;
  646.  
  647.     for (Index1 = -1; Index1 <= 1; Index1++) 
  648.     {
  649.         for (Index2 = -1; Index2 <= 1; Index2++) 
  650.         {
  651.             if  (oBoard[oMoveRow + Index1][oMoveCol + Index2] == oBadGuy)
  652.             {
  653.                 return (TRUE);
  654.             }
  655.         }
  656.     }
  657.  
  658.     return (FALSE);
  659. }
  660.  
  661. static void TakePieces(BOOL ChangeBoard)
  662. {
  663.     int Index;
  664.     int NextSpaceIndex;
  665.     int NextRowIndex;
  666.     int AdjacentRow;
  667.     int NextColIndex;
  668.     int AdjacentCol;                                  
  669.     int s3;
  670.  
  671.     oPiecesTaken = 0;
  672.  
  673.     for (NextSpaceIndex = 0; NextSpaceIndex < 8; NextSpaceIndex++)
  674.     {
  675.         NextRowIndex = oNextRow[NextSpaceIndex];      //  0, -1, -1, -1, 0, 1, 1, 1 
  676.         NextColIndex = oNextCol[NextSpaceIndex];      //  1, 1, 0, -1, -1, -1, 0, 1 
  677.         AdjacentRow  = oMoveRow + NextRowIndex;
  678.         AdjacentCol  = oMoveCol + NextColIndex;
  679.         s3 = 0;
  680.         
  681.         if (oBoard[AdjacentRow][AdjacentCol] == oBadGuy)
  682. g750:  
  683.         {
  684.             s3++;
  685.             AdjacentRow += NextRowIndex;
  686.             AdjacentCol += NextColIndex;
  687.             
  688.             if (oBoard[AdjacentRow][AdjacentCol] == oGoodGuy)
  689.             {
  690.                 oPiecesTaken += s3;
  691.                 
  692.                 if (ChangeBoard)
  693.                 {
  694.                     AdjacentRow = oMoveRow;
  695.                     AdjacentCol = oMoveCol;
  696.                     for (Index = 0; Index <= s3; Index++)
  697.                     {
  698.                         oBoard[AdjacentRow][AdjacentCol] = oGoodGuy;
  699.                         AdjacentRow += NextRowIndex;
  700.                         AdjacentCol += NextColIndex;
  701.                     }
  702.                 } 
  703.             } 
  704.             else
  705.             {
  706.                 if (oBoard[AdjacentRow][AdjacentCol])
  707.                     goto  g750;
  708.             }
  709.  
  710.             goto  g770;
  711.         } 
  712.  
  713. g770:;
  714.  
  715.     }
  716.     return;
  717. }
  718.  
  719. static void DisplayBoard(void)
  720. {
  721.     int ArrayIndex1;
  722.     int ArrayIndex2;
  723.  
  724.     if (NOT oColor)
  725.         OutPut("    A   B   C   D   E   F   G   H ", 2);
  726.     else 
  727.         oBackColor = WHITE;
  728.  
  729.     if (oColor AND (NOT oBoardDisplayed))
  730.     {
  731.         oBoardDisplayed = TRUE;
  732.         BuffFile("Othello.Scn");
  733.     }
  734.  
  735.     for (ArrayIndex1 = 1; ArrayIndex1 <= 8; ArrayIndex1++)
  736.     {
  737.         if (NOT oColor)
  738.             sprintf(oTempString , "%d", ArrayIndex1);
  739.  
  740.         for (ArrayIndex2 = 1; ArrayIndex2 <= 8; ArrayIndex2++)
  741.         {
  742.             if (NOT oColor)
  743.             {
  744.                 strcat(oTempString , "   ");
  745.                 strcat(oTempString , oPieceType[oBoard[ArrayIndex1][ArrayIndex2] + 1]);
  746.             }
  747.             else
  748.             {
  749.                 if (oBoard[ArrayIndex1][ArrayIndex2] != oWasBoard[ArrayIndex1][ArrayIndex2])
  750.                 {
  751.                     oWasBoard[ArrayIndex1][ArrayIndex2] = oBoard[ArrayIndex1][ArrayIndex2];
  752.  
  753.                     oForeColor = (oBoard[ArrayIndex1][ArrayIndex2] == oRed) ? RED : BLACK;
  754.  
  755.                     sprintf(oTempString, "\x1B[%d;%dH█████", oANSIRow[ArrayIndex1 - 1], oANSICol[ArrayIndex2 - 1]);
  756.  
  757.                     OutPut(oTempString, 0);
  758.                 }
  759.             }
  760.         }
  761.  
  762.         if (NOT oColor)
  763.             OutPut(oTempString, 2);
  764.     }
  765.  
  766.     if (oColor)
  767.     {
  768.         oBackColor = BLACK;
  769.         WipeLine(22);
  770.     }
  771.  
  772.     return;
  773. }
  774.  
  775. static void WipeLine(int RowNumber)
  776. {
  777.     char WipeString[30];
  778.  
  779.     sprintf(WipeString, "\x1B[%d;1H\x1B[K\x1B[13C", RowNumber);
  780.  
  781.     OutPut(WipeString, 0);
  782.  
  783.     return;
  784. }
  785.  
  786. static void AskHandicap(void)
  787. {
  788.     oForeColor = GREEN;
  789.  
  790.     if (YorN("Do you wish to be given a handicap (i.e. Do you want a headstart) ([Y]/N)? "))
  791.     {
  792.         HumanGetsHandicap();
  793.     }
  794.     else
  795.     {
  796.         if (YorN("Do you wish to give me a handicap (i.e. Do you want a hard time) ([Y]/N)? "))
  797.         {
  798.             oHandicapRecipient = oComputer;
  799.             AskCorners();
  800.             oHandicap = oCornersSacrificed * 2.5;
  801.             oComputerPieces += oCornersSacrificed;
  802.         } 
  803.     }
  804.  
  805.     return;
  806. }
  807.  
  808. static void HumanGetsHandicap(void)
  809. {
  810.     oHandicapRecipient = oHuman;
  811.     AskCorners();
  812.     oHandicap = oCornersSacrificed * (-8);
  813.     oHumanPieces += oCornersSacrificed;
  814.  
  815.     return;
  816. }
  817.  
  818. static int CornerCol[4] = { 1, 1, 8, 8 };
  819. static int CornerRow[4] = { 1, 8, 8, 1 };
  820.  
  821. static void AskCorners(void)
  822. {
  823.     int Index;
  824.     int ArrayIndex1;
  825.     int ArrayIndex2;
  826.  
  827.     Input("How many corners (1-4) ", 0, 1);
  828.     oCornersSacrificed = (int) oArgValue;
  829.      
  830.     if (oCornersSacrificed > 4)
  831.     {
  832.         HumanGetsHandicap();
  833.         return;
  834.     } 
  835.      
  836.     if  (oCornersSacrificed < 1)
  837.     {
  838.         HumanGetsHandicap();
  839.         return;
  840.     } 
  841.     for (Index = 0; Index < oCornersSacrificed; Index++)
  842.     {
  843.         ArrayIndex1 = CornerCol[Index];
  844.         ArrayIndex2 = CornerRow[Index];
  845.         oBoard[ArrayIndex1][ArrayIndex2] = oHandicapRecipient;
  846.     }
  847.  
  848.     oSpacesTaken += oCornersSacrificed;
  849.  
  850.     return;
  851. }
  852.  
  853. void EndGame(void)
  854. {
  855.     exit (0);
  856. }
  857.  
  858. //////////////////////////////////////////////////////////
  859. // Output uses printf for its dirty work..  line feeds
  860. // are done separately in a loop according to the number
  861. // of LF's asked for.
  862. //
  863. // If the user has ANSI color, then a color string is sent
  864. // before each line (remember this is an example....)
  865. void OutPut(char *String, int NumLineFeeds)
  866. {
  867.     int Index;
  868.  
  869.     ANSIString(oForeColor, oBackColor);
  870.  
  871.     printf(String);
  872.  
  873.     for (Index = 0; Index < NumLineFeeds; Index++)
  874.         printf("\r\n");
  875.  
  876.     fflush(stdout);
  877.  
  878.     return;
  879. }
  880.  
  881. /////////////////////////////////////////////////////////
  882. // Input - we want to control the maximum length of the
  883. // input, and possibly as for upper case, or get keystrokes
  884. // in hot key mode.
  885. //
  886. int Input(char *Prompt, int Flags, int MaxLength)
  887. {
  888.     int Index = 0;
  889.     int CharIn;
  890.     time_t SleepTime;
  891.  
  892.     OutPut(Prompt, 0);
  893.  
  894.     memset(oTempString, 0, 512);
  895.  
  896.     if (MaxLength > 511)
  897.         MaxLength = 511;
  898.  
  899.     SleepTime = time(NULL) + 240L;
  900.  
  901.     while (1)
  902.     {
  903.         // this call works different from OS/2 command
  904.         // (versus Adept or GMon/2 redirection)
  905.         CharIn = getchar();
  906.  
  907.         if (CharIn != EOF)
  908.         {
  909.             SleepTime = time(NULL) + 240L;
  910.  
  911.             if (CharIn == '\r' || CharIn == '\n')
  912.                 break;
  913.  
  914.             if (CharIn == '\b' && Index)
  915.             {
  916.                 printf("\b \b");
  917.                 Index--;
  918.                 continue;
  919.             }
  920.  
  921.             // Ctrl-Y deletes all input
  922.             if (CharIn == 25 && Index)
  923.             {
  924.                 while (Index--)
  925.                     printf("\b \b");
  926.  
  927.                 continue;
  928.             }
  929.  
  930.             if (NOT isprint(CharIn))
  931.                 continue;
  932.  
  933.             fputc(CharIn, stdout);
  934.  
  935.             fflush(stdout);
  936.  
  937.             oTempString[Index++] = (char) CharIn;
  938.             oTempString[Index] = '\0';
  939.  
  940.             if (Index >= MaxLength)
  941.             {
  942.                 if (Flags & TURBO)
  943.                 {
  944.                     break;
  945.                 }
  946.  
  947.                 continue;
  948.             }
  949.         }
  950.         else
  951.         {
  952.             DosSleep(65);
  953.  
  954.             // we just fell asleep
  955.             if (SleepTime < time(NULL))
  956.                 exit(1);
  957.         }
  958.     }
  959.  
  960.     if (Flags & INPUTUCASE)
  961.         strupr(oTempString);
  962.  
  963.     // store value of string, if any
  964.     oArgValue = atoi(oTempString);
  965.  
  966.     // store length of string, if any
  967.     oArgLen = strlen(oTempString);
  968.  
  969.     OutPut("", 1);
  970.  
  971.     return (0);
  972. }
  973.  
  974. ////////////////////////////////////////////////////////
  975. // returns TRUE if Y (default) ... FALSE if N
  976. int YorN(char *YorNQuestion)
  977. {
  978.     int temp;
  979.  
  980.     do
  981.     {
  982.         Input(YorNQuestion, TURBO | INPUTUCASE, 1);
  983.  
  984.         temp = (int) *oTempString;
  985.  
  986.         if ((temp == 0) OR (temp == 'Y') OR (temp == 'N'))
  987.             break;
  988.  
  989.     } while(1);
  990.  
  991.     *oTempString = '\0';
  992.  
  993.     if ((temp == 'Y') OR (temp == 0))
  994.         return (TRUE);
  995.     else
  996.         return (FALSE);
  997. }
  998.  
  999. void ANSIString(int ForeColor, int BackColor)
  1000. {
  1001.     int StrIndex;
  1002.     char ANSIStrBuff[20];
  1003.  
  1004.     if (NOT oColor)
  1005.         return;
  1006.  
  1007.     StrIndex = sprintf(ANSIStrBuff, "\x1B[%s", oBright ? "1;" : "");
  1008.  
  1009.     StrIndex += sprintf(ANSIStrBuff + StrIndex, "%d;", ForeColor + 30);
  1010.  
  1011.     StrIndex += sprintf(ANSIStrBuff + StrIndex, "%d", BackColor + 40);
  1012.  
  1013.     sprintf(ANSIStrBuff + StrIndex, "m");
  1014.  
  1015.     if (strlen(ANSIStrBuff) < 4)   //  ie. '\x1B[m'
  1016.         *ANSIStrBuff = '\0';
  1017.  
  1018.     printf(ANSIStrBuff);
  1019.  
  1020.     fflush(stdout);    
  1021.  
  1022.     return;
  1023. }
  1024.  
  1025. //////////////////////////////////////////////////////////////////////
  1026. // Read text file and display it to user
  1027. //
  1028. void BuffFile(char *FileToView)
  1029. {
  1030.     int BuffFileHandle, GraphicsHold;
  1031.     ULONG  BufferSize = 512;
  1032.     char  *FileBuffer;
  1033.     char  BuffFileName[80];
  1034.     char *ThisLine, *NextLine, *EndBuffer;
  1035.     int  BytesRead;
  1036.  
  1037.     strcpy(BuffFileName, FileToView);
  1038.  
  1039.     BuffFileHandle = sopen(BuffFileName, O_RDWR | O_TEXT, SH_DENYNO);
  1040.  
  1041.     if (BuffFileHandle == -1) // no file present
  1042.         return;
  1043.  
  1044.     BufferSize = (ULONG) (filelength(BuffFileHandle) + 2);
  1045.  
  1046.     FileBuffer = (char *) calloc(1, BufferSize);
  1047.  
  1048.     if (FileBuffer == NULL)
  1049.     {
  1050.         close(BuffFileHandle);
  1051.  
  1052.         return;
  1053.     }
  1054.  
  1055.     GraphicsHold = oColor;                 // color always off here.. so remember
  1056.  
  1057.     // stop ANSI color string from being displayed
  1058.     // in front of each line of file
  1059.     oColor = FALSE;                      // graphics status
  1060.  
  1061.     BytesRead = read(BuffFileHandle, FileBuffer, BufferSize - 2);
  1062.  
  1063.     if (BytesRead > 1)
  1064.     {
  1065.         EndBuffer = FileBuffer + BytesRead;
  1066.  
  1067.         ThisLine = FileBuffer;
  1068.  
  1069.         while (ThisLine)
  1070.         {
  1071.             NextLine = strchr(ThisLine, '\n');
  1072.  
  1073.             if (NextLine)
  1074.                 *NextLine++ = '\0';
  1075.  
  1076.             OutPut(ThisLine, 1);
  1077.  
  1078.             ThisLine = NextLine;
  1079.  
  1080.             if (ThisLine >= EndBuffer)
  1081.                 break;
  1082.         }
  1083.     }
  1084.  
  1085.     close(BuffFileHandle);
  1086.  
  1087.     free(FileBuffer);                  // free file buffer
  1088.  
  1089.     oColor = GraphicsHold;           // remember graphics mode
  1090.  
  1091.     return;
  1092. }
  1093.  
  1094.  
  1095.  
  1096. //////////// Random Number functions ///////////////
  1097.  
  1098. float Zero2OneRand(void)
  1099. {
  1100.     short rand_result;
  1101.  
  1102.     rand_result = rand();
  1103.  
  1104.     return ((float) rand_result / 32767.0);
  1105. }
  1106.  
  1107. ULONG rand_a;
  1108.  
  1109. void Randomize(void)
  1110. {
  1111.     srand((ULONG) time(NULL));
  1112.  
  1113.     rand_a = (ULONG) rand();
  1114.  
  1115.     srand(Random(1, (ULONG) 65535));
  1116.  
  1117.     return;
  1118. }
  1119.  
  1120. // ***************************************************************************
  1121. // * These routines are random number generators 2 have a setable range      *
  1122. // * of numbers, and one returns a float between 0 and 1                     *
  1123. // ***************************************************************************
  1124.  
  1125. ULONG rand_m  = 100000000;
  1126. ULONG rand_m1 = 10000;
  1127. ULONG rand_b  = 31415821;
  1128.  
  1129. ULONG Random(ULONG Low, ULONG High)
  1130. {
  1131.     rand_a = (ULONG) ((mult((ULONG) rand_a, (ULONG) rand_b) + 1) MOD rand_m);
  1132.     High = (ULONG) ((((rand_a / rand_m1) * (ULONG) High) / rand_m1) + 1);
  1133.     High -= Low;
  1134.  
  1135.     return (High);
  1136. }
  1137.  
  1138. ULONG mult(ULONG p, ULONG q)
  1139. {
  1140.     ULONG multie;
  1141.     ULONG p0, p1, q0, q1;
  1142.  
  1143.     p0 = (p MOD (ULONG) rand_m1);
  1144.     p1 = (p /   (ULONG) rand_m1);
  1145.     q0 = (q MOD (ULONG) rand_m1);
  1146.     q1 = (q /   (ULONG) rand_m1);
  1147.     multie = (ULONG) (((((p0 * q1) + (p1 * q0)) MOD rand_m1) * rand_m1 + (p0 * q0)) MOD rand_m);
  1148.  
  1149.     return (multie);
  1150. }
  1151.  
  1152. //////////////////////////////////////////////////////////
  1153. // Code to extract color (yes/no) flag from Session info
  1154. ///////////////////////////////////////////////////////////
  1155. char *SkipWhiteSpace(char *String);
  1156. char *SkipNonWhiteSpace(char *String);
  1157.  
  1158. void ReadSessionInfo(char *SessionInfoName)
  1159. {
  1160.     FILE *SessionInfoHandle;
  1161.     char  Input[301];
  1162.     int   Key;
  1163.     char *Keyword;
  1164.     char *Data;
  1165.     char *NewLine;
  1166.  
  1167.     SessionInfoHandle = fopen(SessionInfoName, "rt");
  1168.  
  1169.     if (SessionInfoHandle == NULL)
  1170.     {
  1171.         fprintf(stderr, "\n\rSession.Info interface. ");
  1172.         fprintf(stderr, "Can't open '%s'\n\r", SessionInfoName);
  1173.         DosSleep(2000);
  1174.         exit(1);
  1175.     }
  1176.  
  1177.     while (NOT feof(SessionInfoHandle))
  1178.     {
  1179.         if (NOT fgets(Input, 301, SessionInfoHandle))
  1180.             break;
  1181.  
  1182.         if (*Input == ';')
  1183.         {
  1184.             // comment line
  1185.             continue;
  1186.         }
  1187.  
  1188.         NewLine = strchr(Input, '\n');
  1189.  
  1190.         if (NewLine)
  1191.             *NewLine = '\0';
  1192.  
  1193.         Keyword = Input;
  1194.  
  1195.         Data = SkipNonWhiteSpace(Keyword);
  1196.  
  1197.         if (*Data)
  1198.         {
  1199.             *Data++ = '\0';
  1200.  
  1201.             Data = SkipWhiteSpace(Data);
  1202.  
  1203.             // Data now points to data!
  1204.         }
  1205.  
  1206.         // look for ANSICOLOR keyword,
  1207.         // and act on it.
  1208.         if (NOT stricmp(Keyword, "ANSICOLOR"))
  1209.         {
  1210.             oColor = atoi(Data);
  1211.  
  1212.             // all done.. ferget rest o' file
  1213.             break;
  1214.         }
  1215.  
  1216.     }
  1217.  
  1218.     fclose(SessionInfoHandle);
  1219.  
  1220.     return;
  1221. }
  1222.  
  1223. static char *SkipWhiteSpace(char *String)
  1224. {
  1225.     char *p = String;
  1226.  
  1227.     while (*p == ' ' || *p == '\t')
  1228.         p++;
  1229.  
  1230.     return (p);
  1231. }
  1232.  
  1233. static char *SkipNonWhiteSpace(char *String)
  1234. {
  1235.     char *p = String;
  1236.  
  1237.     while (*p && *p != ' ' && *p != '\t')
  1238.         p++;
  1239.  
  1240.     return (p);
  1241. }
  1242.  
  1243.