Programmeer u eie 2048 -speletjie met Java !: 8 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:23

Deur PranP1My (Onvolledig) SiteVolg Meer deur die skrywer:

Ek hou van die spel 2048. En daarom het ek besluit om my eie weergawe te programmeer.

Dit is baie soortgelyk aan die werklike spel, maar om dit self te programmeer, gee my die vryheid om te verander wat ek wil wanneer ek wil. As ek 'n 5x5 -speletjie wil hê in plaas van die tipiese 4x4, kan ek dit eenvoudig doen deur die 'Board' -konstruksie te verander. Sê ek wil die spel moeiliker maak, en voeg stukke by op posisies wat dit vir die speler ingewikkelder sal maak eerder as willekeurig. Met 'n eenvoudige algoritme kan ek dit doen. Alhoewel ek nie al hierdie wysigings in hierdie instruksies sal behandel nie, is ek van plan om meer by te voeg.

Vir eers programmeer ons egter u tipiese spel van 2048.

Laat ons begin!

('N Kantopmerking: hierdie instruksie vereis matige kennis van programmering - spesifiek met Java)

Stap 1: materiaal

U benodig nie veel vir hierdie projek nie, want dit is slegs 'n programmering.

Materiaal:

• Skootrekenaar
• Eclipse (of enige IDE van jou keuse)

Jip. Dis dit.

Stap 2: Leer die program leer ken - raad

Ek het al my kode op GitHub opgelaai - kyk hier:

Ek het die spel in drie klasse verdeel: Board, Tile en Game.

Raad:

Beskrywing: Die bordklas handel oor die speelbord, die opstel van 'n reeks 'Tile' -elemente, die huidige telling en die hoogste teël, en die skikking in 'n string (om later in' Game 'gebruik te word). Die meeste logika is ook hier: die klas bied metodes om 2's en 4's op willekeurige plekke te paai, op, af, links en regs te beweeg en spelers te laat weet wanneer die spel verby is.

Konstrukteurs:

/ * Standaardkonstrukteur vir die raad - stel 'n 4x4 -matriks op */

openbare raad () {…}

/ * Konstrukteur vir die direksie - stel 'n matriks op met 'n gespesifiseerde roostergrootte */

openbare raad (int grids) {…}

Metodes:

/ * Getter metode wat die bord teruggee */

openbare teël getBoard () {…}

/ * Getter metode wat die telling teruggee */

publiek int getScore () {…}

/ * Vind die hoogste teël op die bord en gee dit terug */

public int getHighTile () {…}

/ * Druk die bord op die konsole uit - vir toetsdoeleindes */

openbare leegte druk () {…}

/ * Wys die bord as 'n string - gebruik in die GUI */

openbare string toString () {…}

/ * Skep 'n 2 (of 4) op 'n leë spasie net wanneer 'n skuif gemaak word */

openbare leemte kuit () {…}

/ * Kontroleer of die bord heeltemal verduister is, en as dit die geval is, sal dit die spelers aanspoor om weer te begin */

openbare booleaanse blackOut () {…}

/ * Kontroleer of die spel verby is - as die bord verduister is en nie een van die teëls kan kombineer nie */

openbare booleaanse gameOver () {…}

/ * Word gebel as 'w' of pyltjie omhoog gedruk word - 'verticalMove' vir elke teël op die bord met parameter 'up' */

openbare nietigheid () {…}

/ * Word gebel as op 's' of pyltjie gedruk word - 'verticalMove' vir elke teël op die bord met parameter 'af' */openbare leegte () {…}

/ * Gebel as 'd' of regs -pyltjie ingedruk word - 'horizontale beweging' vir elke teël op die bord met parameter 'regs' */openbare leegte regs () {…}

/ * Gebel as 'a' of pyl na links ingedruk word - 'horisontale beweging' vir elke teël op die bord met parameter 'links' */

openbare leemte links () {…}

/* Vergelyk twee teëls se waardes saam en as dit dieselfde is of as een gelyk is aan 0 (gewone teël) - word hul waardes bygevoeg (mits die teëls wat ons vergelyk twee verskillende teëls is en in die regte rigting beweeg) - beweeg rekursief deur die ry */

openbare leegte horisontaalMove (int ry, int col, string rigting) {…}

/* Vergelyk twee teëls se waardes saam en as hulle dieselfde is of as een gelyk is aan 0 (gewone teël) - word hul waardes bygevoeg (mits die teëls wat ons vergelyk, twee verskillende teëls is en in die regte rigting beweeg) - beweeg rekursief deur die kolom */

openbare leemte verticalMove (int ry, int col, string rigting) {…}

Ja, dit is baie metodes - maar moenie bekommerd wees nie, die meeste is uiters maklik om te verstaan. Boonop is die 'Board' -klas die mees komplekse, so alles daarna is relatief eenvoudig.

Stap 3: Maak kennis met die program - Tile

Teël:

Beskrywing: Die teëlklas handel oor die individuele teëls en is die kleinste van al die klasse. Elke teël het 'n heelgetalwaarde en 'n kleur. Dit het twee konstrukteurs wat teëls van waarde 0 (standaard) of waarde #skep. Die metodes is meestal selfverduidelikend, met 'getter' en 'setter' metodes wat 'n groot deel van die totaal uitmaak.

Konstrukteurs:

/ * Bou 'n basiese teël met 'n waarde van 0 */

openbare teël () {…}

/ * Konstrueer 'n teël met 'n getalwaarde */

openbare teël (int nommer) {…}

Metodes:

/ * Kry die waarde van die teël */

public int getValue () {…}

/ * Stel die teëlwaarde in - gebruik wanneer twee teëls saamgevoeg word */

public void setValue (int -waarde) {…}

/ * Stel die teël voor as 'n string - gebruik in die GUI */

openbare string toString () {…}

/ * Stel die kleur van die teël in op grond van die waarde daarvan */

openbare leemte setColor () {…}

/ * Kry die kleur van die teël */

openbare leegte getColor () {…}

Stap 4: Maak kennis met die program - spel

Spel

Beskrywing: Die spelklas bevat die belangrikste metode, die meeste GUI -metodes en die belangrikste interaksies. Dit neem beide die Tile- en Board -klasse, en stel hulle in staat om saam te werk.

Konstrukteurs:

Geen

Metodes:

/ * stel die GUI op met gepaste groottes en voeg 'n sleutelluisteraar by */

openbare statiese leemte setUpGUI () {…}

/ * Kontroleer of die wsd- of pyltjie sleutels ingedruk word en voer die toepaslike aksies uit - werk die JFrame by met elke beweging */

public void keyPressed (KeyEvent e) {…}

/ * Verf die GUI met 'n reeks snare, die bord, die teëls en sorg dat dit weer geverf word as die spel verby is */

openbare leegteverf (grafika g) {…}

/ * teken 'n individuele teël - genoem uit die verfmetode */

openbare leegte drawTiles (grafika g, teëlteël, int x, int y) {…}

/ * Hoofmetode - stel die GUI op en begin die spel */

openbare statiese leemte hoof (String args) {…}

Stap 5: Belangrike metodes - Beweging

Die bewegingsmetodes is die belangrikste om te verstaan, maar die goeie nuus is dat sodra u die vertikale bewegings verstaan, die begrip op die horisontale bewegings kan toepas. Trouens, die drie vertikale bewegingsmetodes is presies dieselfde as die drie horisontale metodebewegings, behalwe dat een oor rye beweeg en die ander oor kolomme. Laat ons daarom net op die vertikale bewegingsmetodes fokus.

private leemte verticalMove (int ry, int col, string rigting)

{Tile initial = board [border] [col]; Teël vergelyk = bord [ry] [kol]; if (initial.getValue () == 0 || initial.getValue () == vergelyk.getValue ()) {if (ry> grens || (direction.equals ("af") && (ry <grens))) {int addScore = initial.getValue () + vergelyk.getValue (); if (initial.getValue ()! = 0) {telling += addScore; } initial.setValue (addScore); vergelyk.setValue (0); }} anders {if (direction.equals ("af")) {border--; } anders {border ++; } verticalMove (ry, kol, rigting); }}

Bogenoemde metode, verticalMove, word genoem deur die 'op' en 'af' metodes. Kom ons kyk na die 'op' -metode.

openbare leemte ()

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

Hierdie metode gaan deur die hele bord en noem verticalMove vir elke teël met die parameter "up". verticalMove vergelyk dan die teël op posisie 'j' en 'i' met die teël op posisie 'grens' en 'i'. As die twee gelyk is, word hulle gekombineer. As dit nie die geval is nie, word die grensteël met 1 vergroot (aangesien die parameter 'up' is) en word verticalMove weer genoem.