కోడ్‌జిమ్‌లో ఆటల విభాగం: ఈవెంట్ హ్యాండ్లింగ్

CodeGym నుండి "గేమ్‌లు" అనేది పెద్ద ఆసక్తికరమైన టాస్క్‌లతో కూడిన కొత్త విభాగం, ఇక్కడ మీరు జనాదరణ పొందిన గేమ్‌ల యొక్క మీ స్వంత వెర్షన్‌లను సృష్టించవచ్చు. ఇది చాలా సులభం: ప్రతి గేమ్ ప్రాజెక్ట్ సబ్‌టాస్క్‌లుగా విభజించబడింది. వాటిని ఒక్కొక్కటిగా పూర్తి చేయండి మరియు ఆట పూర్తయింది. మీరు దీన్ని సోషల్ నెట్‌వర్క్‌లలో భాగస్వామ్యం చేయవచ్చు మరియు మీ స్నేహితులను ఆడటానికి ఆహ్వానించవచ్చు. ఈ కథనంలో, మేము గేమ్‌లను వ్రాయడానికి ఉపయోగించే ఈవెంట్ హ్యాండ్లింగ్ పద్ధతులను వివరంగా వివరిస్తాము .

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

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

• void onMouseLeftClick(int x, int y);

• void onMouseRightClick(int x, int y);

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

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

2. 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) {
        // 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. కీబోర్డ్‌తో పని చేయడం

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

• void onKeyPress(Key key);

• void onKeyReleased(Key key);

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

1. onKeyPress(Key key)— ఏదైనా కీ నొక్కినప్పుడు అంటారు. కీ పరామితి నొక్కిన కీ (లేదా Key.UNKNOWN).

2. onKeyReleased(Key key)— ఏదైనా కీ విడుదలైనప్పుడు పిలుస్తారు. కీ పరామితి సంబంధిత కీ (లేదా Key.UNKNOWN).

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

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

ముఖ్యమైనది! గేమ్ ఇంజిన్ యొక్క ప్రస్తుత వెర్షన్‌లో, కీ రకం తొమ్మిది విలువల పరిమిత సెట్‌ను కలిగి ఉంది:

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

అనేక గేమ్‌లు నిజ సమయంలో జరుగుతాయి, అంటే వినియోగదారు ఏమీ చేయకపోయినా, ఈవెంట్‌లు ఇప్పటికీ గేమ్‌లో జరుగుతాయి. అటువంటి గేమ్‌లను అమలు చేయడానికి మిమ్మల్ని ప్రారంభించడానికి, మేము గేమ్ ఇంజిన్‌కి టైమర్‌ని జోడించాము. ఇది ఇలాగే పని చేస్తుంది: మీరు టైమర్‌ను ఆన్ చేసి, టైమర్ విరామాన్ని సెట్ చేయండి. ఉదాహరణకు, 500 మిల్లీసెకన్లు. అప్పుడు, ప్రతి సగం సెకను గేమ్ ఇంజిన్ onTurnTimer()పద్ధతిని పిలుస్తుంది. మళ్లీ మళ్లీ ఎప్పటికీ - టైమర్ ఆఫ్ చేయబడే వరకు. కాబట్టి మీరు టైమర్‌ను ఎలా ఉపయోగించాలి?

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

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

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

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

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

        }
    }
    …
}

ఈ సాధారణ ఉదాహరణలో, మేము 3 సెల్‌లు x 3 సెల్‌ల ఫీల్డ్‌ని సృష్టించాము. onTurn()అప్పుడు మేము ప్రతి అర్ధ సెకనుకు పద్ధతిని పిలిచే టైమర్‌ను ప్రారంభించాము . ప్రతి అర్ధ సెకను, సెల్ రంగు మారుతుంది, కానీ దాని కంటెంట్ మారదు. 50 సెకన్ల తర్వాత, రంగు మారదు. ఇప్పటికి ఇంతే! మీరు "గేమ్స్" విభాగం గురించి మరింత తెలుసుకోవాలనుకుంటే, సహాయపడే కొన్ని ఉపయోగకరమైన డాక్యుమెంటేషన్ ఇక్కడ ఉంది: