Zatrzymanie gry

Zaczniemy od zaimplementowania opcji wstrzymania gry, po wciśnięciu klawisza spacji. Jest to z pozoru trudne, jednakże tak naprawdę wymaga minimalnych zmian w kodzie. Zrobimy to w ten sposób, że jeżeli gra jest wstrzymana, to po prostu wąż się nie rusza. Modyfikacja kodu jest w tym przypadku stosunkowo prosta, przy założeniu, że do atrybutów klasy Waz dodamy atrybut pauza, który będzie przyjmował wartości prawda lub fałsz.

Zatrzymanie w języku C++

Dodajemy atrybut pauza jako atrybut klasy Waz.

class Waz
{
private:
	int liczbaPunktow = 0;
	int pozycjaWezaX = 0;
	int pozycjaWezaY = 0;
public:
	bool pauza = false;
    ....

Następnie w metodzie przesun(), z klasy Waz wprowadzamy taki warunek, żeby w przypadku ustawienia atrybutu pauza na true, wąż się nie przesuwał.

Można to zrobić w następujący sposób:

void przesun(bool* watekGrafikiPracuje, bool* watekWazPracuje, Plansza* plansza)
{
    while (*czyGraDziala)
    {
        if (pauza)
        {
        	std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        }
        else
        {
            while (*watekGrafikiPracuje)
            {
            	std::this_thread::sleep_for(std::chrono::milliseconds(1000));
            }
            *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)
            { //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;
            plansza->zaaktualizujOgonWeza();
            plansza->pole[pozycjaWezaY][pozycjaWezaX].wartoscPola = liczbaPunktow + 1;
            std::this_thread::sleep_for(std::chrono::milliseconds(400));
        }
    }
}

Teraz wystarczy zaimplementować opcję, która pozwoli, by kliknięcie klawisza spacja zmieniało wartość atrybutu pauza z prawdy na fałsz i z fałszu na prawdę.

class ObslugaWejscia
{
public:
	bool* czyGraDziala;
	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->zachod;
				else if (waz->kierunekRuchu == waz->wschod)
					waz->kierunekRuchu = waz->polnoc;
				else if (waz->kierunekRuchu == waz->poludnie)
					waz->kierunekRuchu = waz->wschod;
				else
					waz->kierunekRuchu = waz->poludnie;
				break;
			case 'd':
				if (waz->kierunekRuchu == waz->polnoc)
					waz->kierunekRuchu = waz->wschod;
				else if (waz->kierunekRuchu == waz->zachod)
					waz->kierunekRuchu = waz->polnoc;
				else if (waz->kierunekRuchu == waz->poludnie)
					waz->kierunekRuchu = waz->zachod;
				else
					waz->kierunekRuchu = waz->poludnie;
				break;
			case ' ':
					waz->pauza = !waz->pauza;
				break;
			}
		}
	}
};

Zatrzymanie w języku Java

Zaczniemy od dodania atrybutu pauza do klasy Waz.

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

Następnie w klasie ObslugaWejscia zapiszemy, że klawisz spacja będzie modyfikował atrybut pauza obiektu klasy Waz.

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

        case 'd':
            if (waz.kierunekRuchu == Waz.Kierunek.polnoc) {
            	waz.kierunekRuchu = Waz.Kierunek.wschod;
            } else if (waz.kierunekRuchu == Waz.Kierunek.zachod) {
            	waz.kierunekRuchu = Waz.Kierunek.polnoc;
            } else if (waz.kierunekRuchu == Waz.Kierunek.poludnie) {
            	waz.kierunekRuchu = Waz.Kierunek.zachod;
            } else {
            	waz.kierunekRuchu = Waz.Kierunek.poludnie;
            }
            break;
        case ' ':
            waz.pauza = !waz.pauza;
            break;
    }
}

Na koniec w metodzie run
(), będziemy przesuwać węża tylko wtedy, gdy atrybut pauza jest ustawiony na fałsz.

@Override
public void run() {
    while (czyGraDziala) {
        try {
        	Thread.sleep(1000);
        } catch (InterruptedException e) {
        	e.printStackTrace();
        }
        if(!this.pauza) przesun();
        if (!sprawdzCzyNaPlanszy()) {
        	break;
        }
    }
}

Zatrzymanie w Pythonie

Tak jak zostało wcześniej omówione, dodajemy atrybut pauza jako atrybut klasy Waz.

class Waz:
    import enum
    czyGraDziala = True
    class Kierunek(enum.Enum):
        polnoc = 0
        wschod = 1
        poludnie = 2
        zachod = 3
    pauza = False
    ....

Następnie modyfikujemy klasę ObslugaWejscia() w ten sposób, żeby zmieniać wartości tego atrybutu, po każdym wciśnięciu przycisku.

class ObslugaWejscia():
    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 == ' ':
                waz.pauza = not waz.pauza #nasza modyfikacja

Teraz na samym początku metody przesun(), dodajemy:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    import time
    while self.czyGraDziala:
        if self.pauza:
            time.sleep(1)
            continue
    ....

W tym fragmencie kodu korzystamy ze słowa kluczowego continue, które powoduje, że aktualny przebieg pętli zostaje przerwany, a wątek wraca do jej początku. Nie jest to najefektywniejsze rozwiązanie i wielu programistów zasugeruje, żeby zmianę wprowadzić tak, aby zamiast słowa continue, wykorzystać słowo kluczowe else w instrukcji warunkowej:

def przesun(self, zamekWeza, zamekGrafiki, plansza):
    import time
    while self.czyGraDziala:
        if self.pauza:
        	time.sleep(1)
        else:
            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()

To od ciebie zależy, jaką metodę zastosujesz w swoim projekcie. Zaproponowane rozwiązanie jest czytelniejsze, dzięki czemu działanie pętli łatwiej można przeanalizować, aby wykryć ewentualne błędy.

Ramka

Zaimplementujemy teraz ramki otaczające rozgrywkę. Do dyspozycji mamy tylko tryb tekstowy, nasze możliwości są więc ograniczone. Ramkę możemy wykonać na wiele sposobów, z użyciem różnych wzorów. Z racji tego, że celem ramki jest to, żeby wyglądała estetycznie i funkcjonalnie, nie chcemy narzucać żadnej wizji artystycznej, a jedynie zasugerujemy przykładowe rozwiązanie – wraz z wyjaśnieniem, jak je narysować.

*-*-*-*-*-*-*-*-*-*-*

Wzór ten można uzyskać w pseudokodzie w następujący sposób:

dla i = 1, 2... n wykonuj:
	jeżeli i mod 2 == 0:
    	wypisz("-")
    w przeciwnym razie jeżeli i mod 2 == 1:
    	wypisz("*")

Wszystkie podobne, cykliczne wzory, uzyskujemy analogicznie:

dla i = 1, 2... n wykonuj:
	jeżeli i mod LiczbaZnakow == 1:
    	wypisz(pierwszyZnaczek)
    w przeciwnym razie jeżeli i mod LiczbaZnakow == 2:
    	wypisz(drugiZnaczek)
 
 	....
 
    w przeciwnym razie jeżeli i mod LiczbaZnakow == LiczbaZnakow-1
    	wypisz(przedostatniZnaczek)
    w przeciwnym razie jeżeli i mod LiczbaZnakow == 0
    	wypisz(ostatniZnaczek)

W przytoczonym przykładzie zmienna LiczbaZnakow zawiera informację, z ilu znaków składa się jeden element wzoru. W przypadku ramek poziomych wystarczą dwie takie pętle, na początku i na końcu wyświetlania danej klatki. W przypadku pionowych ramek sprawa jest trochę bardziej złożona, ponieważ musimy wyświetlać je w dobrym miejscu.

To znaczy musimy wyświetlać je w każdej wyświetlanej linijce, przed i po wyświetleniu właściwych pól. W tym celu wystarczy wstawić przed odpowiednimi pętlami (a także po ich zastowaniu) warunki odpowiadające docelowej ramce.

**--

class WyswietlanieGrafiki
{
public:
	bool* czyGraDziala;
	void wyswietlGre(Waz* waz, Plansza* plansza, bool* watekGrafikiPracuje, bool* watekWazPracuje)
	{
		while (*czyGraDziala)
		{
			while (*watekWazPracuje)
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(1000));
			}
			*watekGrafikiPracuje = true;
			system("CLS");
			std::cout << " ";
			for (int i = 0; i < plansza->rozmiarXPlanszy; i++) 
			{
				int ramka = i % 4;
				if (ramka == 0 || ramka == 1) std::cout << "*";
				else std::cout << "-";
			}
			std::cout << std::endl;

