Programa el teu propi joc 2048 W / Java !: 8 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:10

Per PranP1My (incomplet) Lloc Seguir més per l'autor:

M'encanta el joc 2048. I per això vaig decidir programar la meva pròpia versió.

És molt similar al joc real, però programar-lo jo mateix em dóna la llibertat de canviar el que vulgui sempre que vulgui. Si vull un joc de 5x5 en lloc del 4x4 típic, un simple canvi amb el constructor "Board" em permetrà fer-ho. Digueu que vull dificultar el joc, afegint peces en posicions que faran que sigui més complex per al jugador que no pas a l’atzar. Fent servir un algorisme senzill, puc fer això. Tot i que no tractaré totes aquestes modificacions en aquest instructiu, tinc previst afegir-ne més a mesura que vagi.

De moment, però, programarem el vostre joc típic del 2048.

Comencem!

(Una nota lateral: aquest instructiu requereix un coneixement moderat de la programació, específicament amb Java)

Pas 1: materials

No necessiteu gaire per aquest projecte, ja que és només un tutorial de programació.

Materials:

• Portàtil
• Eclipsi (o qualsevol IDE que trieu)

Sí. Això és.

Pas 2: Conegueu el programa - Tauler

Vaig penjar tot el meu codi a GitHub. Consulteu-lo aquí:

Vaig dividir el joc en tres classes: Tauler, Rajola i Joc.

Pissarra:

Descripció: la classe Board tracta del tauler de joc, configurant una matriu d'elements "Tile", obtenint la puntuació actual i la fitxa més alta i posant la matriu en una cadena (que s'utilitzarà més endavant a "Game"). La major part de la lògica també és aquí, la classe proporciona mètodes per generar 2 i 4 en ubicacions aleatòries, movent-se cap amunt, cap avall, a l'esquerra i a la dreta i fent saber als jugadors quan finalitza el joc.

Constructors:

/ * Constructor per defecte per a la Junta: estableix una matriu 4x4 * /

junta pública () {…}

/ * Constructor for the Board: estableix una matriu amb una mida de quadrícula especificada * /

Junta pública (quadrícules int) {…}

Mètodes:

/ * Mètode Getter que retorna el tauler * /

public Tile getBoard () {…}

/ * Mètode Getter que retorna la puntuació * /

public int getScore () {…}

/ * Cerca la fitxa més alta del tauler i la torna * /

public int getHighTile () {…}

/ * Imprimeix el tauler a la consola per a proves * /

public void print () {…}

/ * Retorna el tauler com una cadena: utilitzat a la GUI * /

public String toString () {…}

/ * Genera un 2 (o 4) en un espai buit quan es fa un moviment * /

public void spawn () {…}

/ * Comprova si el tauler està completament apagat i, si ho és, farà que els jugadors es reiniciïn * /

public booleà blackOut () {…}

/ * Comprova si el joc s'ha acabat: quan el tauler està apagat i cap de les fitxes es pot combinar * /

public boolean gameOver () {…}

/ * Es crida quan es prem la tecla "w" o la fletxa cap amunt - crida a "verticalMove" per a cada mosaic del tauler amb el paràmetre "amunt" * /

public void up () {…}

/ * Es crida quan es prem la fletxa 's' o cap avall - crida a 'verticalMove' per a cada mosaic del tauler amb el paràmetre 'avall' * / public void down () {…}

/ * Es crida quan es prem la tecla "d" o la fletxa dreta - es diu "horizontalMove" per a cada mosaic del tauler amb el paràmetre "right" * / public void right () {…}

/ * Es crida quan es prem una "fletxa esquerra o esquerra" - crida a "horizontalMove" per a cada mosaic del tauler amb el paràmetre "esquerra" * /

buit públic deixat () {…}

/ * Compara els valors de dues fitxes juntes i si són iguals o si un és igual a 0 (fitxa plana): s’afegeixen els seus valors (sempre que les fitxes que estem comparant siguin dues fitxes diferents i avancin cap a la direcció adequada) - es mou recursivament per la fila * /

public void horizontalMove (fila int, col int, direcció de la cadena) {…}

/ * Compara els valors de dues fitxes juntes i si són iguals o si un és igual a 0 (fitxa plana): s’afegeixen els seus valors (sempre que les fitxes que estem comparant siguin dues fitxes diferents i avancin cap a la direcció adequada) - es mou recursivament per la columna * /

