Programmieren Sie Ihr eigenes 2048-Spiel mit Java! - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Von PranP1My (Unvollständig) SiteFollow More vom Autor:

Ich liebe das Spiel 2048. Und so beschloss ich, meine eigene Version zu programmieren.

Es ist dem eigentlichen Spiel sehr ähnlich, aber es selbst zu programmieren gibt mir die Freiheit, zu ändern, was ich will, wann immer ich will. Wenn ich ein 5x5-Spiel anstelle des typischen 4x4-Spiels haben möchte, kann ich dies durch eine einfache Änderung mit dem Konstrukteur "Board" tun. Sagen wir, ich möchte das Spiel schwieriger machen, indem ich Stücke an Positionen hinzufüge, die es für den Spieler am komplexesten machen, anstatt zufällig. Mit einem einfachen Algorithmus kann ich genau das tun. Während ich nicht alle diese Änderungen in diesem Instructable abdecken werde, plane ich, mehr hinzuzufügen, während ich gehe.

Vorerst programmieren wir jedoch Ihr typisches Spiel von 2048.

Lass uns anfangen!

(Eine Randnotiz: Dieses Instructable erfordert moderate Programmierkenntnisse - insbesondere mit Java)

Schritt 1: Materialien

Für dieses Projekt benötigen Sie nicht viel, da es sich nur um eine exemplarische Programmierung handelt.

Materialien:

• Laptop
• Eclipse (oder eine beliebige IDE Ihrer Wahl)

Jep. Das ist es.

Schritt 2: Lernen Sie das Programm kennen - Vorstand

Ich habe meinen gesamten Code auf GitHub hochgeladen - schau es dir hier an:

Ich habe das Spiel in 3 Klassen unterteilt: Board, Tile und Game.

Planke:

Beschreibung: Die Board-Klasse befasst sich mit dem Spielbrett, indem sie ein Array von 'Kacheln'-Elementen erstellt, den aktuellen Punktestand und das höchste Plättchen erhält und das Array in eine Reihe legt (wird später in 'Spiel' verwendet). Die meiste Logik ist auch hier, die Klasse bietet Methoden zum Spawnen von 2en und 4en an zufälligen Orten, sich nach oben, unten, links und rechts zu bewegen und die Spieler wissen zu lassen, wenn das Spiel vorbei ist.

Konstrukteure:

/* Standardkonstruktor für das Board - richtet eine 4x4-Matrix ein */

öffentliches Forum() {…}

/* Konstruktor für das Board - erstellt eine Matrix mit angegebener Rastergröße */

öffentliches Board (int grids) {…}

Methoden:

/* Getter-Methode, die das Board zurückgibt */

öffentliche Kachel getBoard() {…}

/* Getter-Methode, die die Punktzahl zurückgibt */

public int getScore() {…}

/* Findet das höchste Plättchen auf dem Brett und gibt es zurück */

public int getHighTile() {…}

/* Gibt das Board auf die Konsole aus - zu Testzwecken */

public void print() {…}

/* Gibt das Board als String zurück - wird in der GUI verwendet */

öffentlicher String toString() {…}

/* Spawnt eine 2 (oder 4) an einem leeren Feld, sobald ein Zug gemacht wird */

öffentliche Leere spawn() {…}

/* Überprüft, ob das Board komplett verdunkelt ist und wenn dies der Fall ist, werden die Spieler dazu gebracht, neu zu starten */

public boolean blackOut() {…}

/* Überprüft, ob das Spiel vorbei ist - wenn das Brett verdunkelt ist und keines der Steine kombiniert werden kann */

public boolean gameOver() {…}

/* Wird aufgerufen, wenn 'w' oder Pfeil nach oben gedrückt wird - ruft 'vertikalMove' für jede Kachel auf dem Board mit Parameter 'up' auf */

public void up() {…}

/* Wird aufgerufen, wenn 's' oder Pfeil nach unten gedrückt wird - ruft 'vertikalMove' für jede Kachel auf dem Board mit Parameter 'down' auf */public void down() {…}

/* Wird aufgerufen, wenn 'd' oder Pfeil nach rechts gedrückt wird - ruft 'horizontalMove' für jede Kachel auf dem Board mit Parameter 'right' auf */public void right() {…}

/* Wird aufgerufen, wenn 'a' oder Pfeil nach links gedrückt wird - ruft 'horizontalMove' für jede Kachel auf dem Board mit Parameter 'left' auf */

öffentliche Leere links() {…}

/* Vergleicht die Werte zweier Kacheln miteinander und wenn sie gleich sind oder einer gleich 0 ist (einfache Kachel) - werden ihre Werte addiert (vorausgesetzt, die von uns verglichenen Kacheln sind zwei verschiedene Kacheln und bewegen sich in die entsprechende Richtung) - bewegt sich rekursiv durch die Zeile */

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