			for (int i = 0; i < plansza->rozmiarYPlanszy; i++)
			{
				Pole* tempPoleTab = plansza->pole[i];
				int ramka = i % 4;
				if (ramka == 0 || ramka == 1) std::cout << "*";
				else std::cout << "-";
				for (int j = 0; j < plansza->rozmiarXPlanszy; j++)
				{
					Pole tempPole = tempPoleTab[j];
					if (waz->sprawdzPozycjeY() == i && waz->sprawdzPozycjeX() == j)
						std::cout << "@";
					else if (tempPole.owoc.sprawdzPunkty() != 0)
						std::cout << "$";
					else if (tempPole.wartoscPola > 0)
						std::cout << "x";
					else
						std::cout << " ";
				}

				if (ramka == 0 || ramka == 1) std::cout << "*";
				else std::cout << "-";
				std::cout << std::endl;
			}
			std::cout << std::endl << " ";
			for (int i = 0; i < plansza->rozmiarXPlanszy; i++)
			{
				int ramka = i % 4;
				if (ramka == 0 || ramka == 1) std::cout << "*";
				else std::cout << "-";
			}
			std::cout << std::endl;
			*watekGrafikiPracuje = false;
			std::this_thread::sleep_for(std::chrono::milliseconds(200));
		}
	}
};

public void wyswietlGre(){
        grafikaTekstowa.setText("");
        int ramka;

        grafikaTekstowa.append("   ");
        for (int i = 0; i < plansza.rozmiarXPlanszy; i++)
        {
            ramka = i % 4;
            if (ramka == 0 || ramka == 1) grafikaTekstowa.append("*");
            else grafikaTekstowa.append("-");
        }
        grafikaTekstowa.append("\n ");
        
        for(int i = 0; i<plansza.rozmiarYPlanszy; i++){
            ramka = i % 4;
            if (ramka == 0 || ramka == 1) grafikaTekstowa.append("*");
            else  grafikaTekstowa.append("-");

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

            if (ramka == 0 || ramka == 1) grafikaTekstowa.append("*");
            else  grafikaTekstowa.append("-");
            grafikaTekstowa.append("\n ");
        }
        grafikaTekstowa.append("  ");
        for (int i = 0; i < plansza.rozmiarXPlanszy; i++)
        {
            ramka = i % 4;
            if (ramka == 0 || ramka == 1) grafikaTekstowa.append("*");
            else grafikaTekstowa.append("-");
        }
    }

WyswietlanieGrafiki(Waz waz, Plansza plansza, KeyListener obslugaWejscia){
    this.waz = waz;
    this.plansza = plansza;
    this.okienkoGraficzne = new JFrame();
    this.grafikaTekstowa = new JTextArea();
    grafikaTekstowa.setSize(500, 500);
    grafikaTekstowa.setEditable(false);
    okienkoGraficzne.setSize(500, 500);
    okienkoGraficzne.add(grafikaTekstowa);
    grafikaTekstowa.addKeyListener(obslugaWejscia);
    okienkoGraficzne.setVisible(true);
    grafikaTekstowa.setFont(new Font("monospaced", Font.PLAIN, 12));
}

import java.awt.Font;

