FactoryCraft-Server/FactoryCraft/GeneratorRule.h

#pragma once

#include <Either.h>
#include <JSON.h>

#include "Block.h"
#include "JNoise.h"
#include "JsonExpression.h"
#include "TypeRegistry.h"

class GeneratorRule : public virtual Framework::ReferenceCounter
{
private:
    Framework::JSON::JSONObject* noiseConfig;
    Noise* noise;
    float threshold;
    JBoolExpression* condition;

protected:
    virtual Framework::Either<Block*, int> createBlock(
        int x, int y, int z, int dimensionId)
        = 0;

public:
    GeneratorRule();
    ~GeneratorRule();

    void initialize(JExpressionMemory* zMemory);

    bool checkCondition(int x, int y, int z, JExpressionMemory* zMemory);
    Framework::Either<Block*, int> generateBlock(
        int x, int y, int z, int dimensionId);

    void setNoiseConfig(Framework::JSON::JSONObject* noiseConfig);
    Framework::JSON::JSONObject* zNoiseConfig() const;
    void setThreshold(float threshold);
    float getThreshold() const;
    void setCondition(JBoolExpression* condition);
    JBoolExpression* zCondition() const;
};

template<typename S> class GeneratorRuleFactory
    : public SubTypeFactory<GeneratorRule, S>
{
public:
    GeneratorRuleFactory()
        : SubTypeFactory<GeneratorRule, S>()
    {}

    S* fromJson(Framework::JSON::JSONObject* zJson) const override
    {
        S* result = createValue(zJson);
        GeneratorRule* zRule = dynamic_cast<GeneratorRule*>(result);
        if (zJson->hasValue("noise"))
        {
            zRule->setNoiseConfig(zJson->getValue("noise")->asObject());
        }
        if (zJson->hasValue("threshold"))
        {
            zRule->setThreshold(
                (float)zJson->zValue("threshold")->asNumber()->getNumber());
        }
        zRule->setCondition(
            Game::INSTANCE->zTypeRegistry()->fromJson<JBoolExpression>(
                zJson->zValue("condition")));
        return result;
    }

    Framework::JSON::JSONObject* toJsonObject(S* zObject) const override
    {
        Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
        GeneratorRule* zRule = dynamic_cast<GeneratorRule*>(zObject);
        if (zRule->zNoiseConfig())
        {
            result->addValue("noise",
                dynamic_cast<Framework::JSON::JSONValue*>(
                    zRule->zNoiseConfig()->getThis()));
        }
        result->addValue("threshold",
            new Framework::JSON::JSONNumber(zRule->getThreshold()));
        result->addValue("condition",
            Game::INSTANCE->zTypeRegistry()->toJson(
                dynamic_cast<Framework::JSON::JSONValue*>(
                    zRule->zCondition()->getThis())));
        return result;
    }

    JSONObjectValidationBuilder* addToValidator(
        JSONObjectValidationBuilder* builder) const override
    {
        return builder
            ->withRequiredAttribute("noise", JNoise::getValidator(true))
            ->withRequiredAttribute("condition",
                Game::INSTANCE->zTypeRegistry()
                    ->getValidator<JBoolExpression>())
            ->withRequiredNumber("threshold")
            ->whichIsOptional()
            ->whichIsGreaterOrEqual(0.0)
            ->whichIsLessOrEqual(1.0)
            ->finishNumber();
    }

protected:
    virtual S* createValue(Framework::JSON::JSONObject* zJson) const = 0;
};