Warsztat - Programowanie gier komputerowych :: Prosta gra logiczna - applet Javy







Strona główna Forum Szukaj Lista użytkowników
Grupy
Zarejestruj Zaloguj

Artykuły
Kliknij na kategorię żeby dodać artykuł Szukaj
Programowanie gier » Artykuły » Ogólnie o programowaniu
gier [Wersja do drukowania]
Prosta gra logiczna - applet Javy
Opis Jak napisać prostą grę logiczną w Javie.
Autor giaur Data Czw 07 Paź, 2004 9:53 pm Typ ***
Słowa klucze
Kategoria Ogólnie o programowaniu gier
Odsłony 303


Prosta gra logiczna - applet Javy
Jak napisać prostą grę logiczną w Javie.

W tym artykule pokaże krok po kroku jak napisać prostą
gierkę logiczną w postaci appletu Javy. Cisną się tu na
usta dwa pytania:

1. dlaczego applet Javy ?

Ano dlatego, że to miło umieścić coś na swojej stronie
WWW ku uciesze odwiedzających ją internautów.

2. dlaczego gra logiczna ?

Ano dlatego, że ze względu na specyfikę Javy (czyt. "ze
względu na ślamazarność i powolność Javy", hi, hi)
raczej ciężko napisać w niej Quake'a. Ponieważ gra
logiczna nie wymaga specjalnej szybkości działania, więc
nadaje się w sam raz. Do tego jej napisanie jest dosyć
proste, więc dla początkujących będzie w sam raz.

W tej chwili planuję podzielić ten artykuł na parę
części. W pierwszej z nich (właśnie ją czytasz)
stworzymy gierkę, ale będzie ona bez żadnych bajerów. W
kolejnej (kolejnych ?) dodamy grafikę, animację, dźwięki
i inne wodotryski jakie mi przyjdą do głowy (o ile
przyjdą).

Artykuł jest przeznaczony dla początkujących,
zaawansowani mogą się nudzić podczas lektury.

Zakładam że posiadasz pewną pewną (bardzo podstawową)
znajomość Javy. Użyte w tym programie instrukcje są na
tyle proste i elementarne, że każdy kto ma jakiekolwiek
pojęcie o Javie zrozumie jak to wszystko działa.
Przydało by się za to, gdybyś miał pojęcie o
programowaniu obiektowym.
Do uruchomienia przedstawionych tu programów
potrzebujesz JDK w wersji co najmniej 1.1.

Jeżeli nie wiesz kompletnie nic o Javie, to polecam parę
adresów.

- odwiedź "stronę domową" Javy http://java.sun.com
(możesz stamtąd ściagnąć JDK czyli Java Development
Kit),
- ściągnij sobie książkę Thinking in Java autorstwa
Bruce Eckela (www.bruceeckel.com - jest tam link do
polskiego mirrora),
- poszukaj w sieci tutoriali (jest ich sporo).

Jeżeli o podejście obiektowe do programowania chodzi to
polecam pierwsze rozdziały wspomnianej książki Bruce
Eckela.

To mój pierwszy artykuł poświęcony pisaniu gier, więc
wybacz proszę ewentualne niedociągnięcia. Jeżeli
zauważysz jakiś błąd, albo wiesz że coś można zrobić
szybciej/prościej/lepiej/łatwiej niż ja to zrobiłem, to
nie omieszkaj mnie poinformować. Jeżeli czegoś nie
zrozumiałeś, nie wahaj się pytać.

Wszelkie uwagi i pytania proszę kierować na adres
[e-mail]




Dość ględzenia, ZACZYNAMY !

Gra która napiszemy nazywa się Piętnastka. Zasady są
proste. Na planszy 4x4 jest 15 elementów. Należy je tak
przesuwać korzystając z pustego pola, aby uzyskać
docelową kolejność czyli najczęściej ułożyć obrazek. W
wersji pierwotnej chodziło o ułożenie klocków,
ponumerowanych od 1 do 15, i na początek właśnie taką
wersję napiszemy. Zerknij na obrazek obok jeżeli wciąż
nie wiesz o co chodzi.

Okiej. No to teraz zastanówmy się CO dokładnie chcemy
zrobić. Gdy już będziemy dokładanie wiedzieli CO chcemy,
wówczas okaże się, że sama implementacja (czyli
odpowiedź na pytanie JAK) nie jest już niczym groźnym.


Najprostsza wersja gry która stworzymy będzie działać
według następującego schematu:

1. Wylosuj ułożenie elementów układanki
2. Wyświetl na ekranie plansze gry
3. Porównaj plansze z wzorcem - jeżeli takie same to
nowa gra
4. Sprawdź czy użytkownik nie przekroczył dozwolonego
limitu ruchów - jeżeli tak to nowa gra
5. Wykonaj ruch nakazany przez użytkownika i wróć do
punktu 2.

Rozważmy co kryje się pod każdym z tych punktów.

1. Wylosuj ułożenie elementów układanki
Wygląda banalnie. Ale wcale takie nie jest. Dlaczego ?
Otóż w Piętnastce istnieją układy, z których w żaden
sposób NIE DA SIĘ otrzymać rozwiązania. Tę właściwość
układanki wykorzystał jej twórca - Samuel Lloyd -
obiecując nagrodę 1000 dolarów za rozwiązanie jednego z
nierozwiązywalnych zadań. Jaki stąd morał ? Ano taki, że
nie można po prostu rozlosować początkowego układu
elementów układanki ! Ja widzę dwa rozwiązania:

a) Stworzyć (ręcznie) kilkanaście (kilkadziesiąt)
dobrych układów (czyli takich, z których można uzyskać
rozwiązanie) a następnie losować jeden z nich.
b) Rozpocząć tworzenie losowego układu od końca, czyli
od rozwiązania. Układ początkowy powstanie poprzez
wykonanie iluśtam (kilkuset, kilku tysięcy) losowych,
prawidłowych ruchów. Jeżeli zabrzmiało to
niezrozumiale to napiszę to prościej. Algorytm wygląda
tak:

