Universitatea Lucian Blaga Sibiu

Facultatea de științe

Metode avansate de programare

JOC TIP PACMAN

Student:
Matei Maria-Mihaela
Specializarea Informatica Anul II
 Descrierea jocului și obiective

Pacman este un joc arcade dezvoltat inițial de compania japoneză Namco în 1980. Pacman a
devenit unul dintre cele mai populare jocuri arcade create vreodată.
Scopul jocului este ca jucătorul care direcționează „Pacman-ul” simbolizat printr-un cerc
galben, să să evite fantomele si să mănânce toate punctele albe răspândite prin labirint.
Fantomele sunt entități care cutreieră labirintul la întâmplare.
Pacman-ul are trei vieți. Dacă jucătorul se găsește pe același carou cu o fantomă, atunci
jucătorul trebuie să înceapă din nou de la punctul de plecare și îi este îndepartată o viață.
Pacman-ul avansează automat în direcția aleasă de jucător cu săgețile tastaturii. Când
jucătorul schimbă direcția, Pacman-ul se întoarce și avansează într-o noua direcţie. Când un
perete blochează trecerea Pacman-ului, acesta nu se mai mișcă.
Dacă Pacman-ul mănâncă un punct mic, câștigă 10 puncte; dacă mănâncă un punct mare,
câștigă 50 de puncte. Jocul se oprește atunci când jucătorul a mâncat toate punctele din
labirint sau a rămas fără vieți.
La început, jucătorul este rugat să apese SPACE pentru a începe. Când jocul este încheiat, se
afisează
scorul jucătorului si acesta este întrebat dacă dorește să redea jocul.
 Modelarea jocului

Proiectul meu are cinci clase: Joc, Fantoma, Jucator, Labirint și Personaj. Personajul este o clasă
abstractă. Clasele Fantoma și Jucator moștenesc clasa Personaj.
Descrierea funcțiilor
În primul rând folosim labirintul din figura următoare:

Harta poate fi descompusă în carouri egale (31 rânduri, 28 coloane). În figura următoare, carourile
albe și galbene sunt căile pe care fantomele și jucătorul le pot parcurge.
În clasa Labirint există o variabila walls (pereti) care reprezinta labirintul folosit. Un număr în matrice
reprezinta un carou. (0 = perete, 1 = punct mic, 3 = ușă, 4 = punct mare)
public class Labirint {

public static int[][] walls = new int[][] {

// 0 = perete, 1 = punct mic, 2 = gol, 3 = usa 4 = punct mare
{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,0,0,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
{0,4,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,4,0},
{0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0},
{0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,0},
{0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,2,0,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,0,0,0,2,0,0,2,0,0,0,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,2,2,2,2,2,2,2,2,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,0,0,0,3,3,0,0,0,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,0,2,2,2,2,2,2,0,2,0,0,1,0,0,0,0,0,0},
{2,2,2,2,2,2,1,2,2,2,0,2,2,2,2,2,2,0,2,2,2,1,2,2,2,2,2,2},
{0,0,0,0,0,0,1,0,0,2,0,2,2,2,2,2,2,0,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,2,2,2,2,2,2,2,2,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,0,0,2,0,0,0,0,0,0,0,0,2,0,0,1,0,0,0,0,0,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,0},
{0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
{0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0},
{0,4,1,1,0,0,1,1,1,1,1,1,1,2,2,1,1,1,1,1,1,1,0,0,1,1,4,0},
{0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0},
{0,0,0,1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0},
{0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,1,1,1,0},
{0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0},
{0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0},
{0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,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,0,0,0,0}
};
}

În clasa abstracta Personaj există trei variabile de tip int. « x » et « y

» ce reprezinta coordonatele fantomei sau jucătorului. « state »
reprerzinta direcția personajului.
În clasa Fantoma, în afară de getters și setters, există o funcție de « turnAround ». Acesta permite
schimbrea direcției fantomei. Pe măsură ce fantomele își schimbă direcția la întâmplare, când ajung
la carourile galbene se foloseste metoda « Math.random ».

De exemplu, când starea = 1 (fantoma orientată spre stânga), trebuie să definim stările exacte ale
celor trei carouri:

Labyrinth.walls [y] [x-1] (caroul din partea stângă)

Labyrinth.walls [y-1] [x] (caroul de sus) și

Labyrinthe.walls [y + 1] [x] (caroul de jos).

... (cazurile 2, 3, 4 au același principiu ca si cazul 1)

În clasa Jucator, există trei variabile: « score » (punctele pe care le câștigă jucătorul), « lives »
(numărul de vieți ale jucatorului, valoarea inițială este 3) și « state_temp » .

« state_temp » face ca jucătorul să memoreze direcția în care merge și sa schimbe apoi spre direcția
corespunzătoare de îndată ce ajunge într-un careu galben.
În clasa Joc folosim mai multe funcții care ne permit să desenăm personajele, punctele, zidurile,
numărul de puncte câștigate și numărul de vieți.

În funcția « drawWalls », folosim metoda « StdDraw.picture » cu cinci parametri.

SPACE este o valoare fixă reprezentând lungimea unei părți.

În funcția « drawPunct», folosim o buclă for pentru a schimba starea poziției în care se află punctul
mâncat sau pentru a desena punctele rămase. Folosim metoda « StdDraw.filledCircle » pentru a
desena punctele reprezentate prin puncte mici albe rotunde.

Notă: există două tipuri de puncte (mari și mici), dacă jucătorul mănâncă un punct mic, câștigă 10
puncte; dacă mănâncă un punct mare, câștigă 50 de puncte.

În jocul oficial Pacman dacă jucătorul mănâncă un punct mare, toate fantomele devin vulnerabile,
dar nu am reusit realizarea aceastei funcții.
În funcția « drawJucator » folosim « StdDraw.picture » pentru a desena jucatorul cu direcția
corespunzătoare. Starea jucătorului:

Pentru funcția « drawFantoma » folosim structura if ... else pentru a determina imaginea cu fantoma
corectă.
Pentru funcțiile « drawScore » si « drawLives » interfața grafică este:

Funcția « move » permite avansarea automata a fantomelor sau a jucătorului carou cu carou.
Folosim structura switch case pentru a defini direcția.
În prima parte a funcției « joc », desenăm pereții, punctele, « score », « lives » si « GET READY

». În plus jucătorul și cele patru fantome înaintează.

Dacă jucătorul mănâncă toate punctele, jocul s-a terminat, scorul este afișata ceerea „Apasa SPACE
pentru a incerca din nou.

Daca jucatorul isi pierde toate vietiile:

Pentru meniul principal definim prima interfață grafică. Jucătorului i se cere să apese SPACE pentru a
incepe jocul.
 Concluzie
Acest proiect mi-a permis să înțeleg cum să folosesc StdDraw făcând cercetări pe internet și
crescandu-mi nivelul abilităților în utilizarea Java.

Am făcut specificațiile și am adăugat mai multe funcții suplimentare.

 Bibliografie

1. https://jar-download.com/artifact-search/stdlib
2. http://zetcode.com/tutorials/javagamestutorial/pacman/
3. https://codereview.stackexchange.com/questions/48728/pacman-game-implementation-in-
java
4. https://books.google.ro/books?
id=FFEgiipIhkEC&pg=PA180&lpg=PA180&dq=pacman+java+about&source=bl&ots=AmHbbzb
KFs&sig=ACfU3U15ArQ7mWco9UHZHELXf_tgn-
cKSQ&hl=en&sa=X&ved=2ahUKEwiopd7bwZzqAhU9AxAIHRg3C6EQ6AEwGnoECCMQAQ#v=
onepage&q=pacman%20java%20about&f=false
5. https://www.youtube.com/playlist?list=PL80F962ED3A470F45
6. https://introcs.cs.princeton.edu/java/stdlib/
7. https://introcs.cs.princeton.edu/java/stdlib/StdDraw.java.html
8. https://introcs.cs.princeton.edu/java/stdlib/javadoc/StdDraw.html