Enemy.hpp

Go to the documentation of this file.

///
/// @file Enemy.hpp
/// @brief This file contains the enemy system definitions
/// @namespace gme
///
 
#pragma once
 
#include <cmath>
#include <ranges>
#include <vector>
 
#include "ECS/Component.hpp"
#include "ECS/Interfaces/ISystems.hpp"
#include "ECS/Registry.hpp"
#include "Interfaces/IRenderer.hpp"
#include "Utils/RTypeShared/GameConfig.hpp"
 
namespace gme
{
 
    class EnemySystem final : public ecs::ASystem
    {
        public:
            explicit EnemySystem(const std::shared_ptr<eng::IRenderer> &renderer) : m_renderer(renderer) {}
            ~EnemySystem() override = default;
 
            EnemySystem(const EnemySystem &) = delete;
            EnemySystem &operator=(const EnemySystem &) = delete;
            EnemySystem(EnemySystem &&) = delete;
            EnemySystem &operator=(EnemySystem &&) = delete;
 
            bool isEnable() override { return true; }
            void setEnable(const bool enable) override { (void)enable; }
 
            void update(ecs::Registry &registry, const float dt) override
            {
                std::vector<ecs::Entity> enemiesToRemove;
 
                for (const auto &entity : registry.getAll<ecs::Enemy>() | std::views::keys)
                {
                    auto *transform = registry.getComponent<ecs::Transform>(entity);
                    const auto *velocity = registry.getComponent<ecs::Velocity>(entity);
                    auto *rect = registry.getComponent<ecs::Rect>(entity);
                    const auto *texture = registry.getComponent<ecs::Texture>(entity);
                    const auto *scale = registry.getComponent<ecs::Scale>(entity);
                    auto *animation = registry.getComponent<ecs::Animation>(entity);
 
                    if ((transform == nullptr) || (velocity == nullptr) || (rect == nullptr) || (texture == nullptr) ||
                        (scale == nullptr))
                    {
                        continue;
                    }
 
                    transform->x += velocity->x * dt;
                    transform->y += velocity->y * dt;
 
                    if (animation != nullptr)
                    {
                        animation->current_time += dt;
                        if (animation->current_time >= animation->frame_duration)
                        {
                            animation->current_time = 0.0F;
                            animation->current_frame = (animation->current_frame + 1) % animation->total_frames;
 
                            const int frame_x =
                                animation->current_frame * static_cast<int>(utl::GameConfig::Enemy::Easy::SPRITE_WIDTH);
                            rect->pos_x = static_cast<float>(frame_x);
                            rect->pos_y = static_cast<float>(0);
                        }
                    }
 
                    m_renderer->createSprite(texture->id + std::to_string(entity), texture->path,
                                             std::round(transform->x), std::round(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));
 
                    if (transform->x < utl::GameConfig::Screen::REMOVE_X ||
                        transform->y < utl::GameConfig::Screen::REMOVE_MIN_Y ||
                        transform->y > utl::GameConfig::Screen::REMOVE_MAX_Y)
                    {
                        enemiesToRemove.push_back(entity);
                    }
                }
 
                for (const ecs::Entity entity : enemiesToRemove)
                {
                    if (registry.hasComponent<ecs::Enemy>(entity))
                    {
                        registry.removeComponent<ecs::Enemy>(entity);
                    }
                    if (registry.hasComponent<ecs::Transform>(entity))
                    {
                        registry.removeComponent<ecs::Transform>(entity);
                    }
                    if (registry.hasComponent<ecs::Velocity>(entity))
                    {
                        registry.removeComponent<ecs::Velocity>(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);
                    }
                    if (registry.hasComponent<ecs::Animation>(entity))
                    {
                        registry.removeComponent<ecs::Animation>(entity);
                    }
                    if (registry.hasComponent<ecs::Hitbox>(entity))
                    {
                        registry.removeComponent<ecs::Hitbox>(entity);
                    }
                }
            }
 
        private:
            const std::shared_ptr<eng::IRenderer> &m_renderer;
    }; // class EnemySystem
 
} // namespace gme