i. bierzesz ułożoną układankę,
ii. dajesz ją trzyletniemu dziecku do zabawy,
iii. czekasz 10 minut - w tym czasie dzieciak
przestawia elementy na chybił trafił,
iv. mimo protestów berbecia odbierasz mu zabawkę -
klocki ułożone są losowo


Pierwszy sposób jest banalny, ale mało interesujący.
Drugi jest o wiele ciekawszy i daje lepsze rezultaty (za
każdym razem inny układ), dlatego też właśnie go
zastosujemy.

2. Wyświetl na ekranie plansze gry
3. Porównaj plansze z wzorcem - jeżeli takie same to
nowa gra
W tych dwóch punktach nie ma się nad czym rozwodzić -
każdy z nich to tylko kilka banalnych linijek kodu.

4. Sprawdź czy użytkownik nie przekroczył dozwolonego
limitu ruchów - jeżeli tak to nowa gra
Musimy posiadać licznik, który będzie zwiększany z
każdym kolejnym ruchem.

5. Wykonaj ruch nakazany przez użytkownika i wróć do
punktu 2.
Użytkownik klika na element, który chce przesunąć.
Musimy więc przechwytywać kliknięcia myszy, sprawdzać
który z elementów został wybrany przez użytkownika i czy
może nastąpić jego ruch (czy obok jest wolne pole).
Jeżeli tak, to dokonujemy zmian w informacji o układzie
elementów na planszy.




Zastanówmy się jeszcze jakie elementy są potrzebne.
Najmniejszym z nich jest pojedynczy element układanki
(class Element). 16 takich elementów składa się na całą
układankę (class Plansza). Oprócz tego przyda się nam
jeszcze licznik ruchów (class Licznik). Ostatnią rzeczą,
która jest nam potrzebna jest główna klasa appletu
(class Pietnastka) która złoży to wszystko do kupy.

Przeanalizujmy po kolei potrzebne nam klasy.




KLASA Element

Obiekt klasy Element to po prostu pojedynczy element
układanki. Zastanówmy się czego od niego wymagamy.

