Gestion des événements

1. Introduction

Un moteur de jeu serait de peu d'utilité si nous ne pouvions l'utiliser que pour dessiner quelque chose sur l'écran. Pour écrire un jeu à part entière, nous en avons besoin pour interagir avec l'utilisateur ! Pour être plus précis, notre programme devrait suivre les actions des utilisateurs et y répondre.

Pour ce faire, le moteur de jeu CodeGym dispose de méthodes spéciales qu'il appelle lorsque l'utilisateur clique sur les boutons de la souris ou sur les touches du clavier.

Le but de la classe est que vous écriviez ces méthodes vous-même, puis le moteur de jeu CodeGym se charge de les appeler. Tout ce dont vous avez besoin est de déclarer ces méthodes dans votre code. C'est plus facile à faire qu'il n'y paraît.

2. 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 propre classe qui hérite de la Gameclasse. Et puis écrivez le code que vous voulez dans ces méthodes. Le moteur du jeu appellera ces méthodes lorsque l'utilisateur cliquera sur les boutons de la souris.

onMouseLeftClick(int x, int y)est 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. Les coordonnées de la cellule en haut à gauche sont (0,0). Pour utiliser cette méthode, vous devez la remplacer en plaçant l' @Overrideannotation avant le nom de la méthode.

onMouseRightClick(int x, int y)est appelé lorsque le bouton droit de la souris est cliqué. Cela fonctionne de la même manière que la onMouseLeftClick(int x, int y)méthode.

Exemples 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) {
      // Put a "X" in the cell that was clicked with the left mouse button
      setCellValue(x, y, "X");
   }

   @Override
   public void onMouseRightClick(int x, int y) {
      // Clear the cell that was clicked with the right mouse button
      setCellValue(x, y, "");
   }
}

Dans l'exemple ci-dessus, nous avons déclaré les deux méthodes : onMouseLeftClick()et onMouseRightClick(). La première méthode sera appelée lorsque l'utilisateur cliquera avec le bouton gauche de la souris sur les cellules du terrain de jeu. La deuxième méthode sera appelée lorsque le bouton droit de la souris sera cliqué.

Comme arguments, le moteur de jeu CodeGym passera les (x, y)coordonnées de la cellule du terrain de jeu où la souris a été cliquée.

3. 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 faire quelque chose lorsque l'utilisateur appuie sur une touche, il vous suffit de déclarer ces méthodes dans votre classe qui hérite de la Gameclasse.

Vous écrivez votre code dans ces méthodes, et le moteur du jeu les appellera lorsque l'utilisateur appuie (ou relâche) une touche.

onKeyPress(Key key)est appelé lorsqu'une touche est enfoncée . La valeur de la touche enfoncée (ou ) est transmise à la méthode en tant que paramètre. Pour utiliser cette méthode, vous devez la remplacer en plaçant l' annotation avant le nom de la méthode.Key.UNKNOWNkey@Override

onKeyReleased(Key key)est appelée lorsqu'une touche est relâchée . La valeur de la clé correspondante (ou ) est affectée au paramètre. Pour utiliser cette méthode, vous devez la remplacer en plaçant l' annotation avant le nom de la méthode.Key.UNKNOWNkey@Override

Exemples 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 spacebar is pressed, the center cell turns yellow
      if (key == Key.SPACE) {
         setCellColor(1, 1, Color.YELLOW);
      }
   }

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

4. Liste de toutes les clés prises en charge

Lorsque le moteur CodeGym appelle les méthodes onKeyPress()et onKeyReleased(), il leur transmet des informations sur la touche enfoncée (relâchée). Pour ce faire, le moteur CodeGym a un type spécial appelé Key.

Dans la version actuelle du moteur, le Keytype ne prend en charge qu'un ensemble limité de 9 valeurs :

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Si le joueur appuie sur la barre d'espace, alors la onKeyPress()méthode sera appelée avec Key.SPACEcomme paramètre. Si l'utilisateur appuie sur la flèche gauche, le paramètre sera Key.LEFT. Si l'utilisateur appuie sur une touche qui ne figure pas dans la liste ci-dessus, la onKeyPress()méthode sera appelée avec Key.UNKNOWNcomme paramètre.

Le problème ici est que les jeux CodeGym existants ont été conçus pour fonctionner sur un téléphone. Au lieu du clavier standard, nous avons 8 boutons virtuels :

5. Travailler avec une minuterie

De nombreux jeux se déroulent en temps réel, c'est-à-dire que l'utilisateur peut ne rien faire, mais certains événements se produisent tout de même dans le jeu. Pour vous permettre d'implémenter de tels jeux, nous avons ajouté une minuterie au moteur de jeu.

Voici comment cela fonctionne : vous allumez la minuterie et réglez l'heure après laquelle elle doit se déclencher. Par exemple, 500 ms. Ensuite, toutes les demi-secondes, le moteur de jeu CodeGym appellera la onTurn()méthode. Un nombre infini de fois - jusqu'à ce que la minuterie soit désactivée.

Comment utiliser une minuterie ?

1. Allumez la minuterie

Pour activer la minuterie, nous avons la void setTurnTimer(int timeMs)méthode. La méthode prend comme argument la durée (en millisecondes ou 1/1000s de seconde) de l'intervalle entre les callbacks. Il vous suffit d'appeler cette méthode une fois, et le moteur du jeu commencera à appeler la onTurn()méthode toutes timeMsles millisecondes.

2. Remplacer la onTurn(int)méthode

Pour ce faire, vous devez déclarer une void onTurn(int step)méthode dans une classe qui hérite de la Gameclasse. Le moteur du jeu appellera cette méthode. A chaque appel, le moteur passe un numéro séquentiel qui identifie l'appel de méthode ( 1, 2, 3, ...).

3. Éteignez la minuterie

Si le chronomètre n'est plus nécessaire, par exemple parce que l'utilisateur a terminé le jeu, il peut être désactivé. Pour ce faire, il suffit d'appeler la stopTurnTimer()méthode.

4 Accélérer/modifier la minuterie

Dans certains jeux, la fréquence des événements augmente régulièrement, il serait donc pratique de pouvoir accélérer notre chronomètre, c'est-à-dire réduire le temps entre les rappels. Et rien ne pourrait être plus facile - appelez simplement setTurnTimer(int timeMs)à nouveau avec la nouvelle valeur, et le temps entre les appels à onTurn()changera.

Exemple:

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

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

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

   @Override
   public void onTurn(int step) {
      if (step == 100) {
         stopTurnTimer(); // If this is the 100th callback, then turn off the timer
      }

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

Dans cet exemple simple, nous avons créé un champ de 3 cellules sur 3 cellules. Ensuite, nous avons activé une minuterie qui appellera la onTurn()méthode toutes les demi-secondes.

Ici, la couleur de la cellule centrale changera toutes les demi-secondes. Le texte de la cellule ne changera pas. Après 50 secondes (100 rappels), la couleur cessera de changer et la minuterie s'éteindra.