Programmez votre propre jeu 2048 avec Java ! : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Par PranP1My (incomplet) SiteFollow Plus par l'auteur:

J'adore le jeu 2048. J'ai donc décidé de programmer ma propre version.

C'est très similaire au jeu réel, mais le programmer moi-même me donne la liberté de changer ce que je veux quand je le veux. Si je veux un jeu 5x5 au lieu du 4x4 typique, un simple changement à l'aide du constructeur 'Board' me permettra de le faire. Disons que je veux rendre le jeu plus difficile, en ajoutant des pièces à des positions qui le rendront plus complexe pour le joueur plutôt qu'au hasard. En utilisant un algorithme simple, je peux faire exactement cela. Bien que je ne couvrirai pas toutes ces modifications dans ce Instructable, je prévois d'en ajouter d'autres au fur et à mesure.

Pour l'instant, cependant, nous allons programmer votre jeu typique de 2048.

Commençons!

(Une note latérale: ce Instructable nécessite une connaissance modérée de la programmation - en particulier avec Java)

Étape 1: Matériaux

Vous n'aurez pas besoin de grand-chose pour ce projet car il ne s'agit que d'une procédure pas à pas de programmation.

Matériaux:

• Portable
• Eclipse (ou n'importe quel IDE de votre choix)

Ouais. C'est ça.

Étape 2: Familiarisez-vous avec le programme - Conseil d'administration

J'ai téléchargé tout mon code sur GitHub - consultez-le ici:

J'ai divisé le jeu en 3 classes: Plateau, Tuile et Jeu.

Planche:

Description: La classe Board traite du plateau de jeu, configure un tableau d'éléments 'Tile', obtient le score actuel et la tuile la plus élevée, et met le tableau dans une chaîne (à utiliser plus tard dans 'Game'). La majeure partie de la logique est également présente, la classe fournissant des méthodes pour générer des 2 et des 4 à des emplacements aléatoires, se déplacer vers le haut, le bas, la gauche et la droite, et informer les joueurs lorsque le jeu est terminé.

Constructeurs:

/* Constructeur par défaut pour la carte - configure une matrice 4x4 */

Conseil public() {…}

/* Constructeur pour la carte - configure une matrice avec une taille de grille spécifiée */

Conseil public (grilles int) {…}

Méthodes:

/* Méthode Getter qui renvoie la carte */

public Tile getBoard() {…}

/* Méthode Getter qui renvoie le score */

public int getScore() {…}

/* Trouve la tuile la plus haute du plateau et la renvoie */

public int getHighTile() {…}

/* Imprime la carte sur la console - à des fins de test */

impression vide publique () {…}

/* Renvoie la carte sous forme de chaîne - utilisée dans l'interface graphique */

chaîne publique toString() {…}

/* Génère un 2 (ou 4) sur une case vide à chaque fois qu'un mouvement est effectué */

spawn du vide public () {…}

/* Vérifie si le tableau est complètement noirci et si c'est le cas, il poussera les joueurs à redémarrer */

public booléen blackOut() {…}

/* Vérifie si le jeu est terminé - lorsque le plateau est noirci et qu'aucune des tuiles ne peut se combiner */

public booléen gameOver() {…}

/* Appelé lorsque 'w' ou la flèche vers le haut est enfoncée - appelle 'verticalMove' pour chaque tuile du plateau avec le paramètre 'up' */

annulation publique () {…}

/* Appelé lorsque 's' ou la flèche vers le bas est enfoncée - appelle 'verticalMove' pour chaque tuile du tableau avec le paramètre 'down' */public void down() {…}

/* Appelé lorsque 'd' ou la flèche droite est enfoncée - appelle 'horizontalMove' pour chaque tuile du tableau avec le paramètre 'right' */public void right() {…}

/* Appelé lorsque 'a' ou la flèche gauche est enfoncée - appelle 'horizontalMove' pour chaque tuile du plateau avec le paramètre 'left' */

vide public à gauche () {…}

/* Compare les valeurs de deux tuiles ensemble et si elles sont identiques ou si l'une est égale à 0 (tuile simple) - leurs valeurs sont ajoutées (à condition que les tuiles que nous comparons soient deux tuiles différentes et qu'elles se déplacent vers la direction appropriée) - se déplace récursivement dans la ligne */

public void horizontalMove (int row, int col, direction de la chaîne) {…}

/* Compare les valeurs de deux tuiles ensemble et si elles sont identiques ou si l'une est égale à 0 (tuile simple) - leurs valeurs sont ajoutées (à condition que les tuiles que nous comparons soient deux tuiles différentes et qu'elles se déplacent vers la direction appropriée) - se déplace récursivement dans la colonne */

public void verticalMove (int row, int col, direction de la chaîne) {…}

Oui, cela fait beaucoup de méthodes - mais ne vous inquiétez pas, la plupart sont extrêmement faciles à comprendre. En plus de cela, la classe 'Board' est la plus complexe, donc tout ce qui suit sera relativement simple.

Étape 3: Familiarisez-vous avec le programme - Tile

Tuile:

Description: La classe Tile traite les tuiles individuelles et est la plus petite de toutes les classes. Chaque tuile a une valeur entière et une couleur. Il a deux constructeurs qui créent des tuiles de valeur 0 (par défaut) ou de valeur #. Les méthodes sont pour la plupart explicites, les méthodes « getter » et « setter » constituant la majeure partie du total.

Constructeurs:

/* Construit une tuile de base avec une valeur de 0 */

tuile publique() {…}

/* Construit une tuile avec une valeur de nombre */

tuile publique (nombre entier) {…}

Méthodes:

/* Récupère la valeur de la tuile */

public int getValue() {…}

/* Définit la valeur de la tuile - utilisé lors de l'ajout de deux tuiles ensemble */

public void setValue (int value) {…}

/* Représente la vignette sous forme de chaîne - utilisée dans l'interface graphique */

chaîne publique toString() {…}

/* Définit la couleur de la tuile en fonction de sa valeur */

public void setColor() {…}

/* Récupère la couleur de la tuile */

public void getColor() {…}

Étape 4: Familiarisez-vous avec le programme - Jeu

Jeu

Description: la classe de jeu héberge la méthode principale, la plupart des méthodes de l'interface graphique et les interactions clés. Il prend à la fois les classes Tile et Board et leur permet de travailler ensemble.

Constructeurs:

Rien

Méthodes:

/* configure l'interface graphique avec des tailles appropriées et ajoute un écouteur de clé */

public statique vide setUpGUI() {…}

/* Vérifie si les touches wasd ou fléchées sont enfoncées et effectue les actions appropriées - met à jour le JFrame à chaque mouvement */

Public void keyPressed (KeyEvent e) {…}

/* Peint l'interface graphique avec une série de chaînes, le plateau, les tuiles et s'assure qu'elles sont repeintes lorsque le jeu est terminé */

peinture vide public (Graphiques g) {…}

/* dessine une tuile individuelle - appelée à partir de la méthode paint */

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

/* Méthode principale - configure l'interface graphique et démarre le jeu */

public static void main(String args) {…}

Étape 5: Méthodes importantes - Mouvement

Les méthodes de mouvement sont les plus importantes à comprendre, mais la bonne nouvelle est qu'une fois que vous avez compris les mouvements verticaux, vous pouvez appliquer cette compréhension aux mouvements horizontaux. En fait, les trois méthodes de déplacement vertical sont exactement les mêmes que les trois méthodes de déplacement horizontal, sauf que l'une se déplace sur les lignes et l'autre sur les colonnes. Pour cette raison, concentrons-nous uniquement sur les méthodes de mouvement vertical.

private void verticalMove(int row, int col, direction de la chaîne)

{ Tile initial = board[border][col]; Comparaison de tuiles = board[row][col]; if (initial.getValue() == 0 || initial.getValue() == compare.getValue()) { if (ligne > bordure || (direction.equals("bas") && (ligne < bordure))) { int addScore = initial.getValue() + compare.getValue(); if (initial.getValue() != 0) { score += addScore; } initial.setValue(addScore); compare.setValue(0); } } else { if (direction.equals("bas")) { border--; } else { border++; } verticalMove(ligne, col, direction); } }

La méthode ci-dessus, verticalMove, est appelée par les méthodes 'up' et 'down'. Jetons un coup d'œil à la méthode 'up'.

annulation publique ()

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

Cette méthode parcourt l'ensemble du tableau et appelle verticalMove pour chaque tuile avec le paramètre "up". verticalMove compare ensuite la tuile aux positions 'j' et 'i' avec la tuile aux positions 'border' et 'i'. Si les deux sont égaux, ils sont combinés. Si ce n'est pas le cas, la tuile de bordure est augmentée de 1 (car le paramètre en place est 'up'), et verticalMove est appelé à nouveau.