SolitaireCode.cpp

#include <iostream>
#include <ctime>
#include <string>

using namespace std;

class card {
public:
	string rank;
	string suit;
	bool faceup;

	card(string r="", string s="", bool f = false)
	{
		rank = r;
		suit = s;
		faceup = f;
	}
	void SetRankandSuit(string r, string s) {
		rank = r;
		suit = s;
	}
	void ChangeFace() {
		faceup = !faceup;
	}
	bool operator>(card& w) {
		if ((rank == "K") && (w.rank == "Q")) return true;
		else if ((rank == "Q") && (w.rank == "J")) return true;
		else if ((rank == "J") && (w.rank == "10")) return true;
		else if ((rank == "10") && (w.rank == "9")) return true;
		else if ((rank == "9") && (w.rank == "8")) return true;
		else if ((rank == "8") && (w.rank == "7")) return true;
		else if ((rank == "7") && (w.rank == "6")) return true;
		else if ((rank == "6") && (w.rank == "5")) return true;
		else if ((rank == "5") && (w.rank == "4")) return true;
		else if ((rank == "4") && (w.rank == "3")) return true;
		else if ((rank == "3") && (w.rank == "2")) return true;
		else if ((rank == "2") && (w.rank == "A")) return true;

		return false;
	}
	bool checkalternativecolor(card& rhs) {
		if (((suit == "\4") || (suit == "\3")) && ((rhs.suit == "\5") || (rhs.suit == "\6"))) return true;
		else if (((suit == "\5") || (suit == "\6")) && ((rhs.suit == "\4") || (rhs.suit == "\3"))) return true;

		return false;
	}
	bool checksamesuit(card& rhs) {
		return (suit == rhs.suit);
	}
	void print()  {
		if (faceup) {
			if ((suit == "\4") || (suit == "\3")) {
				cout << "\033[91m";
				cout << rank << suit;
				cout << "\033[0m";
			}
			else cout << rank << suit;
		}
		else {
			cout << "[ ]";
		}
	}
};
template <class T>
class list {
	class node {
	public:
		T Data;
		node* prev;
		node* next;

		node(T& d, node* p, node* n)
		{
			Data = d;
			prev = p;
			next = n;
		}
		node()
		{
			prev = next = nullptr;
		}
	};
	node* head;
	node* tail;
	int size;

public:
	class iterator {
		friend class list;
		node* current;
		iterator(node* c)
		{
			current = c;
		}
	public:
		iterator()
		{
			current = nullptr;
		}
		node* getcurrent() {
			return current;
		}
		T& operator*() const     //deference opr
		{
			return current->Data;
		}
		iterator& operator++()
		{                             //pre increment
			current = current->next;
			return *this;
		}
		iterator operator++(int)
		{                           // post increment
			iterator old = *this;
			current = current->next;
			return old;
		}
		iterator& operator--()
		{                          //pre decrement
			current = current->prev;
			return *this;
		}
		iterator operator--(int)
		{                           // post decrement
			iterator old = *this;
			current = current->prev;
			return old;
		}
		bool operator==(iterator rhs) {
			return current == rhs.current;
		}
		bool operator!=(iterator rhs) {
			return current != rhs.current;
		}
		
	};
	list()
	{
		head = new node();
		tail = new node();
		head->next = tail;
		tail->prev = head;
		size = 0;
	}
	list(list&& rhs) {
		head = rhs.head;
		tail = rhs.tail;

		rhs.head = nullptr;
		rhs.tail = nullptr;
	}
	bool empty() {
		return (head->next == tail);
	}
	T& gethead() {
		return (head->next->Data);
	}
	T& gettail() {
		return (tail->prev->Data);
	}
	iterator getlastnode() {
		iterator it(tail->prev);
		return it;
	}
	int getsize() { return size; }
	iterator begin() {
		iterator it(head->next);
		return it;
	}
	iterator end() {
		iterator it(tail);
		return it;
	}
	void faceuplastnode() {
		tail->prev->Data.faceup = true;
	}
	void facedownlastnode() {
		tail->prev->Data.faceup = false;
	}
	bool Isanyfacedown() {
		iterator it;
		for (it = begin(); it != end(); it++) {
			if (!(*it).faceup)
			    return true;
		}

		return false;
	}
	void insertatend(T d) {
		node* t = new node(d, tail->prev, tail);
		tail->prev->next = t;
		tail->prev = t;
		size++;
	}
	void addnodeslist(iterator it1,iterator it2,int k=1) {
		node* t = it1.getcurrent();
		t->prev = tail->prev;
		tail->prev->next = t;
		
		t = it2.getcurrent();
		t->next = tail;
		tail->prev = t;
		size = size + k;
	}
	void addnode(iterator it) {
		node* t = it.getcurrent();
		t->prev = tail->prev;
		t->next = tail;
		tail->prev->next = t;
		tail->prev = t;
		size++;
	}
	void removeattail() {
		if (tail->prev  != head) {
			node* temp = tail->prev;
			tail->prev = temp->prev;
			temp->prev->next = tail;
			delete temp;
			size--;
		}
	}
	iterator movefromtail(int k=1) {
		node* temp = tail;
		
		for (int i = 0; i < k; i++) {
			temp = temp->prev;
		}
		iterator it(temp);
		size=size - k;
		temp->prev->next = tail;
		tail->prev = temp->prev;
		return it;
	}
	int countfaceupcards() {
		iterator it;
		int count = 0;
		for (it = begin(); it != end(); it++)
		{
			if ((*it).faceup)
				count++;
		}
		return count;
	}
	