1. Z pewnością musimy umieć go zidentyfikować - przy
tworzeniu każdego z obiektów klasy Element nadamy mu
pewien numer (identyfikator).
2. Będziemy chcieli stwierdzić, z którym z elementów
układanki mamy do czynienia - potrzebujemy więc
procedury, która zwracała by nam identyfikator
obiektu.
3. Ponieważ jedną z ważniejszych rzeczy w całej grze
będzie wyświetlanie planszy (a na niej elementów),
więc przyda się nam funkcja wyświetlająca dany element
(a dokładnie jego identyfikator).

I to wszystko czego oczekujemy od obiektów klasy
Element.

Przyjrzyj się klasie Element żeby zobaczyć jak to
wygląda w praktyce. Znajdziesz ją tutaj.




Tak dla przypomnienia dwa słowa o konstruktorze.
Konstruktor uruchamiany jest w momencie tworzenia
obiektu danej klasy. Czyli jeżeli gdzieś gdzieś w kodzie
programu pojawi się instrukcja w stylu:


Element a = new Element(parametr);


to uruchomiony zostanie konstruktor klasy Element, który
stworzy obiekt a i jego identyfikatorowi id przypisze
wartość równą parametr.

W funkcji wyswietl() mogłeś zwrócić uwagę na ten zapis:


g.drawString("" + id, x, y);


i być może zastanawiasz się, czemu nie można napisać po
prostu tak:


g.drawString(id, x, y);


Otóż nie można, bo metoda drawString potrzebuje jako
pierwszego argumentu zmiennej typu String i wyskoczy nam
błąd "Incompatible type for method. Can't convert int to
Java.lang.String". Zapis


g.drawString("" + id, x, y);


sprawia, że id jest dodawane do Stringa, czego wynikiem
jest String. Wówczas metoda drawString umie już z nim
sobie poradzić.
Innym sposobem jest ręczne dokonanie konwersji:


g.drawString(id.toString, x, y);





KLASA Plansza

To największa i najbardziej rozbudowana klasa. Będziemy
od niej sporo wymagać. Obiekt klasy Plansza to po prostu
zestaw 16 elementów tworzących razem całą układankę.
Obiekt klasy Plansza musi:

1. Przechowywać informacje o ułożeniu elementów.
2. Rozlosować ułożenie elementów przed rozpoczęciem
gry.
3. Pozwalać na wykonywanie posunięć.
4. Wyświetlać się na ekranie.
5. Sprawdzać czy układanka została ułożona (czy
elementy leżą w prawidłowej kolejności)

Kod klasy Plansza znajdziesz tutaj.




1. Przechowywać informacje o ułożeniu elementów.

Tu rozwiązanie narzuca się samo - rozpatrujmy Planszą
jako dwuwymiarową tablicę, w której przechowujemy
informację o położeniu elementów układanki. Zadeklarujmy
więc tablicę 4x4, a każde z pól niech będzie obiektem
klasy Element.


private Element ukladanka[][] = new Element[4][4];





Nim przejdziemy do omówienia pozostałych 4 "zadań"
obiektów klasy Plansza, zdefiniujmy parę przydatnych
procedur i zmiennych.

Zdefiniujmy procedury zwracające id Elementu
znajdującego się w określony miejscu tablicy - są to
procedury get_id(). Zauważmy, że do zidentyfikowania
elementu układanki potrzeba dwóch liczb - numeru wiersza
i numeru kolumny. Czasem wygodniej jest operować jedną
liczbą od 0 do 15. Dwie poniższe metody pozwalają
"przeliczyć" liczbę z zakresu 0-15 na numer wiersza
(0-3) i kolumny(0-3). Oto i one:


private int kolumna(int zmienna) {
return(zmienna % 4); // reszta z dzielenia
}

private int wiersz(int zmienna) {
return((int) zmienna/4); // czesc calkowita z
dzielenia
}


Zadeklarujmy też kilka zmiennych opisujących wygląd
planszy - przydadzą się przy wyświetlaniu jej na ekran.


public int wspx, wspy, szer, wys;


wspx i wspy to odpowiednio współrzędna x i y lewego
górnego rogu planszy
szer i wys to odpowiednio szerokość i wysokość jednego
elementu układanki A teraz procedura, która odnajduje
pusty (zerowy) element i zwraca jego miejsce na planszy
(numer od 0 do 15). Przyda się to np. gdy będziemy
testować czy obok elementu klikniętego przez użytkownika
jest puste pole (innymi słowy: czy można wykonać ruch).


