everything everywhere

all at once

1 files changed, 709 insertions, 0 deletions

diff --git a/source/game/StarItemDatabase.cpp b/source/game/StarItemDatabase.cpp
new file mode 100644
index 0000000..4012a20
--- /dev/null
+++ b/source/game/StarItemDatabase.cpp
@@ -0,0 +1,709 @@
+#include "StarItemDatabase.hpp"
+#include "StarCodexDatabase.hpp"
+#include "StarJsonExtra.hpp"
+#include "StarRoot.hpp"
+#include "StarAssets.hpp"
+#include "StarCasting.hpp"
+#include "StarCurrency.hpp"
+#include "StarConsumableItem.hpp"
+#include "StarBlueprintItem.hpp"
+#include "StarCodexItem.hpp"
+#include "StarLiquidItem.hpp"
+#include "StarMaterialItem.hpp"
+#include "StarObjectItem.hpp"
+#include "StarItemDrop.hpp"
+#include "StarInspectionTool.hpp"
+#include "StarInstrumentItem.hpp"
+#include "StarThrownItem.hpp"
+#include "StarUnlockItem.hpp"
+#include "StarActiveItem.hpp"
+#include "StarAugmentItem.hpp"
+#include "StarTools.hpp"
+#include "StarArmors.hpp"
+#include "StarObjectDatabase.hpp"
+#include "StarRootLuaBindings.hpp"
+#include "StarItemLuaBindings.hpp"
+#include "StarConfigLuaBindings.hpp"
+#include "StarUtilityLuaBindings.hpp"
+
+namespace Star {
+
+EnumMap<ItemType> ItemTypeNames{
+  {ItemType::Generic, "generic"},
+  {ItemType::LiquidItem, "liquid"},
+  {ItemType::MaterialItem, "material"},
+  {ItemType::ObjectItem, "object"},
+  {ItemType::CurrencyItem, "currency"},
+  {ItemType::MiningTool, "miningtool"},
+  {ItemType::Flashlight, "flashlight"},
+  {ItemType::WireTool, "wiretool"},
+  {ItemType::BeamMiningTool, "beamminingtool"},
+  {ItemType::HarvestingTool, "harvestingtool"},
+  {ItemType::TillingTool, "tillingtool"},
+  {ItemType::PaintingBeamTool, "paintingbeamtool"},
+  {ItemType::HeadArmor, "headarmor"},
+  {ItemType::ChestArmor, "chestarmor"},
+  {ItemType::LegsArmor, "legsarmor"},
+  {ItemType::BackArmor, "backarmor"},
+  {ItemType::Consumable, "consumable"},
+  {ItemType::Blueprint, "blueprint"},
+  {ItemType::Codex, "codex"},
+  {ItemType::InspectionTool, "inspectiontool"},
+  {ItemType::InstrumentItem, "instrument"},
+  {ItemType::ThrownItem, "thrownitem"},
+  {ItemType::UnlockItem, "unlockitem"},
+  {ItemType::ActiveItem, "activeitem"},
+  {ItemType::AugmentItem, "augmentitem"}
+};
+
+uint64_t ItemDatabase::getCountOfItem(List<ItemPtr> const& bag, ItemDescriptor const& item, bool exactMatch) {
+  auto normalizedBag = normalizeBag(bag);
+  return getCountOfItem(normalizedBag, item, exactMatch);
+}
+
+uint64_t ItemDatabase::getCountOfItem(HashMap<ItemDescriptor, uint64_t> const& bag, ItemDescriptor const& item, bool exactMatch) {
+  ItemDescriptor matchItem = exactMatch ? item.singular() : ItemDescriptor(item.name(), 1);
+  if (!bag.contains(matchItem)) {
+    return 0;
+  } else {
+    return bag.get(matchItem);
+  }
+}
+
+HashMap<ItemDescriptor, uint64_t> ItemDatabase::normalizeBag(List<ItemPtr> const& bag) {
+  HashMap<ItemDescriptor, uint64_t> normalizedBag;
+  for (auto const& item : bag) {
+    if (!item)
+      continue;
+
+    normalizedBag[ItemDescriptor(item->name(), 1)] += item->count();
+
+    if (!item->parameters().toObject().empty())
+      normalizedBag[ItemDescriptor(item->name(), 1, item->parameters())] += item->count();
+  }
+
+  return normalizedBag;
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromSubset(HashMap<ItemDescriptor, uint64_t> const& normalizedBag, StringMap<uint64_t> const& availableCurrencies, HashSet<ItemRecipe> const& subset) {
+  HashSet<ItemRecipe> res;
+  for (auto const& recipe : subset) {
+    // add this recipe if we can make it.
+    if (canMakeRecipe(recipe, normalizedBag, availableCurrencies))
+      res.add(recipe);
+  }
+
+  return res;
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromSubset(HashMap<ItemDescriptor, uint64_t> const& normalizedBag, StringMap<uint64_t> const& availableCurrencies,
+    HashSet<ItemRecipe> const& subset, StringSet const& allowedTypes) {
+  HashSet<ItemRecipe> res;
+  for (auto const& recipe : subset) {
+    // is it the right kind of recipe for this check ?
+    if (recipe.groups.hasIntersection(allowedTypes) || allowedTypes.empty() || recipe.groups.empty()) {
+      // do we have the ingredients to make it.
+      if (canMakeRecipe(recipe, normalizedBag, availableCurrencies)) {
+        res.add(recipe);
+      }
+    }
+  }
+
+  return res;
+}
+
+String ItemDatabase::guiFilterString(ItemPtr const& item) {
+  return (item->name() + item->friendlyName() + item->description()).toLower().splitAny(" ,.?*\\+/|\t").join("");
+}
+
+bool ItemDatabase::canMakeRecipe(ItemRecipe const& recipe, HashMap<ItemDescriptor, uint64_t> const& availableIngredients, StringMap<uint64_t> const& availableCurrencies) {
+  for (auto const& p : recipe.currencyInputs) {
+    if (availableCurrencies.value(p.first, 0) < p.second)
+      return false;
+  }
+
+  for (auto const& input : recipe.inputs) {
+    ItemDescriptor matchInput = recipe.matchInputParameters ? input.singular() : ItemDescriptor(input.name(), 1);
+    if (availableIngredients.value(matchInput) < input.count())
+      return false;
+  }
+
+  return true;
+}
+
+ItemDatabase::ItemDatabase()
+  : m_luaRoot(make_shared<LuaRoot>()) {
+  scanItems();
+  addObjectItems();
+  addCodexes();
+  scanRecipes();
+  addBlueprints();
+}
+
+ItemPtr ItemDatabase::diskLoad(Json const& diskStore) const {
+  if (diskStore) {
+    return item(ItemDescriptor::loadStore(diskStore));
+  } else {
+    return {};
+  }
+}
+
+ItemPtr ItemDatabase::fromJson(Json const& spec) const {
+  return item(ItemDescriptor(spec));
+}
+
+Json ItemDatabase::diskStore(ItemConstPtr const& itemPtr) const {
+  if (itemPtr)
+    return itemPtr->descriptor().diskStore();
+  else
+    return Json();
+}
+
+Json ItemDatabase::toJson(ItemConstPtr const& itemPtr) const {
+  if (itemPtr)
+    return itemPtr->descriptor().toJson();
+  else
+    return Json();
+}
+
+bool ItemDatabase::hasItem(String const& itemName) const {
+  return m_items.contains(itemName);
+}
+
+ItemType ItemDatabase::itemType(String const& itemName) const {
+  return itemData(itemName).type;
+}
+
+String ItemDatabase::itemFriendlyName(String const& itemName) const {
+  return itemData(itemName).friendlyName;
+}
+
+StringSet ItemDatabase::itemTags(String const& itemName) const {
+  return itemData(itemName).itemTags;
+}
+
+ItemDatabase::ItemConfig ItemDatabase::itemConfig(String const& itemName, Json parameters, Maybe<float> level, Maybe<uint64_t> seed) const {
+  auto const& data = itemData(itemName);
+
+  ItemConfig itemConfig;
+  if (data.assetsConfig)
+    itemConfig.config = Root::singleton().assets()->json(*data.assetsConfig);
+  itemConfig.directory = data.directory;
+  itemConfig.config = jsonMerge(itemConfig.config, data.customConfig);
+  itemConfig.parameters = parameters;
+
+  if (auto builder = itemConfig.config.optString("builder")) {
+    RecursiveMutexLocker locker(m_luaMutex);
+    auto context = m_luaRoot->createContext(*builder);
+    context.setCallbacks("root", LuaBindings::makeRootCallbacks());
+    context.setCallbacks("sb", LuaBindings::makeUtilityCallbacks());
+    luaTie(itemConfig.config, itemConfig.parameters) = context.invokePath<LuaTupleReturn<Json, Json>>(
+        "build", itemConfig.directory, itemConfig.config, itemConfig.parameters, level, seed);
+  }
+
+  return itemConfig;
+}
+
+ItemPtr ItemDatabase::item(ItemDescriptor descriptor, Maybe<float> level, Maybe<uint64_t> seed) const {
+  if (!descriptor)
+    return {};
+
+  ItemPtr item;
+  try {
+    item = createItem(m_items.get(descriptor.name()).type, itemConfig(descriptor.name(), descriptor.parameters(), level, seed));
+  } catch (std::exception const& e) {
+    Logger::error("Could not instantiate item '%s'. %s", descriptor, outputException(e, false));
+    item = createItem(m_items.get("perfectlygenericitem").type, itemConfig("perfectlygenericitem", {}, {}));
+  }
+  item->setCount(descriptor.count());
+
+  return item;
+}
+
+bool ItemDatabase::hasRecipeToMake(ItemDescriptor const& item) const {
+  auto si = item.singular();
+  for (auto const& recipe : m_recipes)
+    if (recipe.output.singular() == si)
+      return true;
+  return false;
+}
+
+bool ItemDatabase::hasRecipeToMake(ItemDescriptor const& item, StringSet const& allowedTypes) const {
+  auto si = item.singular();
+  for (auto const& recipe : m_recipes)
+    if (recipe.output.singular() == si)
+      for (auto allowedType : allowedTypes)
+        if (recipe.groups.contains(allowedType))
+          return true;
+  return false;
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesForOutputItem(String itemName) const {
+  HashSet<ItemRecipe> result;
+  for (auto const& recipe : m_recipes)
+    if (recipe.output.name() == itemName)
+      result.add(recipe);
+  return result;
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromBagContents(List<ItemPtr> const& bag, StringMap<uint64_t> const& availableCurrencies) const {
+  auto normalizedBag = normalizeBag(bag);
+  return recipesFromBagContents(normalizedBag, availableCurrencies);
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromBagContents(HashMap<ItemDescriptor, uint64_t> const& bag, StringMap<uint64_t> const& availableCurrencies) const {
+  return recipesFromSubset(bag, availableCurrencies, m_recipes);
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromBagContents(List<ItemPtr> const& bag, StringMap<uint64_t> const& availableCurrencies, StringSet const& allowedTypes) const {
+  auto normalizedBag = normalizeBag(bag);
+  return recipesFromBagContents(normalizedBag, availableCurrencies, allowedTypes);
+}
+
+HashSet<ItemRecipe> ItemDatabase::recipesFromBagContents(HashMap<ItemDescriptor, uint64_t> const& bag, StringMap<uint64_t> const& availableCurrencies, StringSet const& allowedTypes) const {
+  return recipesFromSubset(bag, availableCurrencies, m_recipes, allowedTypes);
+}
+
+uint64_t ItemDatabase::maxCraftableInBag(List<ItemPtr> const& bag, StringMap<uint64_t> const& availableCurrencies, ItemRecipe const& recipe) const {
+  auto normalizedBag = normalizeBag(bag);
+
+  return maxCraftableInBag(normalizedBag, availableCurrencies, recipe);
+}
+
+uint64_t ItemDatabase::maxCraftableInBag(HashMap<ItemDescriptor, uint64_t> const& bag, StringMap<uint64_t> const& availableCurrencies, ItemRecipe const& recipe) const {
+  uint64_t res = highest<uint64_t>();
+
+  for (auto const& p : recipe.currencyInputs) {
+    uint64_t available = availableCurrencies.value(p.first, 0);
+    if (available == 0)
+      return 0;
+    else if (p.second > 0)
+      res = min(available / p.second, res);
+  }
+
+  for (auto const& input : recipe.inputs) {
+    if (!bag.contains(input.singular()))
+      return 0;
+    else if (input.count() > 0)
+      res = min(bag.get(input.singular()) / input.count(), res);
+  }
+
+  return res;
+}
+
+ItemRecipe ItemDatabase::getPreciseRecipeForMaterials(String const& group, List<ItemPtr> const& bag, StringMap<uint64_t> const& availableCurrencies) const {
+  // picks the recipe that:
+  // * can be crafted (duh)
+  // * uses all the input material types
+  // * uses the most materials (if recipes exist with the same input materials)
+
+  auto options = recipesFromBagContents(bag, availableCurrencies);
+  ItemRecipe result;
+  int ingredientsCount = 0;
+  for (auto const& recipe : options) {
+    if (!recipe.groups.contains(group))
+      continue;
+    bool usesAllItemTypes = true;
+    for (auto const& item : bag) {
+      bool match = false;
+      for (auto const& input : recipe.inputs)
+        if (item->matches(input, recipe.matchInputParameters))
+          match = true;
+      if (!match)
+        usesAllItemTypes = false;
+    }
+    if (!usesAllItemTypes)
+      continue;
+    int count = 0;
+    for (auto const& input : recipe.inputs)
+      count += input.count();
+    if (count > ingredientsCount)
+      result = recipe;
+  }
+  return result;
+}
+
+ItemRecipe ItemDatabase::parseRecipe(Json const& config) const {
+  ItemRecipe res;
+  try {
+    res.currencyInputs = jsonToMapV<StringMap<uint64_t>>(config.get("currencyInputs", JsonObject()), mem_fn(&Json::toUInt));
+
+    // parse currency items into currency inputs
+    for (auto input : config.getArray("input")) {
+      auto id = ItemDescriptor(input);
+      if (itemType(id.name()) == ItemType::CurrencyItem) {
+        auto currencyItem = as<CurrencyItem>(item(id));
+        res.currencyInputs[currencyItem->currencyType()] += currencyItem->totalValue();
+      } else {
+        res.inputs.push_back(id);
+      }
+    }
+
+    res.output = ItemDescriptor(config.get("output"));
+    res.duration = config.getFloat("duration", Root::singleton().assets()->json("/items/defaultParameters.config:defaultCraftDuration").toFloat());
+    res.groups = StringSet::from(jsonToStringList(config.get("groups", JsonArray())));
+    if (auto item = ItemDatabase::item(res.output)) {
+      res.outputRarity = item->rarity();
+      res.guiFilterString = guiFilterString(item);
+    }
+    res.collectables = jsonToMapV<StringMap<String>>(config.get("collectables", JsonObject()), mem_fn(&Json::toString));
+    res.matchInputParameters = config.getBool("matchInputParameters", false);
+
+  } catch (JsonException const& e) {
+    throw RecipeException(strf("Recipe missing required ingredient: %s", outputException(e, false)));
+  }
+
+  return res;
+}
+
+HashSet<ItemRecipe> ItemDatabase::allRecipes() const {
+  return m_recipes;
+}
+
+HashSet<ItemRecipe> ItemDatabase::allRecipes(StringSet const& types) const {
+  HashSet<ItemRecipe> res;
+  for (auto const& i : m_recipes) {
+    if (i.groups.hasIntersection(types))
+      res.add(i);
+  }
+  return res;
+}
+
+ItemPtr ItemDatabase::applyAugment(ItemPtr const item, AugmentItem* augment) const {
+  if (item) {
+    RecursiveMutexLocker locker(m_luaMutex);
+    LuaBaseComponent script;
+    script.setLuaRoot(m_luaRoot);
+    script.setScripts(augment->augmentScripts());
+    script.addCallbacks("item", LuaBindings::makeItemCallbacks(augment));
+    script.addCallbacks("config", LuaBindings::makeConfigCallbacks(bind(&Item::instanceValue, augment, _1, _2)));
+    script.init();
+    auto luaResult = script.invoke<LuaTupleReturn<Json, Maybe<uint64_t>>>("apply", item->descriptor().toJson());
+    script.uninit();
+    locker.unlock();
+
+    if (luaResult) {
+      if (!get<0>(*luaResult).isNull()) {
+        augment->take(get<1>(*luaResult).value(1));
+        return ItemDatabase::item(ItemDescriptor(get<0>(*luaResult)));
+      }
+    }
+  }
+
+  return item;
+}
+
+bool ItemDatabase::ageItem(ItemPtr& item, double aging) const {
+  if (!item)
+    return false;
+
+  auto const& itemData = ItemDatabase::itemData(item->name());
+  if (itemData.agingScripts.empty())
+    return false;
+
+  ItemDescriptor original = item->descriptor();
+
+  RecursiveMutexLocker locker(m_luaMutex);
+  LuaBaseComponent script;
+  script.setLuaRoot(m_luaRoot);
+  script.setScripts(itemData.agingScripts);
+  script.init();
+  auto aged = script.invoke<Json>("ageItem", original.toJson(), aging).apply(construct<ItemDescriptor>());
+  script.uninit();
+  locker.unlock();
+
+  if (aged && *aged != original) {
+    item = ItemDatabase::item(*aged);
+    return true;
+  }
+
+  return false;
+}
+
+List<String> ItemDatabase::allItems() const {
+  return m_items.keys();
+}
+
+ItemPtr ItemDatabase::createItem(ItemType type, ItemConfig const& config) {
+  if (type == ItemType::Generic) {
+    return make_shared<GenericItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::LiquidItem) {
+    return make_shared<LiquidItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::MaterialItem) {
+    return make_shared<MaterialItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::ObjectItem) {
+    return make_shared<ObjectItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::CurrencyItem) {
+    return make_shared<CurrencyItem>(config.config, config.directory);
+  } else if (type == ItemType::MiningTool) {
+    return make_shared<MiningTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::Flashlight) {
+    return make_shared<Flashlight>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::WireTool) {
+    return make_shared<WireTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::BeamMiningTool) {
+    return make_shared<BeamMiningTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::PaintingBeamTool) {
+    return make_shared<PaintingBeamTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::TillingTool) {
+    return make_shared<TillingTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::HarvestingTool) {
+    return make_shared<HarvestingTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::HeadArmor) {
+    return make_shared<HeadArmor>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::ChestArmor) {
+    return make_shared<ChestArmor>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::LegsArmor) {
+    return make_shared<LegsArmor>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::BackArmor) {
+    return make_shared<BackArmor>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::Consumable) {
+    return make_shared<ConsumableItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::Blueprint) {
+    return make_shared<BlueprintItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::Codex) {
+    return make_shared<CodexItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::InspectionTool) {
+    return make_shared<InspectionTool>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::InstrumentItem) {
+    return make_shared<InstrumentItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::ThrownItem) {
+    return make_shared<ThrownItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::UnlockItem) {
+    return make_shared<UnlockItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::ActiveItem) {
+    return make_shared<ActiveItem>(config.config, config.directory, config.parameters);
+  } else if (type == ItemType::AugmentItem) {
+    return make_shared<AugmentItem>(config.config, config.directory, config.parameters);
+  } else {
+    throw ItemException(strf("Unknown item type %s", (int)type));
+  }
+}
+
+ItemDatabase::ItemData const& ItemDatabase::itemData(String const& name) const {
+  if (auto p = m_items.ptr(name))
+    return *p;
+  throw ItemException::format("No such item '%s'", name);
+}
+
+ItemRecipe ItemDatabase::makeRecipe(List<ItemDescriptor> inputs, ItemDescriptor output, float duration, StringSet groups) const {
+  ItemRecipe res;
+  res.inputs = move(inputs);
+  res.output = move(output);
+  res.duration = duration;
+  res.groups = move(groups);
+  if (auto item = ItemDatabase::item(res.output)) {
+    res.outputRarity = item->rarity();
+    res.guiFilterString = guiFilterString(item);
+  }
+  return res;
+}
+
+void ItemDatabase::addItemSet(ItemType type, String const& extension) {
+  auto assets = Root::singleton().assets();
+  for (auto file : assets->scanExtension(extension)) {
+    ItemData data;
+    try {
+      auto config = assets->json(file);
+      data.type = type;
+      data.assetsConfig = file;
+      data.name = config.get("itemName").toString();
+      data.friendlyName = config.getString("shortdescription", {});
+      data.itemTags = config.opt("itemTags").apply(jsonToStringSet).value();
+      data.agingScripts = config.opt("itemAgingScripts").apply(jsonToStringList).value();
+      data.directory = AssetPath::directory(file);
+
+      data.agingScripts = data.agingScripts.transformed(bind(&AssetPath::relativeTo, data.directory, _1));
+    } catch (std::exception const& e) {
+      throw ItemException(strf("Could not load item asset %s", file), e);
+    }
+
+    if (m_items.contains(data.name))
+      throw ItemException(strf("Duplicate item name '%s' found", data.name));
+
+    m_items[data.name] = data;
+  }
+}
+
+void ItemDatabase::addObjectDropItem(String const& objectPath, Json const& objectConfig) {
+  auto assets = Root::singleton().assets();
+
+  ItemData data;
+  data.type = ItemType::ObjectItem;
+  data.name = objectConfig.get("objectName").toString();
+  data.friendlyName = objectConfig.getString("shortdescription", {});
+  data.itemTags = objectConfig.opt("itemTags").apply(jsonToStringSet).value();
+  data.agingScripts = objectConfig.opt("itemAgingScripts").apply(jsonToStringList).value();
+  data.directory = AssetPath::directory(objectPath);
+  JsonObject customConfig = objectConfig.toObject();
+  if (!customConfig.contains("inventoryIcon")) {
+    customConfig["inventoryIcon"] = assets->json("/objects/defaultParameters.config:missingIcon");
+    Logger::warn(strf("Missing inventoryIcon for %s, using default", data.name).c_str());
+  }
+  customConfig["itemName"] = data.name;
+  if (!customConfig.contains("tooltipKind"))
+    customConfig["tooltipKind"] = "object";
+
+  if (!customConfig.contains("printable"))
+    customConfig["printable"] = customConfig.contains("price");
+
+  // Don't inherit object scripts. this is kind of a crappy solution to prevent
+  // ObjectItems (which are firable and therefore scripted) from trying to
+  // execute scripts intended for objects
+  customConfig.remove("scripts");
+
+  data.customConfig = move(customConfig);
+
+  if (m_items.contains(data.name))
+    throw ItemException(strf("Object drop '%s' shares name with existing item", data.name));
+
+  m_items[data.name] = move(data);
+}
+
+void ItemDatabase::scanItems() {
+  auto assets = Root::singleton().assets();
+
+  List<std::pair<ItemType, String>> itemSets;
+  auto scanItemType = [&itemSets, assets](ItemType type, String const& extension) {
+    itemSets.append(make_pair(type, extension));
+    assets->queueJsons(assets->scanExtension(extension));
+  };
+
+  scanItemType(ItemType::Generic, "item");
+  scanItemType(ItemType::LiquidItem, "liqitem");
+  scanItemType(ItemType::MaterialItem, "matitem");
+  scanItemType(ItemType::MiningTool, "miningtool");
+  scanItemType(ItemType::Flashlight, "flashlight");
+  scanItemType(ItemType::WireTool, "wiretool");
+  scanItemType(ItemType::BeamMiningTool, "beamaxe");
+  scanItemType(ItemType::TillingTool, "tillingtool");
+  scanItemType(ItemType::PaintingBeamTool, "painttool");
+  scanItemType(ItemType::HarvestingTool, "harvestingtool");
+  scanItemType(ItemType::HeadArmor, "head");
+  scanItemType(ItemType::ChestArmor, "chest");
+  scanItemType(ItemType::LegsArmor, "legs");
+  scanItemType(ItemType::BackArmor, "back");
+  scanItemType(ItemType::CurrencyItem, "currency");
+  scanItemType(ItemType::Consumable, "consumable");
+  scanItemType(ItemType::Blueprint, "blueprint");
+  scanItemType(ItemType::InspectionTool, "inspectiontool");
+  scanItemType(ItemType::InstrumentItem, "instrument");
+  scanItemType(ItemType::ThrownItem, "thrownitem");
+  scanItemType(ItemType::UnlockItem, "unlock");
+  scanItemType(ItemType::ActiveItem, "activeitem");
+  scanItemType(ItemType::AugmentItem, "augment");
+
+  for (auto const& itemset : itemSets)
+    addItemSet(itemset.first, itemset.second);
+}
+
+void ItemDatabase::addObjectItems() {
+  auto objectDatabase = Root::singleton().objectDatabase();
+
+  for (auto const& objectName : objectDatabase->allObjects()) {
+    auto objectConfig = objectDatabase->getConfig(objectName);
+
+    if (objectConfig->hasObjectItem)
+      addObjectDropItem(objectConfig->path, objectConfig->config);
+  }
+}
+
+void ItemDatabase::scanRecipes() {
+  auto assets = Root::singleton().assets();
+
+  auto files = assets->scanExtension("recipe");
+  assets->queueJsons(files);
+  for (auto file : files) {
+    try {
+      m_recipes.add(parseRecipe(assets->json(file)));
+    } catch (std::exception const& e) {
+      Logger::error("Could not load recipe %s: %s", file, outputException(e, false));
+    }
+  }
+}
+
+void ItemDatabase::addBlueprints() {
+  auto assets = Root::singleton().assets();
+
+  for (auto const& recipe : m_recipes) {
+    auto baseDesc = recipe.output;
+    auto baseItem = item(baseDesc);
+
+    String blueprintName = strf("%s-recipe", baseItem->name());
+    if (m_items.contains(blueprintName))
+      continue;
+
+    try {
+      ItemData blueprintData;
+
+      blueprintData.type = ItemType::Blueprint;
+      JsonObject configInfo;
+      configInfo["recipe"] = baseDesc.singular().toJson();
+
+      String description = assets->json("/blueprint.config:description").toString();
+      description = description.replace("<item>", baseItem->friendlyName());
+      configInfo["description"] = Json(description);
+
+      String shortDesc = assets->json("/blueprint.config:shortdescription").toString();
+      shortDesc = shortDesc.replace("<item>", baseItem->friendlyName());
+      configInfo["shortdescription"] = Json(shortDesc);
+
+      configInfo["category"] = assets->json("/blueprint.config:category").toString();
+
+      blueprintData.name = blueprintName;
+      blueprintData.friendlyName = shortDesc;
+      configInfo["itemName"] = blueprintData.name;
+
+      if (baseItem->instanceValue("inventoryIcon", false))
+        configInfo["inventoryIcon"] = baseItem->instanceValue("inventoryIcon");
+
+      configInfo["rarity"] = RarityNames.getRight(baseItem->rarity());
+
+      configInfo["price"] = baseItem->price();
+
+      blueprintData.customConfig = move(configInfo);
+      blueprintData.directory = itemData(baseDesc.name()).directory;
+
+      m_items[blueprintData.name] = blueprintData;
+    } catch (std::exception const& e) {
+      Logger::error("Could not create blueprint item from recipe: %s", outputException(e, false));
+    }
+  }
+}
+
+void ItemDatabase::addCodexes() {
+  auto assets = Root::singleton().assets();
+  auto codexConfig = assets->json("/codex.config");
+
+  auto codexDatabase = Root::singleton().codexDatabase();
+  for (auto const& codexPair : codexDatabase->codexes()) {
+    String codexItemName = strf("%s-codex", codexPair.second->id());
+    if (m_items.contains(codexItemName)) {
+      Logger::warn("Couldn't create codex item %s because an item with that name is already defined", codexItemName);
+      continue;
+    }
+
+    try {
+      ItemData codexItemData;
+
+      codexItemData.type = ItemType::Codex;
+      codexItemData.name = codexItemName;
+      codexItemData.friendlyName = codexPair.second->title();
+      codexItemData.directory = codexPair.second->directory();
+
+      auto customConfig = jsonMerge(codexConfig.get("defaultItemConfig"), codexPair.second->itemConfig()).toObject();
+      customConfig["itemName"] = codexItemName;
+      customConfig["codexId"] = codexPair.second->id();
+      customConfig["shortdescription"] = codexPair.second->title();
+      customConfig["description"] = codexPair.second->description();
+      customConfig["codexIcon"] = codexPair.second->icon();
+      codexItemData.customConfig = customConfig;
+
+      m_items[codexItemName] = codexItemData;
+    } catch (std::exception const& e) {
+      Logger::error("Could not create item for codex %s: %s", codexPair.second->id(), outputException(e, false));
+    }
+  }
+}
+
+}