Section jeux sur CodeGym : Moteur de jeu

"Jeux" de CodeGym est une nouvelle section avec de grandes tâches qui impliquent l'écriture de jeux informatiques populaires. Ils sont plus faciles à créer qu'il n'y paraît : chaque projet est divisé en vingt sous-tâches. En accomplissant les tâches étape par étape, vous écrirez votre propre jeu, puis vous pourrez ajouter des fonctionnalités uniques et le partager avec des amis. Les jeux utilisent le moteur de jeu simple CodeGym . Dans cet article, nous décrirons ses principales caractéristiques et à quoi ressemble le processus d'écriture du jeu.

1. Introduction

Pour le développeur, il y a trois étapes à la mise en place d'un jeu vidéo :

1. Initialisation du jeu - Cette étape consiste en des actions préparatoires : définir la taille du terrain de jeu, dessiner le terrain de jeu, créer des objets de jeu et les placer dans leurs positions initiales, et d'autres actions qui doivent être effectuées au début du jeu.

2. Processus de jeu. Cette étape comprend le déplacement d'objets de jeu, les actions du joueur, le suivi du score et d'autres actions qui doivent être effectuées à une certaine fréquence ou lorsque des boutons sont enfoncés.

3. Achèvement du jeu. Cette étape comprend l'arrêt de l'animation, le signalement d'une victoire ou d'une défaite et d'autres actions qui doivent être effectuées à la fin de la partie.

2. Initialisation du jeu

L'initialisation du jeu consiste en seulement deux étapes : Étape 1 : Créez la classe principale du jeu. Pour développer votre propre jeu à l'aide du moteur de jeu CodeGym, vous devez créer une classe qui hérite de la Gameclasse (com.codegym.engine.cell.Game). Cela donne à votre classe la possibilité d'appeler les méthodes du moteur de jeu et donne au moteur la possibilité d'appeler vos méthodes. Par exemple:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Étape 2 : remplacez la méthode d'initialisation(). Toutes les actions requises pour démarrer le jeu se produiront dans cette méthode : création du terrain de jeu, création des objets du jeu, etc. Il suffit de déclarer cette méthode dans la classe qui hérite de la Gameclasse. Par exemple:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
        // Here we perform all actions to initialize the game and its objects
    }
}

La initialize()méthode est analogue à la main()méthode : c'est le point de départ de tout le code écrit pour le jeu.

3. Créer un terrain de jeu

La création d'un terrain de jeu se compose également de seulement deux étapes. Étape 1 : Divisez le terrain de jeu en cellules. L'ensemble du terrain de jeu est divisé en cellules par le moteur de jeu. La taille minimale est de 3 x 3 ; le maximum est 100x100. Les dimensions de l'écran de jeu sont constantes. Il peut être divisé en différents nombres de cellules. Par exemple, 7 cellules de largeur sur 9 cellules de hauteur : notez que les cellules sont numérotées à partir du coin supérieur gauche. Pour définir la taille du terrain de jeu, utilisez la void setScreenSize(int width, int height)méthode. Il définit la taille du terrain de jeu. Ses paramètres représentent le nombre de cellules horizontalement (largeur) et verticalement (hauteur). Il est généralement appelé une fois au démarrage du jeu. Par exemple:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
       // Set the field size to 7 cells x 9 cells
       setScreenSize(7, 9);
        ...
    }
}

Lors de l'écriture d'un jeu, vous devrez peut-être obtenir la largeur et la hauteur actuelles du terrain de jeu. Pour ce faire, les méthodes int getScreenWidth()et int getScreenHeight()vous seront utiles. Étape 2 : Activez ou désactivez la grille (facultatif). Si vous n'aimez pas la grille noire séparant les cellules sur le terrain de jeu, vous pouvez la désactiver. La void showGrid(boolean isShow)méthode active et désactive la grille. Par défaut, la grille est affichée. Pour le désactiver, appelez cette méthode avec false comme argument :

showGrid(false);

Résultat : Pour réactiver la grille, appelez :

showGrid(true);

4. Un programme primitif

Voici un exemple de programme :

public class MySuperGame extends Game {

    @Override
    public void initialize() {

        // Create a playing field that is 3 cells x 3 cells
        setScreenSize(3, 3);
        // Turn off the grid
        showGrid(false);
        // Change the background of the center cell to blue, and display an "X" in it.
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);
    }
}

Dans cet exemple, le champ de jeu est défini sur 3x3, la grille est désactivée et un "X" orange représentant la moitié de la taille de la cellule est défini sur un fond bleu dans la cellule centrale. Ce sera la première chose que le joueur verra au début du jeu.

5. Travailler avec des cellules du terrain de jeu

Le fait que nous puissions diviser le terrain de jeu en cellules est formidable, mais que pouvons-nous faire avec les cellules elles-mêmes ? Vous pouvez définir les propriétés suivantes pour chaque cellule du terrain de jeu :