	T& getnodefromtail(int k=1) {
		node* temp = nullptr;
		node* c = tail;
		for (int i = 0; i < k; i++)
		{
			temp = c->prev;
			c = temp;
		}
		return (temp->Data);
	}

	void PrintAllListsAdjacently(list<card>& l1, list<card>& l2, list<card>& l3, list<card>& l4, list<card>& l5, list<card>& l6) {
		list<card>::iterator it1 = l1.begin();
		list<card>::iterator it2 = l2.begin();
		list<card>::iterator it3 = l3.begin();
		list<card>::iterator it4 = l4.begin();
		list<card>::iterator it5 = l5.begin();
		list<card>::iterator it6 = l6.begin();
		iterator it = begin();

		cout << "\t(" << size <<" cards)\t(" << l1.size << " cards)\t(" << l2.size << " cards)\t(" << l3.size << " cards)\t(" << l4.size  <<" cards)\t(" << l5.size << " cards)\t(" << l6.size << " cards)" << endl;
		while ((it!=end())||(it1 != l1.end())||(it2 != l2.end())||(it3 != l3.end())||(it4 != l4.end())|| (it5 != l5.end())|| (it6 != l6.end())) {
			cout << "\t  ";
			if (it != end()) {
				(*it).print();
				++it;
			}
			cout << "\t\t   ";
			if (it1 != l1.end()) {
				(*it1).print();
				++it1;
			}
			cout << "\t\t   ";
			if (it2 != l2.end()) {
				(*it2).print();
				++it2;
			}
			
			cout << "\t\t   ";
			if (it3 != l3.end()) {
				(*it3).print();
				++it3;
			}
			
			cout << "\t\t   ";
			if (it4 != l4.end()) {
				(*it4).print();
				++it4;
			}
			cout << "\t\t   ";
			if (it5 != l5.end()) {
				(*it5).print();
				++it5;
			}
			cout << "\t\t   ";
			if (it6 != l6.end()) {
				(*it6).print();
				++it6;
			}
			
			cout << endl;
		}
	}
	~list()
	{
		while (head->next != tail)
		{
			node* temp = head->next;
			head->next = temp->next; temp->next->prev = head;
			delete temp;
		}
		delete head;
		delete tail;
	}
};
class Command {
public:
	string commandType;
	string source;
	string destination;
	int numCards;

