FactoryCraft-Server/FactoryCraft/DimensionGenerator.cpp

#include "DimensionGenerator.h"

#include "BiomGenerator.h"
#include "Constants.h"
#include "Dimension.h"
#include "Game.h"
#include "Noise.h"
#include "RandNoise.h"
#include "WormCaveGenerator.h"

WorldHeightLayer::WorldHeightLayer()
    : ReferenceCounter(),
      noiseConfig(0),
      noise(0),
      value(0),
      valueP(0)
{}

WorldHeightLayer::~WorldHeightLayer()
{
    if (noiseConfig) noiseConfig->release();
    if (noise) noise->release();
    if (value) value->release();
}

void WorldHeightLayer::initialize(JExpressionMemory* zMemory)
{
    if (noise) noise->release();
    noise = JNoise::parseNoise(noiseConfig, zMemory);
    zMemory->setNoise(name, dynamic_cast<Noise*>(noise->getThis()));
    valueP = zMemory->getFloatVariableP(name);
    value->compile(zMemory);
}

void WorldHeightLayer::calculateValue()
{
    *valueP = value->getValue();
}

void WorldHeightLayer::setNoiseConfig(Framework::JSON::JSONObject* noiseConfig)
{
    if (this->noiseConfig) this->noiseConfig->release();
    this->noiseConfig = noiseConfig;
}

Framework::JSON::JSONObject* WorldHeightLayer::zNoiseConfig() const
{
    return noiseConfig;
}

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

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

void WorldHeightLayer::setValue(JFloatExpression* value)
{
    if (this->value) this->value->release();
    this->value = value;
}

JFloatExpression* WorldHeightLayer::zValue() const
{
    return value;
}

WorldHeightLayerFactory::WorldHeightLayerFactory() {}

WorldHeightLayer* WorldHeightLayerFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    WorldHeightLayer* result = new WorldHeightLayer();
    result->setName(zJson->zValue("name")->asString()->getString());
    result->setNoiseConfig(zJson->getValue("noise")->asObject());
    result->setValue(
        Game::INSTANCE->zTypeRegistry()->fromJson<JFloatExpression>(
            zJson->zValue("value")));
    return result;
}

Framework::JSON::JSONObject* WorldHeightLayerFactory::toJsonObject(
    WorldHeightLayer* zObject) const
{
    Framework::JSON::JSONObject* result = new Framework::JSON::JSONObject();
    result->addValue(
        "name", new Framework::JSON::JSONString(zObject->getName()));
    result->addValue("noise", zObject->zNoiseConfig());
    result->addValue("value",
        Game::INSTANCE->zTypeRegistry()->toJson<JFloatExpression>(
            zObject->zValue()));
    return result;
}

JSONObjectValidationBuilder* WorldHeightLayerFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return builder->withRequiredString("name")
        ->finishString()
        ->withRequiredAttribute("noise", JNoise::getValidator(false))
        ->withRequiredAttribute("value",
            Game::INSTANCE->zTypeRegistry()->getValidator<JFloatExpression>());
}

DimensionGenerator::DimensionGenerator()
    : ReferenceCounter(),
      jExpressionMemory(new JExpressionMemory()),
      seedExpression(0),
      dimensionId(0)
{}

DimensionGenerator::~DimensionGenerator()
{
    jExpressionMemory->release();
    if (seedExpression) seedExpression->release();
}

JExpressionMemory* DimensionGenerator::zMemory() const
{
    return jExpressionMemory;
}

void DimensionGenerator::calculateHeightLayers()
{
    for (WorldHeightLayer* layer : heightLayers)
    {
        layer->calculateValue();
    }
}

Dimension* DimensionGenerator::createDimension() const
{
    return new Dimension(getId());
}

void DimensionGenerator::initialize(int worldSeed)
{
    this->worldSeed = jExpressionMemory->getFloatVariableP("worldSeed");
    *this->worldSeed = (float)worldSeed;
    this->dimensionSeed = jExpressionMemory->getFloatVariableP("dimensionSeed");
    seedExpression->compile(jExpressionMemory);
    *this->dimensionSeed = seedExpression->getValue();
    for (WorldHeightLayer* layer : heightLayers)
    {
        layer->initialize(jExpressionMemory);
    }
    xPos = jExpressionMemory->getFloatVariableP("x");
    yPos = jExpressionMemory->getFloatVariableP("y");
    zPos = jExpressionMemory->getFloatVariableP("z");
}