private int znajdz_puste() {
int a;
for (a = 0; a < 16; a++) {
if (get_id(a) == 0)
break;
}
return a;
}


Przypominam, że instrukcja break powoduje "wyskoczenie"
z pętli.




Uzbrojeni w te kilka procedur i zmiennych możemy
rozprawić się z czterema pozostałymi zadaniami.

2. Rozlosować ułożenie elementów przed rozpoczęciem gry.


Procedura nowa_gra() tworzy 16 kolejnych obiektów klasy
Element, każdemu z nich przypisując kolejny numer id.
Następnie uruchamia procedurę rozrzuc_klocki() której
zadaniem jest wygenerowanie "losowego" położenia
elementów.

Procedura rozrzuc_klocki() funkcjonuje według
następującego schematu:

A. Znajdź współrzędne pustego (zerowego) elementu.
B. Wylosuj kierunek ruchu
C. Sprawdź czy ruch w tym kierunku jest możliwy -
jeżeli nie, wróć do punktu B
D. Wykonaj ruch (czyli zamień miejscami odpowiednie
klocki)
E. wróć do punktu A

... i tak kilkaset razy.
Przyjrzyjmy się teraz poszczególnym punktom.

Punkt A - znajdowanie współrzędnych pustego elementu
Skorzystamy z procedury znajdz_puste(). Zapamiętamy
położenie elementu o id = 0 w dwóch zmiennych
puste_kolumna i puste_wiersz.

Punkt B - losowanie kierunku ruchu
Wprowadźmy zmienną


int kierunek


Jej wartość będziemy losować korzystając z następującej
instrukcji:


kierunek = (int) ((Math.random()*5) -2.5);


W ten sposób zmienna kierunek może przybrać wartości -2,
-1, 0, 1, 2, gdzie:

-2 oznacza, że zamieniam pusty element z jego sąsiadem
z góry
2 oznacza, że zamieniam pusty element z jego sąsiadem
z dołu
-1 oznacza, że zamieniam pusty element z jego sąsiadem
z lewej strony
1 oznacza, że zamieniam pusty element z jego sąsiadem
z prawej strony

Czemu takie dziwne wartości ? - niebawem się okaże.

Wprowadźmy też drugą zmienną:


int kierunek_poprzedni


która będzie przechowywać informacje o kierunku
poprzedniego ruchu.

Losowanie kierunku będzie się odbywać w następującej
pętli:


while (!ruchmozliwy(kierunek, kierunek_poprzedni,
puste_kolumna, puste_wiersz)) {
kierunek = (int) ((Math.random()*5) -2.5);
}
zamien(kierunek);
kierunek_poprzedni = kierunek;


(Procedury ruchmozliwy() i zamien() zostaną omówione w
kolejnych punktach. Ich działanie jest jednak
intuicyjnie zrozumiałe, czyż nie ?)
Cała funkcja rozrzuc_klocki() widoczna jest poniżej.
Liczba 1000 w pętli for określa ile ruchów wykonamy
(czyli obrazowo mówiąć ile czasu damy dziecku na
mieszanie wyjściowego układu).


private void rozrzuc_klocki() {
int kierunek, kierunek_poprzedni = 0;
int puste_kolumna, puste_wiersz;

for (int a = 0; a < 1000; a++) {
kierunek = (int) ((Math.random()*5) -2.5);
puste_kolumna = kolumna(znajdz_puste());
puste_wiersz = wiersz(znajdz_puste());
while (!ruchmozliwy(kierunek, kierunek_poprzedni,
puste_kolumna, puste_wiersz)) {
kierunek = (int) ((Math.random()*5) -2.5);
}
zamien(kierunek);
kierunek_poprzedni = kierunek;
}
}


Punkt C - sprawdzenie, czy ruch jest możliwy
Omówię teraz procedurę ruchmozliwy(), która zwraca
wartość logiczną true (można wykonać ruch) albo false
(nie można). Zawiera ona następujące warunki:


1. if (kierunek == 0)
return false;


Może się zdarzyć, że wylosowana zostanie liczba zero,
dla której nie mamy przypisanego kierunku ruchu. Wówczas
procedura zwraca wartość false, gdyż ruch nie jest
możliwy.


