503 lines
20 KiB
C++
503 lines
20 KiB
C++
|
#include "StarMonsterDatabase.hpp"
|
||
|
|
#include "StarMonster.hpp"
|
||
|
|
#include "StarAssets.hpp"
|
||
|
|
#include "StarRoot.hpp"
|
||
|
|
#include "StarJsonExtra.hpp"
|
||
|
|
#include "StarRandom.hpp"
|
||
|
|
#include "StarLexicalCast.hpp"
|
||
|
|
|
||
|
|
namespace Star {
|
||
|
|
|
||
|
|
MonsterDatabase::MonsterDatabase() {
|
||
|
|
auto assets = Root::singleton().assets();
|
||
|
|
|
||
|
|
auto monsterTypes = assets->scanExtension("monstertype");
|
||
|
|
auto monsterParts = assets->scanExtension("monsterpart");
|
||
|
|
auto monsterSkills = assets->scanExtension("monsterskill");
|
||
|
|
auto monsterColors = assets->scanExtension("monstercolors");
|
||
|
|
|
||
|
|
assets->queueJsons(monsterTypes);
|
||
|
|
assets->queueJsons(monsterParts);
|
||
|
|
assets->queueJsons(monsterSkills);
|
||
|
|
assets->queueJsons(monsterColors);
|
||
|
|
|
||
|
|
for (auto const& file : monsterTypes) {
|
||
|
|
try {
|
||
|
|
auto config = assets->json(file);
|
||
|
|
String typeName = config.getString("type");
|
||
|
|
|
||
|
|
if (m_monsterTypes.contains(typeName))
|
||
|
|
throw MonsterException(strf("Repeat monster type name '%s'", typeName));
|
||
|
|
|
||
|
|
MonsterType& monsterType = m_monsterTypes[typeName];
|
||
|
|
|
||
|
|
monsterType.typeName = typeName;
|
||
|
|
monsterType.shortDescription = config.optString("shortdescription");
|
||
|
|
monsterType.description = config.optString("description");
|
||
|
|
|
||
|
|
monsterType.categories = jsonToStringList(config.get("categories"));
|
||
|
|
monsterType.partTypes = jsonToStringList(config.get("parts"));
|
||
|
|
|
||
|
|
monsterType.animationConfigPath = AssetPath::relativeTo(file, config.getString("animation"));
|
||
|
|
monsterType.colors = config.getString("colors", "default");
|
||
|
|
|
||
|
|
monsterType.reversed = config.getBool("reversed", false);
|
||
|
|
|
||
|
|
if (config.contains("dropPools"))
|
||
|
|
monsterType.dropPools = config.getArray("dropPools");
|
||
|
|
|
||
|
|
monsterType.baseParameters = config.get("baseParameters", {});
|
||
|
|
|
||
|
|
// for updated monsters, use the partParameterDescription from the
|
||
|
|
// .partparams file
|
||
|
|
if (config.contains("partParameters")) {
|
||
|
|
Json partParameterSource = assets->json(AssetPath::relativeTo(file, config.getString("partParameters")));
|
||
|
|
monsterType.partParameterDescription = partParameterSource.getObject("partParameterDescription");
|
||
|
|
monsterType.partParameterOverrides = partParameterSource.getObject("partParameters");
|
||
|
|
} else {
|
||
|
|
// outdated monsters still have partParameterDescription defined
|
||
|
|
// directly in the
|
||
|
|
// .monstertype file
|
||
|
|
monsterType.partParameterDescription = config.getObject("partParameterDescription", {});
|
||
|
|
}
|
||
|
|
|
||
|
|
} catch (StarException const& e) {
|
||
|
|
throw MonsterException(strf("Error loading monster type '%s'", file), e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (auto file : monsterParts) {
|
||
|
|
try {
|
||
|
|
auto config = assets->json(file);
|
||
|
|
if (config.isNull())
|
||
|
|
continue;
|
||
|
|
|
||
|
|
MonsterPart part;
|
||
|
|
part.name = config.getString("name");
|
||
|
|
part.category = config.getString("category");
|
||
|
|
part.type = config.getString("type");
|
||
|
|
part.path = AssetPath::directory(file);
|
||
|
|
part.frames = config.getObject("frames");
|
||
|
|
part.partParameters = config.get("parameters", JsonObject());
|
||
|
|
|
||
|
|
auto& partMap = m_partDirectory[part.category][part.type];
|
||
|
|
|
||
|
|
if (partMap.contains(part.name))
|
||
|
|
throw MonsterException(strf("Repeat monster part name '%s' for category '%s'", part.name, part.category));
|
||
|
|
else
|
||
|
|
partMap[part.name] = part;
|
||
|
|
} catch (StarException const& e) {
|
||
|
|
throw MonsterException(strf("Error loading monster part '%s'", file), e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (auto file : monsterSkills) {
|
||
|
|
try {
|
||
|
|
auto config = assets->json(file);
|
||
|
|
if (config.isNull())
|
||
|
|
continue;
|
||
|
|
|
||
|
|
MonsterSkill skill;
|
||
|
|
skill.name = config.getString("name");
|
||
|
|
skill.label = config.getString("label");
|
||
|
|
skill.image = config.getString("image");
|
||
|
|
|
||
|
|
skill.config = config.get("config", JsonObject());
|
||
|
|
skill.parameters = config.get("parameters", JsonObject());
|
||
|
|
skill.animationParameters = config.get("animationParameters", JsonObject());
|
||
|
|
|
||
|
|
if (m_skills.contains(skill.name))
|
||
|
|
throw MonsterException(strf("Repeat monster skill name '%s'", skill.name));
|
||
|
|
else
|
||
|
|
m_skills[skill.name] = skill;
|
||
|
|
} catch (StarException const& e) {
|
||
|
|
throw MonsterException(strf("Error loading monster skill '%s'", file), e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
for (auto file : monsterColors) {
|
||
|
|
try {
|
||
|
|
auto config = assets->json(file);
|
||
|
|
if (config.isNull())
|
||
|
|
continue;
|
||
|
|
|
||
|
|
auto paletteName = config.getString("name");
|
||
|
|
if (m_colorSwaps.contains(paletteName))
|
||
|
|
throw MonsterException(strf("Duplicate monster colors name '%s'", paletteName));
|
||
|
|
|
||
|
|
ColorReplaceMap colorSwaps;
|
||
|
|
for (auto const& swapSet : config.getArray("swaps")) {
|
||
|
|
ColorReplaceMap colorSwaps;
|
||
|
|
for (auto const& swap : swapSet.iterateObject()) {
|
||
|
|
colorSwaps[Color::fromHex(swap.first).toRgba()] = Color::fromHex(swap.second.toString()).toRgba();
|
||
|
|
}
|
||
|
|
m_colorSwaps[paletteName].append(colorSwaps);
|
||
|
|
}
|
||
|
|
} catch (StarException const& e) {
|
||
|
|
throw MonsterException(strf("Error loading monster colors '%s'", file), e);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void MonsterDatabase::cleanup() {
|
||
|
|
MutexLocker locker(m_cacheMutex);
|
||
|
|
m_monsterCache.cleanup();
|
||
|
|
}
|
||
|
|
|
||
|
|
StringList MonsterDatabase::monsterTypes() const {
|
||
|
|
return m_monsterTypes.keys();
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterVariant MonsterDatabase::randomMonster(String const& typeName, Json const& uniqueParameters) const {
|
||
|
|
size_t seed;
|
||
|
|
if (auto seedConfig = uniqueParameters.opt("seed")) {
|
||
|
|
if (seedConfig->type() == Json::Type::String) {
|
||
|
|
seed = lexicalCast<uint64_t>(seedConfig->toString());
|
||
|
|
} else {
|
||
|
|
seed = seedConfig->toUInt();
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
seed = Random::randu64();
|
||
|
|
}
|
||
|
|
|
||
|
|
return monsterVariant(typeName, seed, uniqueParameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterVariant MonsterDatabase::monsterVariant(String const& typeName, uint64_t seed, Json const& uniqueParameters) const {
|
||
|
|
MutexLocker locker(m_cacheMutex);
|
||
|
|
return m_monsterCache.get(make_tuple(typeName, seed, uniqueParameters), [this](tuple<String, uint64_t, Json> const& key) {
|
||
|
|
return produceMonster(get<0>(key), get<1>(key), get<2>(key));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
ByteArray MonsterDatabase::writeMonsterVariant(MonsterVariant const& variant) const {
|
||
|
|
DataStreamBuffer ds;
|
||
|
|
|
||
|
|
ds.write(variant.type);
|
||
|
|
ds.write(variant.seed);
|
||
|
|
ds.write(variant.uniqueParameters);
|
||
|
|
|
||
|
|
return ds.data();
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterVariant MonsterDatabase::readMonsterVariant(ByteArray const& data) const {
|
||
|
|
DataStreamBuffer ds(data);
|
||
|
|
|
||
|
|
String type = ds.read<String>();
|
||
|
|
uint64_t seed = ds.read<uint64_t>();
|
||
|
|
Json uniqueParameters = ds.read<Json>();
|
||
|
|
|
||
|
|
return monsterVariant(type, seed, uniqueParameters);
|
||
|
|
}
|
||
|
|
|
||
|
|
Json MonsterDatabase::writeMonsterVariantToJson(MonsterVariant const& mVar) const {
|
||
|
|
return JsonObject{
|
||
|
|
{"type", mVar.type},
|
||
|
|
{"seed", mVar.seed},
|
||
|
|
{"uniqueParameters", mVar.uniqueParameters},
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterVariant MonsterDatabase::readMonsterVariantFromJson(Json const& variant) const {
|
||
|
|
return monsterVariant(variant.getString("type"), variant.getUInt("seed"), variant.getObject("uniqueParameters"));
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterPtr MonsterDatabase::createMonster(
|
||
|
|
MonsterVariant monsterVariant, Maybe<float> level, Json uniqueParameters) const {
|
||
|
|
if (uniqueParameters) {
|
||
|
|
monsterVariant.uniqueParameters = jsonMerge(monsterVariant.uniqueParameters, uniqueParameters);
|
||
|
|
monsterVariant.parameters = jsonMerge(monsterVariant.parameters, monsterVariant.uniqueParameters);
|
||
|
|
readCommonParameters(monsterVariant);
|
||
|
|
}
|
||
|
|
return make_shared<Monster>(monsterVariant, level);
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterPtr MonsterDatabase::diskLoadMonster(Json const& diskStore) const {
|
||
|
|
return make_shared<Monster>(diskStore);
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterPtr MonsterDatabase::netLoadMonster(ByteArray const& netStore) const {
|
||
|
|
return make_shared<Monster>(readMonsterVariant(netStore));
|
||
|
|
}
|
||
|
|
|
||
|
|
List<Drawable> MonsterDatabase::monsterPortrait(MonsterVariant const& variant) const {
|
||
|
|
NetworkedAnimator animator(variant.animatorConfig);
|
||
|
|
for (auto const& pair : variant.animatorPartTags)
|
||
|
|
animator.setPartTag(pair.first, "partImage", pair.second);
|
||
|
|
animator.setZoom(variant.animatorZoom);
|
||
|
|
auto colorSwap = variant.colorSwap.value(this->colorSwap(variant.parameters.getString("colors", "default"), variant.seed));
|
||
|
|
if (!colorSwap.empty())
|
||
|
|
animator.setProcessingDirectives(imageOperationToString(ColorReplaceImageOperation{colorSwap}));
|
||
|
|
auto drawables = animator.drawables();
|
||
|
|
Drawable::scaleAll(drawables, TilePixels);
|
||
|
|
return drawables;
|
||
|
|
}
|
||
|
|
|
||
|
|
std::pair<String, String> MonsterDatabase::skillInfo(String const& skillName) const {
|
||
|
|
if (m_skills.contains(skillName)) {
|
||
|
|
auto& skill = m_skills.get(skillName);
|
||
|
|
return std::make_pair(skill.label, skill.image);
|
||
|
|
} else {
|
||
|
|
return std::make_pair("", "");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Json MonsterDatabase::skillConfigParameter(String const& skillName, String const& configParameterName) const {
|
||
|
|
if (m_skills.contains(skillName)) {
|
||
|
|
auto& skill = m_skills.get(skillName);
|
||
|
|
return skill.config.get(configParameterName, Json());
|
||
|
|
} else {
|
||
|
|
return Json();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ColorReplaceMap MonsterDatabase::colorSwap(String const& setName, uint64_t seed) const {
|
||
|
|
if (m_colorSwaps.contains(setName))
|
||
|
|
return staticRandomFrom(m_colorSwaps.get(setName), seed);
|
||
|
|
else {
|
||
|
|
Logger::error("Monster colors '%s' not found!", setName);
|
||
|
|
return staticRandomFrom(m_colorSwaps.get("default"), seed);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Json MonsterDatabase::mergePartParameters(Json const& partParameterDescription, JsonArray const& parameters) {
|
||
|
|
JsonObject mergedParameters;
|
||
|
|
|
||
|
|
// First assign all the defaults.
|
||
|
|
for (auto const& pair : partParameterDescription.iterateObject())
|
||
|
|
mergedParameters[pair.first] = pair.second.get(1);
|
||
|
|
|
||
|
|
// Then go through parameter list and merge based on the merge rules.
|
||
|
|
for (auto const& applyParams : parameters) {
|
||
|
|
for (auto const& pair : applyParams.iterateObject()) {
|
||
|
|
String mergeMethod = partParameterDescription.get(pair.first).getString(0);
|
||
|
|
Json value = mergedParameters.get(pair.first);
|
||
|
|
|
||
|
|
if (mergeMethod.equalsIgnoreCase("add")) {
|
||
|
|
value = value.toDouble() + pair.second.toDouble();
|
||
|
|
} else if (mergeMethod.equalsIgnoreCase("multiply")) {
|
||
|
|
value = value.toDouble() * pair.second.toDouble();
|
||
|
|
} else if (mergeMethod.equalsIgnoreCase("merge")) {
|
||
|
|
// "merge" means to either merge maps, or *append* lists together
|
||
|
|
if (!pair.second.isNull()) {
|
||
|
|
if (value.isNull()) {
|
||
|
|
value = pair.second;
|
||
|
|
} else if (value.type() != pair.second.type()) {
|
||
|
|
value = pair.second;
|
||
|
|
} else {
|
||
|
|
if (pair.second.type() == Json::Type::Array) {
|
||
|
|
auto array = value.toArray();
|
||
|
|
array.appendAll(pair.second.toArray());
|
||
|
|
value = move(array);
|
||
|
|
} else if (pair.second.type() == Json::Type::Object) {
|
||
|
|
auto obj = value.toObject();
|
||
|
|
obj.merge(pair.second.toObject(), true);
|
||
|
|
value = move(obj);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (mergeMethod.equalsIgnoreCase("override") && !pair.second.isNull()) {
|
||
|
|
value = pair.second;
|
||
|
|
}
|
||
|
|
|
||
|
|
mergedParameters[pair.first] = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return mergedParameters;
|
||
|
|
}
|
||
|
|
|
||
|
|
Json MonsterDatabase::mergeFinalParameters(JsonArray const& parameters) {
|
||
|
|
JsonObject mergedParameters;
|
||
|
|
|
||
|
|
for (auto const& applyParams : parameters) {
|
||
|
|
for (auto const& pair : applyParams.iterateObject()) {
|
||
|
|
Json value = mergedParameters.value(pair.first);
|
||
|
|
|
||
|
|
// Hard-coded merge for scripts and skills parameters, otherwise merge.
|
||
|
|
if (pair.first == "scripts" || pair.first == "skills" || pair.first == "specialSkills"
|
||
|
|
|| pair.first == "baseSkills") {
|
||
|
|
auto array = value.optArray().value();
|
||
|
|
array.appendAll(pair.second.optArray().value());
|
||
|
|
value = move(array);
|
||
|
|
} else {
|
||
|
|
value = jsonMerge(value, pair.second);
|
||
|
|
}
|
||
|
|
|
||
|
|
mergedParameters[pair.first] = value;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return mergedParameters;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MonsterDatabase::readCommonParameters(MonsterVariant& variant) {
|
||
|
|
variant.shortDescription = variant.parameters.optString("shortdescription").orMaybe(variant.shortDescription);
|
||
|
|
variant.dropPoolConfig = variant.parameters.get("dropPools", variant.dropPoolConfig);
|
||
|
|
variant.scripts = jsonToStringList(variant.parameters.get("scripts"));
|
||
|
|
variant.animationScripts = jsonToStringList(variant.parameters.getArray("animationScripts", {}));
|
||
|
|
variant.animatorConfig = jsonMerge(variant.animatorConfig, variant.parameters.get("animationCustom", JsonObject()));
|
||
|
|
variant.initialScriptDelta = variant.parameters.getUInt("initialScriptDelta", 5);
|
||
|
|
variant.metaBoundBox = jsonToRectF(variant.parameters.get("metaBoundBox"));
|
||
|
|
variant.renderLayer = variant.parameters.optString("renderLayer").apply(parseRenderLayer).value(RenderLayerMonster);
|
||
|
|
variant.scale = variant.parameters.getFloat("scale");
|
||
|
|
variant.movementSettings = ActorMovementParameters(variant.parameters.get("movementSettings", {}));
|
||
|
|
variant.walkMultiplier = variant.parameters.getFloat("walkMultiplier", 1.0f);
|
||
|
|
variant.runMultiplier = variant.parameters.getFloat("runMultiplier", 1.0f);
|
||
|
|
variant.jumpMultiplier = variant.parameters.getFloat("jumpMultiplier", 1.0f);
|
||
|
|
variant.weightMultiplier = variant.parameters.getFloat("weightMultiplier", 1.0f);
|
||
|
|
variant.healthMultiplier = variant.parameters.getFloat("healthMultiplier", 1.0f);
|
||
|
|
variant.touchDamageMultiplier = variant.parameters.getFloat("touchDamageMultiplier", 1.0f);
|
||
|
|
variant.touchDamageConfig = variant.parameters.get("touchDamage", {});
|
||
|
|
variant.animationDamageParts = variant.parameters.getObject("animationDamageParts", {});
|
||
|
|
variant.statusSettings = variant.parameters.get("statusSettings");
|
||
|
|
variant.mouthOffset = jsonToVec2F(variant.parameters.get("mouthOffset")) / TilePixels;
|
||
|
|
variant.feetOffset = jsonToVec2F(variant.parameters.get("feetOffset")) / TilePixels;
|
||
|
|
variant.powerLevelFunction = variant.parameters.getString("powerLevelFunction", "monsterLevelPowerMultiplier");
|
||
|
|
variant.healthLevelFunction = variant.parameters.getString("healthLevelFunction", "monsterLevelHealthMultiplier");
|
||
|
|
variant.clientEntityMode = ClientEntityModeNames.getLeft(variant.parameters.getString("clientEntityMode", "ClientSlaveOnly"));
|
||
|
|
variant.persistent = variant.parameters.getBool("persistent", false);
|
||
|
|
variant.damageTeamType = TeamTypeNames.getLeft(variant.parameters.getString("damageTeamType", "enemy"));
|
||
|
|
variant.damageTeam = variant.parameters.getUInt("damageTeam", 2);
|
||
|
|
|
||
|
|
if (auto sdp = variant.parameters.get("selfDamagePoly", {}))
|
||
|
|
variant.selfDamagePoly = jsonToPolyF(sdp);
|
||
|
|
else
|
||
|
|
variant.selfDamagePoly = *variant.movementSettings.standingPoly;
|
||
|
|
|
||
|
|
variant.portraitIcon = variant.parameters.optString("portraitIcon");
|
||
|
|
variant.damageReceivedAggressiveDuration = variant.parameters.getFloat("damageReceivedAggressiveDuration", 1.0f);
|
||
|
|
variant.onDamagedOthersAggressiveDuration = variant.parameters.getFloat("onDamagedOthersAggressiveDuration", 5.0f);
|
||
|
|
variant.onFireAggressiveDuration = variant.parameters.getFloat("onFireAggressiveDuration", 5.0f);
|
||
|
|
|
||
|
|
variant.nametagColor = jsonToVec3B(variant.parameters.get("nametagColor", JsonArray{255, 255, 255}));
|
||
|
|
|
||
|
|
variant.colorSwap = variant.parameters.optObject("colorSwap").apply([](JsonObject const& json) -> ColorReplaceMap {
|
||
|
|
ColorReplaceMap swaps;
|
||
|
|
for (auto pair : json) {
|
||
|
|
swaps.insert(Color::fromHex(pair.first).toRgba(), Color::fromHex(pair.second.toString()).toRgba());
|
||
|
|
}
|
||
|
|
return swaps;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
MonsterVariant MonsterDatabase::produceMonster(String const& typeName, uint64_t seed, Json const& uniqueParameters) const {
|
||
|
|
RandomSource rand = RandomSource(seed);
|
||
|
|
|
||
|
|
auto const& monsterType = m_monsterTypes.get(typeName);
|
||
|
|
|
||
|
|
MonsterVariant monsterVariant;
|
||
|
|
monsterVariant.type = typeName;
|
||
|
|
monsterVariant.shortDescription = monsterType.shortDescription;
|
||
|
|
monsterVariant.description = monsterType.description;
|
||
|
|
monsterVariant.seed = seed;
|
||
|
|
monsterVariant.uniqueParameters = uniqueParameters;
|
||
|
|
|
||
|
|
monsterVariant.animatorConfig = Root::singleton().assets()->fetchJson(monsterType.animationConfigPath);
|
||
|
|
monsterVariant.reversed = monsterType.reversed;
|
||
|
|
|
||
|
|
// select a list of monster parts
|
||
|
|
List<MonsterPart> monsterParts;
|
||
|
|
auto categoryName = rand.randFrom(monsterType.categories);
|
||
|
|
|
||
|
|
for (auto const& partTypeName : monsterType.partTypes) {
|
||
|
|
auto randPart = rand.randFrom(m_partDirectory.get(categoryName).get(partTypeName)).second;
|
||
|
|
auto selectedPart = uniqueParameters.get("selectedParts", JsonObject()).optString(partTypeName);
|
||
|
|
if (selectedPart)
|
||
|
|
monsterParts.append(m_partDirectory.get(categoryName).get(partTypeName).get(*selectedPart));
|
||
|
|
else
|
||
|
|
monsterParts.append(randPart);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (auto const& partConfig : monsterParts) {
|
||
|
|
for (auto const& pair : partConfig.frames)
|
||
|
|
monsterVariant.animatorPartTags[pair.first] = AssetPath::relativeTo(partConfig.path, pair.second.toString());
|
||
|
|
}
|
||
|
|
JsonArray partParameterList;
|
||
|
|
for (auto const& partConfig : monsterParts) {
|
||
|
|
partParameterList.append(partConfig.partParameters);
|
||
|
|
// Include part parameter overrides
|
||
|
|
if (!monsterType.partParameterOverrides.isNull() && monsterType.partParameterOverrides.contains(partConfig.name))
|
||
|
|
partParameterList.append(monsterType.partParameterOverrides.getObject(partConfig.name));
|
||
|
|
}
|
||
|
|
|
||
|
|
// merge part parameters and unique parameters into base parameters
|
||
|
|
Json baseParameters = monsterType.baseParameters;
|
||
|
|
Json mergedPartParameters = mergePartParameters(monsterType.partParameterDescription, partParameterList);
|
||
|
|
monsterVariant.parameters = mergeFinalParameters({baseParameters, mergedPartParameters});
|
||
|
|
monsterVariant.parameters = jsonMerge(monsterVariant.parameters, uniqueParameters);
|
||
|
|
|
||
|
|
tie(monsterVariant.parameters, monsterVariant.animatorConfig) = chooseSkills(monsterVariant.parameters, monsterVariant.animatorConfig, rand);
|
||
|
|
monsterVariant.animatorZoom = 1.0f;
|
||
|
|
monsterVariant.dropPoolConfig = monsterType.dropPools;
|
||
|
|
|
||
|
|
readCommonParameters(monsterVariant);
|
||
|
|
monsterVariant.animatorZoom = monsterVariant.scale;
|
||
|
|
if (monsterVariant.dropPoolConfig.isType(Json::Type::Array))
|
||
|
|
monsterVariant.dropPoolConfig = rand.randValueFrom(monsterVariant.dropPoolConfig.toArray());
|
||
|
|
|
||
|
|
return monsterVariant;
|
||
|
|
}
|
||
|
|
|
||
|
|
pair<Json, Json> MonsterDatabase::chooseSkills(
|
||
|
|
Json const& parameters, Json const& animatorConfig, RandomSource& rand) const {
|
||
|
|
// Pick a subset of skills, then merge in any params from those skills
|
||
|
|
if (parameters.contains("baseSkills") || parameters.contains("specialSkills")) {
|
||
|
|
auto skillCount = parameters.getUInt("skillCount", 2);
|
||
|
|
|
||
|
|
auto baseSkillNames = jsonToStringList(parameters.get("baseSkills"));
|
||
|
|
auto specialSkillNames = jsonToStringList(parameters.get("specialSkills"));
|
||
|
|
|
||
|
|
List<String> skillNames;
|
||
|
|
|
||
|
|
// First, pick from base skills
|
||
|
|
while (!baseSkillNames.empty() && skillNames.size() < skillCount)
|
||
|
|
skillNames.append(baseSkillNames.takeAt(rand.randInt(baseSkillNames.size() - 1)));
|
||
|
|
|
||
|
|
// ...then fill in from special skills as needed
|
||
|
|
while (!specialSkillNames.empty() && skillNames.size() < skillCount)
|
||
|
|
skillNames.append(specialSkillNames.takeAt(rand.randInt(specialSkillNames.size() - 1)));
|
||
|
|
|
||
|
|
Json finalAnimatorConfig = animatorConfig;
|
||
|
|
JsonArray allParameters({parameters});
|
||
|
|
for (auto& skillName : skillNames) {
|
||
|
|
if (m_skills.contains(skillName)) {
|
||
|
|
auto const& skill = m_skills.get(skillName);
|
||
|
|
allParameters.append(skill.parameters);
|
||
|
|
finalAnimatorConfig = jsonMerge(finalAnimatorConfig, skill.animationParameters);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Need to override the final list of skills, instead of merging the lists
|
||
|
|
Json finalParameters = mergeFinalParameters(allParameters).set("skills", jsonFromStringList(skillNames));
|
||
|
|
|
||
|
|
return {finalParameters, finalAnimatorConfig};
|
||
|
|
} else if (parameters.contains("skills")) {
|
||
|
|
auto availableSkillNames = jsonToStringList(parameters.get("skills"));
|
||
|
|
auto skillCount = min<size_t>(parameters.getUInt("skillCount", 2), availableSkillNames.size());
|
||
|
|
|
||
|
|
List<String> skillNames;
|
||
|
|
for (size_t i = 0; i < skillCount; ++i)
|
||
|
|
skillNames.append(availableSkillNames.takeAt(rand.randInt(availableSkillNames.size() - 1)));
|
||
|
|
|
||
|
|
Json finalAnimatorConfig = animatorConfig;
|
||
|
|
JsonArray allParameters({parameters});
|
||
|
|
for (auto& skillName : skillNames) {
|
||
|
|
if (m_skills.contains(skillName)) {
|
||
|
|
auto const& skill = m_skills.get(skillName);
|
||
|
|
allParameters.append(skill.parameters);
|
||
|
|
finalAnimatorConfig = jsonMerge(finalAnimatorConfig, skill.animationParameters);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Need to override the final list of skills, instead of merging the lists
|
||
|
|
Json finalParameters = mergeFinalParameters(allParameters).set("skills", jsonFromStringList(skillNames));
|
||
|
|
|
||
|
|
return {finalParameters, finalAnimatorConfig};
|
||
|
|
} else {
|
||
|
|
return {parameters, animatorConfig};
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|