Untitled

#include <iostream>
#include <vector>
#include <future>
#include <chrono>
#include <random>
#include <atomic>

// Количество частиц
constexpr int PARTICLE_COUNT = 64;

// Класс частицы
class Particle {
public:
    // Конструктор
    Particle(float x, float y, float speed) : x_(x), y_(y), speed_(speed), active_(true), exploding_(false) {}

    // Обновление положения частицы
    void update(float dt) {
        // Если частица взрывается, то увеличиваем ее размер
        if (exploding_) {
            size_ += dt * explosion_speed_;
        }

        // Иначе перемещаем ее вниз
        else {
            y_ += dt * speed_;
        }
    }

    // Установка состояния взрыва
    void setExploding(bool exploding) {
        exploding_ = exploding;
        explosion_speed_ = std::rand() % 100 + 50; // случайная скорость взрыва
    }

    // Проверка активности частицы
    bool isActive() const {
        return active_;
    }

    // Проверка состояния взрыва
    bool isExploding() const {
        return exploding_;
    }

    // Проверка выхода частицы за пределы экрана
    bool isOffscreen() const {
        return y_ > 1.0f;
    }

    // Получение координаты x
    float getX() const {
        return x_;
    }

    // Получение координаты y
    float getY() const {
        return y_;
    }

    // Получение размера частицы
    float getSize() const {
        return size_;
    }

private:
    float x_; // координата x
    float y_; // координата y
    float speed_; // скорость падения
    float size_ = 0.1f; // размер частицы
    bool active_; // активность частицы
    bool exploding_; // состояние взрыва
    float explosion_speed_; // скорость расширения взрыва
};

// Класс движка эффектов
class EffectEngine {
public:
    // Конструктор
    EffectEngine(float x, float y) : x_(x), y_(y) {
        // Инициализация генератора случайных чисел
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<float> dis(-0.5f, 0.5f);

        // Создание частиц
        for (int i = 0; i < PARTICLE_COUNT; i++) {
            float speed = std::rand() % 100 + 200; // случайная скорость падения
            particles_.emplace_back(x_, y_, speed + dis(gen)); // добавление частицы в вектор
        }
    }

    // Генерация частиц
    void generateParticles() {
        std::vector<std::future<void>> futures;

        // Создание асинх
        for (auto& particle : particles_) {
            if (particle.isActive()) {
                futures.emplace_back(std::async([&particle]() {
                    particle.update(0.016f); // обновление частицы
                    }));
            }
        }

        // Ожидание завершения всех операций
        for (auto& future : futures) {
            future.wait();
        }
    }

    // Обновление состояний частиц
    void updateParticles() {
        // Обновление состояний частиц
        for (auto& particle : particles_) {
            if (particle.isActive()) {
                particle.update(0.016f);

                // Если частица вышла за пределы экрана, то отключаем ее
                if (particle.isOffscreen()) {
                    particle.setExploding(false);
                    particle = Particle(x_, y_, std::rand() % 100 + 200);
                }

                // Если частица не взрывается и прошло 1.5 секунды, то либо гасим ее, либо взрываем
                else if (!particle.isExploding() && elapsed_time_ > 1.5f) {
                    std::random_device rd;
                    std::mt19937 gen(rd());
                    std::uniform_int_distribution<int> dis(0, 9);
                    if (dis(gen) < 5) {
                        particle.setExploding(true);
                        elapsed_time_ = 0.0f;
                    }
                    else {
                        particle.setExploding(false);
                        particle = Particle(x_, y_, std::rand() % 100 + 200);
                    }
                }
            }
        }

        elapsed_time_ += 0.016f;
    }

    // Получение всех частиц
    const std::vector<Particle>& getParticles() const {
        return particles_;
    }

private:
    std::vector<Particle> particles_; // вектор частиц
    float x_; // координата x точки клика
    float y_; // координата y точки клика
    float elapsed_time_ = 0.0f; // прошедшее время
};

int main() {
    // Создание движка эффектов
    EffectEngine engine(0.5f, 0.5f);

    // Основной цикл приложения
    while (true) {
        // Генерация новых частиц
        engine.generateParticles();

        // Обновление состояний частиц
        engine.updateParticles();

        // Вывод частиц на экран
        for (auto& particle : engine.getParticles()) {
            std::cout << particle.getX() << " " << particle.getY() << " " << particle.getSize() << "\n";
        }

        // Задержка цикла
        std::this_thread::sleep_for(std::chrono::milliseconds(16));
    }

    return 0;
}

#include <iostream>
#include <future>
#include <chrono>

void calculate(int a, int b) {
    // Выполнение вычислений
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "Result: " << a * b << std::endl;
}

int main() {
    // Создание future для выполнения calculate в фоновом потоке
    std::future<void> fut = std::async(std::launch::async, calculate, 2, 3);
    
    // Выполнение другой работы в главном потоке
    std::cout << "Main thread doing something else..." << std::endl;
    
    // Ожидание завершения вычислений в фоновом потоке
    fut.get();
    
    return 0;
}