392 lines
7.4 KiB
C++
Executable file
392 lines
7.4 KiB
C++
Executable file
#include <iostream>
|
|
#include <vector>
|
|
#include "Board.h"
|
|
|
|
using namespace std;
|
|
|
|
Board::Board() {
|
|
for (int i = 0; i < 2; ++i) {
|
|
for (int j = 0; j < 8; ++j) {
|
|
xpieces.push_back(new Piece(i, j, 'X'));
|
|
pieces.push_back(new Piece(i, j, 'X'));
|
|
}
|
|
}
|
|
|
|
for (int i = 6; i < 8; ++i) {
|
|
for (int j = 0; j < 8; ++j) {
|
|
opieces.push_back(new Piece(i, j, 'O'));
|
|
pieces.push_back(new Piece(i, j, 'O'));
|
|
}
|
|
}
|
|
}
|
|
|
|
//make this efficient!
|
|
bool Board::isPiece(int r, int c){
|
|
for (int i = 0; i < pieces.size(); ++i){
|
|
if (pieces[i]->getX() == r && pieces[i]->getY() == c){
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//make this efficient!
|
|
Piece* Board::getPiece(int r, int c){
|
|
for (int i = 0; i < pieces.size(); ++i){
|
|
if (pieces[i]->getX() == r && pieces[i]->getY() == c){
|
|
return pieces[i];
|
|
}
|
|
}
|
|
|
|
return new Piece();
|
|
}
|
|
|
|
moves Board::parse(string input){
|
|
input = myToUpper(input);
|
|
|
|
int temp1;
|
|
char temp2;
|
|
string temp3;
|
|
|
|
temp2 = input[0];
|
|
temp1 = input[1] - '0';
|
|
|
|
if (input[3] == 'L')
|
|
{
|
|
temp3 = "LEFT";
|
|
}
|
|
|
|
else if (input[3] == 'R')
|
|
{
|
|
temp3 = "RIGHT";
|
|
}
|
|
|
|
else
|
|
{
|
|
temp3 = "FWD";
|
|
}
|
|
|
|
moves output(temp1, temp2, temp3);
|
|
|
|
return output;
|
|
}
|
|
|
|
bool Board::isGameOver(){
|
|
for (int i = 0; i < xpieces.size(); ++i){
|
|
if (xpieces[i]->getX() == 7){
|
|
cout<<"\n\n\nPlayer X wins!\n\n\n"<<endl;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < opieces.size(); ++i){
|
|
if (opieces[i]->getX() == 0){
|
|
cout<<"\n\n\nPlayer O wins!\n\n\n"<<endl;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Board::changeTurns(){
|
|
if (turn == 'O') turn = 'X';
|
|
else turn = 'O';
|
|
}
|
|
|
|
void Board::displayBoard(){
|
|
cout << "; A B C D E F G H"<<endl;
|
|
for (int i = 0; i < 8; ++i) {
|
|
int label = 8 - i;
|
|
cout<<"; "<<label<<" ";
|
|
for (int j = 0; j < 8; ++j){
|
|
if (isPiece(i, j))
|
|
if (getPiece(i, j)->getType() == 'X')
|
|
cout << "|" << "X";
|
|
else
|
|
cout << "|" << "O";
|
|
else
|
|
cout << "|" << "_";
|
|
}
|
|
|
|
cout<<"|\n";
|
|
}
|
|
|
|
cout<<'\n'<<endl;
|
|
cout<<"turn: "<<turn << "\n";
|
|
}
|
|
|
|
int Board::charToIntColumn(char input){
|
|
int kolumn;
|
|
|
|
switch (input)
|
|
{
|
|
case 'A': kolumn = 0; break;
|
|
case 'B': kolumn = 1; break;
|
|
case 'C': kolumn = 2; break;
|
|
case 'D': kolumn = 3; break;
|
|
case 'E': kolumn = 4; break;
|
|
case 'F': kolumn = 5; break;
|
|
case 'G': kolumn = 6; break;
|
|
case 'H': kolumn = 7; break;
|
|
}
|
|
|
|
return kolumn;
|
|
}
|
|
|
|
char Board::intToCharColumn(int input){
|
|
char kolumn;
|
|
|
|
switch (input)
|
|
{
|
|
case 1: kolumn = 'A'; break;
|
|
case 2: kolumn = 'B'; break;
|
|
case 3: kolumn = 'C'; break;
|
|
case 4: kolumn = 'D'; break;
|
|
case 5: kolumn = 'E'; break;
|
|
case 6: kolumn = 'F'; break;
|
|
case 7: kolumn = 'G'; break;
|
|
case 8: kolumn = 'H'; break;
|
|
}
|
|
|
|
return kolumn;
|
|
}
|
|
|
|
void Board::move(string inputMove){
|
|
moves jugada = parse(inputMove);
|
|
move(jugada);
|
|
}
|
|
|
|
void Board::move(moves jugada){
|
|
int row = 8 - (jugada.row);
|
|
int column = charToIntColumn(jugada.column);
|
|
|
|
if (row > 8 || row < 0 || column > 8 || column < 0) {
|
|
cout<<"ERROR: index out of bound."<<endl;
|
|
}
|
|
|
|
Piece* piece;
|
|
if (isPiece(row, column))
|
|
piece = getPiece(row, column);
|
|
|
|
else{
|
|
cout<<"ERROR: attempting to move an invalid piece.\n";
|
|
return;
|
|
}
|
|
|
|
if (piece->getType() != turn) {
|
|
cout<<"ERROR: attempting to move the wrong side's piece.\n";
|
|
}
|
|
|
|
else {
|
|
if (jugada.moveType == "FWD") {
|
|
piece->moveFwd();
|
|
}
|
|
|
|
else if (jugada.moveType == "LEFT") {
|
|
//add error checking
|
|
piece->moveLeft();
|
|
}
|
|
|
|
else if (jugada.moveType == "RIGHT") {
|
|
//add error checking
|
|
piece->moveRight();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Board::isThisMovePossible(int r, int c, string moveType){
|
|
Piece* piece;
|
|
if (isPiece(r, c))
|
|
piece = getPiece(r, c);
|
|
else
|
|
return false;
|
|
|
|
if (piece->getType() != turn) {
|
|
cout << "Error in Board::isThisMovePossible: trying to move a piece outside your turn.\n";
|
|
return false;
|
|
}
|
|
|
|
else{
|
|
int reflector = 1;
|
|
|
|
if (piece->getType() == 'O')
|
|
reflector *= -1;
|
|
|
|
if (moveType == "FWD"){
|
|
if (isPiece(r+reflector, c))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
else if (moveType == "RIGHT"){
|
|
if (isPiece(r+reflector, c+1) && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 <= 7))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
else if (moveType == "LEFT"){
|
|
if (isPiece(r+reflector, c+1) && (r+reflector >= 0) && (r+reflector <= 7) && (c+1 >= 0))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
else return false;
|
|
}
|
|
}
|
|
|
|
vector<moves> Board::viewPossibleMoves(){
|
|
int r, c = -1;
|
|
vector<moves> output;
|
|
|
|
if (turn == 'X'){
|
|
for (int i = 0; i < xpieces.size(); ++i){
|
|
r = xpieces[i]->getX();
|
|
c = xpieces[i]->getY();
|
|
if (isThisMovePossible(r, c, "FWD"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "FWD");
|
|
output.push_back(temp);
|
|
}
|
|
|
|
if (isThisMovePossible(r,c,"LEFT"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "LEFT");
|
|
output.push_back(temp);
|
|
}
|
|
|
|
if (isThisMovePossible(r,c,"RIGHT"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "RIGHT");
|
|
output.push_back(temp);
|
|
}
|
|
}
|
|
}
|
|
|
|
else {
|
|
for (int i = 0; i < opieces.size(); ++i){
|
|
r = opieces[i]->getX();
|
|
c = opieces[i]->getY();
|
|
if (isThisMovePossible(r, c, "FWD"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "FWD");
|
|
output.push_back(temp);
|
|
}
|
|
|
|
if (isThisMovePossible(r,c,"LEFT"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "LEFT");
|
|
output.push_back(temp);
|
|
}
|
|
|
|
if (isThisMovePossible(r,c,"RIGHT"))
|
|
{
|
|
moves temp(8-r,intToCharColumn(c+1), "RIGHT");
|
|
output.push_back(temp);
|
|
}
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
string Board::myToUpper(string input){
|
|
string output;
|
|
|
|
for (int i = 0 ; i < input.size(); ++i)
|
|
{
|
|
int numeric;
|
|
|
|
if ((input[i] - 0 >= 97) && (input[i] - 0 <= 122))
|
|
{
|
|
numeric = input[i] - 32;
|
|
output.push_back((char)numeric);// = 'Q';//(char) numeric;
|
|
}
|
|
else output.push_back(input[i]);
|
|
}
|
|
|
|
return output;
|
|
|
|
}
|
|
|
|
void Board::undo(Board& tablero){
|
|
vector<Board> record;
|
|
|
|
if (record.size() < 2)
|
|
{
|
|
cout<<"nothing to undo"<<endl;
|
|
}
|
|
|
|
else
|
|
{
|
|
for (int r = 0; r < 8; ++r)
|
|
{
|
|
for (int k = 0; k < 8; ++k)
|
|
{
|
|
//tablero.modifyAt(r,k,(record[record.size()-2]).elementAt(r,k));
|
|
}
|
|
}
|
|
|
|
record.pop_back();
|
|
}
|
|
}
|
|
|
|
void Board::interpret(string input, Board& tablero){
|
|
vector<Board> record;
|
|
input = myToUpper(input);
|
|
|
|
if (input == "UNDO")
|
|
{
|
|
undo(tablero);
|
|
}
|
|
|
|
else if (input == "DISPLAYRECORD") //for debugging purposes
|
|
{
|
|
cout<<"record: "<<endl;
|
|
cout<<record.size();
|
|
for (int i = 0; i < record.size(); ++i)
|
|
{
|
|
record[i].displayBoard();
|
|
}
|
|
cout<<"---------------------------------------------------END DISPLAY RECORD------------------------"<<endl;
|
|
}
|
|
|
|
else tablero.move(input);
|
|
}
|
|
|
|
void Board::snapshot(vector<Board>& inputVec, Board inputBoard){
|
|
if (inputVec.size() == 10)
|
|
{
|
|
inputVec.erase(inputVec.begin());
|
|
}
|
|
|
|
else if (inputVec.size() > 10)
|
|
{
|
|
cout<<"QUEUE OVERFLOW!"<<endl;
|
|
}
|
|
|
|
inputVec.push_back(inputBoard);
|
|
}
|
|
|
|
int Board::evaluate(char max, char min){
|
|
//right now just evaluating number of pieces
|
|
if (max == 'X'){
|
|
return (xpieces.size() - opieces.size());
|
|
}
|
|
|
|
else if (max == 'O'){
|
|
return (opieces.size() - xpieces.size());
|
|
}
|
|
|
|
else {
|
|
cout << "Unidentified max, must be either X or O.\n";
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|