X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcraftdef.cpp;h=21060519839072636a897a13efb31c58645c535b;hb=e1142ee57f2d7b59a86f6d0d72ae043844bc3121;hp=e701a427959f18383aa6598b1de85148713b6bd9;hpb=cebbaf1664f3005b3b9e66b104b9d4044b1ca277;p=minetest.git diff --git a/src/craftdef.cpp b/src/craftdef.cpp index e701a4279..210605198 100644 --- a/src/craftdef.cpp +++ b/src/craftdef.cpp @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ @@ -22,217 +22,1096 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "irrlichttypes.h" #include "log.h" #include -#include "utility.h" +#include +#include #include "gamedef.h" #include "inventory.h" +#include "util/serialize.h" +#include "util/string.h" +#include "util/numeric.h" +#include "util/strfnd.h" +#include "exceptions.h" -CraftPointerInput::~CraftPointerInput() +inline bool isGroupRecipeStr(const std::string &rec_name) { - for(u32 i=0; i &recipe) { - std::vector items; - for(u32 i=0; i &grid_names) +{ + switch (type) { + case CRAFT_HASH_TYPE_ITEM_NAMES: { + std::ostringstream os; + bool is_first = true; + for (const std::string &grid_name : grid_names) { + if (!grid_name.empty()) { + os << (is_first ? "" : "\n") << grid_name; + is_first = false; + } + } + return getHashForString(os.str()); + } case CRAFT_HASH_TYPE_COUNT: { + u64 cnt = 0; + for (const std::string &grid_name : grid_names) + if (!grid_name.empty()) + cnt++; + return cnt; + } case CRAFT_HASH_TYPE_UNHASHED: + return 0; + } + // invalid CraftHashType + assert(false); + return 0; +} + +// Check if input matches recipe +// Takes recipe groups into account +static bool inputItemMatchesRecipe(const std::string &inp_name, + const std::string &rec_name, IItemDefManager *idef) +{ + // Exact name + if (inp_name == rec_name) + return true; + + // Group + if (isGroupRecipeStr(rec_name) && idef->isKnown(inp_name)) { + const struct ItemDefinition &def = idef->get(inp_name); + Strfnd f(rec_name.substr(6)); + bool all_groups_match = true; + do { + std::string check_group = f.next(","); + if (itemgroup_get(def.groups, check_group) == 0) { + all_groups_match = false; + break; + } + } while (!f.at_end()); + if (all_groups_match) + return true; + } + + // Didn't match + return false; +} + +// Deserialize an itemstring then return the name of the item +static std::string craftGetItemName(const std::string &itemstring, IGameDef *gamedef) +{ + ItemStack item; + item.deSerialize(itemstring, gamedef->idef()); + return item.name; +} + +// (mapcar craftGetItemName itemstrings) +static std::vector craftGetItemNames( + const std::vector &itemstrings, IGameDef *gamedef) +{ + std::vector result; + result.reserve(itemstrings.size()); + for (const auto &itemstring : itemstrings) { + result.push_back(craftGetItemName(itemstring, gamedef)); + } + return result; +} + +// Get name of each item, and return them as a new list. +static std::vector craftGetItemNames( + const std::vector &items, IGameDef *gamedef) +{ + std::vector result; + result.reserve(items.size()); + for (const auto &item : items) { + result.push_back(item.name); + } + return result; +} + +// convert a list of item names, to ItemStacks. +static std::vector craftGetItems( + const std::vector &items, IGameDef *gamedef) +{ + std::vector result; + result.reserve(items.size()); + for (const auto &item : items) { + result.emplace_back(std::string(item), (u16)1, + (u16)0, gamedef->getItemDefManager()); + } + return result; +} + +// Compute bounding rectangle given a matrix of items +// Returns false if every item is "" +static bool craftGetBounds(const std::vector &items, unsigned int width, + unsigned int &min_x, unsigned int &max_x, + unsigned int &min_y, unsigned int &max_y) +{ + bool success = false; + unsigned int x = 0; + unsigned int y = 0; + for (const std::string &item : items) { + // Is this an actual item? + if (!item.empty()) { + if (!success) { + // This is the first nonempty item + min_x = max_x = x; + min_y = max_y = y; + success = true; + } else { + if (x < min_x) min_x = x; + if (x > max_x) max_x = x; + if (y < min_y) min_y = y; + if (y > max_y) max_y = y; + } + } + + // Step coordinate + x++; + if (x == width) { + x = 0; + y++; + } + } + return success; +} + +// Removes 1 from each item stack +static void craftDecrementInput(CraftInput &input, IGameDef *gamedef) +{ + for (auto &item : input.items) { + if (item.count != 0) + item.remove(1); + } +} + +// Removes 1 from each item stack with replacement support +// Example: if replacements contains the pair ("bucket:bucket_water", "bucket:bucket_empty"), +// a water bucket will not be removed but replaced by an empty bucket. +static void craftDecrementOrReplaceInput(CraftInput &input, + std::vector &output_replacements, + const CraftReplacements &replacements, + IGameDef *gamedef) +{ + if (replacements.pairs.empty()) { + craftDecrementInput(input, gamedef); + return; + } + + // Make a copy of the replacements pair list + std::vector > pairs = replacements.pairs; + + for (auto &item : input.items) { + // Find an appropriate replacement + bool found_replacement = false; + for (auto j = pairs.begin(); j != pairs.end(); ++j) { + if (inputItemMatchesRecipe(item.name, j->first, gamedef->idef())) { + if (item.count == 1) { + item.deSerialize(j->second, gamedef->idef()); + found_replacement = true; + pairs.erase(j); + break; + } + + ItemStack rep; + rep.deSerialize(j->second, gamedef->idef()); + item.remove(1); + found_replacement = true; + output_replacements.push_back(rep); + break; + + } } - items.push_back(item); + // No replacement was found, simply decrement count by one + if (!found_replacement && item.count > 0) + item.remove(1); } - return CraftPointerInput(ci.width, items); } -CraftInput createInput(const CraftPointerInput &cpi) +// Dump an itemstring matrix +static std::string craftDumpMatrix(const std::vector &items, + unsigned int width) { - std::vector items; - for(u32 i=0; iserialize(oss); - items.push_back(oss.str()); + std::ostringstream os(std::ios::binary); + os << "{ "; + unsigned int x = 0; + for(std::vector::size_type i = 0; + i < items.size(); i++, x++) { + if (x == width) { + os << "; "; + x = 0; + } else if (x != 0) { + os << ","; } + os << '"' << items[i] << '"'; } - return CraftInput(cpi.width, items); + os << " }"; + return os.str(); +} + +// Dump an item matrix +std::string craftDumpMatrix(const std::vector &items, + unsigned int width) +{ + std::ostringstream os(std::ios::binary); + os << "{ "; + unsigned int x = 0; + for (std::vector::size_type i = 0; + i < items.size(); i++, x++) { + if (x == width) { + os << "; "; + x = 0; + } else if (x != 0) { + os << ","; + } + os << '"' << (items[i].getItemString()) << '"'; + } + os << " }"; + return os.str(); +} + + +/* + CraftInput +*/ + +bool CraftInput::empty() const +{ + for (const auto &item : items) { + if (!item.empty()) + return false; + } + return true; } std::string CraftInput::dump() const { std::ostringstream os(std::ios::binary); - os<<"(width="<\"" << (repl_p.second) << '"'; + sep = ","; + } + os << "}"; + return os.str(); +} + +/* + CraftDefinitionShaped +*/ + +CraftDefinitionShaped::CraftDefinitionShaped( + const std::string &output_, + unsigned int width_, + const std::vector &recipe_, + const CraftReplacements &replacements_): + output(output_), width(width_), recipe(recipe_), replacements(replacements_) { - writeU8(os, 0); // version - os< inp_names = craftGetItemNames(input.items, gamedef); + unsigned int inp_width = input.width; + if (inp_width == 0) + return false; + while (inp_names.size() % inp_width != 0) + inp_names.emplace_back(""); + + // Get input bounds + unsigned int inp_min_x = 0, inp_max_x = 0, inp_min_y = 0, inp_max_y = 0; + if (!craftGetBounds(inp_names, inp_width, inp_min_x, inp_max_x, + inp_min_y, inp_max_y)) + return false; // it was empty + + std::vector rec_names; + if (hash_inited) + rec_names = recipe_names; + else + rec_names = craftGetItemNames(recipe, gamedef); + + // Get recipe item matrix + unsigned int rec_width = width; + if (rec_width == 0) + return false; + while (rec_names.size() % rec_width != 0) + rec_names.emplace_back(""); + + // Get recipe bounds + unsigned int rec_min_x=0, rec_max_x=0, rec_min_y=0, rec_max_y=0; + if (!craftGetBounds(rec_names, rec_width, rec_min_x, rec_max_x, + rec_min_y, rec_max_y)) + return false; // it was empty + + // Different sizes? + if (inp_max_x - inp_min_x != rec_max_x - rec_min_x || + inp_max_y - inp_min_y != rec_max_y - rec_min_y) + return false; + + // Verify that all item names in the bounding box are equal + unsigned int w = inp_max_x - inp_min_x + 1; + unsigned int h = inp_max_y - inp_min_y + 1; + + for (unsigned int y=0; y < h; y++) { + unsigned int inp_y = (inp_min_y + y) * inp_width; + unsigned int rec_y = (rec_min_y + y) * rec_width; + + for (unsigned int x=0; x < w; x++) { + unsigned int inp_x = inp_min_x + x; + unsigned int rec_x = rec_min_x + x; + + if (!inputItemMatchesRecipe( + inp_names[inp_y + inp_x], + rec_names[rec_y + rec_x], gamedef->idef())) { + return false; + } + } + } + + return true; +} + +CraftOutput CraftDefinitionShaped::getOutput(const CraftInput &input, IGameDef *gamedef) const +{ + return CraftOutput(output, 0); +} + +CraftInput CraftDefinitionShaped::getInput(const CraftOutput &output, IGameDef *gamedef) const +{ + return CraftInput(CRAFT_METHOD_NORMAL,width,craftGetItems(recipe,gamedef)); +} + +void CraftDefinitionShaped::decrementInput(CraftInput &input, std::vector &output_replacements, + IGameDef *gamedef) const +{ + craftDecrementOrReplaceInput(input, output_replacements, replacements, gamedef); +} + +u64 CraftDefinitionShaped::getHash(CraftHashType type) const +{ + assert(hash_inited); // Pre-condition + assert((type == CRAFT_HASH_TYPE_ITEM_NAMES) + || (type == CRAFT_HASH_TYPE_COUNT)); // Pre-condition + + std::vector rec_names = recipe_names; + std::sort(rec_names.begin(), rec_names.end()); + return getHashForGrid(type, rec_names); +} + +void CraftDefinitionShaped::initHash(IGameDef *gamedef) +{ + if (hash_inited) + return; + hash_inited = true; + recipe_names = craftGetItemNames(recipe, gamedef); + + if (hasGroupItem(recipe_names)) + hash_type = CRAFT_HASH_TYPE_COUNT; + else + hash_type = CRAFT_HASH_TYPE_ITEM_NAMES; +} + +std::string CraftDefinitionShaped::dump() const +{ + std::ostringstream os(std::ios::binary); + os << "(shaped, output=\"" << output + << "\", recipe=" << craftDumpMatrix(recipe, width) + << ", replacements=" << replacements.dump() << ")"; + return os.str(); +} + +/* + CraftDefinitionShapeless +*/ + +CraftDefinitionShapeless::CraftDefinitionShapeless( + const std::string &output_, + const std::vector &recipe_, + const CraftReplacements &replacements_): + output(output_), recipe(recipe_), replacements(replacements_) +{ + if (hasGroupItem(recipe)) + priority = PRIORITY_SHAPELESS_AND_GROUPS; + else + priority = PRIORITY_SHAPELESS; +} + +std::string CraftDefinitionShapeless::getName() const +{ + return "shapeless"; +} + +bool CraftDefinitionShapeless::check(const CraftInput &input, IGameDef *gamedef) const +{ + if (input.method != CRAFT_METHOD_NORMAL) + return false; + + // Filter empty items out of input + std::vector input_filtered; + for (const auto &item : input.items) { + if (!item.name.empty()) + input_filtered.push_back(item.name); + } + + // If there is a wrong number of items in input, no match + if (input_filtered.size() != recipe.size()) { + /*dstream<<"Number of input items ("<idef())) { + all_match = false; + break; + } + } + //dstream<<" -> match="< &output_replacements, + IGameDef *gamedef) const +{ + craftDecrementOrReplaceInput(input, output_replacements, replacements, gamedef); +} + +u64 CraftDefinitionShapeless::getHash(CraftHashType type) const +{ + assert(hash_inited); // Pre-condition + assert(type == CRAFT_HASH_TYPE_ITEM_NAMES + || type == CRAFT_HASH_TYPE_COUNT); // Pre-condition + return getHashForGrid(type, recipe_names); +} + +void CraftDefinitionShapeless::initHash(IGameDef *gamedef) +{ + if (hash_inited) + return; + hash_inited = true; + recipe_names = craftGetItemNames(recipe, gamedef); + std::sort(recipe_names.begin(), recipe_names.end()); + + if (hasGroupItem(recipe_names)) + hash_type = CRAFT_HASH_TYPE_COUNT; + else + hash_type = CRAFT_HASH_TYPE_ITEM_NAMES; +} + +std::string CraftDefinitionShapeless::dump() const +{ + std::ostringstream os(std::ios::binary); + os << "(shapeless, output=\"" << output + << "\", recipe=" << craftDumpMatrix(recipe, recipe.size()) + << ", replacements=" << replacements.dump() << ")"; + return os.str(); +} + +/* + CraftDefinitionToolRepair +*/ + +CraftDefinitionToolRepair::CraftDefinitionToolRepair(float additional_wear_): + additional_wear(additional_wear_) +{ + priority = PRIORITY_TOOLREPAIR; +} + +static ItemStack craftToolRepair( + const ItemStack &item1, + const ItemStack &item2, + float additional_wear, + IGameDef *gamedef) +{ + IItemDefManager *idef = gamedef->idef(); + if (item1.count != 1 || item2.count != 1 || item1.name != item2.name + || idef->get(item1.name).type != ITEM_TOOL + || itemgroup_get(idef->get(item1.name).groups, "disable_repair") == 1) { + // Failure + return ItemStack(); + } + + s32 item1_uses = 65536 - (u32) item1.wear; + s32 item2_uses = 65536 - (u32) item2.wear; + s32 new_uses = item1_uses + item2_uses; + s32 new_wear = 65536 - new_uses + floor(additional_wear * 65536 + 0.5); + if (new_wear >= 65536) + return ItemStack(); + if (new_wear < 0) + new_wear = 0; + + ItemStack repaired = item1; + repaired.wear = new_wear; + return repaired; +} + +std::string CraftDefinitionToolRepair::getName() const +{ + return "toolrepair"; +} + +bool CraftDefinitionToolRepair::check(const CraftInput &input, IGameDef *gamedef) const +{ + if (input.method != CRAFT_METHOD_NORMAL) + return false; + + ItemStack item1; + ItemStack item2; + for (const auto &item : input.items) { + if (!item.empty()) { + if (item1.empty()) + item1 = item; + else if (item2.empty()) + item2 = item; + else + return false; + } + } + ItemStack repaired = craftToolRepair(item1, item2, additional_wear, gamedef); + return !repaired.empty(); +} + +CraftOutput CraftDefinitionToolRepair::getOutput(const CraftInput &input, IGameDef *gamedef) const +{ + ItemStack item1; + ItemStack item2; + for (const auto &item : input.items) { + if (!item.empty()) { + if (item1.empty()) + item1 = item; + else if (item2.empty()) + item2 = item; + } + } + ItemStack repaired = craftToolRepair(item1, item2, additional_wear, gamedef); + return CraftOutput(repaired.getItemString(), 0); +} + +CraftInput CraftDefinitionToolRepair::getInput(const CraftOutput &output, IGameDef *gamedef) const +{ + std::vector stack; + stack.emplace_back(); + return CraftInput(CRAFT_METHOD_COOKING, additional_wear, stack); +} + +void CraftDefinitionToolRepair::decrementInput(CraftInput &input, std::vector &output_replacements, + IGameDef *gamedef) const +{ + craftDecrementInput(input, gamedef); +} + +std::string CraftDefinitionToolRepair::dump() const +{ + std::ostringstream os(std::ios::binary); + os << "(toolrepair, additional_wear=" << additional_wear << ")"; + return os.str(); +} + +/* + CraftDefinitionCooking +*/ + +CraftDefinitionCooking::CraftDefinitionCooking( + const std::string &output_, + const std::string &recipe_, + float cooktime_, + const CraftReplacements &replacements_): + output(output_), recipe(recipe_), cooktime(cooktime_), replacements(replacements_) +{ + if (isGroupRecipeStr(recipe)) + priority = PRIORITY_SHAPELESS_AND_GROUPS; + else + priority = PRIORITY_SHAPELESS; +} + +std::string CraftDefinitionCooking::getName() const +{ + return "cooking"; +} + +bool CraftDefinitionCooking::check(const CraftInput &input, IGameDef *gamedef) const +{ + if (input.method != CRAFT_METHOD_COOKING) + return false; + + // Filter empty items out of input + std::vector input_filtered; + for (const auto &item : input.items) { + const std::string &name = item.name; + if (!name.empty()) + input_filtered.push_back(name); + } + + // If there is a wrong number of items in input, no match + if (input_filtered.size() != 1) { + /*dstream<<"Number of input items ("< input_filtered; + for (const auto &item : input.items) { + const std::string &name = item.name; + if (!name.empty()) + input_filtered.push_back(name); + } + + // If there is a wrong number of items in input, no match + if (input_filtered.size() != 1) { + /*dstream<<"Number of input items ("< rec; + rec.push_back(recipe); + return CraftInput(CRAFT_METHOD_COOKING,(int)burntime,craftGetItems(rec,gamedef)); +} + +void CraftDefinitionFuel::decrementInput(CraftInput &input, std::vector &output_replacements, + IGameDef *gamedef) const +{ + craftDecrementOrReplaceInput(input, output_replacements, replacements, gamedef); +} + +u64 CraftDefinitionFuel::getHash(CraftHashType type) const +{ + if (type == CRAFT_HASH_TYPE_ITEM_NAMES) { + return getHashForString(recipe_name); + } + + if (type == CRAFT_HASH_TYPE_COUNT) { + return 1; + } + + // illegal hash type for this CraftDefinition (pre-condition) + assert(false); + return 0; +} + +void CraftDefinitionFuel::initHash(IGameDef *gamedef) +{ + if (hash_inited) + return; + hash_inited = true; + recipe_name = craftGetItemName(recipe, gamedef); + + if (isGroupRecipeStr(recipe_name)) + hash_type = CRAFT_HASH_TYPE_COUNT; + else + hash_type = CRAFT_HASH_TYPE_ITEM_NAMES; +} + +std::string CraftDefinitionFuel::dump() const +{ + std::ostringstream os(std::ios::binary); + os << "(fuel, recipe=\"" << recipe + << "\", burntime=" << burntime << ")" + << ", replacements=" << replacements.dump() << ")"; + return os.str(); +} + +/* + Craft definition manager +*/ + class CCraftDefManager: public IWritableCraftDefManager { public: + CCraftDefManager() + { + m_craft_defs.resize(craft_hash_type_max + 1); + } + virtual ~CCraftDefManager() { clear(); } - virtual InventoryItem* getCraftResult(const CraftPointerInput &input_cpi, + + virtual bool getCraftResult(CraftInput &input, CraftOutput &output, + std::vector &output_replacement, bool decrementInput, IGameDef *gamedef) const { - if(input_cpi.width > 3){ - errorstream<<"getCraftResult(): ERROR: " - <<"input_cpi.width > 3; Failing to craft."<= input_cpi.width || y >= input_cpi.height()) - input_items[i] = NULL; - else - input_items[i] = input_cpi.items[y*input_cpi.width+x]; - } - for(core::list::ConstIterator - i = m_craft_definitions.begin(); - i != m_craft_definitions.end(); i++) - { - CraftDefinition *def = *i; - - /*infostream<<"Checking "<input.dump() - <<" (output=\""<output<<"\")"<input, gamedef); - if(spec_cpi.width > 3){ - errorstream<<"getCraftResult: ERROR: " - <<"spec_cpi.width > 3 in recipe " - <dump()<= spec_cpi.width || y >= spec_cpi.height()) - spec_items[i] = NULL; - else - spec_items[i] = spec_cpi.items[y*spec_cpi.width+x]; - } + if (input.empty()) + return false; + + std::vector input_names; + input_names = craftGetItemNames(input.items, gamedef); + std::sort(input_names.begin(), input_names.end()); + + // Try hash types with increasing collision rate + // while remembering the latest, highest priority recipe. + CraftDefinition::RecipePriority priority_best = + CraftDefinition::PRIORITY_NO_RECIPE; + CraftDefinition *def_best = nullptr; + for (int type = 0; type <= craft_hash_type_max; type++) { + u64 hash = getHashForGrid((CraftHashType) type, input_names); + + /*errorstream << "Checking type " << type << " with hash " << hash << std::endl;*/ + + // We'd like to do "const [...] hash_collisions = m_craft_defs[type][hash];" + // but that doesn't compile for some reason. This does. + auto col_iter = (m_craft_defs[type]).find(hash); + + if (col_iter == (m_craft_defs[type]).end()) + continue; - bool match = checkItemCombination(input_items, spec_items); + const std::vector &hash_collisions = col_iter->second; + // Walk crafting definitions from back to front, so that later + // definitions can override earlier ones. + for (std::vector::size_type + i = hash_collisions.size(); i > 0; i--) { + CraftDefinition *def = hash_collisions[i - 1]; - if(match){ - std::istringstream iss(def->output, std::ios::binary); - return InventoryItem::deSerialize(iss, gamedef); + /*errorstream << "Checking " << input.dump() << std::endl + << " against " << def->dump() << std::endl;*/ + + CraftDefinition::RecipePriority priority = def->getPriority(); + if (priority > priority_best + && def->check(input, gamedef)) { + // Check if the crafted node/item exists + CraftOutput out = def->getOutput(input, gamedef); + ItemStack is; + is.deSerialize(out.item, gamedef->idef()); + if (!is.isKnown(gamedef->idef())) { + infostream << "trying to craft non-existent " + << out.item << ", ignoring recipe" << std::endl; + continue; + } + + output = out; + priority_best = priority; + def_best = def; } } - catch(SerializationError &e) - { - errorstream<<"getCraftResult: ERROR: " - <<"Serialization error in recipe " - <dump()<decrementInput(input, output_replacement, gamedef); + return true; + } + + virtual std::vector getCraftRecipes(CraftOutput &output, + IGameDef *gamedef, unsigned limit=0) const + { + std::vector recipes; + + auto vec_iter = m_output_craft_definitions.find(output.item); + + if (vec_iter == m_output_craft_definitions.end()) + return recipes; + + const std::vector &vec = vec_iter->second; + + recipes.reserve(limit ? MYMIN(limit, vec.size()) : vec.size()); + + for (std::vector::size_type i = vec.size(); + i > 0; i--) { + CraftDefinition *def = vec[i - 1]; + if (limit && recipes.size() >= limit) + break; + recipes.push_back(def); + } + + return recipes; + } + + virtual bool clearCraftsByOutput(const CraftOutput &output, IGameDef *gamedef) + { + auto to_clear = m_output_craft_definitions.find(output.item); + + if (to_clear == m_output_craft_definitions.end()) + return false; + + for (auto def : to_clear->second) { + // Recipes are not yet hashed at this point + std::vector &defs = m_craft_defs[(int)CRAFT_HASH_TYPE_UNHASHED][0]; + defs.erase(std::remove(defs.begin(), defs.end(), def), defs.end()); + delete def; + } + m_output_craft_definitions.erase(to_clear); + return true; + } + + virtual bool clearCraftsByInput(const CraftInput &input, IGameDef *gamedef) + { + if (input.empty()) + return false; + + // Recipes are not yet hashed at this point + std::vector &defs = m_craft_defs[(int)CRAFT_HASH_TYPE_UNHASHED][0]; + std::vector new_defs; + bool got_hit = false; + for (auto def : defs) { + if (!def->check(input, gamedef)) { + new_defs.push_back(def); + continue; } + got_hit = true; + std::string output = def->getOutput(input, gamedef).item; + delete def; + auto it = m_output_craft_definitions.find(craftGetItemName(output, gamedef)); + if (it == m_output_craft_definitions.end()) + continue; + std::vector &outdefs = it->second; + outdefs.erase(std::remove(outdefs.begin(), outdefs.end(), def), outdefs.end()); } - return NULL; + if (got_hit) + defs.swap(new_defs); + + return got_hit; } - virtual void registerCraft(const CraftDefinition &def) + + virtual std::string dump() const { - infostream<<"registerCraft: registering craft definition: " - < 3 || def.input.height() > 3){ - errorstream<<"registerCraft: input size is larger than 3x3," - <<" ignoring"<::size_type i = 0; + i < it->second.size(); i++) { + os << "type " << type + << " hash " << it->first + << " def " << it->second[i]->dump() + << "\n"; + } + } } - m_craft_definitions.push_back(new CraftDefinition(def)); + return os.str(); + } + virtual void registerCraft(CraftDefinition *def, IGameDef *gamedef) + { + TRACESTREAM(<< "registerCraft: registering craft definition: " + << def->dump() << std::endl); + m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0].push_back(def); + + CraftInput input; + std::string output_name = craftGetItemName( + def->getOutput(input, gamedef).item, gamedef); + m_output_craft_definitions[output_name].push_back(def); } virtual void clear() { - for(core::list::Iterator - i = m_craft_definitions.begin(); - i != m_craft_definitions.end(); i++){ - delete *i; + for (int type = 0; type <= craft_hash_type_max; ++type) { + for (auto &it : m_craft_defs[type]) { + for (auto &iit : it.second) { + delete iit; + } + it.second.clear(); + } + m_craft_defs[type].clear(); } - m_craft_definitions.clear(); + m_output_craft_definitions.clear(); } - virtual void serialize(std::ostream &os) - { - writeU8(os, 0); // version - u16 count = m_craft_definitions.size(); - writeU16(os, count); - for(core::list::Iterator - i = m_craft_definitions.begin(); - i != m_craft_definitions.end(); i++){ - CraftDefinition *def = *i; - // Serialize wrapped in a string - std::ostringstream tmp_os(std::ios::binary); - def->serialize(tmp_os); - os< &unhashed = + m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0]; + for (auto def : unhashed) { + // Initialize and get the definition's hash + def->initHash(gamedef); + CraftHashType type = def->getHashType(); + u64 hash = def->getHash(type); + + // Enter the definition + m_craft_defs[type][hash].push_back(def); } + unhashed.clear(); } private: - core::list m_craft_definitions; + std::vector > > + m_craft_defs; + std::unordered_map > + m_output_craft_definitions; }; IWritableCraftDefManager* createCraftDefManager() { return new CCraftDefManager(); } -