Programmer dit eget 2048 -spil med Java !: 8 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:25

Af PranP1My (Ufuldstændig) SiteFollow Mere af forfatteren:

Jeg elsker spillet 2048. Og derfor besluttede jeg mig for at programmere min egen version.

Det ligner meget det egentlige spil, men selv at programmere det giver mig frihed til at ændre, hvad jeg vil, når jeg vil. Hvis jeg vil have et 5x5 -spil i stedet for det typiske 4x4, vil en simpel ændring ved hjælp af 'Board' -konstruktionen tillade mig at gøre det. Sig, at jeg vil gøre spillet vanskeligere og tilføje brikker på positioner, der vil gøre det mest komplekst for spilleren frem for tilfældigt. Ved hjælp af en simpel algoritme kan jeg gøre netop det. Selvom jeg ikke vil dække alle disse ændringer i denne Instructable, har jeg planer om at tilføje flere, efterhånden som jeg går.

For nu programmerer vi dog dit typiske spil i 2048.

Lad os komme igang!

(En sidebemærkning: Denne instruktør kræver moderat kendskab til programmering - specifikt med Java)

Trin 1: Materialer

Du behøver ikke meget til dette projekt, da det bare er en programmeringsgennemgang.

Materialer:

• Bærbar
• Eclipse (eller enhver IDE efter eget valg)

Jep. Det er det.

Trin 2: Lær programmet at kende - bestyrelsen

Jeg uploadede al min kode til GitHub - tjek den her:

Jeg opdelte spillet i 3 klasser: Board, Tile og Game.

Bestyrelse:

Beskrivelse: Board -klassen beskæftiger sig med tavlen, opsætning af en matrix med 'Tile' -elementer, at få den aktuelle score og den højeste flise og sætte arrayet i en streng (skal bruges senere i' Game '). Det meste af logikken er også her, klassen giver metoder til at gyde 2'er og 4'er på tilfældige steder, bevæge sig op, ned, til venstre og højre og lade spillere vide, når spillet er slut.

Konstruktører:

/ * Standardkonstruktør til bestyrelsen - opsætter en 4x4 -matrix */

offentligt bestyrelse () {…}

/ * Konstruktør til bestyrelsen - opsætter en matrix med specificeret netstørrelse */

offentligt bestyrelse (int grids) {…}

Metoder:

/ * Getter -metode, der returnerer tavlen */

offentlig flise getBoard () {…}

/ * Getter -metode, der returnerer scoren */

public int getScore () {…}

/ * Finder den højeste flise på tavlen og returnerer den */

public int getHighTile () {…}

/ * Udskriver tavlen på konsollen - til testformål */

offentligt tomrumsudskrivning () {…}

/ * Returnerer tavlen som en streng - brugt i GUI */

public String toString () {…}

/ * Gyder en 2 (eller 4) på et tomt sted, meget meget der flyttes */

offentligt tomrum () {…}

/ * Kontrollerer, om brættet er helt sort, og hvis det er, vil det skubbe spillerne til at genstarte */

offentlig boolsk blackOut () {…}

/ * Kontrollerer, om spillet er slut - når brættet er mørklagt, og ingen af fliserne kan kombineres */

offentligt boolsk gameOver () {…}

/ * Opkaldes, når der trykkes på 'w' eller pil op - kalder 'verticalMove' for hver flise på tavlen med parameteren 'up' */

offentligt ugyldigt () {…}

/ * Opkaldes, når der trykkes på 's' eller pil ned - kalder 'verticalMove' for hver flise på tavlen med parameteren 'ned' */offentlig tomrum ned () {…}

/ * Opkaldes, når der trykkes på 'd' eller højre pil - kalder 'horizontalMove' for hver flise på tavlen med parameteren 'højre' */public void right () {…}

/ * Opkaldes, når der trykkes på 'a' eller venstre pil - kalder 'vandret bevægelse' for hver flise på tavlen med parameteren 'venstre' */

offentligt tomrum tilbage () {…}

/* Sammenligner værdier af to fliser sammen, og hvis de er ens, eller hvis en er lig med 0 (almindelig flise) - tilføjes deres værdier (forudsat at de fliser, vi sammenligner, er to forskellige fliser, og de bevæger sig i den rigtige retning) - bevæger sig rekursivt gennem rækken */

