Wstęp

Zacznijmy od przypomnienia diagramu klas:

W tym e‑materiale skupimy się na implementacji wątkówwątekwątków oraz sterowania, dlatego istotne są dla nas dwie klasy: ObsługaWejścia oraz WyświetlanieGrafiki. Jednak, żebyśmy mogli je zaimplementować, należy napisać – co najmniej – pozostałe klasy.

Wielowątkowość i sterowanie w języku Java

Zaczynamy od zadeklarowania istnienia wszystkich klas.

Wszystkie przedstawione klasy znajdują się w różnych plikach.

public class Main {

    public static void main(String[] args) {

    }
}

public class ObslugaWejscia {

}

public class WyswietlanieGrafiki implements Runnable{
    Waz waz;
    Plansza plansza;
    @Override
    public void run() {

    }
}

W klasie WyswietlanieGrafiki zaimplementujemy interfejs Runnable, aby potem uruchomić wyświetlanie jako osobny wątek.

public class Waz {
    private int liczbaPunktow = 0;
    private int pozycjaWezaX = 0;
    private int pozycjaWezaY = 0;
    private int kierunekRuchu = 0;

}

public class Plansza {
    public int rozmiarXPlanszy;
    public int rozmiarYPlanszy;
    public Pole pole[][];

}

public class Owoc {
	private int liczbaPunktow = 0;
}

public class Pole {
    Owoc owoc;
    int wartoscPola = 0;
}

Zwróćmy uwagę, że właśnie zaimplementowaliśmy niektóre zależności i wszystkie zmienne, które znajdowały się na grafie. Nie zaimplementowaliśmy jednak zależności, w których – chwilowo – korzystamy z innych klas.

Spróbujemy zacząć od zaimplementowania klasy WyswietlanieGrafiki.

public class WyswietlanieGrafiki implements Runnable{
    Waz waz;
    Plansza plansza;
    @Override
    public void run() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        wyswietlGre();
    }
    WyswietlanieGrafiki(Waz waz, Plansza plansza){
        this.waz = waz;
        this.plansza = plansza;
    }
    public void wyswietlGre(){
        for(int i = 0; i<plansza.rozmiarYPlanszy; i++){
            for(int j = 0; j<plansza.rozmiarXPlanszy; j++){
                if(plansza.pole[i][j].wartoscPola == 0){
                    System.out.print("+  ");
                }else{
                    System.out.print("x  ");
                }
            }
            System.out.println("\n");
        }
    }
}

Metoda run() została nadpisana przez naszą wersję, w której co 100 milisekund czyścimy ekran, a następnie rysujemy za pomocą wyswietlGre() obecny stan gry. Na ten moment zaimplementowaliśmy wyświetlanie samej planszy – do węża wrócimy potem. Jako znak + wyświetlamy pola puste, a jako x pola, na których jest w tym momencie „coś” bliżej nieokreślonego.

Rozmiar mapy, zgodnie z wymaganiami funkcjonalnymi, ma być docelowo dostępny z konfigurowalnych plików gry, jednak nie możemy zaimplementować wszystkiego jednocześnie. Stworzymy więc zmienną, której wartość na razie ustawimy ręcznie z poziomu kodu. Postępujemy tak, ponieważ najpierw chcemy dokonać implementacji – żeby mapa zaczęła się generować w jakiejkolwiek formie.

Istotną wadą kodu jest to, że dany wątek uruchamia się tylko raz. Do samego wyświetlania wrócimy na późniejszym etapie. W międzyczasie kod ten ulegnie znacznej modyfikacji.

Sama inicjalizacja Planszy wyglądałaby w następujący sposób:

public class Plansza {
    public int rozmiarXPlanszy;
    public int rozmiarYPlanszy;
    public Pole pole[][];
    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();
            }
        }
    }
}

Czas na zaimplementowanie klasy Pole.

public class Pole {
    Owoc owoc;
    int wartoscPola = 0;
    Pole(boolean czyZOwocem){
        if(czyZOwocem){
            owoc = new Owoc();
        }
    }
}

Klasa Owoc nie jest złożona, udało się ją zaimplementować już wcześniej.

