4jcraft/Minecraft.World/WorldGen/Flat/FlatGeneratorInfo.cpp

#include "../../Platform/stdafx.h"
#include "../../Util/StringHelpers.h"
#include "../../Headers/net.minecraft.world.level.levelgen.flat.h"
#include "../../Headers/net.minecraft.world.level.tile.h"
#include "FlatGeneratorInfo.h"

const std::wstring FlatGeneratorInfo::STRUCTURE_VILLAGE = L"village";
const std::wstring FlatGeneratorInfo::STRUCTURE_BIOME_SPECIFIC = L"biome_1";
const std::wstring FlatGeneratorInfo::STRUCTURE_STRONGHOLD = L"stronghold";
const std::wstring FlatGeneratorInfo::STRUCTURE_MINESHAFT = L"mineshaft";
const std::wstring FlatGeneratorInfo::STRUCTURE_BIOME_DECORATION =
    L"decoration";
const std::wstring FlatGeneratorInfo::STRUCTURE_LAKE = L"lake";
const std::wstring FlatGeneratorInfo::STRUCTURE_LAVA_LAKE = L"lava_lake";
const std::wstring FlatGeneratorInfo::STRUCTURE_DUNGEON = L"dungeon";

FlatGeneratorInfo::FlatGeneratorInfo() { biome = 0; }

FlatGeneratorInfo::~FlatGeneratorInfo() {
    for (AUTO_VAR(it, layers.begin()); it != layers.end(); ++it) {
        delete *it;
    }
}

int FlatGeneratorInfo::getBiome() { return biome; }

void FlatGeneratorInfo::setBiome(int biome) { this->biome = biome; }

std::unordered_map<std::wstring,
                   std::unordered_map<std::wstring, std::wstring> >*
FlatGeneratorInfo::getStructures() {
    return &structures;
}

std::vector<FlatLayerInfo*>* FlatGeneratorInfo::getLayers() { return &layers; }

void FlatGeneratorInfo::updateLayers() {
    int y = 0;

    for (AUTO_VAR(it, layers.begin()); it != layers.end(); ++it) {
        FlatLayerInfo* layer = *it;
        layer->setStart(y);
        y += layer->getHeight();
    }
}

std::wstring FlatGeneratorInfo::toString() {
    return L"";
#if 0
	StringBuilder builder = new StringBuilder();

	builder.append(SERIALIZATION_VERSION);
	builder.append(";");

	for (int i = 0; i < layers.size(); i++)
	{
		if (i > 0) builder.append(",");
		builder.append(layers.get(i).toString());
	}

	builder.append(";");
	builder.append(biome);

	if (!structures.isEmpty())
	{
		builder.append(";");
		int structCount = 0;

		for (Map.Entry<String, Map<String, String>> structure : structures.entrySet())
		{
			if (structCount++ > 0) builder.append(",");
			builder.append(structure.getKey().toLowerCase());

			Map<String, String> options = structure.getValue();
			if (!options.isEmpty())
			{
				builder.append("(");
				int optionCount = 0;

				for (Map.Entry<String, String> option : options.entrySet())
				{
					if (optionCount++ > 0) builder.append(" ");
					builder.append(option.getKey());
					builder.append("=");
					builder.append(option.getValue());
				}

				builder.append(")");
			}
		}
	}
	else
	{
		builder.append(";");
	}

	return builder.toString();
#endif
}

