Programowanie obiektowe zadanie 2

Zadanie zaliczeniowe z laboratorium programowania obiektowego

Laboratorium programowania obiektowego
Zadanie zaliczeniowe 2
termin oddawania rozwiazan: 9 czerwca 2008

Bezszachy sa wariantem gry w szachy. Gra prowadzona jest przez dwoch graczy,
nazywanych dalej bialym i czarnym, na szachownicy 8 na 8, za pomoca bierek
szachowych. Poczatkowe ustawienie figur na szachownicy jest takie samo, jak
w zwyklych szachach. Pionkow w bezszachach nie uzywa sie.

Gracze wykonuja na przemian po jednym ruchu, zaczynajac od gracza bialego.

Figury bezszachowe poruszaja sie po szachownicy tak samo, jak szachowe.
Jedynym wyjatkiem jest brak mozliwosci roszady.

W bezszachach, w odroznieniu od szachow, nie istnieja pojecia szachu i mata.
Zabicie krola nie powoduje zakonczenia gry.

Gra konczy sie zwyciestwem jednego z graczy, gdy uda mu sie zabic wszystkie
bierki przeciwnika. Gra konczy sie remisem, gdy gracz nie moze wykonac
zadnego legalnego ruchu, choc pozostaly mu bierki. Remis oglaszamy rowniez,
gdy gracze wykonaja 1000 ruchow (po 500 ruchow kazdego gracza).

Napisz w C++ program, ktory przeprowadzi partie bezszachow miedzy para
graczy:

* losowym, ktory za kazdym razem losowo wybiera jeden z dozwolonych w danej
chwili ruchow. Wybor kazdego z legalnych ruchow powinien byc rownie
prawdopodobny. Jesli np. gracz ma dwie bierki i jedna z nich moze wykonac
10 legalnych ruchow, a druga 5, to prawdopodobienstwo ruchu pierwsza bierka
powinno byc dwa razy wieksze, niz druga.

* leniwym, ktory sposrod bierek, ktorymi moze sie ruszyc wybiera ta, ktora
znajduje sie najblizej jego krawedzi szachownicy (wiersz pierwszy dla bialego,
osmy dla czarnego). Jesli wybrana bierka gracz moze wykonac bicie, robi to,
jesli nie, wykonuje nia losowy ruch.

Program powinien ruszac sie za obu graczy i, po kazdym ruchu, wypisywac
na wyjscie stan szachownicy. Na zakonczenie partii nalezy wypisac informacje
o wyniku - kto wygral, czy byl remis.

Informacje dla osob, ktore nie znaja zasad gry w szachy:

Poslugujemy sie piecioma rodzajami figur:

* wieza - moze sie przesuwac po wierszu lub kolumnie szachownicy
* goniec - moze sie przesuwac po przekatnych szachownicy
* hetman - moze wykonywac ruchy takie, jak wieza lub goniec
* krol - moze wykonac ruch na jedno z sasiednich pol, takze po przekatnej
* skoczek - moze wykonac ruch, zmieniajac numer wiersza o 2 a kolumny o 1,
  lub na odwrot. Jest jedyna bierka, ktora moze "przeskoczyc" nad innymi.

Jesli na polu, na ktore przestawiamy bierke, jest bierka przeciwnika, zabijamy
ja, czyli zdejmujemy z szachownicy.

Poczatkowo na szachownicy w pierwszym wierszu sa figury gracza bialego,
kolejno: wieza, skoczek, goniec, hetman, krol, goniec, skoczek, wieza.
W ostatnim wierszu znajduja sie figury gracza czarnego, w tej samej
kolejnosci.

Uwaga 1: zadanie trzeba rozwiazac obiektowo. Nalezy unikac powtarzania kodu
lub pisania wielokrotnie podobnych fragmentow.

Uwaga 2: hierarchia klas powinna umozliwiac latwe rozszerzenie o nowe
rodzaje bierek i graczy.

Pytania do tresci zadania prosze kierowac na adres:

zaroda@mimuw.edu.pl

A oto rozwiązanie:

#include 
#include 
#include 
#include 
#include 



using namespace std;

class Pionek;
class Gracz;


//struktura przechowujaca mozliwy ruch.
typedef struct Ruch{
	Pionek* pionek;
	int x; //Wiersz docelowy
	int y; //Kolumna docelowa
	int bicie; //Czy bicie.
} Ruch;

