కోడ్‌జిమ్‌లో ఆటల విభాగం: గేమ్ ఇంజిన్

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

1. పరిచయం

డెవలపర్ కోసం, కంప్యూటర్ గేమ్ అమలులో మూడు దశలు ఉన్నాయి:

1. గేమ్ ప్రారంభించడం — ఈ దశలో సన్నాహక చర్యలను కలిగి ఉంటుంది: మైదానం యొక్క పరిమాణాన్ని సెట్ చేయడం, మైదానాన్ని గీయడం, ఆట వస్తువులను సృష్టించడం మరియు వాటిని వాటి ప్రారంభ స్థానాల్లో ఉంచడం మరియు ఆట ప్రారంభంలో తప్పనిసరిగా చేయవలసిన ఇతర చర్యలు.

2. గేమ్ ప్రక్రియ. ఈ దశలో కదిలే గేమ్ ఆబ్జెక్ట్‌లు, ప్లేయర్ చర్యలు, కీపింగ్ స్కోర్ మరియు ఇతర చర్యలు ఉంటాయి, అవి నిర్దిష్ట ఫ్రీక్వెన్సీలో లేదా బటన్‌లను నొక్కినప్పుడు తప్పనిసరిగా చేయాలి.

3. గేమ్ పూర్తి. ఈ దశలో యానిమేషన్‌ను నిలిపివేయడం, గెలుపు లేదా ఓటమిని నివేదించడం మరియు గేమ్ ముగింపులో తప్పనిసరిగా చేయాల్సిన ఇతర చర్యలు ఉంటాయి.

2. గేమ్ ప్రారంభించడం

గేమ్ ప్రారంభించడం రెండు దశలను మాత్రమే కలిగి ఉంటుంది: దశ 1: గేమ్ యొక్క ప్రధాన తరగతిని సృష్టించండి. CodeGym గేమ్ ఇంజిన్‌ని ఉపయోగించి మీ స్వంత గేమ్‌ను అభివృద్ధి చేయడానికి, మీరు తరగతిని వారసత్వంగా పొందే తరగతిని సృష్టించాలి Game(com.codegym.engine.cell.Game). ఇది మీ తరగతికి గేమ్ ఇంజిన్ పద్ధతులకు కాల్ చేయగల సామర్థ్యాన్ని ఇస్తుంది మరియు ఇంజిన్‌కు మీ పద్ధతులకు కాల్ చేసే సామర్థ్యాన్ని అందిస్తుంది. ఉదాహరణకి:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

దశ 2: ప్రారంభ పద్ధతిని భర్తీ చేయండి(). ఆటను ప్రారంభించడానికి అవసరమైన అన్ని చర్యలు ఈ పద్ధతిలో జరుగుతాయి: ఆట మైదానాన్ని సృష్టించడం, గేమ్ వస్తువులను సృష్టించడం మొదలైనవి. మీరు ఈ పద్ధతిని తరగతిని వారసత్వంగా పొందే తరగతిలో ప్రకటించాలి Game. ఉదాహరణకి:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
        // Here we perform all actions to initialize the game and its objects
    }
}

పద్ధతి initialize()పద్ధతికి సారూప్యంగా ఉంటుంది main(): ఇది గేమ్ కోసం వ్రాసిన అన్ని కోడ్‌లకు ప్రారంభ స్థానం.

3. ఆట మైదానాన్ని సృష్టించడం

