Secțiunea de jocuri pe CodeGym: gestionarea evenimentelor

„Jocuri” de la CodeGym este o nouă secțiune cu sarcini mari interesante în care vă creați propriile versiuni ale jocurilor populare. Este simplu: fiecare proiect de joc este împărțit în subsarcini. Completați-le unul câte unul și jocul este gata. Îl puteți partaja pe rețelele sociale și vă puteți invita prietenii să se joace. În acest articol, vom descrie în detaliu metodele de gestionare a evenimentelor folosite pentru a scrie jocuri.

1. Lucrul cu mouse-ul

Motorul de joc are două metode de lucru cu mouse-ul:

• void onMouseLeftClick(int x, int y);

• void onMouseRightClick(int x, int y);

Pur și simplu declarați aceste metode în clasa dvs. care moștenește Gameși adăugați orice cod doriți la ele. Motorul jocului le va apela atunci când utilizatorul face clic pe butoanele mouse-ului.

1. onMouseLeftClick(int x, int y)— apelat de motor când se face clic pe butonul stâng al mouse-ului. Parametrii săi sunt coordonatele celulei terenului de joc în care a avut loc clicul. Celula din stânga sus are coordonatele (0, 0). Trebuie să anulați această metodă pentru a o utiliza.

2. onMouseRightClick(int x, int y)— apelat când se face clic pe butonul din dreapta al mouse-ului. Această metodă funcționează ca onMouseLeftClick(int x, int y)metoda.

Iată un exemplu de utilizare a acestor metode:

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. Lucrul cu tastatura

Motorul de joc are două metode de lucru cu tastatura:

• void onKeyPress(Key key);

• void onKeyReleased(Key key);

Dacă doriți să se întâmple ceva când utilizatorul apasă o tastă, declarați aceste metode în clasa dvs. care moștenește Game și adăugați codul la ele. Motorul jocului le va apela atunci când utilizatorul apasă sau eliberează o tastă.

1. onKeyPress(Key key)— apelat când este apăsată orice tastă. Parametrul cheie este tasta apăsată (sau Key.NEKNOWN).

2. onKeyReleased(Key key)— apelat când se eliberează orice tastă. Parametrul cheie este cheia corespunzătoare (sau Key.UNKNOWN).

Iată un exemplu de utilizare a acestor metode:

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! În versiunea actuală a motorului de joc, tipul de cheie are un set limitat de nouă valori:

3. Lucrul cu cronometrul

Multe jocuri se petrec în timp real, adică chiar dacă utilizatorul nu face nimic, evenimentele apar în continuare în joc. Pentru a vă permite să implementați astfel de jocuri, am adăugat un cronometru motorului de joc. Funcționează cam așa: porniți cronometrul și setați intervalul cronometrului. De exemplu, 500 de milisecunde. Apoi, la fiecare jumătate de secundă, motorul de joc apelează onTurnTimer()metoda. Din nou și din nou pentru totdeauna - până când cronometrul este oprit. Deci, cum folosești cronometrul?

1. Porniți cronometrul.

   Pentru a face acest lucru, există o metodă specială. Metoda ia ca argument intervalul dintre apeluri în milisecunde (1 milisecundă = 1/1000 secundă). Trebuie să-l apelați o singură dată, iar motorul de joc va începe să apeleze metoda de fiecare dată în milisecunde.void setTurnTimer(int timeMs)onTurn()

2. Ignorați metoda onTurn(int).

   Pentru a face acest lucru, trebuie să declarați o metodă în clasa care moștenește . Această metodă va fi apelată de motorul jocului. Mai mult, cu fiecare apel motorul de joc va transmite metodei un identificator secvenţial pentru apel (1, 2, 3, …).void onTurn(int step)Game

3. Opriți cronometrul.

   Dacă cronometrul nu mai este necesar, de exemplu, când utilizatorul finalizează jocul, îl puteți dezactiva. Pentru a face acest lucru, trebuie pur și simplu să apelați metoda.stopTurnTimer()

4. Accelerați sau schimbați cronometrul.

   În unele jocuri, rata cu care apar evenimentele se accelerează constant, așa că ar fi convenabil să ne grăbim cronometrul (reducerea timpului dintre apeluri). Nimic nu ar putea fi mai ușor: apelați setTurnTimer(int timeMs)din nou cu o nouă valoare, iar timpul dintre onTurn()apeluri se va schimba.

De exemplu:

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

        }
    }
    …
}

În acest exemplu simplu, am creat un câmp care este de 3 celule x 3 celule. Apoi am pornit un cronometru care va apela onTurn()metoda la fiecare jumătate de secundă. La fiecare jumătate de secundă, culoarea celulei se va schimba, dar conținutul acesteia nu se va schimba. După 50 de secunde, culoarea nu se va mai schimba. Asta este tot pentru acum! Dacă doriți să aflați mai multe despre secțiunea „Jocuri”, iată o documentație utilă care vă poate ajuta: