Games-sectie op CodeGym: Game-engine

"Games" van CodeGym is een nieuwe sectie met grote taken die betrekking hebben op het schrijven van populaire computerspellen. Ze zijn makkelijker te maken dan het lijkt: elk project is opgedeeld in twintig subtaken. Door taken stap voor stap te voltooien, schrijf je je eigen spel en kun je unieke functies toevoegen en delen met vrienden. "Games" sectie op CodeGym: Game-engine - 1

De spellen maken gebruik van de eenvoudige CodeGym game engine . In dit artikel beschrijven we de belangrijkste functies en hoe het schrijfproces van een game eruitziet.

1. Inleiding

Voor de ontwikkelaar zijn er drie fasen bij de implementatie van een computerspel:

Spelinitialisatie - Deze fase bestaat uit voorbereidende acties: de grootte van het speelveld instellen, het speelveld tekenen, spelobjecten maken en ze in hun oorspronkelijke posities plaatsen, en andere acties die aan het begin van het spel moeten worden uitgevoerd.
Spel proces. Deze fase omvat het verplaatsen van spelobjecten, acties van spelers, het bijhouden van de score en andere acties die moeten worden uitgevoerd met een bepaalde frequentie of wanneer er op knoppen wordt gedrukt.
Voltooiing van het spel. Deze fase omvat het stoppen van de animatie, het melden van winst of verlies en andere acties die aan het einde van het spel moeten worden uitgevoerd.

2. Spelinitialisatie

Spelinitialisatie bestaat uit slechts twee stappen: Stap 1: Maak de hoofdklasse van het spel aan. Om je eigen game te ontwikkelen met de CodeGym-game-engine, moet je een klasse maken die de Gameklasse overerft (com.codegym.engine.cell.Game). Dit geeft je klas de mogelijkheid om de methoden van de game-engine aan te roepen, en geeft de engine de mogelijkheid om jouw methoden aan te roepen. Bijvoorbeeld:


import com.codegym.engine.cell.Game;

public class MySuperGame extends Game {
    ...
}

Stap 2: Negeer de initialisatiemethode(). Alle acties die nodig zijn om het spel te starten, vinden plaats in deze methode: het speelveld maken, spelobjecten maken, enz. Je hoeft deze methode alleen maar te declareren in de klasse die de Gameklasse erft. Bijvoorbeeld:


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

De initialize()methode is analoog aan de main()methode: het is het startpunt voor alle code die voor het spel wordt geschreven.

3. Een speelveld creëren

Ook het creëren van een speelveld bestaat uit slechts twee stappen. Stap 1: Verdeel het speelveld in cellen. Het gehele speelveld wordt door de game-engine in cellen verdeeld. De minimale maat is 3x3; het maximum is 100x100. De afmetingen van het spelscherm zijn constant. Het kan worden onderverdeeld in verschillende aantallen cellen. Bijvoorbeeld 7 cellen breed bij 9 cellen hoog: "Games" sectie op CodeGym: Game engine - 2

"Games" sectie op CodeGym: Game engine - 2

Houd er rekening mee dat cellen worden genummerd vanaf de linkerbovenhoek. Gebruik de methode om de grootte van het speelveld in te stellen void setScreenSize(int width, int height). Het bepaalt de grootte van het speelveld. De parameters vertegenwoordigen het aantal cellen horizontaal (breedte) en verticaal (hoogte). Het wordt meestal een keer aangeroepen wanneer het spel wordt gestart. Bijvoorbeeld:


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

Bij het schrijven van een game moet u mogelijk de huidige breedte en hoogte van het speelveld weten. Om dit te doen, zullen de methoden int getScreenWidth()en int getScreenHeight()van pas komen. Stap 2: Zet het rooster aan of uit (optioneel). Als je het zwarte raster dat de cellen op het speelveld scheidt niet leuk vindt, kun je het uitschakelen. De void showGrid(boolean isShow)methode zet het raster aan en uit. Standaard wordt het raster weergegeven. Om het uit te schakelen, roept u deze methode aan met false als argument:


showGrid(false);

Resultaat: "Games" sectie op CodeGym: Game engine - 3

Om het elektriciteitsnet weer aan te zetten, belt u:


showGrid(true);

4. Een primitief programma

Hier is een voorbeeld van een programma:


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

In dit voorbeeld is het speelveld ingesteld op 3x3, is het raster uitgeschakeld en is een oranje "X" voor de helft van de celgrootte ingesteld op een blauwe achtergrond in de middelste cel. Dit is het eerste dat de speler ziet wanneer het spel begint.

5. Werken met cellen van het speelveld

Dat we het speelveld in cellen kunnen verdelen is mooi, maar wat kunnen we met de cellen zelf? Per cel van het speelveld kun je de volgende eigenschappen instellen:

celkleur (celachtergrondkleur);
tekst (tekst of cijfer);
tekst kleur;
tekstgrootte als percentage van de celgrootte.

Laten we eens kijken naar de methoden om met de cellen van het speelveld te werken :

void setCellColor(int x, int y, Color color)— stelt de kleur van de cel in met coördinaten (x, y):
```
setCellColor(0, 0, Color.RED);
setCellColor(3, 6, Color.BLACK);
setCellColor(6, 8, Color.NONE);
```

Color getCellColor(int x, int y)— geeft de kleur van de cel met coördinaten (x, y):
```
Color myColor = getCellColor(2, 0);
```

void setCellValue(int x, int y, String value)— stelt de tekst van de cel in met coördinaten (x, y) gelijk aan de tekenreeks in de waardeparameter:
```
setCellValue(3, 3, "text");
setCellValue(0, 8, "W");
setCellValue(4, 1, "2222");
setCellValue(6, 6, "");
```

String getCellValue(int x, int y)— retourneert de tekst in de cel met coördinaten (x, y):
```
String s = getCellValue(3, 3);
System.out.println(getCellValue(4, 1));
```

void setCellTextSize(int x, int y, int size)— stelt de grootte van de inhoud van de cel in met coördinaten (x, y). De grootteparameter is de teksthoogte als een percentage van de celhoogte:
```
setCellTextSize(2 , 0, 70); // 70% of the cell height
```

int getCellTextSize(int x, int y)— geeft de grootte van de inhoud van de cel met coördinaten (x, y):
```
int size = getCellTextSize(2 , 0);
```

void setCellNumber(int x, int y, int value)— stelt de tekst van de cel in met coördinaten (x, y) gelijk aan het getal in de waardeparameter:
```
setCellNumber(3, 3, 40);
setCellNumber(0, 8, -8);
setCellNumber(4, 1, 2222);
setCellNumber(6, 6, 0);
```

int getCellNumber(int x, int y)— retourneert het getal in de cel met coördinaten (x, y). Als de cel geen getal bevat, wordt 0 geretourneerd:
```
int i = getCellNumber(3, 3);
System.out.println(getCellNumber(4, 1));
```

void setCellTextColor(int x, int y, Color color)— stelt de kleur in van de inhoud (tekst) van de cel met coördinaten (x, y):
```
setCellTextColor(2, 1, Color.GREEN);
setCellTextColor(0, 1, Color.NONE);
```

Color getCellTextColor(int x, int y)— geeft de kleur van de inhoud (tekst) van de cel met coördinaten (x, y):
```
Color textColor = getCellTextColor(1, 3);
```

Voor het gemak zijn er verschillende setCellValueEx()methoden met verschillende sets parameters:

void setCellValueEx(int x, int y, Color cellColor, String value)— stelt de achtergrondkleur (cellColor) en inhoud (waarde) van de cel in met coördinaten (x, y):
```
setCellValueEx(0, 2, Color.BLUE, "56");
```

void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor)— stelt de achtergrondkleur (cellColor), inhoud (waarde) en tekstkleur (textColor) van de cel in met coördinaten (x, y):
```
setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN);
```

void setCellValueEx(int x, int y, Color cellColor, String value, Color textColor, int textSize)— stelt de achtergrondkleur (cellColor), inhoud (waarde), tekstkleur (textColor) en tekstgrootte (textSize) van de cel in met coördinaten (x, y):
```
setCellValueEx(0, 2, Color.BLACK, "56", Color.GREEN, 70);
```

6. Werken met kleur

Het Color enumis verantwoordelijk voor de kleuren in de game-engine. Het heeft unieke waarden voor 148 kleuren. Het heeft ook een speciale waarde (NONE) die geen kleur vertegenwoordigt. Hier is een voorbeeld van werken met kleur:


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.

Soms heeft u een reeks van alle bestaande kleuren nodig. Gebruik hiervoor de values()methode. Bijvoorbeeld:


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

Het is heel eenvoudig om de index van een kleur in het palet te krijgen:


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

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

U kunt ook een kleur krijgen op basis van de index:


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

7. Dialoogvensters

Aan het einde van het spel moet je een overwinning of verlies aan de speler melden. Om dit te doen, is er een speciale methode die een dialoogvenster op het spelscherm weergeeft:


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

Hier:

cellColoris de achtergrondkleur van het dialoogvenster;
messageis de tekst van het bericht;
textColoris de kleur van de berichttekst;
textSizeis de grootte van de berichttekst.

Het dialoogvenster sluit vanzelf als de gebruiker op de spatiebalk drukt.

8. Hulpmethoden

Bij het schrijven van spellen worden veel willekeurige getallen gebruikt. Om het gemakkelijker te maken om willekeurige getallen te krijgen, kunt u de volgende hulpprogramma's van de game-engine gebruiken:

int getRandomNumber(int max)— geeft een willekeurig geheel getal terug van 0 tot en met (max-1).
int getRandomNumber(int min, int max)— geeft een willekeurig geheel getal terug van min tot en met (max-1).

Dat is het voor nu! Als u meer wilt weten over het gedeelte "Games", vindt u hier wat nuttige documentatie die kan helpen:

Meer lezen:
"Games" sectie op CodeGym: Populaire vragen Sectie "Games" op CodeGym: Afhandeling van gebeurtenissen "Games" sectie op CodeGym: bruikbare theorie