W poprzednich e‑materiałach z serii poświęconej programowaniu obiektowemu napisaliśmy program, który rejestrował wybieranie przez użytkownika przycisków na klawiaturze. Nie przekładało się to jednak na ruch węża. Teraz zajmiemy się tworzeniem rzeczywiście działających mechanik rozgrywki. Zacznijmy od zaimplementowania węża poruszającego się w kierunku, w którym jest zwrócony.

Przypomnijmy sobie, jak wygląda diagram klas, na podstawie którego tworzymy program:

R1MbrEUMaed6o

Ilustracja przedstawia zależności pomiędzy klasami.
1. Klasa Obsługa Wejścia zawiera metodę: +zainterpretuj Wciśniety Przycisk().
Jest ona zależna od 2. klasy Wąż.
Klasa Wąż zawiera zmienne: -liczba Punktów: int =0, -pozycja WężaX: int=0, -pozycja WężaY: int=0, +kierunek Ruchu: int=0, -czy Gra Działa=True oraz metody: +sprawdź Wynik(), +ustaw Wynik(), zmień Kierunek(), +przesuń(), +sprawdź PozycjęX(), +ustaw PozycjeY(), +zjedz Owoc().
Klasa ta zależna jest od 3. klasy Owoc.
Klasa Owoc zawiera zmienną: =liczba Punktów:int=0 oraz metody: +sprawdź Punkty(), +ustaw Punkty().
Klasa ta jest w agregacji całkowitej z 4. klasą Pole.
Klasa Pole zawiera zmienne: +owoc: Owoc=null, +wartość Pola:int=0.
Klasa ta jest w agregacji całkowitej z 5. klasą Plansza.
2. Klasa Wąż zależna od 5. klasy Plansza.
5. Klasa Plansza zawiera zmienne:+rozmiar X Planszy:int, +rozmiar Y Planszy:int, +pole[][]: Pole=Pole[][], +ile Owoców:int=0 oraz metody: +losuj Plansze(), +zresetuj Plansze(), +zaktualizuj Ogon Węża().
Klasa Wyświetlanie Grafiki zawiera metodę: +wyświetl Grę() oraz jest w agregacji częściowej z 2. klasą Wąż oraz 5. klasą Plansza.

Prześledźmy, jak w poszczególnych językach programowania stworzyć i wczytać satysfakcjonujący nas plik konfiguracyjny.

Tworzenie gry w języku C++

Wróćmy do kodu napisanego we wcześniejszych e‑materiałach z tej serii. Zaimplementujmy metodę sprawdzWynik() z klasy Wąż, która powinna sprawdzać aktualną liczbę punktów. Możemy się spodziewać, że zwróci ona jedynie wartość atrybutu liczbaPunktów.

int sprawdzWynik() 
{
	return liczbaPunktow;
}

Z kolei metoda ustawWynik() powinna modyfikować atrybut liczbaPunktow na ten podany w argumencie.

int ustawWynik(int liczbaPunktowDoUstawienia)
{
	liczbaPunktow = liczbaPunktowDoUstawienia;
}

Metoda zmienKierunek(), jak wskazuje jej nazwa, zmienia kierunek ruchu węża, czyli modyfikuje atrybut kierunekRuchu. Nie zdefiniowaliśmy dotychczas, jaki ruch oznacza dana wartość. Stwórzmy więc do tego celu wyliczeniowy typ danych:

enum kierunek {polnoc = 0, wschod = 1, poludnie = 2, zachod = 3};

Dobrą praktyką jest stosowanie słów zamiast abstrakcyjnych wartości liczbowych. Powyższy kod umieścimy jako publiczny w ramach klasy Waz. Metoda zmienKierunek(), z uwzględnieniem wspomnianego typu wyliczeniowego, przyjmie następującą postać:

void zmienKierunek(kierunek nowyKierunek)
{
	kierunekRuchu = nowyKierunek;
}

W diagramie klas kolejna na liście jest metoda przesun(), odpowiadająca za przesunięcie węża. Podczas tworzenia tej klasy założyliśmy, że przesunięcie odbędzie się zgodnie z kierunkiem ruchu.

void przesun()
{
	if (kierunekRuchu == polnoc)
	{
		pozycjaWezaY -= 1;
	}
	else if (kierunekRuchu == poludnie)
	{
		pozycjaWezaY += 1;
	}
	else if (kierunekRuchu == zachod)
	{
		pozycjaWezaX += 1;
	}
	else if (kierunekRuchu == wschod) 
	{
		pozycjaWezaX -= 1;
	}
}

Patrząc na przedstawiony kod, możemy się zastanawiać, czy nie ma w nim błędu. Dlaczego ruch w kierunku północnym zmniejsza wartość y, zamiast zwiększać?

Odpowiedź związana jest ze sposobem wyświetlania danych. Przypomnijmy sobie, jak wygląda metoda wyświetlająca grafikę:

void wyswietlGre(Waz* waz, Plansza* plansza)
{
	while (true)
	{
		system("CLS");
		for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
		{
			for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
			{
				cout << plansza->pole[i][j].wartoscPola << "\t";
			}
			cout << endl;
		}
		this_thread::sleep_for(chrono::milliseconds(400));
	}
}

Plansza rysuje się zgodnie z następującym schematem:

RoXfVajMqSBoo

Ilustracja przedstawia poziomą strzałkę x wychodzącą z punktu 0 skierowana w prawo oraz strzałkę pionową y skierowaną do dołu.

Rysujemy wszystkie wiersze – począwszy od zerowego do ostatniego. Jeśli chcemy, aby wąż poruszał się „do góry”, musi ulec zmianie wartość y. Oczywiście możemy zmienić sposób implementacji grafiki, tak żeby plansza rysowana była od ostatniego wiersza do wiersza o indeksie zero. Mamy dowolność, należy jednak pamiętać o zachowaniu konsekwencji w przyjętej orientacji.

Kolejnymi dwiema metodami z klasy Waz są bliźniacze metody: sprawdzPozycjeX() oraz sprawdzPozycjeY(). Służą one kolejno do odczytywania wartości atrybutów: pozycjaWezaX oraz pozycjaWezaY.

int sprawdzPozycjeY()
{
	return pozycjaWezaY;
}
int sprawdzPozycjeX()	
{
	return pozycjaWezaX;	
}

Metoda ustawPozycje() działa analogicznie do metody ustawWynik(), z tą tylko różnicą, że potrzebujemy dwóch argumentów.

void ustawPozycje(int x, int y)
{
	pozycjaWezaX = x;
	pozycjaWezaY = y;
}

Ostatnią metodą jest metoda zjedzOwoc() – do jej zaimplementowania będziemy potrzebowali obiektu z klasy Owoc. Oznacza to, że musimy przenieść definicję klasy Owoc nad definicję klasy Waz.

void zjedzOwoc(Owoc owoc)
{
	liczbaPunktow += owoc.sprawdzPunkty();
}

Owoc powinien w tym momencie zniknąć. Usunięcie to zaimplementujemy jednak w innym miejscu.

Pojawia się pytanie: Co należy zrobić, aby wąż przesuwał się samodzielnie, zachowując jednocześnie podział z diagramu pakietów?

Dla przypomnienia:

R15KioZPCAlm3

Ilustracja przedstawia trzy foldery z wpisanymi klasami w postaci klas.
Foldery zostały podpisane jako: Sterowanie, Zachowanie rozgrywki, Grafika.
Folder Sterowanie zawiera klasę: obsługa wejścia.
Folder Zachowanie rozgrywki posiada klasy: owoc, wąż, plansza, pole.
Folder Grafika posiada klasy: Wyświetlanie grafiki.

Zamierzony efekt możemy otrzymać na kilka sposobów. Jednym z nich jest dodanie kolejnego wątku dla obiektu klasy Waz. Będzie się on poruszał niezależnie od tego, co się dzieje w obiekcie klasy Plansza.

