Programmer ditt eget 2048 -spill med Java !: 8 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:20

Av PranP1My (ufullstendig) SiteFollow Mer av forfatteren:

Jeg elsker spillet 2048. Derfor bestemte jeg meg for å programmere min egen versjon.

Det ligner veldig på selve spillet, men å programmere det selv gir meg friheten til å endre hva jeg vil når jeg vil. Hvis jeg vil ha et 5x5 -spill i stedet for den typiske 4x4, vil en enkel endring ved hjelp av "Board" -konstruksjonen tillate meg å gjøre det. Si at jeg vil gjøre spillet vanskeligere, og legge til brikker på posisjoner som vil gjøre det mest komplekst for spilleren i stedet for tilfeldig. Ved å bruke en enkel algoritme kan jeg gjøre nettopp det. Selv om jeg ikke vil dekke alle disse modifikasjonene i denne instruksjonsboken, har jeg tenkt å legge til flere etterhvert.

Foreløpig vil vi imidlertid programmere ditt typiske spill i 2048.

La oss komme i gang!

(Et sidebemerkning: Denne instruksen krever moderat kunnskap om programmering - spesielt med Java)

Trinn 1: Materialer

Du trenger ikke mye for dette prosjektet, ettersom det bare er en programmeringsgjennomgang.

Materialer:

• Laptop
• Formørkelse (eller hvilken som helst IDE etter eget valg)

Jepp. Det er det.

Trinn 2: Bli kjent med programmet - styret

Jeg lastet opp all koden min til GitHub - sjekk den ut her:

Jeg delte opp spillet i 3 klasser: Brett, flis og spill.

Borde:

Beskrivelse: Brettklassen tar for seg tavlen, setter opp en rekke "Tile" -elementer, får nåværende poengsum og høyeste flis, og legger matrisen i en streng (som skal brukes senere i "Game"). Mesteparten av logikken er også her, klassen tilbyr metoder for å gyte 2 og 4 på tilfeldige steder, bevege seg opp, ned, venstre og høyre, og gi spillerne beskjed når spillet er over.

Konstruktører:

/ * Standardkonstruktør for styret - setter opp en 4x4 -matrise */

offentlig styre () {…}

/ * Konstruktør for styret - setter opp en matrise med spesifisert rutenettstørrelse */

offentlig styre (int grids) {…}

Metoder:

/ * Getter -metode som returnerer brettet */

offentlig flis getBoard () {…}

/ * Getter -metode som returnerer poengsummen */

public int getScore () {…}

/ * Finner den høyeste flisen på brettet og returnerer den */

public int getHighTile () {…}

/ * Skriver ut brettet på konsollen - for testformål */

offentlig tomrom () {…}

/ * Returnerer brettet som en streng - brukt i GUI */

offentlig String toString () {…}

/ * Gyter en 2 (eller 4) på et tomt rom akkurat når et trekk blir gjort */

offentlig tomrom gyte () {…}

/ * Kontrollerer om brettet er helt mørkt, og hvis det er det, vil det presse spillerne til å starte på nytt */

offentlig boolsk blackOut () {…}

/ * Kontrollerer om spillet er over - når brettet er mørkt og ingen av brikkene kan kombineres */

offentlig boolsk gameOver () {…}

/ * Ringes når "w" eller pil opp trykkes - kaller "verticalMove" for hver flis på brettet med parameteren "opp" */

offentlig ugyldighet () {…}

/ * Ringes når du trykker på s eller pil ned - kaller "verticalMove" for hver flis på tavlen med parameteren "down" */public void down () {…}

/ * Ringes når du trykker på 'd' eller høyre pil - kaller 'horizontalMove' for hver flis på tavlen med parameteren 'høyre' */offentlig tomrom høyre () {…}

/ * Ringes når "a" eller venstre pil trykkes - kaller "horisontalflytt" for hver flis på tavlen med parameteren "venstre" */

offentlig tomrom igjen () {…}

/* Sammenligner to flisers verdier sammen, og hvis de er like eller hvis en er lik 0 (vanlig flis) - blir verdiene lagt til (forutsatt at flisene vi sammenligner er to forskjellige fliser og de beveger seg i riktig retning) - beveger seg rekursivt gjennom raden */

public void horizontalMove (int rad, int col, strengretning) {…}

