FactoryCraft-Server/FactoryCraft/DimensionGenerator.cpp

#include "DimensionGenerator.h"
#include "Constants.h"
#include "Noise.h"
#include "NoBlock.h"

#include <iostream>


DimensionGenerator::DimensionGenerator(int dimensionId)
	: ReferenceCounter(),
	dimensionId(dimensionId),
	minTemplateAffectedPosition(0, 0, 0),
	maxTemplateAffectedPosition(0, 0, 0)
{
	StaticRegistry<DimensionGenerator>::INSTANCE.registerT(this, dimensionId);
}

DimensionGenerator::~DimensionGenerator()
{}

BiomGenerator* DimensionGenerator::zBiomGenerator(int seed, int x, int y)
{
	double noise = zBiomNoise(seed)->getNoise((double)x, (double)y, 0.0);
	double border = 0;
	BiomGenerator* gen = 0;
	auto genI = biomGenerators.begin();
	auto distI = biomDistribution.begin();
	do
	{
		border += (double)distI++;
		gen = genI++;
	} while (border < noise && (bool)distI && (bool)genI);
	return gen;
}

void DimensionGenerator::registerBiom(BiomGenerator* generator, double possibility)
{
	biomGenerators.add(generator);
	biomDistribution.add(possibility);
	for (auto t : generator->getTemplates())
	{
		minTemplateAffectedPosition.x = MIN(minTemplateAffectedPosition.x, t->getMinAffectedOffset().x);
		minTemplateAffectedPosition.y = MIN(minTemplateAffectedPosition.y, t->getMinAffectedOffset().y);
		minTemplateAffectedPosition.z = MIN(minTemplateAffectedPosition.z, t->getMinAffectedOffset().z);
		maxTemplateAffectedPosition.x = MAX(maxTemplateAffectedPosition.x, t->getMaxAffectedOffset().x);
		maxTemplateAffectedPosition.y = MAX(maxTemplateAffectedPosition.y, t->getMaxAffectedOffset().y);
		maxTemplateAffectedPosition.z = MAX(maxTemplateAffectedPosition.z, t->getMaxAffectedOffset().z);
	}
}

Framework::RCArray<GeneratedStructure>* DimensionGenerator::getGeneratedStructoresForArea(int seed, Framework::Vec3<int> minPos, Framework::Vec3<int> maxPos)
{
	Framework::RCArray<GeneratedStructure>* result = new Framework::RCArray<GeneratedStructure>();

	int minSearchX = minPos.x - maxTemplateAffectedPosition.x;
	int minSearchY = minPos.y - maxTemplateAffectedPosition.y;
	int minSearchZ = MAX(minPos.z - maxTemplateAffectedPosition.z, 0);
	int maxSearchX = maxPos.x - minTemplateAffectedPosition.x;
	int maxSearchY = maxPos.y - minTemplateAffectedPosition.y;
	int maxSearchZ = MIN(maxPos.z - minTemplateAffectedPosition.z, WORLD_HEIGHT - 1);

	Noise* structureNoise = zStructureNoise(seed + dimensionId);
	for (int x = minSearchX; x <= maxSearchX; x++)
	{
		for (int y = minSearchY; y <= maxSearchY; y++)
		{
			BiomGenerator* biom = zBiomGenerator(seed + dimensionId, x, y);
			int height = MIN_AIR_LEVEL + (int)(biom->zHeightMapNoise(seed + dimensionId)->getNoise((double)(x), (double)(y), 0.0) * (MAX_AIR_LEVEL - MIN_AIR_LEVEL));
			for (int z = minSearchZ; z <= maxSearchZ; z++)
			{
				if (z < height)
				{
					double rValue = structureNoise->getNoise((double)x, (double)y, (double)z);
					double probSum = 0;
					for (auto t : biom->getTemplates())
					{
						if (t->isGenerationPossable(Framework::Vec3<int>(x, y, z), height - z))
						{
							if (rValue - probSum <= t->getPropability())
							{
								result->add(t->generateAt(Framework::Vec3<int>(x, y, z), structureNoise));
								break;
							}
						}
						probSum += t->getPropability();
					}
				}
			}
		}
	}

	return result;
}