Innym sposobem jest stworzenie wątku w klasie Plansza, tak żeby losowanie kolejnych owoców oraz ruch węża były synchroniczne. Warto odnotować, że potrzebujemy wątku w klasie Plansza, który będzie odpowiadał za losowanie owoców na mapie.

Decydujemy się więc na stworzenie dwóch nowych oddzielnych wątków. Aby to zrobić, musimy dodać do funkcji main następujące linijki:

Waz obiektWaz = Waz();
thread watekWeza(&Waz::przesun, &obiektWaz);
watekWeza.join();

Ostatecznie otrzymamy:

int main()
{
	Plansza plansza = Plansza(5, 5);
	WyswietlanieGrafiki grafika = WyswietlanieGrafiki();
	Waz obiektWaz = Waz();
	thread watekGrafiki (&WyswietlanieGrafiki::wyswietlGre, &grafika, &obiektWaz, &plansza);
	ObslugaWejscia wejscie;
	thread watekWejscia(&ObslugaWejscia::zinterpretujWcisnietyPrzycisk, &wejscie);
	thread watekWeza(&Waz::przesun, &obiektWaz);
	watekGrafiki.join();
	watekWejscia.join();
	watekWeza.join();
}

Zanim zaimplementujemy wyświetlanie się węża na mapie, zapętlimy metodę przesun(), a następnie opóźnimy ją. W przeciwnym wypadku wąż przesuwałby się zgodnie z prędkością pracy naszego procesora.

Metoda ta przyjmie następującą postać:

void przesun()
{
	while (1) 
	{
		if (kierunekRuchu == polnoc)
		{
			pozycjaWezaY -= 1;
		}
		else if (kierunekRuchu == poludnie)
		{
			pozycjaWezaY += 1;
		}
		else if (kierunekRuchu == zachod)
		{
			pozycjaWezaX += 1;
		}
		else if (kierunekRuchu == wschod) 
		{
			pozycjaWezaX -= 1;
		}
        this_thread::sleep_for(chrono::milliseconds(200));
	}
}

Następnie przejdziemy do wyświetlania grafiki:

void wyswietlGre(Waz* waz, Plansza* plansza)
{
	while (true)
	{
		system("CLS");
		for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
		{
			for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
			{
				if (waz->sprawdzPozycjeY() == i && waz->sprawdzPozycjeX() == j)
					cout << "@ \t";
				else
					cout << plansza->pole[i][j].wartoscPola << "\t";
			}
			cout << endl;
		}
		this_thread::sleep_for(chrono::milliseconds(200));
	}
}

W linijkach 11 i 12 dopisaliśmy, że jeżeli wąż znajduje się na obecnie badanym polu, to zamiast wartości pola wyświetli się jego głowa.

Wartość pola w przypadku naszej gry to liczbowa reprezentacja informacji, czy na danym polu znajduje się ogon węża. Jeśli tak – liczba jest większa od zera. Jeśli ogona tam nie ma, to liczba jest równa zero. Im większa liczba, tym bliżej ogona znajduje się reprezentowane przez nią pole.

Po uruchomieniu programu zauważymy, że wąż, pomimo dwukrotnie dłuższego czasu oczekiwania, niekiedy przeskakuje dwukrotnie. Jest to spowodowane tym, że wątki te działają w 100% asynchronicznie i ich wykonania są od siebie niezależne. W celu zapewnienia większej płynności i dokładności rozgrywki, musimy dodać mechanizm synchronizacji. Jego brak uniemożliwi grę – w skrajnej sytuacji wąż mógłby zawsze znajdować się w innym miejscu, niż to, w którym byłby wyświetlany na ekranie.

W przypadku naszego kodu trudno określić, co jest sekcją krytyczną. Zastanówmy się wobec tego, czego chcemy uniknąć:

• Nie chcemy, aby wąż przemieszczał się w trakcie ruchu mapy. Oznacza to, że przesuwanie się mapy musi czekać, aż wąż się ruszy i analogicznie, ruszenie się węża musi oczekiwać na narysowanie się mapy.

• Niepożądana jest również sytuacja, w której wąż ruszy się dwa razy.

Aby program działał prawidłowo, musimy utworzyć co najmniej dwie blokady. Jedna będzie otwierała możliwość działania drugiemu wątkowi, zgodnie z następującym schematem:

RNaBwL5zGGCOm

Ilustracja przedstawia schemat.
Wątek A: czerwona prosta zamknięcie wątku A, ikona klucza praca wątku A, zielona prosta otwarcie wątku B.
Wątek B: czerwona prosta otwarcie wątku B, ikona klucza praca wątku B zielona prosta zamknięcie wątku B.

Mając na uwadze fakt, że semafory są obecne w standardzie C++ dopiero od wersji C++20, skorzystamy z innego rozwiązania. Będziemy symulować działanie semafora za pomocą pętli while i funkcji sleep_for(). Przykładowe „czasowe spowalnianie wątku” prezentuje się następująco:

while(watekAPracuje == true)
{
	this_thread::sleep_for(chrono::milliseconds(10));
}

Zaprezentowane rozwiązanie, choć najprostsze, nie jest idealne. Aby uzyskać ten sam efekt, moglibyśmy skorzystać również ze zmiennych globalnych, jednak warto trzymać się dobrych praktyk. W celu uzyskania optymalnego rozwiązania stworzymy te zmienne w funkcji main, a następnie będziemy przekazywać je do odpowiednich metod jako ich argumenty:

bool watekWazPracuje = true;
bool watekGrafikaPracuje = false;

Wtedy metoda przesun() przyjmie następującą postać:

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje)
{
	while (1) 
	{
		while (*watekGrafikiPracuje)
		{
			this_thread::sleep_for(chrono::milliseconds(10));
		}
		*watekWazPracuje = true;
		if (kierunekRuchu == polnoc)
		{
			pozycjaWezaY -= 1;
		}
		else if (kierunekRuchu == poludnie)
		{
			pozycjaWezaY += 1;
		}
		else if (kierunekRuchu == zachod)
		{
			pozycjaWezaX += 1;
		}
		else if (kierunekRuchu == wschod) 
		{
			pozycjaWezaX -= 1;
		}
		*watekWazPracuje = false;
		this_thread::sleep_for(chrono::milliseconds(400));
	}
}

Natomiast metoda wyswietlGre() będzie wyglądać następująco:

void wyswietlGre(Waz* waz, Plansza* plansza, bool* watekGrafikiPracuje, bool* watekWazPracuje)
{
	while (true)
	{
		while (*watekWazPracuje)
		{
			this_thread::sleep_for(chrono::milliseconds(10));
		}
		*watekGrafikiPracuje = true;
		system("CLS");
		for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
		{
			for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
			{
				if (waz->sprawdzPozycjeY() == i && waz->sprawdzPozycjeX() == j)
					cout << "@ \t";
				else
					cout << plansza->pole[i][j].wartoscPola << "\t";
			}
			cout << endl;
		}
		*watekGrafikiPracuje = false;
		this_thread::sleep_for(chrono::milliseconds(200));
	}
}

Istotne jest, aby odblokowanie wątków odbywało się przed funkcją sleep_for. W przeciwnym wypadku ryzykujemy, że odblokowania nigdy się nie zsynchronizują lub będą to robić w sposób nieregularny.

W tym momencie animacja powinna działać stosunkowo płynnie. Spróbuj ją uruchomić i zobacz efekty.

Zaimplementujmy sterowanie wężem. Do klasy ObslugiWejscia potrzebujemy dostarczyć informacje o naszym wężu. Najprościej będzie dodać je do konstruktora.

Biorąc pod uwagę, że jako argument podajemy referencję do istniejącego obiektu, żeby modyfikować oryginał, a w instrukcjach warunkowych if‑else robimy odpowiedni zwrot, metoda zinterpretujWcisnietyPrzycisk() przyjmie następującą postać:

