g
g
unknown
c_cpp
3 years ago
39 kB
4
Indexable
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <ctime>
#include <fstream>
using namespace std;
class cell; //Definition of inner class
enum class cell_type { wall, empty, peg };
vector<vector<int>> board1 =
{
{0,0,1,1,1,0,0,0,0,0,0}, //These parts are used when transforming the first 6 boards into cell type and are for information purposes.
{0,1,1,1,1,1,0,0,0,0,0}, // There is no other use. The game will be played over the cell type.
{1,1,1,2,1,1,1,0,0,0,0},
{1,1,1,1,1,1,1,0,0,0,0},
{1,1,1,1,1,1,1,0,0,0,0},
{0,1,1,1,1,1,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0}, //I completed it to 11 to be square
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<int>> board2 =
{
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{1,1,1,1,1,1,1,1,1,0,0},
{1,1,1,1,2,1,1,1,1,0,0},
{1,1,1,1,1,1,1,1,1,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<int>> board3 =
{
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1,0,0,0},
{1,1,1,2,1,1,1,1,0,0,0},
{1,1,1,1,1,1,1,1,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<int>> board4 =
{
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{1,1,1,1,1,1,1,0,0,0,0},
{1,1,1,2,1,1,1,0,0,0,0},
{1,1,1,1,1,1,1,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,1,1,1,0,0,0,0,0,0},
{0,0,0,1,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<int>> board5 =
{
{0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,1,1,1,1,1,0,0,0,0},
{0,1,1,1,1,1,1,1,0,0,0},
{1,1,1,1,2,1,1,1,1,0,0},
{0,1,1,1,1,1,1,1,0,0,0},
{0,0,1,1,1,1,1,0,0,0,0},
{0,0,0,1,1,1,0,0,0,0,0},
{0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<int>> board6 =
{
{0,0,0,0,2,0,0,0,0,0,0},
{0,0,0,1,0,1,0,0,0,0,0},
{0,0,1,0,1,0,1,0,0,0,0},
{0,1,0,1,0,1,0,1,0,0,0},
{1,0,1,0,1,0,1,0,1,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
{0,0,0,0,0,0,0,0,0,0,0},
};
vector<vector<vector<int>>> boards = { board1,board2,board3,board4,board5,board6 };
class PegSolitaire {
static int num;
public:
int boardstyle,boardmodel;
PegSolitaire(int boardtype) { //constructor
boardstyle = boardtype;
}
PegSolitaire(); //consructor
class cell {
public:
int x, y, z;
cell(int c, int d) { // inner class consructor
x = c;
y = d;
}
void set(enum cell_type k) { // inner class set function
if (k == cell_type::wall)
z = 0;
else if (k == cell_type::peg)
z = 1;
else if (k == cell_type::empty)
z = 2;
}
};
vector<vector<PegSolitaire::cell>>map;
vector<vector<PegSolitaire::cell>> map_maker(int boardtype, vector<vector<int>> loaded_board) //This function creates cell objects
{
vector<PegSolitaire::cell> storemap;
vector<vector<PegSolitaire::cell>>storemap2;
if (boardtype > 0) {
for (int i = 0; i < 11; i++) { //I completed the ready maps to 11 so that the maps are square
for (int j = 0; j < 11; j++) {
cell obj(i, j);
if (boards[boardtype - 1][i][j] == 0)
obj.set(cell_type::wall);
else if (boards[boardtype - 1][i][j] == 1)
obj.set(cell_type::peg);
else if (boards[boardtype - 1][i][j] == 2)
obj.set(cell_type::empty);
storemap.push_back(obj);
if (j == 10) {
storemap2.push_back(storemap);
storemap.clear();
}
}
}
}
else if (boardtype == 0) {
for (int i = 0; i < loaded_board.size(); i++) {
for (int j = 0; j < loaded_board.size(); j++) {
cell obj(i, j);
if (loaded_board[i][j] == 0)
obj.set(cell_type::wall);
else if (loaded_board[i][j] == 1)
obj.set(cell_type::peg);
else if (loaded_board[i][j] == 2)
obj.set(cell_type::empty);
storemap.push_back(obj);
if (j == loaded_board.size() - 1) {
storemap2.push_back(storemap);
storemap.clear();
}
}
}
}
map = storemap2; //I'm storing the map in the class
return storemap2;
}
void print_board(const int boardtype, vector<vector<vector<PegSolitaire::cell>>>& all_boards) { // print function
if (boardtype != 0) {
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (all_boards[boardtype][i][j].z == 0)
cout << " ";
else if (all_boards[boardtype][i][j].z == 1)
cout << "P";
else if (all_boards[boardtype][i][j].z == 2)
cout << ".";
}
cout << "\n";
}
}
else if (boardtype == 0) {
for (int i = 0; i < all_boards[boardtype].size(); i++) {
for (int j = 0; j < all_boards[boardtype].size(); j++) {
if (all_boards[boardtype][i][j].z == 0)
cout << " ";
else if (all_boards[boardtype][i][j].z == 1)
cout << "P";
else if (all_boards[boardtype][i][j].z == 2)
cout << ".";
}
cout << "\n";
}
}
}
void save_map(vector<vector<PegSolitaire::cell>>& board, fstream& f) { // save function
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
if (board[i][j].z == 0)
f << 'w';
else if (board[i][j].z == 1)
f << 'p';
else if (board[i][j].z == 2)
f << 'e';
}
f << "\n";
}
}
vector<vector<int>> load_game(fstream& f, int& gametype, int& boardtype) { // load function
vector<vector<int>> board;
int boardinfo, gameinfo;
f >> boardinfo;
f >> gameinfo;
gametype = gameinfo;
boardtype = boardinfo;
string line;
vector<int> lineV;
while (f.peek() != EOF) {
f >> line;
for (int i = 0; i < line.length(); i++)
if (line.at(i) == 'w')
lineV.push_back(0);
else if (line.at(i) == 'p')
lineV.push_back(1);
else if (line.at(i) == 'e')
lineV.push_back(2);
board.push_back(lineV);
lineV.clear();
}
return board;
}
int move_control2(int b, int a, char m, vector<vector<vector<PegSolitaire::cell>>>& board, int boardmodel) { //this function checks the validity of moves according to the rules
if (boardmodel == 1) { // This function returns 1 or 0 depending on the suitability of moves.
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 5) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 2) {
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 7) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 7) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 3) {
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 6) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 6) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 4) {
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 5) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 5) {
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 7) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 7) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 6) {
if (m == 'L' || m == 'l') {
if (a > 3) {
if (board[boardmodel][b][a - 4].z != 2 || board[boardmodel][b][a - 2].z != 1)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 4].z != 2 || board[boardmodel][b][a + 2].z != 1)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (a < 7) {
if (board[boardmodel][b - 2][a + 2].z != 2 || board[boardmodel][b - 1][a + 1].z != 1)
return 0;
else {
return 1;
}
}
if (a > 1) {
if (board[boardmodel][b - 2][a - 2].z != 2 || board[boardmodel][b - 1][a - 1].z != 1)
return 0;
else {
return 1;
}
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < 3) {
if (a < 7) {
if (board[boardmodel][b + 2][a + 2].z != 2 || board[boardmodel][b + 1][a + 1].z != 1)
return 0;
else {
return 1;
}
}
if (a > 1) {
if (board[boardmodel][b + 2][a - 2].z != 2 || board[boardmodel][b + 1][a - 1].z != 1)
return 0;
else {
return 1;
}
}
}
else
return 0;
}
}
else if (boardmodel == 0) {
if (m == 'L' || m == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1 || board[boardmodel][b][a - 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'R' || m == 'r') {
if (a < board[boardmodel][0].size() - 2) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1 || board[boardmodel][b][a + 2].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'U' || m == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1 || board[boardmodel][b - 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
else if (m == 'D' || m == 'd') {
if (b < board[boardmodel].size() - 2) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1 || board[boardmodel][b + 2][a].z == 0)
return 0;
else {
return 1;
}
}
else
return 0;
}
}
return 0;
}
int is_the_game_over(vector<vector<vector<PegSolitaire::cell>>>& board, int boardmodel) { //checks if the game is over
int status = 0;
for (int i = 0; i < board[boardmodel].size(); i++) {
for (int j = 0; j < board[boardmodel].size(); j++) {
if (board[boardmodel][i][j].z == 1) {
status = move_control2(i, j, 'L', board, boardmodel);
if (status == 1)
return 1;
status = move_control2(i, j, 'R', board, boardmodel);
if (status == 1)
return 1;
status = move_control2(i, j, 'D', board, boardmodel);
if (status == 1)
return 1;
status = move_control2(i, j, 'U', board, boardmodel);
if (status == 1)
return 1;
}
}
}
return 0;
}
int counter(vector<vector<PegSolitaire::cell>>& board) { // peg counter
int counter = 0;
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board.size(); j++) {
if (board[i][j].z == 0)
counter++;
}
}
return counter;
}
bool who_has_a_lot_of_peg(PegSolitaire obj,PegSolitaire obj2) { // peg compare function
int result, result2; //The class will have a function that takes another object PegSolitaire as parameter and
result = counter(obj.map); // compares the Peg Solitaire games.It returns true is the first game has more pegs, otherwise it returns false.
result2 = counter(obj2.map);
if (result2 > result)
return true;
else
return false;
}
int* numberof_peg_cell_empty(PegSolitaire obj) { //The class will have functions to return the number of pegs, number of empty cells, and number of pegs taken out from the board
int* result;
int counter0, counter1, counter2;
for (int i = 0; i < obj.map.size(); i++) {
for (int j = 0; j < obj.map.size(); j++) {
if (obj.map[i][j].z == 0)
counter0++;
else if (obj.map[i][j].z == 1)
counter1++;
else if (obj.map[i][j].z == 2)
counter2++;
}
}
result[0] = counter0;
result[1] = counter1;
result[2] = counter2;
return result;
}
void board_updater(int b, int a, char directory, vector<vector<vector<PegSolitaire::cell>>>& board, int boardmodel) { // update function
if (board[boardmodel][b][a].z == 1)
board[boardmodel][b][a].z = 2; // This function applies the approved move to the board.
if (boardmodel == 6) { // Since there are special moves on board6, I evaluated them separately.
if (directory == 'L') {
board[boardmodel][b][a - 2].z = 2;
board[boardmodel][b][a - 4].z = 1;
}
else if (directory == 'R') {
board[boardmodel][b][a + 2].z = 2;
board[boardmodel][b][a + 4].z = 1;
}
else if (directory == 'U') {
if (b > 1)
{
if (board[boardmodel][b - 1][a + 1].z != 0 && board[boardmodel][b - 2][a + 2].z != 0) {
board[boardmodel][b - 1][a + 1].z = 2;
board[boardmodel][b - 2][a + 2].z = 1;
}
else if (board[boardmodel][b - 1][a - 1].z != 0 && board[boardmodel][b - 2][a - 2].z != 0) {
board[boardmodel][b - 1][a - 1].z = 2;
board[boardmodel][b - 2][a - 2].z = 1;
}
}
}
else if (directory == 'D') {
if (board[boardmodel][b + 1][a + 1].z != 0 && board[boardmodel][b + 2][a + 2].z != 0) {
board[boardmodel][b + 1][a + 1].z = 2;
board[boardmodel][b + 2][a + 2].z = 1;
}
else if (board[boardmodel][b + 1][a - 1].z != 0 && board[boardmodel][b + 2][a - 2].z != 0) {
board[boardmodel][b + 1][a - 1].z = 2;
board[boardmodel][b + 2][a - 2].z = 1;
}
}
print_board(boardmodel, board); // Printing is started after the board[boardmodel] changes accordingly
}
else {
if (directory == 'L') {
if (board[boardmodel][b][a - 1].z != 0 && board[boardmodel][b][a - 2].z != 0) {
board[boardmodel][b][a - 1].z = 2;
board[boardmodel][b][a - 2].z = 1;
}
}
else if (directory == 'R') {
if (board[boardmodel][b][a + 1].z != 0 && board[boardmodel][b][a + 2].z != 0) {
board[boardmodel][b][a + 1].z = 2;
board[boardmodel][b][a + 2].z = 1;
}
}
else if (directory == 'U') {
if (board[boardmodel][b - 1][a].z != 0 && board[boardmodel][b - 2][a].z != 0) {
board[boardmodel][b - 1][a].z = 2;
board[boardmodel][b - 2][a].z = 1;
}
}
else if (directory == 'D') {
if (board[boardmodel][b + 1][a].z != 0 && board[boardmodel][b + 2][a].z != 0) {
board[boardmodel][b + 1][a].z = 2;
board[boardmodel][b + 2][a].z = 1;
}
}
print_board(boardmodel, board); // Printing is started after the board changes accordingly
}
}
int move_control(string move, vector<vector<vector<PegSolitaire::cell>>>& board, int boardmodel) {
int a = move[0] - 65; //letter // The difference of this function from the other control function is that it activates the updater.
int b = move[1] - 49; //number
if (boardmodel == 1) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 5) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 2) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 7) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 7) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 3) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 6) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 6) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 4) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 5) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 5) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 7) {
if (board[boardmodel][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 7) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
else if (boardmodel == 6) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 3) {
if (board[boardmodel][b][a - 4].z != 2 || board[boardmodel][b][a - 2].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < 5) {
if (board[boardmodel][b][a + 4].z != 2 || board[boardmodel][b][a + 2].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (a < 7) {
if (board[boardmodel][b - 2][a + 2].z != 2 || board[boardmodel][b - 1][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
if (a > 1) {
if (board[boardmodel][b - 2][a - 2].z != 2 || board[boardmodel][b - 1][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < 3) {
if (a < 7) {
if (board[boardmodel][b + 2][a + 2].z != 2 || board[boardmodel][b + 1][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
if (a > 1) {
if (board[boardmodel][b + 2][a - 2].z != 2 || board[boardmodel][b + 1][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
}
else
return 0;
}
}
else if (boardmodel == 0) {
if (move[3] == 'L' || move[3] == 'l') {
if (a > 1) {
if (board[boardmodel][b][a - 2].z != 2 || board[boardmodel][b][a - 1].z != 1)
return 0;
else {
board_updater(b, a, 'L', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'R' || move[3] == 'r') {
if (a < board[0].size() - 2) {
if (board[0][b][a + 2].z != 2 || board[boardmodel][b][a + 1].z != 1)
return 0;
else {
board_updater(b, a, 'R', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'U' || move[3] == 'u') {
if (b >= 2) {
if (board[boardmodel][b - 2][a].z != 2 || board[boardmodel][b - 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'U', board, boardmodel);
return 1;
}
}
else
return 0;
}
else if (move[3] == 'D' || move[3] == 'd') {
if (b < board[boardmodel].size() - 2) {
if (board[boardmodel][b + 2][a].z != 2 || board[boardmodel][b + 1][a].z != 1)
return 0;
else {
board_updater(b, a, 'D', board, boardmodel);
return 1;
}
}
else
return 0;
}
}
return 0;
}
string rand_move(int boardtype, vector<vector<vector<PegSolitaire::cell>>> board) { //generates random moves
int direction_type;
char letter, number, direction; // This function generates moves for computer selection
string move = " ";
if (boardtype == 1 || boardtype == 4) {
letter = rand() % 7 + 65;
number = rand() % 7 + 49; // ascii table values
direction_type = rand() % 4 + 1;
if (direction_type == 1)
direction = 'L';
else if (direction_type == 2)
direction = 'R';
else if (direction_type == 3)
direction = 'U';
else if (direction_type == 4)
direction = 'D';
move[0] = letter;
move[1] = number;
move[2] = '-';
move[3] = direction;
move[4] = '\0';
return move;
}
else if (boardtype == 2 || boardtype == 5) {
letter = rand() % 9 + 65;
number = rand() % 9 + 49;
direction_type = rand() % 4 + 1;
if (direction_type == 1)
direction = 'L';
else if (direction_type == 2)
direction = 'R';
else if (direction_type == 3)
direction = 'U';
else if (direction_type == 4)
direction = 'D';
move[0] = letter;
move[1] = number;
move[2] = '-';
move[3] = direction;
move[4] = '\0';
return move;
}
else if (boardtype == 3) {
letter = rand() % 8 + 65;
number = rand() % 8 + 49;
direction_type = rand() % 4 + 1;
if (direction_type == 1)
direction = 'L';
else if (direction_type == 2)
direction = 'R';
else if (direction_type == 3)
direction = 'U';
else if (direction_type == 4)
direction = 'D';
move[0] = letter;
move[1] = number;
move[2] = '-';
move[3] = direction;
move[4] = '\0';
return move;
}
else if (boardtype == 6) {
letter = rand() % 9 + 65;
number = rand() % 5 + 49;
direction_type = rand() % 4 + 1;
if (direction_type == 1)
direction = 'L';
else if (direction_type == 2)
direction = 'R';
else if (direction_type == 3)
direction = 'U';
else if (direction_type == 4)
direction = 'D';
move[0] = letter;
move[1] = number;
move[2] = '-';
move[3] = direction;
move[4] = '\0';
return move;
}
else if (boardtype == 0) {
int size = board[0].size();
if (size < 9) {
letter = rand() % size + 65;
number = rand() % size + 49;
}
else {
letter = rand() % size + 65;
number = rand() % 8 + 49;
}
direction_type = rand() % 4 + 1;
if (direction_type == 1)
direction = 'L';
else if (direction_type == 2)
direction = 'R';
else if (direction_type == 3)
direction = 'U';
else if (direction_type == 4)
direction = 'D';
move[0] = letter;
move[1] = number;
move[2] = '-';
move[3] = direction;
move[4] = '\0';
return move;
}
return 0;
}
vector<vector<int>> instant_load(fstream& f, int& gametype, int& boardtype) { //this function mediates read operations from file
vector<vector<int>> v9;
v9 = load_game(f, gametype, boardtype);
return v9;
}
int score_counter(vector<vector<vector<PegSolitaire::cell>>>& board, int boardmodel) {
int score = 0; //After it is understood that there are no moves to be played, this function is called and the score is determined.
for (int i = 0; i < board[boardmodel].size(); i++) {
for (int j = 0; j < board[boardmodel][0].size(); j++) {
if (board[boardmodel][i][j].z == 1)
score++;
}
}
return score++;
}
vector<vector<vector<PegSolitaire::cell>>> my_push_first_function(vector<vector<PegSolitaire::cell>>& board0, vector<vector<PegSolitaire::cell>>& board1, vector<vector<PegSolitaire::cell>>& board2,
vector<vector<PegSolitaire::cell>>& board3, vector<vector<PegSolitaire::cell>>& board4, vector<vector<PegSolitaire::cell>>& board5, vector<vector<PegSolitaire::cell>>& board6) {
vector<vector<vector<PegSolitaire::cell>>> new_boards = { board0,board1,board2,board3,board4,board5,board6 }; //To prepend board0 after updating
return new_boards;
}
void playGame(int board_model,int gametype,string filename,fstream& save, fstream& load,vector<vector<vector<PegSolitaire::cell>>>& all_boards, vector<vector<PegSolitaire::cell>> board0, vector<vector<int>> v9) {
auto control = 0, control3 = 1; // this function plays to computer
decltype(control) control2 = 1, score = 0;
print_board(board_model, all_boards);
cout << "\n";
int choice;
while (1) {
cout << ("Continuation of the Game:1 Save:9 Load:0\n");
cin >> choice;
if (choice == 9) {
save_map(all_boards[board_model], save);
cout << "Save Succesfull";
break;
}
else if (choice == 0) {
load.close();
cout << "Enter the file name for loading operations Example:(load1.txt)\n";
cin >> filename;
load.open(filename, ios::in);
v9 = instant_load(load, gametype, board_model);
board_model = board_model;
gametype = gametype;
board0.clear();
board0 = map_maker(0, v9);
cout << "************************************************************\n";
cout << "New Map Loading....\n";
print_board(0, all_boards);
continue;
}
else if (choice == 1) {
string computer_move;
control = 0;
while (control == 0) {
computer_move = rand_move(board_model, all_boards);
control = move_control(computer_move, all_boards, board_model);
}
if (control == 1) {
cout << "Computer move made:" << computer_move << " new map is as above\n\n";
}
control2 = is_the_game_over(all_boards, board_model);
if (control2 == 0) {
score = score_counter(all_boards, board_model);
break;
}
}
}
cout << "\nGAME OVER SCORE:" << score << "\n";
save << score;
save.close();
}
int my_main() { //section where general information is obtained and managed
vector<vector<int>> temp;
vector<vector<PegSolitaire::cell>> board0, board01, board02, board03, board04, board05, board06;
vector<vector<vector<PegSolitaire::cell>>> all_boards = { board0,board01,board02,board03,board04,board05,board06 };
for (int i = 1; i < 7; i++) {
all_boards[i] = map_maker(i, temp);
temp.clear();
}
srand(time(NULL)); // Required to generate random value
int board_model, game_type;
auto control = 0, control3 = 1;
decltype(control) control2 = 1, score = 0;
string move, filename;
int gametype, boardtype;
vector<vector<int>> v9;
fstream save, load;
save.open("save.txt", ios::out);
cout << "\nMENU\nPlease select the board model(1-6)" << "\n"<< "Enter 0 to load map " << "\n"; // Required inputs are received
cin >> board_model;
save << board_model << "\n";
if (board_model < 0 || board_model>6) {
cerr << "\nwrong choice ! Try Again\n";
return 0;
}
if (board_model == 0) {
cout << "Enter the file name for loading operations Example:(load1.txt)\n";
cin >> filename;
load.open(filename, ios::in);
v9 = instant_load(load, gametype, boardtype);
board_model = 0;
game_type = gametype;
board0 = map_maker(0, v9); // board7 is laoded board
all_boards.clear();
all_boards = my_push_first_function(board0, board01, board02, board03, board04, board05, board06);
}
if (board_model != 0) {
cout << "Enter the game type(Human:1 Computer:2)\n";
cin >> game_type;
save << game_type << "\n";
}
if (game_type == 1) {
print_board(board_model, all_boards);
cout << "\n";
int ch;
while (1) {
if (control3 == 0)
cout << "Invalid move try again!\n";
cout << "Enter 1 for move input\nEnter 9 for Save End exit\nEnter 0 Load Game\nEnter 5 to continue with another object\n\n"; //Checking for faulty states
cin >> ch;
if (ch == 5)
return 0;
if (ch == 9) {
save_map(all_boards[board_model], save);
break;
}
else if (ch == 0) {
load.close();
cout << "Enter the file name for loading operations Example:(load1.txt)\n";
cin >> filename;
load.open(filename, ios::in);
v9 = instant_load(load, gametype, boardtype);
board_model = boardtype;
game_type = gametype;
board0.clear();
board0 = map_maker(0, v9);
cout << "************************************************************\n";
cout << "New Map Loading....\n";
all_boards = my_push_first_function(board0, board01, board02, board03, board04, board05, board06);
print_board(0, all_boards);
continue;
}
else if (ch == 1) {
string move;
cout << "Enter move (Example Type: B4-R)\n";
cin >> move;
if (move[2] != '-') {
cout << "Invalid type!\n";
continue;
}
control3 = move_control(move, all_boards, board_model); // Firstly move is checked.
if (control3 == 0)
continue;
control2 = is_the_game_over(all_boards, board_model); // game progress is checked
if (control2 == 0) {
score = score_counter(all_boards, board_model); // The score is printd according to the control value
break;
}
}
}
cout << "GAME OVER SCORE:" << score << "\n";
}
else if (game_type == 2) {
playGame(board_model, game_type, filename, save, load, all_boards, board0, v9);
}
else
cerr << "\nwrong choice ! Try Again\n";
return 0;
}
};
// Dogukan Tastan 1901042627
int main() {
PegSolitaire game1(1), game2(2), game3(3), game4(4), game5(5);
game1.my_main(); //the game continues with 5 different objects
game2.my_main();
game3.my_main();
game4.my_main();
game5.my_main();
}
// Dogukan Tastan 1901042627