Share
În primul post al acestei serii, am discutat de ce programarea orientată-obiect (OOP) a fost utilă pentru dezvoltarea jocurilor și a învățat cum să identifice obiectele, stările lor și comportamentele lor. În acest articol, vom examina principiul PPE specific coeziune și cum se aplică la jocuri.
Notă: Deși acest tutorial este scris folosind Java, ar trebui să puteți folosi aceleași tehnici și concepte în aproape orice mediu de dezvoltare a jocului.
Coeziunea este principiul de a fi sau de a face un lucru bine. Cu alte cuvinte, coeziunea înseamnă gruparea unui cod care contribuie la o singură sarcină.
Un exemplu extraordinar de non-programare al acestui principiu a fost acoperit de unul dintre primele articole Gamedevtuts +, care vorbeau despre regula acustică:
Nu încercați să faceți prea multe jocuri într-un singur pachet ... Individ, fiecare dintre acestea ar fi putut fi jocuri bune. Împreună, s-au luptat unul cu celălalt.
Aceeași regulă se aplică programării orientate pe obiecte. Fiecare obiect trebuie să aibă doar o singură responsabilitate. Fiecare comportament al acelui obiect ar trebui să facă doar o singură sarcină. Mai mult decât atât și veți avea mult mai greu să faceți schimbări în cod.
Cod care este organizat de funcționalitate și care are doar o singură sarcină coeziune ridicată. Codul foarte coeziv este reutilizabil, simplu și ușor de înțeles. De asemenea, creează obiecte care sunt mici și focalizate.
Cod care este organizat arbitrar și are sarcini multiple se spune că are coeziune scăzută. Un astfel de cod este greu de înțeles, menținut și reutilizat și este adesea complex. De asemenea, creează obiecte care sunt mari și nefocuse.
Având o coeziune ridicată este, în general, bună, în timp ce coeziunea scăzută este, în general, rea. La scrierea codului, încercați întotdeauna să scrieți un cod foarte coerent.
Deci, cum se aplică acest lucru programării orientate obiect? Ei bine, pentru început, organizarea codului în obiecte ajută la creșterea coeziunii jocului în general. Cu toate acestea, fiecare obiect individual ar trebui să aibă, de asemenea, coeziune ridicată. Să ne referim la cele trei exemple pentru a vedea cum funcționează acest lucru.
Reamintim din ultimul articol că am definit obiectul navei ca având comportamente de întoarcere, mișcare și tragere.
Dacă ar fi să scriem o singură bucată de cod care să facă toate cele trei comportamente simultan, ar deveni destul de dezordonată. În schimb, ar trebui să separăm fiecare comportament în ceea ce se numește funcții. Funcțiile ne permit să separăm funcționalitatea și să grupezi împreună un cod similar, ajutând astfel la crearea unui cod extrem de coerent.
În programare, un obiect este definit prin crearea unei clase. În Java, o clasă este codificată după cum urmează:
/ ** * Clasa de navă * / Nava de clasă publică / ** * Funcție - efectuează comportamentul (sarcina) de a schimba nava * / void rotate () // Cod care transformă nava / ** * - efectuează comportamentul (sarcina) de mutare a navei * / mișcarea publică voidă () // Cod care mută nava / ** * Funcție - efectuează comportamentul (sarcina) de a trage arma navei * ) // Codul care face ca nava să tragă un glont
După cum puteți vedea, fiecare comportament își are propria funcție, iar codul este destul de bine organizat doar în această structură de schelet.
Nu vă îngrijorați prea mult despre sintaxa exactă încă; o vom discuta mai detaliat pe măsură ce vom continua să vedem în serie.Pentru Tetris, amintiți-vă că comportamentele unui tetromino erau în scădere, se mișcau (în lateral) și se roteau. Structura de bază a clasei este următoarea:
/ ** * Clasa Tetromino * / clasa publica Tetromino / ** * Functia - actualizarea pozitiei Tetromino * / public void fall () // Cod care actualizeaza pozitia Tetromino / ** * Functie - mutati un Tetromino * / public void move () // Cod care mișcă Tetromino în lateral / ** * Funcție - rotiți un Tetromino * / public void rotate () // Cod care rotește Tetromino la 90 de grade
Din nou, comportamentele sunt separate în funcțiile lor. Pentru cădea metoda, totuși, observați că sarcina este de a actualiza poziția tetromino. Acest lucru se datorează faptului că tetromino este mereu în scădere, așa că nu putem face doar sarcina "pentru ca tetromino să cadă".
În schimb, un tetromino care se încadrează doar coboară pe ecran un anumit număr de rânduri odată - deci trebuie să actualizăm poziția tetromino pentru a reflecta această viteză de cădere.
Pentru obiectul fantomă cu comportamente de mișcare și de schimbare a stării, trebuie să facem un pic mai mult de lucru pentru ao face să fie foarte coerentă.
/ ** * Clasa Ghost * / Ghost clasa publica / ** * Functie - muta Ghost * / move void public () // Cod care muta fantoma in directia curenta / ** * Function - change Ghost direcția * / void public changeDirection () // Cod care schimbă direcția Ghost / ** * Funcție - schimbare Ghost speed * / public void changeSpeed () // Cod care schimbă viteza Ghost / ** * schimbare Ghost color * / public void changeColor () // Cod care schimbă culoarea Ghost / ** * Funcție - schimbare Ghost state * / public void changeState () // Cod care schimbă statutul Ghost // Această funcție, de asemenea, va apela cele trei funcții ale changeDirection, changeSpeed și changeColor
Statul Ghost are trei funcții suplimentare adăugate la acesta: schimba directia, schimba culoarea, și changeSpeed. Acestea nu erau în lista noastră originală de comportament deoarece nu sunt comportamente. În schimb, aceste funcții sunt cunoscute ca funcții de ajutor și sunt acolo pentru a ne ajuta să menținem coeziunea ridicată.
Comportamentul schimbării stării (ceea ce se întâmplă atunci când Pac-Man mănâncă un peletizator de putere) necesită trei sarcini diferite: să se întoarcă în albastru, să se reverse și să se miște mai încet. Pentru a menține coeziunea, nu vrem ca o funcție să îndeplinească toate aceste trei sarcini, așa că le împărțim în trei sub-sarcini pe care funcția le va face să-și îndeplinească singura sarcină principală.
Folosirea cuvântului și atunci când descriem ce înseamnă un comportament / funcție înseamnă, de obicei, că ar trebui să creăm mai multe funcții.
Coeziunea este principiul grupării împreună a codului și asigură că fiecare funcție efectuează doar o singură sarcină. Coeziunea ajută la crearea unui cod care poate fi întreținut și reutilizabil.
În următorul sfat rapid, vom discuta principiul cuplării și modul în care se referă la coeziune. Urmăriți-ne pe Twitter, Facebook sau Google+ pentru a fi la curent cu cele mai recente postări.
Accentsconagua