Line data    Source code

       1              : #ifndef __NETWORK_EVENT_DISPATCHER_HPP__
       2              : #define __NETWORK_EVENT_DISPATCHER_HPP__
       3              : 
       4              : #include "communication/NetworkEvent.hpp"
       5              : #include "communication/NetworkMessage.hpp"
       6              : 
       7              : #include "core/math/Glm.hpp"
       8              : #include "core/state/Control.hpp"
       9              : #include "core/animations/AnimationData.hpp"
      10              : #include "core/types/BulletType.hpp"
      11              : #include "core/types/TeamType.hpp"
      12              : #include "core/types/WeaponType.hpp"
      13              : 
      14              : #include <memory>
      15              : #include <optional>
      16              : #include <variant>
      17              : #include <utility>
      18              : #include <functional>
      19              : #include <vector>
      20              : 
      21              : namespace Soldank
      22              : {
      23              : enum class NetworkEventDispatchResult
      24              : {
      25              :     Success = 0,
      26              :     ParseError,
      27              :     ObserverFailure,
      28              :     HandlerFailure
      29              : };
      30              : 
      31              : enum class NetworkEventHandlerResult
      32              : {
      33              :     Success = 0,
      34              :     Failure = 1,
      35              : };
      36              : 
      37              : struct ConnectionMetadata
      38              : {
      39              :     unsigned int connection_id;
      40              :     std::function<void(const NetworkMessage&)> send_message_to_connection;
      41              : };
      42              : 
      43              : class INetworkEventHandler
      44              : {
      45              : public:
      46           16 :     virtual ~INetworkEventHandler() = default;
      47              :     virtual bool ShouldHandleNetworkEvent(NetworkEvent network_event) const = 0;
      48              :     virtual std::optional<ParseError> ValidateNetworkMessage(
      49              :       const NetworkMessage& network_message) const = 0;
      50              :     virtual NetworkEventHandlerResult HandleNetworkMessage(
      51              :       unsigned int sender_connection_id,
      52              :       const NetworkMessage& network_message) = 0;
      53              : };
      54              : 
      55              : template<typename... NetworkMessageArgs>
      56              : class NetworkEventHandlerBase : public INetworkEventHandler
      57              : {
      58              : public:
      59           11 :     bool ShouldHandleNetworkEvent(NetworkEvent network_event) const override
      60              :     {
      61           11 :         return network_event == GetTargetNetworkEvent();
      62              :     }
      63              : 
      64            6 :     std::optional<ParseError> ValidateNetworkMessage(
      65              :       const NetworkMessage& network_message) const override
      66              :     {
      67            6 :         auto parsed = GetNetworkMessageOrError(network_message);
      68            6 :         if (!parsed.has_value()) {
      69            2 :             return parsed.error();
      70              :         }
      71              : 
      72            4 :         return std::nullopt;
      73            3 :     }
      74              : 
      75            4 :     NetworkEventHandlerResult HandleNetworkMessage(unsigned int sender_connection_id,
      76              :                                                    const NetworkMessage& network_message) override
      77              :     {
      78            4 :         auto parsed = GetNetworkMessageOrError(network_message);
      79            4 :         if (!parsed.has_value()) {
      80              :             // Before using this method, the network_message should be validated. Here we just
      81              :             // assume the network_message is correct
      82            0 :             return NetworkEventHandlerResult::Failure;
      83              :         }
      84              : 
      85            4 :         return std::apply(
      86           12 :           [this, sender_connection_id](NetworkEvent /*ignore*/,
      87              :                                        NetworkMessageArgs... network_message_args) {
      88            4 :               return HandleNetworkMessageImpl(sender_connection_id, network_message_args...);
      89              :           },
      90            4 :           *parsed);
      91            2 :     }
      92              : 
      93              : protected:
      94              :     std::expected<std::tuple<NetworkEvent, NetworkMessageArgs...>, ParseError>
      95           10 :     GetNetworkMessageOrError(const NetworkMessage& network_message) const
      96              :     {
      97           10 :         return network_message.Parse<NetworkEvent, NetworkMessageArgs...>();
      98              :     }
      99              : 
     100              :     virtual NetworkEvent GetTargetNetworkEvent() const = 0;
     101              :     virtual NetworkEventHandlerResult HandleNetworkMessageImpl(unsigned int sender_connection_id,
     102              :                                                                NetworkMessageArgs...) = 0;
     103              : };
     104              : 
     105              : class NetworkEventDispatcher
     106              : {
     107              : 
     108              : public:
     109              :     using TDispatchResult =
     110              :       std::pair<NetworkEventDispatchResult, std::variant<ParseError, NetworkEventHandlerResult>>;
     111              : 
     112              :     NetworkEventDispatcher(
     113              :       const std::vector<std::shared_ptr<INetworkEventHandler>>& network_event_handlers);
     114              : 
     115              :     TDispatchResult ProcessNetworkMessage(const ConnectionMetadata& connection_metadata,
     116              :                                           const NetworkMessage& network_message);
     117              : 
     118              :     void AddNetworkEventHandler(const std::shared_ptr<INetworkEventHandler>& network_event_handler);
     119              : 
     120              : private:
     121              :     std::vector<std::shared_ptr<INetworkEventHandler>> network_event_handlers_;
     122              : };
     123              : } // namespace Soldank
     124              : 
     125              : #endif