void zinterpretujWcisnietyPrzycisk(Waz *waz)
{
	while (true)
	{
		char przycisk = getch();
		switch (przycisk)
		{
		case 'a':
			if (waz->kierunekRuchu == waz->polnoc)
				waz->kierunekRuchu = waz->wschod;
			else if (waz->kierunekRuchu == waz->wschod)
				waz->kierunekRuchu = waz->poludnie;
			else if (waz->kierunekRuchu == waz->poludnie)
				waz->kierunekRuchu = waz->zachod;
			else
				waz->kierunekRuchu = waz->polnoc;
			break;
		case 'd':
			if (waz->kierunekRuchu == waz->polnoc)
				waz->kierunekRuchu = waz->zachod;
			else if (waz->kierunekRuchu == waz->zachod)
				waz->kierunekRuchu = waz->poludnie;
			else if (waz->kierunekRuchu == waz->poludnie)
				waz->kierunekRuchu = waz->wschod;
			else
				waz->kierunekRuchu = waz->polnoc;
			break;
		case ' ':

			break;
		}
	}
}

Nie uwzględniliśmy jeszcze wariantu użycia spacji. Zajmiemy się tym na późniejszym etapie prac, ponieważ zatrzymywanie gry nie jest związane z implementacją skręcania.

W funkcji main() musimy w deklaracji wątku watekWejscia dopisać jako argument &obiektWaz, ponieważ dopisaliśmy go do definicji metody, której używamy.

int main()
{
	Plansza plansza = Plansza(25, 25);
	WyswietlanieGrafiki grafika = WyswietlanieGrafiki();
	Waz obiektWaz = Waz();
	obiektWaz.ustawPozycje(0, 25);
	bool watekWazPracuje = true;
	bool watekGrafikaPracuje = false;
	thread watekGrafiki (&WyswietlanieGrafiki::wyswietlGre, &grafika, &obiektWaz, &plansza, &watekWazPracuje, &watekGrafikaPracuje);
	ObslugaWejscia wejscie;
	thread watekWejscia(&ObslugaWejscia::zinterpretujWcisnietyPrzycisk, &wejscie, &obiektWaz);
	thread watekWeza(&Waz::przesun, &obiektWaz, &watekWazPracuje, &watekGrafikaPracuje);
	watekGrafiki.join();
	watekWejscia.join();
	watekWeza.join();
}

W obecnej formie głowa węża jest trudna do wyśledzenia wśród natłoku liczb. Należy poprawić czytelność kodu.

Zmienimy metodę wyswietlGre(), tak aby gra zajmowała mniej miejsca w konsoli.

void wyswietlGre(Waz* waz, Plansza* plansza, bool* watekGrafikiPracuje, bool* watekWazPracuje)
{
	while (true)
	{
		while (*watekWazPracuje)
		{
			this_thread::sleep_for(chrono::milliseconds(10));
		}
		*watekGrafikiPracuje = true;
		system("CLS");
		for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
		{
			for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
			{
				if (waz->sprawdzPozycjeY() == i && waz->sprawdzPozycjeX() == j)
					cout << "@ ";
				else
					cout << "+ ";
			}
			cout << endl;
		}
		*watekGrafikiPracuje = false;
		this_thread::sleep_for(chrono::milliseconds(200));
	}
}

Następnie zaimplementujemy metodę losujPlansze() z klasy Plansza.

	void losujPlansze()
	{
		srand((int)time(NULL));

		for (int i = 0; i < rozmiarYPlanszy; i++)
		{
			for (int j = 0; j < rozmiarXPlanszy; j++)
			{
				if ((rand() % 50) == 0)
				{
					pole[i][j].owoc.ustawPunkty(1);
				}
			}
		}
	}

W przedstawionym kodzie losujemy, czy w danym miejscu pojawi się owoc. Szansa na to jest równa 2%. Warto zwrócić uwagę na linijkę 3 – odbywa się tu inicjalizowanie generatora liczb pseudolosowych. Dzięki temu mamy pewność, że po każdym uruchomieniu programu owoce będą rozmieszczone naprawdę losowo, w różnych przypadkowych miejscach. Generator inicjujemy w tym przypadku aktualnym czasem systemowym (który zawsze będzie inną liczbą). Warto pamiętać, że konieczne jest również dodanie odpowiednich nagłówków do obsługi czasu. Dodamy więc na początku kodu następującą linię:

#include <time.h>

Metodę do wyświetlania gry zmienimy w następujący sposób:

void wyswietlGre(Waz* waz, Plansza* plansza, bool* watekGrafikiPracuje, bool* watekWazPracuje)
	{
		while (true)
		{
			while (*watekWazPracuje)
			{
				this_thread::sleep_for(chrono::milliseconds(10));
			}
			*watekGrafikiPracuje = true;
			system("CLS");
			for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
			{
				for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
				{
					if (waz->sprawdzPozycjeY() == i && waz->sprawdzPozycjeX() == j)
						cout << "@ ";
					else if (plansza->pole[i][j].owoc.sprawdzPunkty() == 0)
						cout << "+ ";
					else
						cout << "$ ";
				}
				cout << endl;
			}
			*watekGrafikiPracuje = false;
			this_thread::sleep_for(chrono::milliseconds(200));
		}
	}

Spróbujmy przygotować plik konfiguracyjny. Zgodnie z wymaganiami opisanymi w pierwszym e‑materiale z tej serii, musimy stworzyć mapę o zmiennym rozmiarze – zrobimy to właśnie z poziomu pliku konfiguracyjnego.

Plik konfiguracyjny przyjmie następującą postać:

szerokosc 20
wysokosc 25

Dane zapisywane są zgodnie z konwencją:

nazwaZmiennej wartośćZmiennej

W celu wczytania danych z pliku skorzystamy z nagłówka <fstream> oraz z klasy ifstream. Należy pamiętać, aby ten nagłówek dołączyć do kodu źródłowego, dodając na początku następującą linię:

#include <fstream>

Pamiętajmy o przestrzeni nazw:

using namespace std;

Wczytamy plik konfiguracyjny zgodnie z zasadą, którą przyjęliśmy. Nie będziemy uwzględniać obsługi błędnie utworzonych plików konfiguracyjnych.

Dodatkowo, ponieważ plik konfiguracyjny jest otwierany raz na całą grę, możemy zrobić to w taki sposób, że zmienne będziemy przyjmować zgodnie z ich nazwami, zamiast według kolejności ich występowania, tzn.:

ifstream plikKonf("config.ini");
int wartoscZmiennej;
string zmienna;
int rozmiarX = 0;
int rozmiarY = 0;
if (plikKonf.is_open())
{
	plikKonf >> zmienna >> wartoscZmiennej;
	if (zmienna == "wysokosc") rozmiarY = wartoscZmiennej;
	else if (zmienna == "szerokosc") rozmiarX = wartoscZmiennej;
}

Inaczej mówiąc: liczba zmiennych w naszym kodzie jest skończona i mają one typ liczbowy. Dodatkowo w pliku konfiguracyjnym nie przewidujemy dodawania łańcuchów znaków do wczytywania. Wszystko to sprawia, że możemy wczytać wszelkie dostępne informacje w odpowiedniej pętli. Zakładamy przy tym, że każda nazwa zmiennej jest łańcuchem znaków, a każdy parametr bez problemu może zostać zrzutowany na typ int. Na tym etapie wczytujemy jedynie dwie informacje, czyli rozmiar i szerokość planszy, ale w przyszłości będziemy z pliku konfiguracyjnego wczytywać także m.in. wygląd poszczególnych elementów rozgrywki.

Powyższy kod wczytuje tylko jedną linijkę – zmodyfikujmy go tak, żeby wczytywał wszystkie dane. Użyjmy do tego metody eof(), dostępnej w klasie ifstream.

ifstream plikKonf("config.ini");
int wartoscZmiennej;
string zmienna;
int rozmiarX = 0;
int rozmiarY = 0;
while (!plikKonf.eof())
{
	if (plikKonf.is_open())
	{
		plikKonf >> zmienna >> wartoscZmiennej;
		if (zmienna == "wysokosc") rozmiarY = wartoscZmiennej;
		else if (zmienna == "szerokosc") rozmiarX = wartoscZmiennej;
	}
}
plikKonf.close();

W programie umieścimy ten fragment kodu w funkcji main(), otrzymując:

int main()
{
	ifstream plikKonf("config.ini");
	int wartoscZmiennej;
	string zmienna;
	int rozmiarX = 0;
	int rozmiarY = 0;
	while (!plikKonf.eof())
	{
		if (plikKonf.is_open())
		{
			plikKonf >> zmienna >> wartoscZmiennej;
			if (zmienna == "wysokosc") rozmiarY = wartoscZmiennej;
			else if (zmienna == "szerokosc") rozmiarX = wartoscZmiennej;
		}
	}
	plikKonf.close();
	Plansza plansza = Plansza(rozmiarX, rozmiarY);
	plansza.losujPlansze();
	WyswietlanieGrafiki grafika = WyswietlanieGrafiki();
	Waz obiektWaz = Waz();
	obiektWaz.ustawPozycje(5, 15);
	bool watekWazPracuje = true;
	bool watekGrafikaPracuje = false;
	thread watekGrafiki(&WyswietlanieGrafiki::wyswietlGre, &grafika, &obiektWaz, &plansza, &watekWazPracuje, &watekGrafikaPracuje);
	ObslugaWejscia wejscie;
	thread watekWejscia(&ObslugaWejscia::zinterpretujWcisnietyPrzycisk, &wejscie, &obiektWaz);
	thread watekWeza(&Waz::przesun, &obiektWaz, &watekWazPracuje, &watekGrafikaPracuje);
	watekGrafiki.join();
	watekWejscia.join();
	watekWeza.join();
}

Przedstawione rozwiązanie jest co prawda bardziej złożone obliczeniowo dla procesora, jednak wczytanie pliku konfiguracyjnego odbywa się tylko raz. Zaletą tego rozwiązania jest fakt, że stworzony przez nas plik konfiguracyjny jest odporny na zmiany w kodzie.

Załóżmy, że w toku pisania programu stwierdzimy, iż nie chcemy już wczytywać jakiejś zmiennej lub że potrzebna nam jest nowa. W sytuacji, w której zaistnieje potrzeba wczytania nowej zmiennej, możemy ją dopisać w dowolnym miejscu pliku bez konieczności uwzględniania kolejności występowania parametrów. W sytuacji, gdy już nie będziemy chcieli wczytywać jakiejś zmiennej, wystarczy, że usuniemy jeden if w kodzie, a sama obecność nieużywanego parametru w pliku konfiguracyjnym nie będzie miała wpływu na zachowanie programu.

Plik, zawierający cały stworzony dotychczas kod w języku C++, możesz pobrać tutaj:

Tworzenie gry w języku Java

Zaczniemy od zaimplementowania metod z klasy Wąż, a konkretnie sprawdzWynik(), która zwraca aktualną liczbę punktów, czyli atrybutu liczbaPunktów.

int sprawdzWynik(){
	return liczbaPunktow;
}

Następnie zaimplementujemy metodę ustawWynik(), zmieniającą wartość atrybutu liczbaPunktów na podaną w argumencie.

void ustawWynik(int liczbaPunktowDoUstawienia)
{
	liczbaPunktow = liczbaPunktowDoUstawienia;
}

Tych dwóch wspomnianych metod będziemy używać do sprawdzania i ustawiania wyniku punktowego w trakcie rozgrywki.

Kolejną metodą z tej klasy jest zmienKierunek() – jak sama nazwa wskazuje, służy ona do zmieniania kierunku ruchu głowy węża. Jeśli chcemy, by wąż skręcił, modyfikujemy atrybut kierunekRuchu, odpowiadający za wyznaczanie kierunku przemieszczania się węża.

Dla uproszczenia naszego programu skorzystamy z klasy enumeracyjnej, dzięki czemu będziemy używać nazw zamiast niewiele mówiących liczb.

Klasę enumeracyjną Kierunek umieścimy w ramach klasy Waz.

enum Kierunek {polnoc, wschod, poludnie, zachod};

Będziemy z niej korzystać prawdopodobnie w ramach innych klas, dlatego też zostawimy ją jako publiczną. Wróćmy do implementacji metody zmienKierunek(), która przyjmie teraz następującą postać:

void zmienKierunek(kierunek nowyKierunek)
{
   kierunekRuchu = nowyKierunek;
}

W języku Java nie można – bez dodatkowych kroków – zmienić typu enumerowanego na typ liczbowy. Dlatego też atrybut kierunekRuchu zmienimy z int na klasę enumeracyjną Kierunek. Robiąc to, odchodzimy od przyjętego wcześniej diagramu. Warto przypomnieć, że stworzyliśmy go w taki sposób, aby jak najwięcej języków było z nim kompatybilnych. Nasze odstępstwo nie jest więc błędem. Klasę enumeracyjną da się w łatwy sposób zrzutować na typ int, jednak w naszym przypadku zmniejszyłoby to jedynie czytelność kodu.

Dodatkowo implementujemy metodę, która pozwoli nam sprawdzić aktualny kierunek ruchu węża:

    Kierunek sprawdzKierunek(){
        return kierunekRuchu;
    }

W tym momencie klasa Waz przyjęłaby następującą postać:

public class Waz {
    enum Kierunek {polnoc, wschod, poludnie, zachod}
    private int liczbaPunktow = 0;
    private int pozycjaWezaX = 0;
    private int pozycjaWezaY = 0;
    private Kierunek kierunekRuchu = Kierunek.polnoc;
    Waz(int pozycjaWezaX, int pozycjaWezaY, Kierunek kierunekRuchu){
        this.pozycjaWezaX = pozycjaWezaX;
        this.pozycjaWezaY = pozycjaWezaY;
        this.kierunekRuchu = kierunekRuchu;
    }

    int sprawdzWynik(){
        return liczbaPunktow;
    }

    void ustawWynik(int liczbaPunktowDoUstawienia){
        liczbaPunktow = liczbaPunktowDoUstawienia;
    }

    void zmienKierunek(Kierunek nowyKierunek){
        kierunekRuchu = nowyKierunek;
    }

	Kierunek sprawdzKierunek(){
		return kierunekRuchu;
    }
}

Musimy jednak poprawić w klasie Main miejsce, w którym powołaliśmy do życia jeden obiekt klasy Waz, otrzymując:

public class Main {

    public static void main(String[] args) {
        ObslugaWejscia wejscie = new ObslugaWejscia();
        WyswietlanieGrafiki grafika = new WyswietlanieGrafiki(new Waz(0, 0, Waz.Kierunek.polnoc), new Plansza(5), wejscie);
        Thread watekGrafiki = new Thread(grafika);
        watekGrafiki.run();
    }
}

Wróćmy do implementacji metod w klasie Waz. Kolejną na liście jest metoda przesun(), która będzie modyfikowała atrybuty pozycjaWezaX i pozycjaWezaY, w zależności od atrybutu kierunekRuchu.

void przesun() {
	if (kierunekRuchu == Kierunek.polnoc) {
		pozycjaWezaY -= 1;
	}
	else if (kierunekRuchu == Kierunek.poludnie) {
		pozycjaWezaY += 1;
	}
    else if (kierunekRuchu == Kierunek.zachod) {
   		pozycjaWezaX += 1;
    }
    else if (kierunekRuchu == Kierunek.wschod) {
    	pozycjaWezaX -= 1;
    }
}

Warto wyjaśnić, dlaczego kierunek północ dodaje „-1” do współrzędnej Y.

Rk42ts2di12ZV

Ilustracja przedstawia poziomą strzałkę x wychodzącą z punktu 0 skierowana w prawo oraz strzałkę pionową y skierowaną do dołu.

Na rysunku znajdują się dwie osie układu współrzędnych, które pokazują, w jakim kierunku rosną dane współrzędne. Nasza plansza w lewym górnym rogu ma pole o współrzędnych (0,0), a w prawym dolnym rogu (n‑1, n‑1). Moglibyśmy oczywiście w implementacji programu odwrócić współrzędne w taki sposób, żeby liczone były one od lewego dolnego rogu.

Kolejnymi dwiema metodami z klasy Waz, które zaimplementujemy, będą metody: sprawdzPozycjeX() oraz sprawdzPozycjeY(). Służą one do odczytywania wartości atrybutów pozycjaWezaX oraz pozycjaWezaY.

int sprawdzPozycjeY() {
    return pozycjaWezaY;
}
int sprawdzPozycjeX() {
    return pozycjaWezaX;
}

Metoda ustawPozycje() działa bardzo podobnie do metody ustawWynik(), z tą tylko różnicą, że tym razem modyfikujemy wspomniane przed chwilą atrybuty, które będziemy też podawali jako argumenty naszej metody.

void ustawPozycje(int x, int y) {
    pozycjaWezaX = x;
    pozycjaWezaY = y;
}

W ramach tej klasy pozostała nam do zaimplementowania jedna metoda – czyli zjedzOwoc(). Wykorzysta ona metodę sprawdzPunkty() dostępną z poziomu obiektów klasy Owoc.

int sprawdzPunkty(){
		return liczbaPunktow;
	}

Za jej pomocą będziemy sprawdzać, ile punktów wart jest dany owoc, a następnie liczba ta zostanie przyznana wężowi.

void zjedzOwoc(Owoc owoc){
	liczbaPunktow += owoc.sprawdzPunkty();
}

Usuwanie owocu po zjedzeniu go przez węża zaimplementujemy w kolejnym etapie prac.

Teraz nadszedł moment, w którym możemy zaimplementować poruszanie się węża po planszy. Odpowiedzialna za to metoda powinna odświeżać się w takim tempie, aby wąż z perspektywy gracza poruszał się płynnie.

Dodatkowo ruch węża trzeba zsynchronizować z rysowaniem się mapy, tak by nie poruszał się on w momencie, gdy mapa jest rysowana. Powodowałoby to bowiem takie niepożądane efekty, jak: przeskakiwanie węża o dwa pola, zniknięcie głowy, przerwy w ogonie. Są to potencjalne błędy, których możemy uniknąć, synchronizując w odpowiedni sposób wyświetlanie planszy i poruszanie się węża.

Zrobimy to w osobnych wątkach. Jeden, już zaimplementowany i gotowy do pracy, odpowiada za rysowanie. Drugi, który właśnie implementujemy, wywołuje poruszanie węża. Natomiast trzeci – główny wątek gry uruchamiany przy włączaniu programu – będzie odpowiadał za zarządzanie całą rozgrywką.

Do zaimplementowania dwóch osobnych wątków, skorzystamy z interfejsu Runnable.

Zaczniemy od klasy Waz, w której po zadeklarowaniu nazwy dopiszemy słowo kluczowe implements, a potem nazwę interfejsu Runnable. Otrzymamy:

public class Waz implements Runnable{
...

Następnie zaimplementujemy wszystkie metody, jakich ten interfejs wymaga, czyli jedynie metody run().

@Override
public void run() {
	przesun();        
}

W tym momencie uruchomienie wątku spowodowałoby jednorazowe przesunięcie węża po planszy, dlatego zapętlimy działanie tej metody w nieskończoność. Dla większej czytelności zapętlenie zrobimy w ramach metody run().

@Override
public void run() {
	while(true){
		przesun();
    }
}

Następnie w klasie Main zaimplementujemy uruchamianie wątku obiektu klasy Waz. Robimy to analogicznie jak w przypadku uruchamiania wątku generującego grafikę.

public class Main {

    public static void main(String[] args) {
        ObslugaWejscia wejscie = new ObslugaWejscia();
        Waz waz = new Waz(0, 0, Waz.Kierunek.polnoc);
        WyswietlanieGrafiki grafika = new WyswietlanieGrafiki(waz, new Plansza(5), wejscie);
        Thread watekGrafiki = new Thread(grafika);
        watekGrafiki.start();
        Thread watekWeza = new Thread(waz);
        watekWeza.start();
    }
}

Uruchomienie gry w tym momencie nie da nam jeszcze zadowalającego efektu. Wątek węża pracuje z pełną szybkością procesora, czyli szybciej niż człowiek byłby w stanie zareagować. W celu spowolnienia przesuwania węża użyjemy metody sleep(), która zatrzymuje wątek na co najmniej podaną liczbę milisekund.

Umieścimy ją w metodzie run() klasy Waz, przez co przyjmie ona następującą postać:

public void run() {
    while(true){
        try{
        	Thread.sleep(1000);
        }catch(InterruptedException e){
        	e.printStackTrace();
        }
        przesun();
    }
}

Dopisana powyżej obsługa wyjątku InterruptedException jest konieczna, ponieważ wyjątek ten może być rzucony w momencie, kiedy wątek zostanie przerwany.

Wątek węża i wątek grafiki działają teraz asynchronicznie. Nie zaimplementowaliśmy jednak jeszcze wyświetlania samego węża na planszy, zatem pora to zrobić.

Warunkiem, który będzie decydował o wyświetlaniu ikonki węża na danym polu, jest zgodność jego koordynatów dostępnych pod atrybutami pozycjaWezaY i pozycjaWezaX z koordynatami danego pola.

Dodajemy taki warunek w metodzie wyswietlGre(), dostępnej w ramach klasy WyswietlanieGrafiki. Przypomnijmy, że znakiem @ oznaczamy głowę węża.

public void wyswietlGre(){
	grafikaTekstowa.setText("");
	for(int i = 0; i<plansza.rozmiarYPlanszy; i++){
		for(int j =0 ; j<plansza.rozmiarXPlanszy; j++){
			if(waz.sprawdzPozycjeY()== i &&waz.sprawdzPozycjeX()==j){
				grafikaTekstowa.append("@  ");
			}else if(plansza.pole[i][j].wartoscPola==0){
				grafikaTekstowa.append("+  ");
			}else{
				grafikaTekstowa.append("x  ");
			}
		}
		grafikaTekstowa.append("\n");
	}
}

Przed uruchomieniem gry należy jeszcze zapętlić wyświetlanie grafiki, analogicznie jak w wypadku poruszania się węża (również z obsługą wyjątku InterruptedException).

public void run() {
    while(true) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        wyswietlGre();
    }
}

Uruchamiając rozgrywkę w tym momencie, zobaczylibyśmy, że wąż się przemieszcza, jednak nie mielibyśmy nad nim żadnej kontroli. Wyświetlałyby się za to w konsoli komunikaty informujące o wciskanych przyciskach. Należy w tym wypadku poprawić metodę keyPressed() w klasie ObsługaWejscia, tak byśmy rzeczywiście sterowali wężem.

Dodamy do tej klasy referencję umożliwiającą zmienianie atrybutów konkretnej instancji klasy Waz. Zrobimy to za pomocą nowo utworzonego konstruktora tej klasy. Następnie zmodyfikujemy wcześniej wspominaną metodę tak, aby wąż skręcał w poprawny sposób.

Ostatecznie klasa ObslugaWejscia przyjęłaby następującą postać:

import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

public class ObslugaWejscia implements KeyListener {
    Waz waz;