//dlugosc boku planszy
#define ROZMIAR_PLANSZY 8




//Nadklasa dla Gracza.
class Gracz {
	protected:
		char nawias_start;	//Poczatek nawiasu zaznaczajacego gracza
		char nawias_stop;	// Koniec tegoz.
	
	public:
		vector Pionki;	//Pionki gracza pozostajace na planszy
		string nazwa_gracza;	//Nazwa gracza.
		void Usun(Pionek*);		//Usuwa pionek z listy pionkow.
		void inicjuj(string nazwa_gracza,char nawias_start,char nawias_stop);
		virtual int Ruch(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);	//Rusza graczem
		string Wypisz(string pionek);									// Wypisuje pionek gracza
		int WykonajRuch(struct Ruch rusz,Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);	// Fizycznie wykonuje ruch
};


//nadklasa dla pionka
class Pionek
{
	public:
		int x; //wiersz planszy
		int y;//kolumna planszy
		int WyprobujRuch(vector* ruchy,Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY],int x,int y);
		Gracz* gracz;
		virtual vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);	//Mozliwe ruchy pionka
		void Zbij();	//Usuwa pionek
		void inicjuj(int i,int j,Gracz* gracz);
		string nazwa;
		virtual string Wypisz();
};

// klasa główna - gra
class Gra 
{

	private:
		int numer_ruchu;
		int ograniczenie;		//Ograniczenie na ilosc ruchow.
		Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY];
		Gracz* gracz1;
		Gracz* gracz2;
	public:
		Gra(Gracz* gracz1,Gracz* gracz2,int ograniczenie)
		{
			this->gracz1=gracz1;
			this->gracz2=gracz2;
			this->ograniczenie=ograniczenie;

			for(int i=0;i<ROZMIAR_PLANSZY;i++)
			{
				for(int j=0;j<ROZMIAR_PLANSZY;j++)
				{
					plansza[i][j]=NULL;
				}
			}
			
			// umieszczanie pionkow na planszy.
			
			for(unsigned int i=0;i Pionki.size(); i++)
			{
				plansza[gracz1->Pionki.at(i)->x][gracz1->Pionki.at(i)->y]=gracz1->Pionki.at(i);
			}

			for(unsigned int i=0;i Pionki.size(); i++)
			{
				plansza[gracz2->Pionki.at(i)->x][gracz2->Pionki.at(i)->y]=gracz2->Pionki.at(i);
			}
			//pionki umieszczone.
			
		}
		int Ruch();
		void Wypisz(); //Wypisuje stan planszy
};



