Programmeer je eigen 2048-game met Java! - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:14

Door PranP1Mijn (onvolledige) siteVolg meer door de auteur:

Ik ben dol op het spel 2048. En dus besloot ik mijn eigen versie te programmeren.

Het lijkt erg op het eigenlijke spel, maar als ik het zelf programmeer, heb ik de vrijheid om te veranderen wat ik wil, wanneer ik maar wil. Als ik een 5x5-game wil in plaats van de typische 4x4, kan ik dit doen door een simpele wijziging met de 'Board'-constructer te doen. Stel dat ik het spel moeilijker wil maken door stukken toe te voegen op posities die het voor de speler het meest complex maken in plaats van willekeurig. Met een eenvoudig algoritme kan ik precies dat doen. Hoewel ik niet al deze wijzigingen in deze Instructable zal behandelen, ben ik van plan om er meer toe te voegen.

Voor nu zullen we echter je typische spel van 2048 programmeren.

Laten we beginnen!

(Een kanttekening: dit Instructable vereist matige kennis van programmeren - met name met Java)

Stap 1: Materialen

Je hebt niet veel nodig voor dit project, omdat het slechts een programmeerhandleiding is.

Materialen:

• laptop
• Eclipse (of een IDE naar keuze)

JEP. Dat is het.

Stap 2: Leer het programma kennen - Board

Ik heb al mijn code geüpload naar GitHub - bekijk het hier:

Ik heb het spel opgedeeld in 3 klassen: Bord, Tegel en Spel.

Bord:

Beschrijving: De klasse Bord houdt zich bezig met het spelbord, het opzetten van een reeks 'Tegel'-elementen, het verkrijgen van de huidige score en de hoogste tegel, en het plaatsen van de reeks in een string (die later in 'Spel' wordt gebruikt). De meeste logica is ook hier, de klasse biedt methoden voor het spawnen van 2's en 4's op willekeurige locaties, omhoog, omlaag, links en rechts, en laat spelers weten wanneer het spel voorbij is.

Constructeurs:

/* Standaardconstructor voor het bord - stelt een 4x4-matrix in */

openbaar bestuur() {…}

/* Constructor voor het bord - stelt een matrix op met gespecificeerde rastergrootte */

openbaar bestuur (int grids) {…}

Methoden:

/* Getter-methode die het bord retourneert */

openbare tegel getBoard() {…}

/* Getter-methode die de score retourneert */

openbare int getScore() {…}

/* Vindt de hoogste tegel op het bord en geeft deze terug */

public int getHighTile() {…}

/* Drukt het bord af op de console - voor testdoeleinden */

public void print() {…}

/* Geeft het bord terug als een string - gebruikt in de GUI */

public String toString() {…}

/* Spawnt een 2 (of 4) op een lege plek op het moment dat een zet wordt gedaan */

public void spawn() {…}

/* Controleert of het bord volledig zwart is en als dat zo is, zal het de spelers aansporen om opnieuw op te starten */

openbare boolean blackOut() {…}

/* Controleert of het spel voorbij is - wanneer het bord zwart is en geen van de tegels kan worden gecombineerd */

openbare booleaanse gameOver() {…}

/* Wordt aangeroepen wanneer 'w' of pijl-omhoog wordt ingedrukt - roept 'verticalMove' aan voor elke tegel op het bord met parameter 'up' */

openbare leegte() {…}

/* Wordt aangeroepen wanneer 's' of pijl-omlaag wordt ingedrukt - roept 'verticalMove' aan voor elke tegel op het bord met parameter 'down' */public void down() {…}

/* Wordt aangeroepen wanneer 'd' of pijl naar rechts wordt ingedrukt - roept 'horizontalMove' aan voor elke tegel op het bord met parameter 'right' */public void right() {…}

/* Wordt aangeroepen wanneer 'a' of pijl naar links wordt ingedrukt - roept 'horizontalMove' aan voor elke tegel op het bord met parameter 'left' */

openbare leegte left() {…}

/* Vergelijkt de waarden van twee tegels met elkaar en als ze hetzelfde zijn of als één gelijk is aan 0 (gewone tegel) - hun waarden worden opgeteld (op voorwaarde dat de tegels die we vergelijken twee verschillende tegels zijn en in de juiste richting bewegen) - beweegt recursief door de rij */

public void horizontalMove (int rij, int col, String richting) {…}

