Игра Арканоид

namespace Constants
{
    const int coordsNum         = 4;
    const int leftBottomCoords  = 0;
    const int leftTopCoords     = 3;
    const int rightBottomCoords = 1;
    const int rightTopCoords    = 2;
 
    const int defaultRadius = 5;
    const int defaultSpeed  = 3;
 
    const int defaultHalfWidth  = 25;
    const int defaultHalfHeight = 5;
}
//==================================================================================================
typedef struct strControls
{
    //TODO: дать возможность переназначать клавиши
    unsigned char goLeft = 97;
    unsigned char goRight = 100;
    unsigned char shootBall = 49;
} Controls;
Controls controls;
//==================================================================================================
typedef struct strCoords
{
    int x;
    int y;
    strCoords() : x(0), y(0){}
    strCoords(int x, int y) : x(x), y(y) {}
    void setXY(const int& x, const int& y) { this->x = x; this->y = y;}
} Coords;
 
class Object {
private:
    Coords center;
    bool deleted; // Метка на удаление
    int red; //Не стоит постоянно передавать одни и те же параметры, сделаем цвет хранимым
    int green;
    int blue;
public:
    Object() : deleted(false){}
    Object(int x, int y) : center(x, y), deleted(false){}
 
    const bool isDeleted(void) const { return deleted; }
    void markForDelete(void) { deleted = true; } // Сеттер не нужен. То что помечено, должно быть удалено.
    const int getX(void) const { return center.x; }
    const int getY(void) const { return center.y; }
    void setX(const int& x) { this->center.x = x; }
    void setY(const int& y) { this->center.y = y; }
    void setXY(const int& x, const int& y) { this->center.setXY(x, y); }
    void setRGB(const int& Red, const int& Green, const int& Blue) { red = Red; green = Green; blue = Blue;}
    virtual void draw(void) = 0;
};
//==================================================================================================
class Elems : public Object
{
private:
    Coords coords[Constants::coordsNum];
public:
    Elems() : Object() {
        setCoords();
    }
    Elems(int x, int y) : Object(x, y){
        setCoords();
    }
 
    const int getLeftBX(void) const { return coords[Constants::leftBottomCoords].x; }
    const int getLeftBY(void) const { return coords[Constants::leftBottomCoords].y; }
    const int getLeftTX(void) const { return coords[Constants::leftTopCoords].x; }
    const int getLeftTY(void) const { return coords[Constants::leftTopCoords].y; }
 
    const int getRightBX(void) const { return coords[Constants::rightBottomCoords].x; }
    const int getRightBY(void) const { return coords[Constants::rightBottomCoords].y; }
    const int getRightTX(void) const { return coords[Constants::rightTopCoords].x; }
    const int getRightTY(void) const { return coords[Constants::rightTopCoords].y; }
 
    void setCoords(void) {
        int x = getX(), y = getY();
        coords[0].setXY(x - Constants::defaultHalfWidth, y - Constants::defaultHalfHeight);
        coords[1].setXY(x + Constants::defaultHalfWidth, y - Constants::defaultHalfHeight);
        coords[2].setXY(x + Constants::defaultHalfWidth, y + Constants::defaultHalfHeight);
        coords[3].setXY(x - Constants::defaultHalfWidth, y + Constants::defaultHalfHeight);
    }
 
    void ballCollisionOccured(void) // Теперь можно добавить разные типы блоков и по разному обрабатывать столкновения
    {
        markForDelete();
    }
 
    virtual void draw(void) {
        setCoords();
        glColor3d(red, green, blue);
        glBegin(GL_POLYGON);
        glVertex2d(coords[0].getX(), coords[0].getY());
        glVertex2d(coords[1].getX(), coords[1].getY());
        glVertex2d(coords[2].getX(), coords[2].getY());
        glVertex2d(coords[3].getX(), coords[3].getY());
        glEnd();
    }
};
//==================================================================================================
class Player : public Elems
{
    //TODO: добавить текущий счет и имя игрока
    //TODO: границы также можно проименовать
public:
    Player() : Elems() {}
    Player(int x, int y) : Elems(x, y) {}
    // Будем держать всю логику перемещений игрока в одном месте.
    void move(const int& dist)
    {
        int x = getX();
        if ((dist > 0 && x < 125) || (dist < 0 && x > -125))
            setX(x + dist);
    }
};
//==================================================================================================
class Ball : public Object
{
private :
    unsigned int Radius;
    int velocity[2];
public:
    Ball() : Object(), Radius(Constants::defaultRadius) {}
    Ball(int x, int y) : Object(x, y), Radius(Constants::defaultRadius) {}
 
    const unsigned int getRadius(void) const { return Radius; }
    void setRadius(const unsigned int& Radius) { this->Radius = Radius; }
 
    void setVelocityX(const int& x) { velocity[0] = x; }
    void setVelocityY(const int& y) { velocity[1] = y; }
 
