740 lines
16 KiB
C
740 lines
16 KiB
C
/* gomoku - 5 in a row game Author: ? */
|
|
|
|
/* This program plays a very old Japanese game called GO-MOKU,
|
|
perhaps better known as 5-in-line. The game is played on
|
|
a board with 19 x 19 squares, and the object of the game is
|
|
to get 5 stones in a row.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#include <curses.h>
|
|
#include <ctype.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
|
|
/* Size of the board */
|
|
#define SIZE 19
|
|
|
|
/* Importance of attack (1..16) */
|
|
#define AttackFactor 4
|
|
|
|
/* Value of having 0, 1,2,3,4 or 5 pieces in line */
|
|
int Weight[7] = {0, 0, 4, 20, 100, 500, 0};
|
|
|
|
#define Null 0
|
|
#define Horiz 1
|
|
#define DownLeft 2
|
|
#define DownRight 3
|
|
#define Vert 4
|
|
|
|
/* The two players */
|
|
#define Empty 0
|
|
#define Cross 1
|
|
#define Nought 2
|
|
|
|
char PieceChar[Nought + 1] = {' ', 'X', '0'};
|
|
|
|
int Board[SIZE + 1][SIZE + 1];/* The board */
|
|
int Player; /* The player whose move is next */
|
|
int TotalLines; /* The number of Empty lines left */
|
|
int GameWon; /* Set if one of the players has won */
|
|
|
|
int Line[4][SIZE + 1][SIZE + 1][Nought + 1];
|
|
|
|
/* Value of each square for each player */
|
|
int Value[SIZE + 1][SIZE + 1][Nought + 1];
|
|
|
|
int X, Y; /* Move coordinates */
|
|
char Command; /* Command from keyboard */
|
|
int AutoPlay = FALSE; /* The program plays against itself */
|
|
|
|
_PROTOTYPE(void Initialize, (void));
|
|
_PROTOTYPE(int Abort, (char *s));
|
|
_PROTOTYPE(void WriteLetters, (void));
|
|
_PROTOTYPE(void WriteLine, (int j, int *s));
|
|
_PROTOTYPE(void WriteBoard, (int N, int *Top, int *Middle, int *Bottom));
|
|
_PROTOTYPE(void SetUpScreen, (void));
|
|
_PROTOTYPE(void GotoSquare, (int x, int y));
|
|
_PROTOTYPE(void PrintMove, (int Piece, int X, int Y));
|
|
_PROTOTYPE(void ClearMove, (void));
|
|
_PROTOTYPE(void PrintMsg, (char *Str));
|
|
_PROTOTYPE(void ClearMsg, (void));
|
|
_PROTOTYPE(void WriteCommand, (char *S));
|
|
_PROTOTYPE(void ResetGame, (int FirstGame));
|
|
_PROTOTYPE(int OpponentColor, (int Player));
|
|
_PROTOTYPE(void BlinkRow, (int X, int Y, int Dx, int Dy, int Piece));
|
|
_PROTOTYPE(void BlinkWinner, (int Piece, int X, int Y, int WinningLine));
|
|
_PROTOTYPE(int Random, (int x));
|
|
_PROTOTYPE(void Add, (int *Num));
|
|
_PROTOTYPE(void Update, (int Lin[], int Valu[], int Opponent));
|
|
_PROTOTYPE(void MakeMove, (int X, int Y));
|
|
_PROTOTYPE(int GameOver, (void));
|
|
_PROTOTYPE(void FindMove, (int *X, int *Y));
|
|
_PROTOTYPE(char GetChar, (void));
|
|
_PROTOTYPE(void ReadCommand, (int X, int Y, char *Command));
|
|
_PROTOTYPE(void InterpretCommand, (int Command));
|
|
_PROTOTYPE(void PlayerMove, (void));
|
|
_PROTOTYPE(void ProgramMove, (void));
|
|
_PROTOTYPE(int main, (void));
|
|
|
|
/* Set terminal to raw mode. */
|
|
void Initialize()
|
|
{
|
|
srand(getpid() + 13); /* Initialize the random seed with our pid */
|
|
initscr();
|
|
raw();
|
|
noecho();
|
|
clear();
|
|
}
|
|
|
|
/* Reset terminal and exit from the program. */
|
|
int Abort(s)
|
|
char *s;
|
|
{
|
|
move(LINES - 1, 0);
|
|
refresh();
|
|
endwin();
|
|
exit(0);
|
|
}
|
|
|
|
/* Set up the screen ----------------------------------------------- */
|
|
|
|
/* Write the letters */
|
|
void WriteLetters()
|
|
{
|
|
int i;
|
|
|
|
addch(' ');
|
|
addch(' ');
|
|
for (i = 1; i <= SIZE; i++) printw(" %c", 'A' + i - 1);
|
|
addch('\n');
|
|
}
|
|
|
|
/* Write one line of the board */
|
|
void WriteLine(j, s)
|
|
int j;
|
|
int *s;
|
|
{
|
|
int i;
|
|
|
|
printw("%2d ", j);
|
|
addch(s[0]);
|
|
for (i = 2; i <= SIZE - 1; i++) {
|
|
addch(s[1]);
|
|
addch(s[2]);
|
|
}
|
|
addch(s[1]);
|
|
addch(s[3]);
|
|
printw(" %-2d\n", j);
|
|
}
|
|
|
|
/* Print the Empty board and the border */
|
|
void WriteBoard(N, Top, Middle, Bottom)
|
|
int N;
|
|
int *Top, *Middle, *Bottom;
|
|
{
|
|
int j;
|
|
|
|
move(1, 0);
|
|
WriteLetters();
|
|
WriteLine(N, Top);
|
|
for (j = N - 1; j >= 2; j--) WriteLine(j, Middle);
|
|
WriteLine(1, Bottom);
|
|
WriteLetters();
|
|
}
|
|
|
|
/* Sets up the screen with an Empty board */
|
|
void SetUpScreen()
|
|
{
|
|
int top[4], middle[4], bottom[4];
|
|
|
|
top[0] = ACS_ULCORNER;
|
|
top[1] = ACS_HLINE;
|
|
top[2] = ACS_TTEE;
|
|
top[3] = ACS_URCORNER;
|
|
|
|
middle[0] = ACS_LTEE;
|
|
middle[1] = ACS_HLINE;
|
|
middle[2] = ACS_PLUS;
|
|
middle[3] = ACS_RTEE;
|
|
|
|
bottom[0] = ACS_LLCORNER;
|
|
bottom[1] = ACS_HLINE;
|
|
bottom[2] = ACS_BTEE;
|
|
bottom[3] = ACS_LRCORNER;
|
|
|
|
WriteBoard(SIZE, top, middle, bottom);
|
|
}
|
|
|
|
/* Show moves ----------------------------------------------- */
|
|
|
|
void GotoSquare(x, y)
|
|
int x, y;
|
|
{
|
|
move(SIZE + 2 - y, 1 + x * 2);
|
|
}
|
|
|
|
/* Prints a move */
|
|
void PrintMove(Piece, X, Y)
|
|
int Piece;
|
|
int X, Y;
|
|
{
|
|
move(22, 49);
|
|
printw("%c %c %d", PieceChar[Piece], 'A' + X - 1, Y);
|
|
clrtoeol();
|
|
GotoSquare(X, Y);
|
|
addch(PieceChar[Piece]);
|
|
GotoSquare(X, Y);
|
|
refresh();
|
|
}
|
|
|
|
/* Clears the line where a move is displayed */
|
|
void ClearMove()
|
|
{
|
|
move(22, 49);
|
|
clrtoeol();
|
|
}
|
|
|
|
/* Message handling ---------------------------------------------- */
|
|
|
|
/* Prints a message */
|
|
void PrintMsg(Str)
|
|
char *Str;
|
|
{
|
|
mvprintw(23, 1, "%s", Str);
|
|
}
|
|
|
|
/* Clears the message about the winner */
|
|
void ClearMsg()
|
|
{
|
|
move(23, 1);
|
|
clrtoeol();
|
|
}
|
|
|
|
/* Highlights the first letter of S */
|
|
void WriteCommand(S)
|
|
char *S;
|
|
{
|
|
standout();
|
|
addch(*S);
|
|
standend();
|
|
printw("%s", S + 1);
|
|
}
|
|
|
|
/* Display the board ----------------------------------------------- */
|
|
|
|
/* Resets global variables to start a new game */
|
|
void ResetGame(FirstGame)
|
|
int FirstGame;
|
|
{
|
|
int I, J;
|
|
int C, D;
|
|
|
|
SetUpScreen();
|
|
if (FirstGame) {
|
|
move(1, 49);
|
|
addstr("G O M O K U");
|
|
move(3, 49);
|
|
WriteCommand("Newgame ");
|
|
WriteCommand("Quit ");
|
|
move(5, 49);
|
|
WriteCommand("Auto");
|
|
move(7, 49);
|
|
WriteCommand("Play");
|
|
move(9, 49);
|
|
WriteCommand("Hint");
|
|
move(14, 60);
|
|
WriteCommand("Left, ");
|
|
WriteCommand("Right, ");
|
|
move(16, 60);
|
|
WriteCommand("Up, ");
|
|
WriteCommand("Down");
|
|
move(18, 60);
|
|
standout();
|
|
addstr("SPACE");
|
|
move(20, 49);
|
|
WriteCommand(" NOTE: Use Num Lock & arrows");
|
|
standend();
|
|
mvaddstr(14, 49, "7 8 9");
|
|
mvaddch(15, 52, ACS_UARROW);
|
|
mvaddch(16, 49, '4');
|
|
addch(ACS_LARROW);
|
|
mvaddch(16, 54, ACS_RARROW);
|
|
addch('6');
|
|
mvaddch(17, 52, ACS_DARROW);
|
|
mvaddstr(18, 49, "1 2 3");
|
|
FirstGame = FALSE;
|
|
} else {
|
|
ClearMsg();
|
|
ClearMove();
|
|
}
|
|
|
|
/* Clear tables */
|
|
for (I = 1; I <= SIZE; I++) for (J = 1; J <= SIZE; J++) {
|
|
Board[I][J] = Empty;
|
|
for (C = Cross; C <= Nought; C++) {
|
|
Value[I][J][C] = 0;
|
|
for (D = 0; D <= 3; D++) Line[D][I][J][C] = 0;
|
|
}
|
|
}
|
|
|
|
/* Cross starts */
|
|
Player = Cross;
|
|
/* Total number of lines */
|
|
TotalLines = 2 * 2 * (SIZE * (SIZE - 4) + (SIZE - 4) * (SIZE - 4));
|
|
GameWon = FALSE;
|
|
}
|
|
|
|
int OpponentColor(Player)
|
|
int Player;
|
|
{
|
|
if (Player == Cross)
|
|
return Nought;
|
|
else
|
|
return Cross;
|
|
}
|
|
|
|
/* Blink the row of 5 stones */
|
|
void BlinkRow(X, Y, Dx, Dy, Piece)
|
|
int X, Y, Dx, Dy, Piece;
|
|
{
|
|
int I;
|
|
|
|
attron(A_BLINK);
|
|
for (I = 1; I <= 5; I++) {
|
|
GotoSquare(X, Y);
|
|
addch(PieceChar[Piece]);
|
|
X = X - Dx;
|
|
Y = Y - Dy;
|
|
}
|
|
attroff(A_BLINK);
|
|
}
|
|
|
|
/* Prints the 5 winning stones in blinking color */
|
|
void BlinkWinner(Piece, X, Y, WinningLine)
|
|
int Piece, X, Y, WinningLine;
|
|
{
|
|
/* Used to store the position of the winning move */
|
|
int XHold, YHold;
|
|
/* Change in X and Y */
|
|
int Dx, Dy;
|
|
|
|
/* Display winning move */
|
|
PrintMove(Piece, X, Y);
|
|
/* Preserve winning position */
|
|
XHold = X;
|
|
YHold = Y;
|
|
switch (WinningLine) {
|
|
case Horiz:
|
|
{
|
|
Dx = 1;
|
|
Dy = 0;
|
|
break;
|
|
}
|
|
|
|
case DownLeft:
|
|
{
|
|
Dx = 1;
|
|
Dy = 1;
|
|
break;
|
|
}
|
|
|
|
case Vert:
|
|
{
|
|
Dx = 0;
|
|
Dy = 1;
|
|
break;
|
|
}
|
|
|
|
case DownRight:
|
|
{
|
|
Dx = -1;
|
|
Dy = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Go to topmost, leftmost */
|
|
while (Board[X + Dx][Y + Dy] != Empty && Board[X + Dx][Y + Dy] == Piece) {
|
|
X = X + Dx;
|
|
Y = Y + Dy;
|
|
}
|
|
BlinkRow(X, Y, Dx, Dy, Piece);
|
|
/* Restore winning position */
|
|
X = XHold;
|
|
Y = YHold;
|
|
/* Go back to winning square */
|
|
GotoSquare(X, Y);
|
|
}
|
|
|
|
/* Functions for playing a game -------------------------------- */
|
|
|
|
int Random(x)
|
|
int x;
|
|
{
|
|
return((rand() / 19) % x);
|
|
}
|
|
|
|
/* Adds one to the number of pieces in a line */
|
|
void Add(Num)
|
|
int *Num;
|
|
{
|
|
/* Adds one to the number. */
|
|
*Num = *Num + 1;
|
|
/* If it is the first piece in the line, then the opponent cannot use
|
|
* it any more. */
|
|
if (*Num == 1) TotalLines = TotalLines - 1;
|
|
/* The game is won if there are 5 in line. */
|
|
if (*Num == 5) GameWon = TRUE;
|
|
}
|
|
|
|
/* Updates the value of a square for each player, taking into
|
|
account that player has placed an extra piece in the square.
|
|
The value of a square in a usable line is Weight[Lin[Player]+1]
|
|
where Lin[Player] is the number of pieces already placed
|
|
in the line */
|
|
void Update(Lin, Valu, Opponent)
|
|
int Lin[];
|
|
int Valu[];
|
|
int Opponent;
|
|
{
|
|
/* If the opponent has no pieces in the line, then simply update the
|
|
* value for player */
|
|
if (Lin[Opponent] == 0)
|
|
Valu[Player] += Weight[Lin[Player] + 1] - Weight[Lin[Player]];
|
|
else
|
|
/* If it is the first piece in the line, then the line is
|
|
* spoiled for the opponent */
|
|
if (Lin[Player] == 1) Valu[Opponent] -= Weight[Lin[Opponent] + 1];
|
|
}
|
|
|
|
/* Performs the move X,Y for player, and updates the global variables
|
|
(Board, Line, Value, Player, GameWon, TotalLines and the screen) */
|
|
void MakeMove(X, Y)
|
|
int X, Y;
|
|
{
|
|
int Opponent;
|
|
int X1, Y1;
|
|
int K, L, WinningLine;
|
|
|
|
WinningLine = Null;
|
|
Opponent = OpponentColor(Player);
|
|
GameWon = FALSE;
|
|
|
|
/* Each square of the board is part of 20 different lines. The adds
|
|
* one to the number of pieces in each of these lines. Then it
|
|
* updates the value for each of the 5 squares in each of the 20
|
|
* lines. Finally Board is updated, and the move is printed on the
|
|
* screen. */
|
|
|
|
/* Horizontal lines, from left to right */
|
|
for (K = 0; K <= 4; K++) {
|
|
X1 = X - K; /* Calculate starting point */
|
|
Y1 = Y;
|
|
if ((1 <= X1) && (X1 <= SIZE - 4)) { /* Check starting point */
|
|
Add(&Line[0][X1][Y1][Player]); /* Add one to line */
|
|
if (GameWon && (WinningLine == Null)) /* Save winning line */
|
|
WinningLine = Horiz;
|
|
for (L = 0; L <= 4; L++) /* Update value for the
|
|
* 5 squares in the line */
|
|
Update(Line[0][X1][Y1], Value[X1 + L][Y1], Opponent);
|
|
}
|
|
}
|
|
|
|
for (K = 0; K <= 4; K++) { /* Diagonal lines, from lower left to
|
|
* upper right */
|
|
X1 = X - K;
|
|
Y1 = Y - K;
|
|
if ((1 <= X1) && (X1 <= SIZE - 4) &&
|
|
(1 <= Y1) && (Y1 <= SIZE - 4)) {
|
|
Add(&Line[1][X1][Y1][Player]);
|
|
if (GameWon && (WinningLine == Null)) /* Save winning line */
|
|
WinningLine = DownLeft;
|
|
for (L = 0; L <= 4; L++)
|
|
Update(Line[1][X1][Y1], Value[X1 + L][Y1 + L], Opponent);
|
|
}
|
|
} /* for */
|
|
|
|
for (K = 0; K <= 4; K++) { /* Diagonal lines, down right to upper left */
|
|
X1 = X + K;
|
|
Y1 = Y - K;
|
|
if ((5 <= X1) && (X1 <= SIZE) &&
|
|
(1 <= Y1) && (Y1 <= SIZE - 4)) {
|
|
Add(&Line[3][X1][Y1][Player]);
|
|
if (GameWon && (WinningLine == Null)) /* Save winning line */
|
|
WinningLine = DownRight;
|
|
for (L = 0; L <= 4; L++)
|
|
Update(Line[3][X1][Y1], Value[X1 - L][Y1 + L], Opponent);
|
|
}
|
|
} /* for */
|
|
|
|
for (K = 0; K <= 4; K++) { /* Vertical lines, from down to up */
|
|
X1 = X;
|
|
Y1 = Y - K;
|
|
if ((1 <= Y1) && (Y1 <= SIZE - 4)) {
|
|
Add(&Line[2][X1][Y1][Player]);
|
|
if (GameWon && (WinningLine == Null)) /* Save winning line */
|
|
WinningLine = Vert;
|
|
for (L = 0; L <= 4; L++)
|
|
Update(Line[2][X1][Y1], Value[X1][Y1 + L], Opponent);
|
|
}
|
|
}
|
|
|
|
Board[X][Y] = Player; /* Place piece in board */
|
|
if (GameWon)
|
|
BlinkWinner(Player, X, Y, WinningLine);
|
|
else
|
|
PrintMove(Player, X, Y);/* Print move on screen */
|
|
Player = Opponent; /* The opponent is next to move */
|
|
}
|
|
|
|
int GameOver()
|
|
/* A game is over if one of the players have
|
|
won, or if there are no more Empty lines */
|
|
{
|
|
return(GameWon || (TotalLines <= 0));
|
|
}
|
|
|
|
/* Finds a move X,Y for player, simply by picking the one with the
|
|
highest value */
|
|
void FindMove(X, Y)
|
|
int *X, *Y;
|
|
{
|
|
int Opponent;
|
|
int I, J;
|
|
int Max, Valu;
|
|
|
|
Opponent = OpponentColor(Player);
|
|
Max = -10000;
|
|
/* If no square has a high value then pick the one in the middle */
|
|
*X = (SIZE + 1) / 2;
|
|
*Y = (SIZE + 1) / 2;
|
|
if (Board[*X][*Y] == Empty) Max = 4;
|
|
/* The evaluation for a square is simply the value of the square for
|
|
* the player (attack points) plus the value for the opponent
|
|
* (defense points). Attack is more important than defense, since it
|
|
* is better to get 5 in line yourself than to prevent the op- ponent
|
|
* from getting it. */
|
|
|
|
/* For all Empty squares */
|
|
for (I = 1; I <= SIZE; I++) for (J = 1; J <= SIZE; J++)
|
|
if (Board[I][J] == Empty) {
|
|
/* Calculate evaluation */
|
|
Valu = Value[I][J][Player] * (16 + AttackFactor) / 16 + Value[I][J][Opponent] + Random(4);
|
|
/* Pick move with highest value */
|
|
if (Valu > Max) {
|
|
*X = I;
|
|
*Y = J;
|
|
Max = Valu;
|
|
}
|
|
}
|
|
}
|
|
|
|
char GetChar()
|
|
/* Get a character from the keyboard */
|
|
{
|
|
int c;
|
|
|
|
c = getch();
|
|
if (c < 0) abort();
|
|
if (c == '\033') { /* arrow key */
|
|
if ((c = getch()) == '[') {
|
|
c = getch();
|
|
switch (c) {
|
|
case 'A': c = 'U'; break;
|
|
case 'B': c = 'D'; break;
|
|
case 'C': c = 'R'; break;
|
|
case 'D': c = 'L'; break;
|
|
default:
|
|
c = '?';
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
c = '?';
|
|
}
|
|
if (islower(c))
|
|
return toupper(c);
|
|
else
|
|
return c;
|
|
}
|
|
|
|
/* Reads in a valid command character */
|
|
void ReadCommand(X, Y, Command)
|
|
int X, Y;
|
|
char *Command;
|
|
{
|
|
int ValidCommand;
|
|
|
|
do {
|
|
ValidCommand = TRUE;
|
|
GotoSquare(X, Y); /* Goto square */
|
|
refresh();
|
|
*Command = GetChar(); /* Read from keyboard */
|
|
switch (*Command) {
|
|
case '\n': /* '\n', '\r' or space means place a */
|
|
case '\r':
|
|
case ' ':
|
|
*Command = 'E';
|
|
break; /* stone at the cursor position */
|
|
|
|
case 'L':
|
|
case 'R':
|
|
case 'U':
|
|
case 'D':
|
|
case '7':
|
|
case '9':
|
|
case '1':
|
|
case '3':
|
|
case 'N':
|
|
case 'Q':
|
|
case 'A':
|
|
case 'P':
|
|
case 'H':
|
|
break;
|
|
|
|
case '8': *Command = 'U'; break;
|
|
case '2': *Command = 'D'; break;
|
|
case '4': *Command = 'L'; break;
|
|
case '6': *Command = 'R'; break;
|
|
default:
|
|
{
|
|
if (GameOver())
|
|
*Command = 'P';
|
|
else
|
|
ValidCommand = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
} while (!ValidCommand);
|
|
}
|
|
|
|
void InterpretCommand(Command)
|
|
char Command;
|
|
{
|
|
int Temp;
|
|
|
|
switch (Command) {
|
|
case 'N':{ /* Start new game */
|
|
ResetGame(FALSE); /* ResetGame but only redraw
|
|
* the board */
|
|
X = (SIZE + 1) / 2;
|
|
Y = X;
|
|
break;
|
|
}
|
|
case 'H':
|
|
FindMove(&X, &Y);
|
|
break; /* Give the user a hint */
|
|
case 'L':
|
|
X = (X + SIZE - 2) % SIZE + 1;
|
|
break; /* Left */
|
|
case 'R':
|
|
X = X % SIZE + 1;
|
|
break; /* Right */
|
|
case 'D':
|
|
Y = (Y + SIZE - 2) % SIZE + 1;
|
|
break; /* Down */
|
|
case 'U':
|
|
Y = Y % SIZE + 1;
|
|
break; /* Up */
|
|
case '7':{
|
|
if ((X == 1) || (Y == SIZE)) { /* Move diagonally *//* t
|
|
* owards upper left */
|
|
Temp = X;
|
|
X = Y;
|
|
Y = Temp;
|
|
} else {
|
|
X = X - 1;
|
|
Y = Y + 1;
|
|
}
|
|
break;
|
|
}
|
|
case '9':{ /* Move diagonally */
|
|
if (X == SIZE) {/* toward upper right */
|
|
X = (SIZE - Y) + 1;
|
|
Y = 1;
|
|
} else if (Y == SIZE) {
|
|
Y = (SIZE - X) + 1;
|
|
X = 1;
|
|
} else {
|
|
X = X + 1;
|
|
Y = Y + 1;
|
|
}
|
|
break;
|
|
}
|
|
case '1':{ /* Move diagonally */
|
|
if (Y == 1) { /* toward lower left */
|
|
Y = (SIZE - X) + 1;
|
|
X = SIZE;
|
|
} else if (X == 1) {
|
|
X = (SIZE - Y) + 1;
|
|
Y = SIZE;
|
|
} else {
|
|
X = X - 1;
|
|
Y = Y - 1;
|
|
}
|
|
break;
|
|
}
|
|
case '3':{ /* Move diagonally */
|
|
if ((X == SIZE) || (Y == 1)) { /* toward lower right */
|
|
Temp = X;
|
|
X = Y;
|
|
Y = Temp;
|
|
} else {
|
|
X = X + 1;
|
|
Y = Y - 1;
|
|
}
|
|
break;
|
|
}
|
|
case 'A':
|
|
AutoPlay = TRUE;
|
|
break; /* Auto play mode */
|
|
} /* case */
|
|
} /* InterpretCommand */
|
|
|
|
void PlayerMove()
|
|
/* Enter and make a move */
|
|
{
|
|
if (Board[X][Y] == Empty) {
|
|
MakeMove(X, Y);
|
|
if (GameWon) PrintMsg("Congratulations, You won!");
|
|
Command = 'P';
|
|
}
|
|
refresh();
|
|
} /* PlayerMove */
|
|
|
|
void ProgramMove()
|
|
/* Find and perform programs move */
|
|
{
|
|
do {
|
|
if (GameOver()) {
|
|
AutoPlay = FALSE;
|
|
if ((Command != 'Q') && (!GameWon)) PrintMsg("Tie game!");
|
|
} else {
|
|
FindMove(&X, &Y);
|
|
MakeMove(X, Y);
|
|
if (GameWon) PrintMsg("I won!");
|
|
}
|
|
refresh();
|
|
} while (AutoPlay);
|
|
}
|
|
|
|
int main()
|
|
{
|
|
Initialize();
|
|
ResetGame(TRUE); /* ResetGame and draw the entire screen */
|
|
refresh();
|
|
X = (SIZE + 1) / 2; /* Set starting position to */
|
|
Y = X; /* the middle of the board */
|
|
do {
|
|
ReadCommand(X, Y, &Command);
|
|
if (GameOver())
|
|
if (Command != 'Q') Command = 'N';
|
|
InterpretCommand(Command);
|
|
if (Command == 'E') PlayerMove();
|
|
if (Command == 'P' || Command == 'A') ProgramMove();
|
|
} while (Command != 'Q');
|
|
Abort("Good bye!");
|
|
return(0);
|
|
}
|