Course All lectures for TE purposes - Lecture: ఈవెంట్ నిర్వహణ

1. పరిచయం

గేమ్ ఇంజన్‌ను మనం స్క్రీన్‌పై ఏదైనా గీయడానికి మాత్రమే ఉపయోగించగలిగితే చాలా తక్కువ ఉపయోగం ఉంటుంది. పూర్తి స్థాయి గేమ్‌ను వ్రాయడానికి, వినియోగదారుతో పరస్పర చర్య చేయడానికి మాకు ఇది అవసరం! మరింత ఖచ్చితంగా చెప్పాలంటే, మా ప్రోగ్రామ్ వినియోగదారు చర్యలను ట్రాక్ చేయాలి మరియు వాటికి ప్రతిస్పందించాలి.

దీన్ని చేయడానికి, కోడ్‌జిమ్ గేమ్ ఇంజిన్ ప్రత్యేక పద్ధతులను కలిగి ఉంది, వినియోగదారు మౌస్ బటన్‌లు లేదా కీబోర్డ్ కీలను క్లిక్ చేసినప్పుడు కాల్ చేస్తుంది.

తరగతి యొక్క విషయం ఏమిటంటే, మీరు ఈ పద్ధతులను మీరే వ్రాస్తారు, ఆపై వాటిని కాల్ చేయడానికి CodeGym గేమ్ ఇంజిన్ బాధ్యత వహిస్తుంది. మీకు కావలసిందల్లా ఈ పద్ధతులను మీ కోడ్‌లో ప్రకటించడం. ఇది ధ్వనించే దానికంటే చేయడం సులభం.

2. మౌస్తో పని చేయడం

గేమ్ ఇంజిన్ మౌస్‌తో పనిచేయడానికి రెండు పద్ధతులను కలిగి ఉంది:

void onMouseLeftClick(int x, int y)

void onMouseRightClick(int x, int y)

మీరు ఈ పద్ధతులను తరగతిని వారసత్వంగా పొందే మీ స్వంత తరగతిలో ప్రకటించండి Game. ఆపై ఈ పద్ధతుల్లో మీకు కావలసిన కోడ్ రాయండి. వినియోగదారు మౌస్ బటన్‌లను క్లిక్ చేసినప్పుడు గేమ్ ఇంజిన్ ఈ పద్ధతులను పిలుస్తుంది.

onMouseLeftClick(int x, int y)ఎడమ మౌస్ బటన్‌ను క్లిక్ చేసినప్పుడు ఇంజిన్ ద్వారా పిలువబడుతుంది . దీని పారామితులు క్లిక్ సంభవించిన మైదానం యొక్క సెల్ యొక్క కోఆర్డినేట్‌లు. ఎగువ ఎడమ సెల్ యొక్క అక్షాంశాలు (0,0). ఈ పద్ధతిని ఉపయోగించడానికి, మీరు దానిని భర్తీ చేయాలి, @Overrideపద్ధతి పేరుకు ముందు ఉల్లేఖనాన్ని ఉంచాలి.

onMouseRightClick(int x, int y)కుడి మౌస్ బటన్‌ను క్లిక్ చేసినప్పుడు అంటారు . ఇది పద్ధతి వలె పనిచేస్తుంది onMouseLeftClick(int x, int y).

ఈ పద్ధతులను ఉపయోగించే ఉదాహరణలు:

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

పై ఉదాహరణలో, మేము రెండు పద్ధతులను ప్రకటించాము: onMouseLeftClick()మరియు onMouseRightClick(). వినియోగదారు ప్లే ఫీల్డ్ యొక్క కణాలపై ఎడమ మౌస్ బటన్‌ను క్లిక్ చేసినప్పుడు మొదటి పద్ధతిని పిలుస్తారు. కుడి మౌస్ బటన్‌ను క్లిక్ చేసినప్పుడు రెండవ పద్ధతిని పిలుస్తారు.

(x, y)వాదనల ప్రకారం, కోడ్‌జిమ్ గేమ్ ఇంజిన్ మౌస్ క్లిక్ చేసిన ప్లే ఫీల్డ్ సెల్ యొక్క కోఆర్డినేట్‌లను పాస్ చేస్తుంది .

3. కీబోర్డ్‌తో పని చేయడం

గేమ్ ఇంజిన్ కీబోర్డ్‌తో పనిచేయడానికి రెండు పద్ధతులను కలిగి ఉంది:

void onKeyPress(Key key);

void onKeyReleased(Key key);

వినియోగదారు ఒక కీని నొక్కినప్పుడు మీరు ఏదైనా చేయాలనుకుంటే, మీరు తరగతిని వారసత్వంగా పొందే మీ తరగతిలో ఈ పద్ధతులను ప్రకటించాలి Game.

మీరు ఈ పద్ధతుల్లో మీ కోడ్‌ను వ్రాస్తారు మరియు వినియోగదారు ఒక కీని నొక్కినప్పుడు (లేదా విడుదల చేసినప్పుడు) గేమ్ ఇంజిన్ వాటిని కాల్ చేస్తుంది.

onKeyPress(Key key)ఏదైనా కీ నొక్కినప్పుడు అంటారు . నొక్కిన కీ (లేదా ) విలువ పరామితిగా పద్ధతికి పంపబడుతుంది . ఈ పద్ధతిని ఉపయోగించడానికి, మీరు దానిని భర్తీ చేయాలి, పద్ధతి పేరుకు ముందు ఉల్లేఖనాన్ని ఉంచాలి.Key.UNKNOWNkey@Override

onKeyReleased(Key key)ఏదైనా కీ విడుదలైనప్పుడు అంటారు . సంబంధిత కీ (లేదా ) విలువ పరామితికి కేటాయించబడుతుంది . ఈ పద్ధతిని ఉపయోగించడానికి, మీరు దానిని భర్తీ చేయాలి, పద్ధతి పేరుకు ముందు ఉల్లేఖనాన్ని ఉంచాలి.Key.UNKNOWNkey@Override

ఈ పద్ధతులను ఉపయోగించే ఉదాహరణలు:

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. అన్ని మద్దతు ఉన్న కీల జాబితా

onKeyPress()కోడ్‌జిమ్ ఇంజిన్ మరియు పద్ధతులను పిలిచినప్పుడు onKeyReleased(), అది నొక్కిన (విడుదల చేయబడిన) కీ గురించి సమాచారాన్ని వారికి పంపుతుంది. దీన్ని చేయడానికి, CodeGym ఇంజిన్ అనే ప్రత్యేక రకాన్ని కలిగి ఉంది Key.

ఇంజిన్ యొక్క ప్రస్తుత సంస్కరణలో, Keyరకం 9 విలువల పరిమిత సెట్‌కు మాత్రమే మద్దతు ఇస్తుంది:

విలువ	వినియోగదారు ఏమి నొక్కినారు
`Key.ENTER`	వినియోగదారు ఎంటర్ కీని నొక్కారు
`Key.ESCAPE`	వినియోగదారు Esc కీని నొక్కారు
`Key.PAUSE`	వినియోగదారు పాజ్ కీని నొక్కారు
`Key.SPACE`	వినియోగదారు స్పేస్ కీని నొక్కారు
`Key.LEFT`	వినియోగదారు ఎడమ బాణం కీని నొక్కారు
`Key.RIGHT`	వినియోగదారు కుడి బాణం కీని నొక్కారు
`Key.UP`	వినియోగదారు పైకి బాణం కీని నొక్కారు
`Key.DOWN`	వినియోగదారు క్రిందికి బాణం కీని నొక్కారు
`Key.UNKNOWN`	పైన జాబితా చేయబడినవి కాకుండా ఏదైనా కీ

ప్లేయర్ స్పేస్ బార్‌ను నొక్కితే, ఆ పద్ధతిని పారామీటర్‌గా onKeyPress()పిలుస్తుంది . Key.SPACEవినియోగదారు ఎడమ బాణాన్ని నొక్కితే, అప్పుడు పరామితి ఉంటుంది Key.LEFT. వినియోగదారు ఎగువ జాబితాలో లేని ఏదైనా కీని నొక్కితే, ఆ పద్ధతిని పారామీటర్‌గా onKeyPress()పిలుస్తుంది .Key.UNKNOWN

ఇక్కడ సమస్య ఏమిటంటే, ప్రస్తుత కోడ్‌జిమ్ గేమ్‌లు ఫోన్‌లో రన్ అయ్యేలా రూపొందించబడ్డాయి. ప్రామాణిక కీబోర్డ్‌కు బదులుగా, మాకు 8 వర్చువల్ బటన్‌లు ఉన్నాయి:

5. టైమర్‌తో పని చేయడం

చాలా గేమ్‌లు నిజ సమయంలో జరుగుతాయి, అంటే వినియోగదారు ఏమీ చేయకపోవచ్చు, కానీ కొన్ని ఈవెంట్‌లు ఇప్పటికీ గేమ్‌లో జరుగుతాయి. అటువంటి గేమ్‌లను అమలు చేయడానికి మిమ్మల్ని అనుమతించడానికి, మేము గేమ్ ఇంజిన్‌కి టైమర్‌ని జోడించాము.

ఇది ఎలా పని చేస్తుందో ఇక్కడ ఉంది: మీరు టైమర్‌ను ఆన్ చేసి, దాన్ని ట్రిగ్గర్ చేయాల్సిన సమయాన్ని సెట్ చేయండి. ఉదాహరణకు, 500 ms. అప్పుడు, ప్రతి అర్ధ సెకనుకు, CodeGym గేమ్ ఇంజిన్ పద్ధతిని పిలుస్తుంది onTurn(). అనంతమైన సార్లు — టైమర్ ఆఫ్ చేయబడే వరకు.

మీరు టైమర్‌ను ఎలా ఉపయోగిస్తున్నారు?

1. టైమర్‌ను ఆన్ చేయండి

టైమర్‌ను ఆన్ చేయడానికి, మాకు void setTurnTimer(int timeMs)పద్ధతి ఉంది. ఈ పద్ధతి కాల్‌బ్యాక్‌ల మధ్య విరామం యొక్క వ్యవధిని (మిల్లీసెకన్లలో లేదా సెకనులో 1/1000 సెకన్లలో) వాదనగా తీసుకుంటుంది. మీరు ఈ పద్ధతికి ఒకసారి కాల్ చేయాలి మరియు గేమ్ ఇంజిన్ onTurn()ప్రతి timeMsమిల్లీసెకన్ల పద్ధతికి కాల్ చేయడం ప్రారంభిస్తుంది.

2. onTurn(int)పద్ధతిని భర్తీ చేయండి

దీన్ని చేయడానికి, మీరు void onTurn(int step)తరగతిని వారసత్వంగా పొందే తరగతిలో ఒక పద్ధతిని తప్పనిసరిగా ప్రకటించాలి Game. గేమ్ ఇంజిన్ ఈ పద్ధతిని పిలుస్తుంది. ప్రతి కాల్‌తో, ఇంజిన్ మెథడ్ కాల్‌ని గుర్తించే సీక్వెన్షియల్ నంబర్‌ను పాస్ చేస్తుంది ( 1, 2, 3, ...).

3. టైమర్‌ను ఆఫ్ చేయండి

టైమర్ ఇకపై అవసరం లేనట్లయితే, ఉదాహరణకు వినియోగదారు గేమ్‌ను పూర్తి చేసినందున, దానిని ఆఫ్ చేయవచ్చు. దీన్ని చేయడానికి, కేవలం stopTurnTimer()పద్ధతిని కాల్ చేయండి.

4 టైమర్‌ను వేగవంతం చేయండి/మార్చండి

కొన్ని గేమ్‌లలో, ఈవెంట్‌ల ఫ్రీక్వెన్సీ క్రమం తప్పకుండా పెరుగుతుంది, కాబట్టి మా టైమర్‌ను వేగవంతం చేయడం సౌకర్యంగా ఉంటుంది, అంటే కాల్‌బ్యాక్‌ల మధ్య సమయాన్ని తగ్గించడం. మరియు ఏదీ సులభం కాదు — setTurnTimer(int timeMs)కొత్త విలువతో మళ్లీ కాల్ చేయండి మరియు కాల్‌ల మధ్య సమయం onTurn()మారుతుంది.

ఉదాహరణ:

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

ఈ సరళమైన ఉదాహరణలో, మేము 3 సెల్‌లు 3 సెల్‌ల ఫీల్డ్‌ని సృష్టించాము. అప్పుడు మేము ప్రతి అర్ధ సెకనుకు పద్ధతిని కాల్ చేసే టైమర్‌ను ఆన్ చేసాము onTurn().

ఇక్కడ, సెంట్రల్ సెల్ యొక్క రంగు ప్రతి అర్ధ సెకనుకు మారుతుంది. సెల్ యొక్క వచనం మారదు. 50 సెకన్ల తర్వాత (100 కాల్‌బ్యాక్‌లు), రంగు మారడం ఆగిపోతుంది మరియు టైమర్ ఆఫ్ అవుతుంది.