ఆట మైదానాన్ని సృష్టించడం కూడా రెండు దశలను మాత్రమే కలిగి ఉంటుంది. దశ 1: ఆట మైదానాన్ని సెల్‌లుగా విభజించండి. మొత్తం ఆట మైదానం గేమ్ ఇంజిన్ ద్వారా కణాలుగా విభజించబడింది. కనిష్ట పరిమాణం 3x3; గరిష్టంగా 100x100. గేమ్ స్క్రీన్ యొక్క కొలతలు స్థిరంగా ఉంటాయి. ఇది వివిధ కణాల సంఖ్యలుగా విభజించబడింది. ఉదాహరణకు, 7 సెల్స్ వెడల్పు 9 సెల్స్ ఎత్తు: ఎగువ ఎడమ మూల నుండి ప్రారంభించి సెల్‌లు లెక్కించబడతాయని గమనించండి. మైదానం యొక్క పరిమాణాన్ని సెట్ చేయడానికి, void setScreenSize(int width, int height)పద్ధతిని ఉపయోగించండి. ఇది మైదానం యొక్క పరిమాణాన్ని సెట్ చేస్తుంది. దీని పారామితులు అడ్డంగా (వెడల్పు) మరియు నిలువుగా (ఎత్తు) కణాల సంఖ్యను సూచిస్తాయి. సాధారణంగా ఆట ప్రారంభించినప్పుడు ఒకసారి అంటారు. ఉదాహరణకి:

import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {

    @Override
    public void initialize() {
       // Set the field size to 7 cells x 9 cells
       setScreenSize(7, 9);
        ...
    }
}

ఆటను వ్రాసేటప్పుడు, మీరు మైదానం యొక్క ప్రస్తుత వెడల్పు మరియు ఎత్తును పొందవలసి ఉంటుంది. దీన్ని చేయడానికి, int getScreenWidth()మరియు int getScreenHeight()పద్ధతులు ఉపయోగపడతాయి. దశ 2: గ్రిడ్‌ను ఆన్ లేదా ఆఫ్ చేయండి (ఐచ్ఛికం). ఆట మైదానంలో సెల్‌లను వేరు చేసే బ్లాక్ గ్రిడ్ మీకు నచ్చకపోతే, మీరు దాన్ని ఆఫ్ చేయవచ్చు. పద్ధతి void showGrid(boolean isShow)గ్రిడ్‌ను ఆన్ మరియు ఆఫ్ చేస్తుంది. డిఫాల్ట్‌గా, గ్రిడ్ ప్రదర్శించబడుతుంది. దీన్ని ఆఫ్ చేయడానికి, ఈ పద్ధతిని తప్పుడు వాదనతో కాల్ చేయండి:

showGrid(false);

ఫలితం: గ్రిడ్‌ని తిరిగి ఆన్ చేయడానికి, కాల్ చేయండి:

showGrid(true);

4. ఒక ఆదిమ కార్యక్రమం

ప్రోగ్రామ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది:

public class MySuperGame extends Game {

    @Override
    public void initialize() {

        // Create a playing field that is 3 cells x 3 cells
        setScreenSize(3, 3);
        // Turn off the grid
        showGrid(false);
        // Change the background of the center cell to blue, and display an "X" in it.
        setCellValueEx(1, 1, Color.BLUE, "X", Color.ORANGE, 50);
    }
}

ఈ ఉదాహరణలో, గేమ్ ఫీల్డ్ 3x3కి సెట్ చేయబడింది, గ్రిడ్ ఆఫ్ చేయబడింది మరియు మధ్య సెల్‌లో నీలిరంగు బ్యాక్‌గ్రౌండ్‌లో నారింజ "X" సగం సెల్ పరిమాణం సెట్ చేయబడింది. ఆట ప్రారంభమైనప్పుడు ఆటగాడు చూసే మొదటి విషయం ఇదే.

5. మైదానం యొక్క కణాలతో పని చేయడం

మనం ఆట మైదానాన్ని కణాలుగా విభజించగలమనే వాస్తవం గొప్పది, అయితే కణాలతో మనం ఏమి చేయగలం? మీరు మైదానంలోని ప్రతి సెల్ కోసం క్రింది లక్షణాలను సెట్ చేయవచ్చు:

• సెల్ రంగు (సెల్ నేపథ్య రంగు);
• టెక్స్ట్ (టెక్స్ట్ లేదా నంబర్);
• టెక్స్ట్ రంగు;
• సెల్ పరిమాణంలో ఒక శాతంగా వచన పరిమాణం.

మైదానం యొక్క కణాలతో పని చేసే పద్ధతులను చూద్దాం :

1. void setCellColor(int x, int y, Color color)- సెల్ రంగును కోఆర్డినేట్‌లతో సెట్ చేస్తుంది (x, y):

   setCellColor(0, 0, Color.RED);
   setCellColor(3, 6, Color.BLACK);
   setCellColor(6, 8, Color.NONE);




2. Color getCellColor(int x, int y)- కోఆర్డినేట్‌లతో సెల్ రంగును అందిస్తుంది (x, y):

   Color myColor = getCellColor(2, 0);




3. void setCellValue(int x, int y, String value)— విలువ పరామితిలోని స్ట్రింగ్‌కు సమానమైన కోఆర్డినేట్‌లతో (x, y) సెల్ యొక్క వచనాన్ని సెట్ చేస్తుంది:

   setCellValue(3, 3, "text");
   setCellValue(0, 8, "W");
   setCellValue(4, 1, "2222");
   setCellValue(6, 6, "");




4. String getCellValue(int x, int y)— సెల్‌లో ఉన్న వచనాన్ని అక్షాంశాలతో (x, y) అందిస్తుంది:

   String s = getCellValue(3, 3);
   System.out.println(getCellValue(4, 1));




5. void setCellTextSize(int x, int y, int size)- సెల్ యొక్క కంటెంట్‌ల పరిమాణాన్ని అక్షాంశాలతో (x, y) సెట్ చేస్తుంది. పరిమాణం పరామితి అనేది సెల్ ఎత్తులో ఒక శాతంగా ఉన్న టెక్స్ట్ ఎత్తు:

   setCellTextSize(2 , 0, 70); // 70% of the cell height




6. int getCellTextSize(int x, int y)- సెల్‌లోని కంటెంట్‌ల పరిమాణాన్ని అక్షాంశాలతో (x, y) అందిస్తుంది:

   int size = getCellTextSize(2 , 0);




7. void setCellNumber(int x, int y, int value)- విలువ పరామితిలోని సంఖ్యకు సమానమైన కోఆర్డినేట్‌లతో (x, y) సెల్ యొక్క వచనాన్ని సెట్ చేస్తుంది:

   setCellNumber(3, 3, 40);
   setCellNumber(0, 8, -8);
   setCellNumber(4, 1, 2222);
   setCellNumber(6, 6, 0);




8. int getCellNumber(int x, int y)- కోఆర్డినేట్‌లతో (x, y) సెల్‌లో ఉన్న సంఖ్యను అందిస్తుంది. సెల్ సంఖ్యను కలిగి ఉండకపోతే, 0ని అందిస్తుంది:

   int i = getCellNumber(3, 3);
   System.out.println(getCellNumber(4, 1));




9. void setCellTextColor(int x, int y, Color color)- సెల్ యొక్క కంటెంట్‌ల (టెక్స్ట్) రంగును అక్షాంశాలతో (x, y) సెట్ చేస్తుంది:

   setCellTextColor(2, 1, Color.GREEN);
   setCellTextColor(0, 1, Color.NONE);




10. Color getCellTextColor(int x, int y)- అక్షాంశాలతో (x, y) సెల్ యొక్క కంటెంట్‌ల (టెక్స్ట్) రంగును అందిస్తుంది:

    Color textColor = getCellTextColor(1, 3);

setCellValueEx()సౌలభ్యం కోసం, వివిధ సెట్ల పారామితులతో అనేక పద్ధతులు ఉన్నాయి :

1. void setCellValueEx(int x, int y, Color cellColor, String value)- కోఆర్డినేట్‌లతో (x, y) సెల్ యొక్క నేపథ్య రంగు (సెల్ కలర్) మరియు కంటెంట్‌లను (విలువ) సెట్ చేస్తుంది:

   setCellValueEx(0, 2, Color.BLUE, "56");




2. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— కోఆర్డినేట్‌లతో (x, y) సెల్ యొక్క నేపథ్య రంగు (సెల్ కలర్), కంటెంట్‌లు (విలువ) మరియు వచన రంగు (టెక్స్ట్ కలర్) సెట్ చేస్తుంది:

   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);