2. if (kierunek + kierunek_poprzedni == 0)
return false;


Ten warunek ustrzega nas przed "chodzeniem w kółko". Np.
gdyby na przemian losować kierunki -2, 2, -2, -2, 2, -2,
2 itd. (czyli góra, dół, góra, dół...) to może się
okazać, że mimo wykonania 1000 ruchów na planszy nic się
nie zmieniło. Ten warunek uniemożliwia taką sytuację
(podobnie dla lewo-prawo, czyli wartości -1 i 1, których
suma też daje 0).
(no to teraz już wiesz po co nadałem kierunkom takie
dziwne wartości.)

Bardzo możliwe, że ten pomysł z uniemożliwieniem
chodzenia w kółko to głupi i niepotrzebny bajer, gdyż
szansa zaistnienia sytuacji, w której faktycznie
chodzimy góra-dół-góra-dół jest pewnie niewielka. Nic
nie stoi na przeszkodzie żebyś wywalił tę część kodu
jeżeli uznasz że jest durna.


3 - 6. if ((kierunek == -2) && (puste_wiersz == 0))
return false;
if ((kierunek == 2) && (puste_wiersz == 3))
return false;
if ((kierunek == -1) && (puste_kolumna == 0))
return false;
if ((kierunek == 1) && (puste_kolumna == 3))
return false;


Te 4 kolejne warunki sprawdzają czy nie jesteśmy na
brzegu planszy i czy wykonując ruch nie wyjdziemy poza
nią. Np.:


if ((kierunek == -2) && (puste_wiersz == 0))
return false;


Kierunek = -2, a więc chce zamienić puste pole z jego
sąsiadem z góry. Sprawdzam więc, czy puste pole nie leży
w najwyższym wierszu. Jeżeli tak, to oczywiście ruch nie
jest możliwy gdyż nie ma żadnego sąsiada z góry- należy
więc zwrócić wartość false.

Procedurę kończy linijka


return true;


Zostanie ona wykonana jeżeli nie wystąpił żadna z
powyżej opisanych okoliczności 1-6 (bo jeżeli wystąpiły,
to wyskoczyliśmy z procedury zwracając wartość false).
Oznacza to, że wykonanie danego ruchu jest możliwe i
procedura zwraca wartość true.

Punkt D - wykonanie ruchu
Wykonanie ruchu następuje w funkcji zamien() i polega
tylko i wyłącznie na zamianie miejscami odpowiednich
elementów planszy, a więc elementu zerowego i któregoś z
jego sąsiadów (w zależności od kierunku ruchu). W tym
celu używamy pomocniczego Elementu o nazwie pomoc.




3. Pozwalać na wykonywanie posunięć.

Patrz kilka linijek wyżej (punkt D) - za wykonywanie
posunięć odpowiada ta sama funkcja zamien().




4. Wyświetlać się na ekranie.

To zadanie realizuje funkcja rysuj_plansze(), najpierw
rysuje kratkę, a później wyświetla elementy korzystając
z metody wyswietl() klasy Element. Wyświetlanych jest
tylko 15 elementów układanki - pomijamy element pusty
(zero).
Przypomnę że wspx i wspy określają lewy górny róg
planszy, a szer i wys to wymiary każdego z elementów
(pól) układanki.

5. Sprawdzać czy układanka została ułożona (czy elementy
leżą w prawidłowej kolejności)

Procedura czy_ulozona() zwraca wartość logiczną true,
gdy elementy o kolejnych id leżą w porządku rosnącym i
false w przeciwnym wypadku.


public boolean czy_ulozona() {
for (int a=0; a<16; a++) {
if (get_id(a) != a)
return(false);
}
return(true);
}





KLASA Licznik

Obiekt tej klasy musi:

1. Przechowywać informację o ilości ruchów wykonanych
przez użytkownika

- zwiększać ją po każdym wykonanym ruchu
- zerować ją przy rozpoczęciu nowej gry

2. Przechowywać informacje o maksymalnej dopuszczalnej
ilości ruchów.
3. Sprawdzać, czy nie przekroczono maksymalnej
dopuszczalnej ilości ruchów.
4. Wypisywać się na ekran.


