Virtuální hrací pole

V minulém díle jsme si založili structuru sGAME_FIELD a její proměnnou l_gameField, která představuje naše virtuální pole. Každá kostička v tomto poli obsahuje třídu pro kostičku a může mít celkem tři stavy. Buď zde nic není a tím pádem bude s_Sprite roven NULL, obsahuje kostičku s_Sprite a ta se buď pohybuje nebo je „skamenělá“. Tedy proměnná l_status označuje existenci kostičky a l_isFixed její pohyblivost. Pole si je možné představit jako takovou neviditelnou šachovnici.

Jaká bude další kostička

V našem boxu Další si vygenerujeme novou kostičku. Nejdříve si do konstruktoru vytvoříme náhodné generování:

qsrand(time(NULL));

l_currentType   = (qrand() % 8)+1;
l_nextType      = (qrand() % 8)+1;

Tím zajistíme, že náš program ví, kterou kostičkou má hra začínat a jakou vypustí jako následující (generování je náhodné). Jednoduše budeme generovat čísla od 1 – 8 a každé znich představuje určitý typ kostičky (já jsem zvolil pro příklad 8 kostiček). Vytvoříme novou metodu v tetris.cpp pro vykreslování našich náhodných kostiček:

void CTetris::paintNextSprite(QPainter* a_painter)
{
    if (l_isStart)
    {
        switch(l_nextType)
        {
            case 1:
                l_GameField->DrawSprite1(a_painter);
                break;
            case 2:
                l_GameField->DrawSprite2(a_painter);
                break;
            case 3:
                l_GameField->DrawSprite3(a_painter);
                break;
            case 4:
                l_GameField->DrawSprite4(a_painter);
                break;
            case 5:
                l_GameField->DrawSprite5(a_painter);
                break;
            case 6:
                l_GameField->DrawSprite6(a_painter);
                break;
            case 7:
                l_GameField->DrawSprite7(a_painter);
                break;
            case 8:
                l_GameField->DrawSprite8(a_painter);
                break;
        }
    }
}

Tado metoda vždy vykreslí do našeho okna kostičku, která bude následovat hned jak dopadne aktuální pohyblivá kostička (všechny políčka v hracím poli nabydou hodnoty l_isFixed = true). Dále si vytvoříme do projektu novou třídu představující jednu kostičku, pojmenovanou CCube. Třída by mohla vypadat takto:

#ifndef CUBE_H
#define CUBE_H

#include 
#include 
#include 

#define WIDTH   30
#define HEIGHT  30

#define WIDTH_PREV   20
#define HEIGHT_PREV  20

class CCube
{
public:
    CCube();
    void Draw(QPainter* painter);
    void DrawReal(QPainter* painter);
    void setPozition(int a_x, int a_y);
    void setColor(int r, int g, int b);
    void autoMove();
    void moveLeft();
    void moveRight();
    QPoint getPos();
    QColor getColor();

protected:
    int l_x;
    int l_y;
    QColor l_color;
};

#endif // CUBE_H

Třída nám vykreslí jednu kostičku do hracího pole metodou DrawReal, tak i kostičku do pozice následující hrací kostičky metodou Draw. Metody pak budou vypadat takto:

void CCube::Draw(QPainter* painter)
{
    painter->setPen(l_color);
    painter->fillRect(l_x, l_y, WIDTH_PREV, HEIGHT_PREV, l_color);
    QRectF rectangle(l_x, l_y, WIDTH_PREV, HEIGHT_PREV);

    painter->drawRect(rectangle);
}

void CCube::DrawReal(QPainter* painter)
{
    painter->setPen(l_color);
    painter->fillRect(l_x, l_y, WIDTH, HEIGHT, l_color);
    QRectF rectangle(l_x, l_y, WIDTH, HEIGHT);

    painter->drawRect(rectangle);
}

Metoda by šla udělat pouze jedna s dalším parametrem. Možností je více. Můžete si zkusit různé experimenty. Důležeté je povšimnout si praktického využití knihovny Qt4. V našich dvouch metodách jsme využili metodu pro nastavení barvy setPen (pro okraje) a pro vyplnění pozadí naší kostičky fillRect. A konečně sama metoda pro vykreslování 4 úhelníků drawRect s parametrem QRectF pro určení souřadnic. Další metody naší třídy:

• setPozition – nastaví aktuální pozici
• setColor – nastaví aktuální barvu
• autoMove – automaticky nastaví pohyb směrem dolů
• moveLeft – pohyb vlevo
• moveRight – pohyb vpravo
• getPos – vrací aktuální pozici
• getColor – vrací aktuální barvu

Implementaci těchto metod si můžete vyzkoušet sami nebo si ji můžete stáhnout v příkladu. V třídě hracího pole CGameField si vytvoříme metody pro inicializaci „preview“ kostiček:

//Inicializacni metody
//-----------------------
void InitSprite1(void);
void InitSprite2(void);
void InitSprite3(void);
void InitSprite4(void);
void InitSprite5(void);
void InitSprite6(void);
void InitSprite7(void);
void InitSprite8(void);

Impementace by pak mohla být třeba takto:

void CGameField::InitSprite2(void)
{
    CCube* a_sprite = new CCube;
    a_sprite->setColor(255, 0, 0);
    a_sprite->setPozition(55, 130);

    CCube* a_sprite2 = new CCube;
    a_sprite2->setColor(255, 0, 0);
    a_sprite2->setPozition(75, 130);

    CCube* a_sprite3 = new CCube;
    a_sprite3->setColor(255, 0, 0);
    a_sprite3->setPozition(55, 110);

    CCube* a_sprite4 = new CCube;
    a_sprite4->setColor(255, 0, 0);
    a_sprite4->setPozition(75, 110);

    l_Sprite2.push_back(a_sprite);
    l_Sprite2.push_back(a_sprite2);
    l_Sprite2.push_back(a_sprite3);
    l_Sprite2.push_back(a_sprite4);
}

Toto například bude velká kostička tvořená čtyřmi menšími kostičkami. Každé části se nastaví pozice a barva jak je patrné z příkladu. Dále přidáme v tetris.cpp k metodě void CTetris::paintEvent(QPaintEvent *event) řádek paintNextSprite(&a_painter). Tím jsme si zajistili, že se nám vykreslí vždy následující kostičky vždy, když spustíme hru tlačítkem start. Aktivace tlačítka start Vytvoříme si metodu pro stisk tlačítka Start.

void CTetris::on_pushButton_clicked()
{
    l_GameField->Reset();
    ui->pushButton->setEnabled(false);
    l_isStart = true;
    l_GameField->AddNewSprite(l_currentType); //l_currentType

    repaint();

    l_timer = startTimer(100);
}

Po stisku provedeme metodu Reset hracího pole (pokud začínáme hru po skončení předchozí hry je potřeba resetovat hrací pole). Tlačítko Start deaktivujeme. Nastavíme proměnnou indikující zda je hra v běhu na hodnotu true. Metodou AddNewSprite (implementujeme si v dalším díle) si vložíme hrací kostku (podle náhodně vygenerované l_currentType). Provedeme překreslení našeho okna metodou repaint. A nakonec spustíme smyčku Timer (se 100ms). Implementace Reset metody pole bude vypadat následovně:

void CGameField::Reset(void)
{
    for (int x = 9; x >= 0; x--)
    {
        for (int y = 0; y < 17; y++)
        {
            l_gameField[x][y].l_isFixed = false;
            l_gameField[x][y].l_status = 0;
            delete l_gameField[x][y].s_Sprite;
            l_gameField[x][y].s_Sprite = new CCube;
        }
    }
    l_isMoved = false;
}

Timer smyčka se pak definuje takto:

void CTetris::timerEvent(QTimerEvent *event)
{
    repaint();
}

Závěr

Máme již hotové hrací pole a víme jaká bude vždy následovat kostička. Příště si doděláme engine pro vykreslení hracích kostiček, uděláme metodu pro testování zda došlo ke kolizi, metodu pro test zda je plná řada a plné řady necháme zmizet. Ukážeme si algoritmu co nám zajistí posunutí „zkamenělin“ po odstranění plné řady. A aktivujeme si klávesnici pro ovládání kostiček.