int DimensionGenerator::getDimensionId() const
{
    return dimensionId;
}

void DimensionGenerator::addHeightLayer(WorldHeightLayer* layer)
{
    heightLayers.add(layer);
}

const Framework::RCArray<WorldHeightLayer>&
DimensionGenerator::getHeightLayers() const
{
    return heightLayers;
}

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

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

void DimensionGenerator::setId(int id)
{
    dimensionId = id;
}

int DimensionGenerator::getId() const
{
    return dimensionId;
}

void DimensionGenerator::setSeed(JFloatExpression* seed)
{
    if (seedExpression) seedExpression->release();
    seedExpression = seed;
}

JFloatExpression* DimensionGenerator::zSeed() const
{
    return seedExpression;
}

BiomedCavedDimensionGenerator::BiomedCavedDimensionGenerator()
    : DimensionGenerator(),
      caveGenerator(0),
      noiseConfig(0),
      biomNoise(0)
{}

BiomedCavedDimensionGenerator::~BiomedCavedDimensionGenerator()
{
    if (noiseConfig) noiseConfig->release();
    if (biomNoise) biomNoise->release();
    if (caveGenerator) caveGenerator->release();
}

void BiomedCavedDimensionGenerator::initialize(int worldSeed)
{
    if (biomNoise) biomNoise->release();
    if (caveGenerator) caveGenerator->release();
    DimensionGenerator::initialize(worldSeed);
    biomNoise = JNoise::parseNoise(noiseConfig, zMemory());
    for (BiomGenerator* gen : biomGenerators)
    {
        gen->initialize(zMemory());
    }
    caveGenerator = new WormCaveGenerator(75, 150, 1, 6, 0.1f, worldSeed - 1);
    terrainHeightP = zMemory()->getFloatVariableP(terrainHeightLayerName);
    seaFluidBlockTypeId = Game::INSTANCE->getBlockTypeId(seaFluidBlockType);
}

BiomGenerator* BiomedCavedDimensionGenerator::zBiomGenerator()
{
    for (BiomGenerator* generator : biomGenerators)
    {
        if (generator->isApplicable()) return generator;
    }
    return 0;
}

