FactoryCraft-Server/FactoryCraft/BiomGenerator.cpp

#include "BiomGenerator.h"

#include "Constants.h"
#include "Dimension.h"
#include "Entity.h"
#include "Game.h"
#include "JNoise.h"

BiomGenerator::BiomGenerator()
    : ReferenceCounter(),
      condition(0)
{}

BiomGenerator::~BiomGenerator()
{
    if (condition) condition->release();
}

void BiomGenerator::initialize(JExpressionMemory* zMemory)
{
    for (GeneratorRule* rule : rules)
    {
        rule->initialize(zMemory);
    }
    for (EntityGenerator* entity : entityGenerators)
    {
        entity->initialize(zMemory);
    }
    for (StructureTemplateCollection* collection : templates)
    {
        collection->initialize(zMemory);
    }
    if (condition)
    {
        condition->compile(zMemory);
    }
}

Framework::Either<Block*, int> BiomGenerator::generateBlock(
    int x, int y, int z, int dimensionId, Chunk* partialGeneratedChunk)
{
    for (GeneratorRule* rule : rules)
    {
        if (rule->checkCondition(x, y, z))
        {
            auto result = rule->generateBlock(x, y, z, dimensionId);
            if ((result.isA() && result.getA())
                || (result.isB() && result.getB()))
            {
                return result;
            }
        }
    }
    return BlockTypeEnum::AIR;
}

bool BiomGenerator::isApplicable()
{
    return !condition || condition->getValue();
}

void BiomGenerator::generateStructures(int x,
    int y,
    int z,
    int dimensionId,
    Framework::Vec3<int>& minPos,
    Framework::Vec3<int>& maxPos,
    Framework::RCArray<GeneratedStructure>* zResult)
{
    for (StructureTemplateCollection* collection : templates)
    {
        collection->generateStructures(
            x, y, z, dimensionId, minPos, maxPos, zResult);
    }
}

void BiomGenerator::generateEntities(int x, int y, int z, int dimensionId)
{
    for (EntityGenerator* entityGen : entityGenerators)
    {
        if (entityGen->isGenerated(x, y, z, dimensionId))
        {
            Entity* entity = entityGen->generate(
                Framework::Vec3<float>((float)x, (float)y, (float)z),
                dimensionId);
            Dimension* dimension = Game::INSTANCE->zDimension(dimensionId);
            if (dimension)
            {
                dimension->addEntity(entity);
            }
            else
            {
                entity->release();
            }
        }
    }
}

const Framework::RCArray<StructureTemplateCollection>&
BiomGenerator::getTemplates() const
{
    return templates;
}

Framework::Vec3<int> BiomGenerator::getMinStructureOffset() const
{
    return minStructureOffset;
}

Framework::Vec3<int> BiomGenerator::getMaxStructureOffset() const
{
    return maxStructureOffset;
}

void BiomGenerator::setName(Framework::Text name)
{
    this->name = name;
}

Framework::Text BiomGenerator::getName() const
{
    return name;
}

void BiomGenerator::setCondition(JBoolExpression* condition)
{
    if (this->condition) this->condition->release();
    this->condition = condition;
}

JBoolExpression* BiomGenerator::getCondition() const
{
    return condition;
}

void BiomGenerator::addTemplate(StructureTemplateCollection* collection)
{
    templates.add(collection);
    Framework::Vec3<int> min = collection->getMinAffected();
    Framework::Vec3<int> max = collection->getMaxAffected();
    if (templates.getEintragAnzahl())
    {
        minStructureOffset = min;
        maxStructureOffset = max;
    }
    else
    {
        if (minStructureOffset.x > min.x) minStructureOffset.x = min.x;
        if (minStructureOffset.y > min.y) minStructureOffset.y = min.y;
        if (minStructureOffset.z > min.z) minStructureOffset.z = min.z;
        if (maxStructureOffset.x < max.x) maxStructureOffset.x = max.x;
        if (maxStructureOffset.y < max.y) maxStructureOffset.y = max.y;
        if (maxStructureOffset.z < max.z) maxStructureOffset.z = max.z;
    }
}

