ArticyExpressoScripts.h

//  
// Copyright (c) 2023 articy Software GmbH & Co. KG. All rights reserved.  
//
 
#pragma once
 
#include "Internationalization/Regex.h"
#include "ArticyObject.h"
#include "ArticyDatabase.h"
 
#include "ArticyExpressoScripts.generated.h"
 
class UArticyString;
class UArticyInt;
class UArticyBool;
class UArticyExpressoScripts;
struct ExpressoType;

struct ARTICYRUNTIME_API ExpressoType
{
    union
    {
        bool BoolValue;   
        int64 IntValue = 0;   
        double FloatValue;   
    };
    FString StringValue;   

    enum EType
    {
        Undefined, Bool, Int, Float, String
    } Type = Undefined;   

    virtual bool& GetBool();

    virtual const bool& GetBool() const;

    virtual int64& GetInt();

    virtual const int64& GetInt() const;

    virtual double& GetFloat();

    virtual const double& GetFloat() const;

    virtual FString& GetString();

    virtual const FString& GetString() const;

    virtual FString ToString() const;
 
 
    //---------------------------------------------------------------------------//

    ExpressoType();

    virtual ~ExpressoType();

    ExpressoType(UArticyBaseObject* Object, const FString& Property);
 
    // ReSharper disable CppNonExplicitConvertingConstructor
 
    //implicit conversion from value type

    ExpressoType(const bool& Value);

    ExpressoType(const int64& Value);

    ExpressoType(const int32& Value);

    ExpressoType(const int16& Value);

    ExpressoType(const int8& Value);

    ExpressoType(const uint64& Value);

    ExpressoType(const uint32& Value);

    ExpressoType(const uint16& Value);

    ExpressoType(const uint8& Value);

    ExpressoType(const double& Value);

    ExpressoType(const float& Value);

    ExpressoType(const FString& Value);

    ExpressoType(const FText& Value);

    ExpressoType(const FName& Value);

    ExpressoType(const UArticyPrimitive* Object);

    ExpressoType(const UArticyString& Value);

    ExpressoType(const UArticyInt& Value);

    ExpressoType(const UArticyBool& Value);

    ExpressoType(const FArticyId& Value);
 
    //implicit conversion to value type

    explicit operator bool() const;

    explicit operator int64() const;

    explicit operator int8() const;

    explicit operator uint8() const;

    explicit operator int16() const;

    explicit operator uint16() const;

    explicit operator int32() const;

    explicit operator uint32() const;

    explicit operator uint64() const;

    explicit operator double() const;

    explicit operator float() const;

    explicit operator FString() const;

    explicit operator FText() const;

    explicit operator FName() const;

    explicit operator FArticyId() const;
 
    // ReSharper restore CppNonExplicitConvertingConstructor
 
    //---------------------------------------------------------------------------//

    ExpressoType operator-() const;

    bool operator==(const ExpressoType& Other) const;

    bool operator!=(const ExpressoType& Other) const;

    bool operator<(const ExpressoType& Other) const;

    bool operator>(const ExpressoType& Other) const;

    bool operator<=(const ExpressoType& Other) const;

    bool operator>=(const ExpressoType& Other) const;

    ExpressoType operator&&(const ExpressoType& Other) const;

    ExpressoType operator||(const ExpressoType& Other) const;

    ExpressoType operator^(const ExpressoType& Other) const;

    ExpressoType operator+(const ExpressoType& Other) const;

    ExpressoType operator-(const ExpressoType& Other) const;

    ExpressoType operator*(const ExpressoType& Other) const;

    ExpressoType operator/(const ExpressoType& Other) const;

    ExpressoType operator%(const ExpressoType& Other) const;
 
    //NOTE: No assignment/mutation operators are defined, as those are not
    //allowed anywhere where a ExpressoType is used!
    /*ExpressoType& operator++();
    ExpressoType operator++(int);
    ExpressoType& operator--();
    ExpressoType operator--(int);*/
 