/* Vergleicht die Werte zweier Kacheln miteinander und wenn sie gleich sind oder einer gleich 0 ist (einfache Kachel) - werden ihre Werte addiert (vorausgesetzt, die von uns verglichenen Kacheln sind zwei verschiedene Kacheln und bewegen sich in die entsprechende Richtung) - bewegt sich rekursiv durch die Spalte */

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

Ja, das sind viele Methoden - aber keine Sorge, die meisten sind extrem einfach zu verstehen. Darüber hinaus ist die Klasse 'Board' die komplexeste, daher wird alles danach relativ einfach sein.

Schritt 3: Lernen Sie das Programm kennen - Tile

Fliese:

Beschreibung: Die Kachelklasse befasst sich mit den einzelnen Kacheln und ist die kleinste aller Klassen. Jede Kachel hat einen ganzzahligen Wert und eine Farbe. Es hat zwei Konstruktoren, die Kacheln mit dem Wert 0 (Standard) oder dem Wert # erstellen. Die Methoden sind größtenteils selbsterklärend, wobei „Getter“- und „Setter“-Methoden einen Großteil der Gesamtheit ausmachen.

Konstrukteure:

/* Konstruiert eine Basiskachel mit dem Wert 0 */

öffentliche Kachel() {…}

/* Konstruiert eine Kachel mit dem Wert Zahl */

öffentliche Kachel (int-Nummer) {…}

Methoden:

/* Ruft den Wert der Kachel ab */

public int getValue() {…}

/* Setzt den Wert der Kachel - wird verwendet, wenn zwei Kacheln zusammengezählt werden */

public void setValue (int-Wert) {…}

/* Stellt die Kachel als String dar - wird in der GUI verwendet */

öffentlicher String toString() {…}

/* Setzt die Farbe der Kachel basierend auf ihrem Wert */

public void setColor() {…}

/* Ruft die Farbe der Kachel ab */

public void getColor() {…}

Schritt 4: Lernen Sie das Programm kennen - Spiel

Spiel

Beschreibung: Die Game-Klasse enthält die Hauptmethode, die meisten GUI-Methoden und die Key-Interaktionen. Es benötigt sowohl die Tile- als auch die Board-Klasse und ermöglicht es ihnen, zusammenzuarbeiten.

Konstrukteure:

Keiner

Methoden:

/* richtet die GUI mit geeigneten Größen ein und fügt einen Key Listener hinzu */

public static void setUpGUI() {…}

/* Prüft, ob wasd- oder Pfeiltasten gedrückt sind und führt die entsprechenden Aktionen aus - aktualisiert den JFrame bei jeder Bewegung */

public void keyPressed (KeyEvent e) {…}

/* Bemalt die GUI mit einer Reihe von Strings, dem Board, den Kacheln und sorgt dafür, dass sie nach dem Spiel neu gemalt werden */

öffentliche Leere Farbe (Grafik g) {…}

/* zeichnet eine einzelne Kachel - aufgerufen von der Paint-Methode */

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

/* Main-Methode - richtet die GUI ein und startet das Spiel */

public static void main(String args) {…}

Schritt 5: Wichtige Methoden - Bewegung

Die Bewegungsmethoden sind am wichtigsten zu verstehen, aber die gute Nachricht ist, dass Sie, sobald Sie die vertikalen Bewegungen verstanden haben, dieses Verständnis auf die horizontalen Bewegungen anwenden können. Tatsächlich sind die drei vertikalen Bewegungsmethoden genau die gleichen wie die drei horizontalen Methodenbewegungen, außer dass sich eine über Zeilen und die andere über Spalten bewegt. Aus diesem Grund konzentrieren wir uns nur auf die vertikalen Bewegungsmethoden.

private void verticalMove(int row, int col, string direction)

{ Tile initial = board[border][col]; Kachelvergleich = board[row][col]; if (initial.getValue() == 0 || initial.getValue() == Compare.getValue()) { if (row > border || (direction.equals("down") && (row < border))) { int addScore = initial.getValue() + vergleichen.getValue(); if (initial.getValue() != 0) { score += addScore; } initial.setValue(addScore); vergleiche.setValue(0); } } else { if (direction.equals("down")) { border--; } sonst { Grenze++; } VerticalMove(Zeile, Spalte, Richtung); } }

Die obige Methode, verticalMove, wird von den Methoden 'up' und 'down' aufgerufen. Werfen wir einen Blick auf die 'up'-Methode.

öffentliche Leere nach oben()

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

Diese Methode durchläuft das gesamte Board und ruft VerticalMove für jede Kachel mit dem Parameter "up" auf. VerticalMove vergleicht dann die Kachel an Position 'j' und 'i' mit der Kachel an Position 'border' und 'i'. Sind beide gleich, werden sie kombiniert. Ist dies nicht der Fall, wird die Rahmenkachel um 1 erhöht (da der Parameter 'up' ist) und verticalMove wird erneut aufgerufen.