NetworkResponse.h

Go to the documentation of this file.

// Leviathan Game Engine
// Copyright (c) 2012-2016 Henri Hyyryläinen
#pragma once
#include "Define.h"
// ------------------------------------ //
#include "Common/DataStoring/NamedVars.h"
#include "Common/SFMLPackets.h"
#include "CommonNetwork.h"
#include "Exceptions.h"

#include "GameSpecificPacketHandler.h"

#include <memory>

namespace Leviathan {

enum class NETWORK_RESPONSE_TYPE : uint16_t {

    Connect,

    Security,

    Authenticate,

    Identification,

    Keepalive,

    CloseConnection,

    RemoteConsoleClosed,

    RemoteConsoleOpened,

    InvalidRequest,

    ServerDisallow,

    ServerAllow,

    ServerStatus,

    SyncValData,

    SyncDataEnd,

    SyncResourceData,

    CreateNetworkedInput,

    UpdateNetworkedInput,

    DisconnectInput,

    StartWorldReceive,

    EntityCreation,

    EntityUpdate,

    EntityDestruction,

    EntityLocalControlStatus,

    CacheUpdated,

    CacheRemoved,

    // //! Instructs a world to create or destroy a constraint
    // //! Create When false the constraint is to be deleted
    // EntityConstraint,

    WorldFrozen,

    ServerHeartbeat,

    StartHeartbeats,

    None,

    Custom
};


class NetworkResponse {
public:
    NetworkResponse(NETWORK_RESPONSE_TYPE type, uint32_t responseid) :
        Type(type), ResponseID(responseid)
    {
        LEVIATHAN_ASSERT(responseid != static_cast<uint32_t>(-1),
            "Response should use 0 if in response to anything");
    }

    virtual ~NetworkResponse(){};

    inline void AddDataToPacket(sf::Packet& packet) const
    {
        packet << static_cast<uint16_t>(Type) << ResponseID;

        _SerializeCustom(packet);
    }

    inline NETWORK_RESPONSE_TYPE GetType() const
    {
        return Type;
    }

    DLLEXPORT std::string GetTypeStr() const;

    inline auto GetResponseID() const
    {
        return ResponseID;
    }

    DLLEXPORT static std::shared_ptr<NetworkResponse> LoadFromPacket(sf::Packet& packet);

    DLLEXPORT static void LimitResponseSize(
        ResponseIdentification& response, uint32_t maxsize);

protected:
    DLLEXPORT virtual void _SerializeCustom(sf::Packet& packet) const = 0;

    const NETWORK_RESPONSE_TYPE Type;

    const uint32_t ResponseID = 0;
};

class ResponseCustom : public NetworkResponse {
public:
    ResponseCustom(
        uint32_t responseid, std::shared_ptr<GameSpecificPacketData> actualresponse) :
        NetworkResponse(NETWORK_RESPONSE_TYPE::Custom, responseid),
        ActualResponse(actualresponse)
    {}

    void _SerializeCustom(sf::Packet& packet) const override
    {

        LEVIATHAN_ASSERT(0, "_SerializeCustom called on ResponseCustom");
    }

    inline void AddDataToPacket(GameSpecificPacketHandler& handler, sf::Packet& packet)
    {

        packet << ResponseID << static_cast<uint16_t>(Type);

        handler.PassGameSpecificDataToPacket(ActualResponse.get(), packet);
    }

    ResponseCustom(
        GameSpecificPacketHandler& handler, uint32_t responseid, sf::Packet& packet) :
        NetworkResponse(NETWORK_RESPONSE_TYPE::Custom, responseid)
    {
        ActualResponse = handler.ReadGameSpecificPacketFromPacket(true, packet);
        if(!ActualResponse) {

            throw InvalidArgument("invalid packet format for user defined response");
        }
    }

    std::shared_ptr<GameSpecificPacketData> ActualResponse;
};

class ResponseNone : public NetworkResponse {
public:
    ResponseNone(NETWORK_RESPONSE_TYPE actualtype, uint32_t responseid = 0) :
        NetworkResponse(actualtype, responseid)
    {}

    void _SerializeCustom(sf::Packet& packet) const override {}

    ResponseNone(NETWORK_RESPONSE_TYPE actualtype, uint32_t responseid, sf::Packet& packet) :
        NetworkResponse(actualtype, responseid)
    {}
};


// This file is generated by the script GenerateResponse.rb
// and contains implementations for all the response types
#include "../Generated/ResponseImpl.h"

} // namespace Leviathan

#ifdef LEAK_INTO_GLOBAL
using Leviathan::NetworkResponse;
#endif