public Reversi()
{
cur_board = new List<List<Board.PIECE>>();
cur_empty_neighbor_list = new List<int>();
b = new Board(cur_board, cur_empty_neighbor_list);
ai = new AI(b, cur_board, cur_empty_neighbor_list);
}
private Bitmap drawBoard(Board b)
{
Bitmap bitmap = new Bitmap(panelBoard.Width, panelBoard.Height);
Graphics g = Graphics.FromImage(bitmap);
int drawWidth = (panelBoard.Width - 1) / b.width;
int drawHeight = (panelBoard.Height - 1) / b.height;
const int pad = 3;
for (int boardX = 0; boardX < b.width; boardX++)
{
for (int boardY = 0; boardY < b.height; boardY++)
{
int drawX = boardX * drawWidth;
int drawY = boardY * drawHeight;
//draw grid
g.DrawRectangle(Pens.Black, drawX, drawY, drawWidth, drawHeight);
//draw player
if (!b.fields[boardX, boardY].IsEmpty())
g.DrawImage(b.fields[boardX, boardY].owner.image, drawX, drawY, drawWidth, drawHeight);
if (checkBoxHelp.Checked)
{
//draw help
if (b.IsValidMove(b.curPlayer, boardX, boardY))
g.DrawEllipse(new Pen(b.curPlayer.color), drawX + drawWidth / 4 + pad + 1, drawY + drawHeight / 4 + pad + 1, drawWidth / 2 - pad * 2,
drawHeight / 2 - pad * 2);
}
}
}
return bitmap;
}
public NewGameForm(Board oldboard)
{
InitializeComponent();
textWidth.Text = oldboard.width.ToString();
textHeight.Text = oldboard.height.ToString();
textName1.Text = oldboard.player1.name;
groupBoxPlayer1.ForeColor = oldboard.player1.color;
textName2.Text = oldboard.player2.name;
groupBoxPlayer2.ForeColor = oldboard.player2.color;
}
private void buttonStart_Click(object sender, EventArgs e)
{
try
{
board = new Board(int.Parse(textWidth.Text), int.Parse(textHeight.Text),
new Player(textName1.Text, Color.Blue, Properties.Resources.ImageEllipseBlue),
new Player(textName2.Text, Color.Red, Properties.Resources.ImageEllipseRed));
Close();
}
catch (Exception)
{
MessageBox.Show("Invalid input, make sure you specify a number in the size field.");
}
}
public ReversiForm()
{
InitializeComponent();
//start new game
board = new Board(6, 6, new Player("Sonic", Color.Blue, Properties.Resources.ImageEllipseBlue),
new Player("Mario", Color.Red, Properties.Resources.ImageEllipseRed));
newGame();
//register events
panelBoard.Paint += pictureBoxBoard_Paint;
panelBoard.MouseClick += panelBoard_MouseClick;
panelBoard.MouseDown += panelBoard_MouseDown;
panelBoard.MouseUp += panelBoard_MouseUp;
}
// Greedy; Choose the Move with Maximum Immediate Gain.
public int Generic_Greedy_AI(Board.PIECE caller, List<int> legal_cand, Board.WEIGHT weight)
{
int max_gain = -10000; int max_gain_idx = -1;
for (int i = 0; i < legal_cand.Count; i++)
{
int h = legal_cand[i] / Board.SIZE, w = legal_cand[i] % Board.SIZE;
int cur_gain = b.place_piece(cur_board, cur_empty_neighbor_list, h, w, caller, Board.MARK.Don_t_mark, weight);
if (cur_gain > max_gain)
{
max_gain = cur_gain;
max_gain_idx = i;
}
}
return legal_cand[max_gain_idx];
}
//
// Creates a new Board object by copying an existing one.
//
public Board(Board board)
{
// Create the squares and map.
this.squares = new int[10, 10];
this.safeDiscs = new bool[10, 10];
// Copy the given board.
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j)
{
this.squares[i, j] = board.squares[i, j];
this.safeDiscs[i, j] = board.safeDiscs[i, j];
}
// Copy the counts.
this.blackCount = board.blackCount;
this.whiteCount = board.whiteCount;
this.emptyCount = board.emptyCount;
this.blackSafeCount = board.blackSafeCount;
this.whiteSafeCount = board.whiteSafeCount;
}
//
// Creates a new Board object by copying an existing one.
//
public Board(Board board)
{
// Create the squares and map.
this.squares = new int[8, 8];
this.safeDiscs = new bool[8, 8];
// Copy the given board.
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
{
this.squares[i, j] = board.squares[i, j];
this.safeDiscs[i, j] = board.safeDiscs[i, j];
}
// Copy the counts.
this.blackCount = board.blackCount;
this.whiteCount = board.whiteCount;
this.emptyCount = board.emptyCount;
this.blackSafeCount = board.blackSafeCount;
this.whiteSafeCount = board.whiteSafeCount;
}
public ReversiForm()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
//
// TODO: Add any constructor code after InitializeComponent call
//
// Create the game board.
this.board = new Board();
// Create the controls for each square, add them to the squares
// panel and set up event handling.
this.squareControls = new SquareControl[8, 8];
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
{
// Create it.
this.squareControls[i, j] = new SquareControl(i, j);
// Position it.
this.squareControls[i, j].Left = j * this.squareControls[i, j].Width;
this.squareControls[i, j].Top = i * this.squareControls[i, j].Height;
// Add it.
this.squaresPanel.Controls.Add(this.squareControls[i, j]);
// Set up event handling for it.
this.squareControls[i, j].MouseMove += new MouseEventHandler(this.SquareControl_MouseMove);
this.squareControls[i, j].MouseLeave += new EventHandler(this.SquareControl_MouseLeave);
this.squareControls[i, j].Click += new EventHandler(this.SquareControl_Click);
}
// Create the column and row labels.
this.colLabels = new Label[8];
for (i = 0; i < 8; i++)
{
// Create a column label.
this.colLabels[i] = new Label();
// Set its display properties.
this.colLabels[i].Text = ReversiForm.alpha.Substring(i, 1);
this.colLabels[i].BackColor = this.cornerLabel.BackColor;
this.colLabels[i].ForeColor = this.cornerLabel.ForeColor;
this.colLabels[i].TextAlign = ContentAlignment.MiddleCenter;
// Set its size and position.
this.colLabels[i].Width = this.squareControls[0, 0].Width;
this.colLabels[i].Height = this.cornerLabel.Height;
this.colLabels[i].Left = this.cornerLabel.Width + i * this.colLabels[0].Width;
this.colLabels[i].Top = 0;
// Add it.
this.boardPanel.Controls.Add(this.colLabels[i]);
}
this.rowLabels = new Label[8];
for (i = 0; i < 8; i++)
{
// Create a row label.
this.rowLabels[i] = new Label();
// Set its display properties.
this.rowLabels[i].Text = (i + 1).ToString();
this.rowLabels[i].BackColor = this.cornerLabel.BackColor;
this.rowLabels[i].ForeColor = this.cornerLabel.ForeColor;
this.rowLabels[i].TextAlign = ContentAlignment.MiddleCenter;
// Set its size and position.
this.rowLabels[i].Width = this.cornerLabel.Height;
this.rowLabels[i].Height = this.squareControls[0, 0].Height;
this.rowLabels[i].Left = 0;
this.rowLabels[i].Top = this.cornerLabel.Height + i * this.rowLabels[0].Width;
// Add it.
this.boardPanel.Controls.Add(this.rowLabels[i]);
}
// Initialize the game state.
this.gameState = ReversiForm.GameState.GameOver;
// Initialize the animation timer.
this.animationTimer.Interval = ReversiForm.animationTimerInterval;
this.animationTimer.Tick += new EventHandler(this.AnimateMove);
// Initialize the window settings.
this.windowSettings = new Rectangle(
this.DesktopLocation.X,
this.DesktopLocation.Y,
this.ClientSize.Width,
this.ClientSize.Height);
// Load any saved program settings.
this.settings = new ProgramSettings(ReversiForm.programSettingsFileName);
this.LoadProgramSettings();
}
int heuristicFunction2(Board newBoard)
{
return newBoard.BlackCount - newBoard.WhiteCount;
}
//
// Makes a move for the current player.
//
private void MakeMove(int row, int col)
{
// Clean up the move history to ensure that it contains only the
// moves made prior to this one.
while (this.moveHistory.Count > this.moveNumber - 1)
this.moveHistory.RemoveAt(this.moveHistory.Count - 1);
// Add the move to the move list.
string color = "Black";
if (this.currentColor == Board.White)
color = "White";
string[] subItems =
{
String.Empty,
this.moveNumber.ToString(),
color,
(alpha[col] + (row + 1).ToString())
};
ListViewItem listItem = new ListViewItem(subItems);
this.moveListView.Items.Add(listItem);
// If necessary, scroll the list to bring the last move into view.
this.moveListView.EnsureVisible(this.moveListView.Items.Count - 1);
// Add this move to the move history.
this.moveHistory.Add(new MoveRecord(this.board, this.currentColor, listItem));
// Enable/disable the move-related menu items and tool bar buttons as
// appropriate.
this.undoMoveMenuItem.Enabled =
this.undoAllMovesMenuItem.Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.UndoMove].Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.UndoAllMoves].Enabled = true;
this.redoMoveMenuItem.Enabled =
this.redoAllMovesMenuItem.Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.RedoMove].Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.RedoAllMoves].Enabled = false;
// Bump the move number.
this.moveNumber++;
// Update the status display.
this.statusLabel.Text = "";
this.statusProgressBar.Visible = false;
this.statusPanel.Refresh();
// Clear any board square highlighting.
this.UnHighlightSquares();
// Make a copy of the board (for doing move animation).
Board oldBoard = new Board(this.board);
// Make the move on the board.
this.board.MakeMove(this.currentColor, row, col);
// If the animate move option is active, set up animation for the
// affected discs.
if (this.options.AnimateMoves)
{
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
{
// Mark the newly added disc.
if (i == row && j == col)
this.squareControls[i, j].IsNew = true;
else
{
// Initialize animation for the discs that were
// flipped.
if (this.board.GetSquareContents(i, j) != oldBoard.GetSquareContents(i, j))
this.squareControls[i, j].AnimationCounter = SquareControl.AnimationStart;
}
}
}
// Update the display to reflect the board changes.
this.UpdateBoardDisplay();
// Save the player color.
this.lastMoveColor = this.currentColor;
// If the animate moves option is active, start the animation.
if (this.options.AnimateMoves)
{
this.gameState = ReversiForm.GameState.InMoveAnimation;
this.animationTimer.Start();
}
// Otherwise, end the move.
else
this.EndMove();
}
//
// Makes a move for the current player.
//
private void MakeMove(int row, int col)
{
// Save the current game state.
previousGameState = new Board(board);
// Log the move.
logMove(row, col);
// Make the move on the board.
board.MakeMove(currentColor, row, col);
// If the animate move option is active,
// set up animation for the affected discs.
if (options.AnimateMoves)
setSquaresForAnimation(row, col);
// Update the display to reflect the board changes.
UpdateBoardDisplay();
// Update parameters.
lastMoveColor = currentColor;
moveNumber++;
// If the animate moves option is active, start the animation.
// Otherwise, end the move.
if (options.AnimateMoves)
{
gameState = ReversiForm.GameState.InMoveAnimation;
animationTimer.Start();
}
else EndMove();
}
// ===================================================================
// This code handles initialization.
// ===================================================================
// Initialize Board
private void InitializeBoard()
{
// Create the game board.
this.board = new Board();
// Create the controls for each square, add them to the squares
// panel and set up event handling.
this.squareControls = new SquareControl[10, 10];
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j)
{
// Create it.
this.squareControls[i, j] = new SquareControl(i, j);
// Position it.
this.squareControls[i, j].Left = j * this.squareControls[i, j].Width;
this.squareControls[i, j].Top = i * this.squareControls[i, j].Height;
// Add it.
this.squaresPanel.Controls.Add(this.squareControls[i, j]);
// Set up event handling for it.
this.squareControls[i, j].MouseMove += new MouseEventHandler(this.SquareControl_MouseMove);
this.squareControls[i, j].MouseLeave += new EventHandler(this.SquareControl_MouseLeave);
this.squareControls[i, j].Click += new EventHandler(this.SquareControl_Click);
}
}
private void panelBoard_MouseClick(object sender, MouseEventArgs e)
{
if (e.Button == MouseButtons.Left)
{
int w = (panelBoard.Width - 1) / board.width;
int h = (panelBoard.Height - 1) / board.height;
Board old = board.Clone();
switch (board.FieldClicked(e.X / w, e.Y / h))
{
case Board.ClickStatus.ValidMove:
oldboard = old;
checkBoxHelp.Checked = false; //help is only for the current turn
redraw();
break;
case Board.ClickStatus.GameOver:
gameOver = true;
oldboard = old;
redraw();
break;
}
}
}
public AI(Board board, List<List<Board.PIECE>> _cur_board, List<int> _cur_empty_neighbor_list)
{
b = board;
cur_board = _cur_board;
cur_empty_neighbor_list = _cur_empty_neighbor_list;
}
int heuristicFunction1(Board newBoard, int forfeit, int color, int opponentMobility)
{
SetAIParameters();
return
this.forfeitWeight * forfeit +
this.frontierWeight * (newBoard.WhiteFrontierCount - newBoard.BlackFrontierCount) +
this.mobilityWeight * color * (newBoard.GetValidMoveCount(color) - newBoard.GetValidMoveCount(-color)) +
this.stabilityWeight * (newBoard.WhiteSafeCount - newBoard.BlackSafeCount) +
this.stonesWeight * (newBoard.WhiteCount - newBoard.BlackCount);
}
public int Simple_Bot_AI(Board.PIECE caller, List<int> legal_cand)
{
return Generic_Greedy_AI(caller, legal_cand, Board.WEIGHT.Default);
}
public MoveRecord(Board board, int currentColor, ListViewItem moveListItem)
{
this.board = new Board(board);
this.currentColor = currentColor;
this.moveListItem = moveListItem;
}
//
// This function uses look ahead to evaluate all valid moves for a
// given player color and returns the best move it can find.
//
private ComputerMove GetBestMove(Board board, int color, int depth, int alpha, int beta)
{
// Initialize the best move.
ComputerMove bestMove = new ComputerMove(-1, -1);
bestMove.rank = -color * ReversiForm.maxRank;
// Find out how many valid moves we have so we can initialize the
// mobility score.
int validMoves = board.GetValidMoveCount(color);
// Start at a random position on the board. This way, if two or
// more moves are equally good, we'll take one of them at random.
Random random = new Random();
int rowStart = random.Next(8);
int colStart = random.Next(8);
// Check all valid moves.
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
{
// Get the row and column.
int row = (rowStart + i) % 8;
int col = (colStart + j) % 8;
if (board.IsValidMove(color, row, col))
{
// Update the progress bar for each move when on the
// first look ahead depth level.
if (depth == 1)
this.BeginInvoke(new UpdateStatusProgressDelegate(this.UpdateStatusProgress));
// Make the move.
ComputerMove testMove = new ComputerMove(row, col);
Board testBoard = new Board(board);
testBoard.MakeMove(color, testMove.row, testMove.col);
int score = testBoard.WhiteCount - testBoard.BlackCount;
// Check the board.
int nextColor = -color;
int forfeit = 0;
bool isEndGame = false;
int opponentValidMoves = testBoard.GetValidMoveCount(nextColor);
if (opponentValidMoves == 0)
{
// The opponent cannot move, count the forfeit.
forfeit = color;
// Switch back to the original color.
nextColor = -nextColor;
// If that player cannot make a move either, the
// game is over.
if (!testBoard.HasAnyValidMove(nextColor))
isEndGame = true;
}
// If we reached the end of the look ahead (end game or
// max depth), evaluate the board and set the move
// rank.
if (isEndGame || depth == this.lookAheadDepth)
{
// For an end game, max the ranking and add on the
// final score.
if (isEndGame)
{
// Negative value for black win.
if (score < 0)
testMove.rank = -ReversiForm.maxRank + score;
// Positive value for white win.
else if (score > 0)
testMove.rank = ReversiForm.maxRank + score;
// Zero for a draw.
else
testMove.rank = 0;
}
// It's not an end game so calculate the move rank.
else
testMove.rank =
this.forfeitWeight * forfeit +
this.frontierWeight * (testBoard.BlackFrontierCount - testBoard.WhiteFrontierCount) +
this.mobilityWeight * color * (validMoves - opponentValidMoves) +
this.stabilityWeight * (testBoard.WhiteSafeCount - testBoard.BlackSafeCount) +
score;
}
// Otherwise, perform a look ahead.
else
{
ComputerMove nextMove = this.GetBestMove(testBoard, nextColor, depth + 1, alpha, beta);
// Pull up the rank.
testMove.rank = nextMove.rank;
// Forfeits are cumulative, so if the move did not
// result in an end game, add any current forfeit
// value to the rank.
if (forfeit != 0 && Math.Abs(testMove.rank) < ReversiForm.maxRank)
testMove.rank += forfeitWeight * forfeit;
// Adjust the alpha and beta values, if necessary.
if (color == Board.White && testMove.rank > beta)
beta = testMove.rank;
if (color == Board.Black && testMove.rank < alpha)
alpha = testMove.rank;
}
// Perform a cutoff if the rank is outside tha alpha-beta range.
if (color == Board.White && testMove.rank > alpha)
{
testMove.rank = alpha;
return testMove;
}
if (color == Board.Black && testMove.rank < beta)
{
testMove.rank = beta;
return testMove;
}
// If this is the first move tested, assume it is the
// best for now.
if (bestMove.row < 0)
bestMove = testMove;
// Otherwise, compare the test move to the current
// best move and take the one that is better for this
// color.
else if (color * testMove.rank > color * bestMove.rank)
bestMove = testMove;
}
}
// Return the best move found.
return bestMove;
}
//
// This function uses look ahead to evaluate all valid moves for a
// given player color and returns the best move it can find.
//
private ComputerMove minimax(Board board, int color, int alpha, int beta, int depth = 1)
{
// Initialize the best move.
ComputerMove bestMove = new ComputerMove(-1, -1);
bestMove.rank = -color * int.MaxValue;
// Start at a random position on the board. This way, if two or
// more moves are equally good, we'll take one of them at random.
Random random = new Random();
int rowStart = random.Next(10);
int colStart = random.Next(10);
// Check every square on the board and try to perform
// each and every move (up to the given depth)
// to calculate best move for the current player.
// We are certain that there are valid moves at this point
// as we wouldn't be here if there weren't any
// checks are performed in the StartTurn function.
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j)
{
// Get the row and column.
int row = (rowStart + i) % 10;
int col = (colStart + j) % 10;
if (board.IsValidMove(color, row, col))
{
// We found a valid move now we copy the board
// and try to make that move on the new board
// to evaluate its weight.
Board tempBoard = new Board(board);
tempBoard.MakeMove(color, row, col);
// Holds the current move being tested.
ComputerMove moveBeingChecked = new ComputerMove(row, col);
// Holds the color ID of a player that has no mobility
// Initialized to 0 in case both are mobile.
int forfeit = 0;
// Holds the color ID of the next player.
int nextPlayer = -color;
// A flag that indicates whether either of
// the players is mobile or if game is over.
bool gameOver = false;
// Just like in StartTurn, after passing a turn
// to the next player due to no mobility for the other
// we need to check if the new player is mobile
// if not then neither can move and game is over.
int opponentMobility = tempBoard.GetValidMoveCount(nextPlayer);
if (opponentMobility == 0)
{
forfeit = nextPlayer;
nextPlayer = color;
if (!tempBoard.HasAnyValidMove(color))
gameOver = true;
}
if (depth >= lookAheadDepth || gameOver)
{
// Initialize AI Parameters.
if (this.currentColor == Board.White)
{
moveBeingChecked.rank = heuristicFunction1(tempBoard, forfeit, color, opponentMobility);
if (tempBoard.EmptyCount > 0 && Board.isCorner(row, col))
moveBeingChecked.rank += 200;
}
else moveBeingChecked.rank = heuristicFunction2(tempBoard);
}
else
{
ComputerMove nextMove = minimax(tempBoard, nextPlayer, alpha, beta, ++depth);
moveBeingChecked.rank = nextMove.rank;
// Adjust the alpha and beta values, if necessary.
if (color == Board.White && moveBeingChecked.rank > beta)
beta = moveBeingChecked.rank;
if (color == Board.Black && moveBeingChecked.rank < alpha)
alpha = moveBeingChecked.rank;
}
// If the alpha-beta pruning is enabled
// perform a cut off if necessary.
if (alphaBeta)
{
if (color == Board.White && moveBeingChecked.rank > alpha)
{
moveBeingChecked.rank = alpha;
return moveBeingChecked;
}
if (color == Board.Black && moveBeingChecked.rank < beta)
{
moveBeingChecked.rank = beta;
return moveBeingChecked;
}
}
// If this is the first move tested, assume it is the
// best for now. otherwise, compare the test move
// to the current best move and take the one that
// is better for this color.
if (bestMove.row < 0)
bestMove = moveBeingChecked;
else if (color * moveBeingChecked.rank < color * bestMove.rank)
bestMove = moveBeingChecked;
}
}
// Return the best move found.
return bestMove;
}
void printChoice(int h, int w, Board.PIECE caller)
{
if (caller == Board.PIECE.BLACK)
Console.WriteLine("@");
else
Console.WriteLine("-");
Console.WriteLine(h + " " + w);
Console.WriteLine();
Console.WriteLine();
}
private void newGame()
{
NewGameForm form = new NewGameForm(board);
form.ShowDialog(this);
if (form.board != null)
{
board = form.board;
oldboard = null;
displayOldBoard = false;
gameOver = false;
}
updateScores(board);
redraw();
}
// ===================================================================
// Code to handle undo/redo of moves.
// ===================================================================
//
// Restores the game to the state it was in before the specified move
// was made.
//
private void RestoreGameAt(int n)
{
// Get the move record.
MoveRecord item = (MoveRecord) this.moveHistory[n];
// Stop any animation.
this.StopMoveAnimation();
// Clear any board square highlighting.
this.UnHighlightSquares();
// Restore the board and update the display.
this.board = new Board(item.board);
this.UpdateBoardDisplay();
// Restore the current player.
this.currentColor = item.currentColor;
// Restore the move list.
this.moveListView.Items.Clear();
for (int i = 0; i < n; i++)
{
item = (MoveRecord) this.moveHistory[i];
this.moveListView.Items.Add(item.moveListItem);
}
if (this.moveListView.Items.Count > 0)
this.moveListView.EnsureVisible(this.moveListView.Items.Count - 1);
else
this.moveListView.Refresh();
// Set the current move number.
this.moveNumber = n + 1;
// Enable/disable the move-related menu items and tool bar buttons
// as appropriate.
this.undoMoveMenuItem.Enabled =
this.undoAllMovesMenuItem.Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.UndoMove].Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.UndoAllMoves].Enabled = (this.moveNumber > 1);
this.redoMoveMenuItem.Enabled =
this.redoAllMovesMenuItem.Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.RedoMove].Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.RedoAllMoves].Enabled = (this.moveNumber < this.moveHistory.Count);
this.resumePlayMenuItem.Enabled =
this.playToolBar.Buttons[(int) ReversiForm.ToolBarButton.ResumePlay].Enabled = false;
// Suspend computer play.
this.isComputerPlaySuspended = true;
}
public int Static_H_Bot_AI(Board.PIECE caller, List<int> legal_cand)
{
return Generic_Greedy_AI(caller, legal_cand, Board.WEIGHT.Static);
}
// ===================================================================
// Event handlers for the square controls.
// ===================================================================
//
// Handles a mouse move on a board square.
//
private void SquareControl_MouseMove(object sender, MouseEventArgs e)
{
// Check the game state to ensure that it is the user's turn.
if (this.gameState != ReversiForm.GameState.InPlayerMove)
return;
SquareControl squareControl = (SquareControl) sender;
// If the square is a valid move for the current player,
// indicate it.
if (this.board.IsValidMove(this.currentColor, squareControl.Row, squareControl.Col))
{
//
if (!squareControl.IsActive && squareControl.PreviewContents == Board.Empty)
{
// If the show valid moves option is active, mark the
// square.
if (this.options.ShowValidMoves)
{
squareControl.IsActive = true;
// If the preview moves option is not active, update
// the square display now.
if (!this.options.PreviewMoves)
squareControl.Refresh();
}
// If the preview moves option is active, mark the
// appropriate squares.
if (this.options.PreviewMoves)
{
// Create a temporary board to make the move on.
Board board = new Board(this.board);
board.MakeMove(this.currentColor, squareControl.Row, squareControl.Col);
// Set up the move preview.
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
if (board.GetSquareContents(i, j) != this.board.GetSquareContents(i, j))
{
// Set and update the square display.
this.squareControls[i, j].PreviewContents = board.GetSquareContents(i, j);
this.squareControls[i, j].Refresh();
}
}
}
// Change the cursor.
squareControl.Cursor = System.Windows.Forms.Cursors.Hand;
}
}
private void updateScores(Board b)
{
labelPlayer1.Text = String.Format("{0}: {1}", b.player1.name, b.GetPlayerScore(b.player1));
labelPlayer1.ForeColor = b.player1.color;
labelPlayer2.Text = String.Format("{0}: {1}", b.player2.name, b.GetPlayerScore(b.player2));
labelPlayer2.ForeColor = b.player2.color;
if (gameOver)
{
int score1 = b.GetPlayerScore(b.player1);
int score2 = b.GetPlayerScore(b.player2);
if (score1 > score2) //player1 wins
{
labelGameStatus.Text = String.Format("{0} won!", b.player1.name);
labelGameStatus.ForeColor = b.player1.color;
}
else if (score2 > score1) //player2 wins
{
labelGameStatus.Text = String.Format("{0} won!", b.player2.name);
labelGameStatus.ForeColor = b.player2.color;
}
else //draw
{
labelGameStatus.Text = "It's a draw...";
labelGameStatus.ForeColor = Color.Black;
}
}
else
{
labelGameStatus.Text = String.Format("It is {0}'s turn.", b.curPlayer.name);
labelGameStatus.ForeColor = b.curPlayer.color;
}
}
// ===================================================================
// Game AI code.
// Note: These are executed in the worker thread.
// ===================================================================
//
// This function starts the look ahead process to find the best move
// for the current player color.
//
private ComputerMove GetBestMove(Board board)
{
// Initialize the alpha-beta cutoff values.
int alpha = ReversiForm.maxRank + 64;
int beta = -alpha;
// Kick off the look ahead.
return this.GetBestMove(board, this.currentColor, 1, alpha, beta);
}
public int Mini_Max_AI(Board.PIECE caller, List<int> legal_cand)
{
// black will maximize
// white will minimize
if (caller == Board.PIECE.BLACK)
{
max_value(copy(cur_board), new List<int>(cur_empty_neighbor_list), -infinity, infinity, SearchDepth);
return legal_cand[best_option];
}
else if (caller == Board.PIECE.WHITE)
{
min_value(copy(cur_board), new List<int>(cur_empty_neighbor_list), -infinity, infinity, SearchDepth);
return legal_cand[best_option];
}
return -1;
}
public int Random_AI(Board.PIECE caller, List<int> legal_cand)
{
Random r = new Random();
int random_idx = r.Next(legal_cand.Count);
return legal_cand[random_idx];
}
// ===================================================================
// Game AI code.
// Note: These are executed in the worker thread.
// ===================================================================
//
// This function starts the look ahead process to find the best move
// for the current player color.
//
private ComputerMove GetBestMove(Board board)
{
// Initialize alpha-beta parameters in case
// alpha-beta pruning option is enabled.
int alpha = int.MaxValue;
int beta = int.MinValue;
// Kick off the look ahead.
return this.minimax(board, currentColor, alpha, beta);
}