	Command(string type="", string src = "", string dest = "", int num = 1)
		: numCards(num) {
		commandType = type;
		source = src;
		destination = dest;
	}
};
template <class T>
class stack {
	list <T> s;
public:
	void push(T d) {
		s.insertatend(d);
	}
	int Size() {
		return s.getsize();
	}
	bool pop(T& d) {
		if (!s.empty())
		{
			d = s.gettail();
			s.removeattail();
			return true;
		}
		else return false;
	}
	bool Isempty() {
		return s.empty();
	}
	bool peekTop(T& d) {
		if (!s.empty())
		{
			d = s.gettail();
			return true;
		}
		else return false;
	}
	list<card>::iterator moveTop() {
		return s.movefromtail();
	}
	void addAttop(list<card>::iterator it) {
		s.addnode(it);
	}
};
class Game {
	list <card> tableau[7];
	stack <card> foundation[4];
	stack <card> stockpile;
	stack <card> wastepile;
	stack <Command> AllCommands;
	int moves;
public:
	Game() { moves = 85; }
	void InitializeDeck(card deck[52]) {
		string suits[] = { "\3", "\6", "\5", "\4"};
		string ranks[] = { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };
		int index = 0;

		for (int i = 0; i < 4; ++i) {
			for (int j = 0; j < 13; ++j) {
				deck[index].SetRankandSuit(ranks[j], suits[i]);
				index++;
			}
		}
		while (index < 52) {
			stockpile.push(deck[index++]);
		}
	}
	void shuffleDeck(card deck[52]) {
		srand(time(0));
		for (int i = 0; i < 52; ++i) {
			int randIndex = rand() % 52;  
			card temp = deck[i];
			deck[i] = deck[randIndex];
			deck[randIndex] = temp;
		}
	}
	void GameSetUp(){

		card deck[52];
		InitializeDeck(deck);
		shuffleDeck(deck);

		int index = 0;
		for (int i = 0; i < 7; ++i) {
			for (int j = 0; j <= i; ++j) {
				if (j == i) {
					deck[index].ChangeFace();
				}
				tableau[i].insertatend(deck[index++]);
			}
		}
		while (index < 52) {
			stockpile.push(deck[index]);
			index++;
		}
	}
	bool movefromcol(string src, string des,int& numofcards) {
		int colsrc = src[1] - '1';
		if ((colsrc < 0) || (colsrc > 6)) return false;
		if (tableau[colsrc].empty())
			return false;
		if ((des[0] == 'c') || (des[0] == 'C')) {
			cout << "Enter number of cards: ";
			cin >> numofcards;
			if ((numofcards > (tableau[colsrc].countfaceupcards())) || (numofcards < 0)) return false;
			if (numofcards == 0) return true;
			card c1;
			c1 = tableau[colsrc].getnodefromtail(numofcards);
			int coldes = des[1] - '1';
			if ((coldes < 0) || (coldes > 6)) return false;
			if (tableau[coldes].empty()) {
				if ((c1.rank == "K")) {
					list<card>::iterator it2 = tableau[colsrc].getlastnode();
					list<card>::iterator it = tableau[colsrc].movefromtail(numofcards);
					tableau[colsrc].faceuplastnode();
					tableau[coldes].addnodeslist(it, it2, numofcards);
					moves--;
					return true;
				}
				else return false;
			}
			card c2 = tableau[coldes].gettail();
			if ((c1.checkalternativecolor(c2)) && (c2 > c1)) {
				list<card>::iterator it2 = tableau[colsrc].getlastnode();
				list<card>::iterator it = tableau[colsrc].movefromtail(numofcards);
				tableau[colsrc].faceuplastnode();
				tableau[coldes].addnodeslist(it, it2, numofcards);
				moves--;
				return true;
			}
			else return false;
		}
		else if ((des[0] == 'f') || (des[0] == 'F')) {
			card c1;
			c1 = tableau[colsrc].getnodefromtail();
			int foundIndex = des[1] - '1';
			if ((foundIndex < 0) || (foundIndex > 6)) return false;
			if (foundation[foundIndex].Isempty()) {
				if ((c1.rank == "A")) {
					list<card>::iterator it = tableau[colsrc].movefromtail();
					tableau[colsrc].faceuplastnode();
					foundation[foundIndex].addAttop(it);
					return true;
				}
				else return false;
			}
			card f;
			foundation[foundIndex].peekTop(f);
			if ((f.checksamesuit(c1)) && (c1 > f)) {
				list<card>::iterator it = tableau[colsrc].movefromtail();
				tableau[colsrc].faceuplastnode();
				foundation[foundIndex].addAttop(it);
				return true;
			}
			else return false;
		}
		else return false;
	}
	bool movefromwaste(string des) {
		if (wastepile.Isempty())
			return false;
		card w;
		wastepile.peekTop(w);
		if ((des[0] == 'c') || (des[0] == 'C')) {
			int colIndex = des[1] - '1';
			if ((colIndex < 0) || (colIndex > 6)) return false;
			if (tableau[colIndex].empty()) {
				if ((w.rank == "K")) {
					list<card>::iterator it = wastepile.moveTop();
					tableau[colIndex].addnode(it);
					moves--;
					return true;
				}
				else return false;
			}
			card c = tableau[colIndex].gettail();
			if ((c.checkalternativecolor(w)) && (c > w)) {
				list<card>::iterator it = wastepile.moveTop();
				tableau[colIndex].addnode(it);
				moves--;
				return true;
			}
			else return false;
		}
		else if ((des[0] == 'f') || (des[0] == 'F')) {
			int foundIndex = des[1] - '1';
			if ((foundIndex < 0) || (foundIndex > 6)) return false;
			if (foundation[foundIndex].Isempty()) {
				if ((w.rank == "A")) {
					list<card>::iterator it = wastepile.moveTop();
					foundation[foundIndex].addAttop(it);
					return true;
				}
				else return false;
			}
			card f;
			foundation[foundIndex].peekTop(f);
			if ((f.checksamesuit(w)) && (w > f)) {
				list<card>::iterator it = wastepile.moveTop();
				foundation[foundIndex].addAttop(it);
				return true;
			}
			else return false;
		}
		else return false;
	}
	bool movefromfound(string src, string des) {
		int foundIndex = src[1] - '1';
		if ((foundIndex < 0) || (foundIndex > 6)) return false;
		if (foundation[foundIndex].Isempty())
			return false;
		card f;
		foundation[foundIndex].peekTop(f);
		if ((des[0] == 'c') || (des[0] == 'C')) {
			int colIndex = des[1] - '1';
			if ((colIndex < 0) || (colIndex > 6)) return false;
			if (tableau[colIndex].empty()) {
				if ((f.rank == "K")) {
					list<card>::iterator it = foundation[foundIndex].moveTop();
					tableau[colIndex].addnode(it);
					return true;
				}
				else return false;
			}
			card c = tableau[colIndex].gettail();
			if ((c.checkalternativecolor(f)) && (c > f)) {
				list<card>::iterator it = foundation[foundIndex].moveTop();
				tableau[colIndex].addnode(it);
				return true;
			}
			else return false;
		}
		else if ((des[0] == 'f') || (des[0] == 'F')) {
			int founddesIndex = des[1] - '1';
			if ((founddesIndex < 0) || (founddesIndex > 6)) return false;
			if (foundIndex == founddesIndex) {
				return true;
			}
			else if (foundation[founddesIndex].Isempty()) {
				if (f.rank == "A") {
					list<card>::iterator it = foundation[foundIndex].moveTop();
					foundation[founddesIndex].addAttop(it);
					return true;
				}
				else return false;
			}
		}
		else return false;
	}
	void draw() {
		if (!stockpile.Isempty()) {
			list<card>::iterator it = stockpile.moveTop();;
			(*it).ChangeFace();
			wastepile.addAttop(it);
		}
		else {
			while (!wastepile.Isempty()) {
				list<card>::iterator it = wastepile.moveTop();
				(*it).ChangeFace();
				stockpile.addAttop(it);
			}
		}
	}
	bool undo() {
		Command lastcommand;
		if (AllCommands.pop(lastcommand)) {
			string input = lastcommand.commandType;
			if ((input == "s") || (input == "S"))
			{
				if (wastepile.Isempty()) {
					while (!stockpile.Isempty()) {
						list<card>::iterator it = stockpile.moveTop();
						(*it).ChangeFace();
						wastepile.addAttop(it);
					}
				}
				else {
					list<card>::iterator it = wastepile.moveTop();
					(*it).ChangeFace();
					stockpile.addAttop(it);
				}
				
			}
			else if ((input == "m") || (input == "M"))
			{
				string src = lastcommand.source;
				string des = lastcommand.destination;
				int numofcards = lastcommand.numCards;

				if ((src[0] == 'c') || (src[0] == 'C')) {
					int colsrc = src[1] - '1';
					if (tableau[colsrc].empty()) return true;
					if ((des == "w") || (des == "W")) {
						list<card>::iterator it = tableau[colsrc].movefromtail();
						wastepile.addAttop(it);
					}
					else if ((des[0] == 'f') || (des[0] == 'F')) {
						int foundindex = des[1] - '1';
						list<card>::iterator it = tableau[colsrc].movefromtail();
						foundation[foundindex].addAttop(it);
					}
					else if ((des[0] == 'c') || (des[0] == 'C')) {
						int coldes = des[1] - '1';
						tableau[coldes].facedownlastnode();
						list<card>::iterator it2 = tableau[colsrc].getlastnode();
						list<card>::iterator it = tableau[colsrc].movefromtail(numofcards);
						tableau[coldes].addnodeslist(it, it2, numofcards);
					}
					
				}
				else if ((src[0] == 'f') || (src[0] == 'F')) {
					int foundsrc = src[1] - '1';
					if (foundation[foundsrc].Isempty()) return true;
					if ((des == "w") || (des == "W")) {
						list<card>::iterator it = foundation[foundsrc].moveTop();
						wastepile.addAttop(it);
					}
					else if ((des[0] == 'f') || (des[0] == 'F')) {
						int founddes = des[1] - '1';
						list<card>::iterator it = foundation[foundsrc].moveTop();
						foundation[founddes].addAttop(it);
					}
					else if ((des[0] == 'c') || (des[0] == 'C')) {
						int coldes = des[1] - '1';
						list<card>::iterator it = foundation[foundsrc].moveTop();
						tableau[coldes].facedownlastnode();
						tableau[coldes].addnode(it);
					}
				}
			}
			return true;
		}
		else return false;
	}
	