// Metody GRA

	int Gra::Ruch()
			{

				cout << "Ruch " << numer_ruchu << ": n";

				if((numer_ruchu Ruch(plansza) && gracz2->Ruch(plansza))
				{
					Wypisz();
					numer_ruchu++;

					if(gracz1->Pionki.size()==0)
					{
						//wygral gracz 2.
						cout << "Wygral gracz '" <nazwa_gracza <Pionki.size()==0)
					{
						//wygral gracz 1.
						cout << "Wygral gracz '" <nazwa_gracza << "' Gratulacje! n";
						return 0;
					}
					else
					{
						//Gramy dalej
						return 1;
					}
				}
				else
				{
					cout << "REMIS!! n";
					return 0;
				}
			}

			
	void Gra::Wypisz() //Wypisuje stan planszy
			{
				int i,j,k;
				
				cout << "nn";
				
				//gorna sciana planszy
				cout << "#";
				for(k=0;k<ROZMIAR_PLANSZY;k++)
				{
					cout <<"##"<< k+1 <<"###";
				}
				
				
				//kolejne wiersze planszy
				for (i=0;i<ROZMIAR_PLANSZY;i++)
				{
					cout << "n#";
					for(k=0;k<ROZMIAR_PLANSZY;k++)
					{
						cout <<"     #";
					}
					cout << "n"<< (char)('A'+i);
					
					for(j=0;j<ROZMIAR_PLANSZY;j++)
					{
						cout<<' ';
						
						if(plansza[i][j]!=NULL)
						{
							//jest tu jakis pionek.
							cout <Wypisz();
						}
						else
						{
							cout << "   ";
						}

						cout << " #";
					}
					
					cout << "n#";
					for(k=0;k<ROZMIAR_PLANSZY;k++)
					{
						cout <<"     #";
					}

					cout << 'n';
					
					for(k=0;k<ROZMIAR_PLANSZY;k++)
					{
						cout <<"######";
					}
					cout << "#";
				}
				
				cout <nazwa_gracza=nazwa_gracza;
			this->nawias_start=nawias_start;
			this->nawias_stop=nawias_stop;
		}

	int Gracz::WykonajRuch(struct Ruch rusz,Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
			{	//przesuwa pionek, na razie bez bicia.
				
				string bicie="";

				if(plansza[rusz.x][rusz.y]!=NULL)
				{
					//Cos tu jest. Zakladam ze bicie.
					plansza[rusz.x][rusz.y]->Zbij();
					bicie=" (bicie)";
				}

				cout << "Gracz '"<nazwa_gracza <<"': "<nazwa <<"  z [" <x) <y+1 <<"] na [" << (char)('A'+rusz.x) << rusz.y+1 <<"]"<< bicie <x][rusz.pionek->y]=NULL;
				rusz.pionek->x=rusz.x;
				rusz.pionek->y=rusz.y;

				return 1;
			}

	void Gracz::Usun(Pionek* pionek)
			{	//Usuwa pionek z listy.
				unsigned int i=0;

				while((i Pionki.size())&&(this->Pionki.at(i)!=pionek))
				{
					i++;
				}

				if(i Pionki.size())
				{
					//znaleziono
					//usuwamy.
					this->Pionki.erase(this->Pionki.begin()+i,this->Pionki.begin()+i+1);
				}
			}


	string Gracz::Wypisz(string pionek)
			{
				string wynik="";
				wynik=nawias_start+pionek+nawias_stop;
				return wynik;
			}


