431a9c00a5
On Linux and macOS, using Clang to compile OpenStarbound produces about 400 MB worth of warnings during the build, making the compiler output unreadable and slowing the build down considerably. 99% of the warnings were unqualified uses of std::move and std::forward, which are now all properly qualified. Fixed a few other minor warnings about non-virtual destructors and some uses of std::move preventing copy elision on temporary objects. Most remaining warnings are now unused parameters.
299 lines
12 KiB
C++
299 lines
12 KiB
C++
#include "StarBiomePlacement.hpp"
|
|
#include "StarJsonExtra.hpp"
|
|
#include "StarLogging.hpp"
|
|
#include "StarRoot.hpp"
|
|
#include "StarAssets.hpp"
|
|
|
|
namespace Star {
|
|
|
|
BiomeItem variantToBiomeItem(Json const& store) {
|
|
auto type = store.get(0);
|
|
if (type == "grass") {
|
|
return GrassVariant(store.get(1));
|
|
} else if (type == "bush") {
|
|
return BushVariant(store.get(1));
|
|
} else if (type == "treePair") {
|
|
return TreePair(TreeVariant(store.get(1).get(0)), TreeVariant(store.get(1).get(1)));
|
|
} else if (type == "objectPool") {
|
|
return ObjectPool(store.getArray(1).transformed([](Json const& pair) {
|
|
return make_pair(pair.getFloat(0), make_pair(pair.get(1).getString(0), pair.get(1).get(1)));
|
|
}));
|
|
} else if (type == "treasureBoxSet") {
|
|
return TreasureBoxSet(store.getString(1));
|
|
} else if (type == "microDungeon") {
|
|
return MicroDungeonNames(jsonToStringSet(store.get(1)));
|
|
} else {
|
|
throw BiomeException(strf("Unrecognized biome item type '{}'", type));
|
|
}
|
|
}
|
|
|
|
Json variantFromBiomeItem(BiomeItem const& biomeItem) {
|
|
if (auto grassVariant = biomeItem.ptr<GrassVariant>()) {
|
|
return JsonArray{"grass", grassVariant->toJson()};
|
|
} else if (auto bushVariant = biomeItem.ptr<BushVariant>()) {
|
|
return JsonArray{"bush", bushVariant->toJson()};
|
|
} else if (auto treePair = biomeItem.ptr<TreePair>()) {
|
|
return JsonArray{"treePair", JsonArray{treePair->first.toJson(), treePair->second.toJson()}};
|
|
} else if (auto objectPool = biomeItem.ptr<ObjectPool>()) {
|
|
return JsonArray{"objectPool", transform<JsonArray>(objectPool->items(), [](pair<double, pair<String, Json>> const& p) {
|
|
return JsonArray{p.first, JsonArray{p.second.first, p.second.second}};
|
|
})};
|
|
} else if (auto treasureBoxSet = biomeItem.ptr<TreasureBoxSet>()) {
|
|
return JsonArray{"treasureBoxSet", String(*treasureBoxSet)};
|
|
} else if (auto microDungeonNames = biomeItem.ptr<MicroDungeonNames>()) {
|
|
return JsonArray{"microDungeon", jsonFromStringSet(*microDungeonNames)};
|
|
} else {
|
|
throw BiomeException(strf("Unrecognized biome item type"));
|
|
}
|
|
}
|
|
|
|
EnumMap<BiomePlacementMode> const BiomePlacementModeNames{
|
|
{BiomePlacementMode::Floor, "floor"},
|
|
{BiomePlacementMode::Ceiling, "ceiling"},
|
|
{BiomePlacementMode::Background, "background"},
|
|
{BiomePlacementMode::Ocean, "ocean"}
|
|
};
|
|
|
|
BiomeItemPlacement::BiomeItemPlacement(BiomeItem item, Vec2I position, float priority)
|
|
: item(std::move(item)), position(position), priority(priority) {}
|
|
|
|
bool BiomeItemPlacement::operator<(BiomeItemPlacement const& rhs) const {
|
|
return priority < rhs.priority;
|
|
}
|
|
|
|
Maybe<BiomeItem> BiomeItemDistribution::createItem(Json const& config, RandomSource& rand, float biomeHueShift) {
|
|
auto& root = Root::singleton();
|
|
|
|
auto type = config.getString("type");
|
|
if (type.equalsIgnoreCase("grass")) {
|
|
auto grassList = jsonToStringList(config.get("grasses"));
|
|
return BiomeItem{root.plantDatabase()->buildGrassVariant(rand.randFrom(grassList), biomeHueShift)};
|
|
|
|
} else if (type.equalsIgnoreCase("bush")) {
|
|
auto bushList = config.getArray("bushes", {});
|
|
auto bushSettings = rand.randValueFrom(bushList);
|
|
|
|
auto bushName = bushSettings.getString("name");
|
|
auto bushMod = rand.randValueFrom(root.plantDatabase()->bushMods(bushName));
|
|
float bushBaseHueShift = rand.randf(-1.0f, 1.0f) * bushSettings.getFloat("baseHueShiftMax");
|
|
float bushModHueShift = rand.randf(-1.0f, 1.0f) * bushSettings.getFloat("modHueShiftMax");
|
|
|
|
return BiomeItem{root.plantDatabase()->buildBushVariant(bushName, bushBaseHueShift, bushMod, bushModHueShift)};
|
|
|
|
} else if (type.equalsIgnoreCase("tree")) {
|
|
auto stemList = jsonToStringList(config.get("treeStemList", JsonArray()));
|
|
auto foliageList = jsonToStringList(config.get("treeFoliageList", JsonArray()));
|
|
|
|
// Find matching pairs of stem / foliage (that have the same shape)
|
|
List<pair<String, String>> matchingPairs;
|
|
for (auto stem : stemList) {
|
|
for (auto foliage : foliageList) {
|
|
if (foliage.empty() || root.plantDatabase()->treeStemShape(stem) == root.plantDatabase()->treeFoliageShape(foliage))
|
|
matchingPairs.append({stem, foliage});
|
|
}
|
|
}
|
|
|
|
if (matchingPairs.empty() && !stemList.empty() && !foliageList.empty())
|
|
Logger::warn("Specified stemList and foliageList, but no matching pairs found.");
|
|
|
|
auto chosenPair = rand.randValueFrom(matchingPairs);
|
|
float treeStemHueShift = rand.randf(-1.0f, 1.0f) * config.getFloat("treeStemHueShiftMax", 0);
|
|
float treeFoliageHueShift = rand.randf(-1.0f, 1.0f) * config.getFloat("treeFoliageHueShiftMax", 0);
|
|
float treeAltFoliageHueShift = rand.randf(-1.0f, 1.0f) * config.getFloat("treeFoliageHueShiftMax", 0);
|
|
|
|
if (!chosenPair.first.empty()) {
|
|
TreeVariant primaryTree;
|
|
TreeVariant altTree;
|
|
if (chosenPair.second.empty()) {
|
|
// Foliage-less trees
|
|
primaryTree = root.plantDatabase()->buildTreeVariant(chosenPair.first, treeStemHueShift);
|
|
altTree = root.plantDatabase()->buildTreeVariant(chosenPair.first, treeStemHueShift);
|
|
} else {
|
|
primaryTree = root.plantDatabase()->buildTreeVariant(
|
|
chosenPair.first, treeStemHueShift, chosenPair.second, treeFoliageHueShift);
|
|
altTree = root.plantDatabase()->buildTreeVariant(
|
|
chosenPair.first, treeStemHueShift, chosenPair.second, treeAltFoliageHueShift);
|
|
}
|
|
return BiomeItem{TreePair{primaryTree, altTree}};
|
|
}
|
|
|
|
} else if (type.equalsIgnoreCase("object")) {
|
|
Json objectPoolConfig = rand.randValueFrom(config.getArray("objectSets"));
|
|
ObjectPool objectPool;
|
|
|
|
Json objectParameters = objectPoolConfig.get("parameters", JsonObject());
|
|
for (auto const& pair : objectPoolConfig.getArray("pool")) {
|
|
if (pair.size() != 2)
|
|
throw BiomeException("Wrong size for objects weight / list pair in biome items");
|
|
|
|
objectPool.add(pair.getFloat(0), {pair.getString(1), objectParameters});
|
|
}
|
|
|
|
return BiomeItem{objectPool};
|
|
|
|
} else if (type.equalsIgnoreCase("treasureBox")) {
|
|
return BiomeItem{TreasureBoxSet(rand.randValueFrom(config.getArray("treasureBoxSets")).toString())};
|
|
|
|
} else if (type.equalsIgnoreCase("microdungeon")) {
|
|
return BiomeItem{MicroDungeonNames(jsonToStringSet(config.get("microdungeons", JsonArray())))};
|
|
|
|
} else {
|
|
throw BiomeException(strf("No such item type '{}' in item distribution", type));
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
BiomeItemDistribution::BiomeItemDistribution() {
|
|
m_mode = BiomePlacementMode::Floor;
|
|
m_distribution = DistributionType::Random;
|
|
m_modulus = 1;
|
|
m_modulusOffset = 0;
|
|
m_blockSeed = 0;
|
|
m_blockProbability = 0.0f;
|
|
m_priority = 0.0f;
|
|
}
|
|
|
|
BiomeItemDistribution::BiomeItemDistribution(Json const& config, uint64_t seed, float biomeHueShift) {
|
|
RandomSource rand(seed);
|
|
|
|
m_mode = BiomePlacementModeNames.getLeft(config.getString("mode", "floor"));
|
|
|
|
m_priority = config.getFloat("priority", 0.0f);
|
|
int variants = config.getInt("variants", 1);
|
|
|
|
m_modulus = 1;
|
|
m_modulusOffset = 0;
|
|
m_blockSeed = 0;
|
|
m_blockProbability = 0.0f;
|
|
|
|
// If distribution settings are string type, it should point to another asset
|
|
// variant.
|
|
auto distributionSettings = config.get("distribution", JsonObject());
|
|
if (distributionSettings.type() == Json::Type::String) {
|
|
auto assets = Root::singleton().assets();
|
|
distributionSettings = assets->json(distributionSettings.toString());
|
|
}
|
|
|
|
m_distribution = DistributionTypeNames.getLeft(distributionSettings.getString("type"));
|
|
if (m_distribution == DistributionType::Random) {
|
|
m_blockProbability = distributionSettings.getFloat("blockProbability");
|
|
m_blockSeed = rand.randu64();
|
|
for (int i = 0; i < variants; ++i) {
|
|
if (auto item = createItem(config, rand, biomeHueShift))
|
|
m_randomItems.append(item.take());
|
|
}
|
|
|
|
} else if (m_distribution == DistributionType::Periodic) {
|
|
unsigned octaves = distributionSettings.getInt("octaves", 1);
|
|
float alpha = distributionSettings.getFloat("alpha", 2.0);
|
|
float beta = distributionSettings.getFloat("beta", 2.0);
|
|
|
|
float modulusVariance = distributionSettings.getFloat("modulusVariance", 0.0);
|
|
|
|
// If density period / offset are not set, just offset a lot to get an even
|
|
// distribution with no free spaces.
|
|
float densityPeriod = distributionSettings.getFloat("densityPeriod", 10);
|
|
float densityOffset = distributionSettings.getFloat("densityOffset", 2.0);
|
|
|
|
float typePeriod = distributionSettings.getFloat("typePeriod", 10);
|
|
|
|
m_modulus = distributionSettings.getInt("modulus", 1);
|
|
m_modulusOffset = rand.randInt(-m_modulus, m_modulus);
|
|
m_densityFunction = PerlinF(octaves, 1.0f / densityPeriod, 1.0, densityOffset, alpha, beta, rand.randu64());
|
|
m_modulusDistortion = PerlinF(octaves, 1.0f / m_modulus, modulusVariance, modulusVariance * 2, alpha, beta, rand.randu64());
|
|
|
|
for (int i = 0; i < variants; ++i) {
|
|
if (auto item = createItem(config, rand, biomeHueShift)) {
|
|
PerlinF weight(octaves, 1.0f / typePeriod, 1.0, 0.0, alpha, beta, rand.randu64());
|
|
m_weightedItems.append({item.take(), weight});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BiomeItemDistribution::BiomeItemDistribution(Json const& store) {
|
|
m_mode = BiomePlacementModeNames.getLeft(store.getString("mode"));
|
|
m_distribution = DistributionTypeNames.getLeft(store.getString("distribution"));
|
|
m_priority = store.getFloat("priority");
|
|
m_blockProbability = store.getFloat("blockProbability");
|
|
m_blockSeed = store.getUInt("blockSeed");
|
|
m_randomItems = store.getArray("randomItems").transformed(variantToBiomeItem);
|
|
m_densityFunction = PerlinF(store.get("densityFunction"));
|
|
m_modulusDistortion = PerlinF(store.get("modulusDistortion"));
|
|
m_modulus = store.getInt("modulus");
|
|
m_modulusOffset = store.getInt("modulusOffset");
|
|
m_weightedItems = store.getArray("weightedItems") .transformed([](Json const& v) {
|
|
return make_pair(variantToBiomeItem(v.get(0)), PerlinF(v.get(1)));
|
|
});
|
|
}
|
|
|
|
Json BiomeItemDistribution::toJson() const {
|
|
return JsonObject{
|
|
{"mode", BiomePlacementModeNames.getRight(m_mode)},
|
|
{"distribution", DistributionTypeNames.getRight(m_distribution)},
|
|
{"priority", m_priority},
|
|
{"blockProbability", m_blockProbability},
|
|
{"blockSeed", m_blockSeed},
|
|
{"randomItems", m_randomItems.transformed(variantFromBiomeItem)},
|
|
{"densityFunction", m_densityFunction.toJson()},
|
|
{"modulusDistortion", m_modulusDistortion.toJson()},
|
|
{"modulus", m_modulus},
|
|
{"modulusOffset", m_modulusOffset},
|
|
{"weightedItems", m_weightedItems.transformed([](pair<BiomeItem, PerlinF> const& p) -> Json {
|
|
return JsonArray{variantFromBiomeItem(p.first), p.second.toJson()};
|
|
})},
|
|
};
|
|
}
|
|
|
|
BiomePlacementMode BiomeItemDistribution::mode() const {
|
|
return m_mode;
|
|
}
|
|
|
|
List<BiomeItem> BiomeItemDistribution::allItems() const {
|
|
if (m_distribution == DistributionType::Random) {
|
|
return m_randomItems;
|
|
} else if (m_distribution == DistributionType::Periodic) {
|
|
List<BiomeItem> items;
|
|
for (auto const& pair : m_weightedItems)
|
|
items.append(pair.first);
|
|
return items;
|
|
} else {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
Maybe<BiomeItemPlacement> BiomeItemDistribution::itemToPlace(int x, int y) const {
|
|
if (m_distribution == DistributionType::Random) {
|
|
if (staticRandomFloat(x, y, m_blockSeed) <= m_blockProbability)
|
|
return BiomeItemPlacement{staticRandomValueFrom(m_randomItems, x, y, m_blockSeed), Vec2I(x, y), m_priority};
|
|
|
|
} else if (m_distribution == DistributionType::Periodic) {
|
|
BiomeItem const* biomeItem = nullptr;
|
|
if (m_densityFunction.get(x, y) > 0) {
|
|
if ((int)(x + m_modulusOffset + m_modulusDistortion.get(x, y)) % m_modulus == 0) {
|
|
float maxWeight = lowest<float>();
|
|
for (auto const& weightedItem : m_weightedItems) {
|
|
float weight = weightedItem.second.get(x, y);
|
|
if (weight > maxWeight) {
|
|
maxWeight = weight;
|
|
biomeItem = &weightedItem.first;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (biomeItem)
|
|
return BiomeItemPlacement{*biomeItem, Vec2I(x, y), m_priority};
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
EnumMap<BiomeItemDistribution::DistributionType> const BiomeItemDistribution::DistributionTypeNames{
|
|
{DistributionType::Random, "random"},
|
|
{DistributionType::Periodic, "periodic"}
|
|
};
|
|
|
|
}
|