    ObslugaWejscia(Waz waz) {
        this.waz = waz;
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        char znak = e.getKeyChar();
        switch (znak) {
            case 'a':
                if (waz.sprawdzKierunek() == Waz.Kierunek.polnoc) {
                    waz.zmienKierunek(Waz.Kierunek.wschod);
                } else if (waz.sprawdzKierunek() == Waz.Kierunek.wschod) {
                	waz.zmienKierunek(Waz.Kierunek.poludnie);
                } else if (waz.sprawdzKierunek() == Waz.Kierunek.poludnie) {
                	waz.zmienKierunek(Waz.Kierunek.zachod);
                } else {
                	waz.zmienKierunek(Waz.Kierunek.polnoc);
                }
                break;

            case 'd':
                if (waz.sprawdzKierunek() == Waz.Kierunek.polnoc) {
                	waz.zmienKierunek(Waz.Kierunek.zachod);
                } else if (waz.sprawdzKierunek() == Waz.Kierunek.zachod) {
                	waz.zmienKierunek(Waz.Kierunek.poludnie);
                } else if (waz.sprawdzKierunek() == Waz.Kierunek.poludnie) {
                	waz.zmienKierunek(Waz.Kierunek.wschod);
                } else {
                	waz.zmienKierunek(Waz.Kierunek.polnoc);
                }
                break;
        }
        if (znak == ' ') System.out.println("Kliknieto spacje");
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }
}

Zaimplementowaliśmy już poruszającą się po mapie głowę węża. Na planszy powinny pojawiać się również owoce w losowych miejscach. Nim przejdziemy do losowania, wróćmy do wyświetlania grafiki, gdzie zaimplementujemy pojawianie się owocu na danym polu. Z racji tego, że każde pole posiada własny atrybut owoc, wystarczy sprawdzić, czy pole owoc zawiera, czy nie.

Zmodyfikowana metoda wyswietlGre() przyjmie następującą postać:

public void wyswietlGre(){
     grafikaTekstowa.setText("");
        for(int i = 0; i<plansza.rozmiarYPlanszy; i++){
            for(int j = 0; j<plansza.rozmiarXPlanszy; j++){
            if(waz.sprawdzPozycjeY() == i && waz.sprawdzPozycjeX() == j){
                grafikaTekstowa.append("@ "); 
            }else if(plansza.pole[i][j].owoc != null){
                grafikaTekstowa.append("$   ");
            }else if(plansza.pole[i][j].wartoscPola == 0){
                grafikaTekstowa.append("+   ");
            }else{
                grafikaTekstowa.append("x   ");
            }
        }
        grafikaTekstowa.append("\n ");
    }
}

Początkowe losowanie planszy zaimplementujemy w metodzie losujPlansze() z klasy Plansza.

void losujPLansze(){
    Random rd = new Random();
    for(int i = 0; i < rozmiarYPlanszy; i++){
        for(int j = 0; j < rozmiarXPlanszy; j++){
            if((rd.nextInt(100)+1) == 100){
                pole[i][j].owoc = new Owoc();
            }
        }
     }
}

Aby możliwe było losowanie liczb, konieczne jest wykorzystanie klasy Random, co wymaga jej zaimportowania (linię dopisujemy na początku pliku klasy Plansza):

import java.util.Random;

W kodzie najpierw losujemy liczbę z przedziału od 1 do 100 włącznie, a następnie sprawdzamy, czy liczba ta jest równa 100. Jeśli tak, to w tym miejscu generujemy nowy obiekt klasy Owoc.

Metody tej użyjemy na końcu konstruktora klasy Plansza.

Plansza(int rozmiar){
    rozmiarXPlanszy = rozmiar;
    rozmiarYPlanszy = rozmiar;
    pole = new Pole[rozmiar][rozmiar];
    for(int i = 0; i<rozmiar; i++){
        for(int j = 0; j<rozmiar; j++){
        pole[i][j] = new Pole();
        }
    }
    losujPLansze();
}

Zjadanie owoców zaimplementujemy na późniejszym etapie prac.

Na koniec zaimplementujemy wczytywanie informacji o programie z pliku konfiguracyjnego. Dla uproszczenia załóżmy, że poprawny plik konfiguracyjny przyjmuje następującą postać:

nazwaParametru wartoscParametru

Zaimplementowany przez nas plik konfiguracyjny będzie zawierał dwie informacje: wielkość planszy oraz startową pozycję węża. Jego przykładowa postać to:

rozmiar 25
pozycjaWezaX 10
pozycjaWezaY 5

Tworząc plik konfiguracyjny, zadbamy o to, aby można było w nim podać parametry w dowolnej kolejności. Dzięki temu uzyskamy gwarancję, że w przyszłości będziemy mogli bez problemu dodawać kolejne parametry.

Do wczytania danych z pliku wykorzystamy klasę Scanner, a do wczytania pliku – klasę File.

Wiemy, że w każdej linijce występuje najpierw nazwa parametru, a potem jego wartość liczbowa, dlatego możemy przyjąć następujący sposób wczytywania, który umieszczamy w klasie Main (zwróćmy uwagę na konieczność zaimportowania wymienionych klas obsługujących pliki):

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        
    	File plik = new File("config.ini");
    	Scanner sc = null;
    	try {
    	     sc = new Scanner(plik);
    	} catch (FileNotFoundException e) {
    	  e.printStackTrace();
    	}
    	int rozmiar = 0;
    	int pozycjaWezaX = 0;
    	int pozycjaWezaY = 0;
    	while (sc.hasNext()) {
    	    String nazwaParametru = sc.next();
    	    switch(nazwaParametru) {
    	         case "rozmiar":
    	             rozmiar = Integer.parseInt(sc.next());
    	             break;
    	         case "pozycjaWezaX":
    	             pozycjaWezaX = Integer.parseInt(sc.next());
    	             break;
    	         case "pozycjaWezaY":
    	             pozycjaWezaY = Integer.parseInt(sc.next());
    	             break;
    	    }
    	}
    	
    	Waz waz = new Waz(pozycjaWezaX, pozycjaWezaY, Waz.Kierunek.polnoc);
        ObslugaWejscia wejscie = new ObslugaWejscia(waz);
        WyswietlanieGrafiki grafika = new WyswietlanieGrafiki(waz, new Plansza(rozmiar), wejscie);
        Thread watekGrafiki = new Thread(grafika);
        watekGrafiki.start();
        Thread watekWeza = new Thread(waz);
        watekWeza.start();
    }
}

Plik konfiguracyjny nazwaliśmy config.ini. Podaliśmy do niego ścieżkę względnąścieżka względna (relatywna)ścieżkę względną. Aby można było z niej skorzystać, plik musi znajdować się w folderze projektu, dlatego też umieściliśmy go w ramach głównego folderu.

Kolejne funkcjonalności, takie jak zjadanie owoców czy pojawianie się ogona węża, zaimplementujemy w ramach następnych e‑materiałów z tej serii.

Plik zawierający cały dotychczas napisany kod w języku Java możesz pobrać tutaj:

Tworzenie gry w języku Python

Zaczniemy od zaimplementowania jednej z metod dostępnych w ramach klasy Waz, czyli metody sprawdzWynik(), która będzie sprawdzać aktualną liczbę punktów na podstawie atrybutu liczbaPunktów.

def sprawdzWynik(self):
    return self.liczbaPunktow;

Następnie utworzymy metodę ustawWynik(), która powinna modyfikować atrybut liczbaPunktow na ten podany jako argument.

def ustawWynik(self, liczbaPunktowDoUstawienia):
    self.liczbaPunktow = liczbaPunktowDoUstawienia;

Metodę zmienKierunek() zaimplementujemy w ten sposób, że najpierw w ramach klasy Waz dodamy klasę enumeracyjną, w której umieścimy wszystkie możliwe kierunki poruszania się węża.

#w klasie Waz
import enum
class Kierunek(enum.Enum):
    polnoc = 0
    wschod = 1
    poludnie = 2
    zachod = 3

Respektujemy wspomnianą wcześniej dobrą praktykę używania w programowaniu słów zamiast abstrakcyjnych liczb, które dla kogoś, kto widzi kod po raz pierwszy, nic nie znaczą. Znacznie łatwiej zrozumieć zapis np. kierunek == polnoc niż kierunek == 0.

Metoda służąca do zmieniania kierunku przyjmie postać:

def zmienKierunek(self, kierunek):
    self.kierunekRuchu = kierunek