//Koniec metod GRACZ
//METODY PIONEK
	vector Pionek::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector zwroc;
		//Bez tego linker g++ się sypie.
		return zwroc;
	}

	void Pionek::inicjuj(int i,int j,Gracz* gracz)
		{
			this->x=i;
			this->y=j;
			this->gracz=gracz;
			gracz->Pionki.push_back(this);
		}
	string Pionek::Wypisz()
		{
			return gracz->Wypisz("|");
		}

	void Pionek::Zbij()
		{
			//Jak nietrudno się domyślić zbija pionek.
			this->gracz->Usun(this);
		}


	int Pionek::WyprobujRuch(vector* ruchy,Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY],int i,int j)
	{

		Ruch gdzie;
 		if((i>=ROZMIAR_PLANSZY)||(i=ROZMIAR_PLANSZY)||(jpush_back(gdzie);
			return 1;
	
		}
		else if(plansza[i][j]->gracz!=this->gracz)
		{
			//Obcy gracz
			gdzie.pionek=this;
			gdzie.x=i;
			gdzie.y=j;
			gdzie.bicie=1;
			ruchy->push_back(gdzie);
			return 0;
		}
		else
		{
			return 0;
		}

	}

//Koniec metod pionek.
// Wszystkie nadklasy zostaly zadeklarowane. Teraz zrobimy podklasy.
// Najpierw gracze.

	class Losowy: public Gracz
	{
		public:
		int Ruch(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		Losowy(string nazwa_gracza,char nawias_start,char nawias_stop)
		{
			inicjuj(nazwa_gracza,nawias_start,nawias_stop);
		}
	};

	int Losowy::Ruch(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector tmp;
		vector mozliwe_ruchy;

		for(unsigned int i=0;i Pionki.size(); i++)
		{		
			tmp=this->Pionki.at(i)->MozliweRuchy(plansza);
			mozliwe_ruchy.insert(mozliwe_ruchy.end(),tmp.begin(),tmp.end());
			tmp.clear();
		}

		

		if(mozliwe_ruchy.size()>0)
		{
			//jesli sa ruchy do wykonania.
			int losowa = rand()%(int)mozliwe_ruchy.size();
			return WykonajRuch(mozliwe_ruchy[losowa],plansza);
		}
		else
		{
			return 0;
		}
	}




	class Leniwy: public Gracz
	{
		public:
		int krawedz ; // Krawedz okreslana jako 'nalezaca'  do gracza.
		int Ruch(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		Leniwy(string nazwa_gracza,char nawias_start,char nawias_stop,int krawedz)
		{
			this->krawedz=krawedz;
			inicjuj(nazwa_gracza,nawias_start,nawias_stop);
		}
	};

	int Leniwy::Ruch(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		int najblizej = ROZMIAR_PLANSZY+1;		//Odleglosc do najblizszej bierki.
		Pionek* najblizszy = NULL;				//Najblizsza bierka
		vector tmp;
		vector mozliwe_ruchy;
		int odleglosc;

		for(unsigned int i=0;i Pionki.size(); i++)
		{		
			tmp=this->Pionki.at(i)->MozliweRuchy(plansza);
			odleglosc=this->krawedz-(Pionki.at(i)->x);

			if(odleglosc0)&&(odlegloscMozliweRuchy(plansza); //Jego mozliwe ruchy.
			unsigned int i=0;
			while((i<tmp.size())&&(tmp.at(i).bicie==0))
			{
				i++;
			}

			if(i<tmp.size()) //Znalezlismy ruch z biciem.
			{
				return WykonajRuch(tmp.at(i),plansza);
			}
			else	// Nie ma bicia, ale losowy ruch.
			{
				int losowa = rand()%(int)tmp.size();
				return WykonajRuch(tmp[losowa],plansza);
			}
		}
		else
		{
			return 0;
		}
	}



// Teraz pionki.



	class Wieza:public Pionek
	{
		public:
		vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		string Wypisz();
		Wieza (int i,int j,Gracz* gracz)
		{
			inicjuj(i,j,gracz);
			this->nazwa="Wieża";
		}
	};

	vector Wieza::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector ruchy;
		int i;

		//Skaczemy po wierszach
		i=y+1;
		while(WyprobujRuch(&ruchy,plansza,x,i)==1)
		{
			i++;
		}
		i=y-1;
		while(WyprobujRuch(&ruchy,plansza,x,i)==1)
		{
			i=i-1;
		}
		//Skaczemy po kolumnach
		i=x+1;
		while(WyprobujRuch(&ruchy,plansza,i,y)==1)
		{
			i++;
		}
		i=x-1;
		while(WyprobujRuch(&ruchy,plansza,i,y)==1)
		{
			i=i-1;
		}

		return ruchy;
	}

	string Wieza::Wypisz()
	{
		return gracz->Wypisz("W");
	}

	class Skoczek:public Pionek
	{
		public:
		vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		string Wypisz();
		Skoczek (int i,int j,Gracz* gracz)
		{
			inicjuj(i,j,gracz);
			this->nazwa="Skoczek";
		}
	};

	vector Skoczek::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector ruchy;

		WyprobujRuch(&ruchy,plansza,x+2,y-1);
		WyprobujRuch(&ruchy,plansza,x+2,y+1);
		WyprobujRuch(&ruchy,plansza,x-2,y-1);
		WyprobujRuch(&ruchy,plansza,x-2,y+1);
		WyprobujRuch(&ruchy,plansza,x+1,y+2);
		WyprobujRuch(&ruchy,plansza,x+1,y-2);
		WyprobujRuch(&ruchy,plansza,x-1,y+2);
		WyprobujRuch(&ruchy,plansza,x-1,y-2);

		return ruchy;
	}

	string Skoczek::Wypisz()
	{
		return gracz->Wypisz("S");
	}



	class Krol:public Pionek
	{
		public:
		vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		string Wypisz();
		Krol (int i,int j,Gracz* gracz)
		{
			inicjuj(i,j,gracz);
			this->nazwa="Król";
		}
	};

	vector Krol::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector ruchy;

		WyprobujRuch(&ruchy,plansza,x-1,y-1);
		WyprobujRuch(&ruchy,plansza,x,y-1);
		WyprobujRuch(&ruchy,plansza,x+1,y-1);
		WyprobujRuch(&ruchy,plansza,x-1,y);
		WyprobujRuch(&ruchy,plansza,x+1,y);
		WyprobujRuch(&ruchy,plansza,x-1,y+1);
		WyprobujRuch(&ruchy,plansza,x,y+1);
		WyprobujRuch(&ruchy,plansza,x+1,y+1);

		return ruchy;
	}

	string Krol::Wypisz()
	{
		return gracz->Wypisz("K");
	}



	class Goniec:public Pionek
	{
		public:
		vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		string Wypisz();
		Goniec (int i,int j,Gracz* gracz)
		{
			inicjuj(i,j,gracz);
			this->nazwa="Goniec";
		}
	};

	vector Goniec::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector ruchy;
		int i;

		//W prawy gorny rog
		i=1;
		while(WyprobujRuch(&ruchy,plansza,x+i,y+i)==1)
		{
			i++;
		}
		i=1;
		// W lewy dolny
		while(WyprobujRuch(&ruchy,plansza,x-i,y-i)==1)
		{
			i++;
		}
		//W prawy dolny
		i=1;
		while(WyprobujRuch(&ruchy,plansza,x+i,y-i)==1)
		{
			i++;
		}
		i=1;
		// W lewy gorny
		while(WyprobujRuch(&ruchy,plansza,x-i,y+i)==1)
		{
			i++;
		}

		return ruchy;
	}

	string Goniec::Wypisz()
	{
		return gracz->Wypisz("G");
	}



	class Hetman:public Pionek
	{
		public:
		vector MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY]);
		string Wypisz();
		Hetman (int i,int j,Gracz* gracz)
		{
			inicjuj(i,j,gracz);
			this->nazwa="Hetman";
		}
	};

	vector Hetman::MozliweRuchy(Pionek* plansza[ROZMIAR_PLANSZY][ROZMIAR_PLANSZY])
	{
		vector ruchy;
		int i;

		//W prawy gorny rog
		i=1;
		while(WyprobujRuch(&ruchy,plansza,x+i,y+i)==1)
		{
			i++;
		}
		i=1;
		//W lewy dolny
		while(WyprobujRuch(&ruchy,plansza,x-i,y-i)==1)
		{
			i++;
		}
		//W lewy dolny
		i=1;
		while(WyprobujRuch(&ruchy,plansza,x+i,y-i)==1)
		{
			i++;
		}
		i=1;
		// W lewy gorny
		while(WyprobujRuch(&ruchy,plansza,x-i,y+i)==1)
		{
			i++;
		}

		//Skaczemy po wierszach
		i=y+1;
		while(WyprobujRuch(&ruchy,plansza,x,i)==1)
		{
			i++;
		}
		i=y-1;
		while(WyprobujRuch(&ruchy,plansza,x,i)==1)
		{
			i=i-1;
		}
		//Skaczemy po kolumnach
		i=x+1;
		while(WyprobujRuch(&ruchy,plansza,i,y)==1)
		{
			i++;
		}
		i=x-1;
		while(WyprobujRuch(&ruchy,plansza,i,y)==1)
		{
			i=i-1;
		}

		return ruchy;
	}

	string Hetman::Wypisz()
	{
		return gracz->Wypisz("H");
	}