Cała klasę Licznik znajdziesz tutaj.




KLASA Pietnastka

Teraz zajmiemy się główną klasą tego programu nazywa.
Nosi ona nazwę Pietnastka. Jej kod znajdziesz tutaj.

Pamiętasz jeszcze schemat według którego ma działać
nasza gra ? Realizujemy go właśnie tutaj, w klasie
Pietnastka.

Na początku deklarujemy parę rzeczy - jeden obiekt klasy
Plansza (nazwałem go gierka), dwa rodzaje czcionek,
jeden kolor, jeden obiekt klasy Licznik (nazwałem go
licznik), oraz zmienną typu boolean.

Następnie w funkcji init() nadajemy zmiennym wartości
początkowe. Tworzymy obiekty podając odpowiednie
parametry konstruktorom klas - np. gierka (obiekt klasy
Plansza) będzie miał wspx i wspy równe 30, a szerokość i
wysokość każdego elementu wyniesie 35
Przypomnę, że init wywoływana jest dokładnie raz - przy
pierwszym uruchomieniu appletu.




Procedura paint() jest wywoływana

- automatycznie przy rysowaniu obszaru appletu (np.
gdy był zasłonięty innym oknem, a teraz został
odsłonięty i trzeba go narysować)
- "ręcznie" po wykonaniu ruchu przy pomocy polecenia
repaint()


A co ona robi ? Nietrudno stwierdzić. Oto i algorytm:

1. wypisuje plansze na ekran.
2. sprawdza czy użytkownik ułożył już układankę.

tak ? - wypisuje stosowny komunikat i wywołuje
funkcję czekaj_na_klikniecie()
nie ? - patrz punkt 3.

3. sprawdza czy użytkownik nie przekroczył maksymalnej
liczby ruchów

tak ? - wypisuje stosowny komunikat i i wywołuje
funkcję czekaj_na_klikniecie()
nie ? - patrz punkt 4

4. wyswietla wartość licznika





Funkcja czekaj_na_klikniecie() jest wywoływana w dwóch
przypadkach - gdy użytkownik ułożył całą układankę, albo
gdy przekroczył maksymalny limit ruchów. Jej zadaniem
jest przygotowanie nowej gry - rozlosowanie nowego
ułożenia elementów oraz wyzerowanie licznika. Poza tym
ustawia ona zmienną czekaj na true, co ma znaczenie przy
obsłudze kliknięć myszy (patrz niżej).





