Spelsektionen på CodeGym: Spelmotor

"Spel" från CodeGym är en ny sektion med stora uppgifter som går ut på att skriva populära dataspel. De är lättare att skapa än det verkar: varje projekt är uppdelat i tjugo deluppgifter. Genom att slutföra uppgifter steg för steg kommer du att skriva ditt eget spel och sedan kan du lägga till unika funktioner och dela det med vänner. Sektionen "Spel" på CodeGym: Spelmotor - 1

Sektionen "Spel" på CodeGym: Spelmotor - 1

Spelen använder den enkla spelmotorn CodeGym . I den här artikeln kommer vi att beskriva dess nyckelfunktioner och hur spelskrivningsprocessen ser ut.

1. Introduktion

För utvecklaren finns det tre steg för implementeringen av ett datorspel:

Spelinitiering — Det här steget består av förberedande åtgärder: ställa in storleken på spelplanen, rita spelplanen, skapa spelobjekt och placera dem i deras initiala positioner och andra åtgärder som måste utföras i början av spelet.
Spelprocess. Det här steget inkluderar rörliga spelobjekt, spelaråtgärder, att hålla poäng och andra åtgärder som måste utföras vid en viss frekvens eller när knappar trycks ned.
Spelet är klart. Detta steg inkluderar att stoppa animeringen, rapportera en vinst eller förlust och andra åtgärder som måste utföras i slutet av spelet.

2. Spelinitiering

Spelinitiering består av endast två steg: Steg 1: Skapa spelets huvudklass. För att utveckla ditt eget spel med hjälp av CodeGym-spelmotorn måste du skapa en klass som ärver klassen ( Gamecom.codegym.engine.cell.Game). Detta ger din klass möjlighet att anropa spelmotorns metoder och ger motorn möjlighet att anropa dina metoder. Till exempel:


import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Steg 2: Åsidosätt initialiseringsmetoden(). Alla åtgärder som krävs för att starta spelet kommer att ske med den här metoden: skapa spelplanen, skapa spelobjekt, etc. Du behöver helt enkelt deklarera denna metod i klassen som ärver klassen Game. Till exempel:


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

Metoden initialize()är analog med main()metoden: den är utgångspunkten för all kod som skrivits för spelet.

3. Skapa en spelplan

Att skapa en spelplan består också av endast två steg. Steg 1: Dela upp spelplanen i celler. Hela spelplanen är uppdelad i celler av spelmotorn. Minsta storlek är 3x3; max är 100x100. Måtten på spelskärmen är konstanta. Det kan delas in i olika antal celler. Till exempel, 7 celler breda och 9 celler höga: Sektionen "Spel" på CodeGym: Spelmotor - 2

Sektionen "Spel" på CodeGym: Spelmotor - 2

Observera att cellerna är numrerade från det övre vänstra hörnet. void setScreenSize(int width, int height)Använd metoden för att ställa in storleken på spelplanen. Den anger storleken på spelplanen. Dess parametrar representerar antalet celler horisontellt (bredd) och vertikalt (höjd). Det brukar kallas en gång när spelet startas. Till exempel:


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

När du skriver ett spel kan du behöva få spelplanens aktuella bredd och höjd. För att göra detta kommer metoderna int getScreenWidth()och att vara användbara. Steg 2: Slå på eller av gallret (valfritt). Om du inte gillar det svarta rutnätet som separerar cellerna på spelplanen kan du stänga av det. Metoden slår på och av nätet. Som standard visas rutnätet. För att stänga av den, anrop den här metoden med false som argument: int getScreenHeight()void showGrid(boolean isShow)


showGrid(false);

Resultat:

Sektionen "Spel" på CodeGym: Spelmotor - 3

För att slå på nätet igen, ring:


showGrid(true);

4. Ett primitivt program

Här är ett exempel på ett program:


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

I det här exemplet är spelfältet inställt på 3x3, rutnätet är avstängt och ett orange "X" halva cellstorleken är satt på en blå bakgrund i mittcellen. Detta kommer att vara det första spelaren ser när spelet startar.

5. Arbeta med celler på spelplanen

Att vi kan dela upp spelplanen i celler är jättebra, men vad kan vi göra med själva cellerna? Du kan ställa in följande egenskaper för varje cell på spelplanen:

cellfärg (cellbakgrundsfärg);
text (text eller nummer);
text färg;
textstorlek i procent av cellstorleken.

Låt oss titta på metoderna för att arbeta med cellerna på spelfältet :

void setCellColor(int x, int y, Color color)— ställer in cellens färg med koordinater (x, y):


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

Color getCellColor(int x, int y)— returnerar cellens färg med koordinater (x, y):
```
Color myColor = getCellColor(2, 0);
```

void setCellValue(int x, int y, String value)— ställer in cellens text med koordinater (x, y) lika med strängen i värdeparametern:
```
setCellValue(3, 3, "text");
setCellValue(0, 8, "W");
setCellValue(4, 1, "2222");
setCellValue(6, 6, "");
```

String getCellValue(int x, int y)— returnerar texten i cellen med koordinater (x, y):
```
String s = getCellValue(3, 3);
System.out.println(getCellValue(4, 1));
```

void setCellTextSize(int x, int y, int size)— ställer in storleken på innehållet i cellen med koordinater (x, y). Storleksparametern är texthöjden i procent av cellhöjden:
```
setCellTextSize(2 , 0, 70); // 70% of the cell height
```

int getCellTextSize(int x, int y)— returnerar storleken på innehållet i cellen med koordinater (x, y):
```
int size = getCellTextSize(2 , 0);
```

void setCellNumber(int x, int y, int value)— ställer in cellens text med koordinater (x, y) lika med numret i värdeparametern:
```
setCellNumber(3, 3, 40);
setCellNumber(0, 8, -8);
setCellNumber(4, 1, 2222);
setCellNumber(6, 6, 0);
```

int getCellNumber(int x, int y)— returnerar talet som finns i cellen med koordinater (x, y). Om cellen inte innehåller ett tal, returnerar 0:
```
int i = getCellNumber(3, 3);
System.out.println(getCellNumber(4, 1));
```

void setCellTextColor(int x, int y, Color color)— ställer in färgen på innehållet (text) i cellen med koordinater (x, y):
```
setCellTextColor(2, 1, Color.GREEN);
setCellTextColor(0, 1, Color.NONE);
```

Color getCellTextColor(int x, int y)— returnerar färgen på cellens innehåll (text) med koordinater (x, y):
```
Color textColor = getCellTextColor(1, 3);
```

För enkelhetens skull finns det flera setCellValueEx()metoder med olika uppsättningar av parametrar:

void setCellValueEx(int x, int y, Color cellColor, String value)— ställer in bakgrundsfärgen (cellColor) och innehållet (värde) för cellen med koordinater (x, y):
```
setCellValueEx(0, 2, Color.BLUE, "56");
```

void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— ställer in bakgrundsfärgen (cellColor), innehåll (värde) och textfärg (textColor) för cellen med koordinater (x, y):
```
setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);
```

void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)— ställer in bakgrundsfärgen (cellColor), innehåll (värde), textfärg (textColor) och textstorlek (textSize) för cellen med koordinater (x, y):
```
setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);
```

6. Arbeta med färg

Den Color enumansvarar för färgerna i spelmotorn. Den har unika värden för 148 färger. Den har också ett speciellt värde (NONE) som inte representerar någon färg. Här är ett exempel på att arbeta med färg:


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.

Ibland kan du behöva skaffa en uppsättning av alla befintliga färger. För att göra detta, använd values()metoden. Till exempel:


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

Det är väldigt enkelt att få fram en färgs index i paletten:


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

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

Du kan också få en färg genom dess index:


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

7. Dialogrutor

I slutet av spelet måste du rapportera en vinst eller förlust till spelaren. För att göra detta finns det en speciell metod som visar en dialogruta på spelskärmen:


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

Här:

cellColorär bakgrundsfärgen för dialogrutan;
messageär texten i meddelandet;
textColorär färgen på meddelandetexten;
textSizeär storleken på meddelandetexten.

Dialogrutan stängs av sig själv om användaren trycker på mellanslagstangenten.

8. Användningsmetoder

När man skriver spel används slumptal mycket. För att göra det lättare att få slumpmässiga siffror kan du använda följande verktygsmetoder från spelmotorn:

int getRandomNumber(int max)— returnerar ett slumpmässigt heltal från 0 till (max-1).
int getRandomNumber(int min, int max)— returnerar ett slumpmässigt heltal från min till (max-1) inklusive.

Det var allt tills vidare! Om du vill lära dig mer om avsnittet "Spel", här är lite användbar dokumentation som kan hjälpa:

Mer läsning:
Avsnittet "Spel" på CodeGym: Populära frågor Avsnittet "Spel" på CodeGym: Eventhantering Avsnittet "Spel" på CodeGym: Användbar teori