Rendezvénykezelés

1. Bemutatkozás

Egy játékmotornak nem sok haszna lenne, ha csak a képernyőre tudnánk rajzolni valamit. Egy teljes értékű játék írásához szükségünk van rá, hogy kapcsolatba léphessünk a felhasználóval! Pontosabban, programunknak nyomon kell követnie a felhasználói műveleteket, és reagálnia kell rájuk.

Ehhez a CodeGym játékmotor speciális metódusokkal rendelkezik, amelyeket akkor hív meg, amikor a felhasználó az egérgombokra vagy a billentyűzet billentyűire kattint.

Az óra lényege, hogy ezeket a metódusokat te magad írod meg, majd a CodeGym játékmotor felel a meghívásért. Mindössze annyit kell tennie, hogy deklarálja ezeket a metódusokat a kódjában. Ezt könnyebb megtenni, mint amilyennek hangzik.

2. Munka az egérrel

A játékmotor két módszerrel dolgozik az egérrel:

void onMouseLeftClick(int x, int y)

void onMouseRightClick(int x, int y)

Egyszerűen deklarálja ezeket a metódusokat a saját osztályában, amely örökli az Gameosztályt. Ezután írjon be bármilyen kódot ezekbe a módszerekbe. A játékmotor ezeket a módszereket hívja meg, amikor a felhasználó rákattint az egérgombokra.

onMouseLeftClick(int x, int y)a motor hívja meg, ha a bal egérgombbal kattintunk. Paraméterei annak a játékmezőnek a koordinátái, ahol a kattintás történt. A bal felső cella koordinátái (0,0): . A módszer használatához felül kell írnia, és a @Overridemegjegyzést a metódus neve elé kell helyezni.

onMouseRightClick(int x, int y)akkor hívódik meg, ha a jobb egérgombbal kattintunk. A módszerhez hasonlóan működik onMouseLeftClick(int x, int y).

Példák ezen módszerek használatára:

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

A fenti példában mindkét metódust deklaráltuk: onMouseLeftClick()és onMouseRightClick(). Az első módszer akkor hívódik meg, amikor a felhasználó a bal egérgombbal rákattint a játékmező celláira. A második módszert akkor hívja meg, ha a jobb egérgombbal kattint.

Érvként a CodeGym játékmotor átadja (x, y)a játékmező azon cellájának koordinátáit, ahol az egér kattintott.

3. A billentyűzet használata

A játékmotor két módszerrel dolgozik a billentyűzettel:

void onKeyPress(Key key);

void onKeyReleased(Key key);

Ha szeretne valamit tenni, amikor a felhasználó megnyom egy billentyűt, akkor csak deklarálnia kell ezeket a metódusokat az Gameosztályt öröklő osztályban.

Ezekkel a módszerekkel írja be a kódot, és a játékmotor meghívja őket, amikor a felhasználó megnyom (vagy felenged) egy billentyűt.

onKeyPress(Key key)bármelyik gomb megnyomásakor hívódik . A lenyomott billentyű (vagy ) értéke paraméterként kerül átadásra a metódusnak . A módszer használatához felül kell írnia, és a megjegyzést a metódus neve elé kell helyezni.Key.UNKNOWNkey@Override

onKeyReleased(Key key)bármelyik billentyű elengedésekor hívódik . A megfelelő kulcs (vagy ) értéke hozzárendelődik a paraméterhez. A módszer használatához felül kell írnia, és a megjegyzést a metódus neve elé kell helyezni.Key.UNKNOWNkey@Override

Példák ezen módszerek használatára:

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. Az összes támogatott kulcs listája

Amikor a CodeGym motor meghívja a onKeyPress()és onKeyReleased()metódusokat, információkat ad át nekik a lenyomott (felengedett) billentyűről. Ehhez a CodeGym motornak van egy speciális típusa, az úgynevezett Key.

A motor jelenlegi verziójában a Keytípus csak 9 értékből álló korlátozott készletet támogat:

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Ha a játékos megnyomja a szóköz billentyűt, akkor a metódus paraméterként onKeyPress()kerül meghívásra . Key.SPACEHa a felhasználó megnyomja a bal nyilat, akkor a paraméter a következő lesz Key.LEFT. Ha a felhasználó megnyom egy olyan billentyűt, amely nem szerepel a fenti listában, akkor a metódus paraméterként onKeyPress()kerül meghívásra .Key.UNKNOWN

A probléma itt az, hogy a meglévő CodeGym játékokat úgy tervezték, hogy telefonon fussanak. A szokásos billentyűzet helyett 8 virtuális gombunk van:

5. Időzítővel végzett munka

Sok játék valós időben játszódik, azaz a felhasználó nem csinálhat semmit, de bizonyos események mégis előfordulnak a játékban. Az ilyen játékok megvalósításához időzítőt adtunk a játékmotorhoz.

Ez így működik: bekapcsolja az időzítőt, és beállítja azt az időt, amely után aktiválódnia kell. Például 500 ms. Ezután fél másodpercenként a CodeGym játékmotor meghívja a onTurn()metódust. Végtelen számú alkalommal – amíg az időzítőt ki nem kapcsolják.

Hogyan használd az időzítőt?

1. Kapcsolja be az időzítőt

Az időzítő bekapcsolásához megvan a void setTurnTimer(int timeMs)módszer. A metódus a visszahívások közötti intervallum időtartamát (ezredmásodpercben vagy 1/1000 másodpercben) veszi argumentumként. Csak egyszer kell meghívnia ezt a metódust, és a játékmotor onTurn()ezredmásodpercenként elkezdi hívni a metódust timeMs.

2. Írja felül a onTurn(int)módszert

Ehhez deklarálnia kell egy void onTurn(int step)metódust egy osztályban, amely örökli az Gameosztályt. A játékmotor ezt a módszert fogja hívni. A motor minden hívásnál átadja a metódushívást azonosító szekvenciális számot ( 1, 2, 3, ...).

3. Kapcsolja ki az időzítőt

Ha az időzítőre már nincs szükség, például azért, mert a felhasználó befejezte a játékot, akkor kikapcsolható. Ehhez egyszerűen hívja meg a stopTurnTimer()módszert.

4 Gyorsítsa fel/módosítsa az időzítőt

Egyes játékokban rendszeresen növekszik az események gyakorisága, így kényelmes lenne, ha felpörgethetnénk az időzítőnket, azaz csökkenthetnénk a visszahívások közötti időt. És mi sem lehet egyszerűbb – csak hívja setTurnTimer(int timeMs)újra az új értékkel, és onTurn()megváltozik a hívások közötti idő.

Példa:

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);
      }
   }
   ...
}

Ebben az egyszerű példában egy olyan mezőt hoztunk létre, amely 3x3 cellából áll. Ezután bekapcsoltunk egy időzítőt, amely onTurn()fél másodpercenként hívja a metódust.

Itt a központi cella színe fél másodpercenként változik. A cella szövege nem változik. 50 másodperc (100 visszahívás) elteltével a szín nem változik, és az időzítő kikapcsol.