Zjadanie owoców

Zaimplementujemy zjadanie owoców przez węża w taki sposób, by znikały one z mapy.

Zastanówmy się, gdzie powinniśmy zacząć pisanie kodu. Teoretycznie czynność zjadania wykonywana jest przez węża, czyli właśnie w klasie Wąż powinniśmy ją obsługiwać. Jednak skąd w klasie Wąż ma znaleźć się informacja, że na danym polu jest owoc?

Informacje o wszystkich polach przechowuje klasa Plansza. Z diagramu klas wynika również, że klasa Wąż otrzymuje informacje od klasy Plansza.

Oznacza to, że jeśli chcemy wykonać program zgodnie z diagramem klas, przekazujemy referencję dotyczącą układu mapy z obiektu klasy Plansza do klasy obiektu Wąż, by ta następnie wykonywała na niej metodę zjedzOwoc().

Jednak klasa Wąż nie posiada zgodnie z założeniami żadnego atrybutu, który mógłby na stałe przechowywać referencję do obiektu reprezentującego planszę.

Problem możemy rozwiązać na kilka sposobów:

1. Zmodyfikować diagram klas, dopasowując go do oczekiwań – jednak celem jest zrealizowanie projektu, bez konieczności wprowadzania zmian na wcześniejszych etapach (i ponownego testowania wszystkich funkcji).

2. Przekazać jednej z metod obiektu klasy Wąż referencję do klasy Plansza, aby tam korzystać z metody zjedzOwoc().

3. Przekazać jednej z metod obiektu klasy Plansza referencję do obiektu klasy Wąż i – analogicznie jak w poprzednim podpunkcie – skorzystać w niej z metody zjedzOwoc().

4. Przekazywać obie referencje – do obiektów reprezentujących węża i planszę – w ramach metody wyświetlGrę(), dostępnej w ramach klasy WyświetlanieGrafiki.

Oczywiście, potencjalnych rozwiązań może być dużo więcej. Jednak nie wszystkie są poprawne. Przykładowo: rozwiązanie polegające na obsłudze zjadania owoców w klasie przeznaczonej do wyświetlania grafiki działałoby w sposób zawiły i nielogiczny. Tym samym znacząco utrudnilibyśmy analizę, serwisowanie i dalszą rozbudowę kodu. Dodatkowo rozwiązania takie są uważane za niezgodne z koncepcją programowania obiektowego, która zakłada, że klasy i obiekty reprezentują pewne sprecyzowane byty i ich zastosowania.

Język C++ i zjadanie owoców

We wszystkich trzech językach skorzystamy z drugiego z przedstawionych sposobów. Referencja zostanie przekazana do metody przesun(), która od tego momentu będzie obsługiwała (poza przesuwaniem węża) każdą potencjalną sytuację – np. zjadanie owoców czy przegranie gry.

Zdefiniowaliśmy wszystkie klasy w jednym pliku bez rozdzielania ich. W przypadku dużych projektów, które mają większą liczbę klas, dobrą praktyką jest umieszczanie każdej klasy w oddzielnym pliku źródłowym. Ułatwia to poruszanie się po projekcie i sprawia, że kod jest czytelny. Nie robimy tego, ponieważ omawiany projekt jest mały i zawiera niewiele klas. Pamiętajmy jednak, że kompilator przetwarza kod źródłowy od pierwszej linii do ostatniej. Dlatego jeżeli w jakiejś klasie wykorzystujemy inne klasy, muszą one zostać zdefiniowane wcześniej (wyżej) w kodzie.

Modyfikujemy kod w taki sposób, aby definicja klasy Plansza znajdowała się przed definicją klasy Waz.

W omawianym przypadku najprościej będzie przenieść definicje klas Owoc i Plansza przed definicje klasy Waz, o ile wcześniej nie występowały w takiej kolejności.

Następnie modyfikujemy argumenty dostarczane do metody przesun().

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)

Dwa pierwsze z argumentów będą przekazywały wskaźniki do zmiennych WatekWazPracuje i WatekGrafikaPracuje, które informują o tym, czy poszczególne wątki działają, czy też są zatrzymane. Trzeci argument będzie przekazywał wskaźnik do obiektu reprezentującego planszę.

Odpowiednie zmiany wprowadzamy w ramach funkcji main(), żeby w funkcji uruchamiającej wątek zgadzały się argumenty.

std::thread watekWeza(&Waz::przesun, &obiektWaz, &watekWazPracuje, &watekGrafikaPracuje, &plansza);

Po zweryfikowaniu, że przedstawione modyfikacje nie powodują błędów w programie, dopisujemy sprawdzenie, czy na danym polu znajduje się owoc.

Tworzymy:

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)
{
	while (1) 
	{
		while (*watekGrafikiPracuje)
		{
			std::this_thread::sleep_for(std::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;
		Owoc owocNaPolu = plansza->pole[pozycjaWezaY][pozycjaWezaX].owoc;
		std::cout << owocNaPolu.sprawdzPunkty() << std::endl;
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
}

Po zastosowaniu tej definicji metody wyświetli się liczba punktów danego pola na mapie.

Warto zwrócić uwagę, że wartość ta pokazuje się o jeden krok animacji przed momentem, gdy wąż faktycznie wejdzie na daną kratkę. Dzieje się tak, ponieważ jeden wątek obsługuje przesuwanie, a inny wyświetlanie grafiki.

RGpp7cgfP0kVR

Zrzut ekranu przedstawia grę w węża programu w konsoli cmd.
Plansza jest w kształcie kwadratu i jest złożona z znaków plusa.
Znaki inne niż plus takie jak małpa lub dolar oznaczają owoce.

Po przetestowaniu praktycznego działania programu, przejdźmy do implementacji zjadania owocu. Pod warunkiem jednak, że ten owoc znajduje się na danym polu:

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)
{
	while (1) 
	{
		while (*watekGrafikiPracuje)
		{
			std::this_thread::sleep_for(std::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;
		Owoc* owocNaPolu = &plansza->pole[pozycjaWezaY][pozycjaWezaX].owoc;
		if (owocNaPolu->sprawdzPunkty())
		{
			zjedzOwoc(owocNaPolu);
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
}

Następnie implementujemy metodę zjedzOwoc().

Istotne jest, że klient na żadnym etapie prac nie wymagał, żeby po zjedzeniu owocu na planszy pojawiał się kolejny owoc. Nie zostało to też uwzględnione na żadnym diagramie.

Dlatego nie zaimplementujemy takiej opcji, przez co metoda zjedzOwoc() przyjmie postać:

void zjedzOwoc(Owoc* owoc)
{
	liczbaPunktow += owoc->sprawdzPunkty();
	owoc->ustawPunkty(0);
}

Dotychczas napisany kod źródłowy w języku C++ można pobrać, korzystając z linku:

Język Java i zjadanie owoców

Implementując zjadanie owoców w języku Java, odejdziemy od projektu programu i dodamy do klasy Waz informacje na temat planszy, poprzez dodanie odpowiedniego atrybutu. Nie jest to jedyne rozwiązanie, ale inne – w większym stopniu – niszczyłyby ład wcześniej opracowanych diagramów.

Na przykładzie problemu zjadania owocu widać, że nawet jeżeli diagram jest ogólny, to jego implementacja może się różnić w zależności od języka, mimo że w domyśle nie powinna. Omawiany problem udało się rozwiązać lepiej w przypadku języka C++, w którym podczas tworzenia wątku można dodać argument do metody przesun(), którą ten wątek wykorzysta (co jest zaprezentowane w sekcji przeznaczonej dla tego języka). Niestety w języku Java nie istnieje żaden prosty sposób na rozwiązanie problemu zjadania owocu.

Innym rozwiązaniem tego problemu potencjalnie mogłaby być zmiana w ramach metody wyswietlGre(), w której zaimplementowalibyśmy wszystkie operacje związane z usuwaniem owoców. Rozwiązanie takie byłoby jednak sprzeczne z dobrą praktyką, polegającą na dbaniu o schludność i łatwość analizy kodu. Umieszczanie fragmentu odpowiedzialnego za logiczne usuwanie owoców w metodzie, która służy do wyświetlania grafiki, utrudniałoby analizę kodu.

Kolejnym nie do końca odpowiednim rozwiązaniem byłoby dodanie do obiektu klasy Plansza referencji do obiektu klasy Waz. Byłby to zabieg niezgodny z wcześniej ustalonym diagramem, do czego z założenia wolimy nie dopuszczać. Warto w tym miejscu zwrócić uwagę, że już na etapie tworzenia diagramów można było się zastanowić, czy klasa Plansza nie powinna przechowywać referencji do obiektu klasy  Waz, analogicznie jak w przypadku owoców. Jeżeli umieścilibyśmy referencję Waz w obiekcie klasy Plansza i z jej poziomu wywoływali jego metodę, to wtedy nie wąż byłby samodzielnym wątkiem, a plansza. Takie podejście również jest poprawne, jednak wymagałoby od nas przebudowania znacznej części kodu.

W projekcie do klasy Waz dodamy bezpośrednio z konstruktora parametr o nazwie planszy. Jest to rozwiązanie najprostsze i niewprowadzające do kodu chaosu, ani nie wymagające istotnych zmian w całej logice gry. Definicja klasy wygląda następująco:

public class Waz implements Runnable{
    enum Kierunek {polnoc, wschod, poludnie, zachod}
    private int liczbaPunktow = 0;
    private int pozycjaWezaX = 0;
    private int pozycjaWezaY = 0;
    private Kierunek kierunekRuchu = Kierunek.polnoc;
    private Plansza plansza;
    ...

Z kolei kod klasy Main modyfikujemy w taki sposób:

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;
    	    }
    	}
    	
    	Plansza plansza = new Plansza(rozmiar);
    	Waz waz = new Waz(pozycjaWezaX, pozycjaWezaY, Waz.Kierunek.polnoc, plansza);
        ObslugaWejscia wejscie = new ObslugaWejscia(waz);
        WyswietlanieGrafiki grafika = new WyswietlanieGrafiki(waz, plansza, wejscie);
        Thread watekGrafiki = new Thread(grafika);
        watekGrafiki.start();
        Thread watekWeza = new Thread(waz);
        watekWeza.start();
    }
}

Konstruktor klasy Waz prezentuje się teraz tak:

Waz(int pozycjaWezaX, int pozycjaWezaY, Kierunek kierunekRuchu, Plansza plansza){
    this.pozycjaWezaX = pozycjaWezaX;
    this.pozycjaWezaY = pozycjaWezaY;
    this.kierunekRuchu = kierunekRuchu;
    this.plansza = plansza;
}

Następnie w metodzie przesun() sprawdzamy, czy w miejscu, gdzie jest głowa węża, znajduje się owoc.

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;
    }
    Owoc owoc = plansza.pole[pozycjaWezaY][pozycjaWezaX].owoc;
    if(owoc != null)
        System.out.println(owoc);
}

Po uruchomieniu modyfikacji i sprawdzeniu, czy wszystko działa, przechodzimy do zaimplementowania metody zjedzOwoc(), która powinna znaleźć się w klasie Waz.

Ponieważ na żadnym etapie projektowania i rozmów nie zostało ustalone, że owoce mają się ponownie pojawiać, nie zaimplementujemy tej opcji.

Zanim przystąpimy do implementacji metody zjedzOwoc(), tworzymy dwie metody, które powinny znaleźć się w definicji klasy Owoc: sprawdzPunkty() oraz ustawPunkty(). Pierwsza z nich zwraca liczbę punktów danego owocu. Druga natomiast służy do ustawienia liczby punktów owocu.

Ostatecznie uzyskujemy następującą postać klasy Owoc:

public class Owoc {
    private int liczbaPunktow = 0;
    public void ustawPunkty(int liczbaPunktow){
        this.liczbaPunktow = liczbaPunktow;
    }
    public int sprawdzPunkty(){
        return this.liczbaPunktow;
    }
}

Metoda zjedzOwoc() wygląda tak:

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

Napotykamy tutaj dość istotny problem. W przypadku projektu w języku Java jeżeli nawet dla obiektu klasy Owoc w danym obiekcie klasy Pole ustawimy wartość punktów na 0, to owoc ten nie zniknie z danego pola.

W wymaganiach zapisano, że owoc ma znikać po zjedzeniu go przez węża.

Rozwiązania tego problemu są dwa. Możemy wyświetlać owoce, które mają wartości niezerowe. Przy założeniu, że nowe owoce się nie pojawiają, jest to rozwiązanie akceptowalne. Jednakże odrzucimy je, aby nie utrudniać ewentualnej późniejszej implementacji pojawiania się owocu.

Skorzystamy z drugiego rozwiązania, polegającego na zmianie budowy klasy zjedzOwoc(). Zamiast jako argument podawać referencje na obiekt klasy Owoc,  będziemy podawali tam referencje na obiekt klasy Pole, które zawiera obiekt klasy Owoc.

void zjedzOwoc(Pole poleNaKtorymJestOwoc) {
    liczbaPunktow += poleNaKtorymJestOwoc.owoc.sprawdzPunkty();
    poleNaKtorymJestOwoc.owoc.ustawPunkty(0);
    poleNaKtorymJestOwoc.owoc = null;
    System.out.println(liczbaPunktow);
}

Przeprowadzamy też zmianę w ramach wywołania tej metody w metodzie przesun().

...
Owoc owoc = plansza.pole[pozycjaWezaY][pozycjaWezaX].owoc;
if(owoc != null)
   zjedzOwoc(plansza.pole[pozycjaWezaY][pozycjaWezaX]);

Możemy zauważyć, że wszystkie owoce mają wartość 0 punktów (a więc zebranie owocu nie powoduje dodania punktów graczowi). Jest to ewidentnie sytuacja niepożądana, która wymaga poprawek w kodzie.

Ustawianie punktów dla owoców dodamy w ramach metody 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();
                pole[i][j].owoc.ustawPunkty(1);
            }
        }
    }
}

Po uruchomieniu rozgrywki możemy zobaczyć, że wąż rzeczywiście przesuwa się po mapie, zjadając kolejne owoce i zbierając punkty.

Cały dotychczas napisany kod źródłowy w języku Java możesz pobrać, korzystając z linku:

Język Python i zjadanie owoców

W przypadku projektu w języku Python problem polega na tym, że w żadnym miejscu kodu nie generujemy obiektów reprezentujących owoce.

Aby wygenerować planszę z owocami, implementujemy metodę losujPlansze(), z użyciem funkcji randint(), dostępnej z biblioteki random.

Dla każdego pola na planszy szansa, że pojawi się jakiś owoc, wynosi 15% – dlatego kod generujący owoce na planszy wygląda w następujący sposób:

def losujPlansze(self):
    import random
    for i in range(self.rozmiarYPlanszy):
        for j in range(self.rozmiarXPlanszy):
            if random.randint(1, 100) <= 15:
                self.pole[i][j].owoc = Owoc()
                self.pole[i][j].owoc.ustawPunkty(1)
                return

A samą metodę wywołujemy w ramach konstruktora obiektu Plansza, czyli:

def __init__(self, rozmiarXPlanszy, rozmiarYPlanszy):
    self.rozmiarXPlanszy = rozmiarXPlanszy
    self.rozmiarYPlanszy = rozmiarYPlanszy
    self.pole = [[Pole() for x in range(rozmiarXPlanszy)] for y in range(rozmiarYPlanszy)]
    self.losujPlansze()
return

W tym miejscu możemy się zorientować, że nie zaimplementowaliśmy jeszcze metody ustawPunkty(), więc robimy to teraz.

def ustawPunkty(self, punkty):
    self.liczbaPunktow = punkty
    return

Po zaimplementowaniu tych podstawowych metod przechodzimy do czynności zjadania owocu. W przypadku języka Python korzystamy z drugiej z przedstawionych wcześniej możliwości.

Definicja metody przesun() zmienia się następująco:

def przesun(self, zamekWeza, zamekGrafiki, plansza):

Natomiast stworzenie wątku węża zmieniamy w taki sposób:

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

Następnie dopisujemy obsługę zjadania owocu w metodzie przesun().

owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
if owoc != None:
	self.zjedzOwoc(owoc)

Jednak obiekt klasy Owoc będzie dalej w danym polu posiadał swoją referencję. Jest to problematyczne, ponieważ wyświetlamy owoc lub puste pole w zależności od tego, czy w danym miejscu obiekt klasy Owoc się znajduje. Należy te referencje usuwać, zamiast jedynie zerować ich wartości. Stąd wprowadzamy modyfikację w kodzie, polegającą na tym, że jako argument metody zjedzOwoc() przekażemy obiekt klasy Pole, z którego usuniemy referencje do danego obiektu klasy Owoc.

Dlatego też metoda zjedzOwoc() zmieni się w następujący sposób:

def zjedzOwoc(self, pole):
    print("PRINT: " + str(pole.owoc.sprawdzPunkty()))
    #self.liczbaPunktow += pole.owoc.sprawdzPunkty()
    pole.owoc = None

Analogicznie zmieniamy wywołanie tej metody, żeby jej parametry się zgadzały:

owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
if owoc != None:
	self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
time.sleep(1)
zamekGrafiki.release()

Po uruchomieniu programu możemy zaobserwować wyświetlanie komunikatu:

Print: None

Błąd wynika z faktu, że nie zaimplementowaliśmy jeszcze metody sprawdzPunkty(). Zróbmy to:

def sprawdzPunkty(self):
    return self.liczbaPunktow

Po dodaniu tej zmiany widzimy, że komunikat jest poprawny, ponieważ pokazuje wartość liczbową:

Print: 1

Dlatego też możemy ostatecznie zmodyfikować metodę zjedzOwoc(), by dodawała punkty do obiektu klasy Waz.

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

Po uruchomieniu programu możemy zaobserwować, że wąż rzeczywiście przesuwa się po planszy.

Dotychczas napisany kod źródłowy w języku Python możesz ściągnąć, korzystając z linku:

Warunki zakończenia rozgrywki

Klient jako jedyny warunek zakończenia rozgrywki wymienił sytuację, w której wąż dotyka swojego ogona. Ponieważ zjedzone owoce się nie odnawiają, sytuację, w której na planszy nie będzie już żadnego owocu (wszystkie owoce zostały zjedzone), uznamy za drugi warunek zakończenia rozgrywki.

Ostatnią kwestią do rozwiązania jest granica mapy. Czy gra powinna się skończyć po tym, gdy wąż dotknie granicy mapy? Założymy, że tak, mimo że nie zostało to w początkowych wymaganiach sformułowane.

Sprawdzenie, czy na mapie są jeszcze jakieś owoce, można zaimplementować na co najmniej dwa sposoby:

• podczas generowania obiektów reprezentujących owoce zliczać je w specjalnej zmiennej w ramach klasy Plansza, a podczas zjadania zmniejszać wartość tej zmiennej;

• podczas zjadania owoców sprawdzać każde pole na mapie w poszukiwaniu owoców.

Wykorzystamy pierwszą metodę, ponieważ jest ona mniej złożona obliczeniowo, a pojedyncza zmienna nie zajmuje dużo pamięci.

Sprawdzenie, czy wąż dotyka krawędzi mapy, będziemy wykonywali w ramach metody przesuń().

Zakończenie rozgrywki napiszemy dopiero wtedy, gdy zaimplementujemy możliwość sprawdzenia wszystkich warunków porażki.

Ostatnim warunkiem zakończenia rozgrywki jest dotknięcie przez głowę węża jego własnego ogona. Sam ogon jednak nie został dotąd zaimplementowany – zrobimy to w dalszej kolejności, ponieważ jego działanie musi zostać szerzej omówione.

Warunki zakończenie rozgrywki w języku C++

Zaczynamy od dodania atrybutu liczbaOwocow do klasy Plansza, domyślnie jego wartość ustawiamy na zero.

Następnie modyfikujemy metodę zjedzOwoc(), żeby przyjmowała jako parametr dodatkowo obiekt klasy Pole. W ten sposób uzyskujemy możliwość modyfikowania atrybutów tego obiektu z poziomu metody zjedzOwoc().

void zjedzOwoc(Owoc* owoc, Plansza* plansza)
{
	liczbaPunktow += owoc->sprawdzPunkty();
	owoc->ustawPunkty(0);
	plansza->liczbaOwocow--;
}

Przy okazji poprawiamy również wywołanie tej metody w metodzie przesun().

zjedzOwoc(owocNaPolu, plansza);

Piszemy fragment kodu odpowiedzialny za wychodzenie za krawędź mapy. Umieszczamy go w ramach metody przesun():

if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza->rozmiarYPlanszy
	|| sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza->rozmiarXPlanszy)
{
	break;
}

Istotna jest kolejność wykonywania instrukcji. Przedstawiony fragment powinien się znaleźć po przesunięciu, jednak przed wywołaniem metody sprawdzPunkty(). Ponieważ po wyjściu z planszy dojdzie do próby wywołania metody z nieistniejącego obiektu lub – co gorsza – pobrania wartości z ujemnego indeksu tablicy, co w języku C++ nie może mieć miejsca.

W tym momencie metoda przesun() wygląda w taki sposób:

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)
{
	while (1) 
	{
		while (*watekGrafikiPracuje)
		{
			std::this_thread::sleep_for(std::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;
		Owoc* owocNaPolu = &plansza->pole[pozycjaWezaY][pozycjaWezaX].owoc;
		if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza->rozmiarYPlanszy
			|| sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza->rozmiarXPlanszy)
		{
			break;
		}
		if (owocNaPolu->sprawdzPunkty())
		{
			zjedzOwoc(owocNaPolu, plansza);
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
}

Zanim przejdziemy dalej, musimy jeszcze dodać, że w momencie generowania owoców inkrementujemy atrybut liczbaOwocow po każdym wygenerowanym owocu.

Możemy uzyskać ten efekt poprzez edytowanie metody losujPlansze(), gdzie losowane są również owoce. Po edycji wygląda ona następująco:

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);
                liczbaOwocow++;
            }
        }
    }
}

Warunki zakończenia rozgrywki w Javie

W przypadku języka Java zaczynamy od zmodyfikowania atrybutów klasy Plansza, a mianowicie od dodania atrybutu liczbaOwocow.

Atrybut ten nie był uwzględniony w początkowym diagramie klas. Co prawda powinniśmy starać się pisać program w sposób jak najbardziej zgodny z diagramem, jednak tylko przy założeniu, że został on poprawnie wykonany. W omawianym przypadku analityk nie uwzględnił, że taki atrybut będzie wymagany lub założył, że w inny sposób zostanie zweryfikowana liczba owoców.

Dodajemy więc następujący atrybut w ramach klasy Plansza:

public int liczbaOwocow = 0;

Następnie edytujemy metodę losujPlansze() z klasy Plansza w ten sposób, żeby po wygenerowaniu owocu inkrementował się również atrybut liczbaOwocow.

Po edycji metoda losujPlansze() wygląda następująco:

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();
                pole[i][j].owoc.ustawPunkty(1);
                liczbaOwocow++;
            }
         }
    }
}

Uwzględniamy również, że zjadanie owoców powoduje dekrementacje, robimy to w ramach metody zjedzOwoc(), dostępnej w klasie Waz.

void zjedzOwoc(Pole poleNaKtorymJestOwoc) {
    liczbaPunktow += poleNaKtorymJestOwoc.owoc.sprawdzPunkty();
    poleNaKtorymJestOwoc.owoc.ustawPunkty(0);
    poleNaKtorymJestOwoc.owoc = null;
    System.out.println(liczbaPunktow);
    plansza.liczbaOwocow--;
 }

Cały czas sprawdzamy, czy granice planszy zostały przez głowę węża przekroczone. W tym celu modyfikujemy klasę Waz, a w niej metodę run(), która wywołuje metodę przesun(), dodając następujące sprawdzenie:

if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza.rozmiarYPlanszy
	|| sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza.rozmiarXPlanszy){
	break;
}

Jednak analogiczne sprawdzenie musiałoby zostać dodane w ramach metody przesun(), tak żeby wątek nie próbował odczytać elementu tablicy spod ujemnego indeksu, co w języku Java nie może mieć miejsca.

Dlatego wprowadzimy w ramach klasy Waz metodę pomocniczą sprawdzCzyNaPlanszy(), która przyjmie następującą postać:

boolean sprawdzCzyNaPlanszy(){
    if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza.rozmiarYPlanszy
        || sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza.rozmiarXPlanszy) return false;
    else return true;
}

Następnie używamy jej w ramach metody run():

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

Metodę pomocniczą sprawdzCzyNaPlanszy() używamy również w metodzie przesun(), żebyśmy nie próbowali operować na nieprawidłowych indeksach planszy.

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;
	}
	if(sprawdzCzyNaPlanszy()) {
		Owoc owoc = plansza.pole[pozycjaWezaY][pozycjaWezaX].owoc;
		if (owoc != null)
			zjedzOwoc(plansza.pole[pozycjaWezaY][pozycjaWezaX]);
	}
}

Wykonywanie identycznego sprawdzenia dwa razy nie jest jednak optymalnym sposobem na rozwiązanie tego problemu.

Warunki zakończenia rozgrywki w Pythonie

Zaczynamy od dodania warunku sprawdzającego, czy wąż znalazł się na granicy mapy w ramach metody przesun(). Początkowo robimy tak, żeby nieskończona pętla przerywała swoje działanie (w późniejszym kroku wykonamy działania związane z zakończeniem rozgrywki). Metoda po zmianie:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    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

        if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
        	zamekGrafiki.release()
        	break
        else:
        	owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
        	if owoc != None:
        		self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
        	time.sleep(1)
        	zamekGrafiki.release()

Sprawdzenie, czy wąż znajduje się w ramach planszy, zapisane zostało w ramach następującego wyrażenia warunkowego:

if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:

Dodajemy również w klasie Plansza atrybut o nazwie ileOwocow. Za jego pomocą będziemy sprawdzać, ile owoców znajduje się aktualnie na planszy. Liczba owoców będzie ustalana podczas ich generowania, tzn. po każdorazowym wygenerowaniu obiektu owocu będziemy inkrementowali wartość tego atrybutu, a po zjedzeniu owocu przez węża, wartość atrybutu będziemy zmniejszali.

Początkową wartość atrybutu ileOwocow ustawiamy na zero.

Oto jedna z możliwych postaci metody losujPlansze() po modyfikacji uwzględniającej zliczanie owoców:

def losujPlansze(self):
    for i in range(self.rozmiarYPlanszy):
        for j in range(self.rozmiarXPlanszy):
            if random.randint(1,100) <= 15:
                self.pole[i][j].owoc = Owoc()
                self.pole[i][j].owoc.ustawPunkty(1)
                self.ileOwocow = self.ileOwocow + 1
    return

Brakuje nam jeszcze dekrementacji liczby owoców podczas ich zjadania. Implementujemy to w ramach metody zjedzOwoc() dostępnej w klasie Waz.

Metoda ta po zmianie:

def zjedzOwoc(self, pole):
    self.liczbaPunktow += pole.owoc.sprawdzPunkty()
    plansza.ileOwocow = plansza.ileOwocow - 1
    pole.owoc = None

Ogon

W oryginalnej grze Snake istotnym elementem rozgrywki jest ogon węża. Przyszedł moment, w którym dodamy go do gry, ponieważ bez niego nie będziemy w stanie zaimplementować wszystkich warunków porażki.

Ogon węża mógłby być osobną klasą, ale wcześniej uznaliśmy, że nie ma takiej potrzeby. Musimy jednak w jakiś sposób rozpoznać pola, w których powinien pojawić się ogon, tzn. miejsca, które odwiedził wąż, a następnie się przesunął.

W implementacji ogona wykorzystamy właśnie fakt, że podąża on bezpośrednio trasą węża. Problem rozwiążemy w następujący sposób: każde Pole posiada specjalny atrybut do tego przewidziany, tj. wartoscPola. Jeżeli atrybut ten będzie dodatni, to w danym miejscu pojawi się znak, który będziemy interpretowali jako ogon. Atrybut wartoscPola we wszystkich polach, gdzie jest on dodatni, będziemy dekrementowali, żeby symulować efekt przesuwania się ogona.