public void verticalMove (fila int, col int, direcció de la cadena) {…}

Sí, hi ha molts mètodes, però no us preocupeu, la majoria són extremadament fàcils d’entendre. A més, la classe 'Board' és la més complexa, de manera que tot el que sigui després serà relativament senzill.

Pas 3: coneixeu el programa: rajola

Rajola:

Descripció: la classe Tile tracta les fitxes individuals i és la més petita de totes les classes. Cada mosaic té un valor enter i un color. Té dos constructors que creen rajoles de valor 0 (per defecte) o valor #. La majoria dels mètodes s’expliquen per si mateixos, amb els mètodes ‘getter’ i ‘setter’ que constitueixen la major part del total.

Constructors:

/ * Construeix un mosaic bàsic amb un valor de 0 * /

rajola pública () {…}

/ * Construeix un mosaic amb un valor de número * /

Rajola pública (número int) {…}

Mètodes:

/ * Obté el valor del mosaic * /

public int getValue () {…}

/ * Defineix el valor de la rajola: s'utilitza quan s'afegeixen dues rajoles juntes * /

public void setValue (valor int) {…}

/ * Representa el mosaic com una cadena: s'utilitza a la GUI * /

public String toString () {…}

/ * Estableix el color del mosaic en funció del seu valor * /

public void setColor () {…}

/ * Obté el color de la rajola * /

public void getColor () {…}

Pas 4: coneixeu el programa: joc

Joc

Descripció: La classe de joc allotja el mètode principal, la majoria dels mètodes GUI i les interaccions clau. Prèn tant les classes Tile com Board, i els permet treballar junts.

Constructors:

Cap

Mètodes:

/ * configura la GUI amb les mides adequades i afegeix un oient de claus * /

public static void setUpGUI () {…}

/ * Comprova si es premen les tecles de cursor o de fletxa i realitza les accions adequades: actualitza el JFrame amb cada moviment * /

public void keyPressed (KeyEvent e) {…}

/ * Pinta la GUI amb una sèrie de cordes, el tauler, les fitxes i garanteix que es tornin a pintar quan finalitzi el joc * /

pintura de buit públic (gràfics g) {…}

/ * dibuixa una fitxa individual - cridada pel mètode de pintura * /

public void drawTiles (gràfics g, mosaic mosaic, int x, int y) {…}

/ * Mètode principal: configura la GUI i inicia el joc * /

public static void main (String args) {…}

Pas 5: Mètodes importants: moviment

Els mètodes de moviment són els més importants d’entendre, però la bona notícia és que, un cop entesos els moviments verticals, podeu aplicar aquesta comprensió als moviments horitzontals. De fet, els tres mètodes de moviment vertical són exactament iguals als tres moviments de mètode horitzontal, excepte que un es mou per files i l’altre per columnes. Per aquest motiu, centrem-nos només en els mètodes de moviment vertical.

private void verticalMove (fila int, col int, direcció de la cadena)

{Rajola inicial = tauler [vora] [col]; Comparar rajoles = tauler [fila] [col]; if (initial.getValue () == 0 || initial.getValue () == compare.getValue ()) {if (fila> vora || (direction.equals ("avall") && (fila <vora))) {int addScore = initial.getValue () + compare.getValue (); if (initial.getValue ()! = 0) {score + = addScore; } initial.setValue (addScore); compare.setValue (0); }} else {if (direction.equals ("down")) {border--; } else {border ++; } verticalMove (fila, col, direcció); }}

El mètode anterior, verticalMove, s'anomena pels mètodes "amunt" i "avall". Fem una ullada al mètode "up".

public void up ()

{for (int i = 0; i <quadrícules; i ++) {border = 0; for (int j = 0; j <quadrícules; j ++) {if (tauler [j] .getValue ()! = 0) {if (vora <= j) {verticalMove (j, i, "cap amunt"); }}}}}

Aquest mètode recorre tota la placa i crida a verticalMove per a cada mosaic amb el paràmetre "up". verticalMove compara llavors la fitxa a la posició 'j' i 'i' amb la fitxa a la posició 'border' i 'i'. Si els dos són iguals, es combinen. Si no ho són, la rajola de la vora s'incrementa en 1 (ja que el paràmetre en lloc és "amunt") i es torna a cridar verticalMove.