Programmējiet savu 2048 spēli W/Java !: 8 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:51

Autors PranP1My (nepilnīga) vietneSekot vairāk autora:

Man patīk spēle 2048. Un tāpēc es nolēmu ieprogrammēt savu versiju.

Tā ir ļoti līdzīga faktiskajai spēlei, taču pati tās programmēšana dod man iespēju brīvi mainīt visu, ko vien vēlos. Ja es vēlos 5x5 spēli, nevis tipisko 4x4, vienkāršas izmaiņas, izmantojot “Board” konstruktoru, man ļaus to izdarīt. Pieņemsim, ka vēlos padarīt spēli grūtāku, pievienojot gabalus pozīcijās, kas to padarīs spēlētājam vissarežģītāko, nevis nejauši. Izmantojot vienkāršu algoritmu, es to varu izdarīt. Lai gan es neaprakstīšu visas šīs izmaiņas šajā pamācībā, es plānoju pievienot vairāk, kad eju.

Tomēr pagaidām mēs ieprogrammēsim jūsu tipisko 2048. gada spēli.

Sāksim!

(Papildu piezīme: šai instrukcijai ir vajadzīgas mērenas zināšanas par programmēšanu - īpaši ar Java)

1. solis: materiāli

Šim projektam jums nevajadzēs daudz, jo tas ir tikai programmēšanas ceļvedis.

Materiāli:

• Klēpjdators
• Eclipse (vai jebkurš IDE pēc jūsu izvēles)

Jā. Tieši tā.

2. solis: iepazīstieties ar programmu - padome

Es augšupielādēju visu savu kodu vietnē GitHub - pārbaudiet to šeit:

Es sadalīju spēli 3 klasēs: galda, flīzes un spēle.

Padome:

Apraksts: Board klase nodarbojas ar spēļu galdu, izveido “Flīžu” elementu masīvu, iegūst pašreizējo punktu skaitu un augstāko flīzi, kā arī ievieto masīvu virknē (jāizmanto vēlāk sadaļā “Spēle”). Lielākā daļa loģikas ir arī šeit, klase nodrošina metodes, kā nārsto 2 un 4 izlases vietās, pārvietojoties uz augšu, uz leju, pa kreisi un pa labi, un paziņojot spēlētājiem, kad spēle ir beigusies.

Konstruktori:

/ * Plātnes noklusējuma konstruktors - izveido 4x4 matricu */

publiskā valde () {…}

/ * Konstruktors valdei - izveido matricu ar noteiktu režģa izmēru */

publiskā valde (int grids) {…}

Metodes:

/ * Getter metode, kas atgriež dēli */

publiskā flīze getBoard () {…}

/ * Getter metode, kas atgriež rezultātu */

public int getScore () {…}

/ * Atrod uz tāfeles augstāko flīzi un atgriež to */

public int getHighTile () {…}

/ * Izdrukā tāfeli uz konsoles - pārbaudes nolūkos */

public void print () {…}

/ * Atgriež dēli kā virkni - izmanto GUI */

public String toString () {…}

/ * Nārsta 2 (vai 4) tukšā vietā, tiklīdz tiek veikta kustība */

public void spawn () {…}

/ * Pārbauda, vai tāfele ir pilnībā aptumšota, un, ja tā ir, tā pamudinās spēlētājus restartēties */

public boolean blackOut () {…}

/ * Pārbauda, vai spēle ir beigusies - kad dēlis ir aptumšots un nevienu no flīzēm nevar apvienot */

public boolean gameOver () {…}

/ * Izsaukts, nospiežot “w” vai augšupvērsto bultiņu - izsauc “verticalMove” katrai plāksnes plāksnei ar parametru “uz augšu” */

publisks anulējums () {…}

/ * Izsaukts, nospiežot “s” vai lejupvērsto bultiņu - sauc “verticalMove” katrai tāfeles plāksnei ar parametru “uz leju” */public void down () {…}

/ * Izsaukts, nospiežot “d” vai labo bultiņu - izsauc “horizontalMove” katrai plāksnes plāksnei ar parametru “right” */public void right () {…}

/ * Tiek izsaukts, nospiežot “a” vai kreiso bultiņu - izsauc “horizontāli pārvietot” katrai tāfeles plāksnei ar parametru “pa kreisi” */

public void left () {…}

/* Salīdzina divu flīžu vērtības kopā un, ja tās ir vienādas vai ja viena ir vienāda ar 0 (vienkārša flīze) - to vērtības tiek pievienotas (ar nosacījumu, ka salīdzināmās flīzes ir divas dažādas flīzes un tās virzās uz atbilstošo virzienu) - rekursīvi pārvietojas pa rindu */

public void horizontalMove (int rinda, int col, virknes virziens) {…}

/* Salīdzina divu flīžu vērtības kopā un, ja tās ir vienādas vai ja viena ir vienāda ar 0 (vienkārša flīze) - to vērtības tiek pievienotas (ar nosacījumu, ka salīdzināmās flīzes ir divas dažādas flīzes un tās virzās uz atbilstošo virzienu) - rekursīvi pārvietojas pa kolonnu */

