RTypeClient.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2023
** RTypeClient.hpp
** File description:
** RTypeClient
*/
 
#ifndef RTYPECLIENT_HPP_
#define RTYPECLIENT_HPP_
 
#include <asio.hpp>
#include <cstdint>
#include "GameEngine.hpp"
#include "Protocol.hpp"
#include "UdpClient.hpp"
#include "TcpClient.hpp"
#include "Keyboard.hpp"
 
namespace RType::Client
{
    class RTypeClient
    {
      public:
        RTypeClient(const std::string &address = "127.0.0.1", unsigned short port = 8080);
        ~RTypeClient();
        void startNetwork(bool &isRunning);
        void gameLoop();
        void handleEvent();
 
        void handleTransformComponent(struct RType::Event event);
        void handleTextureComponent(struct RType::Event event);
        void handleCollisionComponent(struct RType::Event event);
 
        void handleNewEntity(struct RType::Event event);
        void handleEntity(struct RType::Event event);
        void handleDisconnexion(struct RType::Event event);
        void deleteEntity(struct RType::Protocol::EntityIdData entityId);
        void handlePlayerMovement();
        void updatePlayerMovement(const GameEngine::TransformComponent &transform);
 
        void setGameEngineComponent();
        void setGameEngineSystem();
 
        void setGameEngineCallback();
 
        void setGameEngine();
        void setGameEngineScene();
 
        void handleEndGame(struct RType::Event event);
        void setEndGameState(struct RType::Protocol::EndGameData endGameData);
        void setEndGameCallback();
 
        void setPrefab();
 
        void setupTextureEntity();
 
        void setDeleteEntityCallback();
        void setMovementEntityCallback();
        void setControllableCallback();
 
        void shootEvent(const GameEngine::TransformComponent &transform);
        void handlePlayerShoot();
        void runUdpServer();
        void runTcpServer();
        void handleQuit();
 
        void handleTextureState(struct RType::Event event);
        void setTextureState(struct RType::Protocol::StatePlayerData transformData);
        void setTextureStateCallback();
 
        void setTextureInformation(struct RType::Protocol::TextureData textureData, GameEngine::Entity &entity);
 
        void handleControllableComponent(struct RType::Event event);
        void setControllable(struct RType::Protocol::ControllableData controllableData);
 
        void getTransformInformation(struct RType::Protocol::TransformData transformData);
        void setTransformCallback();
 
        void setCollisionInformation(struct RType::Protocol::CollisionData collisionData, GameEngine::Entity &entity);
 
        void getCollisionInformation(struct RType::Protocol::CollisionData collisionData);
        void setCollisionCallback();
 
        void getTextureInformation(struct RType::Protocol::TextureData textureData);
        void setTextureCallback();
 
        void setupGame();
        void setupScoreText();
 
        void handleScore(struct RType::Event event);
        void setScoreCallback();
        void setScore(struct RType::Protocol::ScoreData scoreData);
 
        void playerCollisionCallback(const std::size_t &entityId,
            SparseArray<GameEngine::CollisionComponent> &collisions,
            SparseArray<GameEngine::TransformComponent> &transforms);
        void parallaxCollision(const std::size_t &entityId, SparseArray<GameEngine::CollisionComponent> &collisions,
            SparseArray<GameEngine::TransformComponent> &transforms);
 
        void setInputCallback();
        void handleInput(struct GameEngine::Input::InputInfo inputData);
 
        void handleMoveInput(std::vector<std::byte> data, struct GameEngine::Input::InputInfo input);
 
      protected:
      private:
        std::size_t findEntity(const std::size_t &networkId);
        bool searchEntity(const std::size_t &networkId);
 
        GameEngine::GameEngine _gameEngine;
        asio::io_context _IOContext;
        asio::ip::udp::endpoint _serverUdpEndpoint;
        asio::ip::tcp::endpoint _serverTcpEndpoint;
        RType::Client::UdpClient _udpClient;
        asio::signal_set _signal;
        SafeQueue<struct RType::Event> _eventQueue;
        std::size_t _scoreTextEntity;
        bool _isRunning;
        std::size_t _points;
        uint16_t _serverId;
        std::size_t _id;
        bool _win;
        bool isOpen;
        bool _endScene;
        std::vector<GameEngine::Entity> _entities;
        RType::GameState _gameState;
        GameEngine::Input::InputType _lastInput;
        std::map<uint8_t, std::string> _listTextureTypePrefab;
        std::map<uint8_t, std::string> _listPathTextureId;
    };
} // namespace RType::Client
 
#endif /* !RTYPECLIENT_HPP_ */