Pojawia się jednak pewna nieścisłość – wcześniej w konstruktorze klasy Plansza używaliśmy bezargumentowych konstruktorów klasy Pole. Edytujemy więc jedną z dwóch klas w taki sposób, żeby zachować kompatybilność z diagramem klas.

W klasie Plansza ma się ostatecznie znaleźć metoda losujPlansze(), dlatego też w niej będziemy do konkretnych pól dodawać obiekty klasy Owoc. Wrócimy do tego później, jednak najpierw poprawimy klasę Pole.

public class Pole {
    Owoc owoc;
    int wartoscPola = 0;
    Pole(){
    }
}

W celu przetestowania, czy w grze dobrze działa wyświetlanie, wpierw implementujemy klasę Wąż, której instancję będziemy powoływać w klasie Main().

public class Waz {
    private int liczbaPunktow = 0;
    private int pozycjaWezaX = 0;
    private int pozycjaWezaY = 0;
    private int kierunekRuchu = 0;
    Waz(int pozycjaWezaX, int pozycjaWezaY, int kierunekRuchu){
        this.pozycjaWezaX = pozycjaWezaX;
        this.pozycjaWezaY = pozycjaWezaY;
        this.kierunekRuchu = kierunekRuchu;
    }
}

Zrobienie tego w ten sposób, pozwala łatwo zmieniać miejsce na planszy, w którym wąż ma swoją pozycję startową oraz startowy kierunek ruchu.

Klasa Main() przyjmie postać:

public class Main {

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

Po uruchomieniu program wyświetli się następujący obraz:

+  +  +  +  +

+  +  +  +  +

+  +  +  +  +

+  +  +  +  +

+  +  +  +  +

Teraz dochodzimy do problematycznej części – sterowania. W językach C++ i Python możliwe jest przechwytywanie klawiszy z konsoli za pomocą funkcji lub metody getch(), która nie ma swojego odpowiednika w języku Java.

Istnieje natomiast opcja tworzenia interfejsów graficznych, które mogą przechwytywać pojedyncze kliknięcia. Zależy nam na interpretacji pojedynczych kliknięć, ponieważ gra byłaby dużo mniej użytkowa, gdybyśmy co chwilę potwierdzali klawiszem Enter decyzję.

Zaimplementujmy więc interfejs graficzny. W tym celu skorzystamy z biblioteki Swing, dostępnej w języku Java.

import javax.swing.*;

public class WyswietlanieGrafiki implements Runnable{
    Waz waz;
    Plansza plansza;
    private JFrame okienkoGraficzne;
    private JTextArea grafikaTekstowa;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        wyswietlGre();
    }
    WyswietlanieGrafiki(Waz waz, Plansza plansza){
        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);
        okienkoGraficzne.setVisible(true);
    }
    
    ....
}

Przypomnienie: JFrame to samo okno, a JTextArea to pole tekstowe, które musi być osadzone w oknie. Ustawiamy rozmiar obu obiektów i wyłączamy możliwość edycji okienka tekstowego. Następnie dodajemy okienko tekstowe do obiektu klasy JFrame, a potem wyświetlamy ten obiekt.

Do zmiennych obiektu WyswietlanieGrafiki() dodaliśmy również obiekty utworzone w konstruktorze. Zrobiliśmy to, ponieważ później będziemy potrzebowali tych informacji, do swobodnej modyfikacji zawartości okna.

Wyświetlanie w nowej postaci, która wypisuje stan planszy do zdefiniowanego przed chwilą okienka tekstowego, wyglądałoby w następujący sposób:

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

Metoda append() dopisuje tekst do okienka analogicznie do metody System.out.print().

Z racji tego, że chcemy, aby okienko odświeżało się co jakiś czas automatycznie, to potrzebujemy również sposobu na czyszczenie go. Zrobimy to w następujący sposób:

grafikaTekstowa.setText("");

Zapisany przed chwilą fragment kodu ustawi zawartość okienka na pusty tekst, efektywnie czyszcząc je.

Spróbujmy teraz zaimplementować sterowanie. W tym celu skorzystamy z interfejsu KeyListener, za pomocą którego zaimplementujemy wykrywanie kliknięcia poszczególnych klawiszy. Klasa ObslugaWejscia() będzie teraz wyglądać w następujący sposób:

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

