KarmaTypes.h

Go to the documentation of this file.

 
#pragma once
 
#include <vector>
#include <cstdint>
#include <map>
#include <utility>
#include <algorithm>
#include <glm/glm.hpp>
 
enum class EAllowShrinking
{
    Yes,

    No
};

namespace EEndPlayReason
{
    enum Type : int
    {
        Destroyed,
        LevelTransition,
        EndPlayInEditor,
        RemovedFromWorld,
        Quit,
    };
}

enum { INDEX_NONE = -1 };

namespace EWorldType
{
    enum Type
    {
        None,

        Game,

        Editor,

        PIE,

        EditorPreview,

        GamePreview,

        GameRPC,

        Inactive
    };
}

template <typename KeyType, typename ValueType>
class KarmaMap
{
public:
    typedef std::map<KeyType, ValueType> AMap;
    typedef typename AMap::iterator AnIterator;

    KarmaMap()
    {
    }

    void Add(const KeyType& Key, const ValueType& Value)
    {
        m_KeyValuePair.insert(typename AMap::value_type(Key, Value));
    }

    bool Contains(const KeyType& Key) const
    {
        return m_KeyValuePair.find(Key) != m_KeyValuePair.end();
    }

    ValueType& FindOrAdd(const KeyType& Key)
    {
        ValueType aValue;
        std::pair<AnIterator, bool> const& result = m_KeyValuePair.insert(typename AMap::value_type(Key, aValue));
 
        // a simple return.first->second could work. doing this for better understandibility
        if(result.second)
        {
            // Value was inserted, meaning wasn't there earlier
            return result.first->second;
        }
        else
        {
            // Nothing inserted, meaning value with key already exists
            return result.first->second;
        }
    }

 
    ValueType* Find(const KeyType& Key)
    {
        AnIterator result = m_KeyValuePair.find(Key);
 
        if(result != m_KeyValuePair.end())
        {
            return &result->second;
        }
 
        return nullptr;
    }

    ValueType& operator[](const KeyType& Key)
    {
        return m_KeyValuePair[Key];
    }

    const ValueType& operator[](const KeyType& Key) const
    {
        return m_KeyValuePair.at(Key);
    }
 
    uint32_t Num() const
    {
        return (uint32_t) m_KeyValuePair.size();
    }
 
    auto begin()
    {
        return m_KeyValuePair.begin();
    }
 
    auto end()
    {
        return m_KeyValuePair.end();
    }
 
    auto begin() const
    {
        return m_KeyValuePair.cbegin();
    }
 
    auto end() const
    {
        return m_KeyValuePair.cend();
    }
 
protected:
    AMap m_KeyValuePair;
};

template<typename BuildingBlock>
class KarmaVector
{
public:
    KarmaVector()
    {
    }

    ~KarmaVector()
    {
    }

    uint32_t Remove(BuildingBlock aBlock)
    {
        uint32_t occurences = 0;
        typename std::vector<BuildingBlock>::iterator iterator = m_Elements.begin();
 
        while (iterator != m_Elements.end())
        {
            if (*iterator == aBlock)
            {
                iterator = m_Elements.erase(iterator);
                occurences++;
            }
            else
            {
                ++iterator;
            }
        }
 
        return occurences;
    }

    void Add(BuildingBlock aBlock)
    {
        m_Elements.push_back(aBlock);
    }

    void RangeCheck(uint32_t Index) const
    {
        KR_CORE_ASSERT((Index >= 0 && Index < Num()), "KarmaVector: Range check failed");
    }

    FORCEINLINE int32_t AddUnique(const BuildingBlock& Item)
    {
        int32_t index = Find(Item);
 
        if(index == -1)
        {
            Add(Item);
            return Num() - 1;
        }
        else
        {
            return index;
        }
    }

    int32_t Find(const BuildingBlock& Item) const
    {
        int32_t returnIndex = 0;
 
        typename std::vector<BuildingBlock>::const_iterator iter = m_Elements.begin();
 
        for (; iter != m_Elements.end(); iter++)
        {
            if (m_Elements[returnIndex] == Item)
            {
                break;
            }
            returnIndex++;
        }
 
        if (iter != m_Elements.end())
        {
            return returnIndex;
        }
 
        return INDEX_NONE;
    }

    bool Contains(BuildingBlock aBlock) const
    {
        typename std::vector<BuildingBlock>::const_iterator iterator = m_Elements.begin();
 
        while (iterator != m_Elements.end())
        {
            if (*iterator == aBlock)
            {
                return true;
            }
            else
            {
                ++iterator;
            }
        }
 
        return false;
    }

    void RemoveAtSwap(int32_t Index/*, EAllowShrinking AllowShrinking = EAllowShrinking::Yes*/)
    {
        RangeCheck(Index);
        RemoveAtSwapImpl(Index);
 
        //if (AllowShrinking == EAllowShrinking::Yes)
        //{
            // not functional yet
        //}
    }

    uint32_t RemoveSingleSwap(const BuildingBlock& Item/*, EAllowShrinking AllowShrinking = EAllowShrinking::Yes*/)
    {
        int32_t Index = Find(Item);
 
        if (Index == INDEX_NONE)
        {
            return 0;
        }
 
        RemoveAtSwap(Index/*, AllowShrinking*/);
 
        return 1;
    }

    uint32_t Num() const
    {
        return (uint32_t) m_Elements.size();
    }

    void Reset()
    {
        // Maybe make smartpointer instead of manually deleting
        typename std::vector<BuildingBlock>::iterator iter = m_Elements.begin();
 
        // solution got from https://www.reddit.com/r/cpp_questions/comments/panivh/constexpr_if_statement_to_check_if_template/?utm_source=share&utm_medium=web3x&utm_name=web3xcss&utm_term=1&utm_content=share_button
        if constexpr(std::is_pointer_v<BuildingBlock>)
        {
            for (iter = m_Elements.begin(); iter != m_Elements.end(); iter++)
            {
                if (*iter != nullptr)
                {
                    KR_CORE_INFO("Deleting UObjects");
                    delete *iter;
                    *iter = nullptr;
                }
            }
        }
 
        m_Elements.clear();
    }
 
    void Resize(uint32_t NewSize)
    {
        m_Elements.resize(NewSize);
    }

    void SmartReset()
    {
        m_Elements.clear();
    }

    void SetVectorElementByIndex(int32_t Index, BuildingBlock Value)
    {
        m_Elements[Index] = Value;
    }

    inline void Clear() { m_Elements.clear(); }
    
    inline const std::vector<BuildingBlock>& GetElements() const { return m_Elements; }

    inline std::vector<BuildingBlock>& ModifyElements() { return m_Elements; }

    typename std::vector<BuildingBlock>::iterator begin()
    {
        return m_Elements.begin();
    }

    typename std::vector<BuildingBlock>::iterator end()
    {
        return m_Elements.end();
    }
 
    typename std::vector<BuildingBlock>::const_iterator begin() const
    {
        return m_Elements.cbegin();
    }
 
    typename std::vector<BuildingBlock>::const_iterator end() const
    {
        return m_Elements.cend();
    }

    FORCEINLINE BuildingBlock& IndexToObject(int32_t Index)
    {
        KR_CORE_ASSERT(Index >= 0, "");
        
        if(Index < Num())
        {
            return m_Elements.at(Index);
        }
 
        KR_CORE_ASSERT(false, "Shouldn't happen");
 
        static BuildingBlock aBlock;
        return aBlock;
    }

    FORCEINLINE bool IsValidIndex(int32_t Index) const
    {
        return Index >= 0 && Index < Num();
    }

    FORCEINLINE BuildingBlock const* GetData() const { return m_Elements.data(); }
 
    BuildingBlock& operator[](int32_t Index)
    {
        RangeCheck(Index);
        return m_Elements[Index];
    }
 
    const BuildingBlock& operator[](int32_t Index) const
    {
        RangeCheck(Index);
        return m_Elements[Index];
    }
 
private:
    void RemoveAtSwapImpl(int32_t Index)
    {
        const BuildingBlock* Data = GetData();
        const BuildingBlock* Dest = Data + Index;
 
        // Number of elements (after the generated vacancy) to move
        const int32_t NumElementsAfterHole = Num() - Index - 1;
        const int32_t NumElementsToMoveIntoHole = glm::min(1, NumElementsAfterHole);
 
        if (NumElementsToMoveIntoHole)
        {
            //std::memmove((void *) Dest, (const void*)(Data + Num() - NumElementsToMoveIntoHole),
            //  sizeof(BuildingBlock) * NumElementsToMoveIntoHole);
            const int32_t LastElementIndex = Num() - 1;
            
            m_Elements[Index] = m_Elements[LastElementIndex];
        }
        m_Elements.pop_back();
    }
 
protected:
    std::vector<BuildingBlock> m_Elements;
};

enum ETravelType
{
    TRAVEL_Absolute,

    TRAVEL_Partial,

    TRAVEL_Relative,

    TRAVEL_MAX,
};

enum class ETeleportType : uint8_t
{
    None,

    TeleportPhysics,

    ResetPhysics,
};

struct KARMA_API FUrlConfig
{
    std::string m_DefaultProtocol;
    std::string m_DefaultName;
    std::string m_DefaultHost;
    std::string m_DefaultPortal;
    std::string m_DefaultSaveExt;
    int32_t m_DefaultPort;

    void Init();

    void Reset();
};

struct KARMA_API FURL
{
    std::string m_Protocol;

    std::string m_Host;

    int32_t m_Port;
 
    int32_t m_Valid;

    std::string m_Map;

    std::string m_RedirectURL;
 
    // Options.
    //TArray<FString> Op;

    std::string m_Portal;

    static FUrlConfig UrlConfig;
    static bool m_bDefaultsInitialized;

    //explicit FURL(ENoInit) { }

    FURL(const std::string& Filename = "");

    //FURL(FURL* Base, const TCHAR* TextURL, ETravelType Type);
 
    //static void StaticInit();
    //static void StaticExit();

    //static void FilterURLString(const std::string& Str);

    //bool IsInternal() const;

    //bool IsLocalInternal() const;

    //bool HasOption(const TCHAR* Test) const;

    //const TCHAR* GetOption(const TCHAR* Match, const TCHAR* Default) const;

    //void LoadURLConfig(const TCHAR* Section, const std::string& Filename = "GGameIni");

    //void SaveURLConfig(const TCHAR* Section, const TCHAR* Item, const std::string& Filename = "GGameIni") const;

    //void AddOption(const TCHAR* Str);

    //void RemoveOption(const TCHAR* Key, const TCHAR* Section = nullptr, const std::string& Filename = "GGameIni");

    //std::string ToString(bool FullyQualified = 0) const;

    //std::string GetHostPortString() const;

    //ENGINE_API friend FArchive& operator<<(FArchive& Ar, FURL& U);

    //bool operator==(const FURL& Other) const;
};