Framework::RCArray<GeneratedStructure>*
BiomedCavedDimensionGenerator::getGeneratedStructoresForArea(
    Framework::Vec3<int> minPos, Framework::Vec3<int> maxPos)
{
    int minSearchX = minPos.x - maxStructureOffset.x;
    int minSearchY = minPos.y - maxStructureOffset.y;
    int minSearchZ = MAX(minPos.z - maxStructureOffset.z, 0);
    int maxSearchX = maxPos.x - minStructureOffset.x;
    int maxSearchY = maxPos.y - minStructureOffset.y;
    int maxSearchZ = MIN(maxPos.z - minStructureOffset.z, WORLD_HEIGHT - 1);
    Framework::RCArray<GeneratedStructure>* result
        = new Framework::RCArray<GeneratedStructure>();
    for (int x = minSearchX; x <= maxSearchX; x++)
    {
        for (int y = minSearchY; y <= maxSearchY; y++)
        {
            *xPos = (float)x;
            *yPos = (float)y;
            calculateHeightLayers();
            BiomGenerator* gen = zBiomGenerator();
            for (int z = minSearchZ; z <= maxSearchZ; z++)
            {
                *zPos = (float)z;
                gen->generateStructures(
                    x, y, z, getDimensionId(), minPos, maxPos, result);
            }
        }
    }
    return result;
}

Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
{
    zMemory()->lock();
#ifdef CHUNK_GENERATION_DEBUG_LOG
    Framework::Logging::debug()
        << "generating chunk " << centerX << ", " << centerY;
    double structureTime = 0;
    double caveTime = 0;
    double blockGenTime = 0;
    Framework::Timer zm;
    Framework::Timer zmGlobal;
    Framework::Timer entityGenTime;
    zm.measureStart();
    zmGlobal.measureStart();
#endif
    Framework::RCArray<GeneratedStructure>* structures
        = getGeneratedStructoresForArea(
            Framework::Vec3<int>(
                centerX - CHUNK_SIZE / 2, centerY - CHUNK_SIZE / 2, 0),
            Framework::Vec3<int>(centerX + CHUNK_SIZE / 2,
                centerY + CHUNK_SIZE / 2,
                WORLD_HEIGHT - 1));
#ifdef CHUNK_GENERATION_DEBUG_LOG
    zm.measureEnd();
    structureTime += zm.getSekunden();
    zm.measureStart();
#endif
    CaveChunkGenerator* caveGen
        = caveGenerator->getGeneratorForChunk(centerX, centerY);
#ifdef CHUNK_GENERATION_DEBUG_LOG
    zm.measureEnd();
    caveTime += zm.getSekunden();
#endif
    Chunk* chunk
        = new Chunk(Framework::Point(centerX, centerY), getDimensionId());
    zMemory()->setCurrentChunk(dynamic_cast<Chunk*>(chunk->getThis()));
    int maxZ = 0;
    for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
    {
        for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
        {
            *xPos = (float)x + (float)centerX;
            *yPos = (float)y + (float)centerY;
            // calculate height layers
            calculateHeightLayers();
            // calculate biom
            BiomGenerator* biom = zBiomGenerator();
            int terrainHeight = (int)round(*terrainHeightP);
            // generate blocks
            for (int z = 0; z < WORLD_HEIGHT; z++)
            {
                *zPos = (float)z;
                Framework::Either<Block*, int> generated = BlockTypeEnum::AIR;
                bool structureAffected = 0;
                // check if the block is inside of a structure
                for (auto structure : *structures)
                {
                    if (structure->isBlockAffected(
                            Framework::Vec3<int>(x + centerX, y + centerY, z)))
                    {
                        generated = structure->generateBlockAt(
                            Framework::Vec3<int>(x + centerX, y + centerY, z),
                            getDimensionId());
                        structureAffected = 1;
                        break;
                    }
                }
                bool inCave = false;
                if (!structureAffected)
                {
                    // check if block is a cave block
                    inCave = caveGen->isInCave(x + centerX, y + centerY, z);
                    if (!inCave && z == terrainHeight - 1)
                    {
                        // generate biom block
#ifdef CHUNK_GENERATION_DEBUG_LOG
                        zm.measureStart();
#endif
                        generated = biom->generateBlock(x + centerX,
                            y + centerY,
                            z,
                            getDimensionId(),
                            chunk);
#ifdef CHUNK_GENERATION_DEBUG_LOG
                        zm.measureEnd();
                        blockGenTime += zm.getSekunden();
#endif
                    }
                }
                if (inCave || structureAffected || z >= terrainHeight - 1)
                {
                    if (!inCave && !structureAffected && z > terrainHeight - 1
                        && z < globalSeaLevel)
                    {
                        generated = seaFluidBlockTypeId;
                    }
                    if (generated.isA()
                        || generated.getB() != BlockTypeEnum::AIR)
                    {
                        if (maxZ < z)
                        {
                            maxZ = z;
                        }
                    }
                    if (generated.isA())
                        chunk->putBlockAt(
                            Framework::Vec3<int>(
                                x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z),
                            generated);
                    else
                        chunk->putBlockTypeAt(
                            Framework::Vec3<int>(
                                x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z),
                            generated);
                }
            }
        }
    }
    // generate cave borders
    bool generatedMore = true;
    while (generatedMore)
    {
        generatedMore = false;
        for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
        {
            for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
            {
                *xPos = (float)x + (float)centerX;
                *yPos = (float)y + (float)centerY;
                // calculate height layers
                calculateHeightLayers();
                // calculate biom
                BiomGenerator* biom = zBiomGenerator();
                // generate blocks
                for (int z = (int)round(*terrainHeightP) - 1; z >= 0; z--)
                {
                    *zPos = (float)z;
                    int type = chunk->getBlockTypeAt(Framework::Vec3<int>(
                        x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z));
                    if (!type)
                    {
                        bool needed = false;
                        for (int i = 0; i < 6; i++)
                        {
                            Framework::Vec3<int> pos
                                = getDirection(getDirectionFromIndex(i))
                                + Framework::Vec3<int>(
                                    x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z);
                            const Block* neighborBlock = 0;
                            if (pos.x >= 0 && pos.x < CHUNK_SIZE && pos.y >= 0
                                && pos.y < CHUNK_SIZE && pos.z >= 0
                                && pos.z < WORLD_HEIGHT)
                            {
                                neighborBlock = chunk->zBlockConst(pos);
                            }
                            else if (pos.z >= 0 && pos.z < WORLD_HEIGHT)
                            {
                                neighborBlock = Game::INSTANCE->zConstBlock(
                                    Framework::Vec3<int>(pos.x + centerX,
                                        pos.y + centerY,
                                        pos.z),
                                    getDimensionId());
                            }
                            if (neighborBlock && neighborBlock->isTransparent())
                            {
                                needed = true;
                                break;
                            }
                        }
                        if (needed)
                        {
                            auto generated = biom->generateBlock(x + centerX,
                                y + centerY,
                                z,
                                getDimensionId(),
                                chunk);
                            if (generated.isA()
                                || generated.getB() != BlockTypeEnum::AIR)
                            {
                                if (maxZ < z)
                                {
                                    maxZ = z;
                                }
                            }
                            if (generated.isA())
                                chunk->putBlockAt(
                                    Framework::Vec3<int>(x + CHUNK_SIZE / 2,
                                        y + CHUNK_SIZE / 2,
                                        z),
                                    generated);
                            else
                                chunk->putBlockTypeAt(
                                    Framework::Vec3<int>(x + CHUNK_SIZE / 2,
                                        y + CHUNK_SIZE / 2,
                                        z),
                                    generated);
                            generatedMore = true;
                        }
                    }
                }
            }
        }
    }
    // generate plants
    for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
    {
        for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
        {
            *xPos = (float)x + (float)centerX;
            *yPos = (float)y + (float)centerY;
            // calculate height layers
            calculateHeightLayers();
            // calculate biom
            BiomGenerator* biom = zBiomGenerator();
            // generate blocks
            for (int z = maxZ + 1; z > 0; z--)
            {
                auto current = chunk->getBlockTypeAt(Framework::Vec3<int>(
                    x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z));
                if ((current == BlockTypeEnum::AIR
                        || current == seaFluidBlockTypeId))
                {
                    *zPos = (float)z;
                    bool underwater = current == seaFluidBlockTypeId;
                    bool underground = (float)z < *terrainHeightP;
                    bool surface = z == (int)round(*terrainHeightP);
                    biom->generatePlants(x + centerX,
                        y + centerY,
                        z,
                        getDimensionId(),
                        chunk,
                        underground,
                        underwater,
                        surface,
                        seaFluidBlockTypeId);
                }
            }
        }
    }
    caveGen->release();
    structures->release();
#ifdef CHUNK_GENERATION_DEBUG_LOG
    entityGenTime.measureStart();
#endif
    *xPos = (float)chunk->getCenter().x;
    *yPos = (float)chunk->getCenter().y;
    calculateHeightLayers();
    BiomGenerator* biom = zBiomGenerator();
    for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
    {
        for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
        {
            for (int z = 0; z < WORLD_HEIGHT; z++)
            {
                if (chunk->getBlockTypeAt(Framework::Vec3<int>(
                        x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z))
                    == BlockTypeEnum::AIR)
                {
                    *xPos = (float)x + (float)chunk->getCenter().x;
                    *yPos = (float)y + (float)chunk->getCenter().y;
                    *zPos = (float)z;
                    biom->generateEntities(x + chunk->getCenter().x,
                        y + chunk->getCenter().y,
                        z,
                        getDimensionId(),
                        chunk);
                }
            }
        }
    }
#ifdef CHUNK_GENERATION_DEBUG_LOG
    entityGenTime.measureEnd();
    zmGlobal.measureEnd();
    Framework::Logging::trace() << "structureGenerationTime: " << structureTime;
    Framework::Logging::trace() << "caveGenerationTime: " << caveTime;
    Framework::Logging::trace() << "blockGenTime: " << blockGenTime;
    Framework::Logging::debug() << "totalTime: " << zmGlobal.getSekunden();
#endif
    zMemory()->unlock();
    return chunk;
}

