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/SFMLPackets.h"
#include "Common/DataStoring/NamedVars.h"
#include "CommonNetwork.h"
#include "Entities/Objects/Constraints.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,

    EntityCreation,
    
    EntityUpdate,

    EntityDestruction,

    CacheUpdated,

    CacheRemoved,

    EntityConstraint,

    WorldFrozen,

    ServerHeartbeat,

    StartHeartbeats,

    Custom,

    None
};


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;
    }

    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"

}

#ifdef LEAK_INTO_GLOBAL
using Leviathan::NetworkResponse;
#endif