Explosion.hpp

Go to the documentation of this file.

///
/// @file Explosion.hpp
/// @brief This file contains the explosion system definitions
/// @namespace gme
///
 
#pragma once
 
#include <vector>
 
#include "ECS/Component.hpp"
#include "ECS/Interfaces/ISystems.hpp"
#include "ECS/Registry.hpp"
#include "Interfaces/IRenderer.hpp"
 
namespace gme
{
 
    class ExplosionSystem final : public ecs::ASystem
    {
        public:
            explicit ExplosionSystem(const std::shared_ptr<eng::IRenderer> &renderer) : m_renderer(renderer) {}
            ~ExplosionSystem() override = default;
 
            ExplosionSystem(const ExplosionSystem &) = delete;
            ExplosionSystem &operator=(const ExplosionSystem &) = delete;
            ExplosionSystem(ExplosionSystem &&) = delete;
            ExplosionSystem &operator=(ExplosionSystem &&) = delete;
 
            bool isEnable() override { return true; }
            void setEnable(bool enable) override { (void)enable; }
 
            void update(ecs::Registry &registry, float dt) override
            {
                std::vector<ecs::Entity> explosionsToRemove;
 
                for (auto &[entity, explosion] : registry.getAll<ecs::Explosion>())
                {
                    auto *transform = registry.getComponent<ecs::Transform>(entity);
                    auto *rect = registry.getComponent<ecs::Rect>(entity);
                    auto *texture = registry.getComponent<ecs::Texture>(entity);
                    auto *scale = registry.getComponent<ecs::Scale>(entity);
 
                    if ((transform == nullptr) || (rect == nullptr) || (texture == nullptr) || (scale == nullptr))
                    {
                        continue;
                    }
 
                    explosion.current_time += dt;
                    if (explosion.current_time >= explosion.frame_duration)
                    {
                        explosion.current_time = 0.0f;
                        explosion.current_frame = (explosion.current_frame + 1) % explosion.total_frames;
 
                        int frame_x = (explosion.current_frame % explosion.frames_per_row) *
                                      static_cast<int>(explosion.frame_width);
                        int frame_y = (explosion.current_frame / explosion.frames_per_row) *
                                      static_cast<int>(explosion.frame_height);
 
                        rect->pos_x = static_cast<float>(frame_x);
                        rect->pos_y = static_cast<float>(frame_y);
                    }
 
                    m_renderer->createSprite(texture->id + std::to_string(entity), texture->path, transform->x,
                                             transform->y, scale->x, scale->y, static_cast<int>(rect->pos_x),
                                             static_cast<int>(rect->pos_y), rect->size_x, rect->size_y);
                    m_renderer->drawSprite(texture->id + std::to_string(entity));
 
                    explosion.current_lifetime += dt;
                    if (explosion.current_lifetime >= explosion.lifetime)
                    {
                        explosionsToRemove.push_back(entity);
                    }
                }
 
                for (const ecs::Entity entity : explosionsToRemove)
                {
                    removeExplosion(registry, entity);
                }
            }
 
        private:
            const std::shared_ptr<eng::IRenderer> &m_renderer;
 
            static void removeExplosion(ecs::Registry &registry, const ecs::Entity entity)
            {
                if (registry.hasComponent<ecs::Explosion>(entity))
                    registry.removeComponent<ecs::Explosion>(entity);
                if (registry.hasComponent<ecs::Transform>(entity))
                    registry.removeComponent<ecs::Transform>(entity);
                if (registry.hasComponent<ecs::Rect>(entity))
                    registry.removeComponent<ecs::Rect>(entity);
                if (registry.hasComponent<ecs::Texture>(entity))
                    registry.removeComponent<ecs::Texture>(entity);
                if (registry.hasComponent<ecs::Scale>(entity))
                    registry.removeComponent<ecs::Scale>(entity);
            }
    }; // class ExplosionSystem
} // namespace gme