Bardziej rozbudowana jest metoda przesun(), którą będziemy teraz implementować. Odpowiada ona za ruch węża we właściwym kierunku.

def przesun(self):
    if self.kierunekRuchu == self.Kierunek.polnoc.value:
        self.pozycjaWezaY -= 1
    if self.kierunekRuchu == self.Kierunek.poludnie.value:
        self.pozycjaWezaY += 1
    if self.kierunekRuchu == self.Kierunek.zachod.value:
        self.pozycjaWezaX += 1
    if self.kierunekRuchu == self.Kierunek.wschod.value:
        self.pozycjaWezaX -= 1

Pojawia się pytanie, dlaczego poruszanie się na północ odejmuje 1 od pozycjaWezaY, zamiast dodawać, jak to jest w przypadku kierunku wschód‑zachód i co wydaje się bardziej logiczne.

Wynika to z faktu, że wyświetlamy plansze zgodnie z następującymi osiami:

RXth5U6whq6yk

Ilustracja przedstawia poziomą strzałkę x wychodzącą z punktu 0 skierowana w prawo oraz strzałkę pionową y skierowaną do dołu.

Oznacza to, że na liście najpierw wyświetlamy rzędy od zerowego do ostatniego, a w ramach każdego rzędu od zerowej kolumny do ostatniej.

Podsumowując: aby poruszyć się na planszy w górę, musimy odjąć od pozycjaWezaY liczbę 1. Dodanie spowoduje natomiast poruszanie się w dół. Moglibyśmy oczywiście wyświetlać naszą planszę inaczej – zgodnie ze standardowym sposobem reprezentowania współrzędnych na osi. Możesz teraz spróbować zmodyfikować kod, żeby osiągnąć taki efekt. Pamiętaj jednak, że jeśli wprowadzisz w kodzie zmiany, realizując kroki opisane w dalszej części tego e‑materiału, możesz napotkać nieścisłości.

Kolejne metody z klasy Waz, które zaimplementujemy, to sprawdzPozycjeX() oraz sprawdzPozycjeY(). Zgodnie ze swoją nazwą służą one do zwracania atrybutów pozycjaWezaX oraz pozycjaWezaY.

def sprawdzPozycjeY(self):
	return self.pozycjaWezaY
def sprawdzPozycjeX(self):
	return self.pozycjaWezaX

Następnie zaimplementujemy metodę ustawPozycje(). Działa ona podobnie jak metoda ustawWynik(), z tą różnicą, że zmienia inne atrybuty oraz że potrzebujemy tu dwóch atrybutów.

def ustawPozycje(self, x, y):
	self.pozycjaWezaX = x
    self.pozycjaWezaY = y

Ostatnią metodą z tej klasy, jaką musimy zaimplementować, jest metoda zjedzOwoc(). Przyjmie ona jako argument owoc, który będzie zjadany. Na razie jednak nie będziemy zajmować się znikaniem ani losowaniem owoców. Skupimy się jedynie na implementacji dodawania punktów do obiektu klasy Waz.

def zjedzOwoc(self, owoc):
	self.liczbaPunktow += owoc.sprawdzPunkty()

W tym fragmencie skorzystaliśmy z metody dostępnej w klasie Owoc, która sprawdza liczbę punktów przyznawaną wężowi przez konkretny obiekt tej klasy.

Zaimplementowaliśmy do tej pory wątek grafiki oraz wątek obsługujący wejście, brakuje nam jednak takiego, który obsłużyłby poruszanie się węża po planszy. Zaimplementujmy go zatem:

waz = Waz()
watekWeza = threading.Thread(target=Waz.przesun, args=(waz))

Dodatkowo do wątku grafiki dostarczymy obiekt klasy Waz, którego będziemy używać w trakcie wyświetlania obrazu. Zrobimy to przez dodanie argumentu do metody wyswietlGre().

W tym momencie wąż mógłby się już poruszać, ale nie jesteśmy w stanie tego zweryfikować, ponieważ na naszej planszy jeszcze się on nie wyświetla. Poprawimy więc metodę wyswietlGre() z klasy WyswietlanieGrafiki, do której jako parametr musimy dodać jeszcze sam obiekt klasy Waz.

Przy okazji zaimplementujemy również wyświetlanie owoców oraz pustych komórek. Głowę węża będziemy wyświetlać jako znak @, owoc jako $, pole puste jako +, a ogon jako o.

class WyswietlanieGrafiki():
    def wyswietlGre(self, plansza, waz):
        import os
        import time
        while 1:
            os.system('CLS')
            for i in range(plansza.rozmiarYPlanszy):
                for j in range(plansza.rozmiarXPlanszy):
                    if waz.pozycjaWezaX == j and waz.pozycjaWezaY == i:
                        print("@", end='\t')
                    elif plansza.pole[j][i].owoc != None:
                        print("$", end='\t')
                    elif plansza.pole[j][i].wartoscPola > 0:
                        print("o", end='\t')
                    else:
                        print("x", end='\t')
                print("\n")
            time.sleep(1)

Spróbujmy teraz uruchomić wątek węża i zobaczmy, czy się porusza.

watekWeza.start()
watekWeza.join()

Wąż się nie porusza, ponieważ metoda przesun() z klasy Waz używana jest tylko raz.

Umieścimy ją w pętli while analogicznie jak w przypadku metody wyswietlGre(), którą zaimplementowaliśmy wcześniej. W metodzie przesun() umieścimy również time.sleep(), które będziemy musieli następnie zsynchronizować z wyświetlaniem grafiki. Metoda ta przyjmie następującą postać:

def przesun(self):
    import time
        while 1:
        if self.kierunekRuchu == self.Kierunek.polnoc.value:
            self.pozycjaWezaY -= 1
        if self.kierunekRuchu == self.Kierunek.poludnie.value:
            self.pozycjaWezaY += 1
        if self.kierunekRuchu == self.Kierunek.zachod.value:
            self.pozycjaWezaX += 1
        if self.kierunekRuchu == self.Kierunek.wschod.value:
            self.pozycjaWezaX -= 1
        time.sleep(1)

Jeśli uruchomimy teraz rozgrywkę, wąż natychmiast zniknie z planszy. Spowodowane jest to tym, że domyślnie zmierza w górę, a rozpoczyna ruch w lewym górnym rogu.

Dodajmy więc do konstruktora klasy Waz jego pozycję startową. Dla uproszczenia zakładamy, że pozycja węża podana w konstruktorze znajduje się już na planszy.

Konstruktor jego klasy przyjmie następującą wartość:

def __init__(self, pozycjaWezaX, pozycjaWezaY):
        self.liczbaPunktow = 0
        self.pozycjaWezaX = pozycjaWezaX
        self.pozycjaWezaY = pozycjaWezaY
        self.kierunekRuchu = 0

Powołanie obiektu klasy Waz może więc teraz wyglądać następująco:

waz = Waz(4, 4)

Jeśli uruchomimy program teraz, wąż będzie przemieszczał się po planszy. Zapewne okaże się, że jego ruch nie jest płynny, może też przeskakiwać lub znikać. Wynika to z niezsynchronizowanego wyświetlania grafiki i węża.

Brak synchronizacji działa tak, że wąż porusza się po narysowaniu planszy (w tym wypadku możemy zaobserwować przeskok) albo podczas rysowania planszy (wąż może zniknąć).

Do synchronizacji tych wątków użyjemy zamkazamekzamka dostępnego w ramach modułu threading.

Otwieranie i zamykanie wątków obsługujących węża i wyświetlanie grafiki będzie wyglądać następująco:

RNaBwL5zGGCOm

Ilustracja przedstawia schemat.
Wątek A: czerwona prosta zamknięcie wątku A, ikona klucza praca wątku A, zielona prosta otwarcie wątku B.
Wątek B: czerwona prosta otwarcie wątku B, ikona klucza praca wątku B zielona prosta zamknięcie wątku B.