class WyswietlanieGrafiki():
    def wyswietlGre(self, plansza, waz, zamekWeza, zamekGrafiki):
        import os
        import time
        while waz.czyGraDziala:
            zamekGrafiki.acquire()
            os.system('CLS')
            print(" ", end='  ');
            for i in range(plansza.rozmiarXPlanszy):
                ramka = i%4
                if ramka == 0 or ramka == 1:
                    print("*", end='  ')
                else:
                    print("-", end='  ')
            print("\n")
            for i in range(plansza.rozmiarYPlanszy):
                ramka = i % 4
                if ramka == 0 or ramka == 1:
                    print("*", end='  ')
                else:
                    print("-", end='  ')
                for j in range(plansza.rozmiarXPlanszy):
                    if waz.pozycjaWezaX == j and waz.pozycjaWezaY == i:
                        print("@", end='  ')
                    elif plansza.pole[i][j].owoc != None:
                        print("$", end='  ')
                    elif plansza.pole[i][j].wartoscPola > 0:
                        print("o", end='  ')
                    else:
                        print(" ", end='  ')
                if ramka == 0 or ramka == 1:
                    print("*", end="  ")
                else:
                    print("-", end="  ")
                print("\n")
            print(" ", end='  ')
            for i in range(plansza.rozmiarXPlanszy):
                ramka = i % 4
                if ramka == 0 or ramka == 1:
                    print("*", end='  ')
                else:
                    print("-", end='  ')
            print("\n")

            zamekWeza.release()
            time.sleep(1)

W zaprezentowanych rozwiązaniach dodatkowo usunęliśmy wyświetlanie pola znakiem „+”, ponieważ po dodaniu ramki mamy informacje o granicach mapy, a bez wyświetlania poszczególnych komórek, gra jest dużo bardziej estetyczna.

W języku Python , dodatkowo, dla czytelności zmieniliśmy szerokość odstępów pomiędzy poszczególnymi polami, z „\t” na wielokrotną spację.

Całość kodu źródłowego można pobrać, korzystając z linków:

Możliwe modyfikacje

Warto byłoby rozważyć kilka zmian:

• Zmiana samego wyglądu oraz interfejsu na bardziej współczesny.

• Dodanie dodatkowych wzmocnień zbieralnych przez węża, np. przyspieszenie, spowolnienie lub danie mu możliwości warunkowego przejścia przez swój ogon.

• Generowanie stałej liczby owoców podczas uruchamiania gry i ponowne pojawienie się owocu po zjedzeniu.

• Dodanie dodatkowych trybów rozgrywki, np. trybu turniejowego dla gier imprezowych.

• Zaimplementowanie funkcji przechodzenia węża przez ściany.

• Dodanie historii gier wraz z wynikami.

Omówimy kilka z proponowanych tutaj zmian.

Zmiana interfejsu w języku Java

Możemy skorzystać z kilku bibliotek, m.in. z biblioteki SWING oraz JavaFX.

Obie oferują podobny zakres możliwości. Oto ich krótka charakteryzacja:

Swing wchodzi w skład JFC, czyli Java Foundation Classes, biblioteki komponentów graficznego interfejsu użytkownika oraz usług, które z założenia miały ułatwić proces tworzenia aplikacji desktopowych i internetowych. JFC w całości jest rozwiązaniem wieloplatformowym.

Alternatywą jest JavaFX, technologia, której zamysłem było zastąpienie Swing. Jest to potężna biblioteka, umożliwiająca budowanie zaawansowanych gier. Dla JavaFX dostępne są narzędzia, z których pomocą można w prosty sposób zaprojektować interfejs graficzny. Najważniejszym narzędziem tego typu jest SceneBuilder.

Oto przykład prototypu gry utworzonej z użyciem JavaFX:

RePe6HlzH9H3h

Zrzut ekranu przedstawia przykład prototypu gry typu obrona wieży, utworzonej z użyciem JavaFX. Znajdują się w niej ścieżki z przeciwnikami dążącymi do czerwonego zamku.
Po prawej stronie widoczna jest zakładka z wieżami, opcjami, ilością złota oraz punkty życia zamku.

Zmiana interfejsu w języku C++

Z racji tego, że projektujemy program przeznaczony na system Windows, możemy skorzystać z Windows Forms, czyli ze szkieletu aplikacji, umożliwiającego proste tworzenie aplikacji. Nie służy on stricte do tworzenia gier, ale do tworzenia aplikacji okienkowych. Istnieje możliwość takiego modyfikowania okienka i jego elementów, by utworzyć pożądany efekt. Nie jest to jednak rozwiązanie optymalne.

W C++ możemy jeszcze spróbować skorzystać z OpenGL, który służy do generowania dowolnego rodzaju grafiki. Do tej technologii polecamy skorzystanie dodatkowo z biblioteki GLUT, dodającej wiele przydatnych elementów. OpenGL jest jednak stosunkowo skomplikowany i ma duży próg wejścia. Ostatecznie, korzystając ze wspomnianej technologii oraz biblioteki, możemy w niej tworzyć grafikę z użyciem kształtów lub pojedynczych prymitywów graficznych. Technologia ta umożliwia tworzenie bardzo zaawansowanych animacji. Dodatkowym problemem tej technologii jest to, że przydatna jest w niej dobra znajomość geometrii. Zaletą OpenGL jest to, że w prosty sposób pozwala utworzyć dla gry warstwę prezentacji z wykorzystaniem grafiki.

Możemy również skorzystać z gotowych silników gry, kompatybilnych z językiem C++. Przykładem takich silników jest choćby Unreal Engine czy Godot. W silnikach często zaimplementowana jest wielowątkowość, którą sami – na potrzeby gry – musimy wprowadzać. Służą one do produkcji całej gry, a nie tylko do tworzenia warstwy wizualnej.

Zmiana interfejsu w języku Python

W przypadku Pythona możemy skorzystać z OpenGL. Jest to technologia pozwalająca generować grafikę. W swojej pierwotnej postaci pozwala na generowanie tzw. prymitywów, przez co ma dość wysoki próg wejścia. Do sprawnego posługiwania się nimi wymagana jest zaawansowana znajomość geometrii.

Na pomoc przychodzą jednak biblioteki typu GLUT, zaimplementowane w pakiecie PyOpenGL, a także wspomniana biblioteka PySFML.

GLUT oferuje nam gotowe figury geometryczne, natomiast SFML bardziej złożone konstrukcje. Dodatkową zaletą SFML jest to, że również zaimplementowano ją w języku C++ i Java.

Na omówienie zasługuje również biblioteka PyGame, stworzona z myślą o pisaniu gier w języku Python. Biblioteka ta posiada, podobnie jak inne wymienione, wbudowaną obsługę przechwytywania wciskanych klawiszy, jak również metody pozwalające wczytywać gotowe grafiki.

Generowanie stałej liczby owoców i pojawianie się owoców

Można to zaimplementować na kilka sposobów. Mianowicie:

• Stworzyć predefiniowane mapy, które będziemy wczytywali, dzięki czemu uzyskamy stałą liczbę owoców. Jest to jednak rozwiązanie dość ograniczone, a jednocześnie pracochłonne. Każdą mapę należy oddzielnie zaprojektować, a ponadto aby rozgrywka była ciekawa, map takich powinno być stosunkowo dużo. W przeciwnym wypadku gra szybko stanie się nudna i przewidywalna. Dodatkowo predefiniowane mapy nie rozwiązują nam problemu pojawiania się nowych owoców.

• Zmienić metodę losujPlansze() w ten sposób, by próbowała wygenerować owoce do tego momentu, aż nie uzyska ich określonej liczby. Należy pamiętać, że na danym polu może być maksymalnie jeden owoc. Po zjedzeniu owocu trzeba uruchamiać tę metodę jeszcze raz, aby dodać na planszy brakujący owoc. W takim przypadku konieczna byłaby jednak modyfikacja metody: liczba powtórzeń pętli musiałaby być potencjalnie duża, a prawdopodobieństwo wygenerowania owocu na danym polu małe, by uniknąć sytuacji, że owoce będą pojawiały się tylko na początku planszy.

• Wygenerować z góry określoną liczbę owoców w ramach jakiejś dodatkowej struktury danych, takiej jak lista, a następnie losować pola, do których dany owoc przypiszemy, przy założeniu, że w jednym polu może być maksymalnie jeden owoc. W przypadku zjedzenia owocu przez węża, owoc byłby ponownie przypisywany do losowego miejsca na planszy lub byłby on usuwany z listy owoców, a następnie – na jego miejsce na liście – generowany byłby nowy owoc, który znów zostałby przypisany.

Być może sam wymyślisz jeszcze inne sposoby rozwiązania problemu. My proponujemy następujący pomysł:

• Po zjedzeniu owocu na polu, na którym owoc był, ustawiamy flagę. Następnie próbujemy wygenerować w dowolny sposób (np. korzystając z podanych sposobów) owoc na planszy, jednak nie może on się pojawić na polu, na którym wcześniej została ustawiona wspomniana flaga. Gdy na wszystkich polach (czyli na całej planszy) znajdzie się wspomniana flaga, to wtedy usuwamy ją ze wszystkich pól. W ten sposób uzyskamy taki efekt, że owoce będą się pojawiały – z perspektywy gracza – ciągle w nowych miejscach. W efekcie pola będą się bardzo rzadko powtarzały.

