FactoryCraft-Server/FactoryCraft/DimensionGenerator.cpp

#include "DimensionGenerator.h"

#include <iostream>
#include <Logging.h>
#include <Zeit.h>

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

WorldHeightLayer::WorldHeightLayer()
    : ReferenceCounter(),
      noiseConfig(0),
      noise(0),
      value(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()));
}

void WorldHeightLayer::calculateValue(JExpressionMemory* zMemory)
{
    zMemory->setFloatVariable(name, value->getValue(zMemory));
}

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(jExpressionMemory);
    }
}

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

void DimensionGenerator::initialize(int worldSeed)
{
    jExpressionMemory->setFloatVariable("worldSeed", (float)worldSeed);
    jExpressionMemory->setFloatVariable(
        "dimensionSeed", seedExpression->getValue(jExpressionMemory));
    for (WorldHeightLayer* layer : heightLayers)
    {
        layer->initialize(jExpressionMemory);
    }
}

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

const Framework::Text DimensionGenerator::X = "x";
const Framework::Text DimensionGenerator::Y = "y";
const Framework::Text DimensionGenerator::Z = "z";

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

BiomGenerator* BiomedCavedDimensionGenerator::zBiomGenerator()
{
    for (BiomGenerator* generator : biomGenerators)
    {
        if (generator->isApplicable(zMemory())) 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++)
        {
            zMemory()->setFloatVariable(X, (float)x);
            zMemory()->setFloatVariable(Y, (float)y);
            calculateHeightLayers();
            BiomGenerator* gen = zBiomGenerator();
            for (int z = minSearchZ; z <= maxSearchZ; z++)
            {
                zMemory()->setFloatVariable(Z, (float)z);
                gen->generateStructures(x,
                    y,
                    z,
                    getDimensionId(),
                    zMemory(),
                    minPos,
                    maxPos,
                    result);
            }
        }
    }
    return result;
}

Chunk* BiomedCavedDimensionGenerator::generateChunk(int centerX, int centerY)
{
    zMemory()->lock();
    Framework::Logging::debug()
        << "generating chunk " << centerX << ", " << centerY;
    double structureTime = 0;
    double caveTime = 0;
    double blockGenTime = 0;
    Framework::ZeitMesser zm;
    Framework::ZeitMesser zmGlobal;
    zm.messungStart();
    zmGlobal.messungStart();
    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));
    zm.messungEnde();
    structureTime += zm.getSekunden();
    zm.messungStart();
    CaveChunkGenerator* caveGen
        = caveGenerator->getGeneratorForChunk(centerX, centerY);
    zm.messungEnde();
    caveTime += zm.getSekunden();
    Chunk* chunk
        = new Chunk(Framework::Punkt(centerX, centerY), getDimensionId());
    zMemory()->setCurrentChunk(dynamic_cast<Chunk*>(chunk->getThis()));
    for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
    {
        for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
        {
            zMemory()->setFloatVariable(X, (float)x + (float)centerX);
            zMemory()->setFloatVariable(Y, (float)y + (float)centerY);
            // calculate height layers
            calculateHeightLayers();
            // calculate biom
            BiomGenerator* biom = zBiomGenerator();
            // generate blocks
            for (int z = 0; z < WORLD_HEIGHT; z++)
            {
                zMemory()->setFloatVariable(Z, (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;
                    }
                }
                if (!structureAffected)
                {
                    // check if block is a cave block
                    bool inCave
                        = caveGen->isInCave(x + centerX, y + centerY, z);
                    if (!inCave)
                    {
                        // generate biom block
                        zm.messungStart();
                        generated = biom->generateBlock(x + centerX,
                            y + centerY,
                            z,
                            getDimensionId(),
                            zMemory(),
                            chunk);
                        zm.messungEnde();
                        blockGenTime += zm.getSekunden();
                    }
                }
                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);
            }
        }
    }
    caveGen->release();
    structures->release();
    zmGlobal.messungEnde();
    Framework::Logging::trace() << "structureGenerationTime: " << structureTime;
    Framework::Logging::trace() << "caveGenerationTime: " << caveTime;
    Framework::Logging::trace() << "blockGenTime: " << blockGenTime;
    Framework::Logging::debug() << "totalTime: " << zmGlobal.getSekunden();
    zMemory()->unlock();
    return chunk;
}

void BiomedCavedDimensionGenerator::generateEntities(Chunk* zChunk)
{
    zMemory()->lock();
    zMemory()->setCurrentChunk(dynamic_cast<Chunk*>(zChunk->getThis()));

    zMemory()->setFloatVariable(X, (float)zChunk->getCenter().x);
    zMemory()->setFloatVariable(Y, (float)zChunk->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 (zChunk->getBlockTypeAt(Framework::Vec3<int>(
                        x + CHUNK_SIZE / 2, y + CHUNK_SIZE / 2, z))
                    == BlockTypeEnum::AIR)
                {
                    zMemory()->setFloatVariable(
                        X, (float)x + (float)zChunk->getCenter().x);
                    zMemory()->setFloatVariable(
                        Y, (float)y + (float)zChunk->getCenter().y);
                    zMemory()->setFloatVariable(Z, (float)z);
                    biom->generateEntities(x + zChunk->getCenter().x,
                        y + zChunk->getCenter().y,
                        z,
                        getDimensionId(),
                        zMemory());
                }
            }
        }
    }

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

    zMemory()->setFloatVariable(X, (float)location.x);
    zMemory()->setFloatVariable(Y, (float)location.y);

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

    zMemory()->setFloatVariable(Z, (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::Punkt 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(),
        zMemory(),
        zChunk);
    zMemory()->unlock();
    return generated;
}

bool BiomedCavedDimensionGenerator::spawnStructure(
    Framework::Vec3<int> location,
    std::function<bool(GeneratorTemplate* tmpl)> filter)
{
    zMemory()->lock();
    zMemory()->setFloatVariable(X, (float)location.x);
    zMemory()->setFloatVariable(Y, (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.getEintragAnzahl() == 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;
}

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

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