/// <summary>
/// Set the current playing mode. Defined as a method so it can be called by a delegate
/// </summary>
/// <param name="ePlayingMode"> Playing mode</param>
private void SetPlayingMode(PlayingModeE ePlayingMode) {
PlayingMode = ePlayingMode;
}
/// <summary>
/// Let's the computer play against itself
/// </summary>
/// <param name="bFlash"> true to flash pieces whem moving</param>
private void PlayComputerAgainstComputer(bool bFlash) {
bool bMultipleThread;
bMultipleThread = (m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.DifferentThreadForSearch ||
m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.OnePerProcessorForSearch);
PlayingMode = PlayingModeE.ComputerAgainstComputer;
StartAsyncComputing();
if (bMultipleThread) {
Task.Factory.StartNew(() => PlayComputerAgainstComputerAsync(bFlash, m_searchMode));
} else {
PlayComputerAgainstComputerAsync(bFlash, m_searchMode);
}
}
/// <summary>
/// Cancel the auto-play
/// </summary>
private void CancelAutoPlay() {
if (PlayingMode == PlayingModeE.ComputerAgainstComputer) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
} else {
m_chessCtl.CancelSearch();
}
}
/// <summary>
/// Toggle the player vs player mode.
/// </summary>
private void TogglePlayerAgainstPlayer() {
if (mnuEditPlayerAgainstPlayer.IsChecked) {
PlayingMode = PlayingModeE.PlayerAgainstComputer;
if (frmGameParameter.AskGameParameter(this)) {
CheckIfComputerMustPlay();
} else {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
}
} else {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
}
mnuEditPlayerAgainstPlayer.IsChecked = (PlayingMode == PlayingModeE.PlayerAgainstPlayer);
}
/// <summary>
/// Toggle the design mode. In design mode, the user can create its own board
/// </summary>
private void ToggleDesignMode() {
if (PlayingMode == PlayingModeE.DesignMode) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
mnuEditDesignMode.IsCheckable = false;
if (frmGameParameter.AskGameParameter(this)) {
m_chessCtl.BoardDesignMode = false;
if (m_chessCtl.BoardDesignMode) {
PlayingMode = PlayingModeE.DesignMode;
MessageBox.Show("Invalid board configuration. Correct or reset.");
} else {
m_lostPieceBlack.BoardDesignMode = false;
m_lostPieceWhite.Visibility = System.Windows.Visibility.Visible;
CheckIfComputerMustPlay();
}
} else {
PlayingMode = PlayingModeE.DesignMode;
}
} else {
PlayingMode = PlayingModeE.DesignMode;
mnuEditDesignMode.IsCheckable = true;
m_lostPieceBlack.BoardDesignMode = true;
m_lostPieceWhite.Visibility = System.Windows.Visibility.Hidden;
m_chessCtl.BoardDesignMode = true;
}
mnuEditDesignMode.IsChecked = (PlayingMode == PlayingModeE.DesignMode);
SetCmdState();
}
/// <summary>
/// Creates a game from a PGN text
/// </summary>
private void CreateGame() {
if (m_chessCtl.CreateFromPGNText()) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
}
}
//*********************************************************
//
/// <summary>
/// Let's the computer play against itself
/// </summary>
/// <param name="bFlash"> true to flash pieces whem moving</param>
//
//*********************************************************
private void PlayComputerAgainstComputerBegin(bool bFlash) {
PlayComputerAgainstComputerAsyncDel del;
bool bMultipleThread;
bMultipleThread = (m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.DifferentThreadForSearch ||
m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.OnePerProcessorForSearch);
PlayingMode = PlayingModeE.ComputerAgainstComputer;
StartAsyncComputing();
if (bMultipleThread) {
del = new PlayComputerAgainstComputerAsyncDel(PlayComputerAgainstComputerAsync);
del.BeginInvoke(bFlash,
m_searchMode,
PlayComputerAgainstComputerEndCallback,
del);
} else {
PlayComputerAgainstComputerAsync(bFlash, m_searchMode);
}
}
/// <summary>
/// Test the computer play against itself
/// </summary>
/// <param name="iGameCount"> Number of games to play</param>
/// <param name="searchMode"> Searching mode</param>
private void TestComputerAgainstComputer(int iGameCount, SearchEngine.SearchMode searchMode) {
bool bMultipleThread;
bMultipleThread = (m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.DifferentThreadForSearch ||
m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.OnePerProcessorForSearch);
PlayingMode = PlayingModeE.ComputerAgainstComputer;
StartAsyncComputing();
if (bMultipleThread) {
Task.Factory.StartNew(() => TestComputerAgainstComputerAsync(iGameCount, searchMode));
} else {
TestComputerAgainstComputerAsync(iGameCount, searchMode);
}
}
//*********************************************************
//
/// <summary>
/// Toggle the player vs player mode.
/// </summary>
/// <param name="sender"> Sender object</param>
/// <param name="e"> Event handler</param>
//
//*********************************************************
private void playerAgainstPlayerToolStripMenuItem_Click(object sender, EventArgs e) {
if (playerAgainstPlayerToolStripMenuItem.Checked) {
PlayingMode = PlayingModeE.PlayerAgainstComputer;
if (frmGameParameter.AskGameParameter(this)) {
CheckIfComputerMustPlay();
}
} else {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
}
}
//*********************************************************
//
/// <summary>
/// Cancel the auto-play
/// </summary>
/// <param name="sender"> Sender object</param>
/// <param name="e"> Event handler</param>
//
//*********************************************************
private void cancelAutomaticPlayToolStripMenuItem_Click(object sender, EventArgs e) {
if (PlayingMode == PlayingModeE.ComputerAgainstComputer) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
} else {
m_chessCtl.CancelSearch();
}
}
//*********************************************************
//
/// <summary>
/// Creates a game from a PGN text
/// </summary>
/// <param name="sender"> Sender object</param>
/// <param name="e"> Event handler</param>
//
//*********************************************************
private void createAGameFromPGNToolStripMenuItem_Click(object sender, EventArgs e) {
if (m_chessCtl.CreateFromPGNText()) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
}
}
//*********************************************************
//
/// <summary>
/// Toggle the design mode. In design mode, the user can create its own board
/// </summary>
//
//*********************************************************
private void ToggleDesignMode() {
if (PlayingMode == PlayingModeE.DesignMode) {
PlayingMode = PlayingModeE.PlayerAgainstPlayer;
if (frmGameParameter.AskGameParameter(this)) {
m_chessCtl.BoardDesignMode = false;
if (m_chessCtl.BoardDesignMode) {
PlayingMode = PlayingModeE.DesignMode;
MessageBox.Show("Invalid board configuration. Correct or reset.");
} else {
m_lostPieceBlack.BoardDesignMode = false;
panelWhiteLostPiece.Visible = true;
CheckIfComputerMustPlay();
}
} else {
PlayingMode = PlayingModeE.DesignMode;
}
} else {
PlayingMode = PlayingModeE.DesignMode;
m_lostPieceBlack.BoardDesignMode = true;
panelWhiteLostPiece.Visible = false;
m_chessCtl.BoardDesignMode = true;
}
SetCmdState();
}
//*********************************************************
//
/// <summary>
/// Test the computer play against itself
/// </summary>
/// <param name="iGameCount"> Number of games to play</param>
/// <param name="searchMode"> Searching mode</param>
//
//*********************************************************
private void TestComputerAgainstComputerBegin(int iGameCount, SearchEngine.SearchMode searchMode) {
TestComputerAgainstComputerAsyncDel del;
bool bMultipleThread;
bMultipleThread = (m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.DifferentThreadForSearch ||
m_searchMode.m_eThreadingMode == SearchEngine.SearchMode.ThreadingModeE.OnePerProcessorForSearch);
PlayingMode = PlayingModeE.ComputerAgainstComputer;
StartAsyncComputing();
if (bMultipleThread) {
del = new TestComputerAgainstComputerAsyncDel(TestComputerAgainstComputerAsync);
del.BeginInvoke(iGameCount,
searchMode,
TestComputerAgainstComputerEndCallback,
del);
} else {
TestComputerAgainstComputerAsync(iGameCount, searchMode);
}
}