• couleur de la cellule (couleur d'arrière-plan de la cellule) ;
• texte (texte ou nombre);
• couleur du texte ;
• taille du texte en pourcentage de la taille de la cellule.

Regardons les méthodes pour travailler avec les cellules du terrain de jeu :

1. void setCellColor(int x, int y, Color color)— définit la couleur de la cellule avec les coordonnées (x, y) :

   
   setCellColor(0, 0, Color.RED);
   setCellColor(3, 6, Color.BLACK);
   setCellColor(6, 8, Color.NONE);
   




2. Color getCellColor(int x, int y)— renvoie la couleur de la cellule de coordonnées (x, y) :

   
   Color myColor = getCellColor(2, 0);
   




3. void setCellValue(int x, int y, String value)— définit le texte de la cellule avec les coordonnées (x, y) égales à la chaîne dans le paramètre value :

   
   setCellValue(3, 3, "text");
   setCellValue(0, 8, "W");
   setCellValue(4, 1, "2222");
   setCellValue(6, 6, "");
   




4. String getCellValue(int x, int y)— renvoie le texte contenu dans la cellule de coordonnées (x, y) :

   
   String s = getCellValue(3, 3);
   System.out.println(getCellValue(4, 1));
   




5. void setCellTextSize(int x, int y, int size)— définit la taille du contenu de la cellule avec les coordonnées (x, y). Le paramètre size correspond à la hauteur du texte en pourcentage de la hauteur de la cellule :

   
   setCellTextSize(2 , 0, 70); // 70% of the cell height
   




6. int getCellTextSize(int x, int y)— retourne la taille du contenu de la cellule de coordonnées (x, y) :

   
   int size = getCellTextSize(2 , 0);
   




7. void setCellNumber(int x, int y, int value)— définit le texte de la cellule avec les coordonnées (x, y) égales au nombre dans le paramètre valeur :

   
   setCellNumber(3, 3, 40);
   setCellNumber(0, 8, -8);
   setCellNumber(4, 1, 2222);
   setCellNumber(6, 6, 0);
   




8. int getCellNumber(int x, int y)— renvoie le nombre contenu dans la cellule de coordonnées (x, y). Si la cellule ne contient pas de nombre, renvoie 0 :

   
   int i = getCellNumber(3, 3);
   System.out.println(getCellNumber(4, 1));
   




9. void setCellTextColor(int x, int y, Color color)— définit la couleur du contenu (texte) de la cellule de coordonnées (x, y) :

   
   setCellTextColor(2, 1, Color.GREEN);
   setCellTextColor(0, 1, Color.NONE);
   




10. Color getCellTextColor(int x, int y)— retourne la couleur du contenu (texte) de la cellule de coordonnées (x, y) :

    
    Color textColor = getCellTextColor(1, 3);
    

Pour plus de commodité, il existe plusieurs setCellValueEx()méthodes avec différents ensembles de paramètres :

1. void setCellValueEx(int x, int y, Color cellColor, String value)— définit la couleur d'arrière-plan (cellColor) et le contenu (value) de la cellule de coordonnées (x, y) :

   
   setCellValueEx(0, 2, Color.BLUE, "56");
   




2. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— définit la couleur d'arrière-plan (cellColor), le contenu (value) et la couleur du texte (textColor) de la cellule avec les coordonnées (x, y) :

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);
   




3. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)— définit la couleur d'arrière-plan (cellColor), le contenu (value), la couleur du texte (textColor) et la taille du texte (textSize) de la cellule avec les coordonnées (x, y) :

   
   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);
   

6. Travailler avec la couleur

Le Color enumest responsable des couleurs dans le moteur de jeu. Il a des valeurs uniques pour 148 couleurs. Il a également une valeur spéciale (NONE) qui ne représente aucune couleur. Voici un exemple de travail avec la couleur :

Color myColor = Color.WHITE;  // The myColor variable is set to white.
Color redColor = Color.RED;  // The redColor variable is set to red.
Color blueColor = Color.BLUE;  // The blueColor variable is set to light blue.

Parfois, vous devrez peut-être obtenir un tableau de toutes les couleurs existantes. Pour ce faire, utilisez la values()méthode. Par exemple:

Color[] colors = Color.values();  // The colors variable is assigned an array containing all available colors.

Il est très facile d'obtenir l'index d'une couleur dans la palette :

Color color = Color.RED;
int redIndex = color.ordinal();  // Index of red

int blueIndex = Color.BLUE.ordinal();  // Index of blue

Vous pouvez également obtenir une couleur par son index :

Color color = Color.values()[10];  // The color variable is assigned the color with index 10 in the Color enum.

7. Boîtes de dialogue

À la fin du jeu, vous devez signaler une victoire ou une défaite au joueur. Pour ce faire, il existe une méthode spéciale qui affiche une boîte de dialogue sur l'écran du jeu :

void showMessageDialog(Color cellColor, String message, Color textColor, int textSize)

Ici:

• cellColorest la couleur de fond de la boîte de dialogue ;
• messageest le texte du message ;
• textColorest la couleur du texte du message ;
• textSizeest la taille du texte du message.

La boîte de dialogue se ferme d'elle-même si l'utilisateur appuie sur la barre d'espace.

8. Méthodes utilitaires

Lors de l'écriture de jeux, les nombres aléatoires sont beaucoup utilisés. Pour faciliter l'obtention de nombres aléatoires, vous pouvez utiliser les méthodes utilitaires suivantes fournies par le moteur de jeu :

1. int getRandomNumber(int max)— renvoie un entier aléatoire de 0 à (max-1) inclus.

2. int getRandomNumber(int min, int max)— renvoie un entier aléatoire de min à (max-1) inclus.

C'est tout pour le moment! Si vous souhaitez en savoir plus sur la section "Jeux", voici une documentation utile qui peut vous aider :