/* Sammenligner to flisers verdier sammen, og hvis de er like eller hvis en er lik 0 (vanlig flis) - blir verdiene lagt til (forutsatt at flisene vi sammenligner er to forskjellige fliser og de beveger seg i riktig retning) - beveger seg rekursivt gjennom kolonnen */

public void verticalMove (int rad, int col, strengretning) {…}

Ja, det er mange metoder - men ikke bekymre deg, de fleste er ekstremt enkle å forstå. På toppen av det er 'Board' -klassen den mest komplekse, så alt etter dette vil være relativt enkelt.

Trinn 3: Bli kjent med programmet - Tile

Flis:

Beskrivelse: Tile -klassen omhandler de enkelte flisene, og er den minste av alle klassene. Hver flis har en heltallsverdi og en farge. Den har to konstruktører som lager fliser med verdi 0 (standard) eller verdi #. Metodene er for det meste selvforklarende, med 'getter' og 'setter' metoder som utgjør en hovedvekt av totalen.

Konstruktører:

/ * Konstruerer en grunnleggende flis med verdien 0 */

offentlig flis () {…}

/ * Konstruerer en flis med en verdi på tall */

offentlig flis (int nummer) {…}

Metoder:

/ * Får flisens verdi */

public int getValue () {…}

/ * Angir flisens verdi - brukes når to fliser legges sammen */

public void setValue (int -verdi) {…}

/ * Representerer flisen som en streng - brukt i GUI */

offentlig String toString () {…}

/ * Angir fargen på flisen basert på verdien */

public void setColor () {…}

/ * Får flisens farge */

public void getColor () {…}

Trinn 4: Bli kjent med programmet - spillet

Spill

Beskrivelse: Spillklassen inneholder hovedmetoden, de fleste GUI -metodene og nøkkelinteraksjonene. Den tar både flis- og brettklasser, og gjør dem i stand til å jobbe sammen.

Konstruktører:

Ingen

Metoder:

/ * setter opp GUI med passende størrelser og legger til en Key Listener */

offentlig statisk tomrom setUpGUI () {…}

/ * Kontrollerer om det trykkes på wasd- eller piltastene og utfører de riktige handlingene - oppdaterer JFrame for hvert trekk */

public void keyPressed (KeyEvent e) {…}

/ * Maler GUI med en rekke strenger, brettet, flisene og sørger for at de males om igjen når spillet er over */

offentlig tomrom (grafikk g) {…}

/ * tegner en individuell flis - kalt fra malingsmetoden */

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

/ * Hovedmetode - setter opp GUI og starter spillet */

offentlig statisk tomrom (String args) {…}

Trinn 5: Viktige metoder - bevegelse

Bevegelsesmetodene er de viktigste å forstå, men den gode nyheten er at når du forstår de vertikale bevegelsene, kan du bruke den forståelsen på de horisontale bevegelsene. Faktisk er de tre vertikale bevegelsesmetodene nøyaktig de samme som de tre horisontale metodebevegelsene, bortsett fra at en beveger seg over rader og den andre over kolonner. Av den grunn, la oss fokusere på bare de vertikale bevegelsesmetodene.

private void verticalMove (int rad, int col, strengretning)

{Tile initial = board [border] [col]; Flis sammenligne = brett [rad] [kol]; if (initial.getValue () == 0 || initial.getValue () == sammenligne.getValue ()) {if (rad> grense || (direction.equals ("ned") && (rad <kant))) {int addScore = initial.getValue () + compar.getValue (); if (initial.getValue ()! = 0) {score += addScore; } initial.setValue (addScore); compar.setValue (0); }} annet {if (direction.equals ("ned")) {border--; } annet {border ++; } verticalMove (rad, kol, retning); }}

Metoden ovenfor, verticalMove, kalles med "opp" og "ned" metodene. La oss ta en titt på "opp" -metoden.

offentlig ugyldighet ()

{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"); }}}}}

Denne metoden går gjennom hele brettet og kaller verticalMove for hver flis med parameteren "opp". verticalMove sammenligner deretter flisen i posisjon 'j' og 'i' med flisen i posisjonen 'border' og 'i'. Hvis de to er like, kombineres de. Hvis de ikke er det, økes kantflisen med 1 (ettersom parameteren på plass er 'opp'), og verticalMove kalles igjen.