/* Vergelijkt de waarden van twee tegels met elkaar en als ze hetzelfde zijn of als één gelijk is aan 0 (gewone tegel) - hun waarden worden opgeteld (op voorwaarde dat de tegels die we vergelijken twee verschillende tegels zijn en in de juiste richting bewegen) - beweegt recursief door de kolom */

public void verticalMove (int rij, int col, String richting) {…}

Ja, dat zijn veel methoden - maar maak je geen zorgen, de meeste zijn extreem gemakkelijk te begrijpen. Bovendien is de klasse 'Board' het meest complex, dus alles hierna zal relatief eenvoudig zijn.

Stap 3: Leer het programma kennen - Tile

Tegel:

Beschrijving: De klasse Tile behandelt de afzonderlijke tegels en is de kleinste van alle klassen. Elke tegel heeft een geheel getal en een kleur. Het heeft twee constructors die tegels met waarde 0 (standaard) of waarde # maken. De methoden spreken meestal voor zich, waarbij 'getter'- en 'setter'-methoden een groot deel van het totaal uitmaken.

Constructeurs:

/* Construeert een basistegel met een waarde van 0 */

openbare tegel() {…}

/* Construeert een tegel met een waarde van nummer */

openbare tegel (int nummer) {…}

Methoden:

/* Haalt de waarde van de tegel op */

openbare int getValue() {…}

/* Stelt de waarde van de tegel in - gebruikt bij het optellen van twee tegels bij elkaar */

public void setValue (int waarde) {…}

/* Geeft de tegel weer als een tekenreeks - gebruikt in de GUI */

public String toString() {…}

/* Stelt de kleur van de tegel in op basis van zijn waarde */

public void setColor() {…}

/* Krijgt de kleur van de tegel */

public void getColor() {…}

Stap 4: Leer het programma kennen - Game

Spel

Beschrijving: De Game Class bevat de hoofdmethode, de meeste GUI-methoden en de belangrijkste interacties. Het neemt zowel de Tile- als Board-klassen en stelt ze in staat om samen te werken.

Constructeurs:

Geen

Methoden:

/* stelt de GUI in met de juiste formaten en voegt een Key Listener toe */

openbare statische leegte setUpGUI() {…}

/* Controleert of wasd- of pijltoetsen zijn ingedrukt en voert de juiste acties uit - werkt het JFrame bij elke beweging bij */

openbare ongeldige toets ingedrukt (KeyEvent e) {…}

/* Schildert de GUI met een reeks strings, het bord, de tegels en zorgt ervoor dat ze opnieuw worden geverfd wanneer het spel voorbij is */

openbare leegte verf (Graphics g) {…}

/* tekent een individuele tegel - aangeroepen vanuit de verfmethode */

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

/* Hoofdmethode - stelt de GUI in en start het spel */

public static void main(String args) {…}

Stap 5: Belangrijke methoden - beweging

De bewegingsmethoden zijn het belangrijkst om te begrijpen, maar het goede nieuws is dat als je eenmaal de verticale bewegingen begrijpt, je dat begrip kunt toepassen op de horizontale bewegingen. In feite zijn de drie verticale verplaatsingsmethoden exact hetzelfde als de drie horizontale verplaatsingen, behalve dat de ene over rijen en de andere over kolommen beweegt. Laten we ons daarom concentreren op alleen de verticale bewegingsmethoden.

private void verticalMove(int row, int col, String richting)

{ Tegel initiaal = bord [rand][col]; Tegel vergelijken = bord[rij][col]; if (initial.getValue() == 0 || initial.getValue() == Compare.getValue()) { if (rij > border || (direction.equals("down") && (rij < border))) { int addScore = initial.getValue() + Compare.getValue(); if (initial.getValue() != 0) {score += addScore; } initial.setValue(addScore); vergelijk.setValue(0); } } else { if (direction.equals("down")) { border--; } anders { grens++; } verticalMove(rij, kolom, richting); } }

De bovenstaande methode, verticalMove, wordt aangeroepen door de 'up' en 'down' methoden. Laten we eens kijken naar de 'up'-methode.

openbare leegte()

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

Deze methode gaat door het hele bord en roept verticalMove aan voor elke tegel met de parameter "up". verticalMove vergelijkt vervolgens de tegel op positie 'j' en 'i' met de tegel op positie 'border' en 'i'. Als de twee gelijk zijn, worden ze gecombineerd. Als dat niet het geval is, wordt de grenstegel met 1 verhoogd (omdat de parameter 'omhoog' is), en wordt verticalMove opnieuw aangeroepen.