void BiomedCavedDimensionGenerator::postprocessChunk(Chunk* zChunk)
{
    zMemory()->lock();
    int borderOffset = 1;
    bool generatedMore = true;
    while (generatedMore && borderOffset <= CHUNK_SIZE / 2)
    {
        int centerX = zChunk->getCenter().x;
        int centerY = zChunk->getCenter().y;
        generatedMore = false;
        for (int d = 0; d < 4; d++)
        {
            Direction dir = getDirectionFromIndex(d);
            Chunk* neighbor = zChunk->zNeighbor(dir);
            if (!neighbor) continue;
            int xOffset = 0;
            int yOffset = 0;
            int xj = 0;
            int yj = 0;
            switch (dir)
            {
            case WEST:
                yj = 1;
                xOffset = 1;
                break;
            case NORTH:
                xj = 1;
                yOffset = 1;
                break;
            case EAST:
                yj = 1;
                xOffset = -1;
                break;
            case SOUTH:
                xj = 1;
                yOffset = -1;
                break;
            default:
                break;
            }
            for (int o = 0; o < borderOffset; o++)
            {
                for (int j = 0; j < CHUNK_SIZE; j++)
                {
                    int x = xOffset * o + xj * j;
                    if (xOffset < 0)
                    {
                        x += CHUNK_SIZE - 1;
                    }
                    int y = yOffset * o + yj * j;
                    if (yOffset < 0)
                    {
                        y += CHUNK_SIZE - 1;
                    }
                    *xPos = (float)x + (float)centerX - CHUNK_SIZE / 2;
                    *yPos = (float)y + (float)centerY - CHUNK_SIZE / 2;
                    // calculate height layers
                    calculateHeightLayers();
                    // calculate biom
                    BiomGenerator* biom = zBiomGenerator();
                    // generate blocks
                    for (int z = (int)round(*terrainHeightP) - 1; z >= 0; z--)
                    {
                        *zPos = (float)z;
                        int type = zChunk->getBlockTypeAt(
                            Framework::Vec3<int>(x, y, z));
                        if (!type)
                        {
                            bool needed = false;
                            for (int i = 0; i < 6; i++)
                            {
                                Framework::Vec3<int> pos
                                    = getDirection(getDirectionFromIndex(i))
                                    + Framework::Vec3<int>(x, y, z);
                                const Block* neighborBlock = 0;
                                if (pos.x >= 0 && pos.x < CHUNK_SIZE
                                    && pos.y >= 0 && pos.y < CHUNK_SIZE
                                    && pos.z >= 0 && pos.z < WORLD_HEIGHT)
                                {
                                    neighborBlock = zChunk->zBlockConst(pos);
                                }
                                else if (pos.z >= 0 && pos.z < WORLD_HEIGHT
                                         && i == d)
                                {
                                    neighborBlock = neighbor->zBlockConst(
                                        {pos.x + centerX
                                                - neighbor->getCenter().x,
                                            pos.y + centerY
                                                - neighbor->getCenter().y,
                                            pos.z});
                                }
                                if (neighborBlock
                                    && neighborBlock->isTransparent())
                                {
                                    needed = true;
                                    break;
                                }
                            }
                            if (needed)
                            {
                                auto generated = biom->generateBlock(
                                    x + centerX - CHUNK_SIZE / 2,
                                    y + centerY - CHUNK_SIZE / 2,
                                    z,
                                    getDimensionId(),
                                    zChunk);
                                if (generated.isA())
                                    zChunk->putBlockAt(
                                        Framework::Vec3<int>(x, y, z),
                                        generated);
                                else
                                    zChunk->putBlockTypeAt(
                                        Framework::Vec3<int>(x, y, z),
                                        generated);
                                generatedMore = true;
                            }
                        }
                    }
                }
            }
        }
        borderOffset++;
    }
    zMemory()->unlock();
}

Framework::Either<Block*, int> BiomedCavedDimensionGenerator::generateBlock(
    Framework::Vec3<int> location)
{
    Chunk* zChunk
        = Game::INSTANCE->zDimension(getDimensionId())
              ->zChunk(Game::INSTANCE->getChunkCenter(location.x, location.y));
    if (!zChunk)
    {
        return BlockTypeEnum::NO_BLOCK;
    }
    zMemory()->lock();
    zMemory()->setCurrentChunk(dynamic_cast<Chunk*>(zChunk->getThis()));

    Framework::RCArray<GeneratedStructure>* structures
        = getGeneratedStructoresForArea(location, location);

    *xPos = (float)location.x;
    *yPos = (float)location.y;

    calculateHeightLayers();
    BiomGenerator* biom = zBiomGenerator();

    *zPos = (float)location.z;

    for (auto structure : *structures)
    {
        if (structure->isBlockAffected(location))
        {
            auto generated
                = structure->generateBlockAt(location, getDimensionId());
            structures->release();
            zMemory()->unlock();
            return generated;
        }
    }
    structures->release();

    Framework::Point chunkCenter = Game::getChunkCenter(location.x, location.y);
    CaveChunkGenerator* caveGen
        = caveGenerator->getGeneratorForChunk(chunkCenter.x, chunkCenter.y);
    if (caveGen->isInCave(location.x, location.y, location.z))
    {
        caveGen->release();
        zMemory()->unlock();
        return BlockTypeEnum::AIR;
    }
    caveGen->release();

    auto generated = biom->generateBlock(
        location.x, location.y, location.z, getDimensionId(), zChunk);
    zMemory()->unlock();
    return generated;
}

bool BiomedCavedDimensionGenerator::spawnStructure(
    Framework::Vec3<int> location,
    std::function<bool(GeneratorTemplate* tmpl)> filter)
{
    zMemory()->lock();
    *xPos = (float)location.x;
    *yPos = (float)location.y;

    BiomGenerator* biom = zBiomGenerator();
    zMemory()->unlock();
    for (StructureTemplateCollection* tc : biom->getTemplates())
    {
        for (GeneratorTemplate* t : tc->getStructures())
        {
            if (filter(t))
            {
                RandNoise noise((int)time(0));
                GeneratedStructure* genStr
                    = t->generateAt(location, &noise, getDimensionId());
                if (genStr)
                {
                    int minSearchX = location.x + t->getMinAffectedOffset().x;
                    int minSearchY = location.y + t->getMinAffectedOffset().y;
                    int minSearchZ
                        = MAX(location.z + t->getMinAffectedOffset().z, 0);
                    int maxSearchX = location.x + t->getMaxAffectedOffset().x;
                    int maxSearchY = location.y + t->getMaxAffectedOffset().y;
                    int maxSearchZ
                        = MIN(location.z + t->getMaxAffectedOffset().z,
                            WORLD_HEIGHT - 1);

                    for (int x = minSearchX; x <= maxSearchX; x++)
                    {
                        for (int y = minSearchY; y <= maxSearchY; y++)
                        {
                            for (int z = minSearchZ; z <= maxSearchZ; z++)
                            {
                                if (genStr->isBlockAffected(
                                        Framework::Vec3<int>(x, y, z)))
                                {
                                    auto gen = genStr->generateBlockAt(
                                        Framework::Vec3<int>(x, y, z),
                                        getDimensionId());
                                    Game::INSTANCE->zDimension(getDimensionId())
                                        ->placeBlock(
                                            Framework::Vec3<int>(x, y, z), gen);
                                }
                            }
                        }
                    }
                    genStr->release();
                    zMemory()->unlock();
                    return 1;
                }
            }
        }
    }
    return 0;
}