    //---------------------------------------------------------------------------//

    struct Definition;

    static TMap<FName, Definition> Definitions;

    const Definition& GetDefinition(const FName& CppType) const;

    template<typename T>
    static void AddDefinition(const FName& CppType);
 
    //---------------------------------------------------------------------------//

    void SetValue(UArticyBaseObject* Object, FString Property) const;

    static UArticyBaseObject* TryFeatureReroute(UArticyBaseObject* Object, FString& Property);
};

struct ExpressoType::Definition
{
    TFunction<ExpressoType(UArticyBaseObject*, FProperty*)> Factory;

    TFunction<void(UArticyBaseObject*, FProperty*, const ExpressoType&)> Setter;
};

template<typename T>
void ExpressoType::AddDefinition(const FName& CppType)
{
    Definition def;
 
    def.Factory = [](UArticyBaseObject* Object, FProperty* Property)
        {
            if (Object && Property)
            {
                T* ptr = Property->ContainerPtrToValuePtr<T>(Object);
                if (ptr)
                    return ExpressoType(*ptr);
            }
 
            return ExpressoType{};
        };
 
    def.Setter = [](UArticyBaseObject* Object, FProperty* Property, const ExpressoType& Value)
        {
            if (!Object || !Property)
                return;
 
            T* ptr = Property->ContainerPtrToValuePtr<T>(Object);
            if (ptr)
                (*ptr) = (T)Value;
        };
 
    Definitions.Add(CppType, def);
}

FORCEINLINE int operator+(const int& Lhs, const ExpressoType& Rhs)
{
    return Lhs + (int)Rhs;
}

FORCEINLINE int operator-(const int& Lhs, const ExpressoType& Rhs)
{
    return Lhs - (int)Rhs;
}

FORCEINLINE int operator*(const int& Lhs, const ExpressoType& Rhs)
{
    return Lhs * (int)Rhs;
}

FORCEINLINE int operator/(const int& Lhs, const ExpressoType& Rhs)
{
    return Lhs / (int)Rhs;
}

FORCEINLINE int operator%(const int& Lhs, const ExpressoType& Rhs)
{
    return Lhs % (int)Rhs;
}

FORCEINLINE float operator+(const float& Lhs, const ExpressoType& Rhs)
{
    return Lhs + (float)Rhs;
}

FORCEINLINE float operator-(const float& Lhs, const ExpressoType& Rhs)
{
    return Lhs - (float)Rhs;
}

FORCEINLINE float operator*(const float& Lhs, const ExpressoType& Rhs)
{
    return Lhs * (float)Rhs;
}

FORCEINLINE float operator/(const float& Lhs, const ExpressoType& Rhs)
{
    return Lhs / (float)Rhs;
}

UCLASS(abstract)
class ARTICYRUNTIME_API UArticyExpressoScripts : public UObject
{
    GENERATED_BODY()
 
public:

    UArticyExpressoScripts()
    {
        //add empty condition and instruction
        Conditions.Add(GetTypeHash(FString{ "" }), [&] { return true; });
        Instructions.Add(GetTypeHash(FString{ "" }), [&] { return; });
    }

    virtual UClass* GetUserMethodsProviderInterface() { return nullptr; }

    virtual void Init(UArticyDatabase* DB) { OwningDatabase = DB; }

    UArticyDatabase* GetDb() const { return OwningDatabase; }
 

    void SetCurrentObject(UArticyPrimitive* Object) { self = Object; }

    void SetSpeaker(UArticyObject* Speaker) { speaker = Speaker; }

    bool Evaluate(const int& ConditionFragmentHash, UArticyGlobalVariables* GV, UObject* MethodProvider) const;

    bool Execute(const int& InstructionFragmentHash, UArticyGlobalVariables* GV, UObject* MethodProvider) const;

    void SetDefaultUserMethodsProvider(UObject* MethodProvider);

    UObject* GetDefaultUserMethodsProvider() const;

    UObject* GetUserMethodsProviderObject() const;

