NetworkSyncSystem.hpp

Go to the documentation of this file.

 
#ifndef RTYPE_CLIENT_NETWORK_SYSTEM_HPP_
    #define RTYPE_CLIENT_NETWORK_SYSTEM_HPP_
 
    #include "RType/ECS/ISystem.hpp"
    #include "RType/ECS/Registry.hpp"
    #include "Network/ClientNetwork.hpp"
    
    #include "RType/ECS/Components/Transform.hpp"
    #include "RType/ECS/Components/NetworkId.hpp"
    #include "RType/ECS/Components/Sprite.hpp"
    #include "RType/ECS/Components/Animation.hpp"
    #include "RType/Network/Packet.hpp"
 
    #include "Game/EntityBuilder.hpp"
 
    #include <deque>
    #include <vector>
    #include <iostream>
    #include <list>
    #include <string>
 
namespace rtp::client {
 
    class NetworkSyncSystem : public ecs::ISystem
    {
        public:
            enum class State {
                NotLogged,
                InLobby,
                JoiningRoom,
                CreatingRoom,
                LeavingRoom,
                InRoom,
                InGame
            };
        public:
            NetworkSyncSystem(ClientNetwork& network, ecs::Registry& registry, EntityBuilder builder);
 
            void update(float dt) override;
 
            void tryLogin(const std::string& username, const std::string& password, uint8_t weaponKind) const;
 
            void tryRegister(const std::string& username, const std::string& password) const;
 
            void requestListRooms(void);
 
            void tryCreateRoom(const std::string& roomName, uint32_t maxPlayers, float difficulty, float speed, uint32_t duration, uint32_t seed, uint32_t levelId, uint8_t roomType);
            
            void tryJoinRoom(uint32_t roomId, bool asSpectator = false);
 
            void tryLeaveRoom(void);
 
            void trySetReady(bool isReady);
 
            void tryStartSolo(void);
 
            void trySendMessage(const std::string& message) const;
            
            void sendSelectedWeapon(uint8_t weaponKind) const;
        
        public:
            bool isInRoom(void) const;
 
            bool isReady(void) const;
 
            bool isUdpReady(void) const;
 
            bool isLoggedIn(void) const;
 
            bool _isStartingSolo = false;
 
            std::string getUsername(void) const;
 
            struct GameOverSummary {
                std::string bestPlayer;
                int bestScore{0};
                int playerScore{0};
            };
 
            void setGameOverSummary(const GameOverSummary& summary);
            GameOverSummary getGameOverSummary(void) const;
            bool consumeGameOver(void);
            int getScore(void) const;
            int getHealthCurrent(void) const;
            int getHealthMax(void) const;
 
            std::list<net::RoomInfo> getAvailableRooms(void) const;
 
            bool isInGame(void) const;
 
            State getState(void) const;
 
            uint32_t getCurrentLevelId(void) const;
 
            std::string getLastChatMessage(void) const;
 
            const std::deque<std::string>& getChatHistory(void) const;
 
            uint16_t getAmmoCurrent(void) const;
            uint16_t getAmmoMax(void) const;
            bool isReloading(void) const;
            float getReloadCooldownRemaining(void) const;
            uint32_t getPingMs(void) const;
            bool consumeKicked(void);
 
        private:
            ClientNetwork& _network;                                       
            ecs::Registry& _registry;                                 
            std::unordered_map<uint32_t, ecs::Entity> _netIdToEntity; 
            EntityBuilder _builder;                                        
        private:
            bool _isInRoom = false;                                        
            bool _isReady = false;                                         
            bool _udpReady = false;                                        
            bool _isLoggedIn = false;                                      
            std::string _username;                                         
            std::list<net::RoomInfo> _availableRooms;                 
            State _currentState = State::NotLogged;                        
            std::string _lastChatMessage;                                  
            std::deque<std::string> _chatHistory;                          
            std::size_t _chatHistoryLimit = 8;                             
            uint16_t _ammoCurrent = 0;                                     
            uint16_t _ammoMax = 100;                                       
            bool _ammoReloading = false;                                   
            float _ammoReloadRemaining = 0.0f;                             
            uint32_t _pingMs = 0;                                          
            float _pingTimer = 0.0f;                                       
            float _pingInterval = 1.0f;                                    
            bool _kicked = false;                                          
            uint32_t _currentLevelId = 1;                                   
            GameOverSummary _gameOverSummary{};                             
            bool _gameOverPending{false};                                   
            int _score{0};                                                  
            int _healthCurrent{0};                                          
            int _healthMax{0};                                              
        private:
            void handleEvent(net::NetworkEvent& event);
 
            void onLoginResponse(net::Packet& packet);
 
            void onRegisterResponse(net::Packet& packet);
 
            void onRoomResponse(net::Packet& packet);
 
            void onJoinRoomResponse(net::Packet& packet);
 
            void onCreateRoomResponse(net::Packet& packet);
 
            void onLeaveRoomResponse(net::Packet& packet);
 
            void onSpawnEntityFromServer(net::Packet& packet);
 
            void onEntityDeath(net::Packet& packet);
 
            void onRoomUpdate(net::Packet& packet);
 
            void onRoomChatReceived(net::Packet& packet);
 
            void pushChatMessage(const std::string& message);
 
            void onAmmoUpdate(net::Packet& packet);
            void onBeamState(net::Packet& packet);
            // Map ownerNetId -> list of (beamEntity, offsetY)
            std::unordered_map<uint32_t, std::vector<std::pair<ecs::Entity, float>>> _beamEntities;
            // Map ownerNetId -> list of beam lengths (parallel to _beamEntities entries)
            std::unordered_map<uint32_t, std::vector<float>> _beamLengths;
 
            void onPong(net::Packet& packet);
 
            void onDebugModeUpdate(net::Packet& packet);
    };
}
 
#endif /* !RTYPE_CLIENT_NETWORK_SYSTEM_HPP_ */