public class ObslugaWejscia implements KeyListener {
    @Override
    public void keyTyped(KeyEvent e) {

    }
    @Override
    public void keyPressed(KeyEvent e) {
        char znak = e.getKeyChar();
        if(znak == 'a') System.out.println("Naciśnięto a");
        else if(znak == 'd') System.out.println("Naciśnięto d");
        else if(znak == ' ') System.out.println("Naciśnięto spacje");
    }

    @Override
    public void keyReleased(KeyEvent e) {

    }
}

Obiekt klasy KeyListener , aby mógł działać, musi zostać dołączony do JFrame'a lub innego kontenera. Postępujemy więc podobnie jak w przypadku dodawania JTextArea. W tym celu najprościej będzie dodać obiekt klasy KeyListener do konstruktora klasy WyswietlanieGrafiki – w ten sposób przyjmie on następującą postać:

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

W ten sposób, gdy wybierzemy okienko, a potem przyciski:
a, d, spacja , shift + a, shift + d, to otrzymamy następujący wydruk w konsoli:

Naciśnięto a
Naciśnięto d
Naciśnięto spacje

Możemy zatem wywnioskować, że metoda getKeyChar() jest case sensitivecase sensitivecase sensitive.

W tym momencie klasa main przyjmie następującą postać:

public class Main {

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

Następne mechaniki rozgrywki zaimplementujemy w kolejnych e‑materiałach.

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

Wielowątkowość i sterowanie w języku C++

Zacznijmy od napisania samych nagłówków klas, wraz ze zmiennymi o odpowiednich specyfikatorach dostępu.

class ObslugaWejscia
{
public:
	void zinterpretujWcisnietyPrzycisk()
	{

	}
};

class Waz
{
private:
	int liczbaPunktow = 0;
	int pozycjaWezaX = 0;
	int pozycjaWezaY = 0;
public:
	int kierunekRuchu = 0;
};

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

class WyswietlanieGrafiki
{
public:
	void wyswietlGre() 
	{

	}
	WyswietlanieGrafiki()
	{

	}
};

class Pole
{
public:
	Owoc owoc;
	int wartoscPola = 0;
};

Przepisaliśmy tu jedynie informacje ze stworzonego przez nas diagramu klas. Problem zaczyna się podczas tworzenia klasy Plansza. Według diagramu trzeba w niej utworzyć dwuwymiarową tablicę obiektów klasy Pole. Z racji tego, że wiemy z wyprzedzeniem, że plansza ma mieć modyfikowalną postać z poziomu plików konfiguracyjnych, nie możemy zadeklarować jej wielkości na stałe w kodzie.

int tab[];

int tab[][]; //błąd kompilacji

int tab[][100]; //działa

Zadeklarujemy zatem klasę Plansza w następujący sposób:

class Plansza
{
public:
	int rozmiarXPlanszy;
	int rozmiarYPlanszy;
	Pole** pole;			// wskaźnik do tablicy wskaźników

