NetworkEntity.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Entity/Action.hpp"
#include "CeresEngine/Entity/Component.hpp"
#include "CeresEngine/Entity/Entity.hpp"
#include "CeresEngine/Entity/Event.hpp"
 
#include <cstdint>
 
namespace CeresEngine {
 
    struct CE_SCRIPT_EXPORT() NetworkEntityID {
        CE_SCRIPT_EXPORT()
        UInt64 raw = 0;
 
        CE_SCRIPT_EXPORT()
        inline constexpr NetworkEntityID() noexcept = default;
 
        CE_SCRIPT_EXPORT()
        constexpr NetworkEntityID(const NetworkEntityID& other) noexcept = default;
 
        constexpr NetworkEntityID& operator=(const NetworkEntityID& other) noexcept = default;
 
        CE_SCRIPT_EXPORT()
        explicit inline constexpr NetworkEntityID(const UInt64 raw) noexcept : raw(raw) {}
 
    public: // Operators
        [[nodiscard]] friend inline constexpr bool operator==(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw == b.raw; }
 
        [[nodiscard]] friend inline constexpr bool operator!=(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw != b.raw; }
 
        [[nodiscard]] friend inline constexpr bool operator<(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw < b.raw; }
 
        [[nodiscard]] friend inline constexpr bool operator<=(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw <= b.raw; }
 
        [[nodiscard]] friend inline constexpr bool operator>(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw > b.raw; }
 
        [[nodiscard]] friend inline constexpr bool operator>=(const NetworkEntityID& a, const NetworkEntityID& b) noexcept { return a.raw >= b.raw; }
 
        friend std::ostream& operator<<(std::ostream& os, const NetworkEntityID& id);
    };
 
    struct CE_SCRIPT_EXPORT() NetworkEntityComponent final : public Component<NetworkEntityComponent> {
        CE_REFLECTABLE_STRUCT
        struct Accessor;
 
        CE_SCRIPT_EXPORT()
        NetworkEntityID id;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA(id); }
    };
 
    struct NetworkEntityComponent::Accessor : public Component<NetworkEntityComponent>::Accessor {
        using Component<NetworkEntityComponent>::Accessor::Accessor;
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        NetworkEntityID getID() const { return read(&C::id); }
 
        CE_SCRIPT_EXPORT()
        void setID(const NetworkEntityID id) { mutate(&C::id) = id; }
 
    public:
        [[nodiscard]] CE_SCRIPT_EXPORT()
        bool hasAuthority() const noexcept;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA_GETSET(id, getID, setID); }
    };
 
    class NetworkEntity : public EntityObject<NetworkEntityComponent> {
        using Type::Type;
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct TransferAuthority final : public EntityAction<TransferAuthority> {};
    struct HasAuthorityQuery final : public EntityAction<HasAuthorityQuery, bool> {};
 
    // ---------------------------------------------------------------------------------------------
 
    struct GainedAuthority final : public EntityEvent<GainedAuthority> {};
    struct LostAuthority final : public EntityEvent<LostAuthority> {};
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::NetworkEntityID> {
    size_t operator()(const CeresEngine::NetworkEntityID& networkEntityID) const { return CeresEngine::hash(networkEntityID.raw); }
};
 
CE_EXTERN_COMPONENT(CeresEngine::NetworkEntityComponent);
 
CE_ENTITY_OBJECT_HASH(CeresEngine::NetworkEntity);