I-program ang Iyong Sariling 2048 Game W / Java !: 8 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:09

Sa pamamagitan ng PranP1My (Hindi kumpleto) SiteFollow Higit Pa ng may-akda:

Gustung-gusto ko ang laro 2048. At sa gayon nagpasya akong i-program ang aking sariling bersyon.

Ito ay halos kapareho sa aktwal na laro, ngunit ang pagprograma mismo ng ito ay nagbibigay sa akin ng kalayaan na baguhin ang anumang gusto ko kahit kailan ko gugustuhin. Kung nais ko ang isang 5x5 na laro sa halip na ang tipikal na 4x4, isang simpleng pagbabago gamit ang constructer na 'Lupon' ang magpapahintulot sa akin na gawin ito. Sabihin na nais kong gawing mas mahirap ang laro, pagdaragdag ng mga piraso sa mga posisyon na gagawing mas kumplikado para sa manlalaro sa halip na nang random. Gamit ang isang simpleng algorithm, magagawa ko iyon. Habang hindi ko sasakupin ang lahat ng mga pagbabagong ito sa Instructable na ito, plano kong magdagdag ng higit pa sa aking pagpunta.

Gayunpaman, sa ngayon, ipo-program namin ang iyong tipikal na laro ng 2048.

Magsimula na tayo!

(Isang tala sa gilid: Nangangailangan ang Instructable na ito ng katamtamang kaalaman sa pagprograma - partikular sa Java)

Hakbang 1: Mga Kagamitan

Hindi mo kakailanganin ang bagay para sa proyektong ito dahil ito ay lamang sa isang walkthrough sa programa.

Mga Materyales:

• Laptop
• Eclipse (o anumang IDE na iyong pinili)

Oo. Ayan yun.

Hakbang 2: Kilalanin ang Programa - Lupon

Na-upload ko ang lahat ng aking code sa GitHub - suriin ito rito:

Hinati ko ang laro sa 3 klase: Board, Tile at Game.

Lupon:

Paglalarawan: Nakikipag-usap ang klase ng Lupon sa gameboard, pagse-set up ng isang hanay ng mga elemento ng 'Tile', pagkuha ng kasalukuyang marka at ang pinakamataas na tile, at paglalagay ng array sa isang string (upang magamit sa paglaon sa 'Game'). Karamihan sa lohika ay narito rin, ang klase ay nagbibigay ng mga pamamaraan para sa pangingitlog ng 2 at 4 sa mga random na lokasyon, paglipat pataas, pababa, kaliwa at kanan, at ipapaalam sa mga manlalaro kung natapos na ang laro.

Mga tagapagbuo:

/ * Default na tagapagbuo para sa Lupon - nagtatakda ng isang 4x4 matrix * /

pampublikong Lupon () {…}

/ * Tagabuo para sa Lupon - nagtatakda ng isang matrix na may tinukoy na laki ng grid * /

pampublikong Lupon (int grids) {…}

Paraan:

/ * Pamamaraan ng Getter na nagbabalik ng board * /

public Tile getBoard () {…}

/ * Pamamaraan ng Getter na nagbabalik ng iskor * /

public int getScore () {…}

/ * Nakahanap ng pinakamataas na tile sa board at ibinalik ito * /

public int getHighTile () {…}

/ * I-print ang board papunta sa console - para sa mga layunin ng pagsubok * /

public void print () {…}

/ * Ibinabalik ang board bilang isang String - ginamit sa GUI * /

public String toString () {…}

/ * Spawns isang 2 (o 4) sa isang walang laman na puwang sa oras na ang isang paglipat ay ginawa * /

public void spawn () {…}

/ * Suriin upang makita kung ang board ay ganap na naitim at kung ito ay, ididikit nito ang mga manlalaro upang muling simulan * /

public boolean blackOut () {…}

/ * Mga tseke upang malaman kung ang laro ay tapos na - kapag ang board ay naitiman at wala sa mga tile ang maaaring pagsamahin * /

public boolean gameOver () {…}

/ * Tinawag kapag ang 'w' o pataas na arrow ay pinindot - tinatawag na 'verticalMove' para sa bawat tile sa board na may parameter na 'up' * /

publiko walang bisa () {…}

/ * Tinawag kapag 's' o pababang arrow ay pinindot - tumatawag na 'verticalMove' para sa bawat tile sa board na may parameter na 'down' * / public void down () {…}

/ * Tinawag kapag pinindot ang 'd' o kanang arrow - tumatawag sa 'horizontalMove' para sa bawat tile sa board na may parameter na 'kanan' * / public void right () {…}

/ * Tinawag kapag pinindot ang 'a' o kaliwang arrow - tumatawag na 'pahalangMove' para sa bawat tile sa board na may parameter na 'kaliwa' * /

public void left () {…}

/ * Kinukumpara ang mga halaga ng dalawang tile nang magkasama at kung magkapareho o kung ang isa ay katumbas ng 0 (simpleng tile) - idinagdag ang kanilang mga halaga (sa kondisyon na ang mga tile na pinaghahambing namin ay dalawang magkakaibang mga tile at sila ay lumilipat patungo sa naaangkop na direksyon) - recursively gumagalaw sa pamamagitan ng hilera * /

public void horizontalMove (int row, int col, String direction) {…}

/ * Kinukumpara ang mga halaga ng dalawang tile nang magkasama at kung magkapareho o kung ang isa ay katumbas ng 0 (simpleng tile) - idinagdag ang kanilang mga halaga (sa kondisyon na ang mga tile na pinaghahambing namin ay dalawang magkakaibang mga tile at sila ay lumilipat patungo sa naaangkop na direksyon) - recursively gumagalaw sa pamamagitan ng haligi * /

public void verticalMove (int row, int col, String direction) {…}

Yeah, iyan ay maraming mga pamamaraan - ngunit huwag mag-alala, karamihan ay lubos na madaling maunawaan. Bukod dito, ang klase ng 'Lupon' ang pinaka kumplikado, kaya't ang lahat pagkatapos nito ay magiging simple.

Hakbang 3: Kilalanin ang Programa - Tile

Tile:

Paglalarawan: Ang klase ng Tile ay nakikipag-usap sa mga indibidwal na tile, at ang pinakamaliit sa lahat ng mga klase. Ang bawat tile ay may isang halaga ng integer at isang kulay. Mayroon itong dalawang tagapagbuo na lumilikha ng Mga tile ng halagang 0 (default) o halagang #. Ang mga pamamaraan ay kadalasang nagpapaliwanag, na may mga pamamaraan na 'getter' at 'setter' na bumubuo ng isang maramihan sa kabuuan.

Mga tagapagbuo:

/ * Bumubuo ng isang pangunahing tile na may halagang 0 * /

pampublikong Tile () {…}

/ * Bumubuo ng isang tile na may halagang bilang * /

pampublikong Tile (int number) {…}

Paraan:

/ * Nakukuha ang halaga ng tile * /

public int getValue () {…}

/ * Itinatakda ang halaga ng tile - ginamit kapag nagdaragdag ng dalawang mga tile nang magkasama * /

pampublikong walang bisa na setValue (int halaga) {…}

/ * Kinakatawan ang tile bilang isang String - ginamit sa GUI * /

public String toString () {…}

/ * Itinatakda ang kulay ng tile batay sa halaga nito * /

public void setColor () {…}

/ * Nakukuha ang kulay ng tile * /

public void getColor () {…}

Hakbang 4: Kilalanin ang Programa - Laro

Laro

Paglalarawan: Ang Class Game ay naglalagay ng pangunahing pamamaraan, karamihan sa mga pamamaraan ng GUI at ang Mga pangunahing pakikipag-ugnayan. Tumatagal ito ng parehong mga klase sa Tile at Board, at binibigyang-daan silang magtulungan.

Mga tagapagbuo:

Wala

Paraan:

/ * set up ang GUI na may naaangkop na laki at nagdaragdag ng isang Key Listener * /

public static void setUpGUI () {…}

/ * Mga tseke upang makita kung ang wasd o arrow key ay pinindot at nagsasagawa ng naaangkop na mga aksyon - ina-update ang JFrame sa bawat paglipat * /

public void keyPressed (KeyEvent e) {…}

/ * Pininturahan ang GUI na may isang serye ng mga string, ang board, ang mga tile at tinitiyak na ang mga ito ay muling nai-post kapag natapos ang laro * /

pampublikong walang bisa na pintura (Graphics g) {…}

/ * kumukuha ng isang indibidwal na tile - tinawag mula sa paraan ng pintura * /

public void drawTiles (Graphics g, Tile tile, int x, int y) {…}

/ * Pangunahing pamamaraan - itinatakda ang GUI at sinisimulan ang laro * /

public static void main (String args) {…}

Hakbang 5: Mahahalagang Paraan - Pagkilos

Ang mga pamamaraan ng paggalaw ay pinakamahalagang maunawaan, ngunit ang mabuting balita ay sa sandaling naiintindihan mo ang mga patayong paggalaw, maaari mong ilapat ang pag-unawa sa mga pahalang na paggalaw. Sa katunayan, ang tatlong pamamaraan ng paggalaw ng patayo ay eksaktong kapareho ng tatlong pahalang na paggalaw ng pamamaraan, maliban sa isang paggalaw sa mga hilera at sa iba pang mga haligi. Para sa kadahilanang iyon, mag-focus tayo sa mga patayong pamamaraan lamang ng paggalaw.

pribadong void verticalMove (int row, int col, String direction)

{Inisyal na tile = board [border] [col]; Paghambingin ang tile = board [row] [col]; kung (initial.getValue () == 0 || initial.getValue () == Compare.getValue ()) {if (row> border || (direction.equals ("down") && (row <border))) {int addScore = initial.getValue () + Compare.getValue (); kung (initial.getValue ()! = 0) {score + = addScore; } paunang.setValue (addScore); ihambing.setValue (0); }} iba pa {kung (direction.equals ("down")) {border--; } iba pa {border ++; } verticalMove (hilera, col, direksyon); }}

Ang pamamaraan sa itaas, patayoMove, ay tinawag ng mga 'pataas' at 'pababa' na pamamaraan. Tingnan natin ang pamamaraan na 'up'.

publiko walang bisa ()

{para sa (int i = 0; i <grids; i ++) {border = 0; para sa (int j = 0; j <grids; j ++) {if (board [j] .getValue ()! = 0) {if (border <= j) {verticalMove (j, i, "up"); }}}}}

Ang pamamaraang ito ay dumadaan sa buong board at tumatawag sa verticalMove para sa bawat tile na may parameter na "pataas". Pagkatapos ay inihambing ng verticalMove ang tile sa posisyon na 'j' at 'i' sa tile sa posisyon na 'border' at 'i'. Kung ang dalawa ay pantay, sila ay pinagsama. Kung ang mga ito ay hindi, ang border tile ay nadagdagan ng 1 (dahil ang parameter sa lugar ay 'pataas'), at ang verticalMove ay tinawag ulit.