Capul de pagină: Test de Programare

ÎNREGISTRARE DE PROGRAMARE

OMAR ATHMAN

UNIVERSITATEA DE AGRICULTURĂ JOMO KENYATTA Ș I

TEHNOLOGIE

07/02/2020
Cooperatie Breakout Game

Un joc cooperativ de evadare

În acest proiect, vei dezvolta un joc de tip breakout pentru Games Unlimited. Scopul jocului este
pentru a elimina toate cărămizile cu o minge lovită de jucător. O cărămidă este eliminată odată ce a fost lovită
de mingea jucătorului. Mingea săritură de pe cărămida îndepărtată. Mingea jucătorului este controlată de un
paleta. Mingea ricoș ează din toate marginile, cu excepț ia marginilor de jos. Dacă mingea loveș te marginea de jos a
zona de joc, o viaț ă este pierdută. Un jucător are până la trei vieț i. Dacă toate cărămizile sunt eliminate din
ecranul jucătorului, jocul avansează la următorul nivel. Dacă jucătorul nu mai are vieț i rămase,
jocul s-a terminat. Dacă scorul maxim este în top 10 curent, jocul întreabă jucătorul dacă doreș te să facă o înregistrare pentru
O listă cu scoruri mari este dorită. După fiecare joc jucat, jucătorul ar trebui să vadă ecranul de bun venit.
(detaliat mai jos). O ecran tipic de joc ar putea arăta aș a:

Jocul arată în colț ul din dreapta sus scorul actual, următorul scor pe care jucătorul trebuie să-l depăș ească pentru a

urcă cu o poziț ie în lista de scoruri mari ș i rangul curent în lista de scoruri mari (pe baza
scorul actual). Dacă jucătorul nu este în prezent în top 10, câmpul de rang ar arăta doar „-”. În
în colț ul din dreapta jos, jocul afiș ează nivelul actual al jocului, vieț ile rămase ș i iniț ialele
jucătorul.

Programul trebuie să poată deschide niveluri de joc de pe un server ș i să le stocheze (ș i să le deschidă)

local pe stocare persistentă. În plus, programul trebuie să fie capabil să citească un fiș ier cu scoruri mari
de pe un server ș i actualizaț i-l, dacă scorul maxim al jucătorului este în top 10 ș i jucătorul solicită un
intrare în lista de scoruri mari.
Cooperatie Breakout Game

Când jucătorul începe un joc, un ecran de bun venit îl lasă pe jucător să selecteze dacă doreș te să
începeț i un joc nou, descărcaț i un nou nivel de pe server printr-o conexiune http, deschideț i un nivel local,
accesaț i regulile jocului sub formă de un ecran de ajutor, vizualizaț i scorurile curente (top 10), sau încheiaț i
joc. Dacă utilizatorul trebuie să aș tepte, de exemplu, în timp ce descarcă un nivel, programul trebuie să
afiș aț i o bară de progres. În mod similar, în cazul circumstanț elor excepț ionale, cum ar fi o indisponibilitate
conexiune la server sau un nivel de joc care nu poate fi iniț iat corespunzător (din cauza unei greș eli în
proiectarea nivelului), programul ar trebui să ofere feedback adecvat jucătorului.

Sarcini suplimentare

Unele cărămizi au bonusuri suplimentare: o cărămidă ar putea împărț i mingea în două sau trei mingi, reduce sau
măreș te paleta jucătorului sau oferă o viaț ă suplimentară.

Fiecare grup trebuie să conceapă cel puț in două niveluri de joc. Un nivel de joc oferă o descriere a
layout pentru cărămizi ș i necesită o modalitate de a stoca cărămizile bonus (vezi mai sus). Fiș ierul nivelului jocului
poate folosi doar măsuri relative pentru a facilita portabilitatea. Fiecare cărămidă este specificată în dimensiuni relative,

adică, x % din lăț imea ecranului ș i y % din înălț imea ecranului. Fiș ierul nivelului jocului trebuie să includă
viteza, direcț ia ș i poziț ia iniț ială a mingii, precum ș i dimensiunea paletei. Poț i presupune că
paddle-ul este în repaus ș i centrat orizontal. Odată ce mai multe echipe au implementat...
versiunea fiș ierului de joc, vom lua cea mai bună ca referinț ă ș i toate celelalte programe ar trebui să
fii capabil să citeș ti în acest fiș ier de joc de referinț ă.

Dacă mingea loveș te o rachetă aflată în repaus, aceasta doar inversează direcț ia mingii în direcț iile x ș i y.
Cu toate acestea, dacă jucătorul mută paleta, viteza orizontală a paletei este adăugată la
componenta orizontală a vitezei mingii.

