X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcraftdef.cpp;h=922ea345ee5b73c92560e42f110c9c65aa743954;hb=b4df0d67dd9fca20df632f0247b97f8370757a3c;hp=0cbb74ea07cae5e9f5ae2c718e496004a7d047b9;hpb=103173fc9b4fcb4c0fded2a93d5cbb8f0bea896e;p=minetest.git diff --git a/src/craftdef.cpp b/src/craftdef.cpp index 0cbb74ea0..922ea345e 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,218 +22,1086 @@ 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 "inventorymanager.h" // checkItemCombination +#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 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; + 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; + 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; + 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; + } } - items.push_back(item); + + // 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); } - return CraftPointerInput(ci.width, items); } -CraftInput createInput(const CraftPointerInput &cpi) +// 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) { - std::vector items; - for(u32 i=0; iserialize(oss); - items.push_back(oss.str()); + 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; + + } } + // No replacement was found, simply decrement count by one + if (!found_replacement && item.count > 0) + item.remove(1); } - return CraftInput(cpi.width, items); } +// Dump an itemstring matrix +static 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] << '"'; + } + 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 +*/ + std::string CraftInput::dump() const { std::ostringstream os(std::ios::binary); - os<<"(width="<\"" << (repl_p.second) << '"'; + sep = ","; + } + os << "}"; + return os.str(); +} + +/* + CraftDefinitionShaped +*/ + +std::string CraftDefinitionShaped::getName() const +{ + return "shaped"; +} + +bool CraftDefinitionShaped::check(const CraftInput &input, IGameDef *gamedef) const +{ + if (input.method != CRAFT_METHOD_NORMAL) + return false; + + // Get input item matrix + std::vector 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); +} + +CraftHashType CraftDefinitionShaped::getHashType() const +{ + assert(hash_inited); // Pre-condition + bool has_group = false; + for (const auto &recipe_name : recipe_names) { + if (isGroupRecipeStr(recipe_name)) { + has_group = true; + break; + } + } + if (has_group) + return CRAFT_HASH_TYPE_COUNT; + + return CRAFT_HASH_TYPE_ITEM_NAMES; +} + +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); +} + +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 +*/ + +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); +} + +CraftHashType CraftDefinitionShapeless::getHashType() const +{ + assert(hash_inited); // Pre-condition + bool has_group = false; + for (const auto &recipe_name : recipe_names) { + if (isGroupRecipeStr(recipe_name)) { + has_group = true; + break; + } + } + if (has_group) + return CRAFT_HASH_TYPE_COUNT; + + return CRAFT_HASH_TYPE_ITEM_NAMES; +} + +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()); +} + +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(); } -std::string CraftDefinition::dump() const +/* + CraftDefinitionToolRepair +*/ + +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 + || idef->get(item2.name).type != ITEM_TOOL) { + // 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<<"{output=\""< 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 { - writeU8(os, 0); // version - os< &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]; + output.item = ""; + output.time = 0; + + // If all input items are empty, abort. + bool all_empty = true; + for (const auto &item : input.items) { + if (!item.empty()) { + all_empty = false; + break; + } + } + if (all_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, and return if found. + 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; + + 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]; + + /*errorstream << "Checking " << input.dump() << std::endl + << " against " << def->dump() << std::endl;*/ + + if (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; + } + + // Get output, then decrement input (if requested) + output = out; + + if (decrementInput) + def->decrementInput(input, output_replacement, gamedef); + /*errorstream << "Check RETURNS TRUE" << std::endl;*/ + return true; } + } + } + return false; + } + + 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); - bool match = checkItemCombination(input_items, spec_items); + if (vec_iter == m_output_craft_definitions.end()) + return recipes; - if(match){ - std::istringstream iss(def->output, std::ios::binary); - return InventoryItem::deSerialize(iss, gamedef); + 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 clearCraftRecipesByOutput(const CraftOutput &output, IGameDef *gamedef) + { + auto vec_iter = m_output_craft_definitions.find(output.item); + + if (vec_iter == m_output_craft_definitions.end()) + return false; + + std::vector &vec = vec_iter->second; + for (auto def : vec) { + // Recipes are not yet hashed at this point + std::vector &unhashed_inputs_vec = m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0]; + std::vector new_vec_by_input; + /* We will preallocate necessary memory addresses, so we don't need to reallocate them later. + This would save us some performance. */ + new_vec_by_input.reserve(unhashed_inputs_vec.size()); + for (auto &i2 : unhashed_inputs_vec) { + if (def != i2) { + new_vec_by_input.push_back(i2); } } - catch(SerializationError &e) - { - errorstream<<"getCraftResult: ERROR: " - <<"Serialization error in recipe " - <dump()< &recipe, IGameDef *gamedef) + { + bool all_empty = true; + for (const auto &i : recipe) { + if (!i.empty()) { + all_empty = false; + break; + } + } + if (all_empty) + return false; + + CraftInput input(craft_method, craft_grid_width, craftGetItems(recipe, gamedef)); + // Recipes are not yet hashed at this point + std::vector &unhashed_inputs_vec = m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0]; + std::vector new_vec_by_input; + bool got_hit = false; + for (std::vector::size_type + i = unhashed_inputs_vec.size(); i > 0; i--) { + CraftDefinition *def = unhashed_inputs_vec[i - 1]; + /* If the input doesn't match the recipe definition, this recipe definition later + will be added back in source map. */ + if (!def->check(input, gamedef)) { + new_vec_by_input.push_back(def); + continue; } + CraftOutput output = def->getOutput(input, gamedef); + got_hit = true; + auto vec_iter = m_output_craft_definitions.find(output.item); + if (vec_iter == m_output_craft_definitions.end()) + continue; + std::vector &vec = vec_iter->second; + std::vector new_vec_by_output; + /* We will preallocate necessary memory addresses, so we don't need + to reallocate them later. This would save us some performance. */ + new_vec_by_output.reserve(vec.size()); + for (auto &vec_i : vec) { + /* If pointers from map by input and output are not same, + we will add 'CraftDefinition*' to a new vector. */ + if (def != vec_i) { + /* Adding dereferenced iterator value (which are + 'CraftDefinition' reference) to a new vector. */ + new_vec_by_output.push_back(vec_i); + } + } + // Swaps assigned to current key value with new vector for output map. + m_output_craft_definitions[output.item].swap(new_vec_by_output); } - return NULL; + if (got_hit) + // Swaps value with new vector for input map. + m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0].swap(new_vec_by_input); + + 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) + { + verbosestream << "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; + //TODO: change both maps to unordered_map when c++11 can be used + std::vector > > m_craft_defs; + std::map > m_output_craft_definitions; }; IWritableCraftDefManager* createCraftDefManager() { return new CCraftDefManager(); } -