	void losujPlansze()
	{

	}
	void zresetujPlansze()
	{

	}
	void zaaktualizujOgonWeza()
	{

	}
	Plansza(int rozmiarX, int rozmiarY)
	{
		rozmiarXPlanszy = rozmiarX;
		rozmiarYPlanszy = rozmiarY;

		pole = new Pole* [rozmiarYPlanszy];

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

Pamiętamy, że każda „normalna” tablica jest wskaźnikiem pozwalającym nam bezpośrednio odwoływać się do elementów, które w sobie agreguje.

tab[5] = 10;

*(tab+5) = 10;

W omawianym przypadku utworzymy dynamiczną tablicę, tzn. taką, której rozmiar nie jest znany w czasie kompilacji. Wykorzystujemy do tego celu możliwości, jakie daje nam dynamiczne alokowanie pamięci za pomocą słowa kluczowego new. W klasie Plansza deklarujemy wskaźnik do tablicy wskaźników.

Konstruktor klasy Plansza alokuje dynamicznie pamięć na tablicę wskaźników o rozmiarze rozmiarYPlanszy. Dzieje się to w linii 25 przedstawionego kodu. Będą to wskaźniki do kolejnych tablic, które będą odpowiadać wierszom planszy. Następnie dla każdego wiersza odpowiadającemu mu wskaźnikowi przypisywana jest kolejna tablica, alokowana dynamicznie w linii 29. Te tablice będą już zawierały konkretne pola, a więc odpowiadające im obiekty klasy Pole (linia 32). Rozmiary tych tablic wynoszą rozmiarXPlanszy (a więc odpowiadają liczbie kolumn).

W ten sposób utworzyliśmy faktycznie dynamiczną tablicę dwuwymiarową, która zawiera w pierwszym wymiarze wskaźniki do tablic odpowiadających konkretnym polom planszy. Jak widać w linii 32, odwołanie się do tak zadeklarowanej i zaalokowanej tablicy jest bardzo proste – wystarczy zapis pole[wiersz][kolumna].

Dodatkowo powinniśmy również utworzyć destruktor, ponieważ używaliśmy słowa kluczowego new. W destruktorze będziemy usuwać obiekty utworzone przez wspomniane słowo kluczowe.

~Plansza()
{
    for (int i = 0; i < rozmiarYPlanszy; ++i)
        delete[] pole[i];
    delete[] pole;
}

Mamy już wygenerowaną planszę w pamięci, spróbujmy teraz ją wyświetlić w konsoli – zaimplementujmy klasę WyswietlanieGrafiki.

W samym konstruktorze nie ma potrzeby, abyśmy cokolwiek uzupełniali. W diagramie klas umieściliśmy pomiędzy klasą WyswietlanieGrafiki a Plansza agregację częściową. Zrobiliśmy to, ponieważ sam obiekt klasy WyświetlanieGrafiki może istnieć bez istnienia obiektów klasy Waz i klasy Plansza, dlatego też sam konstruktor zostawiamy pusty.

Za to uzupełniamy samą metodę wyswietlGre().

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

Jako argumenty tej metody podaliśmy wskaźnik do obiektu klasy wąż i wskaźnik do obiektu klasy plansza. Informacje o tych obiektach będziemy przekazywać bezpośrednio przez referencje, zamiast przez kopie obiektów. Postępujemy tak, gdyż w przypadku obiektu klasy plansza, nasza plansza nie zostałaby poprawnie skopiowana – doszłoby do kopiowania płytkiego.

Funkcja system() pozwala przekazywać polecenia, które podamy jako argument, bezpośrednio do konsoli. Polecenie cls służy do czyszczenia konsoli. Jeśli chcielibyśmy to sprawdzić, wystarczy uruchomić konsole systemu Windows, a następnie wpisać w niej cls, polecenie to nie jest case sensitive. Używamy tutaj poleceń z systemuWindows, ponieważ zgodnie z założeniami podanymi w pierwszym materiale mamy zrobić grę pod „System Windows 10 lub nowsze”.

Jak widać w linijkach 4 – 9, pętle przechodzą kolejno po wierszach i kolumnach planszy, odwołując się do obiektów reprezentujących pola w taki sposób jak pokazaliśmy, omawiając konstruktor klasy Plansza.

Teraz, jeśli wywołamy main w ten sposób:

int main()
{
	Plansza plansza = Plansza(5, 5);
	WyswietlanieGrafiki grafika = WyswietlanieGrafiki();
	Waz waz = Waz();
	grafika.wyswietlGre(&waz, &plansza);
}

Wyświetli się nam w konsoli następujący wydruk:

0       0       0       0       0
0       0       0       0       0
0       0       0       0       0
0       0       0       0       0
0       0       0       0       0

Jednak pojawia się problem: program wyświetla to tylko raz. Jeśli zrobilibyśmy nieskończoną pętlę w samej metodzie wyswietlGre(), uzyskalibyśmy wtedy odświeżanie.

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++)
            {
                std::cout << plansza->pole[i][j].wartoscPola << "\t";
            }
            std::cout << std::endl;
        }	
	}
}

Ewentualnie linijkę trzecią zmienimy potem, aby wyświetlanie wykrywało, kiedy gra się kończy. Problemem pozostaje jednak fakt, że sama gra musi otrzymywać jakieś sterowanie. W tym celu posłużymy się wątkami.