void BiomedCavedDimensionGenerator::addBiomGenerator(
    BiomGenerator* biomGenerator)
{
    biomGenerators.add(biomGenerator);
    if (biomGenerators.getEntryCount() == 1)
    {
        minStructureOffset = biomGenerator->getMinStructureOffset();
        maxStructureOffset = biomGenerator->getMaxStructureOffset();
    }
    else
    {
        Framework::Vec3<int> min = biomGenerator->getMinStructureOffset();
        Framework::Vec3<int> max = biomGenerator->getMaxStructureOffset();
        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<BiomGenerator>&
BiomedCavedDimensionGenerator::getBiomGenerators() const
{
    return biomGenerators;
}

void BiomedCavedDimensionGenerator::setBiomNoiseConfig(
    Framework::JSON::JSONObject* biomNoiseConfig)
{
    if (noiseConfig) noiseConfig->release();
    noiseConfig = biomNoiseConfig;
}

Framework::JSON::JSONObject*
BiomedCavedDimensionGenerator::zBiomNoiseConfig() const
{
    return noiseConfig;
}

void BiomedCavedDimensionGenerator::setGlobalSeaLevel(int seaLevel)
{
    globalSeaLevel = seaLevel;
}

int BiomedCavedDimensionGenerator::getGlobalSeaLevel() const
{
    return globalSeaLevel;
}

void BiomedCavedDimensionGenerator::setTerrainHeightLayerName(
    Framework::Text name)
{
    terrainHeightLayerName = name;
}

Framework::Text BiomedCavedDimensionGenerator::getTerrainHeightLayerName() const
{
    return terrainHeightLayerName;
}

void BiomedCavedDimensionGenerator::setSeaFluidBlockType(Framework::Text type)
{
    seaFluidBlockType = type;
}

Framework::Text BiomedCavedDimensionGenerator::getSeaFluidBlockType() const
{
    return seaFluidBlockType;
}

BiomedCavedDimensionGeneratorFactory::BiomedCavedDimensionGeneratorFactory() {}

BiomedCavedDimensionGenerator*
BiomedCavedDimensionGeneratorFactory::createValue(
    Framework::JSON::JSONObject* zJson) const
{
    return new BiomedCavedDimensionGenerator();
}

BiomedCavedDimensionGenerator* BiomedCavedDimensionGeneratorFactory::fromJson(
    Framework::JSON::JSONObject* zJson) const
{
    BiomedCavedDimensionGenerator* result
        = DimensionGeneratorFactory::fromJson(zJson);
    result->setBiomNoiseConfig(zJson->getValue("biomNoise")->asObject());
    for (Framework::JSON::JSONValue* value : *zJson->zValue("bioms")->asArray())
    {
        result->addBiomGenerator(
            Game::INSTANCE->zTypeRegistry()->fromJson<BiomGenerator>(value));
    }
    result->setGlobalSeaLevel(
        (int)zJson->zValue("globalSeaLevel")->asNumber()->getNumber());
    result->setTerrainHeightLayerName(
        zJson->zValue("terrainHeightLeyerName")->asString()->getString());
    result->setSeaFluidBlockType(
        zJson->zValue("seaFluidBlockType")->asString()->getString());
    return result;
}

Framework::JSON::JSONObject* BiomedCavedDimensionGeneratorFactory::toJsonObject(
    BiomedCavedDimensionGenerator* zObject) const
{
    Framework::JSON::JSONObject* result
        = DimensionGeneratorFactory::toJsonObject(zObject);
    Framework::JSON::JSONArray* bioms = new Framework::JSON::JSONArray();
    for (BiomGenerator* biom : zObject->getBiomGenerators())
    {
        bioms->addValue(
            Game::INSTANCE->zTypeRegistry()->toJson<BiomGenerator>(biom));
    }
    result->addValue("bioms", bioms);
    result->addValue("biomNoise",
        dynamic_cast<Framework::JSON::JSONValue*>(
            zObject->zBiomNoiseConfig()->getThis()));
    result->addValue("globalSeaLevel",
        new Framework::JSON::JSONNumber(zObject->getGlobalSeaLevel()));
    result->addValue("terrainHeightLeyerName",
        new Framework::JSON::JSONString(zObject->getTerrainHeightLayerName()));
    result->addValue("seaFluidBlockType",
        new Framework::JSON::JSONString(zObject->getSeaFluidBlockType()));
    return result;
}

JSONObjectValidationBuilder*
BiomedCavedDimensionGeneratorFactory::addToValidator(
    JSONObjectValidationBuilder* builder) const
{
    return DimensionGeneratorFactory::addToValidator(
        builder->withRequiredArray("bioms")
            ->addAcceptedTypeInArray(
                Game::INSTANCE->zTypeRegistry()->getValidator<BiomGenerator>())
            ->finishArray()
            ->withRequiredAttribute("biomNoise", JNoise::getValidator(false))
            ->withRequiredNumber("globalSeaLevel")
            ->finishNumber()
            ->withRequiredString("terrainHeightLeyerName")
            ->finishString()
            ->withRequiredAttribute("seaFluidBlockType",
                Game::INSTANCE->zTypeRegistry()->getValidator<Framework::Text>(
                    BlockTypeNameFactory::TYPE_ID)));
}

const char* BiomedCavedDimensionGeneratorFactory::getTypeToken() const
{
    return "cavedBioms";
}