FactoryCraft-Server/FactoryCraft/JsonExpression.h

#pragma once

#include <Array.h>
#include <Assembly.h>
#include <Critical.h>
#include <functional>
#include <JSON.h>
#include <Text.h>
#include <Trie.h>

#include "Noise.h"
#include "TypeRegistry.h"

class Chunk;

class JExpressionMemory;

class JExpressionMemory : public virtual Framework::ReferenceCounter
{
private:
    Framework::RCTrie<Noise> noises;
    Framework::Trie<float> floatVariables;
    Framework::Trie<bool> boolVariables;
    Chunk* currentChunk;
    Framework::Critical cs;

public:
    JExpressionMemory();
    ~JExpressionMemory();

    void lock();
    void unlock();

    float getNoise(Framework::Text name, float x, float y, float z) const;
    Noise* zNoiseP(Framework::Text name);
    void setNoise(Framework::Text name, Noise* noise);
    void setCurrentChunk(Chunk* chunk);

    float getFloatVariable(const Framework::Text& name) const;
    float* getFloatVariableP(const Framework::Text& name);
    void setFloatVariable(const Framework::Text& name, float value);
    bool getBoolVariable(const Framework::Text& name) const;
    bool* getBoolVariableP(const Framework::Text& name);
    void setBoolVariable(const Framework::Text& name, bool value);
    Chunk* zCurrentChunk();
    Chunk** zzCurrentChunk();
};

typedef float (*FloatFunc)();

class JFloatExpression : public virtual Framework::ReferenceCounter
{
private:
    FloatFunc compiled;
    JExpressionMemory* memory;

protected:
    Framework::Assembly::AssemblyBlock codeBlock;

public:
    JFloatExpression();
    virtual Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory)
        = 0;
    virtual float getValueOld(JExpressionMemory* zMemory) = 0;
    float getValue(JExpressionMemory* zMemory);
    FloatFunc compile(JExpressionMemory* zMemory);
};

typedef bool (*BoolFunc)();

class JBoolExpression : public virtual Framework::ReferenceCounter
{
private:
    BoolFunc compiled;
    JExpressionMemory* memory;

protected:
    Framework::Assembly::AssemblyBlock codeBlock;

public:
    JBoolExpression();
    virtual Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory)
        = 0;
    virtual bool getValueOld(JExpressionMemory* zMemory) = 0;
    bool getValue(JExpressionMemory* zMemory);
    BoolFunc compile(JExpressionMemory* zMemory);
};

class JVariableFloatExpression : public JFloatExpression
{
private:
    Framework::Text name;

public:
    JVariableFloatExpression();
    float getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setName(Framework::Text name);
    Framework::Text getName() const;
};

class JVariableFloatExpressionFactory
    : public SubTypeFactory<JFloatExpression, JVariableFloatExpression>
{
public:
    JVariableFloatExpressionFactory();
    JVariableFloatExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JVariableFloatExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JVariableBoolExpression : public JBoolExpression
{
private:
    Framework::Text name;

public:
    JVariableBoolExpression();
    bool getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setName(Framework::Text name);
    Framework::Text getName() const;
};

class JVariableBoolExpressionFactory
    : public SubTypeFactory<JBoolExpression, JVariableBoolExpression>
{
public:
    JVariableBoolExpressionFactory();
    JVariableBoolExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JVariableBoolExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JConstantFloatExpression : public JFloatExpression
{
private:
    float value;

public:
    JConstantFloatExpression();
    float getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setValue(float value);
    float getValue() const;
};

class JConstantFloatExpressionFactory
    : public SubTypeFactory<JFloatExpression, JConstantFloatExpression>
{
public:
    JConstantFloatExpressionFactory();
    JConstantFloatExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JConstantFloatExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JConstantBoolExpression : public JBoolExpression
{
private:
    bool value;

public:
    JConstantBoolExpression();
    bool getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setValue(bool value);
    bool getValue() const;
};

class JConstantBoolExpressionFactory
    : public SubTypeFactory<JBoolExpression, JConstantBoolExpression>
{
public:
    JConstantBoolExpressionFactory();
    JConstantBoolExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JConstantBoolExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JNoiseFloatExpression : public JFloatExpression
{
private:
    Framework::Text name;
    JFloatExpression* x;
    JFloatExpression* y;
    JFloatExpression* z;

public:
    JNoiseFloatExpression();
    ~JNoiseFloatExpression();
    float getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setName(Framework::Text name);
    Framework::Text getName() const;
    void setX(JFloatExpression* x);
    JFloatExpression* zX() const;
    void setY(JFloatExpression* y);
    JFloatExpression* zY() const;
    void setZ(JFloatExpression* z);
    JFloatExpression* zZ() const;
};

class JNoiseFloatExpressionFactory
    : public SubTypeFactory<JFloatExpression, JNoiseFloatExpression>
{
public:
    JNoiseFloatExpressionFactory();
    JNoiseFloatExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JNoiseFloatExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JOperatorFloatExpression : public JFloatExpression
{
private:
    Framework::Text op;
    std::function<float(float a, float b)> accumulator;
    Framework::RCArray<JFloatExpression> values;

public:
    JOperatorFloatExpression();
    float getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setOperator(
        Framework::Text op, std::function<float(float a, float b)> accumulator);
    Framework::Text getOperator();
    void addValue(JFloatExpression* value);
    const Framework::RCArray<JFloatExpression>& getValues() const;
};

class JOperatorFloatExpressionFactory
    : public SubTypeFactory<JFloatExpression, JOperatorFloatExpression>
{
public:
    JOperatorFloatExpressionFactory();
    JOperatorFloatExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JOperatorFloatExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JBoolOperatorBoolExpression : public JBoolExpression
{
private:
    Framework::Text op;
    std::function<bool(bool a, bool b)> accumulator;
    Framework::RCArray<JBoolExpression> values;

public:
    JBoolOperatorBoolExpression();
    bool getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setOperator(
        Framework::Text op, std::function<float(float a, float b)> accumulator);
    Framework::Text getOperator();
    void addValue(JBoolExpression* value);
    const Framework::RCArray<JBoolExpression>& getValues() const;
};

class JBoolOperatorBoolExpressionFactory
    : public SubTypeFactory<JBoolExpression, JBoolOperatorBoolExpression>
{
public:
    JBoolOperatorBoolExpressionFactory();
    JBoolOperatorBoolExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JBoolOperatorBoolExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JFloatOperatorBoolExpression : public JBoolExpression
{
private:
    Framework::Text op;
    std::function<bool(float a, float b)> accumulator;
    Framework::RCArray<JFloatExpression> values;

public:
    JFloatOperatorBoolExpression();
    bool getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setOperator(
        Framework::Text op, std::function<bool(float a, float b)> accumulator);
    Framework::Text getOperator();
    void addValue(JFloatExpression* value);
    const Framework::RCArray<JFloatExpression>& getValues() const;
};

class JFloatOperatorBoolExpressionFactory
    : public SubTypeFactory<JBoolExpression, JFloatOperatorBoolExpression>
{
public:
    JFloatOperatorBoolExpressionFactory();
    JFloatOperatorBoolExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JFloatOperatorBoolExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};

class JBlockTypeBoolExpression : public JBoolExpression
{
private:
    int typeId;
    JFloatExpression* x;
    JFloatExpression* y;
    JFloatExpression* z;

public:
    JBlockTypeBoolExpression();
    ~JBlockTypeBoolExpression();

private:
    bool isValidPosition(int x, int y, Chunk* currentChunk);

public:
    bool getValueOld(JExpressionMemory* zMemory) override;
    Framework::Assembly::AssemblyBlock& buildAssembly(
        JExpressionMemory* zMemory) override;

    void setTypeId(int typeId);
    int getTypeId() const;
    void setX(JFloatExpression* x);
    JFloatExpression* zX() const;
    void setY(JFloatExpression* y);
    JFloatExpression* zY() const;
    void setZ(JFloatExpression* z);
    JFloatExpression* zZ() const;
};

class JBlockTypeBoolExpressionFactory
    : public SubTypeFactory<JBoolExpression, JBlockTypeBoolExpression>
{
public:
    JBlockTypeBoolExpressionFactory();
    JBlockTypeBoolExpression* fromJson(
        Framework::JSON::JSONObject* zJson) const override;
    Framework::JSON::JSONObject* toJsonObject(
        JBlockTypeBoolExpression* zObject) const override;
    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override;
    const char* getTypeToken() const override;
};