//******************************************************************************
//
// CS 240C : Spring 2003 Ohio University Travis Dillon
// Project 5 : Checkers
// file : checker.cc
// started : 05-13-03
//
//******************************************************************************
//#include <cctype> // Provides isdigit
//#include <iomanip> // Provides setw
//#include <iostream> // Provides cin, cout
//#include <string> // Provides string
#include "checker.h" // Provides definition of Checker class
using namespace std;
namespace main_savitch_14
{
const int Checker::ROWS; //eight rows in checker board
const int Checker::COLUMNS; //eight columns on checker board
Checker::Checker( ): game( )
{ //initializes the game board to initial configuration
restart( );
}
void Checker::display_status( ) const
{
//
//
cout << "\nPlayer 1 = ";
printf("\033[31m");
cout << 'o';
printf("\033[39m");
cout << " and Player 2 = ";
printf("\033[36m");
cout << 'o' << "\n";
printf("\033[39m");
for(int i(3); i >= 0; --i)
{
//rows that start with dark square
for(int w(0); w < 4; ++w) printf("\033[41m \033[40m ");
cout << endl;
for(int j(3); j >= 0; --j)
{
printf("\033[41m ");
switch (data[2*i+1][-2*j+6])
{ //output piece in correct color
case HUMAN: if(is_king(2*i+1,-2*j+6))
{printf("\033[31m");
cout << '@';}
else
{printf("\033[31m");
cout << 'o';}
break;
case COMPUTER: if(is_king(2*i+1,-2*j+6))
{printf("\033[36m");
cout << '@';}
else
{printf("\033[36m");
cout << 'o';}
break;
case NEUTRAL: cout << ' '; break;
}
printf("\033[41m ");
printf("\033[40m ");
printf("\033[36m");
switch (data[2*i+1][-2*j+7])
{
case HUMAN: if(is_king(2*i+1,-2*j+7))
{printf("\033[31m");
cout << '@';}
else
{printf("\033[31m");
cout << 'o';}
break;
case COMPUTER: if(is_king(2*i+1,-2*j+7))
{printf("\033[36m");
cout << '@';}
else
{printf("\033[36m");
cout << 'o';}
break;
case NEUTRAL: cout << ' '; break;
}
printf("\033[40m ");
}
printf("\033[39m\033[49m");
cout << 2*i+1; //rows numbers starting at 7 and decreasing by 2
cout << endl;
for(int w(0); w < 4; ++w) printf("\033[41m \033[40m ");
cout << endl;
//rows that start with light squares
for(int w(0); w < 4; ++w) printf("\033[40m \033[41m ");
cout << endl;
for(int j(3); j >= 0; --j)
{
printf("\033[40m ");
switch (data[2*i][-2*j+6])
{
case HUMAN: if(is_king(2*i,-2*j+6))
{printf("\033[31m");
cout << '@';}
else
{printf("\033[31m");
cout << 'o';}
break;
case COMPUTER: if(is_king(2*i,-2*j+6))
{printf("\033[36m");
cout << '@';}
else
{printf("\033[36m");
cout << 'o';}
break;
case NEUTRAL: cout << ' '; break;
}
printf("\033[40m ");
printf("\033[41m ");
switch (data[2*i][-2*j+7])
{
case HUMAN: if(is_king(2*i,-2*j+7))
{printf("\033[31m");
cout << '@';}
else
{printf("\033[31m");
cout << 'o';}
break;
case COMPUTER: if (is_king(2*i,-2*j+7)){printf("\033[36m"); cout << 'O';}
else {printf("\033[36m"); cout << 'o';} break;
case NEUTRAL: cout << ' '; break;
}
printf("\033[41m ");
}
printf("\033[39m\033[49m");
cout << 2*i; //rows numbers starting at 6 and decreasing by 2
cout << endl;
for(int w(0); w < 4; ++w) printf("\033[40m \033[41m ");
cout << endl;
printf("\033[39m\033[49m");
}
cout << " 0 1 2 3 4 5 6 7\n";
if (is_game_over( ))
cout << "\nGame over." << endl;
else if (last_mover( ) == COMPUTER)
cout << "\nPlayer 1's turn to move ..." << endl;
else
cout << "\nPlayer 2's turn to move ..." << endl;
}
bool Checker::is_game_over( ) const
{ //game is over when one player loses all pieces
return (zero_piece());
}
bool Checker::is_legal(const string& move) const
{ //convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
return (!is_game_over( )) && //no moves after game is over
(piece_r < 8) && //piece must be on board
(data[piece_r][piece_c] == next_mover( )) && //must move your piece
(move.length() == 4) && //legal string length is four characters
(data[move_r][move_c] == NEUTRAL) && //must move to empty spot
(move_c < 8) && //have to stay on the board
((move_r + move_c) % 2 == 0) && //only use the dark squares
(good_move(move)); //this checks for everything
}
void Checker::make_move(const string& move)
{
assert(is_legal(move));
//convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
if(is_jump()) //if there is a jump. pieces have to be removed
{
if(data[piece_r][piece_c] == HUMAN || is_king(move))
//this is for regular HUMAN piece or a king
{ //check to see if HUMAN or king jump is good
if(move_r == piece_r + 6) //this is triple jump
{ //these are all possible triple jumps
if(piece_r < 2 &&
piece_c < 2 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
data[piece_r + 5][piece_c + 5] == last_mover() &&
data[piece_r + 6][piece_c + 6] == NEUTRAL &&
move_c == piece_c + 6)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 3))
remove_king(piece_r + 3, piece_c + 3);
if(is_king(piece_r + 5, piece_c + 5))
remove_king(piece_r + 5, piece_c + 5);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 3] = NEUTRAL;
data[piece_r + 5][piece_c + 5] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c > 5 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
data[piece_r + 5][piece_c - 5] == last_mover() &&
data[piece_r + 6][piece_c - 6] == NEUTRAL &&
move_c == piece_c - 6)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 3))
remove_king(piece_r + 3, piece_c - 3);
if(is_king(piece_r + 5, piece_c - 5))
remove_king(piece_r + 5, piece_c - 5);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 3] = NEUTRAL;
data[piece_r + 5][piece_c - 5] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c > 3 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
data[piece_r + 5][piece_c - 3] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 3))
remove_king(piece_r + 3, piece_c - 3);
if(is_king(piece_r + 5, piece_c - 3))
remove_king(piece_r + 5, piece_c - 3);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 3] = NEUTRAL;
data[piece_r + 5][piece_c - 3] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c < 4 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
data[piece_r + 5][piece_c + 3] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 3))
remove_king(piece_r + 3, piece_c + 3);
if(is_king(piece_r + 5, piece_c + 5))
remove_king(piece_r + 5, piece_c + 5);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 3] = NEUTRAL;
data[piece_r + 5][piece_c + 3] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 1))
remove_king(piece_r + 3, piece_c - 1);
if(is_king(piece_r + 5, piece_c - 1))
remove_king(piece_r + 5, piece_c - 1);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 1] = NEUTRAL;
data[piece_r + 5][piece_c - 1] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 1))
remove_king(piece_r + 3, piece_c + 1);
if(is_king(piece_r + 5, piece_c + 1))
remove_king(piece_r + 5, piece_c + 1);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 1] = NEUTRAL;
data[piece_r + 5][piece_c + 1] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c > 1 &&
piece_c < 6 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 1))
remove_king(piece_r + 3, piece_c - 1);
if(is_king(piece_r + 5, piece_c + 1))
remove_king(piece_r + 5, piece_c + 1);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 1] = NEUTRAL;
data[piece_r + 5][piece_c + 1] = NEUTRAL;
}
else if(piece_r < 2 &&
piece_c < 6 &&
piece_c > 1 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 1))
remove_king(piece_r + 3, piece_c + 1);
if(is_king(piece_r + 5, piece_c - 1))
remove_king(piece_r + 5, piece_c - 1);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 1] = NEUTRAL;
data[piece_r + 5][piece_c - 1] = NEUTRAL;
}
}
if(move_r == piece_r + 4) //this is double jump
{ //these are all possible double jumps
if(piece_r < 4 &&
piece_c > 3 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
move_c == piece_c - 4)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 3))
remove_king(piece_r + 3, piece_c - 3);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 3] = NEUTRAL;
}
else if(piece_r < 4 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
if(is_king(piece_r + 3, piece_c - 1))
remove_king(piece_r + 3, piece_c - 1);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
data[piece_r + 3][piece_c - 1] = NEUTRAL;
}
else if(piece_r < 4 &&
piece_c < 4 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
move_c == piece_c + 4)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 3))
remove_king(piece_r + 3, piece_c + 3);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 3] = NEUTRAL;
}
else if(piece_r < 4 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
if(is_king(piece_r + 3, piece_c + 1))
remove_king(piece_r + 3, piece_c + 1);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
data[piece_r + 3][piece_c + 1] = NEUTRAL;
}
}
if(move_r == piece_r + 2) //this is single jump
{ //these are all possible single jumps
if(piece_r < 6 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
move_r == piece_r + 2 &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c - 1))
remove_king(piece_r + 1, piece_c - 1);
data[piece_r + 1][piece_c - 1] = NEUTRAL;
}
else if(piece_r < 6 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
move_r == piece_r + 2 &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r + 1, piece_c + 1))
remove_king(piece_r + 1, piece_c + 1);
data[piece_r + 1][piece_c + 1] = NEUTRAL;
}
}
}
if(data[piece_r][piece_c] == COMPUTER || is_king(move))
//this is for regular COMPUTER piece or a king
{ //check to see if COMPUTER or king jump is good
if(move_r == piece_r - 6) //this is a triple jump
{ //these are all possible triple jumps
if(piece_r > 5 &&
piece_c < 2 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
data[piece_r - 5][piece_c + 5] == last_mover() &&
data[piece_r - 6][piece_c + 6] == NEUTRAL &&
move_c == piece_c + 6)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 3))
remove_king(piece_r - 3, piece_c + 3);
if(is_king(piece_r - 5, piece_c + 5))
remove_king(piece_r - 5, piece_c + 5);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 3] = NEUTRAL;
data[piece_r - 5][piece_c + 5] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c > 5 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
data[piece_r - 5][piece_c - 5] == last_mover() &&
data[piece_r - 6][piece_c - 6] == NEUTRAL &&
move_c == piece_c - 6)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 3))
remove_king(piece_r - 3, piece_c - 3);
if(is_king(piece_r - 5, piece_c - 5))
remove_king(piece_r - 5, piece_c - 5);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 3] = NEUTRAL;
data[piece_r - 5][piece_c - 5] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c > 3 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
data[piece_r - 5][piece_c - 3] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 3))
remove_king(piece_r - 3, piece_c - 3);
if(is_king(piece_r - 5, piece_c - 3))
remove_king(piece_r - 5, piece_c - 3);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 3] = NEUTRAL;
data[piece_r - 5][piece_c - 3] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c < 4 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
data[piece_r - 5][piece_c + 3] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 3))
remove_king(piece_r - 3, piece_c + 3);
if(is_king(piece_r - 5, piece_c + 3))
remove_king(piece_r - 5, piece_c + 3);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 3] = NEUTRAL;
data[piece_r - 5][piece_c + 3] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c > 1 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 1))
remove_king(piece_r - 3, piece_c - 1);
if(is_king(piece_r - 5, piece_c - 1))
remove_king(piece_r - 5, piece_c - 1);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 1] = NEUTRAL;
data[piece_r - 5][piece_c - 1] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c < 6 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 1))
remove_king(piece_r - 3, piece_c + 1);
if(is_king(piece_r - 5, piece_c + 1))
remove_king(piece_r - 5, piece_c + 1);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 1] = NEUTRAL;
data[piece_r - 5][piece_c + 1] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c > 1 &&
piece_c < 6 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 1))
remove_king(piece_r - 3, piece_c - 1);
if(is_king(piece_r - 5, piece_c + 1))
remove_king(piece_r - 5, piece_c + 1);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 1] = NEUTRAL;
data[piece_r - 5][piece_c + 1] = NEUTRAL;
}
else if(piece_r > 5 &&
piece_c < 6 &&
piece_c > 1 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 1))
remove_king(piece_r - 3, piece_c + 1);
if(is_king(piece_r - 5, piece_c - 1))
remove_king(piece_r - 5, piece_c - 1);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 1] = NEUTRAL;
data[piece_r - 5][piece_c - 1] = NEUTRAL;
}
}
if(move_r == piece_r - 4) //this is double jump
{ //these are all possible double jumps
if(piece_r > 3 &&
piece_c > 3 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
move_c == piece_c - 4)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 3))
remove_king(piece_r - 3, piece_c - 3);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 3] = NEUTRAL;
}
else if(piece_r > 3 &&
piece_c > 1 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
if(is_king(piece_r - 3, piece_c - 1))
remove_king(piece_r - 3, piece_c - 1);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
data[piece_r - 3][piece_c - 1] = NEUTRAL;
}
else if(piece_r > 3 &&
piece_c < 4 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
move_c == piece_c + 4)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 3))
remove_king(piece_r - 3, piece_c + 3);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 3] = NEUTRAL;
}
else if(piece_r > 3 &&
piece_c < 6 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
if(is_king(piece_r - 3, piece_c + 1))
remove_king(piece_r - 3, piece_c + 1);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
data[piece_r - 3][piece_c + 1] = NEUTRAL;
}
}
if(move_r == piece_r - 2) //this is single jump
{ //these are all possible single jumps
if(piece_r > 1 && piece_r < 8 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
move_r == piece_r - 2 &&
move_c == piece_c - 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c - 1))
remove_king(piece_r - 1, piece_c - 1);
data[piece_r - 1][piece_c - 1] = NEUTRAL;
}
else if(piece_r > 1 && piece_r < 8 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
move_r == piece_r - 2 &&
move_c == piece_c + 2)
{ //check if jumped pieces are kings, and then remove
if(is_king(piece_r - 1, piece_c + 1))
remove_king(piece_r - 1, piece_c + 1);
data[piece_r - 1][piece_c + 1] = NEUTRAL;
}
}
}
}
if(is_king(move)) move_king(move); //have to keep track of location of kings
if(next_mover() == HUMAN && move_r == 7 && !is_king(piece_r, piece_c))
set_king(move); //this is when a HUMAN piece gets kinged
if(next_mover() == COMPUTER && move_r == 0 && !is_king(piece_r, piece_c))
set_king(move); //this is when a COMPUTER piece gets kings
data[piece_r][piece_c] = NEUTRAL; //spot is empty after move
data[move_r][move_c] = next_mover( ); //change to user piece
game::make_move(move); //increment number of moves
}
void Checker::restart( )
{
for(int i(0); i < ROWS; ++i)
{
for(int j(0); j < COLUMNS; ++j)
{ //initialize the board
//set proper spots to correct players. empty spots are NEUTRAL
if((i <= 2) && ((i+j) % 2 == 0)) data[i][j] = HUMAN;
if((i <= 4) && (i >= 3) && ((i+j) % 2 == 0)) data[i][j] = NEUTRAL;
if((i <= 7) && (i >= 5) && ((i+j) % 2 == 0))data[i][j] = COMPUTER;
if((i+j) % 2 != 0) data[i][j] = NEUTRAL;
}
}
game::restart( );
}
bool Checker::is_jump() const
{
if(next_mover() == HUMAN)
{
for(int i(0); i < ROWS; ++i)
for(int j(0); j < COLUMNS; ++j)
{
//this checks HUMAN kings jumps down to the left
if(is_king(i,j) &&
i > 1 &&
data[i][j] == next_mover() &&
data[i - 1][j - 1] == opposite(next_mover()) &&
data[i - 2][j - 2] == NEUTRAL &&
j > 1 && j < 8)
return true;
//this checks HUMAN kings jumps down to the right
if(is_king(i,j) &&
i > 1 &&
data[i][j] == next_mover() &&
data[i - 1][j + 1] == opposite(next_mover()) &&
data[i - 2][j + 2] == NEUTRAL &&
j >= 0 && j < 6)
return true;
//this checks for all HUMAN pieces up and left
if(data[i][j] == next_mover() &&
i < ROWS - 2 &&
data[i + 1][j - 1] == opposite(next_mover()) &&
data[i + 2][j - 2] == NEUTRAL &&
j > 1 && j < 8)
return true;
//this checks for all HUMAN pieces up and right
if(data[i][j] == next_mover() &&
i < ROWS - 2 &&
data[i + 1][j + 1] == opposite(next_mover()) &&
data[i + 2][j + 2] == NEUTRAL &&
j >= 0 && j < 6)
return true;
}
}
if(next_mover() == COMPUTER)
{
for(int i(7); i >= 0; --i)
for(int j(0); j < COLUMNS; ++j)
{
//this checks for COMPUTER kings jumps up to the left
if(is_king(i,j) &&
i < 6 &&
data[i][j] == next_mover() &&
i < ROWS - 2 &&
data[i + 1][j - 1] == opposite(next_mover()) &&
data[i + 2][j - 2] == NEUTRAL &&
j > 1 && j < 8)
return true;
//this checks for COMPUTER kings jumps up to the right
if(is_king(i,j) &&
i < 6 &&
data[i][j] == next_mover() &&
i < ROWS - 2 &&
data[i + 1][j + 1] == opposite(next_mover()) &&
data[i + 2][j + 2] == NEUTRAL &&
j >= 0 && j < 6)
return true;
//this checks for all COMPUTER jumps down to the left
if(data[i][j] == next_mover() &&
i > 1 &&
data[i - 1][j - 1] == opposite(next_mover()) &&
data[i - 2][j - 2] == NEUTRAL &&
j > 1 && j < 8)
return true;
//this checks for all COMPUTER jumps down to the right
if(data[i][j] == next_mover() &&
i > 1 &&
data[i - 1][j + 1] == opposite(next_mover()) &&
data[i - 2][j + 2] == NEUTRAL &&
j >= 0 && j < 6)
return true;
}
}
return false;
}
bool Checker::good_move(const std::string& move) const
{
//convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
if(is_jump()) //there is a jump to be made
{ //need to check if correct jump is made
return good_jump(move);
}
else //there is not a jump to be made
{
if((next_mover() == HUMAN) && !is_king(move)) //HUMAN move
return (move_r == piece_r + 1) &&
(move_c == piece_c + 1 || move_c == piece_c -1);
if((next_mover() == COMPUTER) && !is_king(move)) //COMPUTER move
return (move_r == piece_r - 1) &&
(move_c == piece_c + 1 || move_c == piece_c -1);
if(is_king(move)) //kings are seperate, they can go any direction
return (move_r == piece_r -1 || move_r == piece_r + 1) &&
(move_c == piece_c + 1 || move_c == piece_c -1);
}
}
bool Checker::good_jump(const std::string& move)const
{
//convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
if(data[piece_r][piece_c] == HUMAN || is_king(move))
{ //check regular HUMAN and all kings for legal jumps
if(move_r == piece_r + 6) //this is triple jump
{ //these are all possible triple jumps
//there is a lot of code here. it just checks if the move is a
//legal jump
if(piece_r < 2 &&
piece_c < 2 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
data[piece_r + 5][piece_c + 5] == last_mover() &&
data[piece_r + 6][piece_c + 6] == NEUTRAL &&
move_c == piece_c + 6)
return true;
if(piece_r < 2 &&
piece_c > 5 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
data[piece_r + 5][piece_c - 5] == last_mover() &&
data[piece_r + 6][piece_c - 6] == NEUTRAL &&
move_c == piece_c - 6)
return true;
if(piece_r < 2 &&
piece_c > 3 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
data[piece_r + 5][piece_c - 3] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
if(piece_r < 2 &&
piece_c < 4 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
data[piece_r + 5][piece_c + 3] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r < 2 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
if(piece_r < 2 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r < 2 &&
piece_c > 1 &&
piece_c < 6 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r < 2 &&
piece_c < 6 &&
piece_c > 1 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
}
if(move_r == piece_r + 4) //this is double jump
{ //these are all possible legal double jumps
if(piece_r < 4 &&
piece_c > 3 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL &&
move_c == piece_c - 4)
{ //check if there are more available jumps
if(piece_r < 2 &&
data[piece_r + 5][piece_c - 3] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL)
return false;
//check if there are more available jumps
if(piece_r < 2 &&
piece_c > 5 &&
data[piece_r + 5][piece_c - 5] == last_mover() &&
data[piece_r + 6][piece_c - 6] == NEUTRAL)
return false;
//all available jumps made
return true;
}
if(piece_r < 4 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if there are more available jumps
if(piece_r < 2 &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL)
return false;
//check if there are more available jumps
if(piece_r < 2 &&
piece_c < 6 &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL)
return false;
//all available jumps made
return true;
}
if(piece_r < 4 &&
piece_c < 4 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL &&
move_c == piece_c + 4)
{ //check if there are more available jumps
if(piece_r < 2 &&
data[piece_r + 5][piece_c + 3] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL)
return false;
//check if there are more available jumps
if(piece_r < 2 &&
piece_c < 2 &&
data[piece_r + 5][piece_c + 5] == last_mover() &&
data[piece_r + 6][piece_c + 6] == NEUTRAL)
return false;
//all available jumps made
return true;
}
if(piece_r < 4 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if there are more jumps available
if(piece_r < 2 &&
data[piece_r + 5][piece_c + 1] == last_mover() &&
data[piece_r + 6][piece_c + 2] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r < 2 &&
piece_c > 1 &&
data[piece_r + 5][piece_c - 1] == last_mover() &&
data[piece_r + 6][piece_c - 2] == NEUTRAL)
return false;
//all available jumps made
return true;
}
}
if(move_r == piece_r + 2) //this is single jump
{ //these are both possible single jumps
if(piece_r < 6 &&
piece_c > 1 &&
data[piece_r + 1][piece_c - 1] == last_mover() &&
data[piece_r + 2][piece_c - 2] == NEUTRAL &&
move_r == piece_r + 2 &&
move_c == piece_c - 2)
{ //check if there are more jumps available
if(piece_r < 4 &&
data[piece_r + 3][piece_c - 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r < 4 &&
piece_c > 3 &&
data[piece_r + 3][piece_c - 3] == last_mover() &&
data[piece_r + 4][piece_c - 4] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
if(piece_r < 6 &&
piece_c < 6 &&
data[piece_r + 1][piece_c + 1] == last_mover() &&
data[piece_r + 2][piece_c + 2] == NEUTRAL &&
move_r == piece_r + 2 &&
move_c == piece_c + 2)
{ //check if there are more jumps available
if(piece_r < 4 &&
data[piece_r + 3][piece_c + 1] == last_mover() &&
data[piece_r + 4][piece_c] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r < 4 &&
piece_c < 4 &&
data[piece_r + 3][piece_c + 3] == last_mover() &&
data[piece_r + 4][piece_c + 4] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
}
}
if(data[piece_r][piece_c] == COMPUTER || is_king(move))
{ //check to see if COMPUTER of a king is jumping legally
if(move_r == piece_r - 6) //this is triple jump
{ //these are all possible triple jumps
if(piece_r > 5 &&
piece_c < 2 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
data[piece_r - 5][piece_c + 5] == last_mover() &&
data[piece_r - 6][piece_c + 6] == NEUTRAL &&
move_c == piece_c + 6)
return true;
if(piece_r > 5 &&
piece_c > 5 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
data[piece_r - 5][piece_c - 5] == last_mover() &&
data[piece_r - 6][piece_c - 6] == NEUTRAL &&
move_c == piece_c - 6)
return true;
if(piece_r > 5 &&
piece_c > 3 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
data[piece_r - 5][piece_c - 3] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
if(piece_r > 5 &&
piece_c < 4 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
data[piece_r - 5][piece_c + 3] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r > 5 &&
piece_c > 1 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
if(piece_r > 5 &&
piece_c < 6 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r > 5 &&
piece_c > 1 &&
piece_c < 6 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
return true;
if(piece_r > 5 &&
piece_c < 6 &&
piece_c > 1 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
return true;
}
if(move_r == piece_r - 4) //this is double jump
{ //these are all the double jumps
if(piece_r > 3 &&
piece_c > 3 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL &&
move_c == piece_c - 4)
{ //check if there are more jumps available
if(piece_r > 5 &&
piece_c > 5 &&
data[piece_r - 5][piece_c - 5] == last_mover() &&
data[piece_r - 6][piece_c - 6] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 5 &&
data[piece_r - 5][piece_c - 3] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
if(piece_r > 3 &&
piece_c > 1 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if there are more jumps available
if(piece_r > 5 &&
piece_c < 6 &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c - 6] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 5 &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
if(piece_r > 3 &&
piece_c < 4 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL &&
move_c == piece_c + 4)
{ //check if there are more jumps available
if(piece_r > 5 &&
piece_c < 2 &&
data[piece_r - 5][piece_c + 5] == last_mover() &&
data[piece_r - 6][piece_c + 6] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 5 &&
data[piece_r - 5][piece_c + 3] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
if(piece_r > 3 &&
piece_c < 6 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL &&
move_c == piece_c)
{ //check if there are more jumps available
if(piece_r > 5 &&
piece_c < 1 &&
data[piece_r - 5][piece_c - 1] == last_mover() &&
data[piece_r - 6][piece_c - 2] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 5 &&
data[piece_r - 5][piece_c + 1] == last_mover() &&
data[piece_r - 6][piece_c + 2] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
}
if(move_r == piece_r - 2) //this is single jump
{ //these are both of the single jumps
if(piece_r > 1 && piece_r < 8 &&
piece_c > 1 &&
data[piece_r - 1][piece_c - 1] == last_mover() &&
data[piece_r - 2][piece_c - 2] == NEUTRAL &&
move_c == piece_c - 2)
{ //check if there are more jumps available
if(piece_r > 3 &&
data[piece_r - 3][piece_c - 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 3 &&
piece_c > 3 &&
data[piece_r - 3][piece_c - 3] == last_mover() &&
data[piece_r - 4][piece_c - 4] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
if(piece_r > 1 && piece_r < 8 &&
piece_c < 6 &&
data[piece_r - 1][piece_c + 1] == last_mover() &&
data[piece_r - 2][piece_c + 2] == NEUTRAL &&
move_c == piece_c + 2)
{ //check if there are more jumps available
if(piece_r > 3 &&
data[piece_r - 3][piece_c + 1] == last_mover() &&
data[piece_r - 4][piece_c] == NEUTRAL)
return false;
//check if there are more jumps available
if(piece_r > 3 &&
piece_c < 4 &&
data[piece_r - 3][piece_c + 3] == last_mover() &&
data[piece_r - 4][piece_c + 4] == NEUTRAL)
return false;
//there are no more jumps available
return true;
}
}
}
return false;
}
bool Checker::zero_piece()const
{
int h(0); //number of HUMAN pieces
int c(0); //number of COMPUTER pieces
for(int i(0); i < ROWS; ++i)
{
for(int j(0); j < COLUMNS; ++j)
{ //increment h and c if a piece is present
if(data[i][j] == HUMAN) ++h;
if(data[i][j] == COMPUTER) ++c;
}
}
return (h == 0 || c == 0);
}
bool Checker::is_king(const std::string& move)const
{
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int spot = piece_r * 10 + piece_c;
for(int i(0); i < kings.size(); ++i)
if(kings[i] == spot) return true; //return true if piece pos. is found
return false;
}
void Checker::move_king(const std::string& move)
{
//convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
int orig = piece_r * 10 + piece_c; //where king was before move
int next = move_r * 10 + move_c; //where king is after it is moved
for(int i(0); i < kings.size(); ++i)
if(kings[i] == orig) kings[i] = next; //replace old pos. with new pos.
//can't leave old pos. in here or other pieces would become kings
}
void Checker::set_king(const std::string& move)
{ //this is when a piece gets initually kinged
//convert the incoming string into four integers for use as array index
int column = atoi(move.c_str( ));
int piece_r = column / 1000;
int piece_c = (column - piece_r * 1000) / 100;
int move_r = ((column - piece_r * 1000) - piece_c * 100) / 10;
int move_c = ((column - piece_r * 1000) - piece_c * 100) - move_r * 10;
int spot = move_r * 10 + move_c;
kings.push_back(spot); //insert king position into vector
}
void Checker::remove_king(int row, int col)
{
int spot = row * 10 + col;
vector<int>::iterator iter; //iterator to walk the vector
for(iter = kings.begin(); iter != kings.end(); ++iter)
if((*iter) == spot)
{ //once the correct location is found, delete it's data
kings.erase(iter);
return;
}
}
bool Checker::is_king(int row, int col)const
{ //check a location to see if it's piece is a king
int spot = row * 10 + col;
for(int i(0); i < kings.size(); ++i)
if(kings[i] == spot) return true; //return true if piece is a king
return false;
}
} //end main_savitch_14