Eventhantering

1. Introduktion

En spelmotor skulle vara till liten nytta om vi bara kunde använda den för att rita något på skärmen. För att skriva ett fullfjädrat spel behöver vi det för att interagera med användaren! För att vara mer exakt bör vårt program spåra användaråtgärder och svara på dem.

För att göra detta har spelmotorn CodeGym speciella metoder som den anropar när användaren klickar på musknapparna eller tangentbordstangenterna.

Poängen med klassen är att du skriver dessa metoder själv, och sedan ansvarar CodeGym-spelmotorn för att anropa dem. Allt du behöver är att deklarera dessa metoder i din kod. Det här är lättare att göra än det låter.

2. Arbeta med musen

Spelmotorn har två metoder för att arbeta med musen:

void onMouseLeftClick(int x, int y)

void onMouseRightClick(int x, int y)

Du deklarerar helt enkelt dessa metoder i din egen klass som ärver klassen Game. Och skriv sedan vilken kod du vill i dessa metoder. Spelmotorn anropar dessa metoder när användaren klickar på musknapparna.

onMouseLeftClick(int x, int y)anropas av motorn när vänster musknapp klickas. Dess parametrar är koordinaterna för cellen på spelplanen där klicket inträffade. Koordinaterna för den övre vänstra cellen är (0,0). För att använda den här metoden måste du åsidosätta den och placera anteckningen @Overrideföre metodnamnet.

onMouseRightClick(int x, int y)anropas när höger musknapp klickas. Det fungerar på samma sätt som onMouseLeftClick(int x, int y)metoden.

Exempel på användning av dessa metoder:

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

I exemplet ovan deklarerade vi båda metoderna: onMouseLeftClick()och onMouseRightClick(). Den första metoden kommer att anropas när användaren klickar med vänster musknapp på cellerna på spelplanen. Den andra metoden kommer att anropas när du klickar på höger musknapp.

Som argument kommer CodeGym-spelmotorn att passera (x, y)koordinaterna för cellen på spelplanen där musen klickades.

3. Arbeta med tangentbordet

Spelmotorn har två metoder för att arbeta med tangentbordet:

void onKeyPress(Key key);

void onKeyReleased(Key key);

Om du vill göra något när användaren trycker på en tangent behöver du bara deklarera dessa metoder i din klass som ärver klassen Game.

Du skriver din kod i dessa metoder, och spelmotorn anropar dem när användaren trycker på (eller släpper) en tangent.

onKeyPress(Key key)anropas när någon knapp trycks ned . Värdet på den nedtryckta knappen (eller ) skickas till metoden som parameter. För att använda den här metoden måste du åsidosätta den och placera anteckningen före metodnamnet.Key.UNKNOWNkey@Override

onKeyReleased(Key key)anropas när någon tangent släpps . Värdet på motsvarande nyckel (eller ) tilldelas parametern . För att använda den här metoden måste du åsidosätta den och placera anteckningen före metodnamnet.Key.UNKNOWNkey@Override

Exempel på användning av dessa metoder:

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. Lista över alla nycklar som stöds

När CodeGym-motorn anropar metoderna onKeyPress()och onKeyReleased(), skickar den information till dem om den nedtryckta (släppta) tangenten. För att göra detta har CodeGym-motorn en speciell typ som kallas Key.

I den nuvarande versionen av motorn Keystöder typen endast en begränsad uppsättning av 9 värden:

Key.ENTER

Key.ESCAPE

Key.PAUSE

Key.SPACE

Key.LEFT

Key.RIGHT

Key.UP

Key.DOWN

Key.UNKNOWN

Om spelaren trycker på mellanslagstangenten onKeyPress()kommer metoden att anropas med Key.SPACEsom parameter. Om användaren trycker på vänsterpilen blir parametern Key.LEFT. Om användaren trycker på någon tangent som inte finns i listan ovan onKeyPress()kommer metoden att anropas med Key.UNKNOWNsom parameter.

Problemet här är att de befintliga CodeGym-spelen designades för att köras på en telefon. Istället för standardtangentbordet har vi 8 virtuella knappar:

5. Arbeta med en timer

Många spel äger rum i realtid, dvs användaren kanske inte gör någonting, men vissa händelser inträffar fortfarande i spelet. För att du ska kunna implementera sådana spel har vi lagt till en timer i spelmotorn.

Så här fungerar det: du sätter på timern och ställer in tiden efter vilken den ska utlösas. Till exempel, 500 ms. Sedan, varje halv sekund, kommer CodeGym-spelmotorn att anropa onTurn()metoden. Ett oändligt antal gånger — tills timern stängs av.

Hur använder du en timer?

1. Slå på timern

För att slå på timern har vi void setTurnTimer(int timeMs)metoden. Metoden tar som argument varaktigheten (i millisekunder eller 1/1000s av en sekund) av intervallet mellan återuppringningar. Du behöver bara anropa den här metoden en gång, och spelmotorn kommer att börja anropa onTurn()metoden varje timeMsmillisekund.

2. Åsidosätt onTurn(int)metoden

För att göra detta måste du deklarera en void onTurn(int step)metod i en klass som ärver Gameklassen. Spelmotorn kommer att kalla denna metod. Med varje samtal skickar motorn ett sekventiellt nummer som identifierar metodanropet ( , 1, 2, 3...).

3. Stäng av timern

Om timern inte längre behövs, till exempel för att användaren har avslutat spelet, kan den stängas av. För att göra detta, ring helt enkelt stopTurnTimer()metoden.

4 Accelerera/ändra timern

I vissa spel ökar frekvensen av händelser regelbundet, så det skulle vara bekvämt att kunna snabba upp vår timer, det vill säga minska tiden mellan återuppringningar. Och ingenting kan vara enklare – ring bara igen med det nya värdet, så ändras setTurnTimer(int timeMs)tiden mellan samtalen till.onTurn()

Exempel:

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

I detta enkla exempel skapade vi ett fält som är 3 celler gånger 3 celler. Sedan slog vi på en timer som anropar onTurn()metoden varje halv sekund.

Här kommer färgen på den centrala cellen att ändras varje halv sekund. Texten i cellen kommer inte att ändras. Efter 50 sekunder (100 återuppringningar) slutar färgen att ändras och timern stängs av.