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);
    }
    for (PlantConfig* plantConfig : plantConfigs)
    {
        plantConfig->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::generatePlants(int x,
    int y,
    int z,
    int dimensionId,
    Chunk* zChunk,
    bool underground,
    bool underwater,
    int seaFluidBlockTypeId)
{
    PlantConfig* chosenConfig = 0;
    double maxValue = 0.0;
    for (PlantConfig* plantConfig : plantConfigs)
    {
        double value = plantConfig->doesGeneratePlant(x,
            y,
            z,
            dimensionId,
            zChunk,
            underground,
            underwater,
            seaFluidBlockTypeId);
        if (value > maxValue)
        {
            maxValue = value;
            chosenConfig = plantConfig;
        }
    }
    if (chosenConfig)
    {
        chosenConfig->generatePlantAt(x, y, z, dimensionId, zChunk);
    }
}

void BiomGenerator::generateEntities(
    int x, int y, int z, int dimensionId, Chunk* zChunk)
{
    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);
            zChunk->addGeneratedEntity(entity);
        }
    }
}

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;
}

void BiomGenerator::addPlantConfig(PlantConfig* config)
{
    plantConfigs.add(config);
}

const Framework::RCArray<PlantConfig>& BiomGenerator::getPlantConfigs() const
{
    return plantConfigs;
}

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));
    }
    for (Framework::JSON::JSONValue* value :
        *zJson->asObject()->zValue("plants")->asArray())
    {
        result->addPlantConfig(
            Game::INSTANCE->zTypeRegistry()->fromJson<PlantConfig>(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);
    Framework::JSON::JSONArray* plants = new Framework::JSON::JSONArray();
    for (PlantConfig* plant : zObject->getPlantConfigs())
    {
        plants->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson<PlantConfig>(plant));
    }
    result->addValue("plants", plants);
    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()
        ->withRequiredArray("plants")
        ->addAcceptedTypeInArray(
            Game::INSTANCE->zTypeRegistry()->getValidator<PlantConfig>())
        ->finishArray();
}