Flagą może być nowy atrybut, który dodamy w ramach klasy Pole.

Zwróć także uwagę na to, że potencjalnych sposobów na efektywne generowanie pola może być naprawdę wiele.

Możemy np. spróbować skorzystać z algorytmu Sita Erastotenesa i generować je tylko na polach, których umowny numer jest liczbą pierwszą albo generować owoc na numerze pola, podzielnym przez liczbę n, gdzie n to liczba punktów węża % 10.

Omówione propozycje algorytmu szukania miejsca na kolejny owoc to tylko przykłady, przedstawiliśmy je, by pokazać, że temat można rozwijać naprawdę kreatywnie.

Przechodzenie węża przez ściany

W tym przypadku istnieje szansa, że musielibyśmy zmodyfikować jeden z warunków zakończenia rozgrywki, zdefiniowany w innym materiale z serii. Algorytm przenoszenia głowy wyglądałby mniej więcej tak dla osi poziomej:

jeżeli waz.sprawdzPozycjeX() > plansza.rozmiarXPlanszy-1:
	waz.ustawPozycje(0, waz.sprawdzPozycjeY())
w przeciwnym wypadku, jeżeli waz.sprawdzPozycjeX() < 0:
	waz.ustawPozycje(plansza.rozmiarXPlanszy-1, waz.sprawdzPozycjeY())

Analogicznie dla pionowej:

jeżeli waz.sprawdzPozycjeY() > plansza.rozmiarYPlanszy-1:
	waz.ustawPozycje(waz.sprawdzPozycjeX(), 0)
w przeciwnym wypadku, jeżeli waz.sprawdzPozycjeY() < 0:
	waz.ustawPozycje(plansza.sprawdzPozycjeX(), plansza.rozmiarYPlanszy-1)

Należałoby zaimplementować te fragmenty w odpowiednim miejscu, np. przed miejscem, gdzie teraz jest sprawdzane czy wąż znajduje się na planszy, w ramach metody przesun().

Historia gry

Sposobów na zapisanie historii gry jest kilka. Możemy po prostu zapisywać te informacje w specjalnym pliku tekstowym, a następnie – po każdym uruchomieniu programu – wczytywać te informacje i przed rozpoczęciem właściwej rozgrywki wyświetlać wynik.

Można też zapisywać te informacje w specjalnie przygotowanym pliku XML lub wczytywać niewielką bazę danych, na wybranym silniku bazodanowym, obsługującym wybrany język zapytań.

Jeżeli mowa o bazie danych, to można stworzyć ją specjalnie dla naszego projektu. Jest to jednak temat na osobny materiał.

Przyspieszenie gry i nowe tryby

Samo zwiększenie lub zmniejszenie tempa gry jest rzeczą prostą. W  wątku, który wykorzystuje zamek, wystarczy zwiększyć czas trwania danego wywołania metody sleep(), odpowiednio według potrzeb, tzn. zmniejszyć (w przypadku gdy chcemy grę przyspieszyć) lub zwiększyć (jeżeli chcemy grę spowolnić).

Z dodatkowymi trybami gry sprawa nie jest taka prosta, ponieważ w zależności od pomysłu, tryby te mogłyby wymagać dużych zmian.

Przykładowo: tryb w którym poruszamy się dwoma wężami byłby potencjalnie problematyczny ze względu na sposób wyświetlania węży na mapie. Jednak po drobnych modyfikacjach i to byłoby możliwe.

Stworzenie nowych trybów gry zależy od kreatywności autora programu.

Podsumowanie

Na tym kończymy projekt. Czego się nauczyliśmy?

• Posługiwać diagramami UML, służącymi do dokumentowania i specyfikowania systemów informatycznych.

• Korzystać z wielu wątków i je synchronizować.

• Obsługiwać oprogramowanie do kontroli wersji.

• Zasad SOLID, wspomagających pisanie czytelnego kodu.

Słownik