W naszym przypadku wątkiem A będzie ten obsługujący grafikę, a wątkiem B – obsługujący węża.

Przez „zamknięcie wątku” mamy na myśli zatrzymanie działania tego wątku do czasu jego ponownego „otwarcia”.

Zamki możemy umieścić w programie na kilka sposobów. Jednym z nich jest zadeklarowanie na początku dwóch zmiennych, odpowiadających za jeden wątek. Jednakże takie rozwiązanie spowoduje, że nasz kod przestanie być modułowy, co oznacza, że nie będziemy mogli np. wymienić klasy Waz na inną, ponieważ będzie się w niej znajdowało odwołanie do globalnej zmiennej. Jest to wada, której staramy się uniknąć m.in. poprzez utworzenie diagramów klas i pakietów.

Dlatego też do odpowiednich metod klasy Waz i klasy WyswietlanieGrafiki dodamy obydwa zamki, aby metody same mogły się do nich bez problemu odwoływać – przez referencje.

W metodzie przesun() dodamy jako argumenty zamekWeza oraz zamekGrafiki i analogicznie postąpimy w metodzie wyswietlanieGrafiki().

Utworzenie wcześniej wspomnianych wątków będzie wyglądać następująco:

plansza = Plansza(7, 7)
wyswietlanieGrafiki = WyswietlanieGrafiki()
waz = Waz(6, 6)
zamekWeza = threading.Lock()
zamekWyswietlania = threading.Lock()
zamekWeza.acquire()
watekGrafiki = threading.Thread(target=WyswietlanieGrafiki.wyswietlGre, args=(wyswietlanieGrafiki, plansza,waz, zamekWeza, zamekWyswietlania))
obslugaWejscia = ObslugaWejscia()
watekWejscia = threading.Thread(target=ObslugaWejscia.zinterpretujWcisnietyPrzycisk, args=(obslugaWejscia,waz))
watekWeza = threading.Thread(target=Waz.przesun, args=(waz, zamekWeza, zamekWyswietlania))
watekGrafiki.start()
watekWejscia.start()
watekWeza.start()
watekWejscia.join()
watekGrafiki.join()
watekWeza.join()

Natomiast metody przesun() oraz wyswietlGrafike() prezentują się tak:

def przesun(self, zamekWeza, zamekGrafiki):
    import time
    while 1:
    zamekWeza.acquire()
  	if self.kierunekRuchu == self.Kierunek.polnoc.value:
		self.pozycjaWezaY -= 1
	elif self.kierunekRuchu == self.Kierunek.poludnie.value:
		self.pozycjaWezaY += 1
    elif self.kierunekRuchu == self.Kierunek.zachod.value:
        self.pozycjaWezaX += 1
    elif self.kierunekRuchu == self.Kierunek.wschod.value:
        self.pozycjaWezaX -= 1
    time.sleep(1)
    zamekGrafiki.release()

def wyswietlGre(self, plansza, waz, zamekWeza, zamekGrafiki):
    import os
    import time
    while 1:
        zamekGrafiki.acquire()
        os.system('CLS')
        for i in range(plansza.rozmiarYPlanszy):
            for j in range(plansza.rozmiarXPlanszy):
                if waz.pozycjaWezaX == j and waz.pozycjaWezaY == i:
                    print("@", end='\t')
                    elif plansza.pole[i][j].owoc != None:
                    print("$", end='\t')
                    elif plansza.pole[i][j].wartoscPola > 0:
                    print("o", end='\t')
                    else:
                    print("x", end='\t')
            print("\n")
         zamekWeza.release()
         time.sleep(1)

Wątek obsługi wejścia jest już utworzony i działa w tle w naszym programie. Nadal jednak nie mamy wpływu na ruch węża, wyświetlają się tylko komunikaty informujące o wciskanych klawiszach. Dlatego do metody obsługującej wejście dostarczymy obiekt klasy Waz, którego atrybut kierunekRuchu będziemy następnie modyfikować.

Jeśli wąż porusza się w kierunku północnym, a my wciśniemy przycisk A, to oczekujemy, że zacznie przemieszczać się na zachód. Analogicznie, jeśli porusza się na zachód, będziemy oczekiwać, że po ponownym użyciu klawisza A zacznie przemieszczać się na południe.

Oznacza to, że w zależności od tego, czy klikniemy przycisk A czy B, wąż zmieni swój kierunek o 90 lub o -90 stopni.

Biorąc to pod uwagę oraz dodając do argumentów metody zinterpretujWcisnietyPrzycisk(), otrzymamy ostatecznie:

def zinterpretujWcisnietyPrzycisk(self, waz):
    import msvcrt
    while 1:
        x = msvcrt.getch().decode('ASCII')
        if x == 'a':
            if waz.kierunekRuchu == waz.Kierunek.polnoc.value:
           		waz.kierunekRuchu = waz.Kierunek.zachod.value
            elif waz.kierunekRuchu == waz.Kierunek.wschod.value:
            	waz.kierunekRuchu = waz.Kierunek.polnoc.value
            elif waz.kierunekRuchu == waz.Kierunek.poludnie.value:
            	waz.kierunekRuchu = waz.Kierunek.wschod.value
            elif waz.kierunekRuchu == waz.Kierunek.zachod.value:
            	waz.kierunekRuchu = waz.Kierunek.poludnie.value
        elif x == 'd':
            if waz.kierunekRuchu == waz.Kierunek.polnoc.value:
            	waz.kierunekRuchu = waz.Kierunek.wschod.value
            elif waz.kierunekRuchu == waz.Kierunek.wschod.value:
            	waz.kierunekRuchu = waz.Kierunek.poludnie.value
            elif waz.kierunekRuchu == waz.Kierunek.poludnie.value:
            	waz.kierunekRuchu = waz.Kierunek.zachod.value
            elif waz.kierunekRuchu == waz.Kierunek.zachod.value:
            	waz.kierunekRuchu = waz.Kierunek.polnoc.value
        elif x == ' ':
        print("kliknieto spacje")

Zmodyfikowaniem obsługi przycisku spacji zajmiemy się w ramach kolejnych e‑materiałów z tej serii.

Po uruchomieniu gry mamy już poruszającego się poprawnie węża. Pozostaje jeszcze tylko zaimplementować wczytanie do pliku.

Nasz plik konfiguracyjny wygląda następująco:

[plansza]
rozmiarX = 7
rozmiarY = 7

Odczytamy go z pomocą klasy ConfigParser, dostępnej w ramach nagłówka configparser.

Dla naszego pliku przykładowy kod przyjąłby następującą postać:

ustawienia = configparser.ConfigParser()
ustawienia.read('plikKonfiguracyjny.ini')
rozmiarX = ustawienia.getint('plansza', 'rozmiarX')

W linijce 2 otwieramy odpowiedni plik konfiguracyjny. Plik ten, o ile podajemy ścieżkę bezwzględnąścieżka bezwzględnaścieżkę bezwzględną, a na tym nam zależy, musimy umieścić w folderze z kodem źródłowym.

W linijce 3 pobieramy wartość rozmiarX z działu [plansza]. Jako pierwszy argument tej metody podajemy nazwę nagłówka, a jako drugi – nazwę parametru.

Ostatecznie fragment zawierający wczytywanie ustawień i wielkość planszy prezentuje się tak (należy zwrócić uwagę na konieczność zaimportowania nagłówka klasy configparser):

import configparser
ustawienia = configparser.ConfigParser()
ustawienia.read('plikKonfiguracyjny.ini')
rozmiarX = ustawienia.getint('plansza', 'rozmiarX')
rozmiarY = ustawienia.getint('plansza', 'rozmiarY')
plansza = Plansza(rozmiarX, rozmiarY)

Inne funkcje, takie jak działanie ogona węża, pojawianie się i znikanie owoców na mapie, zaimplementujemy w ramach kolejnych e‑materiałów z tej serii.

Plik zawierający cały dotychczas napisany kod w języku Python możesz pobrać tutaj:

Słownik