FlatLayerInfo* FlatGeneratorInfo::getLayerFromString(const std::wstring& input,
                                                     int yOffset) {
    return NULL;
#if 0
	std::vector<std::wstring> parts = stringSplit(input, L'x');

	int height = 1;
	int id;
	int data = 0;

	if (parts.size() == 2)
	{
		height = _fromString<int>(parts[0]);
		if (yOffset + height >= Level::maxBuildHeight) height = Level::maxBuildHeight - yOffset;
		if (height < 0) height = 0;
	}

	std::wstring identity = parts[parts.size() - 1];
	parts = stringSplit(identity, L':');

	id = _fromString<int>(parts[0]);
	if (parts.size() > 1) data = _from_String<int>(parts[1]);

	if (Tile::tiles[id] == NULL)
	{
		id = 0;
		data = 0;
	}

	if (data < 0 || data > 15) data = 0;

	FlatLayerInfo *result = new FlatLayerInfo(height, id, data);
	result->setStart(yOffset);
	return result;
#endif
}

std::vector<FlatLayerInfo*>* FlatGeneratorInfo::getLayersFromString(
    const std::wstring& input) {
    if (input.empty()) return NULL;

    std::vector<FlatLayerInfo*>* result = new std::vector<FlatLayerInfo*>();
    std::vector<std::wstring> depths = stringSplit(input, L',');

    int yOffset = 0;

    for (AUTO_VAR(it, depths.begin()); it != depths.end(); ++it) {
        FlatLayerInfo* layer = getLayerFromString(*it, yOffset);
        if (layer == NULL) return NULL;
        result->push_back(layer);
        yOffset += layer->getHeight();
    }

    return result;
}

FlatGeneratorInfo* FlatGeneratorInfo::fromValue(const std::wstring& input) {
    return getDefault();

#if 0
	if (input.empty()) return getDefault();
	std::vector<std::wstring> parts = stringSplit(input, L';');

	int version = parts.size() == 1 ? 0 : Mth::getInt(parts[0], 0);
	if (version < 0 || version > SERIALIZATION_VERSION) return getDefault();

	FlatGeneratorInfo *result = new FlatGeneratorInfo();
	int index = parts.size() == 1 ? 0 : 1;
	std::vector<FlatLayerInfo *> *layers = getLayersFromString(parts[index++]);

	if (layers == NULL || layers->isEmpty())
	{
		delete layers;
		return getDefault();
	}

	result->getLayers()->addAll(layers);
	delete layers;
	result->updateLayers();

	int biome = Biome::plains_Id;
	if (version > 0 && parts.size() > index) biome = Mth::getInt(parts[index++], biome);
	result->setBiome(biome);

	if (version > 0 && parts.size() > index)
	{
		std::vector<std::wstring> structures = stringSplit(parts[index++], L',');

		for(AUTO_VAR(it, structures.begin()); it != structures.end(); ++it)
		{
			std::vector<std::wstring> separated = stringSplit(parts[index++], L"\\(");

			std::unordered_map<std::wstring, std::wstring> structureOptions;

			if (separated[0].length() > 0)
			{
				(*result->getStructures())[separated[0]] = structureOptions;

				if (separated.size() > 1 && separated[1].endsWith(L")") && separated[1].length() > 1)
				{
					String[] options = separated[1].substring(0, separated[1].length() - 1).split(" ");

					for (int option = 0; option < options.length; option++)
					{
						String[] split = options[option].split("=", 2);
						if (split.length == 2) structureOptions[split[0]] = split[1];
					}
				}
			}
		}
	}
	else
	{
		(* (result->getStructures()) )[STRUCTURE_VILLAGE] = std::unordered_map<std::wstring, std::wstring>();
	}

	return result;
#endif
}

FlatGeneratorInfo* FlatGeneratorInfo::getDefault() {
    FlatGeneratorInfo* result = new FlatGeneratorInfo();

    result->setBiome(Biome::plains->id);
    result->getLayers()->push_back(new FlatLayerInfo(1, Tile::unbreakable_Id));
    result->getLayers()->push_back(new FlatLayerInfo(2, Tile::dirt_Id));
    result->getLayers()->push_back(new FlatLayerInfo(1, Tile::grass_Id));
    result->updateLayers();
    (*(result->getStructures()))[STRUCTURE_VILLAGE] =
        std::unordered_map<std::wstring, std::wstring>();

    return result;
}