Provocare suplimentară

Până acum, jocul poate fi jucat doar de un singur jucător. Pentru markeri suplimentari, poț i încerca să proiectezi
o versiune colaborativă a acestui joc în care paleta unui alt jucător se află la opusul
ecranul. Actualizările jocului între cei doi jucători se efectuează printr-o conexiune Bluetooth.
Această sarcină este dificilă deoarece necesită o sincronizare permanentă între cei doi jucători. Dacă
îț i place să duci jocul colaborativ la un alt nivel, chiar ș i 4 jucători ar putea fi conectaț i pentru unul
joc, adică, de fiecare parte a jocului este o paletă a fiecărui jucător participant. Echipa pierde
game until either one of the players has no live left or, if there is a common number of lives for
toț i jucătorii, nu a mai rămas nicio viaț ă pentru echipă.
Cooperatie Breakout Game

Puncte de verificat

Toate erorile sunt tratate corect (re ț ea, sistem de fi ș iere)

Descărcare reu ș ită a fi ș ierelor de nivel pentru joc

•Încărca ț i, actualiza ț i ș i stoca ț i cu succes scorul maxim de pe/pe server

•Încărca ț i local fi ș ierele nivelului jocului

Proiectează cel pu ț in două fi ș iere de nivel de joc

•A fi capabil să cite ș ti formatul de referin ț ă

Ecran de joc bine conceput

•Mecanica jocului OK (eliminarea cărămizilor, cărămizi bonus, comportament de săritură)

Detec ț ia coliziunilor OK
•Toate actualizările sunt OK (scorul curent, vie ț ile, avansarea la următorul nivel, …)

•Ecran de întâmpinare plăcut (de exemplu, o imagine ca fundal) inclusiv ecran de ajutor

•Jocul func ț ionează la diferite rezolu ț ii (de asemenea, în mod portret ș i peisaj)

•Feedback adecvat (bară de progres, descărcare cu succes a fi ș ierelor, …)

•Game fluid and plays well
Cooperatie Breakout Game

CODARE: AM FOLOSIT LIMBA DE PROGRAMARE JAVA

/*
* Fiș ier: [Link]
* -------------------
* Name:
„Lider de Secț iune:”

*
Acest fiș ier va implementa în cele din urmă jocul Breakout.
*/

import [Link].*;
import [Link].*;
import [Link].*;

import [Link].*;
import [Link].*;
import [Link].*;

public class Breakout extinde GraphicsProgram {

/* Lăț imea ș i înălț imea ferestrei aplicaț iei în pixeli */

public static final int APPLICATION_WIDTH = 450;
public static final int APPLICATION_HEIGHT = 650;

/* Dimensiunile tablei de joc (de obicei aceleaș i) */

private static final int WIDTH = APPLICATION_WIDTH;
Cooperativă Breakout Game

private static final int ÎNĂLȚ IME = ÎNALȚ IMEA_APLICAȚ IEI;

Dimensiunile paletei
private static final int PADDLE_WIDTH = 70;
private static final int PADDLE_HEIGHT = 20;

/** Offset al paddle-ului de sus de la bază */

private static final int PADDLE_Y_OFFSET = 30;

Numărul de cărămizi pe rând

private static final int NBRICKS_PER_ROW = 15;

Numărul de rânduri de cărămizi

private static final int NBRICK_ROWS = 10;

/** Separare între cărămizi */

privat static final int BRICK_SEP = 4;

lăț imea unei cărămizi

privat static final int Lăț imea_Cărămidelor =

(LARGIME - (NUMAR_CARAMIDE_PE_LINE - 1) * SEP_CARAMIDA) / NUMAR_CARAMIDE_PE_LINE;

Înălț imea unei cărămizi

privat static final int INĂLTIMEA_CĂRĂMIDELOR = 8;

Raza mingii în pixeli

private static final int RAZA_BILA = 10;
Cooperatie Breakout Game

/** Ofsetul rândului superior de cărămidă de la partea de sus */

valoarea statică finală privată int BRICK_Y_OFFSET = 70;

/** Numărul de ture */

private static final int NTURNS = 3;

Viteza mingii
private double vx, vy;

/**Generator de numere aleatorii pentru vx*/

private RandomGenerator rgen = [Link]();

/* Întârziere de animaț ie sau timp de pauză între miș cările mingii */

privat static final int DELAY = 10;

/* Metodă: run() */
/* Rulează programul Breakout. */
public void run() {
pentru(int i=0; i < NTURNS; i++) {
setUpGame();
joacăJoc();
if(brickCounter == 0) {
[Link](false);
printaCâș tigător();
opreș te;
}
dacă (brickCounter > 0) {
eliminaTot();
Cooperatie Breakout Game

}
}
dacă (numărătoareaCărămizilor > 0) {

printGameOver();
}
}

private void setUpGame() {

deseneazăCărămizi( lăț imea()/2, OFFSET_Y_CĂRĂMIDĂ);

deseneazăRachita();
drawBall();
}

//adăugarea unui obiect de cărămidă individual

private GRect cărămidă;

//drawing all the bricks necessary for the game

private void deseneazaCărămizi(double cx, double cy) {

Trebuie să avem mai multe coloane în fiecare rând

* aș adar, trebuie să fie două bucle for,

* un ciclu for pentru rânduri ș i un ciclu for pentru coloane.

*/

pentru( int rand = 0; rand < NBRICK_ROWS; rand++ ) {

pentru (int coloana = 0; coloana < NBRICKS_PER_ROW; coloana++) {

Cooperatie Breakout Game

/* Pentru a obț ine coordonata x pentru lăț imea de început:

* începe de la lăț imea centrului,

* scade jumătate din cărămizi (lăț ime) din rând,

* scade jumătate din separaț iile (lăț imea) dintre cărămizi
în rând,
* acum eș ti la locul unde ar trebui să fie prima cărămidă,

* aș a că pentru punctul de plecare al următoarelor cărămizi din coloană, tu

trebuie să:

* adaugă o lăț ime de cărămidă

* aduce o lăț ime de separare

*/

double x = cx - (NBRICKS_PER_ROW*BRICK_WIDTH)/2 -
((NBRICKS_PER_ROW-1)*BRICK_SEP)/2 + coloana*BRICK_WIDTH +
coloană*BRICK_SEP;

/* Pentru a obț ine coordonata y a înălț imii de început: */

* începe de la lungimea dată de sus pentru primul rând,

* apoi adăugaț i o înălț ime de cărămidă ș i o separare a cărămizilor pentru fiecare dintre

următoarele rânduri
*/

double y = cy + row * Y_HEIGHT + row * Y_SEP;

brick = new GRect( x , y , BRICK_WIDTH , BRICK_HEIGHT );

adăuga (cărămidă);

[Link](true);

Setarea culorilor în funcț ie de rândul în care se află cărămizile

Cooperatie Breakout Game

dacă (rând < 2) {

[Link]([Link]Ș U);
}
dacă (row == 2 || row == 3) {
[Link]([Link]);
}
dacă (row == 4 || row == 5) {
[Link]([Link]);
}
dacă (rândul == 6 || rândul == 7) {

[Link]([Link]);
}
dacă (rândul == 8 || rândul == 9) {

[Link]([Link]);
}
}
}
}

//adăugarea obiectului individual de paddle

paddle privat GRect;

//configurare paddle

private void deseneazaRama() {

//începerea paletei în mijlocul ecranului
dublu x = getWidth()/2 - PADDLE_WIDTH/2;
înălț imea paletei rămâne constantă pe parcursul jocului
//trebuie să ne asigurăm că scădem ÎNĂLȚ IMEA PALANEI,
Cooperatie Breakout Game

deoarece dreptunghiul este desenat din colț ul din stânga sus

double y = getHeight() - PADDLE_Y_OFFSET - PADDLE_HEIGHT;
paddle = new GRect (x, y, PADDLE_WIDTH, PADDLE_HEIGHT);
[Link](true);
adaugă (paddle);

adăugaț i ascultători de mouse();

}

//facând ca mouse-ul să urmărească paleta

public void mouseMoved(MouseEvent e) {

Mouse-ul urmăreș te punctul mijlociu al paletei.
* Dacă punctul din mijloc al paletei este între jumătatea lăț imii paletei ecranului
* ș i o jumătate din lăț imea paddle-ului înainte de sfârș itul ecranului,

* locaț ia x a paletei este setată la poziț ia cursorului minus jumătate din lungimea paletei
lăț ime
* ș i înălț imea rămâne aceeaș i
*/
dacă (([Link]() < getWidth() - PADDLE_WIDTH/2) && ([Link]() >
PADDLE_WIDTH/2)) {
[Link]([Link]() - PADDLE_WIDTH/2, getHeight() -
PADDLE_Y_OFFSET - PADDLE_HEIGHT);
}

//adăugarea unui obiect de tip minge individual

private GOval minge;

Cooperatie Breakout Game

//setarea mingii
private void deseneazaMinge() {

double x = getWidth()/2 - RAZA_BALLULUI;

double y = getHeight()/2 - RAZA_BOLUI;
mingea = noua GOval(x, y, RAZA_MINGII, RAZA_MINGII);
[Link](true);
adauga(minge);
}

private void joacăJoc() {

aș teaptăClick();
getViteza mingii();
în timp ce (adevărat) {

mutăMinge();
dacă ([Link]() >= obț ineÎnălț imea()) {

opreș te;
}
if(brickCounter == 0) {
sparge;
}
}
}

private void getBallVelocity() {

vy = 4.0;
vx = [Link](1.0, 3.0);
Cooperatie Breakout Game

dacă ([Link](0.5)) {
vx = -vx;
}

private void mutaMinge() {

[Link](vx, vy);
//verifică pentru pereț i

trebuie să obț inem vx ș i vy în punctul cel mai apropiat de 0 sau de celălalt capăt

dacă (([Link]() - vx <= 0 && vx < 0) || ([Link]() + vx >= (getWidth() -

BALL_RADIUS*2) && vx>0)) {
vx = -vx;
}
Nu trebuie să verificăm perete de jos, deoarece mingea poate cădea prin
perete la acel punct
dacă (([Link]() - vy <= 0 && vy < 0 )) {
vy = -vy;
}

//verifică pentru alte obiecte

GObject collider = obț ineObiectulColizant();

dacă (colizor == palet) {

Trebuie să ne asigurăm că mingea ricoș ează doar de partea de sus a
vâsle
* ș i, de asemenea, că nu se „lipseș te” de acesta dacă părț i diferite ale mingii îl lovesc
vâsli repede ș i pune mingea "prinsă" pe vâsla.
* Am rulat "println ("vx: " + vx + ", vy: " + vy + ", ballX: " + [Link]() + ",
ballY: " +[Link]());"
* ș i am descoperit că [Link]() se schimbă cu 4 de fiecare dată, în loc de 1,
Cooperatie Breakout Game

* astfel încât să nu ajungă niciodată exact la înălț imea la care mingea loveș te
rachetă (înălț imea rachetei + înălț imea mingii),

* prin urmare, estimez că punctul este mai mare sau egal cu înălț imea la
cu care mingea loveș te racheta,
* dar mai puț in decât înălț imea unde mingea loveș te paleta minus 4.
*/

dacă ([Link]() >= getHeight() - PADDLE_Y_OFFSET -

INALTIMEA_PADDLE-RAZA_BOLA*2 && [Link]() < obtineInaltime() -
PADDLE_Y_OFFSET - PADDLE_HEIGHT - BALL_RADIUS*2 + 4) {
vy = -vy;
}
}
//deoarece am pus o serie de cărămizi, ultima cărămidă din zidul de cărămidă este atribuită
cărămidă de valoare.

deci, ne restrângem spunând că colierul nu este egal cu o pagaie sau

nul
//aș a că tot ce a rămas este cărămida
altfel dacă (colizor != null) {
elimină(collider);
brickCounter--;
vy = -vy;
}
pauză (ÎNDELANGĂ);

private GObject obtineObiectulColizor() {

dacă((getElementAt([Link](), [Link]())) != null) {

Cooperatie Breakout Game

returnează getElementAt([Link](), [Link]());

}
altfel dacă (getElementAt( ([Link]() + BALL_RADIUS*2), [Link]()) != null ) {
return getElementAt([Link]() + BALL_RADIUS*2, [Link]());
}
altfel dacă(getElementAt([Link](), ([Link]() + BALL_RADIUS*2)) != null ) {
return getElementAt([Link](), [Link]() + BALL_RADIUS*2);
}
altfel dacă(getElementAt(([Link]() + RAZA_MINGII*2), ([Link]() +
BALL_RADIUS*2)) != null ){
returnează getElementAt([Link]() + BALL_RADIUS*2, [Link]() +
RADIUS_BOL*2);
}
//need to return null if there are no objects present
altfel{
returnează null;

private void printGameOver() {

GLabel gameOver = new GLabel ("Game Over", getWidth()/2, getHeight()/2);
[Link](-[Link]()/2, -[Link]());
[Link]([Link]);
adauga (gameOver);

private int brickCounter = 100;

Cooperatie Breakout Game

private void printWinner() {

GLabel Câș tigător = new GLabel ("Câș tigător!!", getWidth()/2, getHeight()/2);

[Link](-[Link]()/2, -[Link]());
[Link]([Link]);
adauga (Câș tigător);

}
}