path: root/source/game/StarMaterialDatabase.cpp

#include "StarMaterialDatabase.hpp"
#include "StarJsonExtra.hpp"
#include "StarFormat.hpp"
#include "StarAssets.hpp"
#include "StarRoot.hpp"
#include "StarLogging.hpp"
#include "StarParticleDatabase.hpp"

namespace Star {

MaterialDatabase::MaterialDatabase() {
  m_metaModIndex = {
      {"metamod:none", NoModId},
      {"metamod:biome", BiomeModId},
      {"metamod:undergroundbiome", UndergroundBiomeModId}};

  auto assets = Root::singleton().assets();
  auto pdb = Root::singleton().particleDatabase();

  setMetaMaterial(EmptyMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:empty", EmptyMaterialId, CollisionKind::None, false});
  setMetaMaterial(NullMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:null", NullMaterialId, CollisionKind::Block, true});
  setMetaMaterial(StructureMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:structure", StructureMaterialId, CollisionKind::Block, true});
  setMetaMaterial(BiomeMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome", BiomeMaterialId, CollisionKind::Block, true});
  setMetaMaterial(Biome1MaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome1", Biome1MaterialId, CollisionKind::Block, true});
  setMetaMaterial(Biome2MaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome2", Biome2MaterialId, CollisionKind::Block, true});
  setMetaMaterial(Biome3MaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome3", Biome3MaterialId, CollisionKind::Block, true});
  setMetaMaterial(Biome4MaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome4", Biome4MaterialId, CollisionKind::Block, true});
  setMetaMaterial(Biome5MaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:biome5", Biome5MaterialId, CollisionKind::Block, true});
  setMetaMaterial(BoundaryMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:boundary", BoundaryMaterialId, CollisionKind::Slippery, true});
  setMetaMaterial(ObjectSolidMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:objectsolid", ObjectSolidMaterialId, CollisionKind::Block, true});
  setMetaMaterial(ObjectPlatformMaterialId, MaterialDatabase::MetaMaterialInfo{"metamaterial:objectplatform", ObjectPlatformMaterialId, CollisionKind::Platform, false});

  auto metaMaterialConfig = assets->json("/metamaterials.config");
  for (auto metaMaterial : metaMaterialConfig.iterateArray()) {
    auto matName = "metamaterial:" + metaMaterial.getString("name");
    if (isMaterialName(matName)) {
      Logger::info("Metamaterial '{}' has duplicate material name!", matName);
      continue;
    }

    MaterialId matId = metaMaterial.getUInt("materialId");
    if (isRealMaterial(matId) || matId >= FirstEngineMetaMaterialId) {
      Logger::info("Material id {} for metamaterial '{}' does not fall within the valid range!", matId, matName);
      continue;
    } else if (containsMetaMaterial(matId)) {
      Logger::info("Material id {} for metamaterial '{}' conflicts with another metamaterial id!", matId, matName);
      continue;
    }

    auto matCollisionKind = CollisionKindNames.getLeft(metaMaterial.getString("collisionKind"));

    bool blocksLiquidFlow = metaMaterial.getBool("blocksLiquidFlow", isSolidColliding(matCollisionKind));

    setMetaMaterial(matId, MaterialDatabase::MetaMaterialInfo{matName, matId, matCollisionKind, blocksLiquidFlow});
  }

  auto& materials = assets->scanExtension("material");
  auto& mods = assets->scanExtension("matmod");

  assets->queueJsons(materials);
  assets->queueJsons(mods);

  for (auto& file : materials) {
    try {
      auto matConfig = assets->json(file);

      MaterialInfo material;

      auto materialId = matConfig.getInt("materialId");
      material.id = materialId;

      material.name = matConfig.getString("materialName");
      material.path = file;
      material.config = matConfig;

      material.itemDrop = matConfig.getString("itemDrop", "");

      JsonObject descriptions;
      for (auto entry : matConfig.iterateObject())
        if (entry.first.endsWith("Description"))
          descriptions[entry.first] = entry.second;
      descriptions["description"] = matConfig.getString("description", "");
      descriptions["shortdescription"] = matConfig.getString("shortdescription", "");
      material.descriptions = descriptions;

      material.category = matConfig.getString("category");

      material.particleColor = jsonToColor(matConfig.get("particleColor", JsonArray{0, 0, 0, 255}));
      if (matConfig.contains("miningParticle"))
        material.miningParticle = pdb->config(matConfig.getString("miningParticle"));
      if (matConfig.contains("miningSounds"))
        material.miningSounds = transform<StringList>(
            jsonToStringList(matConfig.get("miningSounds")), bind(AssetPath::relativeTo, file, _1));
      if (matConfig.contains("footstepSound"))
        material.footstepSound = AssetPath::relativeTo(file, matConfig.getString("footstepSound"));

      material.tillableMod = matConfig.getInt("tillableMod", NoModId);
      material.soil = matConfig.getBool("soil", false);
      material.falling = matConfig.getBool("falling", false);
      material.cascading = matConfig.getBool("cascading", false);

      if (matConfig.contains("renderTemplate")) {
        auto renderTemplate = assets->fetchJson(matConfig.get("renderTemplate"), file);
        auto renderParameters = matConfig.get("renderParameters");
        material.materialRenderProfile = make_shared<MaterialRenderProfile>(parseMaterialRenderProfile(jsonMerge(renderTemplate, renderParameters), file));
      }

      material.damageParameters =
          TileDamageParameters(assets->fetchJson(matConfig.get("damageTable", "/tiles/defaultDamage.config")),
              matConfig.optFloat("health"),
              matConfig.optUInt("requiredHarvestLevel"));

      material.collisionKind = CollisionKindNames.getLeft(matConfig.getString("collisionKind", "block"));
      material.foregroundOnly = matConfig.getBool("foregroundOnly", material.collisionKind != CollisionKind::Block);
      material.supportsMods = matConfig.getBool("supportsMods", !(material.falling || material.cascading || material.collisionKind != CollisionKind::Block));

      material.blocksLiquidFlow = matConfig.getBool("blocksLiquidFlow", isSolidColliding(material.collisionKind));

      if (material.id != materialId || !isRealMaterial(material.id))
        throw MaterialException(strf("Material id {} does not fall in the valid range\n", materialId));

      if (containsMaterial(material.id))
        throw MaterialException(strf("Duplicate material id {} found for material {}", material.id, material.name));

      if (isMaterialName(material.name))
        throw MaterialException(strf("Duplicate material name '{}' found", material.name));

      setMaterial(material.id, material);

      for (auto liquidInteraction : matConfig.getArray("liquidInteractions", {})) {
        LiquidId liquidId = liquidInteraction.getUInt("liquidId");
        LiquidMaterialInteraction interaction;
        interaction.consumeLiquid = liquidInteraction.getFloat("consumeLiquid", 0.0f);
        interaction.transformTo = liquidInteraction.getUInt("transformMaterialId", NullMaterialId);
        interaction.topOnly = liquidInteraction.getBool("topOnly", false);
        m_liquidMaterialInteractions[{liquidId, material.id}] = interaction;
      }
    } catch (StarException const& e) {
      throw MaterialException(strf("Error loading material file {}", file), e);
    }
  }

  for (auto& file : mods) {
    try {
      auto modConfig = assets->json(file);

      ModInfo mod;

      auto modId = modConfig.getInt("modId");
      mod.id = modId;

      mod.name = modConfig.getString("modName");
      mod.path = file;
      mod.config = modConfig;

      mod.itemDrop = modConfig.getString("itemDrop", "");

      JsonObject descriptions;
      for (auto entry : modConfig.iterateObject())
        if (entry.first.endsWith("Description"))
          descriptions[entry.first] = entry.second;
      descriptions["description"] = modConfig.getString("description", "");
      mod.descriptions = descriptions;

      mod.particleColor = jsonToColor(modConfig.get("particleColor", JsonArray{0, 0, 0, 255}));
      if (modConfig.contains("miningParticle"))
        mod.miningParticle = pdb->config(modConfig.getString("miningParticle"));
      if (modConfig.contains("miningSounds"))
        mod.miningSounds = transform<StringList>(
            jsonToStringList(modConfig.get("miningSounds")), bind(AssetPath::relativeTo, file, _1));
      if (modConfig.contains("footstepSound"))
        mod.footstepSound = AssetPath::relativeTo(file, modConfig.getString("footstepSound"));

      mod.tilled = modConfig.getBool("tilled", false);

      mod.breaksWithTile = modConfig.getBool("breaksWithTile", false);

      if (modConfig.contains("renderTemplate")) {
        auto renderTemplate = assets->fetchJson(modConfig.get("renderTemplate"));
        auto renderParameters = modConfig.get("renderParameters");
        mod.modRenderProfile = make_shared<MaterialRenderProfile>(parseMaterialRenderProfile(jsonMerge(renderTemplate, renderParameters), file));
      }

      mod.damageParameters =
          TileDamageParameters(assets->fetchJson(modConfig.get("damageTable", "/tiles/defaultDamage.config")),
              modConfig.optFloat("health"),
              modConfig.optUInt("harvestLevel"));

      if (modId != mod.id || !isRealMod(mod.id))
        throw MaterialException(strf("Mod id {} does not fall in the valid range\n", mod.id));

      if (containsMod(mod.id))
        throw MaterialException(strf("Duplicate mod id {} found for mod {}", mod.id, mod.name));

      if (m_modIndex.contains(mod.name) || m_metaModIndex.hasLeftValue(mod.name))
        throw MaterialException(strf("Duplicate mod name '{}' found", mod.name));

      setMod(mod.id, mod);
      m_modIndex[mod.name] = mod.id;

      for (auto liquidInteraction : modConfig.getArray("liquidInteractions", {})) {
        LiquidId liquidId = liquidInteraction.getUInt("liquidId");
        LiquidModInteraction interaction;
        interaction.consumeLiquid = liquidInteraction.getFloat("consumeLiquid", 0.0f);
        interaction.transformTo = liquidInteraction.getUInt("transformModId", NoModId);
        interaction.topOnly = liquidInteraction.getBool("topOnly", false);
        m_liquidModInteractions[{liquidId, mod.id}] = interaction;
      }
    } catch (StarException const& e) {
      throw MaterialException(strf("Error loading mod file {}", file), e);
    }
  }

  m_defaultFootstepSound = assets->json("/client.config:defaultFootstepSound").toString();
}

StringList MaterialDatabase::materialNames() const {
  StringList names = m_materialIndex.keys();
  names.appendAll(m_metaMaterialIndex.keys());
  return names;
}

bool MaterialDatabase::isMetaMaterialName(String const& name) const {
  return m_metaMaterialIndex.contains(name);
}

bool MaterialDatabase::isMaterialName(String const& name) const {
  return m_materialIndex.contains(name) || m_metaMaterialIndex.contains(name);
}

bool MaterialDatabase::isValidMaterialId(MaterialId material) const {
  if (isRealMaterial(material))
    return containsMaterial(material);
  else
    return containsMetaMaterial(material);
}

MaterialId MaterialDatabase::materialId(String const& matName) const {
  if (auto m = m_metaMaterialIndex.maybe(matName))
    return *m;
  else
    return m_materialIndex.get(matName);
}

String MaterialDatabase::materialName(MaterialId materialId) const {
  if (isRealMaterial(materialId))
    return getMaterialInfo(materialId)->name;
  else
    return getMetaMaterialInfo(materialId)->name;
}

Maybe<String> MaterialDatabase::materialPath(MaterialId materialId) const {
  if (isRealMaterial(materialId))
    return getMaterialInfo(materialId)->path;
  else
    return {};
}

Maybe<Json> MaterialDatabase::materialConfig(MaterialId materialId) const {
  if (isRealMaterial(materialId))
    return getMaterialInfo(materialId)->config;
  else
    return {};
}

String MaterialDatabase::materialDescription(MaterialId materialNumber, String const& species) const {
  auto material = m_materials[materialNumber];
  return material->descriptions.getString(
      strf("{}Description", species), material->descriptions.getString("description"));
}

String MaterialDatabase::materialDescription(MaterialId materialNumber) const {
  auto material = m_materials[materialNumber];
  return material->descriptions.getString("description");
}

String MaterialDatabase::materialShortDescription(MaterialId materialNumber) const {
  auto material = m_materials[materialNumber];
  return material->descriptions.getString("shortdescription");
}

String MaterialDatabase::materialCategory(MaterialId materialNumber) const {
  auto material = m_materials[materialNumber];
  return material->category;
}

StringList MaterialDatabase::modNames() const {
  StringList modNames = m_modIndex.keys();
  modNames.appendAll(m_metaModIndex.leftValues());
  return modNames;
}

bool MaterialDatabase::isModName(String const& name) const {
  return m_modIndex.contains(name);
}

bool MaterialDatabase::isValidModId(ModId mod) const {
  if (isRealMod(mod))
    return mod < m_mods.size() && (bool)m_mods[mod];
  else
    return m_metaModIndex.hasRightValue(mod);
}

ModId MaterialDatabase::modId(String const& modName) const {
  if (auto m = m_metaModIndex.maybeRight(modName))
    return *m;
  else
    return m_modIndex.get(modName);
}

String const& MaterialDatabase::modName(ModId mod) const {
  if (isRealMod(mod))
    return getModInfo(mod)->name;
  else
    return m_metaModIndex.getLeft(mod);
}

Maybe<String> MaterialDatabase::modPath(ModId mod) const {
  if (isRealMod(mod))
    return getModInfo(mod)->path;
  else
    return {};
}

Maybe<Json> MaterialDatabase::modConfig(ModId mod) const {
  if (isRealMod(mod))
    return getModInfo(mod)->config;
  else
    return {};
}

String MaterialDatabase::modDescription(ModId modId, String const& species) const {
  auto mod = m_mods[modId];
  return mod->descriptions.getString(strf("{}Description", species), mod->descriptions.getString("description"));
}

String MaterialDatabase::modDescription(ModId modId) const {
  auto mod = m_mods[modId];
  return mod->descriptions.getString("description");
}

String MaterialDatabase::modShortDescription(ModId modId) const {
  auto mod = m_mods[modId];
  return mod->descriptions.getString("shortdescription");
}

String MaterialDatabase::defaultFootstepSound() const {
  return m_defaultFootstepSound;
}

TileDamageParameters MaterialDatabase::materialDamageParameters(MaterialId materialId) const {
  if (!isRealMaterial(materialId))
    return {};
  else
    return getMaterialInfo(materialId)->damageParameters;
}

TileDamageParameters MaterialDatabase::modDamageParameters(ModId modId) const {
  if (!isRealMod(modId))
    return {};
  else
    return getModInfo(modId)->damageParameters;
}

bool MaterialDatabase::modBreaksWithTile(ModId modId) const {
  if (!isRealMod(modId))
    return {};
  else
    return getModInfo(modId)->breaksWithTile;
}

CollisionKind MaterialDatabase::materialCollisionKind(MaterialId materialId) const {
  if (isRealMaterial(materialId))
    return getMaterialInfo(materialId)->collisionKind;
  else if (containsMetaMaterial(materialId))
    return getMetaMaterialInfo(materialId)->collisionKind;
  else
    return CollisionKind::Block;
}

bool MaterialDatabase::canPlaceInLayer(MaterialId materialId, TileLayer layer) const {
  return layer != TileLayer::Background || !getMaterialInfo(materialId)->foregroundOnly;
}

ItemDescriptor MaterialDatabase::materialItemDrop(MaterialId materialId) const {
  if (isRealMaterial(materialId)) {
    auto matInfo = getMaterialInfo(materialId);
    if (!matInfo->itemDrop.empty())
      return ItemDescriptor(matInfo->itemDrop, 1, JsonObject());
  }

  return {};
}

ItemDescriptor MaterialDatabase::modItemDrop(ModId modId) const {
  if (isRealMod(modId)) {
    auto modInfo = getModInfo(modId);
    if (!modInfo->itemDrop.empty())
      return ItemDescriptor(modInfo->itemDrop, 1);
  }

  return {};
}

MaterialColorVariant MaterialDatabase::materialColorVariants(MaterialId materialId) const {
  if (isRealMaterial(materialId)) {
    auto const& matInfo = getMaterialInfo(materialId);
    if (matInfo->materialRenderProfile)
      return matInfo->materialRenderProfile->colorVariants;
  }

  return 0;
}

MaterialColorVariant MaterialDatabase::modColorVariants(ModId modId) const {
  if (isRealMod(modId)) {
    auto const& modInfo = getModInfo(modId);
    if (modInfo->modRenderProfile)
      return modInfo->modRenderProfile->colorVariants;
  }

  return 0;
}

bool MaterialDatabase::isMultiColor(MaterialId materialId) const {
  if (isRealMaterial(materialId)) {
    auto const& matInfo = getMaterialInfo(materialId);
    if (matInfo->materialRenderProfile)
      return matInfo->materialRenderProfile->colorVariants > 0;
  }

  return false;
}

ParticleConfigPtr MaterialDatabase::miningParticle(MaterialId materialId, ModId modId) const {
  if (isRealMod(modId)) {
    auto const& modInfo = getModInfo(modId);
    if (modInfo->miningParticle)
      return modInfo->miningParticle;
  }

  if (isRealMaterial(materialId)) {
    auto const& matInfo = getMaterialInfo(materialId);
    if (matInfo->miningParticle)
      return matInfo->miningParticle;
  }

  return ParticleConfigPtr();
}

String MaterialDatabase::miningSound(MaterialId materialId, ModId modId) const {
  if (isRealMod(modId)) {
    auto const& modInfo = getModInfo(modId);
    if (!modInfo->miningSounds.empty())
      return Random::randValueFrom(modInfo->miningSounds);
  }

  if (isRealMaterial(materialId)) {
    auto const& matInfo = getMaterialInfo(materialId);
    if (!matInfo->miningSounds.empty())
      return Random::randValueFrom(matInfo->miningSounds);
  }

  return String();
}

String MaterialDatabase::footstepSound(MaterialId materialId, ModId modId) const {
  if (isRealMod(modId)) {
    auto const& modInfo = getModInfo(modId);
    if (!modInfo->footstepSound.empty())
      return modInfo->footstepSound;
  }

  if (isRealMaterial(materialId)) {
    auto const& matInfo = getMaterialInfo(materialId);
    if (!matInfo->footstepSound.empty())
      return matInfo->footstepSound;
  }

  return m_defaultFootstepSound;
}

Color MaterialDatabase::materialParticleColor(MaterialId materialId, MaterialHue hueShift) const {
  auto color = getMaterialInfo(materialId)->particleColor;
  color.setHue(pfmod(color.hue() + materialHueToDegrees(hueShift) / 360.0f, 1.0f));
  return color;
}

bool MaterialDatabase::isTilledMod(ModId modId) const {
  if (!isRealMod(modId))
    return false;
  return getModInfo(modId)->tilled;
}

bool MaterialDatabase::isSoil(MaterialId materialId) const {
  if (!isRealMaterial(materialId))
    return false;
  return getMaterialInfo(materialId)->soil;
}

ModId MaterialDatabase::tilledModFor(MaterialId materialId) const {
  if (!isRealMaterial(materialId))
    return NoModId;
  return getMaterialInfo(materialId)->tillableMod;
}

bool MaterialDatabase::isFallingMaterial(MaterialId materialId) const {
  if (!isRealMaterial(materialId))
    return false;
  return getMaterialInfo(materialId)->falling;
}

bool MaterialDatabase::isCascadingFallingMaterial(MaterialId materialId) const {
  if (!isRealMaterial(materialId))
    return false;
  return getMaterialInfo(materialId)->cascading;
}

bool MaterialDatabase::supportsMod(MaterialId materialId, ModId modId) const {
  if (modId == NoModId)
    return true;
  if (!isRealMaterial(materialId))
    return false;
  if (!isRealMod(modId))
    return false;

  return getMaterialInfo(materialId)->supportsMods;
}

MaterialDatabase::MetaMaterialInfo::MetaMaterialInfo(String name, MaterialId id, CollisionKind collisionKind, bool blocksLiquidFlow)
  : name(name), id(id), collisionKind(collisionKind), blocksLiquidFlow(blocksLiquidFlow) {}

MaterialDatabase::MaterialInfo::MaterialInfo() : id(NullMaterialId), tillableMod(NoModId), falling(), cascading() {}

MaterialDatabase::ModInfo::ModInfo() : id(NoModId), tilled(), breaksWithTile() {}

size_t MaterialDatabase::metaMaterialIndex(MaterialId materialId) const {
  return materialId - FirstMetaMaterialId;
}

bool MaterialDatabase::containsMetaMaterial(MaterialId materialId) const {
  auto i = metaMaterialIndex(materialId);
  return m_metaMaterials.size() > i && m_metaMaterials[i];
}

void MaterialDatabase::setMetaMaterial(MaterialId materialId, MetaMaterialInfo info) {
  auto i = metaMaterialIndex(materialId);
  if (i >= m_metaMaterials.size())
    m_metaMaterials.resize(i + 1);
  m_metaMaterials[i] = make_shared<MetaMaterialInfo>(info);
  m_metaMaterialIndex[info.name] = materialId;
}

bool MaterialDatabase::containsMaterial(MaterialId materialId) const {
  return m_materials.size() > materialId && m_materials[materialId];
}

void MaterialDatabase::setMaterial(MaterialId materialId, MaterialInfo info) {
  if (materialId >= m_materials.size())
    m_materials.resize(materialId + 1);
  m_materials[materialId] = make_shared<MaterialInfo>(info);
  m_materialIndex[info.name] = materialId;
}

bool MaterialDatabase::containsMod(ModId modId) const {
  return m_mods.size() > modId && m_mods[modId];
}

void MaterialDatabase::setMod(ModId modId, ModInfo info) {
  if (modId >= m_mods.size())
    m_mods.resize(modId + 1);
  m_mods[modId] = make_shared<ModInfo>(info);
}

shared_ptr<MaterialDatabase::MetaMaterialInfo const> const& MaterialDatabase::getMetaMaterialInfo(MaterialId materialId) const {
  if (!containsMetaMaterial(materialId))
    throw MaterialException(strf("No such metamaterial id: {}\n", materialId));
  else
    return m_metaMaterials[metaMaterialIndex(materialId)];
}

shared_ptr<MaterialDatabase::MaterialInfo const> const& MaterialDatabase::getMaterialInfo(MaterialId materialId) const {
  if (materialId >= m_materials.size() || !m_materials[materialId])
    throw MaterialException(strf("No such material id: {}\n", materialId));
  else
    return m_materials[materialId];
}

shared_ptr<MaterialDatabase::ModInfo const> const& MaterialDatabase::getModInfo(ModId modId) const {
  if (modId >= m_mods.size() || !m_mods[modId])
    throw MaterialException(strf("No such mod id: {}\n", modId));
  else
    return m_mods[modId];
}

}