Ogon w języku C++

W przypadku implementacji gry w języku C++ rozpoczynamy od dopisaniu fragmentu kodu, który będzie odpowiedzialny za wyświetlanie się ogona. Za znak ogona przyjmiemy znak „x”, który powinien się wyświetlić w przypadku, gdy na danym polu nie znajdują się ani owoc, ani głowa węża oraz gdy wartość atrybutu wartoscPola będzie większa od zera.

Metoda wyswietlGre() --- po uwzględnieniu wspomnianych przed chwilą warunków wyświetlania znaku „x” – przyjmuje następującą postać:

// @: głowa węża, x: ogon węża, $: owoc, +: pole
void wyswietlGre(Waz* waz, Plansza* plansza, bool* watekGrafikiPracuje, bool* watekWazPracuje)
{
    while (true)
    {
        while (*watekWazPracuje)
        {
            std::this_thread::sleep_for(std::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)
                    std::cout << "@ ";
                else if (plansza->pole[i][j].owoc.sprawdzPunkty() != 0)
                    std::cout << "$ ";
                else if (plansza->pole[i][j].wartoscPola > 0)
                    std::cout << "x ";
                else
                    std::cout << "+ ";
            }
            std::cout << std::endl;
        }
        *watekGrafikiPracuje = false;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
}

Następnie dopisujemy kod w taki sposób, by na odpowiednich polach ogon zaczął się rzeczywiście pojawiać.

Przechodzimy do metody przesun(), gdzie odwołujemy się do obiektu Pole poprzez obiekt klasy Plansza.

plansza->pole[pozycjaWezaY][pozycjaWezaX]

W kolejnym kroku ustawiamy w danym polu wartość atrybutu wartoscPola na podstawie obecnego wyniku punktowego, czyli atrybutu liczbaPunktow dostępnego w ramach klasy Waz.

Atrybut wartoscPola modyfikujemy następująco:

plansza->pole[pozycjaWezaY][pozycjaWezaX] = liczbaPunktow;

Cała metoda przesun():

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)
{
	while (1) 
	{
		while (*watekGrafikiPracuje)
		{
			std::this_thread::sleep_for(std::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;
		Owoc* owocNaPolu = &plansza->pole[pozycjaWezaY][pozycjaWezaX].owoc;
		if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza->rozmiarYPlanszy
			|| sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza->rozmiarXPlanszy)
		{
			break;
		}
		if (owocNaPolu->sprawdzPunkty())
		{
			zjedzOwoc(owocNaPolu, plansza);
		}
		plansza->pole[pozycjaWezaY][pozycjaWezaX].wartoscPola = liczbaPunktow;
		std::this_thread::sleep_for(std::chrono::milliseconds(500));
	}
}

Po uruchomieniu programu widzimy, że wąż rysuje za sobą nieskończony ogon. Żeby zasymulować jego ruch, implementujemy metodę zaaktualizujOgonWeza(), dostępną w klasie Plansza. Będziemy w niej iterować po wszystkich dostępnych obiektach klasy Pole, a następnie dekrementować atrybut wartoscPola – w przypadku, jeżeli wartość tego atrybutu jest większa niż zero.

Metodę tę wywołamy w końcowej części metody przesun(), jednak przed wywołaniem funkcji sleep_for().

Metoda zaaktualizujOgonWeza() przyjmuje następującą postać:

void zaaktualizujOgonWeza()
{
    for (int i = 0; i < rozmiarYPlanszy; i++)
    {
        for (int j = 0; j < rozmiarXPlanszy; j++)
        {
            if (pole[i][j].wartoscPola > 0)
            {
                pole[i][j].wartoscPola--;
            }
        }
    }
}

Po uruchomieniu gry możemy zaobserwować, że ogon węża pojawia się i porusza za głową węża dopiero po trzecim zjedzonym owocu.

Przykładowym prostym rozwiązaniem tego problemu byłoby ustawienie domyślnego wyniku punktowego węża w atrybucie liczbaPunktow na dwa. Wtedy ogon wyświetlałby się prawidłowo – nie jest to jednak idealne rozwiązanie.

Problem z ogonem bierze się stąd, że plansza jest aktualizowana zbyt szybko – gdy wąż ma jeden punkt (czyli atrybut liczbaPunktow jest równy jeden), atrybut wartoscPola również przyjmuje jeden. Jednak ponieważ Pole aktualizowane jest po ustawieniu wartości punktów, to od razu ten punkt jest kasowany - w linii nr 9 powyższego kodu metody zaktualizujOgonWeza(). Jeżeli zamienimy kolejnością aktualizowanie ogona oraz ustawianie wartości pola, to ogon będzie za krótki tylko o jedno pole, zamiast o dwa.

Oto przykład, w którym pokazujemy, jak najpierw aktualizujemy ogon, a dopiero potem ustawiamy wartość Pola:

plansza->zaaktualizujOgonWeza();
plansza->pole[pozycjaWezaY][pozycjaWezaX].wartoscPola = liczbaPunktow;

Ta pozostała kratka opóźnienia bierze się stąd, że o ile rzeczywiście wartość Pola jest ustawiana w danej iteracji przed dekrementacją, o tyle wartości wszystkich pozostałych pól już są dekrementowane w metodzie zaktualizujOgonWeza(). A ponieważ fakt wykonania przesunięcia powoduje wykonanie tej metody, dekrementowany jest również atrybut wartoscPola pola dopiero co odwiedzonego.

Problem ten można rozwiązać, modyfikując instrukcję w następujący sposób:

plansza->pole[pozycjaWezaY][pozycjaWezaX].wartoscPola = liczbaPunktow + 1;

W ten sposób liczba punktów węża jest zgodna z długością jego ogona.

Na tym przykładzie widać, że nie zawsze pierwsze, najprostsze rozwiązanie jest  dobre. Po przetestowaniu może okazać się, że jest ono błędne. Należy wtedy dokładnie przeanalizować powód błędnego działania kodu, zaproponować poprawione rozwiązanie i sprawdzić, czy ono działa w sposób prawidłowy.

Dotychczas napisany kod w języku C++ można pobrać za pomocą linku:

Ogon w języku Java

W projekcie w języku Java mamy już zaimplementowane wyświetlanie ogona, który jest znakiem „x”. Dla przypomnienia: za wyświetlanie grafiki odpowiada metoda wyswietlGre() z klasy WyswietlanieGrafiki, która powinna wyglądać w następujący sposób:

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 ");
	}
}

Dlatego też możemy skupić się na implementacji ogona. Przechodzimy do metody przesun(), w której będziemy ustawiali atrybut wartoscPola, w obiektach klasy Pole, na podstawie atrybutu węża o nazwie liczbaPunktow.

Po dodaniu linijki:

plansza.pole[pozycjaWezaY][sprawdzPozycjeX()].wartoscPola = liczbaPunktow;

W metodzie przesun() z klasy Waz po uruchomieniu programu możemy zobaczyć, że w sytuacji, gdy wąż zjadł przynajmniej jeden owoc, to rysuje on za sobą ślad.

Dzieje się tak, ponieważ nigdzie nie zmniejszamy jeszcze wartosci atrybutu wartoscPola.