public boolean mouseDown(Event event, int x, int y) {


To procedura obsługi myszy, a dokładniej jednego z
możliwych zdarzeń - MOUSE_DOWN, czyli przyciśnięcia
lewego przycisku myszy. Zmienne typu integer x i y
przechowują współrzędne punktu kursora myszy.
Ta procedura jest uruchamiana automatycznie po każdym
kliknięciu - nie musisz się martwić jej wywoływaniem,
Java zrobi to sama.

A oto co dzieje się w środku:

Najpierw sprawdzam stan zmiennej logicznej czekaj.
Jeżeli jest ona ustawiona na true wówczas zmieniam ją na
false i wywołuję funkcję paint(). Po co to ? Głównie po
to, żeby oddzielić od siebie kolejne rozgrywki i dać
użytkownikowi czas na przeczytanie odpowiedniego
komunikatu.

Jeżeli zmienna czekaj miała wartość false wówczas
sprawdzam czy użytkownik kliknął w plansze - jeżeli nie,
to nie muszę obsługiwać tego kliknięcia:


if ((x > gierka.wspx) && (x < gierka.wspx +
4*gierka.width)
&& (y > gierka.wspy) && (y < gierka.wspy +
4*gierka.height)) {
...tu obsługa klinknięcia...
}


Następnie obliczam, w który element planszy nastąpiło
kliknięcie


int kol, row;
kol = (int) (x - gierka.wspx)/gierka.width;
row = (int) (y - gierka.wspy)/gierka.height;


Teraz sprawdzam czy obok klikniętego elementu jest
element zerowy, czyli czy można wykonać ruch. Np. w
pierwszym warunku sprawdzam czy można przesunąć
kliknięty kawałek w górę.


if ((row != 0) && (gierka.get_id(row-1, kol) == 0)) {

licznik.zwieksz();
gierka.zamien(2);
repaint();
}


Jeżeli ponad klikniętym kawałkiem leży kawałek pusty,
wówczas po pierwsze zwiększam wartość licznika, potem
wywołuje znaną nam już funkcję klasy Plansza - zamien(),
a na końcu odpalam metodę paint() przy pomocy polecenia
repaint(). Analogiczne warunki sprawdzamy dla ruchu w
dół, lewo i prawo.




I to już wszystko. Mamy gotowe cztery pliki -
Element.java, Plansza.java, Licznik.java i
Pietnastka.java. Wrzuć je do jednego katalogu (zakładam
że masz zainstalowane JDK i zrobioną ścieżkę dostępu do
niego), napisz


javac Pietnastka.java


Otrzymasz 4 pliki typu .class.
Następnie stwórz plik w htmlu wywołujący plik
pietnastka.class. Np. tak:













Potem możesz go uruchomić spod IE albo Netscape'a albo
też posłużyć się Appletviewerem pisząc


appletviewer nazwa_pliku.html


Możesz też wygenerować dokumentację pisząc


javadoc *.java


(zauważ, że dokumentacja powstaje tylko dla zmiennych i
metod typu public. I nic w tym dziwnego, po co w koncu
innemu programiscie wiedza na temat elementów typu
private, do których i tak nie ma on dostępu ?)

Kliknij tutaj aby zagrać w stworzoną przed chwilą grę.

UWAGA ! Grać się w to nie da, bo ustawiłem ilość
losowych ruchów na 2 (czyli wystarczą 2 rozsądne
kliknięcia żeby ułożyć grę), a max ruchów na 10 (czyli w
11 ruchu gra zostanie przerwana), tak żeby łatwo można
było zaobserwować co się dzieje gdy ułożymy układankę, a
co gdy "przekręcimy" licznik. W normalnej grze, te
wartości powinny być o wiele wyższe - np. ilość losowych
ruchów ~1000, max ruchów ~300.

No i mamy już całą gierkę. hmm.... Problem w tym że
wygląda ona maksymalnie paskudnie ! Za to ma dwie
olbrzymie zalety. Po pierwsze działa. Po drugie dzięki
podejściu obiektowemu jest tak napisana, że jej
ulepszenie nie będzie wymagało pisania wszystkiego od
nowa. Dlatego też w kolejnym odcinku bez większego
problemu uporamy się z jej topornym wyglądem.

No dobra, tyle na dzisiaj. Mam nadzieję, że śledząc
kolejne etapy powstawania tej gry czegoś się nauczyłeś.
W kolejnym odcinku pojawią się nieco ambitniejsze rzeczy
- obsługa przycisków, multimedia - prosta animacja i
dźwięki, wątki itp. Będzie też mniej łopatologicznie.

c.d.n.
giaur
[e-mail]
www.giaur.hg.pl


Skocz do: Wybierz forumWarsztat - Programowanie
gier komputerowych|--Szkółka| |--Szkółka -
języki| |--Szkółka - grafika| |--Szkółka -
inne|--Programowanie gier| |--Ogólnie|
|--Dźwięk| |--Sztuczna Inteligencja|
|--Inne|--Programowanie grafiki|
|--Programowanie grafiki| |--OpenGL|
|--DirectX|--Produkcja| |--Pomysły|
|--Projektowanie| |--Projekty| |--Grafika|
|--Ogłoszenia|--O czym innym| |--Konferencje,
spotkania| |--Warsztat| |--Aktualności|
|--Artykuły| |--Wykłady| |--Compo|
|--Lepperlandia|--Śmietnik| |--Z odrzutu



Powered by Knowledge Base, wGEric (C) 2002 PHPBB.com MOD
This script (Knowledge Base - MX Addon v. 1.03e) is modified
by Haplo





W1.5b (C) 2004
[admin: ayufan, g[R]eK, Goliatus, mikael_, Regedit]
Wszystkie czasy w strefie CET (Europa)

Powered by phpBB2 Plus 1.52 based on phpBB 2.0.10 © 2001, 2002 phpBB
Group :: FI Theme :: Mody i Podziękowania