int main()
{
	Plansza plansza = Plansza(5, 5);
	WyswietlanieGrafiki grafika = WyswietlanieGrafiki();
	Waz waz = Waz();
	std::thread watekGrafiki(&WyswietlanieGrafiki::wyswietlGre, &grafika, &waz, &plansza);
	watekGrafiki.join();
}

Uruchomienie wątku będzie wyglądać tak, jak to przedstawiliśmy. W tym przypadku w pierwszym argumencie wskazujemy metodę, którą będziemy się posługiwać, a w drugim argumencie – wskaźnik this wybranego przez nas obiektu tej klasy, w ramach którego wskazaną wcześniej metodę będziemy wywoływać w wątku. W dalszych argumentach znajdują się dane, które przekazujemy jako argumenty samej metody, czyli w naszym przypadku wskazujemy na adresy obiektów.

void wyswietlGre(Waz* waz, Plansza* plansza)

std::thread watekGrafiki(&WyswietlanieGrafiki::wyswietlGre, &grafika, &waz, &plansza);

Dla optymalnego działania programu spowolnimy działanie tego wątku.

W tym celu skorzystamy z następującego fragmentu kodu:

std::this_thread::sleep_for(std::chrono::milliseconds(200));

Kod ten zatrzymuje działanie danego wątku na 200 milisekund, czyli na dwie dziesiąte sekundy. Możemy to sobie skonfigurować pod nasze potrzeby.

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++)
			{
				std::cout << plansza->pole[i][j].wartoscPola << "\t";
				std::this_thread::sleep_for(std::chrono::milliseconds(200));
			}
			std::cout << std::endl;
		}
	}
}

Metoda – z użyciem wcześniej wspominanego fragmentu – wyglądałaby następująco:

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++)
			{
				std::cout << plansza->pole[i][j].wartoscPola << "\t";
			}
			std::cout << std::endl;
		}
		std::this_thread::sleep_for(std::chrono::milliseconds(200));
	}
}

Powodując zatrzymanie wątku na dwie dziesiąte sekundy po każdorazowym narysowaniu planszy.

class ObslugaWejscia
{
public:
	void zinterpretujWcisnietyPrzycisk()
	{
		while (true)
		{
			char przycisk = getch();
			switch (przycisk)
			{
			case 'a':
				std::cout << "Nacisnieto a\n";
				break;
			case 'd':
				std::cout << "Nacisnieto d\n";
				break;
			case ' ':
				std::cout << "Nacisnieto spacje\n";
				break;
			}
		}
	}
};

W tym przypadku ponownie zdecydowaliśmy się zostawić, przynajmniej na razie, pusty konstruktor. Funkcja getch() czyta każdy kliknięty przez nas w konsoli znak od razu, bez potrzeby potwierdzania enterem.

Funkcja ta dostępna jest w ramach pliku nagłówkowego conio.h.

#define _CRT_NONSTDC_NO_DEPRECATE

Teraz sprawdźmy, czy obsługa wejścia działa – w tym celu zakomentujemy linie, które uruchamiają wątek obsługujący grafikę, oraz utworzymy obiekt klasy ObslugaWejscia, wraz z odpowiednim wątkiem.

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

Po skompilowaniu i użyciu klawiszy: a, d, spacja oraz n wyświetlą się następujące komunikaty.

Nacisnieto a
Nacisnieto d
Nacisnieto spacje

Przycisk n nie wyświetla żadnego komunikatu, ponieważ nie zdefiniowaliśmy dla tego przycisku żadnego zachowania. Kombinacja klawiszy shift + a, oraz shift + d również nie daje nam żadnego komunikatu.

Kolejne funkcje gry zaimplementujemy w następnych e‑materiałach. Stworzony do tego momentu kod można pobrać, korzystając z linku:

Wielowątkowość i sterowanie w języku Python

Zanim zaczniemy omawiać program, przypomnimy sobie, jak uruchomić program w konsoli systemu Windows.

python ścieżkaBezpośredniaDoPliku\plik.py

python C:\Users\Sebastian\PycharmProjects\rename\scratch.py

start python *scieżka*

start python C:\Users\Sebastian\PycharmProjects\rename\scratch.py

Następnie, tak jak w przypadku dwóch poprzednich języków, zaczniemy od stworzenia wszystkich klas, zgodnie z diagramem klas.

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