Do modyfikowania tego atrybutu we wszystkich polach posłuży nam metoda zaaktualizujOgonWeza(), z klasy Plansza, której jeszcze nie zaimplementowaliśmy. Dopisujemy ją i iterujemy w niej wszystkie Pola, a w sytuacji, gdy wartoscPola będzie większa od 0 – zdekrementujemy ją.

void zaaktualizujOgonWeza(){
	for(int i = 0; i < rozmiarYPlanszy; i++){
		for(int j = 0; j < rozmiarXPlanszy; j++){
			if(pole[i][j].wartoscPola > 0){
				pole[i][j].wartoscPola--;
			}
		}
	}
}

Wywołanie tej metody umieszczamy w ramach metody przesun(), po wykonaniu samego przesunięcia, ale przed zmianą atrybutu wartoscPola.

Dodatkowo, w celu uniknięcia ewentualnych błędów, aktualizacje wartości danego pola oraz wywołanie metody zaaktualizujOgonWeza() umieszczamy w wyrażeniu warunkowym sprawdzającym, czy wąż znajduje się na planszy.

Metoda przesun():

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;
	}
	if(sprawdzCzyNaPlanszy()) {
		Owoc owoc = plansza.pole[pozycjaWezaY][pozycjaWezaX].owoc;
		if (owoc != null)
			zjedzOwoc(plansza.pole[pozycjaWezaY][pozycjaWezaX]);
		plansza.zaaktualizujOgonWeza();
		plansza.pole[pozycjaWezaY][sprawdzPozycjeX()].wartoscPola = liczbaPunktow;
	}
}

Po uruchomieniu gry i zjedzeniu kilku owoców możemy zobaczyć, że ogon jest o jedną kratkę za krótki. W domyśle powinien on odpowiadać swoją długością liczbie zjedzonych owoców. Obecnie odpowiada liczbie zjedzonych owoców minus jeden, gdzie minimalna długość ogona to zero.

Sytuacja ta wynika z faktu, że o ile rzeczywiście ustawiamy wartość pola po użyciu metody zaaktualizujOgonWeza(), wartość jest jednak zbyt mała. Już w trakcie kolejnego przesunięcia się węża wartość jest błędnie modyfikowana. Jest ona bowiem zmniejszana, zanim w ogóle się pojawi.

Atrybut wartoscPola ustawimy następująco:

plansza.pole[pozycjaWezaY][sprawdzPozycjeX()].wartoscPola = liczbaPunktow + 1;

Wyświetlana w grze długość ogona jest już równa liczbie punktów zdobytych przez węża.

Cały dotychczas napisany kod źródłowy w języku Java możesz pobrać, korzystając z linku:

Ogon w języku Python

W języka Python mamy już zaimplementowane wyświetlanie się ogona w sytuacji, gdy atrybut wartoscPola klasy Pole jest większy od 0.

Metoda wyswietlGre():

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)

Zgodnie z ustaleniami dopisujemy do gry fragment odpowiedzialny za zamianę wartości atrybutu wartoscPola z klasy Pole na wartość atrybutu liczbaPunktow, z klasy Waz. W tym celu wystarczy dopisać do metody przesun() następujące dwie linijki:

pole = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()]
pole.wartoscPola = pole.wartoscPola = 1

Ostatecznie sama metoda przesun() wygląda następująco:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    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

        if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
        	zamekGrafiki.release()
        	break
        else:
            owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
            if owoc != None:
            	self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
            pole = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()]
            pole.wartoscPola = self.liczbaPunktow
            time.sleep(1)
            zamekGrafiki.release()

Możemy zauważyć, że po zjedzeniu owocu wąż – zamiast ogona, który się za nim porusza – generuje coś w rodzaju linii, którą ciągnie. Jest to spowodowane brakiem mechanizmu kasującego ogon. Zaimplementujemy go teraz w ramach metody zaaktualizujOgonWeza(), która znajduje się w klasie Plansza.

W tym celu iterujemy po wszystkich obiektach klasy Pole i dekrementujemy wartości atrybutów wartoscPola tam, gdzie wartość tego atrybutu jest większa od zera.

Alternatywnie moglibyśmy zmniejszać te wartości we wszystkich obiektach, ponieważ teoretycznie nie powinno to stanowić dla programu różnicy – nie jest to jednak prawda. Jeżeli co klatkę zmniejszalibyśmy wartości we wszystkich obiektach typu Pole, to zaistniałaby możliwość, że po długiej grze w danym atrybucie wartość zostałaby tak bardzo zmniejszona, że mogłoby dojść do przepełnienia (z ang. overflow) atrybutu i zmieniłby on swoją wartość na dodatnią.

Ostatecznie metoda zaaktualizujOgonWeza() mogłaby przyjąć następującą postać:

def zaaktualizujOgonWeza(self):
    for i in range(self.rozmiarYPlanszy):
        for j in range(self.rozmiarXPlanszy):
        	if(self.pole[i][j].wartoscPola > 0):
                 self.pole[i][j].wartoscPola = self.pole[i][j].wartoscPola - 1
    return

Dodajemy do kodu wywołanie metody zaaktualizujOgonWeza().  Robimy to w ramach metody przesun() z klasy Waz.

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    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

        if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
        	zamekGrafiki.release()
        	break
        else:
        	owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
            if owoc != None:
            self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
            pole = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()]
            plansza.zaaktualizujOgonWeza()
            pole.wartoscPola = self.liczbaPunktow
            time.sleep(1)
            zamekGrafiki.release()

Po zaktualizowaniu metody przesun() widzimy, że po uruchomieniu gry ogon węża jest o jedno pole za krótki. Jest to spowodowane tym, że co „klatkę animacji” wszystkie pola są aktualizowane, włącznie z tą dopiero co ustawioną.

Problem ten można naprawić na wiele sposobów. Możemy np. zapamiętywać poprzednią lokalizację węża i na tym polu nie aktualizować długości jego ogona, jednak taka operacja wymagałaby dużej liczby zmian w kodzie.

Skorzystamy z prostszego rozwiązania polegającego na ustawianiu wartości atrybutu wartoscPola na o jeden większą, niż atrybutu liczbaPunktow, dzięki czemu po przesunięciu się węża zobaczymy na planszy oczekiwaną długość ogona.

Metoda przesun() przyjmie ostatecznie następującą postać:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    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

        if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
        	zamekGrafiki.release()
        	break
        else:
        	owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
        	if owoc != None:
        		self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
        	pole = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()]
        	plansza.zaaktualizujOgonWeza()
        	pole.wartoscPola = self.liczbaPunktow + 1
        	time.sleep(1)
        	zamekGrafiki.release()

Dotychczas napisany kod w języku Python pobierzesz z tego linku:

Koniec rozgrywki

Ustaliliśmy wcześniej, że gra kończy się, gdy:

1. W grze zebrano wszystkie owoce, jakie były dostępne.

2. Wąż wyjedzie poza planszę.

3. Wąż dotknie własnego ogona.

Są to wszystkie warunki, które muszą zostać obligatoryjnie dodane, zgodnie z wymaganiami opisanymi we wcześniejszych materiałach.

