Trigger on_rightclick regardless on the formspec meta field

[dragonfireclient.git] / src / craftdef.cpp

diff --git a/src/craftdef.cpp b/src/craftdef.cpp
index d3f1edaf9ae9707455c04ecbad8387a1d53984e7..286d1eadaf8dc699ec4c492f23b09b284d1ea5f2 100644 (file)
--- a/src/craftdef.cpp
+++ b/src/craftdef.cpp
@@ -139,7 +139,7 @@ static std::vector<ItemStack> craftGetItems(
        for (std::vector<std::string>::size_type i = 0;
                        i < items.size(); i++) {
                result.push_back(ItemStack(std::string(items[i]), (u16)1,
-                       (u16)0, "", gamedef->getItemDefManager()));
+                       (u16)0, gamedef->getItemDefManager()));
        }
        return result;
 }
@@ -960,6 +960,96 @@ class CCraftDefManager: public IWritableCraftDefManager
 
                return recipes;
        }
+
+       virtual bool clearCraftRecipesByOutput(const CraftOutput &output, IGameDef *gamedef)
+       {
+               std::map<std::string, std::vector<CraftDefinition*> >::iterator vec_iter =
+                       m_output_craft_definitions.find(output.item);
+
+               if (vec_iter == m_output_craft_definitions.end())
+                       return false;
+
+               std::vector<CraftDefinition*> &vec = vec_iter->second;
+               for (std::vector<CraftDefinition*>::iterator i = vec.begin();
+                               i != vec.end(); ++i) {
+                       CraftDefinition *def = *i;
+                       // Recipes are not yet hashed at this point
+                       std::vector<CraftDefinition*> &unhashed_inputs_vec = m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0];
+                       std::vector<CraftDefinition*> 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 (std::vector<CraftDefinition*>::iterator i2 = unhashed_inputs_vec.begin();
+                                       i2 != unhashed_inputs_vec.end(); ++i2) {
+                               if (def != *i2) {
+                                       new_vec_by_input.push_back(*i2);
+                               }
+                       }
+                       m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0].swap(new_vec_by_input);
+               }
+               m_output_craft_definitions.erase(output.item);
+               return true;
+       }
+
+       virtual bool clearCraftRecipesByInput(CraftMethod craft_method, unsigned int craft_grid_width,
+               const std::vector<std::string> &recipe, IGameDef *gamedef)
+       {
+               bool all_empty = true;
+               for (std::vector<std::string>::size_type i = 0;
+                               i < recipe.size(); i++) {
+                       if (!recipe[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<CraftDefinition*> &unhashed_inputs_vec = m_craft_defs[(int) CRAFT_HASH_TYPE_UNHASHED][0];
+               std::vector<CraftDefinition*> new_vec_by_input;
+               bool got_hit = false;
+               for (std::vector<CraftDefinition*>::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;
+                       std::map<std::string, std::vector<CraftDefinition*> >::iterator
+                               vec_iter = m_output_craft_definitions.find(output.item);
+                       if (vec_iter == m_output_craft_definitions.end())
+                               continue;
+                       std::vector<CraftDefinition*> &vec = vec_iter->second;
+                       std::vector<CraftDefinition*> 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 (std::vector<CraftDefinition*>::iterator i = vec.begin();
+                                       i != vec.end(); ++i) {
+                               /* If pointers from map by input and output are not same,
+                                       we will add 'CraftDefinition*' to a new vector. */
+                               if (def != *i) {
+                                       /* Adding dereferenced iterator value (which are
+                                               'CraftDefinition' reference) to a new vector. */
+                                       new_vec_by_output.push_back(*i);
+                               }
+                       }
+                       // Swaps assigned to current key value with new vector for output map.
+                       m_output_craft_definitions[output.item].swap(new_vec_by_output);
+               }
+               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 std::string dump() const
        {
                std::ostringstream os(std::ios::binary);
@@ -1036,4 +1126,3 @@ IWritableCraftDefManager* createCraftDefManager()
 {
        return new CCraftDefManager();
 }
-