CppCon 2014 - Développement rapide de jeux en C++11/C++14

std::vector<Brick> bricks; 

constexpr int brkCountX{11}; // How many columns? 
constexpr int brkCountY{4}; // How many rows? 
constexpr int brkStartColumn{1}; // What column number to start at? 
constexpr int brkStartRow{2}; // What row number to start at? 
constexpr float brkSpacing{3}; // Spacing between adjacent bricks. 
constexpr float brkOffsetX{22.f}; // X offset for the grid pattern. 

for(int iX{0}; iX < brkCountX; ++iX) 
    for(int iY{0}; iY < brkCountY; ++iY) 
    { 
        float x{(iX + brkStartColumn) 
        * (Brick::defWidth + brkSpacing)}; 
        float y{(iY + brkStartRow) 
        * (Brick::defHeight + brkSpacing)}; 
        bricks.emplace_back(brkOffsetX + x, y); 
    }

void solveBrickBallCollision(Brick& mBrick, Ball& mBall) noexcept
{
    if(!isIntersecting(mBrick, mBall)) return;
    
    mBrick.destroyed = true;
    
    float overlapLeft{mBall.right() - mBrick.left()};
    float overlapRight{mBrick.right() - mBall.left()};
    float overlapTop{mBall.bottom() - mBrick.top()};
    float overlapBottom{mBrick.bottom() - mBall.top()};
    
    bool ballFromLeft(std::abs(overlapLeft) < std::abs(overlapRight));
    
    bool ballFromTop(std::abs(overlapTop) < std::abs(overlapBottom));
    
    float minOverlapX{ballFromLeft ? overlapLeft : overlapRight};
    float minOverlapY{ballFromTop ? overlapTop : overlapBottom};

    if(std::abs(minOverlapX) < std::abs(minOverlapY))
    {
        mBall.velocity.x = ballFromLeft ?
        -Ball::defVelocity : Ball::defVelocity;
    }
    else
    {
        mBall.velocity.y = ballFromTop ?
        -Ball::defVelocity : Ball::defVelocity;
    }
}

bricks.erase(
        std::remove_if(std::begin(bricks), std::end(bricks),
        [](const auto& mBrick){ return mBrick.destroyed; }),
        std::end(bricks)
    );

struct Rectangle 
{ 
    sf::RectangleShape shape; 

    float x() const noexcept { return shape.getPosition().x; } 
    float y() const noexcept { return shape.getPosition().y; } 
    float width() const noexcept { return shape.getSize().x; } 
    float height() const noexcept { return shape.getSize().y; } 
    float left() const noexcept { return x() - width() / 2.f; } 
    float right() const noexcept { return x() + width() / 2.f; } 
    float top() const noexcept { return y() - height() / 2.f; } 
    float bottom() const noexcept { return y() + height() / 2.f; } 
}; 
struct Circle 
{ 
    sf::CircleShape shape; 

    float x() const noexcept { return shape.getPosition().x; } 
    float y() const noexcept { return shape.getPosition().y; } 
    float radius() const noexcept { return shape.getRadius(); } 
    float left() const noexcept { return x() - radius(); } 
    float right() const noexcept { return x() + radius(); } 
    float top() const noexcept { return y() - radius(); } 
    float bottom() const noexcept { return y() + radius(); } 
};

class Game
{
private:
    enum class State{Paused, InProgress};
    
    static constexpr int brkCountX{11}, brkCountY{4};
    static constexpr int brkStartColumn{1}, brkStartRow{2};
    static constexpr float brkSpacing{3.f}, brkOffsetX{22.f};
    
    sf::RenderWindow window{{wndWidth, wndHeight}, "Arkanoid - 9"};
    
    Ball ball{wndWidth / 2.f, wndHeight / 2.f};
    Paddle paddle{wndWidth / 2, wndHeight - 50};
    std::vector<Brick> bricks;
    
    State state{State::InProgress};
    bool pausePressedLastFrame{false};
    
public:
    Game() { window.setFramerateLimit(60); }

    void restart()
    {
        state = State::Paused;
        for(int iX{0}; iX < brkCountX; ++iX)
            for(int iY{0}; iY < brkCountY; ++iY)
            {
                float x{(iX + brkStartColumn)
                * (Brick::defWidth + brkSpacing)};
                float y{(iY + brkStartRow)
                * (Brick::defHeight + brkSpacing)};
                bricks.emplace_back(brkOffsetX + x, y);
            }
            
        ball = Ball{wndWidth / 2.f, wndHeight / 2.f};
        paddle = Paddle{wndWidth / 2, wndHeight - 50};
    }

    void run()
    {
        while(true)
        {
            window.clear(sf::Color::Black);
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::Escape))
                break;
                
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::P))
            {
                if(!pausePressedLastFrame)
                {
                    if(state == State::Paused)
                        state = State::InProgress;
                    else if(state == State::InProgress)
                        state = State::Paused;
                }
                pausePressedLastFrame = true;
            }
            else pausePressedLastFrame = false;
            
            if(sf::Keyboard::isKeyPressed(sf::Keyboard::Key::R))
                restart();

            if(state != State::Paused)
            {
                ball.update();
                paddle.update();
                
                for(auto& brick : bricks)
                {
                    brick.update();
                    solveBrickBallCollision(brick, ball);
                }
                
                bricks.erase(
                    std::remove_if(std::begin(bricks), std::end(bricks),
                    [](const auto& mBrick){ return mBrick.destroyed; }),
                    std::end(bricks)
                );
                
                solvePaddleBallCollision(paddle, ball);
            }
            
            ball.draw(window);
            paddle.draw(window);
            for(auto& brick : bricks) brick.draw(window);
            
            window.display();
        }
    }
};

class Entity
{
public:
    bool destroyed{false};

    virtual ~Entity() { }
    virtual void update() { }
    virtual void draw(sf::RenderWindow& mTarget) { }
};

class Manager
{
private:
    std::vector<std::unique_ptr<Entity>> entities;
    std::map<std::size_t, std::vector<Entity*>> groupedEntities;

public:
    template<typename T, typename... TArgs> T& create(TArgs&&... mArgs)
    {
        static_assert(std::is_base_of<Entity, T>::value,"`T` must be derived from `Entity`");

        auto uPtr(std::make_unique<T>(std::forward<TArgs>(mArgs)...));
        auto ptr(uPtr.get());

        groupedEntities[typeid(T).hash_code()].emplace_back(ptr);
        
        entities.emplace_back(std::move(uPtr));
        return *ptr;
    }
    
    void refresh()
    {
        for(auto& pair : groupedEntities)
        {
            auto& vector(pair.second);
            vector.erase(
                std::remove_if(std::begin(vector), std::end(vector),
                [](auto mPtr){ return mPtr->destroyed; }),
                std::end(vector)
            );
        }

        entities.erase(
            std::remove_if(std::begin(entities), std::end(entities),
            [](const auto& mUPtr){ return mUPtr->destroyed; }),
            std::end(entities)
        );
    }

    void clear()
    {
        groupedEntities.clear();
        entities.clear();
    }
    
    template<typename T> auto& getAll()
    {
        return groupedEntities[typeid(T).hash_code()];
    }
    
    template<typename T, typename TFunc>
    void forEach(const TFunc& mFunc)
    {
        auto& vector(getAll<T>());

        for(auto ptr : vector) mFunc(*reinterpret_cast<T*>(ptr));
    }

    void update()
    {
        for(auto& e : entities) e->update();
    }
    
    void draw(sf::RenderWindow& mTarget)
    {
        for(auto& e : entities) e->draw(mTarget);
    }
};