/****************************************************************
*********************** --- MAIN --- ****************************
****************************************************************/

int main(int argc, char **argv) {

	Gracz* gracz1;
	Gracz* gracz2;
	Gra* gierka;

	//Inicjalizujemy generator liczb pseudolosowych.
	srand(time(NULL));

	//Tworzymy graczy
	gracz1 = new Losowy("Biały",'[',']');
	gracz2 = new Leniwy("Czarny",'{','}',7);

	//Rozmieszczamy pionki gracza 1
	new Wieza(0,0,gracz1);
	new Skoczek(0,1,gracz1);
	new Goniec(0,2,gracz1);
	new Hetman(0,3,gracz1);
	new Krol(0,4,gracz1);
	new Goniec(0,5,gracz1);
	new Skoczek(0,6,gracz1);
	new Wieza(0,7,gracz1);

	//Rozmieszczamy pionki gracza 2
	new Wieza(7,0,gracz2);
	new Skoczek(7,1,gracz2);
	new Goniec(7,2,gracz2);
	new Hetman(7,4,gracz2);
	new Krol(7,3,gracz2);
	new Goniec(7,5,gracz2);
	new Skoczek(7,6,gracz2);
	new Wieza(7,7,gracz2);
	//Tworzymy
	gierka=new Gra(gracz1,gracz2,500);
	//No i siup!
	while(gierka->Ruch())
	{
	}

return 0;
}