class Owoc:
    liczbaPunktow = 0
    def __init__(self):
        self.liczbaPunktow = 0
    def sprawdzPunkty(self):
        return
    def ustawPunkty(self):
        return
    
class Plansza:
    rozmiarXPlanszy = 0
    rozmiarYPlanszy = 0
    pole = None
    def __init__(self, rozmiarXPlanszy, rozmiarYPlanszy):
        self.rozmiarXPlanszy = rozmiarXPlanszy
        self.rozmiarYPlanszy = rozmiarYPlanszy
        #self.pole = #tu musimy dopisac tworzenie sie samej dwuwymiarowej planszy
        return
    def losujPlansze(self):
        return
    def zresetujPlansze(self):
        return
    def zaaktualizujOgonWeza(self):
        return

class Pole:
    owoc = None
    wartoscPola = 0
    def __init__(self):
        self.owoc = None
        self. wartoscPola = 0
        
class WyswietlanieGrafiki:
    def wyswietlGre(self):
        return
    
class ObslugaWejscia:
    def zinterpretujWcisnietyPrzycisk(self):
        return

W kolejnym kroku stworzymy obsługę wejścia – z racji tego, że tworzymy program na system Windows, to skorzystamy z biblioteki: msvcrt

class ObslugaWejscia:
    def zinterpretujWcisnietyPrzycisk(self):
        import msvcrt
        while 1:
            x = msvcrt.getch().decode('ASCII')
            print(x)

Przedstawiony fragment kodu w nieskończonej pętli wyświetla na wyjście to, co dostanie na wejściu. Metoda getch() zapewnia nam odczyt wejścia bajt po bajcie. Metoda decode() dekoduje wejście – a podany argument sprawia, że uznajemy znaki za takie, które występują w ASCII. Na razie zostawimy to w tej formie. Żeby przetestować, czy działa to u ciebie, spróbuj wywołać następujący kod:

x = ObslugaWejscia()
x.zinterpretujWcisnietyPrzycisk()

Spróbujmy teraz stworzyć i wyświetlić planszę.

class Plansza:
    rozmiarXPlanszy = 0;
    rozmiarYPlanszy = 0;
    pole = None;
    def __init__(self, rozmiarXPlanszy, rozmiarYPlanszy):
        self.rozmiarXPlanszy = rozmiarXPlanszy
        self.rozmiarYPlanszy = rozmiarYPlanszy
        self.pole = [[Pole() for x in range(rozmiarXPlanszy)] for y in range(rozmiarYPlanszy)]
        return
    def losujPlansze(self):
        return
    def zresetujPlansze(self):
        return
    def zaaktualizujOgonWeza(self):
        return

W tym fragmencie kodu, w konstruktorze klasy Plansza, umieściliśmy tworzenie dwuwymiarowej listy obiektów klasy Pole.

class WyswietlanieGrafiki():
    def wyswietlGre(self, plansza):
        for i in range(plansza.rozmiarYPlanszy):
            for j in range(plansza.rozmiarXPlanszy):
                print(plansza.pole[j][i].wartoscPola, end='\t')
            print("\n")

Następnie umieściliśmy wypisywanie wszystkich linii, umieszczonych w klasie plansza.

Przykładowe wywołanie:

plansza = Plansza(5, 5)
wyswietlanieGrafiki = WyswietlanieGrafiki()
wyswietlanieGrafiki.wyswietlGre(plansza)

Wynik ostatniego fragmentu kodu:

0	0	0	0	0	

0	0	0	0	0	

0	0	0	0	0	

0	0	0	0	0	

0	0	0	0	0

Na razie robimy to tylko raz, potem zmienimy w taki sposób, aby się odświeżało.

Nie możemy jednak jednocześnie odczytywać wejścia i rysować planszy, ponieważ obie czynności są w praktyce nieskończone. Skorzystamy w tym przypadków z omówionych we wcześniejszych e‑materiałach wątków.

Możemy zrobić to na dwa sposoby – albo wywoływać metody klas w ramach wątków, albo odziedziczyć wątki w ramach poszczególnych klas.

My skorzystamy z pierwszej opcji.

Poprawne uruchomienie wątku wejścia wyglądałoby w następujący sposób:

obslugaWejscia = ObslugaWejscia()
watekWejscia = threading.Thread(target=ObslugaWejscia.zinterpretujWcisnietyPrzycisk, args=(obslugaWejscia,))
watekWejscia.start()
watekWejscia.join()

Wskazujemy w nim target jako metodę danej klasy, a następnie – jako argument self– obiekt tej klasy.
Potem uruchamiany wątek i robimy join(), żeby program się nie zakończył przed końcem uruchomionego wcześniej wątku.

Analogicznie robimy z wątkiem grafiki:

plansza = Plansza(5, 5)
wyswietlanieGrafiki = WyswietlanieGrafiki()
wyswietlanieGrafiki.wyswietlGre(plansza)
watekGrafiki = threading.Thread(target=WyswietlanieGrafiki.wyswietlGre, args=(wyswietlanieGrafiki, plansza,))
watekGrafiki.start()
watekGrafiki.join()

Po stworzeniu obu wątków wywołania wyglądałyby następująco:

plansza = Plansza(5, 5)
wyswietlanieGrafiki = WyswietlanieGrafiki()
watekGrafiki = threading.Thread(target=WyswietlanieGrafiki.wyswietlGre, args=(wyswietlanieGrafiki, plansza,))
obslugaWejscia = ObslugaWejscia()
watekWejscia = threading.Thread(target=ObslugaWejscia.zinterpretujWcisnietyPrzycisk, args=(obslugaWejscia,))
watekWejscia.start()
watekGrafiki.start()
watekWejscia.join()
watekGrafiki.join()

Poprawiamy wyświetlanie grafiki, żeby ekran się odświeżał.

class WyswietlanieGrafiki():
    def wyswietlGre(self, plansza):
        import os
        import time
        while 1:
            os.system('CLS')
            for i in range(plansza.rozmiarYPlanszy):
                for j in range(plansza.rozmiarXPlanszy):
                    print(plansza.pole[j][i].wartoscPola, end='\t')
                print("\n")
            time.sleep(1)

Cały poprzedni kod umieściliśmy w nieskończonej pętli oraz zaimportowaliśmy jeszcze klasę time, dzięki której spowolniliśmy odświeżanie ekranu, żeby mniej obciążać komputer. Zrobiliśmy tak, ponieważ – w przypadku tej gry – niepotrzebne jest odświeżanie częściej niż co sekundę.

Polecenie os.system() powoduje wysłanie polecenia do konsoli. Polecenie cls powoduje wyczyszczenie okna konsoli.

Na koniec tego e‑materiału poprawmy jeszcze obsługę wejścia, żeby powoli zaczynała interpretować kliknięcia odpowiednich klawiszy. Chwilowo zakomentujemy również działanie wątku generującego grafikę.

class ObslugaWejscia():
    def zinterpretujWcisnietyPrzycisk(self):
        import msvcrt
        while 1:
            x = msvcrt.getch().decode('ASCII')
            if x == 'a':
                print("Naciśnięto a")
            elif x == 'd':
                print("Naciśnięto d")
            elif x == ' ':
                print("Naciśnięto spacje")

Przedstawiliśmy edycję klasy, teraz zapiszmy przykładowe wywołanie wątku:

plansza = Plansza(5, 5)
wyswietlanieGrafiki = WyswietlanieGrafiki
#watekGrafiki = threading.Thread(target=WyswietlanieGrafiki.wyswietlGre, args=(wyswietlanieGrafiki, plansza,))
obslugaWejscia = ObslugaWejscia
watekWejscia = threading.Thread(target=ObslugaWejscia.zinterpretujWcisnietyPrzycisk, args=(obslugaWejscia,))
#watekGrafiki.start()
watekWejscia.start()
watekWejscia.join()
#watekGrafiki.join()

Po użyciu kombinacji klawiszy a, d, spacja, a + shift, d + shift wyświetlą się w konsoli następujące komunikaty:

Naciśnięto a
Naciśnięto d
Naciśnięto spacje

Stąd wniosek, że program odróżnia wielkie litery od małych znaków.

Kolejne mechaniki rozgrywki zaimplementujemy w następnych e‑materiałach.

Korzystając z zamieszczonego linku, możesz pobrać końcową wersję kodu źródłowego Python dla tego e‑materiału.

Słownik