Zakończenie rozgrywki w języku C++

Zakończenie rozgrywki, czyli zatrzymanie gry, obejmuje zatrzymanie dodatkowo powołanych wątków, wyświetlenie liczby punktów, jakie zdobył gracz, a także wyświetlenie menu, umożliwiającego wyjście z gry.

Zdefiniowane wcześniej warunki zakończenia rozgrywki możemy „wykrywać” w ramach metody przesun(), ponieważ w niej mamy dostęp do wszystkich potrzebnych informacji, a dodatkowo to właśnie przesunięcie głowy węża wywołuje wszystkie modyfikacje.

W przypadku implementacji w języku C++ mamy trzy nieskończone pętle. Jedną dostępną w ramach metody zinterpretujWcisnietyPrzycisk() z klasy ObslugaWejscia, kolejną w metodzie przesun() z klasy Waz, następną z kolei w metodzie wyswietlGre(), dostępnej w ramach klasy WyswietlanieGrafiki.

Należy teraz dodać do wszystkich wymienionych wyżej klas nowy atrybut o nazwie czyGraSieToczy lub dopisać go do definicji wymienionych powyżej metod.

Dodanie atrybutu do definicji metod spowoduje, że staną się one bardziej rozbudowane.

Dodanie atrybutu do klas będzie oznaczało, że nie wykonaliśmy programu zgodnie z założonym na początku diagramem.

Stajemy przed trudną decyzją, czy lepiej trzymać się diagramu, czy jednak zgłosić uwagę do projektantów.

W przypadku zgłoszenia uwagi, po uzyskaniu zgody projektantów na zmianę, dodajemy we wcześniej wspomnianych klasach następujący atrybut wraz z konstruktorem:

bool* czyGraDziala;

Natomiast wszystkie nieskończone pętle typu:

while(true)
{
	...
}

lub

while(1)
{
	...
}

zamieniamy na:

while(*czyGraDziala)
{

}

W funkcji main() – przed samym stworzeniem i uruchomieniem wątków – dopisujemy także:

wejscie.czyGraDziala = &czyGraPracuje;
grafika.czyGraDziala = &czyGraPracuje;
obiektWaz.czyGraDziala = &czyGraPracuje;

Następnie przechodzimy do umieszczenia w ramach metody przesun() warunków, które grę zatrzymają:

if (sprawdzPozycjeY() < 0 || sprawdzPozycjeY() >= plansza->rozmiarYPlanszy
	|| sprawdzPozycjeX() < 0 || sprawdzPozycjeX() >= plansza->rozmiarXPlanszy)
	{ //waz wyjezdza poza mape
		*czyGraDziala = false;
		break;
	}
if (owocNaPolu->sprawdzPunkty())
{
	zjedzOwoc(owocNaPolu, plansza);
	if (plansza->liczbaOwocow == 0) //wszystkie owoce zjedzone 
	{
		*czyGraDziala = false;
	}
}
if(plansza->pole[pozycjaWezaY][pozycjaWezaX].wartoscPola > 0) //waz dotyka swojego ogona
	*czyGraDziala = false;

W funkcji main() po wszystkich metodach join() dopisujemy następujący fragment kodu:

	system("CLS");
	std::cout << "          ____  " << std::endl;
	std::cout << "        o8%8888,    " << std::endl;
	std::cout << "      o88%8888888.  " << std::endl;
	std::cout << "     8'-    -:8888b   " << std::endl;
	std::cout << "     8'         8888  " << std::endl;
	std::cout << "   d8.-=. ,==-.:888b  " << std::endl;
	std::cout << "   >8 `~` :`~' d8888   " << std::endl;
	std::cout << "   88         ,88888   " << std::endl;
	std::cout << "   88b. `-~  ':88888  " << std::endl;
	std::cout << "   888b ~==~ .:88888 " << std::endl;
	std::cout << "   88888o--:':::8888      " << std::endl;
	std::cout << "   `88888| :::' 8888b  " << std::endl;
	std::cout << "   8888^^'       8888b  " << std::endl;
	std::cout << "  d888           ,%888b.   " << std::endl;
	std::cout << " d88%            %%%8--'-.  " << std::endl;
	std::cout << "/88:.__ ,       _%-' ---  -  " << std::endl;
	std::cout << "    '''::===..-'   =  --." << std::endl;
	std::cout<<"Gra zakonczona, wynik to: "<<obiektWaz.sprawdzWynik();

Oczywiście Mona Lisa pełni tutaj funkcję placeholdera, który możemy zastąpić dowolnym, lepiej pasującym obrazkiem lub napisem. Możemy też użyć np. logotypu jakiejś firmy.

Po uruchomieniu i przetestowaniu tego kodu zauważymy jednak pewien problem. W momencie, gdy spełniony zostanie którykolwiek z warunków zakończenia rozgrywki (wyjście poza plansze, dotknięcie ogona lub zjedzenie wszystkich owoców), wąż się zatrzymuje, ale nie wyświetla się wynik. Dzieje się to dopiero po jeszcze jednym naciśnięciu jakiegokolwiek klawisza. Dlaczego?

Przyczyną jest sposób, w jaki odczytujemy klawiaturę. Ma to miejsce w metodzie zinterpretujWcisnietyPrzycisk() klasy ObslugaWejscia:

void zinterpretujWcisnietyPrzycisk(Waz* waz)
	{
		while (true)
		{
			char przycisk = getch();
			switch (przycisk)
			{
			case 'a':
            
            ...

W piątej linii wywoływana jest funkcja getch(), która odczytuje stan klawisza. Czeka ona na naciśnięcie klawisza, dlatego (mimo że wątek ma być już przerwany) w tym miejscu pojawia się dodatkowe oczekiwanie. Dopiero po naciśnięciu klawisza następuje zakończenie wątku. Jak sobie z tym poradzić?

Najprościej będzie zmodyfikować kod, aby najpierw program sprawdzał, czy jakiś klawisz został faktycznie naciśnięty, a dopiero potem odczytywał za pomocą funkcji getch(), jaki to był klawisz. Można to zrobić w taki sposób:

while (*czyGraDziala)
		{
			char przycisk = 0;
			if (kbhit()) 
				przycisk = getch();
			switch (przycisk)
			{
			case 'a':

Funkcja kbhit() zwraca true, jeżeli naciśnięto jakiś klawisz, a false, jeżeli nie. Całość metody zinterpretujWcisnietyPrzycisk():

void zinterpretujWcisnietyPrzycisk(Waz* waz)
	{
		while (*czyGraDziala)
		{
			char przycisk = 0;
			if (kbhit()) 
				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;
			}
		}
		return;
	}

Po modyfikacji program poprawnie kończy swoje działanie.

Napisany dotąd kod C++ można pobrać, korzystając z tego linku:

Zakończenie rozgrywki w języku Java

Wcześniej zdefiniowaliśmy różne warunki zakończenia rozgrywki. Wszystkie jesteśmy w stanie sprawdzić z poziomu metody przesun().

W przypadku implementacji gry w języku Java musimy przekazać informację do obydwu pracujących wątków, a tylko w jednym z nich będziemy sprawdzać, czy gra się zakończyła.

Dodatkowym problemem jest, że w diagramie klas nie umieściliśmy atrybutu odpowiadającego za sprawdzanie, czy gra aktualnie działa, czy nie. Mamy dwie możliwości: możemy spróbować obejść ten problem albo zgłosić uwagę do projektantów, że należy na diagram nanieść poprawkę, żeby gdzieś taki atrybut się znalazł.

Wybieramy tę drugą opcję. Gdy projektanci zaakceptują poprawkę, zamieścimy atrybut czyGraDziala w ramach klasy Waz. Należy pamiętać o przetestowaniu kodu po wprowadzonych poprawkach.

Dzięki temu rozwiązaniu uzyskamy również dostęp do tego atrybutu w ramach klasy WyswietlGrafike, ponieważ klasa ta ma jako atrybut obiekt klasy Waz.

Dlatego jako atrybut klasy Waz dodamy:

boolean czyGraDziala;

Następnie edytujemy metodę run() w klasie WyswietlanieGrafiki oraz w klasie Waz – w taki sposób, żeby obecne tam nieskończone pętle while zmienić z postaci:

while(true){
	...
}

na:

while(czyGraDziala){ // w klasie Waz
	...
}

while(waz.czyGraDziala){ // w klasie WyswietlanieGrafii
	...
}

W metodzie main() w klasie Main dodajemy również:

waz.czyGraDziala = true;

Dopisujemy ten fragment przed uruchomieniem wątków, ponieważ domyślną wartością zmiennej boolean w Javie jest false.

Dopisujemy trzy wcześniej zdefiniowane warunki zakończenia rozgrywki:

if(plansza.pole[sprawdzPozycjeY()][sprawdzPozycjeX()].wartoscPola > 0){
	czyGraDziala = false;
}

if (sprawdzCzyNaPlanszy()) {
    czyGraDziala = false;
}

if(plansza.liczbaOwocow == 0){
	czyGraDziala = false;
}

Metoda przesun() przyjmuje następującą postać:

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;
    }
    if (sprawdzCzyNaPlanszy()) {
    	Owoc owoc = plansza.pole[pozycjaWezaY][pozycjaWezaX].owoc;
        if (owoc != null)
        	zjedzOwoc(plansza.pole[pozycjaWezaY][pozycjaWezaX]);
        plansza.zaaktualizujOgonWeza();
        if(plansza.pole[sprawdzPozycjeY()][sprawdzPozycjeX()].wartoscPola > 0){
        	czyGraDziala = false; //zakonczenie gry, dotkniecie ogona.
        }
        plansza.pole[pozycjaWezaY][sprawdzPozycjeX()].wartoscPola = liczbaPunktow + 1;
    }
    else {
    	czyGraDziala = false; //zakonczenie gry, poza planszą
    }
    if(plansza.liczbaOwocow == 0){
    	czyGraDziala = false; //zakończenie gry, wszystkie owoce
    }
}

Dodatkowo przeciążamy metodę wyswietlGre(), żeby móc wyświetlić graczowi komunikat po zakończeniu rozgrywki.

public void wyswietlGre(String wiadomosc){
	grafikaTekstowa.setText(wiadomosc);
}

W metodzie main() na końcu dopisujemy:

try {
	watekGrafiki.join();
	watekWeza.join();
} catch (InterruptedException e) {
	e.printStackTrace();
}
grafika.wyswietlGre("Twoj wynik punktowy to: " + waz.sprawdzWynik());

W ten sposób kończymy implementację zakończenia rozgrywki w języku Java.

Cały kod źródłowy w języku Java można pobrać, korzystając z poniższego linku:

Zakończenie rozgrywki w języku Python

Podobnie jak w przypadku innych języków możemy sprawdzić wszystkie zakończenia rozgrywki w ramach metody przesun(). Zrobimy to więc w tej metodzie, jednak pojawia się pytanie, jak przekażemy tę informację z wątku węża do innych wątków?

Najprościej będzie zgłosić projektantom uwagę, że nie jesteśmy w stanie zrealizować funkcji bez dodatkowego atrybutu, który musi zostać dodany.

Po uzyskaniu zgody projektantów, dodajemy wspomniany atrybut do klasy Waz. Atrybut ten domyślnie ustawimy na wartość True.

czyGraDziala = True

Diagram klas po zmianie wygląda następująco:

REm7mScYTFuzZ

Ilustracja

Następnie zamieniamy nieskończone pętle (związane z animacją oraz z poruszaniem się węża) z postaci:

while 1:
	...

na:

while self.czyGraDziala: #w wnętrzu klasy Waz
    ...
while waz.czyGraDziala: #w klasie WyswietlanieGrafiki
    ...

Dopisujemy wcześniej zdefiniowane warunki, a w nich:

waz.czyGraDziala = False

Tymi warunkami są:

if pole.wartoscPola > 0:
	waz.czyGraDziala = False # dotkniecie ogona

if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
	waz.czyGraDziala = False # wyjscie poza plansze

if plansza.ileOwocow == 0:
	waz.czyGraDziala = False #wszystkie owoce z planszy zjedzone

Po wprowadzeniu tych warunków metoda przesun() wygląda następująco:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    import time
    while self.czyGraDziala:
        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
        if plansza.ileOwocow == 0:
        	waz.czyGraDziala = False
        if self.sprawdzPozycjeY() < 0 or self.sprawdzPozycjeY() >= plansza.rozmiarYPlanszy or self.sprawdzPozycjeX() < 0 or self.sprawdzPozycjeX() >= plansza.rozmiarXPlanszy:
        	zamekGrafiki.release()
        	waz.czyGraDziala = False
        	break
        else:
        	owoc = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()].owoc
            if owoc != None:
            	self.zjedzOwoc(plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()])
            pole = plansza.pole[self.sprawdzPozycjeY()][self.sprawdzPozycjeX()]
            plansza.zaaktualizujOgonWeza()

            if pole.wartoscPola > 0:
            	waz.czyGraDziala = False  # dotkniecie ogona
            pole.wartoscPola = self.liczbaPunktow + 1
            time.sleep(1)
            zamekGrafiki.release()

Teraz modyfikujemy program tak, by po zakończeniu rozgrywki pokazywał wynik punktowy.

watekGrafiki.join()
watekWeza.join()
import os
os.system('CLS')
print("      .")
print("     .|.")
print("     |||")
print("     |||")
print("     |||")
print("     |||")
print("     j_I")
print("    .)_(.")
print("    |===|")
print("    /___\ ")
print("   //___\\ ")
print("  /=======\ ")
print(" / .-\"\"\"-. \ ")
print("|__|     |__|")
print("Twoj wynik punktowy to: " + str(waz.liczbaPunktow))
watekWejscia.join()

W przedstawionym fragmencie dopisaliśmy jeszcze wyświetlanie się wieży, przed wyświetleniem wyniku. Tak skonstruowany obrazek nazywa się ASCII ArtASCII ArtASCII Art.

W tym przypadku został on wybrany losowo, żeby pokazać koncepcję. Sugerujemy napisanie własnego lub wybranie innego, bardziej pasującego tematycznie.

Cały napisany dotąd kod w języku Python można pobrać, korzystając z linku:

Słownik