    virtual void draw(void)
    {
        glColor3d(red, green, blue);
        glBegin(GL_POINTS);
        int BallX, BallY, x = getX() , y = getY();
        for (float angle = 0.3; angle < 6.4; angle += 0.1) {
            BallX = Radius * cosf(angle);
            BallY = Radius * sinf(angle);
            glVertex2d(BallX + x, BallY + y);
        }
        glEnd();
    }
 
    void checkCollisionWithPlayer(const Player* player)
    {
        if (getY() == player->getY() + 2 &&
            getX() > player->getLeftTX() - Radius &&
            getX() < player->getRightTX() + Radius)
            velocity[1] = 1;
    }
 
    bool checkCollisionWithBlock(const Elems* block)
    {
        int x = getX(), y = getY();
        if (block->getLeftBY() == y &&
            x > block->getLeftBX() - 2 &&
            x < block->getRightBX() + 2)
        {
            velocity[1] = -1;
            return true;
        }
 
        if (block->getLeftTY() == y &&
            x > block->getLeftTX() - 2 &&
            x < block->getRightTX() + 2)
        {
            velocity[1] = 1;
            return true;
        }
 
        if (block->getLeftBX() == x &&
            y > block->getLeftBY() + 1 &&
            y < block->getLeftTY() - 1)
        {
            velocity[0] = -1;
            return true;
        }
 
        if (block->getRightBX() == x &&
            y > block->getRightBY() + 1 &&
            y < block->getRightTY() - 1)
        {
            velocity[0] = 1;
            return true;
        }
        return false;
    }
 
    void move(void)
    {
        setX(getX() + velocity[0]);
        setY(getY() + velocity[1]);
        if (getX() < -150)
            velocity[0] = 1;
        else
        {
            if (getX() > 150) // Внес внутри блока чтобы проверка не срабатывала вхолостую
                velocity[0] = -1;
        }
 
        if (getY() > 120)
            velocity[1] = -1;
        else
        {
            if (getY() < -120) // Внес внутри блока чтобы проверка не срабатывала вхолостую
                velocity[1] = 1;
        }
    }
};
//==================================================================================================
class Field {
private:
    bool ballState;
    int speed = Constants::defaultSpeed;
 
    std::vector<Elems*> blocks;
    Player player;
    Ball ball;
 
    void createField(void) {
        //TODO: сделать сохранение/загрузку уровней
        unsigned int BlocksNum = 16;
        Elems* block;
        for (int i = 0, x = -105, y = 100; i < BlocksNum; ++i, x += 70)
        {
            block = new Elems;
            block->setXY(x, y);
            blocks.push_back(block);
 
            if (i % 4 == 3)
            {
                x -= 280;
                y -= 25;
            }
        }
    }
public:
 
    Field() :
        player(0, -100), ball(player.getX(), player.getY() + 10), ballState(false)
    {
        player.setRGB(255, 0, 0); //TODO: этого кода можно избежать, используя конструкторы
        ball.setRGB(0, 0, 255);
        createField();
        int num = blocks.size();
        for (int i = 0; i < num; ++i)
            blocks[i]->setRGB(255, 255, 0);
    }
    ~Field()
    {
        if (!blocks.empty())
        {
            for (int i = 0; i < blocks.size(); ++i)
                delete blocks[i];
        }
    }
 
    void setBallState(const bool& ballState) { this->ballState = ballState; }
 
    void draw(void)
    {
        int num = blocks.size();
        for (int i = 0; i < num; ++i)
            blocks[i]->draw();
        player.draw();
        ball.draw();
    }
 
    void playerMove(const unsigned char& key)
    {
        if (key == controls.goRight)
            player.move(5);
        else // Убрал лишнюю проверку, у нас и так либо одна клавиша либо другая за счет keyboard()
            player.move(-5);
        if (ballState == false)
        {
            ball.setX(player.getX());
            if (player.getX() < 0)
            {
                ball.setVelocityX(-1);
                ball.setVelocityY(1);
            }
            else
            {
                ball.setVelocityX(1);
                ball.setVelocityY(1);
            }
        }
    }
 
    void ballTick(void)
    {
        for (int j = 0; j < speed; ++j)
        {
            ball.move();
 
            ball.checkCollisionWithPlayer(&player);
 
            int num = blocks.size();
            for (int i = 0; i < num; ++i)//перебор всех блоков
                if (ball.checkCollisionWithBlock(blocks[i]))
                    blocks[i]->ballCollisionOccured();
 
            for (int i = 0; i < blocks.size(); ++i)
                if (blocks[i]->isDeleted())
                    delete blocks[i];
 
        }
    }
} field;
//==================================================================================================
void displayGame(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    field.draw();
    field.ballTick();
    glFlush();
}
//==================================================================================================
void keyboard(unsigned char key, int, int)
{
    if (key == controls.goRight || key == controls.goLeft)
    {
        field.playerMove(key);
        return;
    }
 
    if (key == controls.shootBall)
        field.setBallState(true);
}

Example Object;