3. void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)— సెల్ యొక్క నేపథ్య రంగు (సెల్ కలర్), కంటెంట్‌లు (విలువ), టెక్స్ట్ కలర్ (టెక్స్ట్ కలర్), మరియు టెక్స్ట్ సైజు (టెక్స్ట్ సైజ్)ను కోఆర్డినేట్‌లతో (x, y) సెట్ చేస్తుంది:

   setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);

6. రంగుతో పని చేయడం

Color enumగేమ్ ఇంజిన్‌లోని రంగులకు ఇది బాధ్యత వహిస్తుంది. ఇది 148 రంగులకు ప్రత్యేక విలువలను కలిగి ఉంది. ఇది రంగును సూచించని ప్రత్యేక విలువ (NONE) కూడా కలిగి ఉంది. రంగుతో పని చేసే ఉదాహరణ ఇక్కడ ఉంది:

Color myColor = Color.WHITE;  // The myColor variable is set to white.
Color redColor = Color.RED;  // The redColor variable is set to red.
Color blueColor = Color.BLUE;  // The blueColor variable is set to light blue.

కొన్నిసార్లు మీరు ఇప్పటికే ఉన్న అన్ని రంగుల శ్రేణిని పొందవలసి ఉంటుంది. దీన్ని చేయడానికి, values()పద్ధతిని ఉపయోగించండి. ఉదాహరణకి:

Color[] colors = Color.values();  // The colors variable is assigned an array containing all available colors.

పాలెట్‌లో రంగుల సూచికను పొందడం చాలా సులభం:

Color color = Color.RED;
int redIndex = color.ordinal();  // Index of red

int blueIndex = Color.BLUE.ordinal();  // Index of blue

మీరు దాని సూచిక ద్వారా రంగును కూడా పొందవచ్చు:

Color color = Color.values()[10];  // The color variable is assigned the color with index 10 in the Color enum.

7. డైలాగ్ బాక్స్‌లు

ఆట ముగింపులో, మీరు ఆటగాడికి గెలుపు లేదా ఓటమిని నివేదించాలి. దీన్ని చేయడానికి, గేమ్ స్క్రీన్‌పై డైలాగ్ బాక్స్‌ను ప్రదర్శించే ప్రత్యేక పద్ధతి ఉంది:

void showMessageDialog(Color cellColor, String message, Color textColor, int textSize)

ఇక్కడ:

• cellColorడైలాగ్ బాక్స్ యొక్క నేపథ్య రంగు;
• messageసందేశం యొక్క వచనం;
• textColorసందేశం యొక్క రంగు;
• textSizeఅనేది మెసేజ్ టెక్స్ట్ పరిమాణం.

వినియోగదారు స్పేస్ బార్‌ను నొక్కితే డైలాగ్ బాక్స్ దానంతట అదే మూసివేయబడుతుంది.

8. యుటిలిటీ పద్ధతులు

ఆటలు రాసేటప్పుడు, యాదృచ్ఛిక సంఖ్యలు ఎక్కువగా ఉపయోగించబడతాయి. యాదృచ్ఛిక సంఖ్యలను పొందడం సులభతరం చేయడానికి, మీరు గేమ్ ఇంజిన్ అందించిన క్రింది యుటిలిటీ పద్ధతులను ఉపయోగించవచ్చు:

1. int getRandomNumber(int max)— యాదృచ్ఛిక పూర్ణాంకాన్ని 0 నుండి (గరిష్టంగా-1) కలుపుకొని తిరిగి ఇస్తుంది.

2. int getRandomNumber(int min, int max)— యాదృచ్ఛిక పూర్ణాంకాన్ని నిమి నుండి (గరిష్టంగా-1) కలుపుకొని తిరిగి ఇస్తుంది.

ఇప్పటికి ఇంతే! మీరు "గేమ్స్" విభాగం గురించి మరింత తెలుసుకోవాలనుకుంటే, సహాయపడే కొన్ని ఉపయోగకరమైన డాక్యుమెంటేషన్ ఇక్కడ ఉంది: