Orchestrator.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2024
** rtype (Workspace)
** File description:
** Orchestrator.hpp
*/
 
#pragma once
#include <any>
#include <vector>
#include <memory>
#include <random>
#include <unordered_map>
#include "Log.hpp"
#include "Recoded.hpp"
#include "SoundLib.hpp"
#include "LogMacros.hpp"
#include "Utilities.hpp"
#include "CustomExceptions.hpp"
#include "GUI/ECS/EntityNode.hpp"
#include "GUI/ECS/Online/Bullet.hpp"
#include "GUI/ECS/Online/EnemyBrain.hpp"
#include "GUI/ECS/Online/PlayerBrain.hpp"
#include "GUI/ECS/Systems.hpp"
#include "GUI/ECS/Components.hpp"
#include "GUI/Network/MessageStruct.hpp"
#include "GUI/Network/ThreadCapsule.hpp"
 
namespace GUI
{
    namespace ECS
    {
        namespace Online
        {
            class Orchestrator : public EntityNode {
                public:
                Orchestrator(const std::uint32_t entityId = 0);
 
                ~Orchestrator() = default;
 
                void initialiseClass(std::unordered_map<std::type_index, std::vector<std::any>> &ecsEntities);
 
                void setNetworkClass(const std::shared_ptr<GUI::Network::ThreadCapsule> &network);
 
                void start();
 
                void stop();
 
                void reset();
 
                void tick(const std::vector<GUI::Network::MessageNode> &packets);
 
                void tick_all();
 
                void render();
 
                const bool isGameOver() const;
 
                const bool isGameWon() const;
 
 
                const std::string getInfo(const unsigned int indent = 0) const;
 
                private:
 
                void _shootSound();
                void _damageSound();
                void _deadSound();
                void _buttonSound();
                void _gameOverSound();
                void _winSound();
 
                void _spawn(const std::uint32_t id, const std::pair<float, float> &pos);
 
                void _spawnFriendBullet(const std::uint32_t id, const std::pair<float, float> &pos);
 
                void _spawnEnemyBullet(const std::uint32_t id, const std::pair<float, float> &pos);
 
                void _setPosition(const std::uint32_t id, const std::pair<float, float> &pos);
 
                void _killEntity(const std::uint32_t id);
 
                void _sendMessage(const GUI::Network::MessageNode &node);
 
                void _kill();
 
                void _spawnEnemy(const std::uint32_t id, const std::pair<float, float> pos);
 
                const int _randInt(int min = 0, int max = 5);
 
                void _setTheScene();
 
                void _setTextComponents();
 
                bool _playing = false;                                                                 
                bool _gameWon = false;                                                                 
                bool _gameOver = false;                                                                
                int _stepUp = -10;                                                                     
                int _stepDown = 10;                                                                    
                int _stepLeft = -10;                                                                   
                int _stepRight = 10;                                                                   
                float _screenPosXOffset = 75;                                                          
                float _screenPosYOffset = 45;                                                          
                long int _activeEnemies = 0;                                                           
                std::size_t _playerId = 0;                                                             
                std::optional<std::shared_ptr<GUI::ECS::Components::TextComponent>> _remainingEnemies; 
                std::optional<std::shared_ptr<GUI::ECS::Components::ImageComponent>> _backgroundItem;  
                std::shared_ptr<GUI::ECS::Components::SpriteComponent> _spriteBullet;                  
                std::shared_ptr<GUI::ECS::Components::SpriteComponent> _spriteBulletEnemy;             
                std::shared_ptr<GUI::ECS::Components::SpriteComponent> _spritePlayer;                  
                std::shared_ptr<GUI::ECS::Components::SpriteComponent> _spriteEnemy;                   
                std::vector<GUI::ECS::Online::Bullet> _playerBullets;                                  
                std::vector<GUI::ECS::Online::Bullet> _enemyBullets;                                   
                std::shared_ptr<GUI::ECS::Systems::Window> _window;                                    
                std::shared_ptr<GUI::ECS::Systems::EventManager> _event;                               
                std::vector<std::shared_ptr<GUI::ECS::Online::PlayerBrain>> _playerBrain;              
                std::vector<std::shared_ptr<GUI::ECS::Online::EnemyBrain>> _enemyBrain;                
                std::unordered_map<std::type_index, std::vector<std::any>> _ecsEntities;               
                std::optional<std::shared_ptr<GUI::Network::ThreadCapsule>> _network;                  
            };
 
            std::ostream &operator<<(std::ostream &os, const Orchestrator &item);
        }
    }
}