Chunk* DimensionGenerator::generateChunk(int seed, int centerX, int centerY)
{
	Framework::RCArray<GeneratedStructure>* structures = getGeneratedStructoresForArea(seed, 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));
	std::cout << "generating chunk " << centerX << ", " << centerY << "\n";
	Chunk* chunk = new Chunk(Framework::Punkt(centerX, centerY), dimensionId);
	for (int x = -CHUNK_SIZE / 2; x < CHUNK_SIZE / 2; x++)
	{
		for (int y = -CHUNK_SIZE / 2; y < CHUNK_SIZE / 2; y++)
		{
			BiomGenerator* biom = zBiomGenerator(seed + dimensionId, x + centerX, y + centerY);
			// TODO: use Noise interpolator for height map between different bioms
			int height = MIN_AIR_LEVEL + (int)(biom->zHeightMapNoise(seed + dimensionId)->getNoise((double)(x + centerX), (double)(y + centerY), 0.0) * (MAX_AIR_LEVEL - MIN_AIR_LEVEL));
			int maxSurfaceHeight = (int)(MAX_SURFACE_HEIGHT * (1.f - (float)(height - MIN_AIR_LEVEL) / (float)(MAX_AIR_LEVEL - MIN_AIR_LEVEL)));
			int actualSurfaceHeight = (int)((float)maxSurfaceHeight * (1.f - VARIABLE_SURFACE_PART) + ((float)maxSurfaceHeight * VARIABLE_SURFACE_PART * (float)biom->zHeightMapNoise(seed + dimensionId)->getNoise((double)(x + centerX), (double)(y + centerY), 10.0)));
			for (int z = 0; z < WORLD_HEIGHT; z++)
			{
				Framework::Either<Block*, int> generated = AirBlockBlockType::ID;
				bool structureAffected = 0;
				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));
						structureAffected = 1;
						break;
					}
				}
				if (!structureAffected)
				{
					if (z < height && z >= height - actualSurfaceHeight)
						generated = biom->generateSurfaceBlock(x + centerX, y + centerY, z);
					else if (z < height)
						generated = biom->generateBelowSurfaceBlock(x + centerX, y + centerY, 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);
			}
		}
	}
	structures->release();
	return chunk;
}

Framework::Either<Block*, int> DimensionGenerator::generateBlock(int seed, Framework::Vec3<int> location)
{
	Framework::RCArray<GeneratedStructure>* structures = getGeneratedStructoresForArea(seed, location, location);
	BiomGenerator* biom = zBiomGenerator(seed + dimensionId, location.x, location.y);
	// TODO: use Noise interpolator for height map between different bioms
	int height = MIN_AIR_LEVEL + (int)(biom->zHeightMapNoise(seed + dimensionId)->getNoise((double)(location.x), (double)(location.y), 0.0) * (MAX_AIR_LEVEL - MIN_AIR_LEVEL));
	int maxSurfaceHeight = (int)(MAX_SURFACE_HEIGHT * (1.f - (float)(height - MIN_AIR_LEVEL) / (float)(MAX_AIR_LEVEL - MIN_AIR_LEVEL)));
	int actualSurfaceHeight = (int)((float)maxSurfaceHeight * (1.f - VARIABLE_SURFACE_PART) + ((float)maxSurfaceHeight * VARIABLE_SURFACE_PART * (float)biom->zHeightMapNoise(seed + dimensionId)->getNoise((double)(location.x), (double)(location.y), 10.0)));
	for (auto structure : *structures)
	{
		if (structure->isBlockAffected(location))
		{
			auto generated = structure->generateBlockAt(location);
			structures->release();
			return generated;
		}
	}
	structures->release();
	if (location.z < height && location.z >= height - actualSurfaceHeight)
		return biom->generateSurfaceBlock(location.x, location.y, location.z);
	else if (location.z < height)
		return biom->generateBelowSurfaceBlock(location.x, location.y, location.z);
	return AirBlockBlockType::ID;
}

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