public void horizontalMove (int række, int col, strengretning) {…}

/* Sammenligner værdier af to fliser sammen, og hvis de er ens, eller hvis en er lig med 0 (almindelig flise) - tilføjes deres værdier (forudsat at de fliser, vi sammenligner, er to forskellige fliser, og de bevæger sig i den rigtige retning) - bevæger sig rekursivt gennem kolonnen */

public void verticalMove (int række, int col, strengretning) {…}

Ja, det er mange metoder - men bare rolig, de fleste er ekstremt lette at forstå. Oven i det er 'Board' -klassen den mest komplekse, så alt efter dette vil være relativt enkelt.

Trin 3: Lær programmet at kende - flise

Flise:

Beskrivelse: Tile -klassen omhandler de enkelte fliser og er den mindste af alle klasser. Hver flise har en heltalværdi og en farve. Det har to konstruktører, der opretter fliser af værdi 0 (standard) eller værdi #. Metoderne er for det meste selvforklarende, idet 'getter' og 'setter' metoder udgør en hovedpart af totalen.

Konstruktører:

/ * Konstruerer en grundlæggende flise med en værdi på 0 */

offentlig flise () {…}

/ * Konstruerer en flise med en værdi på tal */

offentlig flise (int -nummer) {…}

Metoder:

/ * Får flisens værdi */

public int getValue () {…}

/ * Indstiller flisens værdi - bruges når to fliser lægges sammen */

public void setValue (int -værdi) {…}

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

public String toString () {…}

/ * Indstiller flisens farve baseret på dens værdi */

public void setColor () {…}

/ * Får flisens farve */

public void getColor () {…}

Trin 4: Lær programmet - spil at kende

Spil

Beskrivelse: Spilleklassen rummer hovedmetoden, de fleste GUI -metoder og nøgleinteraktionerne. Det tager både flise- og bordklasser, og gør det muligt for dem at arbejde sammen.

Konstruktører:

Ingen

Metoder:

/ * konfigurerer GUI'en med passende størrelser og tilføjer en Key Listener */

offentligt statisk tomrum setUpGUI () {…}

/ * Kontrollerer, om der trykkes på wasd- eller piletasterne og udfører de relevante handlinger - opdaterer JFrame med hvert træk */

public void keyPressed (KeyEvent e) {…}

/ * Maler GUI'en med en række strenge, brættet, fliserne og sikrer, at de males om, når spillet er slut */

offentlig tomrumsmaling (grafik g) {…}

/ * tegner en individuel flise - kaldet fra malingsmetoden */

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

/ * Hovedmetode - konfigurerer GUI og starter spillet */

public static void main (String args) {…}

Trin 5: Vigtige metoder - Bevægelse

Bevægelsesmetoderne er de vigtigste at forstå, men den gode nyhed er, at når du forstår de lodrette bevægelser, kan du anvende denne forståelse på de vandrette bevægelser. Faktisk er de tre lodrette bevægelsesmetoder nøjagtigt de samme som de tre vandrette metodebevægelser, undtagen at den ene bevæger sig på tværs af rækker og den anden på tværs af kolonner. Af den grund, lad os fokusere på kun de lodrette bevægelsesmetoder.

private void verticalMove (int række, int col, strengretning)

{Tile initial = board [border] [col]; Flise sammenligne = bræt [række] [kol]; hvis (initial.getValue () == 0 || initial.getValue () == sammenligne.getValue ()) {if (række> grænse || (retning.equals ("ned") && (række <grænse))) {int addScore = initial.getValue () + sammenlign.getValue (); hvis (initial.getValue ()! = 0) {score += addScore; } initial.setValue (addScore); sammenlign.setValue (0); }} andet {if (direction.equals ("ned")) {border--; } andet {border ++; } verticalMove (række, kol, retning); }}

Ovenstående metode, verticalMove, kaldes med 'op' og 'ned' metoderne. Lad os tage et kig på 'op' -metoden.

offentligt tomrum op ()

{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 metode går gennem hele tavlen og kalder verticalMove for hver flise med parameteren "op". verticalMove sammenligner derefter flisen i position 'j' og 'i' med flisen i positionen 'border' og 'i'. Hvis de to er lige, kombineres de. Hvis de ikke er det, øges kantflisen med 1 (da parameteren på plads er 'op'), og verticalMove kaldes igen.