    virtual UArticyGlobalVariables* GetGV() { return nullptr; }
 
protected:

    virtual void SetGV(UArticyGlobalVariables* GV) const { }
 
    //========================================//

    UArticyPrimitive* self = nullptr;

    UArticyObject* speaker = nullptr;

    TMap<uint32, TFunction<bool()>> Conditions;

    TMap<uint32, TFunction<void()>> Instructions;

    UArticyObject* getObj(const FString& NameOrId, const uint32& CloneId = 0) const;

    static void setProp(UArticyBaseObject* Object, const FString& Property, const ExpressoType& Value);

    void setProp(const ExpressoType& Id_CloneId, const FString& Property, const ExpressoType& Value) const;

    static ExpressoType getProp(UArticyBaseObject* Object, const FString& Property);

    ExpressoType getProp(const ExpressoType& Id_CloneId, const FString& Property) const;

    int random(int Min, int Max);

    int random(int Max);

    float random(float Min, float Max);

    float random(float Max);

    ExpressoType random(const ExpressoType& Min, const ExpressoType& Max);

    ExpressoType random(const ExpressoType& Max);

    static void incrementProp(UArticyBaseObject* Object, const FString& Property, const float Value = 1);

    void incrementProp(const ExpressoType& Id_CloneId, const FString& Property, const float Value = 1) const;

    static void decrementProp(UArticyBaseObject* Object, const FString& Property, const float Value = 1);

    void decrementProp(const ExpressoType& Id_CloneId, const FString& Property, const float Value = 1) const;

    static bool isInRange(float valueToTest, float lowerBound, float upperBound);

    static bool isPropInRange(UArticyBaseObject* Object, const FString& Property, float lowerBound, float upperBound);

    bool isPropInRange(const ExpressoType& Id_CloneId, const FString& Property, float lowerBound, float upperBound) const;

    static bool isInRange(const FString& valueToTest, const FString& lowerBound, const FString& upperBound);

    static bool isPropInRange(UArticyBaseObject* Object, const FString& Property, const FString& lowerBound, const FString& upperBound);

    bool isPropInRange(const ExpressoType& Id_CloneId, const FString& Property, const FString& lowerBound, const FString& upperBound) const;

    void resetAllSeenCounters();

    int getSeenCounter(UArticyBaseObject* Object = nullptr);

    int getSeenCounter(const FString& NameOrId);

    int setSeenCounter(const int Value = 1);

    int setSeenCounter(UArticyBaseObject* Object, const int Value = 1);

    int setSeenCounter(const FString& NameOrId, const int Value = 1);

    bool fallback(UArticyBaseObject* Object);

    bool fallback(const FString& NameOrId);

    bool fallback();

    template<typename ...ArgTypes>
    static void print(const FString& Msg, ArgTypes... Args);

    template<typename ...ArgTypes>
    static void print(const ExpressoType& Msg, ArgTypes... Args)
    {
        print(Msg.ToString(), Args...);
    }

    static const bool& ConditionOrTrue(const bool& Condition) { return Condition; }

    static const bool ConditionOrTrue(const int& Condition) { return Condition > 0; }

    static bool ConditionOrTrue(void /*JustAComment*/) { return true; }

    mutable UObject* UserMethodsProvider = nullptr;

    TWeakObjectPtr<UObject> DefaultUserMethodsProvider = nullptr;
 
private:

    UArticyDatabase* OwningDatabase = nullptr;

    UArticyObject* getObjInternal(const ExpressoType& Id_CloneId) const;

    static void PrintInternal(const FString& msg);
};

template <typename ... ArgTypes>
void UArticyExpressoScripts::print(const FString& Msg, ArgTypes... Args)
{
    auto msg = Msg;
 
    auto arr = TArray<ExpressoType>{ Args... };
    for (int i = 0; i < arr.Num(); ++i)
        msg = msg.Replace(*FString::Printf(TEXT("{%d}"), i), *FString{ arr[i] });
 
    PrintInternal(msg);
}