Программа - поздравление

#include "HappyNewYear.hpp"
 
int main() 
{
    const int windowWidth = 600;
    const int windowHeight = 500;
    sf::RenderWindow win(sf::VideoMode(windowWidth, windowHeight), "Happy new Year!");
    win.setFramerateLimit(50);
    
    auto parts = SimpleParticlesBuilder::create()
        .add(std::make_tuple("snow.png", sf::IntRect(0, 0, 32, 32), 10))
        .add(std::make_tuple("snow.png", sf::IntRect(33, 33, 32, 32), 10))
        .setSpeed(0.5f)
        .setWindowParams(windowWidth, windowHeight)
        .build();
    
    sf::Font font;
    sf::Text text;
    if(!font.loadFromFile("PTC75F.ttf"))
        return -1;
    
    text.setFont(font);
    text.setString(L"С Новым годом, Cyberforum!");
    text.setFillColor(sf::Color(54, 226, 92));
    text.setPosition(90, windowHeight / 2 - 30);
        
    while (win.isOpen())
    {
        parts.update();
 
        sf::Event event;
        while(win.pollEvent(event))
        {
            if(sf::Event::Closed == event.type)
                win.close();
        }
        
        win.clear(sf::Color(2, 41, 232));
 
        for( const auto& it : parts.getSprites() )
            win.draw(it);
        win.draw(text);
 
        win.display();
    }
}

/////////////////////////////////////////////////////////////////////////////////////////
// Created by GbaLog
// Link on github.com: [url]https://github.com/GbaLog/[/url]
/////////////////////////////////////////////////////////////////////////////////////////
#ifndef SIMPLE_PARTICLES
#define SIMPLE_PARTICLES
/////////////////////////////////////////////////////////////////////////////////////////
#include <SFML/Graphics.hpp>
#include <cmath>
#include <ctime>
#include <random>
#include <string>
#include <stdexcept>
#include <vector>
#include <tuple>
 
#include "timer.hpp"
/////////////////////////////////////////////////////////////////////////////////////////
class SimpleParticles
{
 
public:
 
    SimpleParticles(
        std::vector<std::tuple<std::string, sf::IntRect, unsigned>>&& data,
        int windowWidth,
        int windowHeight,
        float speed
    )
        :
        speed(speed),
        windowWidth(windowWidth),
        windowHeight(windowHeight),
        sprites{}
    {
        for( const auto& it : data )
            add(std::get<0>(it), std::get<1>(it), std::get<2>(it));
    }
 
    void setSpeed( const float speed )
    {
        this->speed = speed;
    }
 
    void setWindowParams( const int windowWidth, const int windowHeight )
    {
        this->windowWidth = windowWidth;
        this->windowHeight = windowHeight;
 
        for( auto& it : sprites )
        {
            it.setPosition(random(0, windowWidth), random(0, windowHeight));
        }
    }
 
    void add( const std::string& filename, const sf::Rect<int>& rect, unsigned count )
    {
        sf::Texture* texture = new sf::Texture;
        if( !texture->loadFromFile(filename, rect) )
        {
            throw std::invalid_argument("File does not exists\n");
        }
 
        textures.push_back(texture);
 
        sf::Sprite tmp;
        tmp.setTexture(*texture);
        //adding alpha canal to color sprite
        /* sf::Color clr( tmp.getColor() );
        clr.a = 63;
 
        tmp.setColor(clr); */
        //set origin by center
        tmp.setOrigin(rect.width / 2, rect.height / 2);
 
        for( size_t it{}; it < count; ++it )
        {
            tmp.setPosition(random(0, windowWidth), random(0, windowHeight));
            sprites.push_back(tmp);
 
            angles.emplace_back(static_cast<float>(random(0, 360) * 2 * PI / 360.f));
        }
 
    }
 
    const std::vector<sf::Sprite>& getSprites() const
    {
        return sprites;
    }
 
    void update()
    {
        float factor = speed * (timer.get_elapsed_time<tools::milliseconds>() / 10.f);
        for( size_t it{}; it < sprites.size(); ++it )
        {
            sprites[it].move(std::cos(angles[it]) * factor, std::sin(angles[it]) * factor);
 
            //check collision with walls
            if( sprites[it].getPosition().x - sprites[it].getOrigin().x < 0 )
            {
                angles[it] = PI - angles[it];
                sprites[it].setPosition(
                    sprites[it].getOrigin().x + 1,
                    sprites[it].getPosition().y
                );
            }
            if( sprites[it].getPosition().x + sprites[it].getOrigin().x > windowWidth+1 )
            {
                angles[it] = PI - angles[it];
                sprites[it].setPosition(
                    windowWidth - sprites[it].getOrigin().x + 1,
                    sprites[it].getPosition().y
                );
            }
            if( sprites[it].getPosition().y - sprites[it].getOrigin().y < 0 )
            {
                angles[it] = -angles[it];
                sprites[it].setPosition(
                    sprites[it].getPosition().x,
                    sprites[it].getOrigin().y + 1
                );
            }
            if( sprites[it].getPosition().y + sprites[it].getOrigin().y > windowHeight+1 )
            {
                angles[it] = -angles[it];
                sprites[it].setPosition(
                    sprites[it].getPosition().x,
                    windowHeight - sprites[it].getOrigin().y + 1
                );
            }
 
            sprites[it].rotate(1);
        }
        timer.restart();
    }
 
private:
 
    //simple random function
    float random( float from, float to )
    {
        // static std::mt19937 gen( std::time(nullptr) );
        static std::mt19937 gen( std::chrono::system_clock::now().time_since_epoch().count() );
        std::uniform_real_distribution<> dist( from, to );
        return dist(gen);
    }
 
    tools::Timer timer;
    float speed;
    int windowWidth;
    int windowHeight;
    std::vector<sf::Texture*> textures;
    std::vector<sf::Sprite> sprites;
    std::vector<float> angles;
 
    constexpr static float PI = 3.14159f;
};
/////////////////////////////////////////////////////////////////////////////////////////
class SimpleParticlesBuilder
{
public:
 
    SimpleParticlesBuilder()
        :
        data{},
        windowWidth{},
        windowHeight{},
        speed{10.f}
    {}
 
 
    static SimpleParticlesBuilder create()
    {
        return SimpleParticlesBuilder{};
    }
 
    SimpleParticlesBuilder& add( const std::tuple<std::string, sf::IntRect, unsigned>& newElement )
    {
        data.push_back(newElement);
        return *this;
    }
 
    SimpleParticlesBuilder& add( std::tuple<std::string, sf::IntRect, unsigned>&& newElement )
    {
        data.emplace_back(std::forward<decltype(newElement)>(newElement));
        return *this;
    }
 
    SimpleParticlesBuilder& add( const std::string& filename, const sf::IntRect& rect, const unsigned count )
    {
        data.emplace_back(std::make_tuple(filename, rect, count));
        return *this;
    }
 
    SimpleParticlesBuilder& setWindowParams( const int windowWidth, const int windowHeight )
    {
        this->windowWidth = windowWidth;
        this->windowHeight = windowHeight;
        return *this;
    }
 
    SimpleParticlesBuilder& setSpeed( const float speed )
    {
        this->speed = speed;
        return *this;
    }
 
    SimpleParticles build()
    {
        return SimpleParticles( std::move(data), windowWidth, windowHeight, speed );
    }
private:
    std::vector<std::tuple<std::string, sf::IntRect, unsigned>> data;
    int windowWidth;
    int windowHeight;
    float speed;
};
/////////////////////////////////////////////////////////////////////////////////////////
//
//    example using SimpleParticlesBuilder:
//
//      auto parts =
//          SimpleParticlesBuilder::create()
//            .add("img.png", sf::IntRect(0, 0, 32, 32), 33)
//            .setWindowParams(800, 600)
//            .setSpeed(10.f)
//            .build();
//
/////////////////////////////////////////////////////////////////////////////////////////
#endif //SIMPLE_PARTICLES
/////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////////////
// Created by GbaLog
// Link on github.com: [url]https://github.com/GbaLog/[/url]
/////////////////////////////////////////////////////////////////////////////////////////
#ifndef TIMER_HPP
#define TIMER_HPP
/////////////////////////////////////////////////////////////////////////////////////////
#include <chrono>
/////////////////////////////////////////////////////////////////////////////////////////
namespace tools
{
/////////////////////////////////////////////////////////////////////////////////////////
    using nanoseconds   = std::chrono::nanoseconds;
    using microseconds  = std::chrono::microseconds;
    using milliseconds  = std::chrono::milliseconds;
    using seconds       = std::chrono::seconds;
    using minutes       = std::chrono::minutes;
    using hours         = std::chrono::hours;
/////////////////////////////////////////////////////////////////////////////////////////
    class Timer
    {
        //-------------------------------------------------------------------------------
    public:
        //-------------------------------------------------------------------------------
        using clock      = std::chrono::system_clock;
        using time_point = clock::time_point;
        //-------------------------------------------------------------------------------
        Timer()
            :
            start_time{ clock::now() }
        {}
        //-------------------------------------------------------------------------------
        template<typename _Time>
        bool gone( _Time&& time )
        {
            return (clock::now() - start_time) >= time;
        }
        //-------------------------------------------------------------------------------
        template<typename _Time>
        bool restart( _Time&& time )
        {
            auto tmp_start = start_time;
            start_time = clock::now();
            return (start_time - tmp_start) >= time;
        }
        //-------------------------------------------------------------------------------
        time_point restart()
        {
            auto tmp_start = start_time;
            start_time = clock::now();
            return tmp_start;
        }
        //-------------------------------------------------------------------------------
        template<typename _Duration>
        inline typename _Duration::rep get_elapsed_time() const
        {
            return std::chrono::duration_cast<_Duration>(clock::now() - start_time).count();
        }
        //-------------------------------------------------------------------------------
    private:
        //-------------------------------------------------------------------------------
        time_point start_time;
        //-------------------------------------------------------------------------------
    };
/////////////////////////////////////////////////////////////////////////////////////////
} //tools
/////////////////////////////////////////////////////////////////////////////////////////
#endif //TIMER_HPP
/////////////////////////////////////////////////////////////////////////////////////////