public void verticalMove (int rinda, int col, virknes virziens) {…}

Jā, to ir daudz metožu, taču neuztraucieties, jo lielāko daļu ir ļoti viegli saprast. Turklāt “Board” klase ir vissarežģītākā, tāpēc viss pēc tam būs samērā vienkāršs.

3. solis: iepazīstieties ar programmu - flīze

Flīze:

Apraksts: Flīžu klase attiecas uz atsevišķām flīzēm, un tā ir mazākā no visām klasēm. Katrai flīzei ir vesela skaitļa vērtība un krāsa. Tam ir divi konstruktori, kas izveido 0 vērtības (noklusējuma) vai #. Metodes lielākoties ir pašsaprotamas, un lielāko daļu no kopējā apjoma veido “getter” un “setter”.

Konstruktori:

/ * Izveido pamata flīzi ar vērtību 0 */

publiskā flīze () {…}

/ * Izveido flīzi ar skaitļa vērtību */

publiska flīze (int numurs) {…}

Metodes:

/ * Iegūst flīzes vērtību */

public int getValue () {…}

/ * Iestata flīzes vērtību - tiek izmantota, pievienojot divas flīzes kopā */

public void setValue (int vērtība) {…}

/ * Pārstāv flīzi kā virkni - izmanto GUI */

public String toString () {…}

/ * Iestata flīzes krāsu, pamatojoties uz tās vērtību */

public void setColor () {…}

/ * Iegūst flīzes krāsu */

public void getColor () {…}

4. solis: iepazīstieties ar programmu - spēle

Spēle

Apraksts: Spēļu klasē ir iekļauta galvenā metode, lielākā daļa GUI metožu un galvenās mijiedarbības. Tas aizņem gan flīžu, gan dēļu nodarbības un ļauj viņiem strādāt kopā.

Konstruktori:

Nav

Metodes:

/ * izveido atbilstoša izmēra GUI un pievieno atslēgu klausītāju */

public static void setUpGUI () {…}

/ * Pārbauda, vai ir nospiests WASD vai bulttaustiņš, un veic atbilstošās darbības - atjaunina JFrame ar katru kustību */

public void keyNospiests (KeyEvent e) {…}

/ * Krāso GUI ar virkni virkņu, tāfeli, flīzēm un nodrošina to pārkrāsošanu, kad spēle ir beigusies */

public void paint (Grafika g) {…}

/ * zīmē atsevišķu flīzi - tiek izsaukta no krāsošanas metodes */

public void drawTiles (grafika g, flīžu flīze, int x, int y) {…}

/ * Galvenā metode - izveido GUI un sāk spēli */

public static void main (String args) {…}

5. solis: Svarīgas metodes - kustība

Kustības metodes ir vissvarīgākās, lai saprastu, bet labā ziņa ir tā, ka, kad esat sapratis vertikālās kustības, varat to izmantot horizontālajām kustībām. Faktiski trīs vertikālās kustības metodes ir tieši tādas pašas kā trīs horizontālās metodes kustības, izņemot vienu kustību pa rindām, bet otru pāri kolonnām. Šī iemesla dēļ pievērsīsimies tikai vertikālās kustības metodēm.

private void verticalMove (int rinda, int col, virknes virziens)

{Flīžu iniciālis = tāfele [robeža] [kol.]; Flīžu salīdzinājums = dēlis [rinda] [kol.]; if (initial.getValue () == 0 || initial.getValue () == salīdzināt.getVērta ()) {ja (rinda> robeža || (direction.equals ("uz leju") && (rinda <robeža))) {int addScore = initial.getValue () + salīdzināt.getValue (); ja (initial.getValue ()! = 0) {score += addScore; } initial.setValue (addScore); salīdzināt.setValue (0); }} else {if (direction.equals ("down")) {border--; } cits {robeža ++; } verticalMove (rinda, kolonna, virziens); }}

Iepriekš minēto metodi, vertikālo pārvietošanu, sauc par “augšup” un “uz leju” metodēm. Apskatīsim “augšup” metodi.

publisks anulējums ()

{par (int i = 0; i <režģi; i ++) {robeža = 0; for (int j = 0; j <grids; j ++) {if (board [j] .getValue ()! = 0) {if (border <= j) {verticalMove (j, i, "up"); }}}}}

Šī metode iet cauri visai tāfelei un izsauc vertikālo pārvietošanu katrai flīzei ar parametru "uz augšu". verticalMove pēc tam salīdzina flīzi pozīcijā 'j' un 'i' ar flīzi pozīcijā 'robeža' un 'i'. Ja abi ir vienādi, tie tiek apvienoti. Ja tie nav, apmales flīze tiek palielināta par 1 (jo vietā esošais parametrs ir uz augšu), un atkal tiek izsaukts verticalMove.