Section Jeux sur CodeGym : Gestion des événements

"Jeux" de CodeGym est une nouvelle section avec de grandes tâches intéressantes où vous créez vos propres versions de jeux populaires. C'est simple : chaque projet de jeu est divisé en sous-tâches. Complétez-les un par un et le jeu est terminé. Vous pouvez le partager sur les réseaux sociaux et inviter vos amis à jouer. Dans cet article, nous décrirons en détail les méthodes de gestion des événements utilisées pour écrire des jeux.

1. Travailler avec la souris

Le moteur de jeu a deux méthodes pour travailler avec la souris :

• void onMouseLeftClick(int x, int y);

• void onMouseRightClick(int x, int y);

Vous déclarez simplement ces méthodes dans votre classe qui hérite de Game, et ajoutez-y le code de votre choix. Le moteur du jeu les appellera lorsque l'utilisateur cliquera sur les boutons de la souris.

1. onMouseLeftClick(int x, int y)— appelé par le moteur lorsque le bouton gauche de la souris est cliqué. Ses paramètres sont les coordonnées de la cellule du terrain de jeu où le clic s'est produit. La cellule en haut à gauche a les coordonnées (0, 0). Vous devez remplacer cette méthode pour l'utiliser.

2. onMouseRightClick(int x, int y)— appelé lorsque le bouton droit de la souris est cliqué. Cette méthode fonctionne comme la onMouseLeftClick(int x, int y)méthode.

Voici un exemple d'utilisation de ces méthodes :

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;
import com.codegym.engine.cell.Key;

public class MySuperGame extends Game {
    @Override
    public void initialize() {
        // Set the size of the playing field to 3x3
        setScreenSize(3, 3);

        // Paint the playing field white
        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                setCellColor(x, y, Color.WHITE);
            }
        }
    }

    @Override
    public void onMouseLeftClick(int x, int y) {
        // Set "X" in the cell where the left mouse click occurred
        setCellValue(x, y, "X");
    }

    @Override
    public void onMouseRightClick(int x, int y) {
        // Clear the cell where the right mouse click occurred
        setCellValue(x, y, "");
    }
}

2. Travailler avec le clavier

Le moteur de jeu propose deux méthodes pour travailler avec le clavier :

• void onKeyPress(Key key);

• void onKeyReleased(Key key);

Si vous voulez que quelque chose se produise lorsque l'utilisateur appuie sur une touche, déclarez ces méthodes dans votre classe qui hérite de Game et ajoutez-y votre code. Le moteur de jeu les appellera lorsque l'utilisateur appuie ou relâche une touche.

1. onKeyPress(Key key)— appelé lorsqu'une touche est enfoncée. Le paramètre clé est la touche enfoncée (ou Key.UNKNOWN).

2. onKeyReleased(Key key)— appelé lorsqu'une touche est relâchée. Le paramètre key est la clé correspondante (ou Key.UNKNOWN).

Voici un exemple d'utilisation de ces méthodes :

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;
import com.codegym.engine.cell.Key;

public class MySuperGame extends Game {
    @Override
    public void initialize() {
        // Set the size of the playing field to 3x3
        setScreenSize(3, 3);

        // Paint the playing field white
        for (int x = 0; x < 3; x++) {
            for (int y = 0; y < 3; y++) {
                setCellColor(x, y, Color.WHITE);
            }
        }
    }

    @Override
    public void onKeyPress(Key key) {
        // When the space bar is pressed, the center cell turns yellow
        if (key == Key.SPACE) {
            setCellColor(1, 1, Color.YELLOW);
        }
    }

    @Override
    public void onKeyReleased(Key key) {
        // When the space bar is released, the center cell changes back to white
        if (key == Key.SPACE) {
            setCellColor(1, 1, Color.WHITE);
        }
    }
}

Important! Dans la version actuelle du moteur de jeu, le type Clé a un ensemble limité de neuf valeurs :

3. Travailler avec la minuterie

De nombreux jeux se déroulent en temps réel, c'est-à-dire que même si l'utilisateur ne fait rien, des événements se produisent tout de même dans le jeu. Pour vous permettre de mettre en œuvre de tels jeux, nous avons ajouté une minuterie au moteur de jeu. Cela fonctionne quelque chose comme ceci : vous allumez la minuterie et réglez l'intervalle de la minuterie. Par exemple, 500 millisecondes. Ensuite, toutes les demi-secondes, le moteur du jeu appelle la onTurnTimer()méthode. Encore et encore pour toujours - jusqu'à ce que la minuterie soit éteinte. Alors, comment utilisez-vous la minuterie?

1. Allumez la minuterie.

   Pour ce faire, il existe une méthode spéciale. La méthode prend comme argument l'intervalle entre les appels en millisecondes (1 milliseconde = 1/1000 seconde). Vous n'avez besoin de l'appeler qu'une seule fois, et le moteur du jeu commencera à appeler la méthode à chaque milliseconde.void setTurnTimer(int timeMs)onTurn()

2. Remplacez la méthode onTurn(int).

   Pour ce faire, vous devez déclarer une méthode dans la classe qui hérite de . Cette méthode sera appelée par le moteur du jeu. De plus, à chaque appel, le moteur du jeu transmettra à la méthode un identifiant séquentiel pour l'appel (1, 2, 3, …).void onTurn(int step)Game

3. Éteignez la minuterie.

   Si la minuterie n'est plus nécessaire, par exemple, lorsque l'utilisateur termine le jeu, vous pouvez la désactiver. Pour ce faire, il vous suffit d'appeler la méthode.stopTurnTimer()

4. Accélérez ou modifiez la minuterie.

   Dans certains jeux, la vitesse à laquelle les événements se produisent s'accélère constamment, il serait donc pratique d'accélérer notre minuterie (réduire le temps entre les appels). Rien de plus simple : appelez setTurnTimer(int timeMs)à nouveau avec une nouvelle valeur, et le temps entre onTurn()les appels changera.

Par exemple:

import com.codegym.engine.cell.Color;
import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    …
    @Override
    public void initialize() {
    	// Create a playing field that is 3 cells x 3 cells
        setScreenSize(3, 3);
        showGrid(false);
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);

        setTurnTimer(500);   // Turn on the timer, the interval between calls is 500ms.
    }

    @Override
    public void onTurn(int step) {
        if(step == 100) {
            stopTurnTimer();  // If 100 calls have been made, turn off the timer
        }

        if (step % 2 == 1) {
            // If this call is odd, set the cell background to red
            setCellColor(1, 1, Color.RED);
        } 
        else {
            // If this call is even, set the cell background to blue
            setCellColor(1, 1, Color.BLUE);

        }
    }
    …
}

Dans cet exemple simple, nous avons créé un champ de 3 cellules x 3 cellules. Ensuite, nous avons lancé une minuterie qui appellera la onTurn()méthode toutes les demi-secondes. Toutes les demi-secondes, la couleur de la cellule changera, mais son contenu ne changera pas. Après 50 secondes, la couleur ne changera plus. C'est tout pour le moment! Si vous souhaitez en savoir plus sur la section "Jeux", voici une documentation utile qui peut vous aider :