	bool RunCommand(string input) {
		string src, des;

		cout << "Enter Source: ";
		cin >> src;
		cout << "Enter Destination: ";
		cin >> des;
		int numofcards = 1;

		if ((src[0] == 'c')|| (src[0] == 'C')) {
			if (!movefromcol(src,des,numofcards)) return false;
		}
		else if ((src == "w")|| (src == "W")) {
			if (!movefromwaste(des)) return false;
		}
		else if ((src[0] == 'f')|| (src[0] == 'F')) {  
			if (!movefromfound(src,des)) return false;
		}
		else {
			return false;
		}

		Command currentCommand(input, des,src, numofcards);
		AllCommands.push(currentCommand);
		return true;
	}
	bool CheckWinCondition() {
		for (int i = 0; i < 4; ++i) {
			card d;
			if (foundation[i].peekTop(d)) {
				if (d.rank != "K")
					return false;
			}
			else return false;
		}
		for (int i = 0; i < 7; i++) {
			if (tableau[i].Isanyfacedown())
				return false;
		}
		return true;
	}
	void PrintGameState() {
		system("cls");
		cout << "\033[1;6;3;33m";
		cout << "\n\n\t\t\t\t\t\t   \5 SOLITAIRE \5" << endl;
		cout << "\033[0;91m"; 
		cout << "Moves left : " << moves << endl;
		cout << "\033[1;6;94m";
		cout << "________________________________________________________________________________________________________________________\n" << endl;
		cout << "\033[0m";
		cout << "Stockpile\t\tWastepile\t\t\tFoundation 1\tFoundation 2\tFoundation 3\tFoundation 4" << endl;
		card c;
		if (stockpile.peekTop(c)) { c.print(); }
		else cout << "[ ]";
		cout << "\t\t\t";
		if(wastepile.peekTop(c)) { c.print(); }
		else cout << "[ ]";
		cout << "\t\t\t\t";
		for (int i = 0; i < 4; i++)
		{
			if(foundation[i].peekTop(c)) { c.print(); }
			else cout << "[ ]";
			cout << "\t\t";
		}
		cout << "\n(" << stockpile.Size() << " cards)\t\t(" << wastepile.Size() << " cards)\t\t\t";
		for (int i = 0; i < 4; i++) cout <<"(" << foundation[i].Size() << " cards)\t";
		cout << "\033[1;93m";
		cout << "\n\n\n______________________________________________________Tableau_________________________________________________________" << endl;
		cout << "\033[0m";
		cout << "\tColumn1 \t Column2 \t Column3 \t Column4 \t Column5 \t Column6 \t Column7" << endl;
		tableau[0].PrintAllListsAdjacently(tableau[1], tableau[2], tableau[3], tableau[4], tableau[5], tableau[6]);
		cout << "\033[1;6;94m";
		cout << "________________________________________________________________________________________________________________________\n" << endl;
		cout << "\033[0m";
	}
	void GameInstructionsAndDisplay() {
		cout << "\033[1;6;3;93m";
		cout << "\n\n\t\t\t\t\t\t   \5 SOLITAIRE \5" << endl;
		cout << "\033[0m";
		cout << "\033[6;91m";
		cout << "\n\n\n\4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6" << endl;
		cout << "\033[1;6;94m";
		cout << "________________________________________________________________________________________________________________________\n" << endl;
		cout << "\033[0;93m";
		cout << "\nGame Commands And Instructions: " << endl;
		cout << "\033[0m";
		cout << "\n\n~ Command s to draw a card from the stack\n~ Command q to quit the game \n~ Command z to undo recent command\n~ Command m to move cards\n~ Sources can be columns (c1,c2,c3,c4,c5,c6,c7) or foundations (f1,f2,f3,f4) or wastepile (w)\n~ Destination can be columns (c1,c2,c3,c4,c5,c6,c7) or foundations (f1,f2,f3,f4)\n~ Cards should be placed in ascending rank order and alternative color" << endl;
		cout << "\033[1;6;94m";
		cout << "\n________________________________________________________________________________________________________________________" << endl;
		cout << "\033[6;91m";
		cout << "\n\4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6 \4 \3 \5 \6" << endl;
		cout << "\033[1;6;34m";
		cout << "\n\n       \t\t\t\t\tPress enter to Start the Game...." << endl;
		cout << "\033[0m";
		cin.get();
		system("cls");
		PrintGameState();
	}
	void RunGame() {
		GameSetUp();
		GameInstructionsAndDisplay();
		string input;
		while (true) {
			cout << "Enter your command: ";
			cin >> ws;
			getline(cin,input);

			if ((input == "q") || (input == "Q")){
				break;
			}
			else if ((input == "z") || (input == "Z")) {
				if (!undo()) {
					cout << "\033[1;6;3;31m";
					cout << "\tYou are at the start of the game... \t" << endl;
					cout << "\033[0m";
					continue;
				}
			}
			else if ((input == "s") || (input == "S")) {
				draw();
				Command currentCommand(input);
				AllCommands.push(currentCommand);
			}
			else if ((input == "m") || (input == "M")) {
				if (!RunCommand(input)) {
					cout << "\033[1;6;3;31m";
					cout << "\tI N V A L I D      M O V E \t" << endl;
					cout << "\033[0m";
					continue;
				}
			}
			else {
				cout << "\033[1;6;3;31m";
				cout << "\tI N V A L I D      M O V E \t" << endl;
				cout << "\033[0m";
				continue;
			}
			PrintGameState();
			if (CheckWinCondition()) {
				cout << "\033[1;6;3;32m";
				cout << "\n\t\t\t\t\t     < G A M E     W O N > \t\n\t\t\t\t\tC O N G R A T U L A T I O N S  :)" << endl;
				cout << "\033[0m";
				break;
			}
			if (moves==0) {
				cout << "\033[1;6;3;91m";
				cout << "\n\t\t\t\t\t        You lost the Game :(" << endl;
				cout << "\033[0m";
				break;
			}
		}
	}
};

int main() {

	Game solitaire;
	solitaire.RunGame();
	

	system("pause");
	return 0;
}