const Framework::RCArray<StructureTemplateCollection>&
BiomGenerator::getTemplates()
{
    return templates;
}

void BiomGenerator::addGeneratorRule(GeneratorRule* rule)
{
    rules.add(rule);
}

const Framework::RCArray<GeneratorRule>&
BiomGenerator::getGeneratorRules() const
{
    return rules;
}

void BiomGenerator::addEntityGenerator(EntityGenerator* generator)
{
    entityGenerators.add(generator);
}

const Framework::RCArray<EntityGenerator>&
BiomGenerator::getEntityGenerators() const
{
    return entityGenerators;
}

BiomGeneratorFactory::BiomGeneratorFactory()
    : ObjectTypeFactory()
{}

BiomGenerator* BiomGeneratorFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    BiomGenerator* result = new BiomGenerator();
    result->setName(zJson->zValue("name")->asString()->getString());
    if (zJson->hasValue("condition"))
    {
        result->setCondition(
            Game::INSTANCE->zTypeRegistry()->fromJson<JBoolExpression>(
                zJson->zValue("condition")));
    }
    bool first = 1;
    for (Framework::JSON::JSONValue* value :
        *zJson->zValue("structurCollections")->asArray())
    {
        StructureTemplateCollection* collection
            = Game::INSTANCE->zTypeRegistry()
                  ->fromJson<StructureTemplateCollection>(value);
        result->addTemplate(collection);
    }
    for (Framework::JSON::JSONValue* value :
        *zJson->asObject()->zValue("blocks")->asArray())
    {
        result->addGeneratorRule(
            Game::INSTANCE->zTypeRegistry()->fromJson<GeneratorRule>(value));
    }
    for (Framework::JSON::JSONValue* value :
        *zJson->asObject()->zValue("entities")->asArray())
    {
        result->addEntityGenerator(
            Game::INSTANCE->zTypeRegistry()->fromJson<EntityGenerator>(value));
    }
    return result;
}

Framework::JSON::JSONObject* BiomGeneratorFactory::toJsonObject(
    BiomGenerator* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "name", new Framework::JSON::JSONString(zObject->getName()));
    if (zObject->getCondition())
    {
        result->addValue("condition",
            Game::INSTANCE->zTypeRegistry()->toJson<JBoolExpression>(
                zObject->getCondition()));
    }
    Framework::JSON::JSONArray* collections = new Framework::JSON::JSONArray();
    for (StructureTemplateCollection* collection : zObject->getTemplates())
    {
        collections->addValue(Game::INSTANCE->zTypeRegistry()
                ->toJson<StructureTemplateCollection>(collection));
    }
    result->addValue("structurCollections", collections);
    Framework::JSON::JSONArray* rules = new Framework::JSON::JSONArray();
    for (GeneratorRule* rule : zObject->getGeneratorRules())
    {
        rules->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson<GeneratorRule>(rule));
    }
    result->addValue("blocks", rules);
    Framework::JSON::JSONArray* entities = new Framework::JSON::JSONArray();
    for (EntityGenerator* entity : zObject->getEntityGenerators())
    {
        entities->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson<EntityGenerator>(entity));
    }
    result->addValue("entities", entities);
    return result;
}

JSONObjectValidationBuilder* BiomGeneratorFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("name")
        ->finishString()
        ->withRequiredAttribute("condition",
            Game::INSTANCE->zTypeRegistry()->getValidator<JBoolExpression>(),
            false,
            true)
        ->withRequiredArray("structurCollections")
        ->addAcceptedTypeInArray(Game::INSTANCE->zTypeRegistry()
                ->getValidator<StructureTemplateCollection>())
        ->finishArray()
        ->withRequiredArray("blocks")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<GeneratorRule>())
        ->finishArray()
        ->withRequiredArray("entities")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<EntityGenerator>())
        ->finishArray();
}